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

2017-12-21  本文已影响0人  闲大赋

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

缓存概念

Cache 通常有如下组件构成

Spring Boot 缓存

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

    @Service
    public class MenuServiceImpl implements MenuService {
        
        @Cacheable("menu")
        public Menu getMenu(Long id) {...}
            
    }

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

集成Spring cache

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

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

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

spring.cache.type=Simple

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

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

@SpringBootApplication
@EnableCaching
public class Ch14Application {
  public static void main(String[] args) {
    SpringApplication.run(Ch14Application.class, args);
  }
}

实现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 缓存实现。

class TowLevelCacheManager extends RedisCacheManager {
    RedisTemplate redisTemplate;
    public TowLevelCacheManager(RedisTemplate redisTemplate,RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration) {
        super(cacheWriter,defaultCacheConfiguration);
        this.redisTemplate = redisTemplate;
    }
    //使用RedisAndLocalCache代替Spring Boot自带的RedisCache
    @Override
    protected Cache decorateCache(Cache cache) {
        return new RedisAndLocalCache(this, (RedisCache) cache);
    }

  public void publishMessage(String cacheName) {
    this.redisTemplate.convertAndSend(topicName, cacheName);
  }
  // 接受一个消息清空本地缓存
  public void receiver(String name) {
    RedisAndLocalCache cache = ((RedisAndLocalCache) this.getCache(name));
    if(cache!=null){
      cache.clearLocal();
    }
  }

}

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

创建RedisAndLocalCache

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

RedisAndLocalCache 的构造如下

class RedisAndLocalCache implements Cache {
  // 本地缓存提供
  ConcurrentHashMap<Object, Object> local = new ConcurrentHashMap<Object, Object>();
  RedisCache redisCache;
  TowLevelCacheManager cacheManager;

  public RedisAndLocalCache(TowLevelCacheManager cacheManager, RedisCache redisCache) {
    this.redisCache = redisCache;
    this.cacheManager = cacheManager;
  }

  @Override
  public String getName() {
    return redisCache.getName();
  }

  @Override
  public Object getNativeCache() {
    return redisCache.getNativeCache();
  }

  //其他get put evict方法参考后面代码到吗片段说明
}

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

@Override
public ValueWrapper get(Object key) {
  // 一级缓存先取
  ValueWrapper wrapper = (ValueWrapper) local.get(key);
  if (wrapper != null) {
    return wrapper;
  } else {
    // 二级缓存取
    wrapper = redisCache.get(key);
    if (wrapper != null) {
      local.put(key, wrapper);
    }
    return wrapper;
  }
}

@Override
public void put(Object key, Object value) {
  System.out.println(value.getClass().getClassLoader());
  redisCache.put(key, value);
  //通知其他节点缓存更新
  clearOtherJVM();
}
@Override
public void evict(Object key) {
  redisCache.evict(key);
  //通知其他节点缓存更新
  clearOtherJVM();
}
protected void clearOtherJVM() {
    cacheManager.publishMessage(redisCache.getName());
}
// 提供给CacheManager清空一节缓存
public void clearLocal() {
  this.local.clear();
}

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

put方法实现逻辑如下

缓存同步说明

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

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

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

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

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

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

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

将代码组合在一起

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

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

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

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

最后，本博客节选了我的书 <Spring Boot 2精髓：从构建小系统到架构分布式大系统>, 此例子可以直接从gitee上下载 https://gitee.com/xiandafu/Spring-Boot-2.0-Samples
欢迎反馈
我的博客即将搬运同步至腾讯云+社区，邀请大家一同入驻：https://cloud.tencent.com/developer/support-plan

上一篇 下一篇

猜你喜欢

热点阅读