spring batch 分片redis channel

一、简介

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

　　Cache 接口为缓存的组件规范定义，包含缓存的各种操作集合； Cache接口下 Spring 提供了各种 xxxCache 的实现； 
如 RedisCache ， EhCacheCache , ConcurrentMapCache 等；

　　每次调用需要缓存功能的方法时，Spring 会检查检查指定参数的指定的目标方法是否已经被调用过；如果有就直接从缓存中获取方法调用后的结果，如果没有就调用方法并缓
存结果后返回给用户。下次调用直接从缓存中获取。

　　使用 Spring 缓存抽象时我们需要关注以下两点；
　　　　1、确定方法需要被缓存以及他们的缓存策略
　　　　2、从缓存中读取之前缓存存储的数据

 

二、基础概念

 

三、注解

 

四、表达式语法

 

五、整合SpringCache简化缓存开发

1、引入依赖

<!--引入redis-->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
   <exclusions>
      <exclusion>
         <groupId>io.lettuce</groupId>
         <artifactId>lettuce-core</artifactId>
      </exclusion>
   </exclusions>
</dependency>
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
允许null值缓存

2、写配置

（1）自动配置了哪些
　　CacheAutoConfiguration 会导入 RedisCacheConfiguration；
　　自动配好了缓存管理器 RedisCacheManager

// 缓存自动配置源码
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(CacheManager.class)
@ConditionalOnBean(CacheAspectSupport.class)
@ConditionalOnMissingBean(value = CacheManager.class, name = "cacheResolver")
@EnableConfigurationProperties(CacheProperties.class)
@AutoConfigureAfter({ CouchbaseAutoConfiguration.class, HazelcastAutoConfiguration.class,
                     HibernateJpaAutoConfiguration.class, RedisAutoConfiguration.class })
@Import({ CacheConfigurationImportSelector.class, // 看导入什么CacheConfiguration
         CacheManagerEntityManagerFactoryDependsOnPostProcessor.class })
public class CacheAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public CacheManagerCustomizers cacheManagerCustomizers(ObjectProvider<CacheManagerCustomizer<?>> customizers) {
        return new CacheManagerCustomizers(customizers.orderedStream().collect(Collectors.toList()));
    }

    @Bean
    public CacheManagerValidator cacheAutoConfigurationValidator(CacheProperties cacheProperties,
                                                                 ObjectProvider<CacheManager> cacheManager) {
        return new CacheManagerValidator(cacheProperties, cacheManager);
    }

    @ConditionalOnClass(LocalContainerEntityManagerFactoryBean.class)
    @ConditionalOnBean(AbstractEntityManagerFactoryBean.class)
    static class CacheManagerEntityManagerFactoryDependsOnPostProcessor
        extends EntityManagerFactoryDependsOnPostProcessor {

        CacheManagerEntityManagerFactoryDependsOnPostProcessor() {
            super("cacheManager");
        }

    }

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(RedisConnectionFactory.class)
@AutoConfigureAfter(RedisAutoConfiguration.class)
@ConditionalOnBean(RedisConnectionFactory.class)
@ConditionalOnMissingBean(CacheManager.class)
@Conditional(CacheCondition.class)
class RedisCacheConfiguration {

