SpringBoot集成Redis缓存

青旅半醒 2022-10-24 11:55 245阅读 0赞

#### SpringBoot集成Redis缓存 ####

1、新建SpringBoot项目后，引入redis依赖

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

--------------------

2、编写yml配置文件

server:
      port: 8081
      
    spring:
      redis:
        host: 127.0.0.1
        port: 6379
        # password:
        timeout: 60s
    # lettuce:
    # pool:
    # # 连接池中的最小空闲连接
    # min-idle: 0
    # # 连接池中的最大空闲连接
    # max-idle: 8
    # # 连接池的最大数据库连接数
    # max-active: 8
    # # #连接池最大阻塞等待时间（使用负值表示没有限制）
    # max-wait: -1ms

--------------------

3、编写config配置类

package com.pipi.springbootredis.config;
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.jsontype.BasicPolymorphicTypeValidator;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    import java.net.UnknownHostException;
    
    @Configuration
    public class RedisConfig { 
    
        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException { 
            RedisTemplate<String, Object> template = new RedisTemplate();
            template.setConnectionFactory(redisConnectionFactory);
    
            // Json序列化配置
            Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
            ObjectMapper om = new ObjectMapper();
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            // om.enableDefaultTyping()从2.10过时，activateDefaultTyping代替
            // om.activateDefaultTyping(BasicPolymorphicTypeValidator.builder().build(), ObjectMapper.DefaultTyping.NON_FINAL);
            om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            jackson2JsonRedisSerializer.setObjectMapper(om);
    
            // String的序列化
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
            // key采用String的序列化方式
            template.setKeySerializer(stringRedisSerializer);
            // value采用Jackson序列化方式
            template.setValueSerializer(jackson2JsonRedisSerializer);
            // hash类型存值map中的key也采用String的序列化方式，map中的value采用Jackson
            template.setHashKeySerializer(stringRedisSerializer);
            template.setHashValueSerializer(jackson2JsonRedisSerializer);
            // 初始化redisTemplate
            template.afterPropertiesSet();
    
            return template;
        }
    
    }

--------------------

4、加个实体类，方便测试

package com.pipi.springbootredis.entity;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    import java.io.Serializable;
    
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class UserEntity implements Serializable { 
    
        private String name;
        private Integer age;
    
    }

--------------------

5、编写Redis工具类

开发中一般不会直接使用RedisTemplate模板，而是再次封装，写一些常用的方法。

例如：

