Guava+zookeeper的集群本地缓存小实践

最新推荐文章于 2024-07-05 23:28:59 发布
置顶 最新推荐文章于 2024-07-05 23:28:59 发布
阅读量2.4k 收藏 4
点赞数 2
分类专栏： 个人实践 文章标签： 本地缓存 guava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laoxilaoxi_/article/details/82898090
版权

目录

零、依赖

一、结构

二、逻辑

三、代码实现

四、使用

五、问题

六、其他

零、依赖

<dependency>

    <groupId>com.google.guava</groupId>

    <artifactId>guava</artifactId>

    <version>20.0</version>

</dependency>

<dependency>

    <groupId>org.apache.curator</groupId>

    <artifactId>curator-recipes</artifactId>

    <version>4.0.1</version>

</dependency>

<dependency>

    <groupId>org.apache.zookeeper</groupId>

    <artifactId>zookeeper</artifactId>

    <version>3.4.12</version>

</dependency>

 

一、结构

二、逻辑

1.采用guava做本地缓存服务

2.采用zookeeper做集群缓存通知

流程：

    ①修改、删除数据

    ②读取数据（未命中缓存如下图，命中则直接返回）

 

三、代码实现

/***************本地缓存*******************/
public class LocalCacheUtil{

    private static Map<String, Cache> cacheMap = new ConcurrentHashMap<>();

    private static ZkClient zkClient = new ZkClient("config/cacheZkConfig.properties");

    /**
     * 获取缓存内容
     * @param group 分组
     * @param key key
     * @return 缓存对象
     */
    public static Object get(String group, String key){
        PathUtil.check(group,"group");
        PathUtil.check(key,"key");
        Cache cache = cacheMap.get(group);
        if(cache == null){
            return null;
        }
        return cache.getIfPresent(key);
    }

    /**
     * 写缓存
     * @param group 分组
     * @param key key
     * @param val 值
     * @param expire 过期时间，不支持动态传入
     */
    public static void put(String group,String key,Object val,Long expire){
        PathUtil.check(group,"group");
        PathUtil.check(key,"key");
        Cache cache = getCache(group,expire);
        cache.put(key,val);
        zkClient.setWatcher(group, key, LocalCacheWatcher.getInstance());
    }

    /**
     * 删除缓存
     * @param group 分组
     * @param key key
     */
    public static void remove(String group,String key){
        PathUtil.check(group,"group");
        PathUtil.check(key,"key");
        Cache cache = cacheMap.get(group);
        if(cache != null){
            cache.invalidate(key);
        }
        zkClient.delete(group,key);
    }

    static void removeLocal(String group, String key){
        PathUtil.check(group,"group");
        PathUtil.check(key,"key");
        Cache cache = cacheMap.get(group);
        if(cache != null){
            cache.invalidate(key);
        }
    }

    static void removeAll(){
        for (String group : cacheMap.keySet()) {
            Cache cache = cacheMap.get(group);
            if(cache != null){
                cache.invalidateAll();
            }
        }
    }

    /**
     * 获取cache
     * @param group 分组
     * @param expire 超时时间
     * @return cache
     */
    private static Cache getCache(String group, Long expire){
        Cache cache = cacheMap.get(group);
        if(cache == null){
            cache = CacheBuilder.newBuilder()
                    .maximumSize(2000)
                    .expireAfterWrite(expire, TimeUnit.MINUTES)
                    .build();
            cacheMap.put(group,cache);
        }
        return cache;
    }
}


/***************回调*******************/
public class LocalCacheWatcher implements CuratorWatcher {

    private static final Logger LOGGER = LoggerFactory.getLogger(LocalCacheWatcher.class);

    static LocalCacheWatcher getInstance(){
        return LocalCacheWatcherInstance.LOCAL_CACHE_WATCHER;
    }

