Spring Boot 集成Redis使用教程

Spring Boot 集成Redis使用教程

1.去官网下载redis

·下载成功后解压在/usr/local/中
·进入redis-3.0.7文件夹中，用make进行编译
·编译成功后可以看到有对应的src、conf等文件夹，进入src文件夹，执行make install进行安装
·全部安装成功后，在/usr/local中新建redis文件夹，在redis文件夹中新建bin、ect、db文件夹
	mkdir /usr/local/redis/bin
	mkdir /usr/local/redis/etc
	mkdir /usr/local/redis/db
	注意：若无权限，请在命令前加sudo指令
·将redis-3.0.7文件夹中的redis.conf文件复制到/usr/local/redis/etc中
·将redis-3.0.7/src文件夹中的mkreleasdhdr.sh redis-benchmark redis-check-aof redis-check-dump redis-cli redis-server 复制到/usr/local/redis/bin中
·编辑redis.conf文件
	将下面内容粘贴进去：
	#修改为守护模式
	daemonize yes
	#设置进程锁文件
	pidfile /usr/local/redis/redis.pid
	#端口
	port 6379
	#客户端超时时间
	timeout 300
	#日志级别
	loglevel debug
	#日志文件位置
	logfile /usr/local/redis/log-redis.log
	#设置数据库的数量，默认数据库为0，可以使用SELECT <dbid>命令在连接上指定数据库id
	databases 16
	##指定在多长时间内，有多少次更新操作，就将数据同步到数据文件，可以多个条件配合
	#save <seconds> <changes>
	#Redis默认配置文件中提供了三个条件：
	save 900 1
	save 300 10
	save 60 10000
	#指定存储至本地数据库时是否压缩数据，默认为yes，Redis采用LZF压缩，如果为了节省CPU时间，
	#可以关闭该#选项，但会导致数据库文件变的巨大
	rdbcompression yes
	#指定本地数据库文件名
	dbfilename dump.rdb
	#指定本地数据库路径
	dir /usr/local/redis/db/
	#指定是否在每次更新操作后进行日志记录，Redis在默认情况下是异步的把数据写入磁盘，如果不开启，可能
	#会在断电时导致一段时间内的数据丢失。因为 redis本身同步数据文件是按上面save条件来同步的，所以有
	#的数据会在一段时间内只存在于内存中
	appendonly no
	#指定更新日志条件，共有3个可选值：
	#no：表示等操作系统进行数据缓存同步到磁盘（快）
	#always：表示每次更新操作后手动调用fsync()将数据写到磁盘（慢，安全）
	#everysec：表示每秒同步一次（折衷，默认值）
	appendfsync everysec
	#设置redis连接密码
	requirepass password
·此时登录密码为password
·redis后台启动
	在bin文件夹中执行命令：
		sudo ./redis-server ../etc/redis.conf开启redis服务
·关闭redis
	在bin文件夹中执行命令：
		sudo ./redis-cli -a password shutdown

2.依赖加载

在pom文件中添加如下依赖
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
	<exclusions>
		<exclusion>
			<artifactId>lettuce-core</artifactId>
			<groupId>io.lettuce</groupId>
		</exclusion>
	</exclusions>
</dependency>
<dependency>
	<groupId>org.apache.commons</groupId>
	<artifactId>commons-pool2</artifactId>
</dependency>
<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
</dependency>
注意：因为目前市场上基本不用lettuce客户端进行操作，将redis包中带的lettuce排除掉，添加jedis依赖，并添加配套使用的commons-pool2连接池。

3.配置文件

在application.yml或application.properties文件中添加redis配置
spring:
  redis:
  	#数据库名称
    database: 0
    #连接地址
    host: localhost
    #连接端口号
    port: 6379
    #连接密码
    password: 745210
    jedis:
      pool:
        min-idle: 5
        max-active: 10
        max-idle: 10
        max-wait: 2000
    #超时时间
    timeout: 1000
本文使用yml文件格式，看着结构更清晰些，也可以使用properties文件。

