Spring Boot与缓存

Updated on with 0 views and 0 comments

JSR107

Java Caching定义了5个核心接口,分别是CachingProvider, CacheManager, Cache, Entry 和 Expiry。

  • CachingProvider定义了创建、配置、获取、管理和控制多个CacheManager。一个应用可以在运行期访问多个CachingProvider。
  • CacheManager定义了创建、配置、获取、管理和控制多个唯一命名的Cache,这些Cache存在于CacheManager的上下文中。一个CacheManager仅被一个CachingProvider所拥有。
  • Cache是一个类似Map的数据结构并临时存储以Key为索引的值。一个Cache仅被一个CacheManager所拥有。
  • Entry是一个存储在Cache中的key-value对。
  • Expiry 每一个存储在Cache中的条目有一个定义的有效期。一旦超过这个时间,条目为过期的状态。一旦过期,条目将不可访问、更新和删除。缓存有效期可以通过ExpiryPolicy设置。
  • image.png

JSR-107规范 提取码:uAjL

Spring缓存抽象

Cache缓存接口,定义缓存操作。实现有:RedisCache、EhCacheCache、ConcurrentMapCache等
CacheManager缓存管理器,管理各种缓存(Cache)组件
@Cacheable主要针对方法配置,能够根据方法的请求参数对其结果进行缓存
@CacheEvict清空缓存
@CachePut保证方法被调用,又希望结果被缓存。
@EnableCaching开启基于注解的缓存
keyGenerator缓存数据时key生成策略
serialize缓存数据时value序列化策略

| serialize | 缓存数据时value序列化策略 |

@Cacheable

@Service
public class EmployServiceImpl implements EmployService {

    @Autowired
    EmployeeMapper employeeMapper;

    /**
     * 将方法的运行结果进行缓存,以后再要相同的数据,直接从缓存中获取,不用调用方法
     *
     * CacheManager管理多个Cache组件,对缓存真正的CRUD操作在Cache组件中,每一个缓存组件有自己唯一的名字
     *      cacheName/value:指定缓存组件的名字;将方法的返回结果放在哪个缓存中,是数组的方式,可以指定多个缓存;
     *      key:缓存数据时使用的key,可以用它来指定,默认使用方法参数的值
     *              可以编写SpEL:#id;参数id的值   #a0  #p0  #root.args[0]
     *                    getEmp[2]
     *      keyGenerator:key的生成器,可以自己指定Key的生成器组件id -- 与key二选一使用
     *      cacheManager:指定缓存管理器,与cacheResolver(缓存解析器)二选一使用
     *      condition:指定符合条件的情况下才缓存
     *                  ,condition = "#id>0"
     *                  condition = "#a0>1":第一个参数的值》1的时候才进行缓存
     *      unless:否定缓存,当unless指定的条件为true,方法的返回值不会被缓存,可以获取到结果进行判断(#result)
     *                  unless = "#result == null"
     *                  unless = "#a0==2":如果第一个参数的值是2,结果不缓存;
     *      sync:是否使用异步模式
     * @param id
     * @return
     */
    @Override
    @Cacheable(cacheNames = "emp", key = "#root.args[0]", condition = "#id > 0")
    public Employee getEmp(Integer id) {
        System.out.println("查询"+id+"号员工");
        Employee emp = employeeMapper.getEmpById(id);
        return emp;
    }
}

image.png