    @Override
    public void process(WatchedEvent event) {
        LOGGER.info("收到监听事件："+event.toString());
        //空事件不处理，只做监控
        if(Watcher.Event.EventType.None.equals(event.getType())){
            if(Watcher.Event.KeeperState.Expired.equals(event.getState())){
                LOGGER.info("清理全部缓存...");
                LocalCacheUtil.removeAll();
            }
            return;
        }
        String path = event.getPath();
        String[] pathSplit = PathUtil.splitPath(path);
        LOGGER.info("GROUP = "+pathSplit[1]+",KEY = "+pathSplit[2]);
        LocalCacheUtil.removeLocal(pathSplit[1],pathSplit[2]);
    }

    private static class LocalCacheWatcherInstance{
        private static final LocalCacheWatcher LOCAL_CACHE_WATCHER = new LocalCacheWatcher();
    }
}

/***************zookeeper 处理类*******************/
public class ZkClient {

    private static final Logger LOGGER = LoggerFactory.getLogger(ZkClient.class);
    /**
     * zk客户端
     */
    private CuratorFramework cf;

    private String appPath;

    ZkClient(String path) {
        ZkConfig zkConfig = loadConfig(path);
        init(zkConfig);
    }

    public ZkClient(ZkConfig config) {
        init(config);
    }

    /**
     * zk初始化方法
     */
    private void init(ZkConfig zkConfig){
        LOGGER.info("ZkClientUtil init start...");
        cf = CuratorFrameworkFactory.builder()
                .connectString(zkConfig.getConnectString())
                .sessionTimeoutMs(zkConfig.getSessionTimeoutMs())
                .connectionTimeoutMs(zkConfig.getConnectionTimeoutMs())
                .retryPolicy(new ExponentialBackoffRetry(
                        zkConfig.getBaseSleepTimeMs(),
                        zkConfig.getMaxRetries()))
                .namespace(zkConfig.getNamespace())
                .build();
        cf.start();
        appPath = zkConfig.getAppPath();
        LOGGER.info("ZkClientUtil init complete...");
    }

    /**
     * 设置watcher
     * @param group 分组
     * @param key key
     * @param curatorWatcher watcher回调
     */
    void setWatcher(String group, String key, CuratorWatcher curatorWatcher)  {

        String path = PathUtil.getPath(appPath,group,key);
        try {
            Stat stat = cf.checkExists().forPath(path);
            if(stat == null){
                cf.create().creatingParentsIfNeeded().forPath(path);
            }
            cf.checkExists().usingWatcher(curatorWatcher).forPath(path);
        } catch (Exception e) {
            LOGGER.error("set watcher fail, path:"+path+":"+e.getMessage());
        }
    }

    /**
     *  删除节点
     * @param group 分组
     * @param key key
     */
    void delete(String group, String key){
        String path = PathUtil.getPath(appPath,group,key);
        try {
            Stat stat = cf.checkExists().forPath(path);
            if(stat != null){
                cf.delete().guaranteed().forPath(path);
            }

        } catch (Exception e) {
            LOGGER.error("delete zNode fail, path:"+path+":"+e.getMessage());
        }
    }

    private ZkConfig loadConfig(String path){
        LOGGER.info("ZkClient start load properties start :"+path);
        Properties properties = new Properties();
        // 使用ClassLoader加载properties配置文件生成对应的输入流
        InputStream in = ZkClient.class.getClassLoader().getResourceAsStream(path);
        // 使用properties对象加载输入流
        try {
            properties.load(in);
            LOGGER.info("ZkClient load properties finish :"+path);
        }catch (IOException e){
            throw new RuntimeException("ZkClient load properties fail :"+path,e);
        }
        ZkConfig zkConfig = new ZkConfig();
        zkConfig.setConnectString(properties.getProperty("connectString"));
        zkConfig.setSessionTimeoutMs(properties.getProperty("sessionTimeoutMs"));
        zkConfig.setConnectionTimeoutMs(properties.getProperty("connectionTimeoutMs"));
        zkConfig.setBaseSleepTimeMs(properties.getProperty("baseSleepTimeMs"));
        zkConfig.setMaxRetries(properties.getProperty("maxRetries"));
        zkConfig.setAppPath(properties.getProperty("appPath"));
        zkConfig.setNamespace(properties.getProperty("namespace"));
        return zkConfig;
    }
}

