SpringBoot 2，用200行代码完成一个一二级分布式缓存

缓存系统的用来代替直接访问数据库，用来提升系统性能，减小数据库负载。早期缓存跟系统在一个虚拟机里，这样内存访问，速度最快。后来应用系统水平扩展，缓存作为一个独立系统存在，如redis，但是每次从缓存获取数据，都还是要通过网络访问才能获取，效率相对于早先从内存里获取，还是不够逆天快。如果一个应用，比如传统的企业应用，一次页面显示，要访问数次redis，那效果就不是特别好，性能不够快不说，还容易使得Reids负载过高，Redis的主机出现各种物理故障。因此，现在有人提出了一二级缓存。即一级缓存跟系统在一个虚拟机内，这样速度最快。二级缓存位于redis里，当一级缓存没有数据的时候，再从redis里获取，并同步到一级缓存里。这跟CPU的一级缓存，二级缓存是一个道理。当然也面对同样的问题。

缓存概念

Cache 通常有如下组件构成

CacheManager，用来创建，管理，管理多个命名唯一的Cache。如可以有组织机构缓存，菜单项的缓存，菜单树的缓存等
Cache类似Map那样的Key—Value存储结构，Value部分通常包含了缓存的对象，通过Key来取得缓存对象
缓存项，存放在缓存里的对象，常常需要实现序列化接口，以支持分布式缓存。
Cache存储方式，缓存组件的可以将对象放到内存，也可以是其他缓存服务器，Spring Boot 提供了一个基于ConcurrentMap的缓存，同时也集成了Redis,EhCache 2.x,JCache缓存服务器等
缓存策略，通常Cache 还可以有不同的缓存策略，如设置缓存最大的容量，缓存项的过期时间等
分布式缓存，缓存通常按照缓存数据类型存放在不同缓存服务器上，或者同一类型的缓存，按照某种算法，不同key的数据放在不同的缓存服务器上。
Cache Hit，当从Cache中取得期望的缓存项，我们通常称之为缓存命中。如果没有命中我们称之为Cache Miss，意味着需要从数据来源处重新取出并放回Cache中
Cache Miss：缓存丢失，根据Key没有从缓存中找到对应的缓存项
Cache Evication：缓存清除操作。
Hot Data，热点数据，缓存系统能调整算法或者内部存储方式，使得将最有可能频繁访问的数据能尽快访问到。
On-Heap,Java分配对象都是在堆内存里，有最快的获取速度。由于虚拟机的垃圾回收管理，缓存放过多的对象会导致垃圾回收时间过长，从而有可能影响性能。
Off-Heap,堆外内存，对象存放到在虚拟机分配的堆外内存，因此不受垃圾回收管理的管理，不影响系统系统，但堆外内存的对象要被使用，还要序列化成堆内对象。很多缓存工具会把不常用的对象放到堆外，把热点数据放到堆内。

Spring Boot 缓存

Spring Boot 本身提供了一个基于ConcurrentHashMap 的缓存机制，也集成了EhCache2.x，JCache(JSR-107,EhCache3.x,Hazelcast,Infinispan),还有Couchbase，Redies等。Spring Boot应用通过注解的方式使用统一的使用缓存，只需在方法上使用缓存注解即可，其缓存的具体实现依赖于你选择的目标缓存管理器。如下使用@Cacheable