package com.pipi.springbootredis.utils;
    
    import org.springframework.data.redis.core.*;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.Resource;
    import java.util.*;
    import java.util.concurrent.TimeUnit;
    
    /** * spring redis 工具类 * **/
    @SuppressWarnings(value = {  "unchecked", "rawtypes" })
    @Component
    public class RedisCache { 
    
        @Resource
        public RedisTemplate redisTemplate;
    
        /** * 给缓存的key设置过期时间 * * @param key 缓存的键值 * @param time 缓存的有效时间（秒） * @return 是否设置成功 */
        public boolean expire(String key, long time) { 
            try { 
                if (time > 0) { 
                    redisTemplate.expire(key, time, TimeUnit.SECONDS);
                }
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 获取指定key的缓存有效时间（秒） * * @param key 键值 * @return 有效时间（秒）, -1永久有效，-2已失效 */
        public long getExpire(String key) { 
            return redisTemplate.getExpire(key, TimeUnit.SECONDS);
        }
    
        /** * 判断指定key是否存在 * * @param key 缓存的键值 * @return 是否存在 */
        public boolean hasKey(String key) { 
            try { 
                return redisTemplate.hasKey(key);
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 缓存基本的对象，Integer、String、实体类等 * * @param key 缓存的键值 * @param value 缓存的值 * @return 缓存的对象 */
        public <T> ValueOperations<String, T> setCacheObject(String key, T value) { 
            ValueOperations<String, T> operation = redisTemplate.opsForValue();
            operation.set(key, value);
            return operation;
        }
    
        /** * 指定key的存值递增 * * @param key 键值 * @param i 递增的整数步长 * @return 递增执行后的值 */
        public long incr(String key, long i) { 
            if (i < 0) { 
                throw new RuntimeException("递增因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, i);
        }
    
        /** * 指定key的存值递增 * * @param key 键值 * @param d 递增的浮点数 * @return 递增执行后的值 */
        public double incr(String key, double d) { 
            if (d < 0) { 
                throw new RuntimeException("递增因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, d);
        }
    
        /** * 指定key的存值递减 * * @param key 键值 * @param i 递减的整数步长 * @return 递减执行后的值 */
        public long decr(String key, long i) { 
            if (i < 0) { 
                throw new RuntimeException("递减因子必须大于0");
            }
            return redisTemplate.opsForValue().decrement(key, i);
        }
    
        /** * 指定key的存值递减 * * @param key 键值 * @param d 递减的整数步长 * @return 递减执行后的值 */
        public double decr(String key, double d) { 
            if (d < 0) { 
                throw new RuntimeException("递减因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, -d);
        }
    
        /** * 缓存基本的对象，Integer、String、实体类等 * * @param key 缓存的键值 * @param value 缓存的值 * @param timeout 时间 * @param timeUnit 时间颗粒度 * @return 缓存的对象 */
        public <T> ValueOperations<String, T> setCacheObject(String key, T value, Integer timeout, TimeUnit timeUnit) { 
            ValueOperations<String, T> operation = redisTemplate.opsForValue();
            operation.set(key, value, timeout, timeUnit);
            return operation;
        }
    
        /** * 获得缓存的基本对象 * * @param key 缓存键值 * @return 缓存键值对应的数据 */
        public <T> T getCacheObject(String key) { 
            ValueOperations<String, T> operation = redisTemplate.opsForValue();
            return operation.get(key);
        }
    
        /** * 删除单个对象 * * @param key */
        public void deleteObject(String key) { 
            redisTemplate.delete(key);
        }
    
        /** * 删除集合对象 * * @param collection */
        public void deleteObject(Collection collection) { 
            redisTemplate.delete(collection);
        }
    
        /** * 缓存List数据 * * @param key 缓存的键值 * @param dataList 待缓存的List数据 * @return 缓存的对象 */
        public <T> ListOperations<String, T> setCacheList(String key, List<T> dataList) { 
            ListOperations listOperation = redisTemplate.opsForList();
            if (null != dataList) { 
                int size = dataList.size();
                for (int i = 0; i < size; i++) { 
                    listOperation.leftPush(key, dataList.get(i));
                }
            }
            return listOperation;
        }
    
        /** * 获得缓存的list对象 * * @param key 缓存的键值 * @return 缓存键值对应的数据 */
        public <T> List<T> getCacheList(String key) { 
            List<T> dataList = new ArrayList<T>();
            ListOperations<String, T> listOperation = redisTemplate.opsForList();
            Long size = listOperation.size(key);
    
            for (int i = 0; i < size; i++) { 
                dataList.add(listOperation.index(key, i));
            }
            return dataList;
        }
    
        /** * 缓存Set * * @param key 缓存键值 * @param dataSet 缓存的数据 * @return 缓存数据的对象 */
        public <T> BoundSetOperations<String, T> setCacheSet(String key, Set<T> dataSet) { 
            BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
            Iterator<T> it = dataSet.iterator();
            while (it.hasNext()) { 
                setOperation.add(it.next());
            }
            return setOperation;
        }
    
        /** * 获得缓存的set * * @param key * @return */
        public <T> Set<T> getCacheSet(String key) { 
            Set<T> dataSet = new HashSet<T>();
            BoundSetOperations<String, T> operation = redisTemplate.boundSetOps(key);
            dataSet = operation.members();
            return dataSet;
        }
    
        /** * 缓存Map * * @param key * @param dataMap * @return */
        public <T> HashOperations<String, String, T> setCacheMap(String key, Map<String, T> dataMap) { 
            HashOperations hashOperations = redisTemplate.opsForHash();
            if (null != dataMap) { 
                for (Map.Entry<String, T> entry : dataMap.entrySet()) { 
                    hashOperations.put(key, entry.getKey(), entry.getValue());
                }
            }
            return hashOperations;
        }
    
        /** * 获得缓存的Map * * @param key * @return */
        public <T> Map<String, T> getCacheMap(String key) { 
            Map<String, T> map = redisTemplate.opsForHash().entries(key);
            return map;
        }
    
        /** * 获得缓存的基本对象列表 * * @param pattern 字符串前缀 * @return 对象列表 */
        public Collection<String> keys(String pattern) { 
            return redisTemplate.keys(pattern);
        }
    
    }

--------------------

6、编写测试

package com.pipi.springbootredis;
    
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.pipi.springbootredis.entity.UserEntity;
    import com.pipi.springbootredis.utils.RedisCache;
    import org.junit.jupiter.api.Test;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.data.redis.core.RedisTemplate;
    
    import javax.annotation.Resource;
    import java.util.Date;
    
    @SpringBootTest
    class SpringbootRedisApplicationTests { 
    
        @Resource
        // 这是jar包里的模板
        private RedisTemplate redisTemplate;
    
        @Resource
        // 这是自己封装好的工具类
        private RedisCache redisCache;
    
        @Test
        void contextLoads() { 
            redisTemplate.opsForValue().set("name", "guanzz");
            Object name = redisTemplate.opsForValue().get("name");
            System.out.println(name);
        }
    
        @Test
        void test01() throws JsonProcessingException { 
            UserEntity user = new UserEntity("皮皮真", 18);
            // 真实开发中一般使用json来传递对象
            String jsonUser = new ObjectMapper().writeValueAsString(user);
            redisTemplate.opsForValue().set("user", user);
            Object getUser = redisTemplate.opsForValue().get("user");
            System.out.println(getUser);
        }
    
        @Test
        void test02() throws InterruptedException { 
            redisCache.setCacheObject("name", "皮皮真");
            redisCache.expire("name", 1);
            Thread.sleep(2000);  // 睡2秒
            long time = redisCache.getExpire("name");
            System.out.println(time);
        }
    
        @Test
        void test03() { 
            boolean b1 = redisCache.hasKey("name");
            boolean b2 = redisCache.hasKey("age");
            System.out.println(b1 + ", " + b2);
        }
    
    }

--------------------