/*************ZkConfig zk配置类**************/
public class ZkConfig {
    /**
     * 连接地址，多个地址用“,”间隔
     * 例如：localhost:2181,localhost1:2181
     */
    private String connectString;
    /**
     * session超时时间，单位ms
     */
    private int sessionTimeoutMs = 5000;
    /**
     * 连接超时时间，单位ms
     */
    private int connectionTimeoutMs = 5000;
    /**
     * 重试机制，间隔时间
     */
    private int baseSleepTimeMs = 100;
    /**
     * 重试机制，重试次数
     */
    private int maxRetries = 5;
    /**
     * 应用路径，用于隔离znood路径
     */
    private String appPath = "defaultAppPath";
    /**
     * namespace，用于区分zk用途
     */
    private String namespace;

    public String getConnectString() {
        return connectString;
    }

    public void setConnectString(String connectString) {
        if(connectString == null || "".equals(connectString.trim())){
            throw new RuntimeException("load properties fail，connectString must spacial!!!");
        }
        this.connectString = connectString;
    }

    public int getSessionTimeoutMs() {
        return sessionTimeoutMs;
    }

    public void setSessionTimeoutMs(String sessionTimeoutMs) {
        if(sessionTimeoutMs != null && !"".equals(sessionTimeoutMs.trim())){
            this.sessionTimeoutMs = Integer.valueOf(sessionTimeoutMs);
        }
    }

    public void setSessionTimeoutMs(int sessionTimeoutMs) {
        this.sessionTimeoutMs = sessionTimeoutMs;
    }

    public int getConnectionTimeoutMs() {
        return connectionTimeoutMs;
    }

    public void setConnectionTimeoutMs(String connectionTimeoutMs) {
        if(connectionTimeoutMs != null && !"".equals(connectionTimeoutMs.trim())){
            this.connectionTimeoutMs = Integer.valueOf(connectionTimeoutMs);
        }
    }

    public void setConnectionTimeoutMs(int connectionTimeoutMs) {
        this.connectionTimeoutMs = connectionTimeoutMs;
    }

    public int getBaseSleepTimeMs() {
        return baseSleepTimeMs;
    }

    public void setBaseSleepTimeMs(String baseSleepTimeMs) {
        if(baseSleepTimeMs != null && !"".equals(baseSleepTimeMs.trim())){
            this.baseSleepTimeMs = Integer.valueOf(baseSleepTimeMs);
        }
    }

    public void setBaseSleepTimeMs(int baseSleepTimeMs) {
        this.baseSleepTimeMs = baseSleepTimeMs;
    }

    public int getMaxRetries() {
        return maxRetries;
    }

    public void setMaxRetries(String maxRetries) {
        if(maxRetries != null && !"".equals(maxRetries.trim())){
            this.maxRetries = Integer.valueOf(maxRetries);
        }
    }

    public void setMaxRetries(int maxRetries) {
        this.maxRetries = maxRetries;
    }

    public String getAppPath() {
        return appPath;
    }

    public void setAppPath(String appPath) {
        if(appPath != null && !"".equals(appPath.trim())){
            this.appPath = appPath;
        }
    }

    public String getNamespace() {
        return namespace;
    }

    public void setNamespace(String namespace) {
        this.namespace = namespace;
    }
}

/*************PathUtil zk路径校验类*************/
class PathUtil {

    private static final String PATH_SPLIT_CHAR = "/";

    private static final String PATH_SPLIT_CHAR1 = "\\";

    static String getPath(String... strs){
        StringBuilder stringBuilder = new StringBuilder();
        for (String str : strs) {
            stringBuilder.append(PATH_SPLIT_CHAR).append(str.trim());
        }
        return stringBuilder.toString();
    }

    static String[] splitPath(String path){
        path = path.substring(1);
        return path.split(PATH_SPLIT_CHAR);
    }