1    [@Service](https://my.oschina.net/service)
2    public class MenuServiceImpl implements MenuService {
3    	
4    	@Cacheable("menu")
5    	public Menu getMenu(Long id) {...}
6     		
7    }

MenuService实例作为一个容器管理bean，Spring将会生成代理类，在实际调用MenuService.getMenu方法前，会调用缓存管理器，取得名"menu"的缓存，此时，缓存的key就是方法参数id，如果缓存命中，则返回此值，如果没有找到，则进入实际的MenuService.getMenu方法，在返回调用结果给调用者之前，还会将此查询结果缓存以备下次使用。

集成Spring cache

集成Spring Cache，只需要在pom中使用如下依赖

1<dependency>
2  <groupId>org.springframework.boot</groupId>
3  <artifactId>spring-boot-starter-cache</artifactId>
4</dependency>

如果你使用Spring自带的内存的缓存管理器，需要在appliaction.properties里配置属性

spring.cache.type=Simple

Simple只适合单机应用或者开发环境使用或者是一个小微系统，通常你的应用是分布式应用，Spring Boot 还支持集成更多的缓存服务器。

simple: 基于ConcurrentHashMap实现的缓存，适合单机或者开发环境使用。
none：关闭缓存，比如开发阶段先确保功能正确，可以先禁止使用缓存
redis：使用redis作为缓存，你还需要在pom里增加redis依赖。本章缓存将重点介绍redis缓存以及扩展redis实现一二级缓存
Generic，用户自定义缓存实现，用户需要实现一个org.springframework.cache.CacheManager的实现
其他还有JCache，EhCache 2.x，Hazelcast等，为了保持本书的简单，将不在这里一一介绍。

最后，需要使用注解 @EnableCaching 打开缓存功能。

1@SpringBootApplication
2@EnableCaching
3public class Ch14Application {
4  public static void main(String[] args) {
5    SpringApplication.run(Ch14Application.class, args);
6  }
7}

实现Redis 俩级缓存

SpringBoot自带的Redis缓存非常容易使用，但由于通过网络访问了Redis，效率还是比传统的跟应用部署在一起的一级缓存略慢。本章中，扩展RedisCacheManager和RedisCache，在访问Redis之前，先访问一个ConcurrentHashMap实现的简单一级缓存，如果有缓存项，则返回给应用，如果没有，再从Redis里取，并将缓存对象放到一级缓存里

当缓存项发生变化的时候，注解@CachePut 和 @CacheEvict会触发RedisCache的put( Object key, Object value)和evict(Object key)操作，俩级缓存需要同时更新ConcurrentHashMap和Redis缓存，且需要通过Redis的Pub发出通知消息，其他Spring Boot应用通过Sub来接收消息，同步更新Spring Boot应用自身的一级缓存。

为了简单起见，一级缓并没有缓存过期策略，用户系统如果会有大量数据需要放到一级缓存，需要再次扩展这里的代码，比如使用LRUHashMap代替Map

实现 TowLevelCacheManager

首先，创建创建一个新的缓存管理器，命名为TowLevelCacheManager，继承了Spring Boot的RedisCacheManager，重载decorateCache方法。返回的是我们新创建的LocalAndRedisCache 缓存实现。

1class TowLevelCacheManager extends RedisCacheManager {
2	RedisTemplate redisTemplate;
3	public TowLevelCacheManager(RedisTemplate redisTemplate,RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration) {
4		super(cacheWriter,defaultCacheConfiguration);
5		this.redisTemplate = redisTemplate;
6	}
7	//使用RedisAndLocalCache代替Spring Boot自带的RedisCache
8	@Override
9	protected Cache decorateCache(Cache cache) {
10		return new RedisAndLocalCache(this, (RedisCache) cache);
11	}
12
13  public void publishMessage(String cacheName) {
14    this.redisTemplate.convertAndSend(topicName, cacheName);
15  }
16  // 接受一个消息清空本地缓存
17  public void receiver(String name) {
18    RedisAndLocalCache cache = ((RedisAndLocalCache) this.getCache(name));
19    if(cache!=null){
20      cache.clearLocal();
21    }
22  }
23
24}

在Spring Cache中，在缓存管理器创建好每个缓存后，都会调用decorateCache方法，这样缓存管理器子类有机会实现自己的扩展，在这段代码，返回了自定义的RedisAndLocalCache实现。 publishMessage方法提供个给Cache，用于当缓存更新的时候，使用Redis的消息机制通知其他分布式节点的一级别缓存。receiver方法对应于publishMessage方法，当收到消息后，会清空一节缓存。

创建RedisAndLocalCache

RedisAndLocalCache 是我们系统的核心，他实现了Cache接口，类，会实现如下操作。

get操作，通过Key取对应的缓存项，在调用父类RedisCache之前，会先检测本地缓存是否存在，存在则不需要调用父类的get操作。如果不存在，调用父类的get操作后，将Redis返回的ValueWrapper放到本地缓存里待下次用。
put，调用父类put操作更新Redis缓存，同时广播消息，缓存改变。我们将在下一章讲如何使用Redis的Pub/Subscribe 来同步缓存
evict ，同put操作一样，调用父类处理，清空对应的缓存，同时广播消息
putIfAbsent，同put操作一样，调用父类实现，同时广播消息

RedisAndLocalCache 的构造如下

1class RedisAndLocalCache implements Cache {
2  // 本地缓存提供
3  ConcurrentHashMap<Object, Object> local = new ConcurrentHashMap<Object, Object>();
4  RedisCache redisCache;
5  TowLevelCacheManager cacheManager;
6
7  public RedisAndLocalCache(TowLevelCacheManager cacheManager, RedisCache redisCache) {
8    this.redisCache = redisCache;
9    this.cacheManager = cacheManager;
10  }
11
12  @Override
13  public String getName() {
14    return redisCache.getName();
15  }
16
17  @Override
18  public Object getNativeCache() {
19    return redisCache.getNativeCache();
20  }
21
22  //其他get put evict方法参考后面代码到吗片段说明
23}

如上代码所示，RedisAndLocalCache 实现了Cache接口，并使用了真正的RedisCache作为其实现方法。其关键的get和put方法如下

1@Override
2public ValueWrapper get(Object key) {
3  // 一级缓存先取
4  ValueWrapper wrapper = (ValueWrapper) local.get(key);
5  if (wrapper != null) {
6    return wrapper;
7  } else {
8    // 二级缓存取
9    wrapper = redisCache.get(key);
10    if (wrapper != null) {
11      local.put(key, wrapper);
12    }
13    return wrapper;
14  }
15}
16
17@Override
18public void put(Object key, Object value) {
19  System.out.println(value.getClass().getClassLoader());
20  redisCache.put(key, value);
21  //通知其他节点缓存更新
22  clearOtherJVM();
23}
24@Override
25public void evict(Object key) {
26  redisCache.evict(key);
27  //通知其他节点缓存更新
28  clearOtherJVM();
29}
30protected void clearOtherJVM() {
31	cacheManager.publishMessage(redisCache.getName());
32}
33// 提供给CacheManager清空一节缓存
34public void clearLocal() {
35  this.local.clear();
36}

变量local代表了一个简单的缓存实现，使用了ConcurrentHashMap。其get方法有如下逻辑实现

通过key从本地取出 ValueWrapper
如果ValueWrapper存在，则直接返回
如果ValueWrapper不存在，则调用父类RedisCache取得缓存项
如果缓存项为空，则说明暂时无此项，直接返回空，等@Cacheable 调用业务方法获取缓存项

put方法实现逻辑如下

先调用redisCache，更新二级缓存
调用clearOtherJVM方法，通知其他节点缓存更新
其他节点（包括本节点)的TowLevelCacheManager收到消息后，会调用receiver方法从而实现一级缓存
为了简单起见，一级缓存的同步更新仅仅是清空一级缓存而并非采用同步更新缓存项。一级缓存将在下一次get方法调用时会再次从Reids里加载最新数据。
一节缓存仅仅简单使用了Map实现，并未实现缓存的多种策略。因此，如果你的一级缓存如果需要各种缓存策略，还需要用一些第三方库或者自行实现，但大部分情况下TowLevelCacheManager都足够使用