    @Bean // 放入缓存管理器
    RedisCacheManager cacheManager(CacheProperties cacheProperties, 
                                   CacheManagerCustomizers cacheManagerCustomizers,
                                   ObjectProvider<org.springframework.data.redis.cache.RedisCacheConfiguration> redisCacheConfiguration,
                                   ObjectProvider<RedisCacheManagerBuilderCustomizer> redisCacheManagerBuilderCustomizers,
                                   RedisConnectionFactory redisConnectionFactory, ResourceLoader resourceLoader) {
        RedisCacheManagerBuilder builder = RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(
            determineConfiguration(cacheProperties, redisCacheConfiguration, resourceLoader.getClassLoader()));
        List<String> cacheNames = cacheProperties.getCacheNames();
        if (!cacheNames.isEmpty()) {
            builder.initialCacheNames(new LinkedHashSet<>(cacheNames));
        }
        redisCacheManagerBuilderCustomizers.orderedStream().forEach((customizer) -> customizer.customize(builder));
        return cacheManagerCustomizers.customize(builder.build());
    }

（2）配置使用redis作为缓存
新建 application.properties
spring.cache.type=redis

3、测试使用缓存

（a）@Cacheable——触发将数据保存到缓存的操作
（b）@CacheEvict——触发将数据从缓存删除的操作，失效模式使用
（c）@CachePut——不影响方法执行更新缓存，双写模式可以使用
（d）@Caching——组合以上多个操作
（e）@CacheConfig——在类级别共享缓存的相同配置

（1）开启缓存功能：@EnableCaching

（2）使用注解完成缓存操作

　　　　修改 com.atguigu.gulimall.product.service.impl.CategoryServiceImpl 的 getLevel1Catagories 方法

/**
 * 查询一级分类
* @return
*/
//每一个需要缓存的数据我们都来指定要放到哪个名字的缓存。【缓存的分区（按照业务类型分）】
@Cacheable({"category"})  //代表当前方法的结果需要缓存，如果缓存中有，方法不用调用。如果缓存中没有，会调用方法，最后将方法的结果放入缓存
@Override
public List<CategoryEntity> getLevel1Catagories() {
    System.out.println("getLevel1Catagories......");
    return baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid",0));
}

访问：http://localhost:10000
第一次访问，控制台打印了 “getLevel1Catagories......”，再多次刷新之后没有打印，且redis里面有该缓存信息
说明之后默然查询缓存了

（3）@Cacheable细节处理

　　 上面我们看到redis生成的key名称随机，并且ttl=-1.如何处理这个问题

　　（a）修改application.properties

spring.cache.type=redis

spring.cache.redis.time-to-live=3600000


 　（b）修改 com.atguigu.gulimall.product.service.impl.CategoryServiceImpl 的 getLevel1Catagories 方法

/**
 * 查询一级分类
* @return
*/
/**
 * 1、每一个需要缓存的数据我们都来指定要放到哪个名字的缓存。【缓存的分区（按照业务类型分）】
2、@Cacheable({"category"})
代表当前方法的结果需要缓存，如果缓存中有，方法不用调用。
      如果缓存中没有，会调用方法，最后将方法的结果放入缓存
3、默认行为
     （1）如果缓存中有，方法不再调用
     （2）key是默认自动生成的：缓存的名字: : SimpleKey []（自主生成的key值）
     （3）缓存的value值。默认使用jdk序列化机制，将序列化后的数据存到redis
（4）默认ttl时间：-1

自定义
     （1）指定生成的缓存使用的key；key属性指定，接受一个SpEl表达式
SpEl的详细
     （2）指定缓存的数据的存活时间，配置文件中修改ttl
（3）将数据保存为json格式
*/
@Cacheable(value = {"category"},key = "#root.method.name")
@Override
public List<CategoryEntity> getLevel1Catagories() {
    System.out.println("getLevel1Catagories......");
    return baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid",0));
}

　　测试结果：

　　发现过期时间有了，并且缓存的key值成了设置的名称

（4）自定义缓存配置
　　 上面我们发现虽然缓存时间和key值都指定了，但是缓存的内容没有序列化，不是json类型。如何处理这个问题

　　（a）新建文件 com.atguigu.gulimall.product.config.MyCacheConfig
package com.atguigu.gulimall.product.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.cache.CacheProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@EnableConfigurationProperties(CacheProperties.class)
@Configuration
@EnableCaching
public class MyCacheConfig {

//    @Autowired
//    CacheProperties cacheProperties;

