redis的学习（二）

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

一、redis事务？

redis单条命令是原子性的，但是redis事务是不保证原子性的
redis事务的本质：一组命令的集合，一个事务中所有的命令都会被序列化，在事务执行的过程中，会按照顺序执行。一次性、顺序性、排他性。
redis事务没有隔离级别的概念
所有命令在事务中，并没有直接被执行，只有发起执行命令的时候才执行。exec（执行命令）

redis事务

开启事务（multi）
取消事务（discard）//取消事务
执行事务（exec）

编译型异常（代码有问题），事务中所有的命令都不会被执行
运行时异常,如果事务队列中存在问题，那么执行命令的时候，其他的命令会正常执行，错误的命令则抛出异常。

二、redis监控

悲观锁：无论做什么都加锁
乐观锁：不加锁，更新数据判断在此期间是否有人修改数据
redis监控

watch money(key)//监视key
unwatch//解除监控

用watch实现乐观锁
执行之前另一个线程修改了值就会导致失败
如果发现执行的事务执行失败，就需要先解锁，获取最新的值，再次监控，比对监视的值是否发生了变化，如果没有变化则执行成功，如果变了就执行失败，重复上面的操作直到成功为止（这个过程类似与自旋锁）

三、jedis操作redis

使用java操作redis,jredis是使用java操作redis的中间件

pom
       <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>4.2.2</version>
        </dependency>
测试
		Jedis jedis = new Jedis("127.0.0.1",6379);
        System.out.println(jedis.ping());
        jedis.close();

四、springboot 使用redis

springboot2.x以后原来使用jedis变为了lettuce
jedis采用直连，多个线程操作是不安全的，如果要避免不安全，需要使用jedis pool连接池，更像bio模式
lettuce:采用的是netty，实例可以在多个线程中进行共享，不存在线程不安全的情况，可以减少线程数据，更像nio模式

自己的RedisTemplate模板

@Configuration
public class RedisConfig {
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory)
    {
        RedisTemplate<String,Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        // json序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(mapper);
        // string序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //key采用string的序列化
        template.setKeySerializer(stringRedisSerializer);
        //hash采用string的序列化
        template.setHashKeySerializer(stringRedisSerializer);
        //value采用json的序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //hash的value采用json的序列化
        template.setHashKeySerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return  template;
    }
}

五、redis.conf详解

1.redis对大小写不敏感
# units are case insensitive so 1GB 1Gb 1gB are all the same.

包含

2.可以包含多个配置文件
# include /path/to/local.conf
# include /path/to/other.conf

网络

3.绑定ip
bind 127.0.0.1 -::1
4.保护模式
protected-mode yes
5.连接的端口
port 6379

通用

6.守护进程开启默认为no,需要改为yes之后可以后台运行
daemonize yes
7如果以后台方式运行需要指定一个pid文件
pidfile /var/run/redis_6379.pid
8日志的级别
# Specify the server verbosity level.
# This can be one of:
# debug (a lot of information, useful for development/testing))(测试和开发阶段)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably)(生成环境默认)
# warning (only very important / critical messages are logged)
loglevel notice
9.生成的日志文件名
logfile ""（默认为直接输出）
10.数据库数量
databases 16（默认为16个）
11.是否显示默认logo
always-show-logo no

快照（持久化）

持久化，在规定时间内执行了多少次操作，则会持久化到文件 .rdb .aof
redis是内存数据库,如果没有持久化,那么就会有数据丢失
1.save
#如果3600s内，如果至少有1个key进行了修改，我们就需要持久化
# save 3600 1
#如果300s内，如果至少有100个key进行了修改，我们就需要持久化
# save 300 100
#如果60s内，如果至少有10000个key进行了修改，我们就需要持久化
# save 60 10000
2.stop-writes-on-bgsave-error yes #如果持久化出错是否继续工作
3.rdbcompression yes #是否压缩rdb文件，需要消耗一些cpu资源
4.rdbchecksum yes #保存rdb文件的时候是否需要错误的检查校验
5.dir ./ #持久化生成的目录

REPLICATION (主从复制)

SECURITY(安全)