缓存同步说明

当缓存发生改变的时候，需要通知分布式系统的TowLevelCacheManager的，清空一级缓存.这里使用Redis实现消息通知，关于Redis消息发布和订阅，参考Redis一章。

为了实现Redis的Pub/Sub 模式，我们需要在CacheConfig里添加一些代码，创建一个消息监听器

1//定义一个redis 的频道，默认叫cache，用于pub/sub
2@Value("${springext.cache.redis.topic:cache}")
3String topicName;
4@Bean
5RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
6                                        MessageListenerAdapter listenerAdapter) {
7  RedisMessageListenerContainer container = new RedisMessageListenerContainer();
8  container.setConnectionFactory(connectionFactory);
9  container.addMessageListener(listenerAdapter, new PatternTopic(topicName));
10  return container;
11}

如上所示，需要配置文件配置 springext.cache.redis.topic，指定一个频道的名字，如果没有配置，默认的频道名称是cache。

配置一个监听器很简单，只需要实现MessageListenerAdapter，并注册到RedisMessageListenerContainer即可。

MessageListenerAdapter 需要实现onMessage方法，我们只需要获取消息内容，这里是指要清空的缓存名字，然后交给MyRedisCacheManager 来处理即可

1@Bean
2MessageListenerAdapter listenerAdapter(final TowLevelCacheManager cacheManager) {
3  return new MessageListenerAdapter(new MessageListener() {
4    public void onMessage(Message message, byte[] pattern) {
5      byte[] bs = message.getChannel();
6      try {
7        //Sub 一个消息，通知缓存管理器，这里的type就是Cache的名字
8        String type = new String(bs, "UTF-8");
9        cacheManager.receiver(type);
10      } catch (UnsupportedEncodingException e) {
11        e.printStackTrace();
12        // 不可能出错，忽略
13      }
14    }
15  });
16}

