TheWe1

Appearance

多级缓存架构设计 ​

原理篇 ​

两级缓存 ​

使用本地缓存作为一级缓存，再加上远程缓存作为二级缓存的两级缓存架构。

在先不考虑并发等复杂问题的情况下，两级缓存的访问流程可以用下面这张图来表示：

image-20220407141201672

使用两级缓存相比单纯使用远程缓存，具有什么优势呢？

  • 本地缓存基于本地环境的内存，访问速度非常快，对于一些变更频率低、实时性要求低的数据，可以放在本地缓存中，提升访问速度
  • 使用本地缓存能够减少和Redis类的远程缓存间的数据交互，减少网络I/O开销，降低这一过程中在网络通信上的耗时

数据一致性问题。首先，两级缓存与数据库的数据要保持一致，一旦数据发生了修改，在修改数据库的同时，本地缓存、远程缓存应该同步更新。

分布式环境下，一级缓存之间也会存在一致性问题，当一个节点下的本地缓存修改后，需要通知其他节点也刷新本地缓存中的数据，否则会出现读取到过期数据的情况，这一问题可以通过类似于Redis中的发布/订阅功能解决。

应用篇 ​

双级缓存 ​

L1 Caffeine JVM 级别内存 ， L2 Redis 内存

目前大部分应用缓存都是基于 Spring Cache 实现,基于注释（annotation）的缓存（cache）技术,存在的问题如下：

  • Spring Cache 仅支持 单一的缓存来源，即：只能选择 Redis 实现或者 Caffeine 实现，并不能同时使用。
  • 数据一致性：各层缓存之间的数据一致性问题，如应用层缓存和分布式缓存之前的数据一致性问题。
  • 缓存过期：Spring Cache 不支持主动的过期策略

img

使用 ​
    1. 引入依赖
xml
<dependency>
    <groupId>com.open</groupId>
    <artifactId>multilevel-cache-starter</artifactId>
    <version>1.0</version>
</dependency>
<dependency>
    <groupId>com.open</groupId>
    <artifactId>multilevel-cache-starter</artifactId>
    <version>1.0</version>
</dependency>
    1. 开启缓存支持
java
@EnableCaching
public class App {
	public static void main(String[] args) {
		SpringApplication.run(App.class, args);
	}
}
@EnableCaching
public class App {
	public static void main(String[] args) {
		SpringApplication.run(App.class, args);
	}
}
    1. 目标接口声明 Spring Cache 注解
@Cacheable(value = "get",key = "#key")
@GetMapping("/get")
public String get(String key){
    return "success";
}
@Cacheable(value = "get",key = "#key")
@GetMapping("/get")
public String get(String key){
    return "success";
}
代码原理 ​
    1. 自定义 CacheManager 多级缓存实现
java
public class RedisCaffeineCacheManager implements CacheManager {

	@Override
	public Cache getCache(String name) {
		Cache cache = cacheMap.get(name);
		if (cache != null) {
			return cache;
		}
		cache = new RedisCaffeineCache(name, stringKeyRedisTemplate, caffeineCache(), cacheConfigProperties);
		Cache oldCache = cacheMap.putIfAbsent(name, cache);
		log.debug("create cache instance, the cache name is : {}", name);
		return oldCache == null ? cache : oldCache;
	}
}
public class RedisCaffeineCacheManager implements CacheManager {

	@Override
	public Cache getCache(String name) {
		Cache cache = cacheMap.get(name);
		if (cache != null) {
			return cache;
		}
		cache = new RedisCaffeineCache(name, stringKeyRedisTemplate, caffeineCache(), cacheConfigProperties);
		Cache oldCache = cacheMap.putIfAbsent(name, cache);
		log.debug("create cache instance, the cache name is : {}", name);
		return oldCache == null ? cache : oldCache;
	}
}
    1. 多级读取、过期策略实现
java
public class RedisCaffeineCache extends AbstractValueAdaptingCache {
	protected Object lookup(Object key) {
		Object cacheKey = getKey(key);

    // 1. 先调用 caffeine 查询是否存在指定的值
		Object value = caffeineCache.getIfPresent(key);
		if (value != null) {
			log.debug("get cache from caffeine, the key is : {}", cacheKey);
			return value;
		}

    // 2. 调用 redis 查询在指定的值
		value = stringKeyRedisTemplate.opsForValue().get(cacheKey);

		if (value != null) {
			log.debug("get cache from redis and put in caffeine, the key is : {}", cacheKey);
			caffeineCache.put(key, value);
		}
		return value;
	}
}
public class RedisCaffeineCache extends AbstractValueAdaptingCache {
	protected Object lookup(Object key) {
		Object cacheKey = getKey(key);

    // 1. 先调用 caffeine 查询是否存在指定的值
		Object value = caffeineCache.getIfPresent(key);
		if (value != null) {
			log.debug("get cache from caffeine, the key is : {}", cacheKey);
			return value;
		}

    // 2. 调用 redis 查询在指定的值
		value = stringKeyRedisTemplate.opsForValue().get(cacheKey);

		if (value != null) {
			log.debug("get cache from redis and put in caffeine, the key is : {}", cacheKey);
			caffeineCache.put(key, value);
		}
		return value;
	}
}
    1. 过期策略，所有更新操作都基于 redis pub/sub 消息机制更新