    /**
     * 配置文件中的东西没有用上
     *
     * 1、原来和配置文件绑定的配置类是这样子的
     *      @ConfigurationProperties(prefix = "spring.cache")
     *      public class CacheProperties
     *
     * 2、要让他生效
     *      @EnableConfigurationProperties(CacheProperties.class)
     *
     * @return
     */
    @Bean
    RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties){
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        config = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
        config = config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));

        //将配置文件中的所有配置都让它生效
        CacheProperties.Redis redisProperties = cacheProperties.getRedis();
        if(redisProperties.getTimeToLive() != null){
            config = config.entryTtl(redisProperties.getTimeToLive());
        }
        if(redisProperties.getKeyPrefix() != null){
            config = config.prefixKeysWith(redisProperties.getKeyPrefix());
        }
        if(!redisProperties.isCacheNullValues()){
            config = config.disableCachingNullValues();
        }
        if(!redisProperties.isUseKeyPrefix()){
            config = config.disableKeyPrefix();
        }
        return config;
    }
}
　　注意：一定要开启注解 @EnableConfigurationProperties(CacheProperties.class)，否则配置文件中的东西没用上

测试结果：

　　可以看到：缓存 key 值，过期时间，内容序列化都有了

　　（b）修改application.properties，设置其他缓存配置

spring.cache.type=redis

spring.cache.redis.time-to-live=3600000
#如果指定了前缀就用我们指定的前缀，如果没有就默认使用缓存的名字作为前缀
spring.cache.redis.key-prefix=CACHE_
spring.cache.redis.use-key-prefix=false
#是否缓存空值  防止缓存穿透
spring.cache.redis.cache-null-values=true


 　　具体测试结果不再展示，通常建议开启缓存空值，防止缓存穿透

 （5)@CacheEvict注解

　　（a）修改 application.properties 文件，使用分区的前缀

spring.cache.type=redis

spring.cache.redis.time-to-live=3600000
#如果指定了前缀就用我们指定的前缀，如果没有就默认使用缓存的名字作为前缀
#spring.cache.redis.key-prefix=CACHE_
spring.cache.redis.use-key-prefix=true
#是否缓存空值  防止缓存穿透
spring.cache.redis.cache-null-values=true

　（b）修改 com.atguigu.gulimall.product.service.impl.CategoryServiceImpl 的 updateCascade 方法

/**
     * 级联更新所有关联的数据
     *  @CacheEvict：失效模式
     * @param category
     */
    @CacheEvict(value = "category", key = "'getLevel1Catagories'")
    //category:key
    @Override
    @Transactional
    public void updateCascade(CategoryEntity category) {
        this.updateById(category);
        categoryBrandRelationService.updateCategory(category.getCatId(), category.getName());

        //同时修改缓存中的数据
        //redis.del("catalogJson");等待下次主动查询进行更新
    }

　　测试：
　　　　访问 http://localhost:10000，redis中结果如下：

　　启动网关、启动renren-fast，修改分类，redis中结果：

　　思考：如果修改分类要清除多个缓存呢，例如修改分类，需要删除一级、二级和三级缓存

 

　　（c）先来修改之前的 getCatalogJson 方法，获取分类的json数据，使用@Cacheable注解缓存数据

@Cacheable(value = "category", key = "#root.methodName")
@Override
public Map<String, List<Catelog2Vo>> getCatalogJson(){
    System.out.println("查询了数据库.....");
    List<CategoryEntity> selectList = baseMapper.selectList(null);
    List<CategoryEntity> level1Catagorys = getParent_cid(selectList, 0L);

    //2、封装数据
    Map<String, List<Catelog2Vo>> parent_cid = level1Catagorys.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
        // 1、每一个的一级分类，查到这个以及分类的二级分类
        List<CategoryEntity> categoryEntities = getParent_cid(selectList, v.getCatId());
        //2、封装上面的结果
        List<Catelog2Vo> catelog2Vos = null;
        if (categoryEntities != null) {
            catelog2Vos = categoryEntities.stream().map(l2 -> {
                Catelog2Vo catelog2Vo = new Catelog2Vo(v.getCatId().toString(), null, l2.getCatId().toString(), l2.getName());
                //1、找当前二级分类的三级分类封装成vo
                List<CategoryEntity> level3Catalog = getParent_cid(selectList, l2.getCatId());
                if(level3Catalog!=null){
                    List<Catelog2Vo.Category3Vo> collect = level3Catalog.stream().map(l3 -> {
                        //2、封装成指定格式
                        Catelog2Vo.Category3Vo category3Vo = new Catelog2Vo.Category3Vo(l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());
                        return category3Vo;
                    }).collect(Collectors.toList());
                    catelog2Vo.setCatalog3List(collect);
                }
                return catelog2Vo;
            }).collect(Collectors.toList());
        }
        return catelog2Vos;
    }));
    return parent_cid;
}
　　清空redis，启动网关，多次访问gulimall.com。查看一级菜单和json数据是否都只访问了一次数据库