缓存工作原理

  1. 自动配置类;CacheAutoConfiguration
  2. 缓存的配置类
    org.springframework.boot.autoconfigure.cache.GenericCacheConfiguration
    org.springframework.boot.autoconfigure.cache.JCacheCacheConfiguration
    org.springframework.boot.autoconfigure.cache.EhCacheCacheConfiguration
    org.springframework.boot.autoconfigure.cache.HazelcastCacheConfiguration
    org.springframework.boot.autoconfigure.cache.InfinispanCacheConfiguration
    org.springframework.boot.autoconfigure.cache.CouchbaseCacheConfiguration
    org.springframework.boot.autoconfigure.cache.RedisCacheConfiguration
    org.springframework.boot.autoconfigure.cache.CaffeineCacheConfiguration
    org.springframework.boot.autoconfigure.cache.GuavaCacheConfiguration
    org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration【默认】
    org.springframework.boot.autoconfigure.cache.NoOpCacheConfiguration
  3. 哪个配置类默认生效:SimpleCacheConfiguration;
  4. 给容器中注册了一个CacheManager:ConcurrentMapCacheManager
  5. 可以获取和创建ConcurrentMapCache类型的缓存组件;他的作用将数据保存在ConcurrentMap中;

运行流程:

@Cacheable:

  1. 方法运行之前,先去查询Cache(缓存组件),按照cacheNames指定的名字获取;

(CacheManager先获取相应的缓存),第一次获取缓存如果没有Cache组件会自动创建。

  1. 去Cache中查找缓存的内容,使用一个key,默认就是方法的参数;

key是按照某种策略生成的;默认是使用keyGenerator生成的,默认使用SimpleKeyGenerator生成key;

SimpleKeyGenerator生成key的默认策略;

  • 如果没有参数;key=new SimpleKey();
  • 如果有一个参数:key=参数的值
  • 如果有多个参数:key=new SimpleKey(params);
  1. 没有查到缓存就调用目标方法;
  2. 将目标方法返回的结果,放进缓存中

@Cacheable标注的方法执行之前先来检查缓存中有没有这个数据,默认按照参数的值作为key去查询缓存,

如果没有就运行方法并将结果放入缓存;以后再来调用就可以直接使用缓存中的数据;

核心:

  • 1)、使用CacheManager【ConcurrentMapCacheManager】按照名字得到Cache【ConcurrentMapCache】组件
  • 2)、key使用keyGenerator生成的,默认是SimpleKeyGenerator

@CachePut

/**
     * @CachePut:既调用方法,又更新缓存数据;同步更新缓存
     * 修改了数据库的某个数据,同时更新缓存;
     * 运行时机:
     *  1、先调用目标方法
     *  2、将目标方法的结果缓存起来
     *
     * 测试步骤:
     *  1、查询1号员工;查到的结果会放在缓存中;
     *          key:1  value:lastName:张三
     *  2、以后查询还是之前的结果
     *  3、更新1号员工;【lastName:zhangsan;gender:0】
     *          将方法的返回值也放进缓存了;
     *          key:传入的employee对象  值:返回的employee对象;
     *  4、查询1号员工?
     *      应该是更新后的员工;
     *          key = "#employee.id":使用传入的参数的员工id;
     *          key = "#result.id":使用返回后的id
     *             @Cacheable的key是不能用#result
     *      为什么是没更新前的?【1号员工没有在缓存中更新】 -- 要保持key一致才能从缓存中更新
     *
     */
    @CachePut(/*value = "emp",*/key = "#result.id")
    public Employee updateEmp(Employee employee){
        System.out.println("updateEmp:"+employee);
        employeeMapper.updateEmp(employee);
        return employee;
    }

@CacheEvict

/**
     * @CacheEvict:缓存清除
     *  key:指定要清除的数据
     *  allEntries = true:指定清除这个缓存中所有的数据
     *  beforeInvocation = false:缓存的清除是否在方法之前执行
     *      默认代表缓存清除操作是在方法执行之后执行;如果出现异常缓存就不会清除
     *
     *  beforeInvocation = true:
     *      代表清除缓存操作是在方法运行之前执行,无论方法是否出现异常,缓存都清除
     *
     *
     */
    @CacheEvict(value="emp",beforeInvocation = true/*key = "#id",*/)
    public void deleteEmp(Integer id){
        System.out.println("deleteEmp:"+id);
        //employeeMapper.deleteEmpById(id);
        int i = 10/0;
    }

@Caching&CacheConfig

