SpringBoot整合Redis之SpringDataRedis

秒速五厘米 2022-05-25 06:09 224阅读 0赞

添加依赖：

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

application.properties:

#redis配置
    spring.redis.database=0
    spring.redis.host=127.0.0.1
    spring.redis.port=6379
    
    spring.redis.password=123
    spring.redis.pool.max-idle=8
    spring.redis.pool.min-idle=0
    spring.redis.pool.max-active=8
    spring.redis.pool.max-wait=-1
    spring.redis.timeout=5000

配置类：

@Configuration
    /**开启SpringBoot支持的缓存功能 使用Nosql或者数据库的时候 当查询的时候会缓存数据*/
    @EnableCaching
    public class RedisConfig { 
    
    
        @Bean
        public CacheManager cacheManager(RedisTemplate<?,?> redisTemplate) {
            CacheManager cacheManager = new RedisCacheManager(redisTemplate);
            return cacheManager;
    
        }
    
    
    
    
        @Primary
        @Bean
        public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory factory) {
    
          /**spring data redis 提供多个序列化器 序列化转成json*/
           /* RedisTemplate template = new StringRedisTemplate(factory); Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class); ObjectMapper om = new ObjectMapper(); om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); jackson2JsonRedisSerializer.setObjectMapper(om); template.setValueSerializer(jackson2JsonRedisSerializer); template.afterPropertiesSet(); return template;*/
    
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate
                    <String, Object>();
            redisTemplate.setConnectionFactory(factory);
            return redisTemplate;
    
    
        }
    
    
        @Bean
        public StringRedisTemplate stringRedisTemplate(JedisConnectionFactory factory) {
            StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
            stringRedisTemplate.setConnectionFactory(factory);
            return stringRedisTemplate;
        }
    
    
    }

redis提供两种序列化方式：

一种是String的序列化策略（RedisTemplate）可以保存对象，一种是JDK的序列化策略（StringRedisTemplate）操作String数据。  
除此之外：spring data redis 提供多个序列化器

GenericToStringSerializer：使用 Spring 转换服务进行序列化；
    JacksonJsonRedisSerializer：使用 Jackson 1，将对象序列化为 JSON；
    Jackson2JsonRedisSerializer：使用 Jackson 2，将对象序列化为 JSON；
    JdkSerializationRedisSerializer：使用 Java 序列化；
    OxmSerializer：使用 Spring O/X 映射的编排器和解排器（marshaler 和 unmarshaler）实
    现序列化，用于 XML 序列化；
    StringRedisSerializer：序列化 String 类型的 key 和 value。

redis的五种数据结构：

ValueOperations：字符串类型操作
    ListOperations：列表类型操作
    SetOperations：集合类型操作
    ZSetOperations：有序集合类型操作
    HashOperations：散列操作

spring 封装了 RedisTemplate 对象来进行对redis的各种操作，它支持所有的 redis 原生的 api。
    
    RedisTemplate中定义了对5种数据结构操作
    
    
    
    1 redisTemplate.opsForValue();//操作字符串
    2 redisTemplate.opsForHash();//操作hash
    3 redisTemplate.opsForList();//操作list
    4 redisTemplate.opsForSet();//操作set
    5 redisTemplate.opsForZSet();//操作有序set

BoundValueOperations：字符串类型操作
    BoundListOperations：列表类型操作
    BoundSetOperations：集合类型操作
    BoundZSetOperations：有序集合类型操作
    BoundHashOperations：散列操作

BoundValueOperations<String, String> valueOperations = stringRedisTemplate.boundValueOps("key");
    BoundListOperations<String, String> listOperations = stringRedisTemplate.boundListOps("key");
    BoundSetOperations<String, String> setOperations = stringRedisTemplate.boundSetOps("key");
    BoundZSetOperations<String, String> zSetOperations = stringRedisTemplate.boundZSetOps("key");
    BoundHashOperations<String, Object, Object> hashOperations = stringRedisTemplate.boundHashOps("key");

