SpringBoot(4) ------>整合CacheManager与Redis

1、向pom文件中添加依赖

     <!--springboot中的redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

2、application.yml添加配置

spring:
  redis:
    host: localhost     # Redis服务器地址
    database: 0         # Redis数据库索引（默认为0）
    port: 6379          # Redis服务器连接端口
    password: ld123456  # Redis服务器连接密码（默认为空）

3、RedisConfig配置类

package com.donleo.mybatis.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
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.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.util.Arrays;

/**
 * @author liangd
 * date 2020-12-04 16:15
 * code Redis配置类
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    /**
     * 配置redisTemplate 代替默认配置
     * @param redisConnectionFactory  RedisConnectionFactory
     * @return  RedisTemplate
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(mapper);

        template.setValueSerializer(serializer);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }

    /**
     *
     * 配置 cacheManager 代替默认的cacheManager （缓存管理器）
     * @param factory RedisConnectionFactory
     * @return  CacheManager
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(objectMapper);
        // 配置序列化
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(serializer));

        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }

    /**
     * 配置KeyGenerator
     * @return
     */
    @Bean
    @Override
    public KeyGenerator keyGenerator() {
        //lambda 表达式
        return (target, method, params) -> method.getName() + Arrays.asList(params);
    }
    /*
        // 1. 不需要参数,返回值为 5
            () -> 5

        // 2. 接收一个参数(数字类型),返回其2倍的值
            x -> 2 * x

        // 3. 接受2个参数(数字),并返回他们的差值
            (x, y) -> x – y

        // 4. 接收2个int型整数,返回他们的和
            (int x, int y) -> x + y

        // 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
            (String s) -> System.out.print(s)
     */
     /*   @Bean
       @Override
       public KeyGenerator keyGenerator() {
           return (target,  method,  params)->{
               return method.getName()+ Arrays.asList(params);
           };
       }*/
}

4、自定义Redis工具类

　 1）接口层

package com.donleo.mybatis.service;

/**
 * @author liangd
 * date 2020-12-04 16:19
 * code 自定义封装redis接口定义
 */
public interface IRedisService {
    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     * @return
     */
    boolean expire(String key, long time);

    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    long getExpire(String key);

    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */

    boolean hasKey(String key);

    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */

    void del(String... key);

    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    Object get(String key);

    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    boolean set(String key, Object value);

    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    boolean set(String key, Object value, long time);
}

　 2）实现层

package com.donleo.mybatis.service.impl;

import com.donleo.mybatis.service.IRedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.concurrent.TimeUnit;

/**
 * @author liangd
 * date 2020-12-04 16:21
 * code 自定义封装Redis接口定义
 */
@Service
public class RedisServiceImpl implements IRedisService {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    @Override
    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 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    @Override
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    @Override
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    @Override
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    //============================String=============================

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    @Override
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    @Override
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    @Override
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
}

5、测试-->通过Redis工具类缓存

package com.donleo.mybatis.service.impl;

import com.donleo.mybatis.common.CommonResult;
import com.donleo.mybatis.dao.IDeptMapper;
import com.donleo.mybatis.model.Dept;
import com.donleo.mybatis.service.IDeptService;
import com.donleo.mybatis.service.IRedisService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

/**
 * @author liangd
 * date 2020-12-03 11:09
 * code 部门逻辑层(使用自定义RedisTemplate设置缓存)
 */
@Service
public class DeptServiceImpl implements IDeptService {

    @Resource
    private IDeptMapper deptMapper;

    @Resource
    private IRedisService redisService;

    @Override
    public CommonResult findAll() {
        List<Dept> list;
        boolean b = redisService.hasKey("deptList:");
        if (b) {
            Object object = redisService.get("deptList:");
            list = (List<Dept>) object;
        } else {
            list = deptMapper.selectAll();
            redisService.set("deptList:",list);
        }
        return CommonResult.success(list);
    }

    @Override
    public Integer add(Dept dept) {
        dept.setId(null);
        deptMapper.insert(dept);
        return dept.getId();
    }

    @Override
    public Integer delete(Integer id) {
        redisService.del("dept:"+id);
        redisService.del("deptList:");
        return deptMapper.deleteByPrimaryKey(id);
    }

    @Override
    public Integer update(Dept dept) {
        return deptMapper.updateByPrimaryKeySelective(dept);
    }