java
public class RedisCaffeineCache extends AbstractValueAdaptingCache {
	@Override
	public void put(Object key, Object value) {
		push(new CacheMessage(this.name, key));
	}

	@Override
	public ValueWrapper putIfAbsent(Object key, Object value) {
				push(new CacheMessage(this.name, key));
	}

	@Override
	public void evict(Object key) {
		push(new CacheMessage(this.name, key));
	}

	@Override
	public void clear() {
		push(new CacheMessage(this.name, null));
	}

	private void push(CacheMessage message) {
		stringKeyRedisTemplate.convertAndSend(topic, message);
	}
}
public class RedisCaffeineCache extends AbstractValueAdaptingCache {
	@Override
	public void put(Object key, Object value) {
		push(new CacheMessage(this.name, key));
	}

	@Override
	public ValueWrapper putIfAbsent(Object key, Object value) {
				push(new CacheMessage(this.name, key));
	}

	@Override
	public void evict(Object key) {
		push(new CacheMessage(this.name, key));
	}

	@Override
	public void clear() {
		push(new CacheMessage(this.name, null));
	}

	private void push(CacheMessage message) {
		stringKeyRedisTemplate.convertAndSend(topic, message);
	}
}
    1. MessageListener 删除指定 Caffeine 的指定值
java
public class CacheMessageListener implements MessageListener {

	private final RedisTemplate<Object, Object> redisTemplate;

	private final RedisCaffeineCacheManager redisCaffeineCacheManager;

	@Override
	public void onMessage(Message message, byte[] pattern) {
		CacheMessage cacheMessage = (CacheMessage) redisTemplate.getValueSerializer().deserialize(message.getBody());
				cacheMessage.getCacheName(), cacheMessage.getKey());
		redisCaffeineCacheManager.clearLocal(cacheMessage.getCacheName(), cacheMessage.getKey());
	}
}
public class CacheMessageListener implements MessageListener {

	private final RedisTemplate<Object, Object> redisTemplate;

	private final RedisCaffeineCacheManager redisCaffeineCacheManager;

	@Override
	public void onMessage(Message message, byte[] pattern) {
		CacheMessage cacheMessage = (CacheMessage) redisTemplate.getValueSerializer().deserialize(message.getBody());
				cacheMessage.getCacheName(), cacheMessage.getKey());
		redisCaffeineCacheManager.clearLocal(cacheMessage.getCacheName(), cacheMessage.getKey());
	}
}

Redis+Guava缓存架构 ​

高频数据流处理系统中，Redis 的压力也会很大，同时 I/O 开销才是耗时的主要原因，这时候为了降低 Redis 读写压力我们可以用到本地缓存，Guava 为我们提供了优秀的本地缓存 API，包含了过期策略等等

Redis 懒加载缓存 ​

数据在新增到 MySQL 不进行缓存，在精确查找进行缓存，做到查询即缓存，不查询不缓存。

image-20220617153307544

redis 结合本地缓存 ​

微服务场景下，多个微服务使用一个大缓存，流数据业务下，高频读取缓存对 Redis 压力很大，我们使用本地缓存结合 Redis 缓存使用，降低 Redis 压力，同时本地缓存没有连接开销，性能更优。

image-20220617153436403

java
/**
 * 本地缓存-guava 
 */
private Cache<String, Integer> localCache = CacheBuilder.newBuilder()
    .concurrencyLevel(16) // 并发级别
    .initialCapacity(1000) // 初始容量
    .maximumSize(10000) // 缓存最大长度
    .expireAfterAccess(1, TimeUnit.HOURS) // 缓存1小时没被使用就过期
    .build();
/**
 * 本地缓存-guava 
 */
private Cache<String, Integer> localCache = CacheBuilder.newBuilder()
    .concurrencyLevel(16) // 并发级别
    .initialCapacity(1000) // 初始容量
    .maximumSize(10000) // 缓存最大长度
    .expireAfterAccess(1, TimeUnit.HOURS) // 缓存1小时没被使用就过期
    .build();

优点如下：

  • redis 保证数据可持久，本地缓存保证超高的读取性能，微服务共用 redis 大缓存的场景能有效降低 redis 压力
  • guava 作为本地缓存，提供了丰富的 api，过期策略，最大容量，保证服务内存可控，冷数据不会长期占据内存空间
  • 服务重启导致的本地缓存清空不会影响业务进行
  • 微服务及分布式场景使用，分布式情况下每个服务实例只会缓存自己接入的那一部分设备的自增号，本地内存空间最优

缺点如下：

  • 增加编码复杂度，不直接
  • 只适用于缓存内容只增不改的场景

总结：

  • 本地缓存空间可控，过期策略优
  • 适用于微服务及分布式场景
  • 缓存内容不能发生改变
  • 性能优