redisTemplate有两个方法经常用到,一个是opsForXXX一个是boundXXXOps,XXX是value的类型,前者获取到一个Opercation,但是没有指定操作的key,可以在一个连接(事务)内操作多个key以及对应的value;后者会获取到一个指定了key的operation,在一个连接内只操作这个key对应的value.

Service:

@Service
    public class RedisService { 
        /** * StringRedisTemplate * 也可以是RedisTemplate template; * 只是两种序列化策略不同 * 一种是String的序列化策略，储存String类型数据 * 一种是JDK的序列化策略。可以存储对象类型数据 **/
    
        @Autowired
        StringRedisTemplate stringRedisTemplate;
    
        @Autowired
        RedisTemplate template;
    
    
        /** * 存储对象 */
    
        public void addUser(String key, User user) {
            template.opsForValue().set(key, user);
        }
    
    
        /** * 存储String数据 */
    
        public void addString(String key, String string) {
            stringRedisTemplate.opsForValue().set(key, string);
        }
    
    
        /** * 获取对象 */
    
        public User getUser(String key) {
            User user = (User) template.opsForValue().get(key);
            return user;
        }
    
        /** * 获取String */
    
        public String getString(String key) {
            String str = stringRedisTemplate.opsForValue().get(key);
            return str;
        }
    
        /** * 获取String */
    
        public String getString2(String key) {
    /**和前面的方法一样 只不过绑定了key*/
    
            BoundValueOperations<String, String> boundValueOperations = stringRedisTemplate.boundValueOps(key);
            String str = boundValueOperations.get();
            return str;
        }
    
    
        /** * 存储String设置过期时间 */
    
        public String addStringLimitTime(String key, String value) {
    /** 3秒过期*/
    
            stringRedisTemplate.opsForValue().set(key, value, 3, TimeUnit.SECONDS);
            return "ok";
        }
    
    
        /** * 删除redis存储所有的数据 */
    
    
        public void delete() {
            Set<String> set = stringRedisTemplate.keys("*");
            System.out.println(set.size());
            stringRedisTemplate.delete(set);
            System.out.println("删除成功");
    
        }
    
    
        /** * 删除redis存储所有的数据 */
    
    
        public void delete2() {
            Set<String> set = template.keys("*");
            System.out.println(set.size());
            template.delete(set);
            System.out.println("删除成功");
    
        }
    
    }

Controller测试：

@Controller
    public class RedisController { 
    
        @Autowired
        RedisService redisService;
    
        /** * 存储对象测试 */
        @RequestMapping("/addUser")
        @ResponseBody
        public String addUser() {
            User user = new User(1, "A", "123");
            redisService.addUser("userA", user);
            return "ok";
    
        }
    
    
        /** * 获取对象测试 */
        @RequestMapping("/getUser")
        @ResponseBody
        public User getUser() {
            User user = redisService.getUser("userA");
            return user;
    
    
        }
    
    
        /** * 存储String测试 */
        @RequestMapping("/addString")
        @ResponseBody
        public String addString() {
            redisService.addString("str1", "String1");
            return "ok";
    
        }
    
    
        /** * 获取String测试 */
        @RequestMapping("/getString")
        @ResponseBody
        public String getString() {
            String string = redisService.getString("str1");
            return string;
    
    
        }
    
        /** * 获取String测试 */
        @RequestMapping("/getString2")
        @ResponseBody
        public String getString2() {
            String string = redisService.getString2("str1");
            return string;
    
    
        }
    
        /** * 过期时间测试 */
        @RequestMapping("/addLimitTime")
        @ResponseBody
        public String addLimitTime() {
            String string = redisService.addStringLimitTime("time", "timeValue");
            return string;
    
    
        }
    
        /** * 过期时间测试 */
        @RequestMapping("/getLimitTime")
        @ResponseBody
        public String getLimitTime() {
            String string = redisService.getString("time");
            return string;
    
    
        }
    
    
    
    
    
        /**清除缓存*/
        @RequestMapping("/remove")
        @ResponseBody
        public String delete(){
             redisService.delete();
            return "ok";
    
    
        }
    
    
    
    }