    static void check(String src, String name){
        if(src == null || "".equals(src.trim())){
            throw new RuntimeException(name +" not empty!");
        }
        //判断“/”,"\"，因为zk是路径
        if(src.contains(PATH_SPLIT_CHAR) || src.contains(PATH_SPLIT_CHAR1)){
            throw new RuntimeException(name +" can not contains \"/\" and \"\\\"!");
        }
    }
}

 

四、使用

public class LocalCacheTest {
    //模拟数据库
    private static final Map<String,Map<String,String>> db = new ConcurrentHashMap<>();
    //模拟数据库数据
    static{
        Map<String,String> map = new HashMap();
        map.put("uId","1001");
        map.put("name","name_"+"1001");
        db.put("1001",map);
    }


    public static void main(String[] args) throws InterruptedException {
        //设置配置
        ZkConfig cacheZkConfig = new ZkConfig();
        cacheZkConfig.setConnectString("localhost:2181");
        //初始化zk
        ZkClientUtil.init(cacheZkConfig);

        //1.测试读取缓存
        for (int i = 0 ;i<=1 ;i++) {
            System.out.println(findUser("1001"));
        }
        //2.测试缓存失效
//        Thread.sleep(60000);
        System.out.println("--------------");
        System.out.println("过期后查询："+findUser("1001"));
        //3.测试缓存移除
        updateUser("1001","name_2");
        System.out.println("更新后查询："+findUser("1001"));
        //4.测试缓存移除
        deleteUser("1001");
        System.out.println("删除后查询："+findUser("1001"));
    }

    /**
     * 读取缓存测试
     * @param uId
     * @return
     */
    private static Map<String,String> findUser(String uId){
        String group = "user";
        Object o = LocalCacheUtil.get(group,uId);
        if(o != null){
            System.out.println("------->缓存命中，key："+uId);
            return (Map<String,String>) o;
        }
        System.out.println("------->缓存未命中，key："+uId);
        Map<String,String> user = db.get(uId);
        if(user != null){
            System.out.println("------->放缓存，key："+uId);
            LocalCacheUtil.put(group,uId,user,1L);
        }
        return user;
    }

    private static void updateUser(String uId,String name){
        String group = "user";
        Map<String,String> user = findUser(uId);
        if(user == null){
            throw new RuntimeException("user not exist,uId:"+uId);
        }
        System.out.println("------->删除缓存，key："+uId);
        LocalCacheUtil.remove(group,uId);
        user.put("name",name);
        db.put(uId,user);
        //如果担心此期间其他请求刷新缓存，可以在db修改后再remove一次缓存（缓存双淘汰）
    }

    private static void deleteUser(String uId){
        String group = "user";
        Map<String,String> user = findUser(uId);
        if(user == null){
            //不存在直接认为成功
            return;
        }
        System.out.println("------->删除缓存，key："+uId);
        LocalCacheUtil.remove(group,uId);
        db.remove(uId);
        //如果担心此期间其他请求刷新缓存，可以在db删除后再remove一次缓存（缓存双淘汰）
    }

}

五、问题

1.集群同步机制依赖于zookeeper，zk的建立连接是异步的，连不上也能启动，会影响集群通知

2.基于aop注解的没写

六、其他

一次简单的尝试，欢迎讨（来）论（喷），邮箱地址laoxilaoxi@foxmail.com