    @Override
    public Dept findById(Integer id) {
        //判断redis中是否存在当前key,加一个冒号生成文件夹
        boolean b = redisService.hasKey("dept:" + id);
        Dept dept;
        //如果存在，从redis中查询，否则从数据库中查询
        if (b) {
            dept = (Dept) redisService.get("dept:" + id);
        } else {
            dept = deptMapper.selectByPrimaryKey(id);
            //放入resis中
            redisService.set("dept:"+id, dept);
        }
        return dept;
    }
}

6、测试-->通过CacheManager缓存(1)

package com.donleo.mybatis.service.impl;

import com.donleo.mybatis.common.CommonResult;
import com.donleo.mybatis.dao.IRoleMapper;
import com.donleo.mybatis.model.Role;
import com.donleo.mybatis.service.IRoleService;
import org.springframework.cache.annotation.*;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

/**
 * @author liangd
 * date 2020-12-04 17:42
 * code 角色逻辑实现层(使用注解CacheManager设置缓存)
 * 使用@CacheConfig配置缓存名
 */
@Service
@CacheConfig(cacheNames = "role")
public class RoleServiceImpl implements IRoleService {

    @Resource
    private IRoleMapper roleMapper;

    /**
     * 使用@Caching注解可以让我们在一个方法或者类上同时指定多个Spring Cache相关的注解。
     * 其拥有三个属性：cacheable、put和evict，分别用于指定@Cacheable、@CachePut和@CacheEvict。
     *
     * @param role
     * @return
     */
    @Override
    @Caching(
            put = @CachePut(key = "#role.id"),
            evict = @CacheEvict(key = "'findAllRole[]'")
    )
    public CommonResult add(Role role) {
        role.setId(null);
        try {
            roleMapper.insert(role);
        } catch (Exception e) {
            return CommonResult.failed();
        }
        return CommonResult.success(role.getId());
    }

    /**
     * 使用@CacheEvict移除key
     * @param id
     * @return
     */
    @Override
    @CacheEvict(key = "#id")
    public Integer delete(Integer id) {
        return roleMapper.deleteByPrimaryKey(id);
    }

    @Override
    public Integer update(Role role) {
        return roleMapper.updateByPrimaryKeySelective(role);
    }

    /**
     * 使用@Cacheable标注的方法，Spring在每次执行前都会检查Cache中是否存在相同key的缓存元素，
     * 如果存在就不再执行该方法，而是直接从缓存中获取结果进行返回，否则才会执行并将返回结果存入指定的缓存中。
     *
     * @param id
     * @return
     */
    @Override
    @Cacheable(key = "#id")
    public Role findById(Integer id) {
        return roleMapper.selectByPrimaryKey(id);
    }

    /**
     * 使用@CachePut 也可以声明一个方法支持缓存功能。
     * 与@Cacheable不同的是使用@CachePut标注的方法在执行前不会去检查缓存中是否存在之前执行过的结果，
     * 而是每次都会执行该方法，并将执行结果以键值对的形式存入指定的缓存中。
     *
     * @return
     * keyGenerator将方法名作为key，存进缓存，例如findAllRole[],删除key时需要添加单引号
     */
    @Override
    @CachePut(keyGenerator = "keyGenerator")
    public CommonResult findAllRole() {
        List<Role> list = roleMapper.selectAll();
        return CommonResult.success(list);
    }
}

7、测试-->通过CacheManager缓存(2)

package com.donleo.cache.service.impl;

import com.donleo.cache.common.CommonResult;
import com.donleo.cache.mapper.IRoleMapper;
import com.donleo.cache.model.Role;
import com.donleo.cache.service.IRoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.*;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author liangd
 * date 2020-12-10 09:49
 * code
 * .@CacheConfig抽取缓存的公共配置，在这里配置了cacheNames就不需要再每个方法上面指定value属性了
 */
@Service
@CacheConfig(cacheNames = "role")
public class RoleServiceImpl implements IRoleService {

    @Autowired
    private IRoleMapper roleMapper;

