SpringBoot2.x 集成redis

Spring boot 2.x 集成Redis 做缓存

maven依赖

 <dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

properties 配置文件配置

## Redis
spring.redis.host= 127.0.0.1
spring.redis.port= 6379
#连接超时时间
spring.redis.timeout= 60
#连接数据库
spring.redis.database= 0

RedisTemplate 序列化方式

主要是使用RedisTemplate,但是在使用RedisTemplate 的时候需要注意，redisTemplate 的key 和value默认的序列化方式是JdkSerializationRedisSerializer 的方式进行序列化的，在使用的时候会发现，在key 或者value 的前缀都会有下边这样的特殊符号；虽然不影响正常的使用，但是用可视化工具查看的时候，可视化很差；

\xac\xed\x00\x05t\x00\x0cTest

RedisTemplate 序列化方式优化

介于上述redisTemplate 优化方式的弊端，我们可以设置自定义的序列化方式覆盖默认的序列化方式。主要使用的是使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值；配置方式:

/**
 * author:zj
 * Date:2020/4/3
 * Time:16:06
 */
@Configuration
public class RedisConfig {



    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);

        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(mapper);

        redisTemplate.setValueSerializer(serializer);

        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

RedisTemplate 使用

在使用RedisTemplate 的时候，我们直接在需要缓存的类里面引入RedisTemplate；RedisRemplate 经常使用的是下列几个方法操作redis：

1. redisTemplate.opsForValue() 操作redis 对应的String 数据类型
2. redisTemplate.opsForSet() 操作redis 对应的Set 数据类型
3. redisTemplate.opsForZSet() 操作redis 对应的ZSet 数据类型
4. redisTemplate.opsForList() 操作redis中对应的List 数据类型

package com.corn.redis;

import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.assertj.core.util.Lists;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.*;
import org.springframework.util.ObjectUtils;

import javax.annotation.Resource;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@SpringBootTest
@Slf4j
class RedisApplicationTests {

	//为什么用@Resource 不用@Autowired ,主要是因为当我们
	@Resource
	private RedisTemplate redisTemplate;



	/**
	 *@描述 进行redis String 操作 可操作json,对象
	 *@参数
	 *@返回值
	 *@创建人  zj
	 *@创建时间  2020/4/3
	 */
	@Test
	void get() {
		redisTemplate.opsForList()
		Object hello = redisTemplate.opsForValue().get("hello");
		if(ObjectUtils.isEmpty(hello)){
			redisTemplate.opsForValue().set("hello","hello world");
			List<String> list = Lists.newArrayList();
			list.add("hello");
			redisTemplate.opsForValue().set("hello modle",list);
		}
		log.info("redis String类型获取缓存结果集:{}", JSONObject.toJSONString(hello));
	}

	/**
	 *@描述  进行设置redis tts
	 *@参数
	 *@返回值
	 *@创建人  zj
	 *@创建时间  2020/4/3
	 */
	@Test
	void getTTL(){
		redisTemplate.opsForValue().set("ttl", "hello ttl",1,TimeUnit.SECONDS);
		try {
			Thread.sleep(2000);
			Object ttl = redisTemplate.opsForValue().get("ttl");
			log.info("redis ttl获取结果集:{}",JSONObject.toJSONString(ttl));
		}catch (Exception e){
			e.printStackTrace();
		}
	}

	/**
	 *@描述  进行redis List 操作
	 * 方法: leftPush  左边存值 rightPush 右边存值 leftPop 左边消费 rightPop 右边消费
	 *@参数
	 *@返回值
	 *@创建人  zj
	 *@创建时间  2020/4/3
	 */
	@Test
	void list(){
		//左边push
		redisTemplate.opsForList().leftPush("leftpush","1");
		redisTemplate.opsForList().leftPush("leftpush","2");
		redisTemplate.opsForList().leftPush("leftpush","3");
		//左边获取结果
		Object leftPush = redisTemplate.opsForList().leftPop("leftPush");
		log.info("左边获取结果集:{}",JSONObject.toJSONString(leftPush));

		//右边push
		redisTemplate.opsForList().rightPush("rightpush","1");
		redisTemplate.opsForList().rightPush("rightpush","2");
		//右边获取结果集
		Object rightpush = redisTemplate.opsForList().rightPop("rightpush");
		log.info("右边获取结果集:{}",JSONObject.toJSONString(rightpush));

		//获取指定位置的结果集
		Object index = redisTemplate.opsForList().index("leftpush", 1);
		log.info("获取指定位置结果集 index :{}",JSONObject.toJSONString(index));

		//获取区间结果集 (0 ,-1) 获取所有的,(0,0)获取最新
		List range = redisTemplate.opsForList().range("leftpush", 0, -1);
		log.info("获取指定区间结果集:{}",JSONObject.toJSONString(range));


		//设置 list 过期时间
		redisTemplate.expire("leftpush", 10,TimeUnit.SECONDS);

	}