// @Caching 定义复杂的缓存规则
    @Caching(
         cacheable = {
             @Cacheable(/*value="emp",*/key = "#lastName")
         },
         put = {
             @CachePut(/*value="emp",*/key = "#result.id"),
             @CachePut(/*value="emp",*/key = "#result.email")
         }
    )
    public Employee getEmpByLastName(String lastName){
        return employeeMapper.getEmpByLastName(lastName);
    }
@CacheConfig(cacheNames="emp"/*,cacheManager = "employeeCacheManager"*/) //抽取缓存的公共配置
@Service
public class EmployeeService {}

Redis

默认使用的是ConcurrentMapCacheManager==ConcurrentMapCache;将数据保存在 ConcurrentMap<Object, Object>中

开发中使用缓存中间件;redis、memcached、ehcache;

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

RedsiTemplate

RedisTemplate:k-v都是对象

StringRedisTemplate:k-v都是字符串的

(1)方法

stringRedisTemplate.opsForValue() -- 操作字符串的
stringRedisTemplate.opsForList() -- 操作List(列表)的
stringRedisTemplate.opsForSet() -- 操作Set(集合)的
stringRedisTemplate.opsForHash() -- 操作Hash(散列)
stringRedisTemplate.opsForZSet() -- 操作ZSet(有序集合)

序列号机制

@Test
	void testRedis() {
		Employee emp = employeeMapper.getEmpById(1);
		redisTemplate.opsForValue().set("emp-01",emp);
	}

image.png

保存对象默认使用JDK序列化机制,序列化后的数据保存到redis中

想要将数据以json方式保存,一是自己将对象转化为json,二是改版redisTemplate默认的序列化规则

@Configuration
public class MyRedisConfig {

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        Jackson2JsonRedisSerializer<Object> objectJackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        template.setDefaultSerializer(objectJackson2JsonRedisSerializer);
        return template;
    }

}

测试缓存

CacheManager===Cache 缓存组件来实际给缓存中存取数据

  1. 引入redis的starter,容器中保存的是 RedisCacheManager;
  2. RedisCacheManager 帮我们创建 RedisCache 来作为缓存组件;RedisCache通过操作redis缓存数据的
  3. 默认保存数据 k-v 都是Object;利用序列化保存;如何保存为json
  • 1.引入了redis的starter,cacheManager变为 RedisCacheManager;
  • 2.默认创建的 RedisCacheManager 操作redis的时候使用的是 RedisTemplate<Object, Object>
  • 3.RedisTemplate<Object, Object> 是 默认使用jdk的序列化机制
  1. 自定义CacheManager;

Springboot 1.X

@Bean
    public RedisCacheManager employeeCacheManager(RedisTemplate<Object, Object> redisTemplate){
        RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
        //key多了一个前缀

        //使用前缀,默认会将CacheName作为key的前缀
        cacheManager.setUsePrefix(true);

        return cacheManager;
    }

Springboot 2.X

@Bean
    public RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
        RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(10)) //设置过期时间
                .disableCachingNullValues()   //禁止缓存null对象
//                .computePrefixWith(cacheName -> "yourAppName".concat(":").concat(cacheName).concat(":"))//* //此处定义了cache key的前缀,避免公司不同项目之间的key名称冲突
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer())) //定义了key和value的序列化协议,同时hash key和hash value也被定义
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new Jackson2JsonRedisSerializer<>(Object.class)));  //序列化器也可以使用GenericJackson2JsonRedisSerializer,可加入@Class属性

        return RedisCacheManager.builder(redisConnectionFactory)
                .cacheDefaults(cacheConfiguration)
                .build();
    }

存缓存也可以使用这种方式

@Autowired
    CacheManager cacheManager;

    public Employee getEmployee(Integer id) {
        System.out.println("查询"+id+"号员工");
        Employee emp = employeeMapper.getEmpById(id);
	//获取某个缓存
        Cache dept = cacheManager.getCache("dept");
        dept.put("dept::1",dept);
        return emp;
    }