    /**
     * .@Cacheable标注的方法执行之前先来检查缓存中有没有这个数据，默认按照参数的值作为key去查询缓存，
     * 如果没有就运行方法并将结果放入缓存；以后再来调用就可以直接使用缓存中的数据；
     *
     * .@Cacheable 将方法的运行结果进行缓存，以后再要相同的数据，直接从缓存中获取，不用调用方法;
     * <p>
     * CacheManager管理多个Cache组件的，对缓存的真正CRUD操作在Cache组件中，每一-个缓存组件有自己唯- --一个名字;
     * <p>
     * <p>
     * 原理：
     * 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
     * <p>
     * 3、哪个配置类默认生效：SimpleCacheConfiguration；
     * <p>
     * 4、给容器中注册了一个CacheManager：ConcurrentMapCacheManager
     * 5、可以获取和创建ConcurrentMapCache类型的缓存组件；他的作用将数据保存在ConcurrentMap中；
     * <p>
     * 运行流程：
     * <p>
     * .@Cacheable：
     * 1、方法运行之前，先去查询Cache（缓存组件），按照cacheNames指定的名字获取；
     *  （CacheManager先获取相应的缓存），第一次获取缓存如果没有Cache组件会自动创建。
     * 2、去Cache中查找缓存的内容，使用一个key，默认就是方法的参数；
     *      key是按照某种策略生成的；默认是使用keyGenerator生成的，默认使用SimpleKeyGenerator生成key；
     *      SimpleKeyGenerator生成key的默认策略；
     *          如果没有参数；key=new SimpleKey()；
     *          如果有一个参数：key=参数的值
     *          如果有多个参数：key=new SimpleKey(params)；
     * 3、没有查到缓存就调用目标方法；
     * 4、将目标方法返回的结果，放进缓存中
     * <p>
     * <p>
     * 核心：
     * 1）、使用CacheManager【ConcurrentMapCacheManager】按照名字得到Cache【ConcurrentMapCache】组件
     * 2）、key使用keyGenerator生成的，默认是SimpleKeyGenerator
     * <p>
     * 几个属性：
     * a)cacheNames/value：指定缓存组件的名字
     *      cacheNames = {"role"}可以使用多个参数,是数组的形式，可以指定多个缓存
     * b)key：缓存数据使用的key，可以用他来指定。默认是使用方法参数的值
     *      编写SpEl:   #id  #a0,#po,#argrs[0]  "0"代表参数的索引
     *      #result  方法执行后的返回值
     *      #root.methodName   方法名
     *      key = "#root.methodName+'['+#id+']'"
     * c)keyGenerator: key的生成器、可以自己指定key的生成器的组件Id
     *      key/keyGenerator 二选一
     *      keyGenerator = "myKeyGenerator"
     * d)cacheManager：指定缓存管理器或者cacheResolver:获取解析器
     *      cacheManager/cacheResolver 二选一
     * e)condition：指定符合缓存的条件
     *      condition = "#id>0 and #root.methodName eq 'aaa'" 可以多条件判断
     * f)unless: 否定缓存，当unless的条件为true，方法结果不会被缓存,可以获取结果进行判断
     *      unless = "#result==null"，结果为null，就不缓存
     * g)sync:是否使用异步模式
     *      默认false   同步
     *      为true时，unless不支持
     */

    @Override
    @Cacheable(value = {"role"}, key = "#id",
            condition = "#id>0", unless = "#result==null")
    public Role findById(Integer id) {
        return roleMapper.selectById(id);
    }

    /**
     * .@CachePut既调用方法、又更新数据，达到同步更新缓存
     * <p>
     * 运行时机：
     * 1、先调用目标方法
     * 2、将目标方法的结果缓存起来
     *
     * 条件：存取Id的key要保持一致
     *     key = "#role.id"     传入员工的Id
     *     key = "#result.id"   使用返回员工的Id
     * 注意： @Cacheable不能使用#result
     *      因为 @Cacheable在目标方法执行之前需要得到这个key，所以不能用#result
     */
    @Override
    @CachePut(value = "role", key = "#result.id")
    public Role update(Role role) {
        roleMapper.updateById(role);
        return role;
    }

    /**
     * .@CacheEvict 缓存清除
     *
     *  key：指定要清除的数据
     *  allEntries：指定清除这个缓存库的所有数据，默认为false
     *  beforeInvocation：在执行方法之前清除，默认为false，在方法之后执行
     *
     */
    @Override
    @CacheEvict(/*value = "role",*/key = "#id")
    public Integer delete(Integer id) {
        return roleMapper.deleteById(id);
    }

    /**
     * .@Caching 定义复杂缓存规则
     */
    @Override
    @Caching(
            cacheable = {
                    @Cacheable(key = "#role.roleName")
            },
            put = {
                    @CachePut(key = "#role.id"),
                    @CachePut(key = "#role.roleCode")
            }
    )
    public CommonResult add(Role role) {
        role.setId(null);
        try {
            roleMapper.insert(role);
        } catch (Exception e) {
            return CommonResult.failed();
        }
        return CommonResult.success(role.getId());
    }

    @Override
    public CommonResult findAllRole() {
        List<Role> roleList = roleMapper.selectList(null);
        return CommonResult.success(roleList);
    }
}