	/**
	 *@描述  set 无序集合
	 *@参数
	 *@返回值
	 *@创建人  zj
	 *@创建时间  2020/4/3
	 */
	@Test
	void set(){
		//set 添加值
		redisTemplate.opsForSet().add("set", "1", "2", "3", "4", "5");

		redisTemplate.opsForSet().add("setb","3","7","9");

		//获取变量中的值
		Set set = redisTemplate.opsForSet().members("set");
		log.info("set 获取变量中的值:{}",JSONObject.toJSONString(set));

		//获取变量中元素的个数
		Long set1 = redisTemplate.opsForSet().size("set");
		log.info("set 中元素的个数:{}",set1);

		//随机获取set 中的元素
		Object set2 = redisTemplate.opsForSet().randomMember("set");
		log.info("随机获取set 中的元素:{}",JSONObject.toJSONString(set2));

		//判断set 中是存在某元素 布尔类型
		Boolean set3 = redisTemplate.opsForSet().isMember("set", "1");
		log.info("set 中存在是否存在某元素:{}",set3);

		//弹出变量
		Object set4 = redisTemplate.opsForSet().pop("set");
		log.info(" pop 弹出set 的元素:{}",set4);

		//scan 暂时没搞使用方式，san 在redis 中主要用作扫描key 值
		Cursor set5 = redisTemplate.opsForSet().scan("set", ScanOptions.scanOptions().match("set").build());
		while (set5.hasNext()){
			Object next = set5.next();
			log.info(" scan 匹配到的结果集为:{}",JSONObject.toJSONString(next));

		}

		//获取变量之间的交集
		Set intersect = redisTemplate.opsForSet().intersect("set", "setb");
		intersect.forEach(l->{
			log.info("两个变量之间的交集是:{}",JSONObject.toJSONString(l));
		});

		//变量之间的并集
		Set union = redisTemplate.opsForSet().union("set", "setb");
		union.forEach(l->{
			log.info("变量并集结果为:{}",JSONObject.toJSONString(l));
		});


	}


	/**
	 *@描述  zset 有序集合 和set 存在公共的方法 ，eg: add 等
	 *@参数
	 *@返回值
	 *@创建人  zj
	 *@创建时间  2020/4/3
	 */
	@Test
	void zset(){
		//进行单个元素存储
		redisTemplate.opsForZSet().add("zset","a",1);
		redisTemplate.opsForZSet().add("zset","b",2);
		redisTemplate.opsForZSet().add("zset","c",3);

		//直接存储set
		ZSetOperations.TypedTuple<Object> typedTuple = new DefaultTypedTuple<>("a",3.0);
		ZSetOperations.TypedTuple<Object> typedTupleb = new DefaultTypedTuple<>("b",6.0);
		Set<ZSetOperations.TypedTuple> typedTuples = new HashSet<>();
		typedTuples.add(typedTuple);
		typedTuples.add(typedTupleb);

		redisTemplate.opsForZSet().add("zsetb",typedTuples);

		//根据分值区间获取结果集
		Set set1 = redisTemplate.opsForZSet().rangeByScore("zset", 1, 2);
		set1.forEach(l->{
			log.info("获取分值区间结果集:{}",JSONObject.toJSONString(l));
		});

		//获取区间分值的元素个数
		Long zset = redisTemplate.opsForZSet().count("zset", 1, 2);
		log.info("获取区间分值的个数:{}",zset);

		//获取元素的分值
		Double score = redisTemplate.opsForZSet().score("zset", "a");
		log.info("获取元素的分值:{}",score);

		//获取元素的个数
		Long zset1 = redisTemplate.opsForZSet().zCard("zset");
		log.info("获取元素的个数:{}",zset1);

		//修改分值
		redisTemplate.opsForZSet().incrementScore("zset", "a", 11);
		log.info("获取修改后的元素分值:{}",redisTemplate.opsForZSet().score("zset","a"));

		//倒叙排序指定分值区间的元素
		Set set2 = redisTemplate.opsForZSet().reverseRangeByScore("zset", 1, 20);
		set2.forEach(l->{
			log.info("获取排序后的结果集:{}",l);
		});
	}
}