4.redisTemplate和stringRedisTemplate的区别

redisTemplate和stringRedisTemplate区别：
	·redisTemplate使用的是JdkSerializationRedisSerializer
	·stringRedisTemplate使用的是StringRedisSerializer
redisTemplate存入数据会将数据先序列化画成字节数组然后存入Redis数据库，打开redis查看的时候，看到的是不可读的形式。获取数据时也会降数据当做字符数组转化，然后返回。
注意：
	当要存的数据时字符串类型，直接使用stringRedisTemplate就可以。如果是复杂的对象类型，就使用redisTemplate。

5.操作数据

字符串：
	redisTemplate.opsForValue().set("int","1");//因为使用jdk序列化器，值不能运算
	stringRedisTemplate.opsForValue().set("key","value");//存入
	stringRedsiTemplate.opsForValue().get("key","value");//取出
	stringRedsiTemplate.opsForValue().increment("int",1);//加1操作
	Jedis jedis = (Jedis)stringRedisTemplate.getConnectionFactory().getConnection().getNativeConnection();
	jedis.decr("int");// 减1操作，redisTemplate不支持这个方法，只能使用jedis
散列数据结构：
	//存入一个map集合
	stringRedisTemplate.opsForHash().putAll("hash",new HashMap<String,Object>();
	//给redis中一个map集合添加字段
	stringRedisTemplate.opsForHash().put("hash","key","value");
	//绑定一个散列数据类型
	BoundHashOperations hashOps = stringRedisTemplate.boundHashOps("hash");
	//删除散列
	hashOps.delete("key1","key2"...);
	//新增
	hashOps.put("key1","value1");
链表：
	//从右往左插入一个链表,最后存储顺序为：v4,v3,v2,v1
	stringRedisTemplate.opsForList().leftPushAll("list1","v1","v2","v3","v4");
	//从左往右插入一个链表，最后存储顺序为：v1,v2,v3,v4
	strinGRedisTemplate.opsForList().rightPushAll("list2","v1","v2","v3","v4");
	//绑定链表进行操作
	BoundListOperations listOps = stringRedisTemplate.boundListOps("list2");
	//从右边弹出一个成员
	listOps.rightPop();
	//获取定位元素
	listOps.index(下标);
	//从左边插入链表
	listOps.leftPush("v0");
	//求链表长度
	Long size = listOps.size();
	//求链表下标区间成员，下标范围为0~size-1
	List elements = listOps.range(0,size-1);//获取链表全部元素
集合：
	//集合中不允许重复
	stringRedisTemplate.opsForSet().add("set1","v1","v2","v3","v4","v5");
	stringRedisTemplate.opsForSet().add("set2","v2","v4","v6","v8");
	//绑定集合操作
	BoundSetOperations setOps = stringRedisTemplate.boundSetOps("set1");
	//增加两个元素
	setOps.add("v6","v7");
	//删除两个元素
	setOps.remove("v1","v7");
	//返回所有元素
	Set set1 = setOps.members();
	//求成员数
	Long size = setOps.size();
	//求交集
	Set inter = setOps.intersect("set2");
	//求交集并保存
	setOps.intersectAndStore("set2","inter");
	//求差集
	Set diff = setOps.diff("set2");
	//求差集并用新集合diff保存
	setOps.diffAndStore("set2","diff");
	//求并集
	Set union = setOps.union("set2");
	//求并集，并用新集合union保存
	setOps.unionAndStore("set2","union");
有序集合：
	Set<ZSetOperations.TypedTuple<String>> typedTupleSet = new HashSet<>();
	for (int i = 1; i <= 9; i++){
		//分数
		double score = i*0.1;
		//创建一个TypedTuple对象，存入值和分数
		ZSetOperations.TypedTuple<String> typedTuple = new DefaultTypedTuple<String>("value"+i,score);
		typedTupleSet.add(typedTuple);
	}
	// 往有序集合插入元素
	stringRedisTemplate.opsForZSet().add("zSet1",typedTupleSet);
	// 绑定在zset1有序集合操作
	BoundZSetOperations<String, String> zSetOps = stringRedisTemplate.boundZSetOps("zSet1");
	// 增加一个元素
	zSetOps.add("value10",0.26);
	Set<String> setRange = zSetOps.range(1, 6);
	// 按分数排序获取有序集合
	Set<String> setScore = zSetOps.rangeByScore(0.2, 0.6);
	// 定义值范围
	RedisZSetCommands.Range range = new RedisZSetCommands.Range();
	range.gt("value3");//大于value3
	// range.gte("value3"); //大于等于value3
	// range.lt("value8"); //小于value8
	range.lte("value8");//小于等于value8
	Set<String> setLex = zSetOps.rangeByLex(range);
	// 删除元素
	zSetOps.remove("value9","value2");
	// 求分数
	Double score = zSetOps.score("value8");
	// 在下标取件下，按分数排序，同时返回value和score
	Set<ZSetOperations.TypedTuple<String>> rangeSet = zSetOps.rangeWithScores(1,6);
	// 在分数区间下，按分数排序，同时返回value和score
	Set<ZSetOperations.TypedTuple<String>> scoreSet = zSetOps.rangeByScoreWithScores(1,6);
	// 从小到大排序
	Set<String> reverseRange = zSetOps.reverseRange(2, 8);

6.redis缓存

·配置：
	spring:
		cache:
			cache-name: #如果由底层的缓存管理器支持创建，以逗号分隔的列表来缓存名称
			type: #缓存类型，在默认的情况下，Spring会自动根据上下文探测
			redis:
				cache-null-values: true #是否允许redis缓存空值
				key-prefix: #Redis的键前缀
				time-to-live: 0ms #缓存超时时间戳，配置为0则不设置超时时间
				use-key-prefix: true #是否启用Redis的键前缀
·启动类上加@EnableCaching的注解
·Spring缓存注解：
	添加：@CachePut(value="redisCache",key="'redis_user_'+#result.id")
	获取：@Cacheable(value="redisCache",key="'redis_user_'+#id")
	更新：@CachePut(value="redisCache",condition="#result != 'null'",key="'redis_user_'+#id")
	移除：@CacheEvict(value="redusCache",key="'redis_user_'+#id",beforeInvocation=false)

	@CachePut:表示将方法结果返回存放到缓存中。
	@Cacheable:表示先从缓存中通过定义的键查询，如果可以查询到数据，则返回，否则执行该方法，返回数据，并且将返回结果保存到缓存中。
	@CacheEvict:通过定义的键移除缓存，他有一个Boolean类型的配置项，beforeInvocation,表示在方法之前或者之后移除缓存。

·自定义缓存管理器：
	配置文件：
		spring:
			cache:
				redis:
					// 禁用前缀
					use-key-prefix: false
					// 允许保存空值
					cache-null-values: true
					// 自定义前缀
					key-prefix:
					// 定义超时时间
					time-to-live=600000
	@Configuration

	@Autowired
	private RedisConnectionFactory connectionFactory = null;
	//自定义Redis缓存管理器
	@Bean(name="redisCacheManager")
	public RedisCacheManager initRedisCacheManager(){
		//Redis加锁的写入器
		RedisCacheWriter writer = RedisCacheWriter.lockingRedisCacheWriter(connectionFactory);
		// 启动Redis缓存的默认设置
		RedisCacheConfiguration config = RedisCacheConfiguration,defaultCacheConfig();
		// 设置JDK序列化器
		config = config.serializeValuesWith(SerializationPair.fromSerializer(new JdkSerializationRedisSerializer()));
		// 禁用前缀
		config = config.disableKeyPrefix();
		// 设置10min超时
		config = config.entryTtl(Duration.ofMinutes(10));
		// 创建缓Redis存管理器
		RedisCacheManager redisCacheManager = new RedisCacheManager(writer,config);
		return redisCacheManager;
	}

本文纯属个人做笔记使用，能帮助到大家最好，有问题也请指正。