springboot+Redis缓存讲解+案例+原理+整合(简单详细！)_springboot cache redis

    Spring从3.1开始定义了org.springframework.cache.Cache和org.springframework.cache.CacheManager接口来统一不同的缓存技术；并支持使用JCache（JSR-107）注解简化我们开发；

 

    1、 Cache接口为缓存的组件规范定义，包含缓存的各种操作集合；

 

    2、 Cache接口下Spring提供了各种xxxCache的实现,如RedisCache,EhCacheCache , ConcurrentMapCache等；每次调用需要缓存功能的方法时，Spring会检查检查指定参数的指定的目标方法是否已经被调用过；如果有就直接从缓存中获取方法调用后的结果，如果没有就调用方法并缓存结果返回给用户。下次直接从缓存中获取。

 

    3、 使用Spring缓存抽象时我们需要关注以下两点；

            第一点：确定方法需要被缓存以及他们的缓存策略 

            第二点：从缓存中读取之前缓存存储的数据

        默认是没有缓存的，所以每次进行CRUD操作都会直接去查询数据库。 

            * 开启日志帮助理解(可省)：

                logging.level.包名: debug。  

                # 没有缓存只要执行查询就会执行sql语句，然后显示到控制台，如果有了缓存就不会查询数据库，所以就不再显示到控制台

                     

 

            * 添加@Cacheable注解到要缓存方法上：下面的是该注解的属性：

            cacheNames/value：缓存组件的名字，该组件内可以包含多个缓存(就是将一个缓存分到哪组里面，这个组是缓存的父亲)，

                 该缓存可以通过该属性放在多个父亲里面，这个属性是一个数组形式。

 

            key: 指定缓存的名字，默认使用的是方法参数的值，key可以使用SpEl表达式。

                 如：

                     将该方法的第一个参数当做key： key="#id" 或 key="#root.args[0]"

                     将key设置为缓存父亲的名字： key="#root.caches[0].name" 就能获取cacheNames或value中的第一个名字

                     将key设置为方法名拼接参数id： 如：getDept[1]：  key = "#root.methodName+'['+#id+']'"

                     将key设置为参数，第一个例子使用的#id就是这个。   #id = #a0 = #p0 = root.args[0]

                 

 

 

            keyGenerator： key的生成器，可以自己指定key的生成器(自己写一个keyGenerator放在IOC)。该属性的值为自定义的Bean的id

                    该属性和key属性二选一使用。

                      

 

 

            cacheManager： 设置缓存管理器。

                    如： 在EhCache的缓存服务器(类似于Redis)中的project(父亲)中有loginCache缓存，

                         在Redis缓存服务器里面也有该缓存，那么就可以使用cacheManager指定使用哪个缓存服务器里面的缓存。

 

            cacheResolver： 缓存解析器。

                    该属性和cacheManager二选一使用。

 

            condition： 满足一定条件才进行缓存，当条件为true才缓存

                    如： condition = "#id>0"   //当取到的参数的id>0的时候才进行缓存。或者： #a0>0，可以写复合条件

 

            unless： 满足条件就不缓存，当条件为true不缓存！和condition相反。  注意： 既满足condition又满足unless的数据不缓存

                        unless可以获取方法结果进行判断，在key属性的参数里面有个#result就是获取方法返回值的和unless组合使用。

                    如： unless = "#result == null"  //返回结果为空就不缓存。

                         unless = "#a0 == 2"  //如果第一个参数为0就不缓存

 

            sync： 缓存是否使用异步模式进行缓存。默认为false使用的是同步模式，如果改为异步(sync=true)就不支持unless属性

     //主类：  @EnableCaching
            @SpringBootApplication
            @EnableCaching      //开启缓存
            public class Springboot11CacheApplication {

     //Service层： @Cacheable
            @Cacheable(value = "dept",key = "#id")  //开启方法缓存
            public Department queryById(Integer id) {
                return this.departmentMapper.queryById(id);
            }

@EnableConfigurationProperties({CacheProperties.class})
@AutoConfigureAfter({CouchbaseDataAutoConfiguration.class, HazelcastAutoConfiguration.class, HibernateJpaAutoConfiguration.class, RedisAutoConfiguration.class})
@Import({CacheAutoConfiguration.CacheConfigurationImportSelector.class,CacheAutoConfiguration.CacheManagerEntityManagerFactoryDependsOnPostProcessor.class})
public class CacheAutoConfiguration {

 
 
static class CacheConfigurationImportSelector implements ImportSelector {
    CacheConfigurationImportSelector() {    //无参构造器
    }
 
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {   //主要就是这个方法，会自动导入组件
        CacheType[] types = CacheType.values();
        String[] imports = new String[types.length];
 
        for(int i = 0; i < types.length; ++i) {
            imports[i] = CacheConfigurations.getConfigurationClass(types[i]);  //这个imports就是接收所有的组件的一个参数
        }
 
        return imports;            //所以直接在这里打断点会直接获取到所有的组件
    }
}

                     

    SimpleCacheConfiguration matched:    //只有这一个生效！

    CaffeineCacheConfiguration: 

       Did not match:

    CouchbaseCacheConfiguration: 

       Did not match:

    EhCacheCacheConfiguration:

       Did not match:

    GenericCacheConfiguration:

       Did not match:

    HazelcastCacheConfiguration:

       Did not match:

    InfinispanCacheConfiguration:

       Did not match:

    JCacheCacheConfiguration:

       Did not match:

    NoOpCacheConfiguration:

       Did not match:

    RedisCacheConfiguration:

       Did not match:

                

                

public Cache getCache(String name) {   //这个参数name就会传进来使用@Cacheable的value或cacheNames属性指定的值。
    Cache cache = (Cache)this.cacheMap.get(name);    
    if (cache == null && this.dynamic) {
        synchronized(this.cacheMap) {    //双重检查
            cache = (Cache)this.cacheMap.get(name);
            if (cache == null) {    // 如果在CacheMap中(就是一个map)获取不到name的值，就新建一个缓存放到map里面（就是新建了一个Entry）
                cache = this.createConcurrentMapCache(name);   //但是，这是如何新建的缓存呢？
                this.cacheMap.put(name, cache);
            }
        }
    }

protected Cache createConcurrentMapCache(String name) {
   SerializationDelegate actualSerialization = (isStoreByValue() ? this.serialization : null);
   return new ConcurrentMapCache(name, new ConcurrentHashMap<>(256), isAllowNullValues(), actualSerialization);  //直接返回ConcurrentMapCache
}

                

protected Object lookup(Object key) {  //先去查询ConcurrentMapCache的map中是否有这个key的缓存，没有就会执行put方法
   return this.store.get(key);   //this是ConcurrentMapCache； store是ConcurrentMap类型的：缓存数据都是放在Map里面的。ConcurrentMap<Object, Object> store;
}

总结：

    @Cachable标注的方法在执行之前先检查(lookup)缓存中是否有这个数据，默认按照参数的值为key去查找缓存，如果没有就将结果放入缓存(put)。以后再调用就会直接从缓存中获取。

    key的生成策略：默认使用的是keyGenerator生成的，默认使用的是SimpleKeyGenerator生成key。

@CachePut(value = "dept",key = "#result.id")  // 操作的表示department，所以可以写 #department.id
public Department update(Department department) {
    this.departmentDao.update(department);
    return this.queryById(department.getId());
}

通过Java操作Redis：

• 1、导入jar包：(Web和Spring Data Redis)

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

 

    说明： 由于更新到springboot2.x之后，就已经不再使用Jedis操作Redis，而是改版为Lettuce

 

为什么改版？

    Jedis：采用的是直连，就是直接去连接数据库，如果有多个线程操作的话就是不安全的，想要避免不安全，就需要使用Jedis pool连接池。

    Lettuce：底层采用的Netty，异步请求，实例可以在多个线程中共享，所以不存在线程不安全的情况，可以减少线程数量，就不需要再开连接池

 

• 在springboot-autoconfigure/META-INF/spring.factories 中查找redis自动配置了AutoConfiguration源码：

@Bean
@ConditionalOnMissingBean(name = {"redisTemplate"}) //我们可以自己定义一个替换默认的，这就能够让springboot操作redis不再乱码！！
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
    //默认使用的 RedisTemplate 没有过多的配置，Redis中的对象保存都是需要序列化的，而这里没有序列化等操作
    //而且 RedisTemplate 的量个泛型都是Object Object类型，所以我们使用的时候要强制转换，因为，Redis使用的都是 String Object
    RedisTemplate<Object, Object> template = new RedisTemplate();  //RedisTemplate 是写项目时整合需要使用到的bean。
    template.setConnectionFactory(redisConnectionFactory);
    return template;
}
 
@Bean
@ConditionalOnMissingBean
//因为String类型是Redis中最常用的类型，所以单独提取出来了
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
    StringRedisTemplate template = new StringRedisTemplate();
    template.setConnectionFactory(redisConnectionFactory);
    return template;
}

 

• 2、配置连接：

    #如果只配置url和port，那么可以不配置，因为这两个属性都是默认的localhost和6379

 

#配置Redis连接,他的属性去RedisAutoConfiguration中查看

spring:

    redis:   

        url: 127.0.0.1 # 默认就是localhost，后面使用的都是 Lettuce ，因为默认springboot2.x的Jedis的源码不生效(源码的jar包导入不全)

        port: 6379  #默认是6379。配置的是 spring.redis.lettuce.xxx，不是spring.redis.jedis.xxx

                         

 

• 3、测试连接： RedisTemplate！

package com.springboot.redis02springboot;
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.connection.RedisConnection;
import org.springframework.data.redis.core.RedisTemplate;
 
@SpringBootTest
class Redis02SpringbootApplicationTests {
 
    //注入RedisAutoConfiguration中的Bean --- RedisTemplate
    @Autowired
    private RedisTemplate redisTemplate;
            // RedisTemplate 的方法和 Redis 的常用的指令操作是一样的，事务和基本的CRUD等都是使用RedisTemplate
 
            // opsForValue     => String
            // opsForList      => list 如： redisTemplate.opsForList().leftPush("name","zs"); 集合左边添加数据
            // opsForSet       => Set
            // opsForHash      => Hash
            // opsForzset      => zset
            // opsForGeo       => Geospatial
            // keys            => 正则匹配，查询key
            // multi           => 开启事务
            // discard         => 事务的删除操作
            // exec            => 执行事务
            // 常用的操作。事务、CRUD等都是RedisTemplate
 
 
            // 获取 Redis 连接对象，一般很少用。有flushdb、flushall等操作，也可以操作Redis。
            // RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
            // connection.flushAll();
            // connection.flushDb();
 
    @Test
    void contextLoads() {
 
        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        //因为是创建的共享连接(我理解为池redis pool)，所以不能使用select选择数据库。
        connection.flushDb();
        connection.close();
 
        redisTemplate.opsForValue().set("name","zs"); //java操作redis存数据会乱码，但是idea控制台正常显示，后面讲如何修改。
        System.out.println(redisTemplate.opsForValue().get("name"));
    }
 
}

 

• 为啥redis会乱码？

    原因就在RedisTemplate类里面，很明显的4个序列化属性配置，而且返回类型都是RedisSerializer，继续往下看发现RedisTemplate默认的是JDK序列化，他会让字符串转义。

      

• 如何让SpringBoot操作Redis不会乱码？ 也就是替换默认的JDK序列化方式。 如果不想替换可以直接使用StringRedisTemplate！！！

    在RedisAutoConfiguration类里面有两个方法，一个就是RedisTemplate()方法，这个类使用的是@ConditionalOnMissingBean修饰的，所以就能自定义自己的Bean来覆盖默认的Bean，而且上面默认使用的是JDK序列化的也是RedisTemplate类。因此自定义 redisTemplate()！！

 

    先看下面的两个例子，Redis后台使用keys * 输出的都是乱码

    

    1.  开发就是传递的都是json字符串到Redis中(set的是一个JSON字符串)，不是实体对象！！  例外：当传递一个session会传递对象

@Test
public void test1() throws JsonProcessingException {
 
    User u = new User("zs",23);
 
    ObjectMapper objectMapper = new ObjectMapper();  //使用的是jackson转换json对象
    String user = objectMapper.writeValueAsString(u);
 
    //实际开发中用json传递对象，而不是 redisTemplate.opsForValue().set("user",new User("",""));
    redisTemplate.opsForValue().set("user",user);
 
    System.out.println(redisTemplate.opsForValue().get("user"));
}   

这样执行成功，

    然而在控制台打印的数据是：    {"name":"zs","age":23}

    查询redis使用key *查看到的是：  "\xac\xed\x00\x05t\x00\x04user"   //因为使用的是JDK序列化会自动转义字符串

 

    2.  如果要想set一个实体对象到Redis中，必须要先给实体类序列化(实现 Serixx接口)

    因为默认使用的是JDK序列化,所以会报 SerializationException：Failed to serialize object using DefaultSerializer异常

//实体类：

 

 

@Data 
@AllArgsConstructor 
@NoArgsConstructor 
public class User implements Serializable {
    ...
}

 

向Redis中插入对象：

 

 

//序列化pojo后，重新set一个实体类对象
@Test
public void test2() throws JsonProcessingException {
 
    User user = new User("zs",23);
 
    //实际开发中传递的都是json，而不是 redisTemplate.opsForValue().set("user",new User("","")); 黄色部分
    redisTemplate.opsForValue().set("user1",user);   
 
    System.out.println(redisTemplate.opsForValue().get("user1")); 
}

    控制台打印的是：  User{name='zs', age=23}

    使用keys *查看到的是："\xac\xed\x00\x05t\x00\x05user1"

    

    总结：上面的两个例子，一般开发中需要将对象存到Redis中，就需要将对象转换为Json字符串(Jackson、fastjson)，然后set进去。如果特殊情况需要传递对象到Redis中，如需要传递session到对象里面，就必须将pojo类序列化(实例化Serixxx接口)。

 

   分析：两种方式在Redis中存入的key都是乱码形式的对象("\xac\xed\x00\x05t\x00\x05user1")，原因就是默认使用的JDK序列化方式，所以现在就需要配置自己的序列化方式(RedisAutoConfiguration中的RedisTemplate没有做一些额外的配置，只是创建了一个自己的对象；然后点进去RedisTemplate类里面，发现默认使用的是JDK序列化方式，因为RedisAutoConfiguration里面的RedisTemplate()方法使用了@ConditionalOnMissingBea修饰，所以用户可以自己定义Bean覆盖默认的RedisTemplate，然后就会替换默认JDK序列化方式。)

    

• 使用StringRedisTemplate： 如果只存储String类型数据，好处是不用重写JDK，复杂类型还是推荐RedisTemplate

@Autowired
StringRedisTemplate stringRedisTemplate;
 
//StringRedisTemplate
@Test
public void test3() throws JsonProcessingException {
 
    User u = new User("zs",23);
 
    stringRedisTemplate.opsForValue().set("user4",String.valueOf(u));
 
    System.out.println(stringRedisTemplate.opsForValue().get("user4"));
}

• 到底如何才能替换默认的JDK序列化？ 替换之后就没有序列化的问题了！

别着急，先分析一波：

 

    因为@ConditionalOnMissingBean的缘故，要替换默认的RedisTemplate方法就必须和RedisAutoConfiguration里面的RedisTemplate方法名相同，这里建议将方法直接复制到自定义的类里面(我们现在写的是一个Bean，忘了什么？ 配置类@Configuration注解)

    然后点进去RedisTemplate类里面，看到的就是上面 "为什么Redis会乱码?" 图片里面的信息，映入眼帘的就是四个属性，返回值都是RedisSerializer类型，继续点进去。看下图：

            

 

    看到了啥？ 这些罗列出来的都是RedisSerializer接口的实现类，默认使用的就是JdkSerxxx序列(就是上面蓝色条选中的那个)。有Stringxxx的用来序列字符串的，Jacksonxxx用来序列Jackson，使用Jackson就使用这个。

    因此，如果需要使用什么序列化方式，就使用哪种序列，一般就是传递的key是String，value就是json类型。下面的模板是一个通用模板！！

package com.springboot.config;    //对照 StringRedisTemplate 看，里面的步骤基本相同，而且可以变出自己的Util类
 
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
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 MyRedisTemplate {
 
@Bean
//1. 为了开发方便，所以将第一个泛型修改为String
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) //这个Factory就是：LettuceConnectionFactory
            throws UnknownHostException {
 
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        //2. 连接Lettuce工厂
        template.setConnectionFactory(factory);
        //3.序列化配置：
                //3.1：Json序列化，让Json解析任意的对象，让User对象变成Json序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper(); 
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
 
                //3.2：String序列化：
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //所有的key采用String类型的序列化
        template.setKeySerializer(stringRedisSerializer);
        //所有的Hash的key也采用String类型的序列化
        template.setHashKeySerializer(stringRedisSerializer);
        //所以的value采用json类型的序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //所有的hash的value采用json类型的序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        //将所有的属性set进去
        template.afterPropertiesSet();
 
        return template;
 
    }
}   

测试：

 

 
//自己定义了RedisTemplate后的测试：覆盖了原有的JDK序列化
@Test
public void test4() throws JsonProcessingException {
 
    User u = new User("zs",23);
 
    ObjectMapper objectMapper = new ObjectMapper();
    String user = objectMapper.writeValueAsString(u);
 
    redisTemplate.opsForValue().set("user11",user);
 
    System.out.println(redisTemplate.opsForValue().get("user11"));
}

 

    控制台输出： User{name='zs', age=23}

    Redis：keys * 查看： user11   ，get user11: "\"{\\\"name\\\":\\\"zs\\\",\\\"age\\\":23}\""

• 问题描述： 如果向Redis中插入中文出现下面情况，不用担心：

        @Bean
        public RedisTemplate redisTemplate(xx factory){
        
            RedisTemplate<String, Object> template = new RedisTemplate<>();
            template.setConnectionFactory(factory);
 
            // 下面两句话就行
            Jackson2Rxxx jackson = new Jackson2RedisCacheSerxxx<>(Object.class);
            template.setDefaultxxx(jackson);
 
            return template;
        }