SpringBoot+Redis实现数据缓存

旧城等待， 2022-10-02 12:47 290阅读 0赞

## 常见的缓存工具有Redis和Memcache ##

*  Redis和Memcache都是内存数据库，但是memcached除了可以缓存纯数据之外，还可用于缓存其他东西，例如图片、视频等等；
 *  Redis支持5种数据类型，而memcached只支持键值对数据
 *  Redis支持将数据支持化到硬盘中，而memcached一旦宕机将丢失数据
 *  Redis是单线程的，而Memcached是多线程的，相对而言Redis更适合分布式搭建
 *  Redis支持数据备份
 *  Memcached对于内存管理更高效，但是Redis内存管理更便捷

## redis缓存功能（项目中要有RedisTemplate的Bean） ##

SpringBoot结合redis 实现sql 查询结果缓存  
前提：配置并连接了redis数据库 实体类实现了Serializable接口  
第一步：在启动类Application 上添加@EnableCaching 开启缓存  
第二步：在业务逻辑层service层中的事务方法 上添加 @Cacheable(value=“value”,key =" ‘key’ “) 注意key值要双引号，也要有单引号  
第三步：为了保证缓存与数据一致性 进行删除操作时 也要清除缓存  
同样在service层 方法上使用@CacheEvict(value=“value”,key =” ‘key’ ")

@Cacheable(value={"users"}, key="#user.id", condition="#user.id%2==0")

*  value属性是必须指定的，其表示当前方法的返回值是会被缓存在哪个Cache上的，对应Cache的名称。其可以是一个Cache也可以是多个Cache，当需要指定多个Cache时其是一个数组。
 *  key属性是用来指定Spring缓存方法的返回结果时对应的key的。
 *  通过condition属性对满足筛选条件的结果进行缓存。

**主要依赖**

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-redis</artifactId>
                <version>1.4.4.RELEASE</version>
            </dependency>

## **Redis配置** ##

**配置文件**

#多redis连接配置
    spring.redis.shard.hostname =127.0.0.1
    #spring.redis.shard.password =123456
    spring.redis.shard.port = 6379
    
    spring.redis.pool.maxIdle = 20
    spring.redis.pool.maxTotal = 500
    spring.redis.pool.numTestsPerEvictionRun = 3
    spring.redis.pool.testOnBorrow = true
    spring.redis.pool.blockWhenExhausted = false
    spring.redis.pool.testOnReturn = false

**加载配置类**

@Component
    @PropertySource(value = {"classpath:redis.properties"} ,encoding="UTF-8")
    public class JedisConfig implements Serializable {
    
        private static final long serialVersionUID = 1L;
    
        @Value("${spring.redis.shard.hostname}")
        private String hostname;
        @Value("#{${spring.redis.shard.port}}")
        private int port;
        //@Value("${spring.redis.shard.password}")
        //private String password;
        @Value("#{${spring.redis.pool.maxIdle}}")
        private Integer maxTotal;
        @Value("#{${spring.redis.pool.maxTotal}}")
        private Integer maxIdle;
    
        private boolean testOnBorrow;
        private boolean testOnReturn;
    
        public String getHostname() {
            return hostname;
        }
    
        public void setHostname(String hostname) {
            this.hostname = hostname;
        }
    
        public int getPort() {
            return port;
        }
    
        public void setPort(int port) {
            this.port = port;
        }
    
    
        public Integer getMaxTotal() {
            return maxTotal;
        }
    
        public void setMaxTotal(Integer maxTotal) {
            this.maxTotal = maxTotal;
        }
    
        public Integer getMaxIdle() {
            return maxIdle;
        }
    
        public void setMaxIdle(Integer maxIdle) {
            this.maxIdle = maxIdle;
        }
    
        public boolean isTestOnBorrow() {
            return testOnBorrow;
        }
    
        public void setTestOnBorrow(boolean testOnBorrow) {
            this.testOnBorrow = testOnBorrow;
        }
    
        public boolean isTestOnReturn() {
            return testOnReturn;
        }
    
        public void setTestOnReturn(boolean testOnReturn) {
            this.testOnReturn = testOnReturn;
        }
    
       
        
    }

**Jedis配置类**

@Configuration
    public class JedisConfiguration {
        @Autowired
        JedisConfig redisConfig;
        public JedisConnectionFactory convertJedisConnectionFactory() {
    
            System.out.println(redisConfig);
            JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
            jedisConnectionFactory.setHostName(redisConfig.getHostname());
            jedisConnectionFactory.setPort(redisConfig.getPort());
            // jedisConnectionFactory.setPassword(redisConfig.getPassword());
    
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            jedisPoolConfig.setMaxTotal(redisConfig.getMaxTotal());
            jedisPoolConfig.setMaxIdle(redisConfig.getMaxIdle());
            jedisPoolConfig.setMinIdle(20);
            jedisPoolConfig.setMaxWaitMillis(30000);
            jedisPoolConfig.setTestOnBorrow(redisConfig.isTestOnBorrow());
            jedisPoolConfig.setTestOnReturn(redisConfig.isTestOnReturn());
            // jedisPoolConfig.setTestWhileIdle();
    
            jedisConnectionFactory.setPoolConfig(jedisPoolConfig);
            jedisConnectionFactory.afterPropertiesSet();
            return jedisConnectionFactory;
        }
    
    
        @Bean
        @ConditionalOnMissingBean
        public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
            StringRedisTemplate template = new StringRedisTemplate();
            template.setConnectionFactory(redisConnectionFactory);
            return template;
    
        }
    
    
        @Bean(value = "template")
        @ConditionalOnMissingBean(name = "redisTemplate")
        public RedisTemplate<String,Object> RedisTemplate()
        {
            RedisTemplate<String,Object> template =new RedisTemplate<>();
            template.setConnectionFactory(convertJedisConnectionFactory());
    
            Jackson2JsonRedisSerializer jsonRedisSerializer=new Jackson2JsonRedisSerializer(Object.class);
            ObjectMapper om=new ObjectMapper();
            //指定序列化的域
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            //指定序列化输入的类型(排除final类型)
            om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            jsonRedisSerializer.setObjectMapper(om);
    
            //主体选择序列化方式 JSON
            template.setDefaultSerializer(jsonRedisSerializer);
    
            //Map部分
            //序列化和反序列化redis的key值
            template.setKeySerializer(new StringRedisSerializer());
            //设置hash key和value的序列化模式
            template.setHashKeySerializer( new StringRedisSerializer());
            template.setHashValueSerializer(jsonRedisSerializer);
    
            //表示设定结束
            template.afterPropertiesSet();
            return template;
        }
    }

测试结果：第一访问会进过服务层，第二次访问不会进过服务层，直接从缓存中获取结果。  
![在这里插入图片描述][20190618210910775.png]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk5MDgxOA_size_16_color_FFFFFF_t_70_pic_center]

[20190618210910775.png]: /images/20220112/f4531c4b22ba4f07b63c28ad7d8a73c1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk5MDgxOA_size_16_color_FFFFFF_t_70_pic_center]: /images/20220112/566b764f2c2f4d7398186339579e20d3.png