可以设置redis密码，默认是没有密码的
# requirepass foobared #配置文件设置密码
命令设置密码
config get requirepass #获取redis密码
config set requirepass 123456 #设置密码
auth 123456 #登录
设置密码之后没有登录显示的错误信息
(error) NOAUTH Authentication required.

CLIENTS(客户端)

# maxclients 10000 #可以连接redis的客户端的数量最大为10000

MEMORY MANAGEMENT（内存）

# maxmemory <bytes> #内存的最大容量
# maxmemory-policy noeviction  #内存达到最大容量后的处理策略

# volatile-lru -> Evict using approximated LRU, only keys with an expire set. #只对设置了过期时间的key进行lru
# allkeys-lru -> Evict any key using approximated LRU. #删除lru算法的key
# volatile-random -> Remove a random key having an expire set.#随机删除即将过期的key
# allkeys-random -> Remove a random key, any key. #随机删除key
# volatile-ttl -> Remove the key with the nearest expire time (minor TTL) #删除即将过期的key
# noeviction -> Don't evict anything, just return an error on write operations.#永不过期，返回错误

APPEND ONLY MOD(aof持久化的配置)

appendonly no #默认是不开启aof模式的，默认是使用rdb方式持久化的，大部分情况下rdb完全够用
appendfilename "appendonly.aof" #aof默认的文件名
# appendfsync always #每次修改都会执行sync,消耗性能
appendfsync everysec #每一秒执行一次sync，可能丢失1s数据
# appendfsync no #不执行sync,这个时候操作系统自己同步数据，速度是最快的

六、持久化

rdb

redis会单独创建（fork）一个子进程来进行持久化，会先将数据写入到一个临时文件中，等待持久化结束后，将这个文件替换上次持久化的文件，整个过程中，主进程不需要进行任何io操作，这就确保了极高的效率，如果要进行大规模的数据恢复，且对数据恢复的完整性不是特别的敏感，那么rdb的效率比aof高，rdb的缺点是最后一次持久化的数据可能丢失，redis默认就是rdb的持久化策略.
有时候在生成环境会将dump.rdb复制一份
rdb持久化的文件名是dump.rdb，可以在配置文件的快照中设置。

触发机制

1.save的规则满足的情况，会出发rdb规则
2.flushall命令，也会触发rdb规则
3.退出redis，也会触发rdb规则

恢复机制

1.只需要将rdb文件放在redis的启动目录下就可以了，redis启动的时候会自动检查dump.rdb恢复其中的数据

2.查看需要存在的位置

127.0.0.1:6379> config get dir
1) "dir"
2) "/usr/local/bin"#如果在这个目录下的dump.rdb文件，启动就会自动恢复其中的数据
rdb的特点

优点：
1.适合大规模数据恢复
2.对数据的完整性不高
缺点：
1.需要一定的时间间隔进行操作，如果redis意外宕机之后，这个最后一次修改的数据就没了
2.fork进程的时候，会占用一定的内存空间

aof

1.将所有的命令都记录下来，相当于字典
2.以日志的形式将redis执行过程中所有的指令记录下来（读的操作不记录），只允许追加文件但是不可以修改文件，redis启动之后就会读取该文件进行重构数据，换而言之redis重启的话就会根据日志的内容将写的指令从前到后执行一遍来完成数据的恢复工作。
3.aof保存的文件是appendonly.aof ，默认是不开启的，需要手动开启（appendonly yes）
4.如果appendonly.aof文件有错误，这个时候redis会启动不起来，我们需要修复这个文件,redis提供了一个修复的工具(redis-check-aof ),如果文件正常就重启就恢复成功

修复命令

[root@redis bin]# redis-check-aof  --fix  appendonly.aof

重写的规则

aof默认的是文件的无限追加，当文件大于64m,就会fork一个新的进程来进行文件的重写
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

aof的特点

优点：
1.每一次修改都会同步，文件的完整性更好
2.每秒同步一次，可能会丢失1秒的数据
3.从不同步效率高
缺点：
1.相对数据文件来说，aof远远大于rdb,修复的速度比rdb慢
2.aof的运行效率也比rdb慢（aof会进行io操作）,所以redis默认是rdb持久化