　　可以看到，多次访问后，一级分类菜单和分类的json数据都只访问了一次数据库，查看redis情况

　　可以看到，redis中有两个key，一个是一级分类，一个是分类的json数据，并且key的前缀都是 “category”，后缀是方法名

　　思考：现在我们从管理后台修改分类，如何一次性是这两个key都失效呢

 

　（d）修改 com.atguigu.gulimall.product.service.impl.CategoryServiceImpl 的 updateCascade 方法

　　　　使用 @Caching 注解，里面存储数组对象，指定多个删除的key值

/**
 * 级联更新所有关联的数据
 *  @CacheEvict：失效模式
 *      1、同时进行多种缓存操作  @Caching
 * @param category
 */
//@CacheEvict(value = "category", key = "'getLevel1Catagories'")
@Caching(evict = {
        @CacheEvict(value = "category", key = "'getLevel1Catagories'"),
        @CacheEvict(value = "category", key = "'getCatalogJson'")
})
//category:key
@Override
@Transactional
public void updateCascade(CategoryEntity category) {
    this.updateById(category);
    categoryBrandRelationService.updateCategory(category.getCatId(), category.getName());

    //同时修改缓存中的数据
    //redis.del("catalogJson");等待下次主动查询进行更新
}
　　测试：
　　　　访问 gulimall.com，然后后台修改分类，发现两个key都被删除了，这里就不再截图展示了
　　思考：这样一个一个指定过于麻烦，我们如何一次性操作简便呢

（e）修改 com.atguigu.gulimall.product.service.impl.CategoryServiceImpl 的 updateCascade 方法

　　　　使用 @CacheEvict(value = "category", allEntries = true)，直接一次性删除分区 “category”里面的数据

/**
     * 级联更新所有关联的数据
     *  @CacheEvict：失效模式
     *      1、同时进行多种缓存操作  @Caching
     *      2、指定删除某个分区下的所有数据 @CacheEvict(value = "category", allEntries = true)
     *      3、存储同一类型的数据，都可以指定成同一个分区。分区名默认就是缓存的前缀
     * @param category
     */
    //@CacheEvict(value = "category", key = "'getLevel1Catagories'")
//    @Caching(evict = {
//            @CacheEvict(value = "category", key = "'getLevel1Catagories'"),
//            @CacheEvict(value = "category", key = "'getCatalogJson'")
//    })
    //category:key
    @CacheEvict(value = "category", allEntries = true)
    @Override
    @Transactional
    public void updateCascade(CategoryEntity category) {
        this.updateById(category);
        categoryBrandRelationService.updateCategory(category.getCatId(), category.getName());

        //同时修改缓存中的数据
        //redis.del("catalogJson");等待下次主动查询进行更新
    }

 

六、SpringCache 原理与不足

原理：
　　CacheManager（RedisCacheManager）——>Cache（RedisCache）——>Cache负责缓存的读写

（1）读模式
　　（a）缓存穿透：查询一个null数据。
　　　　解决方案：缓存空数据，可通过spring.cache.redis.cache-null-values=true
　　（b）缓存击穿：大量并发进来同时查询一个正好过期的数据。
　　　　解决方案：加锁 ? 默认是无加锁的;使用sync = true来解决击穿问题
　　（c）缓存雪崩：大量的key同时过期。
　　　　解决方案：加随机时间。加上过期时间：spring.cache.redis.time-to-live=3600000

（2）写模式
　　（a）读写加锁。 
　　（b）引入Canal，感知到MySQL的更新去更新Redis 
　　（c）读多写多，直接去数据库查询就行

（3）总结
　　常规数据（读多写少，即时性，一致性要求不高的数据，完全可以使用Spring-Cache）；写模式(只要缓存的数据有过期时间就足够了)
　　特殊数据：特殊设计