laoxilaoxi_
关注
专栏目录
【项目实战】主流的分布式锁服务解决方案介绍（Zookeeper，Curator，Redis，Lock，Guava，Chubby）
本本本添哥
07-21 663
Zookeeper分布式锁服务是一种基于Zookeeper的分布式锁实现。Zookeeper是一个分布式协调服务，提供分布式锁服务。setnx命令是一个原子操作命令，可以用来设置一个键的值，如果键已经存在，则返回0；如果键不存在，则设置键的值并返回1。在分布式锁的服务中，我们可以使用setnx命令来尝试获取锁。如果返回值为1，说明获取锁成功；如果返回值为0，说明锁已经被其他进程或线程获取了，需要继续等待。expire指令可以设置键的过期时间，让Redis在指定时间后自动删除这个键。
Guava cache
鸟哥哥的专栏
01-12 3760
Guava cache,一个小巧的本地缓存使用详解
分布式系统缓存系列之guava cache
weixin_30242907的博客
07-22 804
guava是google的一个开源java框架，其github地址是 https://github.com/google/guava。guava工程包含了若干被Google的 Java项目广泛依赖的核心库，例如：集合 [collections] 、缓存 [caching] 、原生类型支持 [primitives support] 、并发库 [concurrency librari...
分布式限流01介绍 guava nginx
最新发布
存在,即合理
07-05 163
我们把水比作是请求，漏桶比作是系统处理能力极限，水先进入到漏桶里，漏桶里的水按一定速率流出，当流出的速率小于流入的速率时，由于漏桶容量有限，后续进入的水直接溢出（拒绝请求），以此实现限流。
本地缓存同步的一个简单方案
霍力强的专栏
10-11 2500
现在大部分系统使用的都是分布式缓存系统Redis。 但在一些场景下，比如缓存单元很大，单元数不多，变化很小，加载时间很长，如算法模型。 这个时候使用本地缓存比Redis的效率要高很多，但是又要保证集群中各个机器的缓存的一致性，不然就会出现请求耗时不稳定的情况，也有可能出现相同的请求不同服务器返回的结果不一致。 本文介绍了一个简单的实现集群中同步各服务器本地缓存的方案。 实现思路： 集群各个...
本地缓存
wanf425的专栏
07-07 4751
经过前面两篇文章的介绍，我们知道了缓存的重要性以及分布式系统的基础概念，接下来我们就要开始正式学习一些主流的缓存系统。 首先来简单了解缓存系统的分类，缓存系统按照缓存数据的存储方式可以分为本地缓存和集中式缓存两种。 本地缓存：缓存数据保存在单个应用服务器中，各个应用服务器之间的缓存数据是独立的。 集中式缓存：缓存数据保存在专门的缓存服务器中，应用服务器通过网络请求从缓存服务器获...
分布式情况下本地缓存同步方案
weixin_43831204的博客
08-27 4018
两级缓存数据数据不一致性问题 伪代码: @Scheduled(cron = "0 0/3 * * * ? ") public void cacheRoom() { Long start = System.currentTimeMillis(); log.info("Cache room data, execute start :{}", start); RLock lock = redissonClusterClient.getLock(Lo
带你吃透（Netty+Redis+ZooKeeper+高并发实战）从底层原理开始剖析
weixin_62421895的博客
08-20 1198
今天给大家分享的Netty+Redis+ZooKeeper底层原理+高并发实战，希望大家认真阅读，跟上文章的节奏，一步步去提升自己~大公司的面试题从某个侧面映射出生产场景中对专项技术的要求。高并发的面试题以前基本是BAT等大公司的专利，现在几乎蔓延至与Java项目相关的整个行业。例如，与Java NIO、Reactor模式、 高性能通信、分布式锁、分布式ID、分布式缓存、高并发架构等技术相关的面试题。
基于Zookeeper和guava动态限流 源码
07-25
Zookeeper提供了一种简单易用的接口，用于管理分布式环境中的命名服务、配置管理、集群同步、分布式锁等功能。它采用了类似于文件系统的数据结构，使得数据管理和访问变得简单直观。 Guava是Google推出的一系列Java...
curator_zookeeper需要的jar
03-01
4. `curator-test-2.8.0.jar`：这是一个测试库，包含了一些用于单元测试和集成测试的工具，如模拟Zookeeper服务器的`MockZooKeeper`和`TestingServer`，帮助开发者在没有真实Zookeeper集群的情况下进行测试。...
分布式接口幂等性、分布式限流：Guava 、nginx和lua限流
m0_67322837的博客
09-01 306
算法是死的，人是活的，先进的生产力来自于不断的创造，在技术领域尤其如此。举个最简单的例子，那就是支付，用户购买商品后支付，支付扣款成功，但是返回结果的时候网络异常，此时钱已经扣了，用户再次点击按钮，此时会进行第二次扣款，返回结果成功，用户查询余额返发现多扣钱了，流水记录也变成了两条,这就没有保证接口的幂等性。通过版本号的方式，来控制update的操作的幂等性，用户查询出要修改的数据，系统将数据返回给页面，将数据版本号放入隐藏域，用户修改数据，点击提交，将版本号一同提交给后台，后台使用版本号作为更新条件。
聊聊在集群环境中本地缓存如何进行同步
kingwinstar的博客
08-15 1918
之前有发过一篇文章聊聊如何利用redis实现多级缓存同步。有个读者就给我留言说，因为他项目的redis版本不是6.0+版本，因此他使用我文章介绍通过MQ来实现本地缓存同步，他的同步流程大概如下图他原来的业务流程是每天凌晨开启定时器去爬取第三方的数据，并持久化到redis，后边因为redis发生过宕机事故，他碰巧看了我文章，就觉得可以用使用多级缓存的策略，用来做个兜底。
分布式环境下，同步服务本地缓存
小小程序员的专栏
06-18 749
分布式环境下，同步服务本地缓存
java zk监听异步_zookeeper实现项目初始化缓存以及同步监听
weixin_30995429的博客
02-26 236
packagecom.blog.cas.common.dic;importcom.alibaba.fastjson.JSON;importcom.alibaba.fastjson.JSONObject;importcom.blog.cas.common.constants.Constants;importcom.blog.cas.common.utils.BeanFactoryUtils;impo...
Canal数据同步策略
Leon_Jinhai_Sun的博客
11-22 987
缓存数据同步的常见方式有三种： 设置有效期：给缓存设置有效期，到期后自动删除。再次查询时更新 优势：简单、方便 缺点：时效性差，缓存过期之前可能不一致 场景：更新频率较低，时效性要求低的业务 同步双写：在修改数据库的同时，直接修改缓存 优势：时效性强，缓存与数据库强一致 缺点：有代码侵入，耦合度高； 场景：对一致性、时效性要求较高的缓存数据 异步通知：修改数据库时发送事件通知，相关服务监听到通知后修改缓存数据 优势：低耦合，可以同时通知多个
使用Guava作为本地缓存让系统飞起来
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
12-03 312
简介 guava是google的一个开源java框架，其github地址是 https://github.com/google/guava。guava工程包含了若干被Google的Java项目广泛依赖的核心库，例如： 集合 [collections] 缓存 [caching] 原生类型支持 [primitives support] 并发库 [concurrency libraries] 通用注解...
flume系列之：基于zookeeper部署flume agent升级guava和curator版本
zhengzaifeidelushang的博客
09-01 699
flume系列之：基于zookeeper部署flume agent升级guava和curator版本
Guava 缓存读后总结
laoxilaoxi_的博客
06-21 863
目录 零、说明 一、初始化 二、缓存回收机制 四、其他说明 Cache API（偷懒一下） 零、说明 Guava - cache是​​一个本地缓存，读了一些源码和文档在此总结一下。 先来个上手例子（学习官网套路） LoadingCache<Key, Object> loadingCache = CacheBuilder.newBuilder() ...
服务大量配置信息使用ZOOKEEPER和jvm 缓存实现
zhangxihangzhuan的专栏
05-11 579
设置更改配置信息写入zookeeper，同时通知各个客户端更新配置信息到jvm 缓存。获取配置信息从jvm缓存获取。一：pom 依赖&lt;dependency&gt; &lt;groupId&gt;org.apache.curator&lt;/groupId&gt; &lt;artifactId&gt;curator-recipes&lt;/artifactId&gt; ...
企业项目开发：Guava Cache 本地缓存实践
第七章企业项目开发深入探讨了本地缓存技术，特别是使用Guava Cache在实际项目中的应用。在现代软件开发中，缓存技术是提高系统性能的关键组件，特别是在处理大量数据或频繁查询时，通过存储常用数据在内存中，能够...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值