将代码组合在一起

前三节分别实现了缓存管理器，缓存，还有缓存之间的同步，现在需要将缓存管理器配置为应用的缓存管理器，通过搭配@Configuration和@Bean实现

1@Configuration
2public class CacheConfig {
3  @Bean
4  public TowLevelCacheManager cacheManager(RedisTemplate redisTemplate) {
5    //RedisCache需要一个RedisCacheWriter来实现读写Redis
6    RedisCacheWriter writer = RedisCacheWriter.lockingRedisCacheWriter(redisTemplate.getConnectionFactory());
7    /*SerializationPair用于Java和Redis之间的序列化和反序列化，我们这里使用自带的JdkSerializationRedisSerializer,并在反序列化过程中，使用当前的ClassLoader*/
8    SerializationPair pair = SerializationPair.fromSerializer(new JdkSerializationRedisSerializer(this.getClass().getClassLoader()));
9    /*构造一个RedisCache的配置，比如是否使用前缀，比如Key和Value的序列化机制（*/
10    RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(pair);
11	/*创建CacheManager，并返回给Spring 容器*/
12    TowLevelCacheManager cacheManager = new TowLevelCacheManager(redisTemplate,writer,config);
13    return cacheManager;
14  }
15}

构造一个TowLevelCacheManager较为复杂，这是因为构造RedisCacheManager复杂导致的，构造RedisCacheManager需要如下俩个参数

RedisCacheWriter，一个实现Redis操作的接口，SpringBoot提供了NoLock和Lock俩种实现，在缓存写操作的时候，前者有较高性能，而后者实现了Redis锁。
RedisCacheConfiguration 用于设置缓存特性，比如缓存项目的TTL(存活时间)，缓存Key的前缀等，默认情况是TTL为0，不使用前缀。你可以为缓存管理器设置默认的配置，也可以为每一个缓存设置一个配置。最为重要的配置是SerializationPair，用于Java和Redis的序列化和反序列化操作，这里我们使用我们这里使用自带的JdkSerializationRedisSerializer作为序列化机制，这个类在Reids一章有详细介绍。

如上代码实现了一二级缓存，行数不到200行代码。相对于自带的RedisCache来说，缓存效率更高。相对于专业的一二级缓存服务器来说，如Ehcache+Terracotta组合，更加轻量级

最后，本博客节选了我的书 <Spring Boot 2精髓：从构建小系统到架构分布式大系统>, 此例子可以直接从gitee上下载 https://gitee.com/xiandafu/Spring-Boot-2.0-Samples 欢迎反馈