SpringBoot整合Spring Cache，简化分布式缓存开发

<!--引入缓存场景-->
<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<!--使用redis作为缓存中间件-->
<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

@EnableConfigurationProperties(CacheProperties.class)
@Configuration
@EnableCaching
public class CacheConfig {
  //其他内容，暂时略过
}

@Repository
@CacheConfig(cacheNames = "users")
public class UserDao implements IUserDao{
    @Autowired
    private UserMapper userMapper;
    @Cacheable(key = "'getTotalCount'")
    @Override
    public int getTotalCount(){
        int totalCount = userMapper.getTotalCount();
        return totalCount;
    }

    @Cacheable(key = "#userId")
    @Override
    public User getUser(Integer userId){
      return  userMapper.getUser(userId);
    }
    @Caching(evict = {
            @CacheEvict(key = "'getUsers'"),
            @CacheEvict(key = "'getTotalCount'")
    })
    @Override
    public void insertUser(User u){

        userMapper.insertUser(u);
    }
    @Cacheable(key = "'getUsers'")
    @Override
    public List<User> getUsers(){

       return userMapper.getUsers();
    }
    @Caching(evict = {
            @CacheEvict(key = "'getUsers'")
    })
    @Override
    public void updateUserNameById(Integer userId, String name){

        userMapper.updateUserNameById(userId, name);
    }
    @Caching(evict = {
            @CacheEvict(key = "'getUsers'"),
            @CacheEvict(key = "'getTotalCount'"),
            @CacheEvict(key = "#userId")
    })
    @Override
    public void deleteUser(Integer userId){
        userMapper.deleteUser(userId);
    }

    /**
     * 调用方法，有更新缓存的数据 修改数据库的数据同时更新新缓存。
     */
    @Caching(evict = {
            @CacheEvict(key="'getUsers'")
    },put = {@CachePut(key = "#result.id")})
    @Override
    public User updateUser(User user){
        userMapper.updateUser(user);
        return user;
    }
}

server:
  port: 8084

spring:
  application:
    name: springboot-cache
  datasource:
    url: jdbc:mysql://localhost:3306/user_db_test
    username: root
    password: admin123
    type: com.zaxxer.hikari.HikariDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
  redis:
    # Redis服务器地址
    host: localhost
    # Redis服务器连接端口
    port: 6379
    # Redis服务器连接密码（默认为空）
    password:
    # Redis数据库索引（默认为0）
    database: 0
  # 连接超时时间（毫秒）
    timeout : 300
    client-type: lettuce #切换jedis客户端，改成jedis
    lettuce: #切换jedis客户端，改成jedis
      pool:
        # 连接池最大连接数（使用负值表示没有限制）
        max-active: 8
        # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1
        # 连接池中的最大空闲连接
        max-idle: 8
        # 连接池中的最小空闲连接
        min-idle: 0
  cache:
    type: redis
    redis:
      #是否缓存空值,防止缓存穿透
      cache-null-values: true
      #缓存过期时间（单位为毫秒）
      time-to-live: 100000
      #缓存前缀，用于区分其他缓存,不指定前缀，默认使用缓存的名字作为前缀
#      key-prefix: CACHE_
      #是否使用缓存前缀，false不使用任何缓存前缀
#      use-key-prefix: false

# 配置mybatis规则
mybatis:
  config-location: classpath:mybatis/mybatis-config.xml  #全局配置文件位置
  mapper-locations: classpath:mybatis/mapper/*.xml  #sql映射文件位置

1. 缓存中有数据，方法不调用
2. 缓存的value值，默认使用jdk序列化机制，将序列化的数据存到redis中；
3. key是默认生成的，如果不指定，默认user::SimpleKey []；可以通过key属性指定，接收一个SpEL表达式的值；
4. 默认时间是 -1，永不过期，可以在配置文件中配置过期时间；

@EnableConfigurationProperties(CacheProperties.class)//开启属性配置绑定功能
@Configuration
@EnableCaching //开启缓存启动类的注解从启动类移到这里
public class CacheConfig {


    /**
     * 配置文件中的东西没有用上；
     * 1、原来文件中的东西没有用上
     * @ConfigurationProperties(prefix = "spring.cache")
     * public class CacheProperties {
     *
     * 2、要让他生效
     * @return
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory,CacheProperties cacheProperties){
         //缓存配置对象
         RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
         redisCacheConfiguration = redisCacheConfiguration
         //序列化方式：new GenericJackson2JsonRedisSerializer();
        .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new FastJsonRedisSerializer<>(Object.class)));

        CacheProperties.Redis redisProperties = cacheProperties.getRedis();
        if (redisProperties.getTimeToLive() != null) {
            redisCacheConfiguration = redisCacheConfiguration.entryTtl(redisProperties.getTimeToLive());
        }
        if (redisProperties.getKeyPrefix() != null) {
            redisCacheConfiguration = redisCacheConfiguration.prefixCacheNameWith(redisProperties.getKeyPrefix());
        }
        if (!redisProperties.isCacheNullValues()) {
            redisCacheConfiguration = redisCacheConfiguration.disableCachingNullValues();
        }
        if (!redisProperties.isUseKeyPrefix()) {
            redisCacheConfiguration = redisCacheConfiguration.disableKeyPrefix();
        }

        return RedisCacheManager
                .builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
                 .cacheDefaults(redisCacheConfiguration).build();
    }
}

<module>springboot-cache</module>