2.SpringBoot与缓存（spring缓存抽象）

1几个重要概念和缓存注解

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

操作(redis缓存)

1.xml中的坐标依赖

<dependency>
		    <groupId>org.springframework.bootgroupId>
		    <artifactId>spring-boot-starter-webartifactId>
		    <version>2.2.4.RELEASEversion>
dependency>
<dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redisartifactId>
            <version>2.2.2.RELEASEversion>
   dependency>

2.yml文件的配置

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/tables_mysql
    username: sdfds
    password: 2312
    type: com.alibaba.druid.pool.DruidDataSource
  redis:
   jpa:
     hibernate:
       # 更新或者创建数据表结构
       ddl-auto: updata
       #控制台显示SQL
     show-sql: true
#     配置连接的redis地址
   host: 118.24.44.169

3.redis自定义序列化

@Configuration
public class MyRedisConfig {
    /**
     * 自定义redis序列化
     * @param  * @param redisConnectionFactory
     * @return org.springframework.data.redis.core.RedisTemplate
     */
    //操作user
    @Bean
    public RedisTemplate<Object, User> UserRedisTemplate(
            RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        RedisTemplate<Object, User> template = new RedisTemplate<Object, User> ();
        template.setConnectionFactory(redisConnectionFactory);
        Jackson2JsonRedisSerializer<User> serializer = new    Jackson2JsonRedisSerializer<User>(User.class);
        template.setDefaultSerializer(serializer);
        return template;
    }
    //操作单位
    @Bean
    public RedisTemplate<Object, dept>  deptRedisTemplate(
            RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        RedisTemplate<Object, dept> template = new RedisTemplate<Object, dept> ();
        template.setConnectionFactory(redisConnectionFactory);
        Jackson2JsonRedisSerializer<dept> serializer = new    Jackson2JsonRedisSerializer<dept>(dept.class);
        template.setDefaultSerializer(serializer);
        return template;
    }
//    自定义user cacheManager
    @Bean
    public RedisCacheManager  UserCacheManager(RedisTemplate<Object, User> UserRedisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(UserRedisTemplate);
        //key多了一个前缀

        //使用前缀，默认把cacheName作为前缀
        cacheManager.setUsePrefix(true);
        return cacheManager;
    }
    //    自定义单位cacheManager
    @Bean
    @Primary  //默认缓存管理器  必须得有默认
    public RedisCacheManager  UserCacheManager(RedisTemplate<Object, dept>  deptRedisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(deptRedisTemplate);
        //key多了一个前缀

        //使用前缀，默认把cacheName作为前缀
        cacheManager.setUsePrefix(true);
        return cacheManager;
    }
}

4.业务层代码

@CacheConfig( cacheNames ="emp",cacheManager ="UserCacheManager" ) //指定全部的缓存的位置,使用的管理器，缓存的公共注解
@Service
public class UserService {
    @Autowired
    Usermaper usermaper;
    @Resource("UserCacheManager")
    RedisCacheManager  UserCacheManager;
    @Autowired
    RedisTemplate redisTemplate;
    @Autowired
    RedisTemplate<Object, User> UserRedisTemplate;
    /*
    * 将方法的运行结果进行缓存，以后要相同的数据，直接从缓存中获取，不要调用方法
    * 几个属性：
    *   root表示方法
		cacheNames/value：指定缓存组件的名字;
		key ：缓存数据使用的Key：可以用它来指定。默认是使用方法参数的值 1-方法的返回值；
		    getUser[id]=#root.methodName+"["+#id+"]"
		keyGenerator ：key的生成器，可以自己指定key的生成器的组件ID
		key /keyGenerator ：二选一使用
		cacheManager：指定缓存管理器，或者cacheResolver指定解析器
		condition：指定符合条件的情况下才缓存
		#a0>1:第一个参数的值>1的时候才进行缓存
		unless：否定缓存；但unless指定的条件为true；方法的返回值就不会被缓存；可以获取到结果进行判断
		sync:是否使用异步模式（不支持unless）
    *
    * */
    @Cacheable(cacheNames = {"emp"},condition = "#id>0",key = "#id",unless="#result==null")
    public User getUser(Integer id ){
        System.out.println("查询"+id+"员工");
        User  user = usermaper.getById(id);
        return user;
    }
    //编码的方式实现查询
    public user getuser01(Integer id){
     System.out.println("查询"+id+"员工");
        User  user = usermaper.getById(id);
        //获取某个缓存
        Cache emp = UserCacheManager.getCache("emp");
        //缓存中放数据
        emp.put("1",user);
        return user;
    	
    }

    /*注意该key值要和缓存是使用的key值是一个属性
    * */
    @CachePut(cacheNames = {"emp"},key = "#result.id")
    public  User  updata(User user){
        usermaper.updateDept(user);
        return user;
    }
    /*** allEntries = true;//指定清除缓存中的所有属性
     * beforeInvocation = false；缓存的清除是在方法之后执行
     * 代表：缓存清除操作是在方法执行之后执行；如果出现异常缓存就不会清除
     * */
    @CacheEvict(cacheNames = {"emp"},beforeInvocation = false,key= "#id")
    public void  delete(Integer id){
        usermaper.deleteById(id);
    }
	
    /*定义复查的缓存规则*/
    @Caching(
            cacheable = { @Cacheable(cacheNames = {"emp"},condition = "#id>0",key = "#id")},
            put = {
                    @CachePut(cacheNames = {"emp"},key = "#result.id"),
                    @CachePut(cacheNames = {"emp"},key = "#result.lastName")
            },
            evict = {
                    @CacheEvict(cacheNames = {"emp"},beforeInvocation = false,key= "#id")
                    }
    )
    public User getUsers(Integer id ){
        System.out.println("查询"+id+"员工");
        User  user = usermaper.getById(id);
        return user;
    }
    //测试保存对象
    public void test02(){
        User  user  =new User();
        //默认如果保存对象，使用JDK序列化机制，序列化后的数据保存到Redis中
        redisTemplate.opsForValue().set("emp-01","getUsers");
        /*21.将数据以json的方式保存
        * 1)自己将对象转为json
        * 2)redisTemplate的默认序列化规则，自定义序列化规则
        * */
        UserRedisTemplate.opsForValue().set("emp-01","getUsers");

    }
}