javacoo
javacoo

一个简单实用的函数式缓存工具类

一个简单实用的函数式缓存工具类：封装了基本的缓存增删查操作，提供了热点数据集中失效和缓存穿透的统一解决方案，以及在此基础上的开发模型。

背景介绍

日常开发中缓存使用越来越普遍而问题也接憧而至，首先是开发方式的繁琐：查询缓存->有就直接返回，没有就查询数据库或者调用其他服务获取，再保存至缓存中...如：

    /**
     * 获取渠道下，字段值
     * 
  • 
     * @param channelNo: 渠道
     * @param field: 字段
     * @return: java.lang.String 值
     */
    private String getChannelConfigFieldValue(String channelNo,String field){
        ....
          //从缓存获取
            String key = StringUtils.join(CHANNEL_CONFIG_KEY_PREFIX,channelNo);
            String result = RedisUtils.get(key);
            JSONObject jsonObject;
            if(StringUtils.isNotBlank(result)){
                jsonObject = JSON.parseObject(result);
            }else{
                //加载并缓存数据
                jsonObject = loadAndCacheChannelConfigInfo(channelNo);
            }
       ....
    }
    /**
     * 加载并缓存渠道配置信息
     * 
  • 
     * @param channelNo: 渠道号
     * @return: com.alibaba.fastjson.JSONObject
     */
    private JSONObject loadAndCacheChannelConfigInfo(String channelNo){
            .....
            //发起远程调用/访问数据库 加载数据
            Map queryParam = new HashMap<>();
            ...
            log.info("加载并缓存渠道配置信息 param => {}", JSON.toJSONString(queryParam));
            String result = HttpClientUtils.sendHttpPostJson(getChannelInfoUrl, JSON.toJSONString(queryParam));
            ...
            JSONObject jsonObject = JSON.parseObject(result);
            ...
            //设置缓存
            String key = StringUtils.join(CHANNEL_CONFIG_KEY_PREFIX,channelNo);
            RedisUtils.set(key, result,CACHE_EXPIRE_TIME);
            log.info("加载并缓存渠道配置信息成功  key=> {}", key);
            return jsonObject;
            ...
    }

    此类模板式的代码出现在使用缓存的任何地方,且大多是CV大法而来，既不美观也不优雅，还极易出错。其次，在使用缓存的过程中由于使用方法或者对问题的处理不当，可能给数据库或者依赖的服务造成严重的影响，常见的问题如：热点数据集中失效，缓存穿透等。所以需要將缓存开发使用过程中的共性抽离出来，抽象并封装使之模板化，规范化，并最终形成一个可扩展，易维护，使用方便的工具或者工具集。

    设计思路

    • 统一缓存开发使用模式，提供/约定一套开发方法/模型。

      动静分离：抽象公共部分，函数化变化部分。

    • 封装常见问题处理流程默认实现，并提供扩展机制。

      SPI机制：内部默认实现，外部可扩展。

    • 资源使用细粒度保护，减少资源竞争。

      分布式锁：redisson分布式锁

    知识准备

    一,函数式编程:

    1. 什么是函数式编程

      函数式编程并不是Java新提出的概念，属于编程范式中的一种，它起源于一个数学问题，我们并不需要过多的了解函数式编程的历史，要追究它的历史以及函数式编程，关于范畴论、柯里化早就让人立马放弃学习函数式编程了，对于函数式编程我们所要知道的是，它能将一个行为传递作为参数进行传递。

    2. 函数式编程的目的

      Java8出现之前，我们关注的往往是某一类对象应该具有什么样的属性，当然这也是面向对象的核心--对数据进行抽象。但是java8出现以后，这一点开始出现变化，似乎在某种场景下，更加关注某一类共有的行为（这似乎与之前的接口有些类似），这也就是java8提出函数式编程的目的。

    对象-函数.png

    1. Lambda表达式

      不得不提增加Lambda的目的，其实就是为了支持函数式编程，而为了支持Lambda表达式，才有了函数式接口。另外，为了在面对大型数据集合时，为了能够更加高效的开发，编写的代码更加易于维护，更加容易运行在多核CPU上，java在语言层面增加了Lambda表达式。

    2. 函数式接口

      在Java中有一个接口中只有一个方法表示某特定方法并反复使用，例如Runnable接口中只有run方法就表示执行的线程任务。Java8中对于这样的接口有了一个特定的名称——函数式接口。Java8中即使是支持函数式编程，也并没有再标新立异另外一种语法表达。所以只要是只有一个方法的接口，都可以改写成Lambda表达式。在Java8中新增了java.util.function用来支持Java的函数式编程，其中的接口均是只包含一个方法,与其他接口的区别:

      • 函数式接口中只能有一个抽象方法（我们在这里不包括与Object的方法重名的方法）；
      • 可以有从Object继承过来的抽象方法，因为所有类的最终父类都是Object；
      • 接口中唯一抽象方法的命名并不重要，因为函数式接口就是对某一行为进行抽象，主要目的就是支持Lambda表达式。

      Java8还提供了@FunctionalInterface注解来帮助我们标识函数式接口。另外需要注意的是函数式接口的目的是对某一个行为进行封装，某些接口可能只是巧合符合函数式接口的定义。java8的Function包下的类是为了支持基本类型而添加的接口，部分类图如下：

    Supplier.png

    1. 进一步学习

      推荐大家阅读《java8 in action》 以及《Java函数式编程》，前者是对java8新特性全面的阐述，深入浅出，注重实战，非常适合入门。后者则注重函数式编程背后的故事，教你如何构建函数式数据结构，以及函数式编程范式如何帮助你编写更好的程序。

    二，SPI机制

    1. java SPI 机制

      SPI（Service Provider Interface），是JDK内置的一种 服务提供发现机制，可以用来启用框架扩展和替换组件，主要是被框架的开发人员使用，比如java.sql.Driver接口，其他不同厂商可以针对同一接口做出不同的实现，MySQL和PostgreSQL都有不同的实现提供给用户，而Java的SPI机制可以为某个接口寻找服务实现。Java中SPI机制主要思想是将装配的控制权移到程序之外，在模块化设计中这个机制尤其重要，其核心思想就是 解耦。

    java-spi.png

    1. SPI机制的约定：

      • 在META-INF/services/目录中创建以接口全限定名命名的文件该文件内容为Api具体实现类的全限定名
      • 使用ServiceLoader类动态加载META-INF中的实现类
      • 如SPI的实现类为Jar则需要放在主程序classPath中
      • Api具体实现类必须有一个不带参数的构造方法

    2. 不足

      • 不能按需加载，需要遍历所有的实现，并实例化，然后在循环中才能找到我们需要的实现。如果不想用某些实现类，或者某些类实例化很耗时，它也被载入并实例化了，这就造成了浪费。
      • 获取某个实现类的方式不够灵活，只能通过 Iterator 形式获取，不能根据某个参数来获取对应的实现类。
      • 多个并发多线程使用 ServiceLoader 类的实例是不安全的。

    3. 改造

      基于 xkernel

    三，分布式锁

    这里用到分布式锁 starter，详见：分布式锁 starter

    实施步骤

    一，缓存模块设计

    整个模块围绕2个接口和1个工具类展开：缓存管理接口，缓存函数接口，缓存整合工具类。

    • 缓存管理接口主要定义常用缓存基本操作接口，如设置，获取，删除缓存等，默认实现基于Redis。

    • 缓存函数接口则是基于Suppliper和Function2个函数式接口，分别定义了获取单个对象和集合对象的4个常用接口，后续可根据实际需要扩展，默认实现基于缓存管理接口+分布式锁 starter 。

    • 缓存整合工具类则组合了2个接口，对外统一提供缓存相关操作方法。

    • 缓存管理接口和缓存函数接口是模块的扩展点，基于xkernel 提供的SPI机制，结合SpringBoot注解 ConditionalOnBean,ConditionalOnProperty实现。

      总体类结构图如下所示：

    CacheManager.png

    包结构如下：

    xService
 └── src
    ├── main  
    │   ├── java  
    │   │   └── com.javacoo 
    │   │   ├────── xservice
    │   │   │         ├──────cache
    │   │   │         │         ├── CacheFunction 缓存函数接口
    │   │   │         │         ├── CacheManager 缓存管理接口
    │   │   │         │         ├── CacheFactory 缓存工厂
    │   │   │         │         ├── CacheHolder 缓存对象持有者
    │   │   │         │         ├── config
    │   │   │         │         │     └── CacheConfig 缓存配置
    │   │   │         │         └── internal 接口内部实现
    │   │   │         │               ├── redis
    │   │   │         │               └──   ├── CombinatorialFunction 函数组合对象
    │   │   │         │                     ├── RedisCacheFunction 缓存函数接口实现类
    │   │   │         │                     └── RedisCacheManager 缓存管理接口实现类
    │   │   │         └──────utils
    │   │   │                   └── CacheUtil 缓存工具类
    │   └── resource  
    │       ├── META-INF
    │             └── ext
    │                  └── internal
    │                          ├── com.javacoo.xservice.base.support.cache.CacheFunction
    │                          └── com.javacoo.xservice.base.support.cache.CacheManager
    └── test  测试

    二，核心逻辑概述

    模块核心是围绕数据加载方案及热点数据集中失效和缓存穿透问题解决方案展开：数据加载方案主要是采取多重检查机制，确保分布式，高并发条件下数据不多加载，不漏加载。热点数据集中失效和缓存穿透问题解决方案主要采用如下策略：

    • 热点数据集中失效解决方案：redisson分布式锁+随机过期时间
    • 缓存穿透的解决方案：设置空数据特定值（根据业务场景特性：空数据的key数量有限、key重复请求概率较高），缺点：需要存储所有空数据的key，对于一些恶意攻击，KEY不相同的情况，也起不了保护数据库的作用。
    • 缓存穿透的解决备选方案：空数据的key各不相同、key重复请求概率低的场景而言，可使用BloomFilter。

    加载数据并缓存流程图:

    加载数据并设置缓存.png

    三，如何扩展

    基于xkernel 提供的SPI机制，扩展非常方便，大致步骤如下：

    1. 实现缓存函数接口：如 com.xxxx.xxxx.MyCacheFunction
    2. 配置缓存函数接口：
      • 在项目resource目录新建包->META-INF->services
      • 创建com.javacoo.xservice.base.support.cache.CacheFunction文件，文件内容：实现类的全局限定名，如：
    myCacheFunction=com.xxxx.xxxx.MyCacheFunction
    • 修改配置文件，添加如下内容:
    #缓存函数接口实现
app.config.cache.functionImpl = myCacheFunction

    四，如何使用

    由于过于简单，直接上代码，如下所示：

        /**
     * 查询缓存KEY:id
     */
    private static final String QUERY_CACHE_KEY = "query:%1$s";
    /**
     * 查询缓存超时时间:1 分钟
     */
    private static final int QUERY_CACHE_TIMEOUT = 60 * 1;
    /**
     * 缓存工具类
     */
    @Autowired
    protected CacheUtil cacheUtil;
    @Autowired
    private ExampleDao exampleDao;

    @Override
    public Optional getExampleInfo(String id) {
        AbstractAssert.isNotBlank(id, ErrorCodeConstants.SERVICE_GET_EXAMPLE_INFO_ID);
        // 从缓存中获取数据
        String cacheKey = String.format(QUERY_CACHE_KEY,id);
        return Optional.ofNullable(cacheUtil.getCacheValueFunction(cacheKey,QUERY_CACHE_TIMEOUT,ExampleDto.class, getExampleInfoFunction,id));
    }

    /**
     * 获取示例信息函数
     * 
  • 
     * @author [email protected]
     * @param id: id
     * @return: ExampleDto 示例信息
     */
    private Function getExampleInfoFunction = (String id)-> exampleDao.getExampleInfo(id);

    五，代码实现

    1. 缓存管理接口

      /**
 * 缓存管理接口
 * 
    2. 
 *
 * @author: [email protected]
 */
@Spi(CacheConfig.DEFAULT_IMPL)
public interface CacheManager {
    /**
     * 设置单个值
     * 
    3. 
     * @author [email protected]
     * @param key: 键
     * @param value: 值
     * @return: boolean true->成功
     */
    boolean set(String key, Object value);

    /**
     * 设置单个值并设置失效时间
     * 
    4. 
     * @author [email protected]
     * @param key: 键
     * @param value: 值
     * @param expireTime:缓存时间，单位秒
     * @return: boolean true->成功
     */
    boolean setAndExpire(String key, Object value, int expireTime);

    /**
     * 获取单个值
     * 
    5. 
     * @author [email protected]
     * @param key: 键
     * @return: T 返回对象
     */
     T get(String key);

    /**
     * 批量设置hash
     * 
    6. 
     * @author [email protected]
     * @param key: 键
     * @param hash: Map对象
     * @return: boolean true->成功
     */
    boolean hmSet(String key, Map hash);

    /**
     * 给hash字段设置值
     * 
    7. 
     * @author [email protected]
     * @param key: 键
     * @param field: 字段
     * @param value: 值
     * @return: boolean true->成功
     */
    boolean hSet(String key, String field, Object value);

    /**
     * 获取hash值
     * 
    8. 
     * @author [email protected]
     * @param key: 键
     * @param field: 字段
     * @return: T 返回对象
     */
     T hGet(String key, String field);

    /**
     * 如果缓存key不存在则设置缓存并设置失效时间，否则不做操作
     * 
    9. 
     * @author [email protected]
     * @param key: 键
     * @param value: 值
     * @param time: 缓存时间，单位秒
     * @return: boolean true->成功
     */
    boolean setIfAbsent(final String key, Object value, int time);

    /**
     * 删除缓存
     * 
    10. 
     * @author [email protected]
     * @date 2021/7/14 9:13
     * @param key: 键
     * @return: boolean true->成功
     */
    boolean del(String key);

    /**
     * 删除hash缓存
     * 
    11. 
     * @author [email protected]
     * @param key: 键
     * @param fields: 字段
     * @return: long 值
     */
    long hashDel(String key, String... fields);

    /**
     * 自增
     * 
    12. 
     * @author [email protected]
     * @param key: 键
     * @param liveTime: 天数 这个计数器的有效存留时间
     * @param delta: 自增量
     * @return: java.lang.Long
     */
   Long incr(String key, long liveTime, long delta);
}

    13. 缓存管理接口实现类：

      /**
 * 缓存管理接口实现类
 * 
    14. 基于redis实现
      15. 
 *
 * @author: [email protected]
 */
@Slf4j
public class RedisCacheManager implements CacheManager {
    /**
     * RedisTemplate
     */
    @Autowired
    private RedisTemplate redisTemplate;
    /**
     * 设置单个值
     * 
    15. 
     *
     * @param key : 键
     * @param value : 值
     * @author [email protected]
     * @return: boolean true->成功
     */
    @Override
    public boolean set(String key, Object value) {
        Objects.requireNonNull(key, "缓存Key不能为空!");
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            log.error("[Redis缓存]设置缓存 key:{},value:{},失败:{}", key, value, e);
            return false;
        }
    }

    /**
     * 设置单个值并设置失效时间
     * 
    16. 
     *
     * @param key : 键
     * @param value : 值
     * @param expireTime :缓存时间，单位秒
     * @author [email protected]
     * @return: boolean true->成功
     */
    @Override
    public boolean setAndExpire(String key, Object value, int expireTime) {
        Objects.requireNonNull(key, "缓存Key不能为空!");
        try {
            //设置默认时间24H
            expireTime = expireTime <= 0 ? 1 : expireTime;
            redisTemplate.opsForValue().set(key, value, expireTime, TimeUnit.SECONDS);
            return true;
        } catch (Exception e) {
            log.error("[Redis缓存]设置缓存 key:{},value:{},失败:{}", key, value, e);
            return false;
        }
    }

    /**
     * 获取单个值
     * 
    17. 
     *
     * @param key : 键
     * @author [email protected]
     * @return: T 返回对象
     */
    @Override
    public  T get(String key) {
        Objects.requireNonNull(key, "缓存Key不能为空!");
        try {
            return (T) redisTemplate.opsForValue().get(key);
        } catch (Exception e) {
            log.error("[Redis缓存]获取缓存 key:{},失败:{}", key, e);
            return null;
        }
    }

    /**
     * 批量设置hash
     * 
    18. 
     *
     * @param key : 键
     * @param hash : Map对象
     * @author [email protected]
     * @return: boolean true->成功
     */
    @Override
    public boolean hmSet(String key, Map hash) {
        Objects.requireNonNull(key, "缓存Key不能为空!");
        try {
            redisTemplate.opsForHash().putAll(key, hash);
            return true;
        } catch (Exception e) {
            log.error("[Redis缓存]设置缓存hash key:{},value:{},失败:{}", key, hash, e);
            return false;
        }
    }

    /**
     * 给hash字段设置值
     * 
    19. 
     *
     * @param key : 键
     * @param field : 字段
     * @param value : 值
     * @author [email protected]
     * @return: boolean true->成功
     */
    @Override
    public boolean hSet(String key, String field, Object value) {
        Objects.requireNonNull(key, "缓存Key不能为空!");
        Objects.requireNonNull(field, "缓存哈希字段不能为空!");
        try {
            redisTemplate.opsForHash().put(key, field, value);
            return true;
        } catch (Exception e) {
            log.error("[Redis缓存]设置hash值, key:{}, value:{} 失败. {}", key, field, e);
            return false;
        }
    }

    /**
     * 获取hash值
     * 
    20. 
     *
     * @param key : 键
     * @param field : 字段
     * @author [email protected]
     * @return: T 返回对象
     */
    @Override
    public  T hGet(String key, String field) {
        Objects.requireNonNull(key, "缓存Key不能为空!");
        Objects.requireNonNull(field, "缓存哈希字段不能为空!");
        try {
            return (T) redisTemplate.opsForHash().get(key, field);
        } catch (Exception e) {
            log.error("[Redis缓存]获取缓存hash key:{},field:{} 失败,{}", key, field, e);
            return null;
        }
    }

    /**
     * 如果缓存key不存在则设置缓存并设置失效时间，否则不做操作
     * 
    21. 
     *
     * @param key : 键
     * @param value : 值
     * @param time : 缓存时间，单位秒
     * @author [email protected]
     * @return: boolean true->成功
     */
    @Override
    public boolean setIfAbsent(String key, Object value, int time) {
        Objects.requireNonNull(key, "缓存Key不能为空!");
        try {
            time = time <= 0 ? 1 : time;
            return redisTemplate.opsForValue().setIfAbsent(key, value, time, TimeUnit.SECONDS);
        } catch (Exception e) {
            log.error("[Redis缓存]设置缓存 key:{},value:{}失败,{}", key, value, e);
            return false;
        }
    }

    /**
     * 删除缓存
     * 
    22. 
     *
     * @param key : 键
     * @author [email protected]
     * @return: boolean true->成功
     */
    @Override
    public boolean del(String key) {
        Objects.requireNonNull(key, "缓存Key不能为空!");
        try {
            return redisTemplate.delete(key);
        } catch (Exception e) {
            log.error("[Redis缓存]删除缓存 key:{} 失败.{}", key, e);
            return false;
        }
    }

    /**
     * 删除hash缓存
     * 
    23. 
     *
     * @param key : 键
     * @param fields : 字段
     * @author [email protected]
     * @return: long 值
     */
    @Override
    public long hashDel(String key, String... fields) {
        Objects.requireNonNull(key, "缓存Key不能为空!");
        Objects.requireNonNull(fields, "缓存哈希字段不能为空!");
        try {
            return redisTemplate.opsForHash().delete(key, fields);
        } catch (Exception e) {
            log.error("[Redis缓存]删除缓存 key:{},fields:{} 失败,{}", key, fields, e);
        }
        return -1;
    }

    /**
     * 自增
     * 
    24. 
     *
     * @param key : 键
     * @param liveTime : 天数 这个计数器的有效存留时间
     * @param delta : 自增量
     * @author [email protected]
     * @return: java.lang.Long
     */
    @Override
    public Long incr(String key, long liveTime, long delta) {
        RedisAtomicLong entityIdCounter = new RedisAtomicLong("INCSEQ_"+key, redisTemplate.getConnectionFactory());
        Long increment = entityIdCounter.addAndGet(delta);

        //初始设置过期时间
        if ((null == increment || increment.longValue() == 0) && liveTime > 0) {
            entityIdCounter.expire(liveTime, TimeUnit.DAYS);
        }
        return increment;
    }
}

    25. 缓存函数接口:

      /**
 * 缓存函数接口
 * @author: [email protected]
 * @since: 2021/7/14 11:08
 */
@Spi(CacheConfig.DEFAULT_IMPL)
public interface CacheFunction {
    /**
     * 根据参数获取缓存
     * 
    26. Function版
      27. 
     * @author [email protected]
     * @param key: 缓存KEY
     * @param expireTime: 超时时间，单位 秒
     * @param clazz: 目标对象类型
     * @param function: 执行函数
     * @param p: 附加给function的参数
     * @return: java.util.Optional 对象数据
     */
     Optional getCacheValueFunction(String key,int expireTime, Class clazz, Function function,P p);
    /**
     * 获取缓存
     * 
    27. Supplier版
      28. 
     * @author [email protected]
     * @param key:缓存KEY
     * @param expireTime:超时时间，单位 秒
     * @param clazz:目标对象类型
     * @param function:执行函数
     * @return: java.util.Optional 对象数据
     */
     Optional getCacheValueFunction(String key,int expireTime, Class clazz, Supplier function);
    /**
     * 根据参数获取集合缓存
     * 
    28. Function版
      29. 
     * @author [email protected]
     * @param key: 缓存KEY
     * @param expireTime: 超时时间，单位 秒
     * @param clazz: 目标对象类型
     * @param function: 执行函数
     * @param p: 附加给function的参数
     * @return: java.util.Optional> 对象集合数据
     */
     Optional> getCacheListValueFunction(String key,int expireTime, Class clazz, Function> function,P p);
    /**
     * 获取集合缓存
     * 
    29. Supplier版本
      30. 
     * @author [email protected]
     * @param key: 缓存KEY
     * @param expireTime: 超时时间，单位 秒
     * @param clazz: 目标对象类型
     * @param function: 执行函数
     * @return: java.util.Optional> 对象集合数据
     */
     Optional> getCacheListValueFunction(String key,int expireTime, Class clazz,Supplier> function);
}

    30. 缓存函数接口实现类:

      /**
 * 缓存函数接口实现类
 * 
    31. 
 * 
    32. 1,热点数据集中失效解决方案：redisson分布式锁+随机过期时间
      33. 
 * 
    33. 2,缓存穿透的解决方案：设置空数据特定值（根据业务场景特性：空数据的key数量有限、key重复请求概率较高），缺点：需要存储所有空数据的key，对于一些恶意攻击，KEY不相同的情况，也起不了保护数据库的作用
      34. 
 * 
    34. 3,缓存穿透的解决备选方案：空数据的key各不相同、key重复请求概率低的场景而言，可使用BloomFilter
      35. 
 * @author: [email protected]
 */
@Slf4j
public class RedisCacheFunction implements CacheFunction {

    /**
     * 根据参数获取缓存
     * 
    35. Function版
      36. 
     *
     * @param key : 缓存KEY
     * @param expireTime : 超时时间，单位 秒
     * @param clazz : 目标对象类型
     * @param function : 执行函数
     * @param p : 附加给function的参数
     * @author [email protected]
     * @return: java.util.Optional 对象数据
     */
    @Override
    public  Optional getCacheValueFunction(String key, int expireTime, Class clazz, Function function, P p) {
        return getCacheValue(key,expireTime,clazz,CombinatorialFunction.builder().function(function).p(p).build());
    }

    /**
     * 获取缓存
     * 
    36. Supplier版
      37. 
     *
     * @param key :缓存KEY
     * @param expireTime :超时时间，单位 秒
     * @param clazz :目标对象类型
     * @param function :执行函数
     * @author [email protected]
     * @return: java.util.Optional 对象数据
     */
    @Override
    public  Optional getCacheValueFunction(String key, int expireTime, Class clazz, Supplier function) {
        return getCacheValue(key,expireTime,clazz,CombinatorialFunction.builder().supplier(function).build());
    }

    /**
     * 根据参数获取集合缓存
     * 
    37. Function版
      38. 
     *
     * @param key : 缓存KEY
     * @param expireTime : 超时时间，单位 秒
     * @param clazz : 目标对象类型
     * @param function : 执行函数
     * @param p : 附加给function的参数
     * @author [email protected]
     * @return: java.util.Optional> 对象集合数据
     */
    @Override
    public  Optional> getCacheListValueFunction(String key, int expireTime, Class clazz,
        Function> function, P p) {
        return getCacheListValue(key,expireTime,clazz,CombinatorialFunction.builder().listFunction(function).p(p).build());
    }

    /**
     * 获取集合缓存
     * 
    38. Supplier版本
      39. 
     *
     * @param key : 缓存KEY
     * @param expireTime : 超时时间，单位 秒
     * @param clazz : 目标对象类型
     * @param function : 执行函数
     * @author [email protected]
     * @return: java.util.Optional> 对象集合数据
     */
    @Override
    public  Optional> getCacheListValueFunction(String key, int expireTime, Class clazz,
        Supplier> function) {
        return getCacheListValue(key,expireTime,clazz,CombinatorialFunction.builder().listSupplier(function).build());
    }
    /**
     * 获取集合缓存
     * 
    39. 
     * @author [email protected]
     * @param key: 缓存KEY
     * @param expireTime: 超时时间，单位 秒
     * @param clazz: 目标对象类型
     * @param combinatorialFunction:函数组合对象
     * @return: java.util.Optional> 对象集合数据
     */
    public  Optional> getCacheListValue(String key, int expireTime, Class clazz,CombinatorialFunction combinatorialFunction) {
        //获取缓存
        List records = getList(key, clazz);
        if (records != null && !records.isEmpty()) {
            return Optional.of(records);
        }
        //检查是否是特定值-empty
        Object o = get(key);
        if(Constants.CACHE_EMPTY_VALUE.equals(o)){
            return Optional.empty();
        }
        //获取锁失败
        if (!tryLock(key)) {
            log.error("获取锁失败:key->{},直接返回.",key);
            return Optional.empty();
        }
        //获取锁成功
        try {
            //再检查一次：当其他等待线程获取到锁时，缓存一般已经有值，所以需要再次确认，以免重复查库
            records = getList(key, clazz);
            if (records != null && !records.isEmpty()) {
                return Optional.of(records);
            }
            //执行目标函数
            if(combinatorialFunction.getListSupplier() != null){
                records = combinatorialFunction.getListSupplier().get();
            }else if(combinatorialFunction.getListFunction() != null && combinatorialFunction.getP() != null){
                records = combinatorialFunction.getListFunction().apply(combinatorialFunction.getP());
            }
            if (records != null && !records.isEmpty()) {
                //设置缓存
                setObject(key, records,expireTime);
                //再次获取缓存,确保缓存成功
                records = getList(key, clazz);
                if (records != null && !records.isEmpty()) {
                    log.info("线程{},执行目标函数获取数据并缓存,key={}",Thread.currentThread().getName(), key);
                    return Optional.of(records);
                }
            }
            //缓存空字符串数据,防止重复请求
            setAndExpire(key, Constants.CACHE_EMPTY_VALUE,expireTime);
            log.info("线程{},数据不存在,缓存空字符串数据,防止重复请求，key={}",Thread.currentThread().getName(), key);
        } catch(Exception e){
            log.error("获取集合缓存失败:key->{}.",key,e);
            throw e;
        }finally {
            unlock(key);
        }
        return Optional.empty();
    }
    /**
     * 获取单值缓存
     * 
    40. 
     * @author [email protected]
     * @param key: 缓存KEY
     * @param expireTime: 超时时间，单位 秒
     * @param clazz: 目标对象类型
     * @param combinatorialFunction: 函数组合对象
     * @return: java.util.Optional 对象数据
     */
    public  Optional getCacheValue(String key, int expireTime, Class clazz, CombinatorialFunction combinatorialFunction) {
        //获取缓存
        T record = getObject(key, clazz);
        if (record != null) {
            return Optional.of(record);
        }
        //检查是否是特定值-empty
        Object o = get(key);
        if(Constants.CACHE_EMPTY_VALUE.equals(o)){
            return Optional.empty();
        }
        //获取锁失败
        if (!tryLock(key)) {
            log.error("获取锁失败:key->{},直接返回.",key);
            return Optional.empty();
        }
        try {
            //再检查一次：当其他等待线程获取到锁时，缓存一般已经有值，所以需要再次确认，以免重复查库
            record = getObject(key, clazz);
            if(record != null){
                return Optional.of(record);
            }
            //执行目标函数
            if(combinatorialFunction.getSupplier() != null){
                record = combinatorialFunction.getSupplier().get();
            }else if(combinatorialFunction.getFunction() != null && combinatorialFunction.getP() != null){
                record = combinatorialFunction.getFunction().apply(combinatorialFunction.getP());
            }
            if(record != null){
                //设置缓存
                setObject(key, record,expireTime);
                //再次获取缓存,确保缓存成功
                record = getObject(key, clazz);
                if(record != null){
                    log.info("线程{},执行目标函数获取数据并缓存,key={}",Thread.currentThread().getName(), key);
                    return Optional.of(record);
                }
            }
            //缓存空字符串数据,防止重复请求
            setAndExpire(key, Constants.CACHE_EMPTY_VALUE,expireTime);
            log.info("线程{},数据不存在,缓存空字符串数据,防止重复请求,key={}",Thread.currentThread().getName(), key);
        } catch(Exception e){
            log.error("根据参数获取缓存失败:key->{}.",key,e);
            throw e;
        } finally {
            unlock(key);
        }
        return Optional.empty();
    }
    /**
     * 加锁
     * 
    41. 
     * @author [email protected]
     * @param cacheKey: 缓存key
     * @return: boolean 是否成功
     */
    private boolean tryLock(String cacheKey){
        int timeout = Lock.TIMEOUT_SECOND;
        if(!LockHolder.getLock().isPresent()){
            log.error("不支持加锁");
            return false;
        }
        boolean isLocked = LockHolder.getLock().get().tryLock(cacheKey, TimeUnit.SECONDS,0,timeout);
        if(isLocked){
            SwapAreaUtils.getSwapAreaData().setCacheKey(cacheKey);
            log.info("加锁成功,KEY:{},自动失效时间:{}秒",cacheKey,timeout);
        }
        return isLocked;
    }
    /**
     * 解锁
     * 
    42. 
     * @author [email protected]
     * @param key: 缓存key
     * @return: void
     */
    private void unlock(String key){
        if(!LockHolder.getLock().isPresent()){
            return;
        }
        LockHolder.getLock().get().unlock(key);
    }
    /**
     * 获取对象集合
     * 
    43. 
     * @author [email protected]
     * @param key:键
     * @param clazz:对象类型
     * @return: java.util.List对象集合
     */
    private final  List getList(final String key,final Class clazz) {
        try{
            return FastJsonUtil.toList(get(key), clazz);
        }catch(Exception ex){
            log.error("获取对象集合->JSON转集合对象失败",ex);
            //如果不是空值,说明数据异常，需要删除此数据
            if(!Constants.CACHE_EMPTY_VALUE.equals(get(key))){
                del(key);
            }
        }
        return Collections.emptyList();
    }
    /**
     * 获取对象
     * 
    44. 
     * @author [email protected]
     * @param key: 键
     * @param clazz: 对象类型
     * @return: T 目标对象
     */
    private final  T getObject(final String key,final Class clazz) {
        try{
            return FastJsonUtil.toBean(get(key), clazz);
        }catch(Exception ex){
            //如果不是空值
            if(!Constants.CACHE_EMPTY_VALUE.equals(get(key))){
                del(key);
            }
        }
        return null;
    }
    /**
     * 删除缓存
     * 
    45. 
     * @author [email protected]
     * @param key: 键
     * @return: boolean true->成功
     */
    private boolean del(String key) {
        if(getCacheManager() == null){
            return false;
        }
        return getCacheManager().del(key);
    }
    /**
     * 设置对象
     * 
    46. 
     * @author [email protected]
     * @param key: 键
     * @param value: 对象
     * @param expireTime 超时时间，单位 秒
     */
    private void setObject(final String key, final Object value,final int expireTime) {
        setAndExpire(key, FastJsonUtil.toJSONString(value),expireTime);
    }
    /**
     * 设置单个值并设置失效时间
     * 
    47. 
     * @author [email protected]
     * @param key: 键
     * @param value: 值
     * @param expireTime:缓存时间，单位秒
     * @return: boolean true->成功
     */
    private boolean setAndExpire(String key, Object value, int expireTime) {
        if(getCacheManager() == null){
            return false;
        }
        return getCacheManager().setAndExpire(key,value,expireTime);
    }

    /**
     * 获取单个值
     * 
    48. 
     * @author [email protected]
     * @param key: 键
     * @return: T 返回对象
     */
    private  T get(String key) {
        if(getCacheManager() == null){
            return null;
        }
        return getCacheManager().get(key);
    }
    /**
     * 获取缓存管理器
     * 
    49. 
     * @author [email protected]
     * @return: com.javacoo.xservice.base.support.cache.CacheManager
     */
    private CacheManager getCacheManager(){
        if(!CacheHolder.getCacheManager().isPresent()){
            log.error("不支持缓存");
            return null;
        }
        return CacheHolder.getCacheManager().get();
    }
}

    50. 函数组合对象：

      /**
 * 函数组合对象
 * 
    51. 
 *
 * @author: [email protected]
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CombinatorialFunction {
    /**
     * 单值,提供者函数
     */
    private Supplier supplier;
    /**
     * 单值,带参数函数
     */
    private Function function;
    /**
     * 集合,提供者函数
     */
    private Supplier> listSupplier;
    /**
     * 集合,带参数函数
     */
    private Function> listFunction;
    /**
     * 参数
     */
    private P p;
}

    52. 缓存管理对象持有者:

      /**
 * 缓存管理对象持有者
 * 
    53. 
 * @author [email protected]
 */
public class CacheHolder {
    /** 缓存管理接口对象*/
    static CacheManager cacheManager;
    /** 缓存函数接口对象*/
    static CacheFunction cacheFunction;

    public static Optional getCacheManager() {
        return Optional.ofNullable(cacheManager);
    }
    public static Optional getCacheFunction() {
        return Optional.ofNullable(cacheFunction);
    }
}

    54. 缓存管理接口工厂:

      /**
 * 缓存管理接口工厂
 * 
    55. 
 * @author [email protected]
 */
@Slf4j
@Component
@ConditionalOnBean(CacheConfig.class)
public class CacheFactory {
    /** 缓存配置 */
    @Autowired
    private CacheConfig cacheConfig;

    @Bean
    public CacheManager createCacheManager() {
        log.info("初始化缓存管理,实现类名称:{}",cacheConfig.getImpl());
        CacheHolder.cacheManager = ExtensionLoader.getExtensionLoader(CacheManager.class).getExtension(cacheConfig.getImpl());
        log.info("初始化缓存管理,缓存管理接口实现类:{}", CacheHolder.cacheManager);
        return CacheHolder.cacheManager;
    }
    @Bean
    public CacheFunction createCacheFunction() {
        log.info("初始化缓存函数接口,实现类名称:{}",cacheConfig.getFunctionImpl());
        CacheHolder.cacheFunction = ExtensionLoader.getExtensionLoader(CacheFunction.class).getExtension(cacheConfig.getFunctionImpl());
        log.info("初始化缓存函数接口实现类:{}", CacheHolder.cacheFunction);
        return CacheHolder.cacheFunction;
    }
}

    56. 工具类实现：

      /**
 * 缓存工具类
 * 
    57. 提供缓存基本操作
      58. 
 * 
    58. 获取单个对象缓存：Function版
      59. 
 * 
    59. 获取单个对象缓存：Supplier版
      60. 
 * 
    60. 获取集合类型缓存：Function版
      61. 
 * 
    61. 获取集合类型缓存：Supplier版
      62. 
 * @author [email protected]
 */
@Component
public class CacheUtil {
    /**
     * 设置单个值
     * @param key
     * @param value
     * @return
     */
    public boolean set(String key, Object value) {
        return getCacheManager() == null ? false : getCacheManager().set(key,value);
    }

    /**
     * 设置单个值并设置失效时间
     * @param key
     * @param value
     * @param expireTime 缓存时间，单位秒
     * @return
     */
    public boolean setAndExpire(String key, Object value, int expireTime) {
        return getCacheManager() == null ? false : getCacheManager().setAndExpire(key,value,expireTime);
    }

    /**
     * 获取单个值
     * @param key
     * @return
     */
    public  T get(String key) {
        return getCacheManager() == null ? null : getCacheManager().get(key);
    }

    /**
     * 批量设置hash
     * @param key
     * @param hash
     * @return
     */
    public boolean hmSet(String key, Map hash) {
        return getCacheManager() == null ? false : getCacheManager().hmSet(key,hash);
    }

    /**
     * 给hash字段设置值
     * @param key
     * @param field
     * @param value
     * @return
     */
    public boolean hSet(String key, String field, Object value) {
        return getCacheManager() == null ? false : getCacheManager().hSet(key,field,value);
    }

    /**
     * 获取hash值
     *  引用见{@link RedisTemplate}
     * @param key
     * @param field
     * @return
     */
    public  T hGet(String key, String field) {
        return getCacheManager() == null ? null : getCacheManager().hGet(key,field);
    }

    /**
     * 如果缓存key不存在则设置缓存并设置失效时间，否则不做操作
     * @param key
     * @param value
     * @param time 缓存时间，单位秒
     * @return
     */
    public boolean setIfAbsent(final String key, Object value, int time) {
        return getCacheManager() == null ? false : getCacheManager().setIfAbsent(key,value,time);
    }

    /**
     * 删除缓存
     * @param key
     * @return
     */
    public boolean del(String key) {
        return getCacheManager() == null ? false : getCacheManager().del(key);
    }

    /**
     * 删除hash缓存
     * @param key
     * @param fields
     * @return
     */
    public long hashDel(String key, String... fields) {
        return getCacheManager() == null ? -1 : getCacheManager().hashDel(key,fields);
    }

    /**
     * redis 自增
     * @param key
     * @param liveTime 天数 这个计数器的有效存留时间
     * @param delta 自增量
     * @return
     */
    public long incr(String key, long liveTime, long delta) {
        return getCacheManager() == null ? -1 : getCacheManager().incr(key,liveTime,delta);
    }

    /**
     * 获取缓存
     * 
      
     * 说明:Function版
     * 
      
     * @author DuanYong
     * @param key 缓存KEY
     * @param expireTime 超时时间，单位 秒
     * @param clazz 目标对象类型
     * @param function 执行函数
     * @param p 附加给function的参数
     * @return 目标对象
     */
    public  T getCacheValueFunction(String key,int expireTime, Class clazz, Function function,P p) {
        return getCacheFunction() == null ? null : getCacheFunction().getCacheValueFunction(key,expireTime,clazz,function,p).orElse(null);
    }
    /**
     * 获取缓存
     * 
      
     * 说明:Supplier版
     * 
      
     * @author DuanYong
     * @param key 缓存KEY
     * @param clazz 目标对象类型
     * @param function 执行函数
     * @return 目标对象
     */
    public  T getCacheValueFunction(String key,int expireTime, Class clazz, Supplier function) {
        return getCacheFunction() == null ? null : getCacheFunction().getCacheValueFunction(key,expireTime,clazz,function).orElse(null);
    }
    /**
     * 获取集合缓存
     * 
      说明:Function版本
      
     * @author DuanYong
     * @param key 缓存KEY
     * @param clazz 目标对象类型
     * @param function 执行函数
     * @param p 附加给function的参数
     * @return 目标对象
     */
    public  List getCacheListValueFunction(String key,int expireTime, Class clazz, Function> function,P p) {
        return getCacheFunction() == null ? Collections.emptyList() : getCacheFunction().getCacheListValueFunction(key,expireTime,clazz,function,p).orElse(Collections.emptyList());
    }
    /**
     * 获取集合缓存
     * 
      说明:Supplier版本
      
     * @author DuanYong
     * @param key 缓存KEY
     * @param clazz 目标对象类型
     * @param function 执行函数
     * @return 目标对象
     */
    public  List getCacheListValueFunction(String key,int expireTime, Class clazz,Supplier> function) {
        return getCacheFunction() == null ? Collections.emptyList() : getCacheFunction().getCacheListValueFunction(key,expireTime,clazz,function).orElse(Collections.emptyList());
    }
    /**
     * 获取缓存管理器
     * 
    62. 
     * @author [email protected]
     * @return: com.javacoo.xservice.base.support.cache.CacheManager
     */
    private CacheManager getCacheManager(){
        if(!CacheHolder.getCacheManager().isPresent()){
            log.error("不支持缓存");
            return null;
        }
        return CacheHolder.getCacheManager().get();
    }
    /**
     * 获取缓存函数接口
     * 
    63. 
     * @author [email protected]
     * @return: com.javacoo.xservice.base.support.cache.CacheFunction
     */
    private CacheFunction getCacheFunction(){
        if(!CacheHolder.getCacheManager().isPresent()){
            log.error("不支持缓存");
            return null;
        }
        if(!CacheHolder.getCacheFunction().isPresent()){
            log.error("不支持缓存函数");
            return null;
        }
        return CacheHolder.getCacheFunction().get();
    }

    应用场景

    • 适用于大多数并发较少，数据一致性要求不高的场景。

    结果验证及局限性

    • 统一了缓存使用模式，简化了开发。
    • 此方案在并发较少，数据一致性要求不高的场景效果较好。
    • 高并发，数据一致性要求高的场景其缓存设计方案可参考: OpenResty+Lua+Redis+Canal实现多级缓存架构

    后续规划

    • 完善缓存相关问题解决方案。
    一些信息
    路漫漫其修远兮,吾将上下而求索
码云：https://gitee.com/javacoo
QQ群：164863067
作者/微信：javacoo
邮箱：[email protected]

    你可能感兴趣的:(一个简单实用的函数式缓存工具类)

    • 深入探讨服务器虚拟化：架构、技术与应用 码上飞扬 服务器虚拟化K8SDockerXenKVM
      1.引言在现代IT基础设施中，服务器虚拟化已成为一种不可或缺的技术。它不仅提高了资源利用率，还增强了系统的灵活性和可管理性。随着企业对高效、灵活和可扩展IT环境的需求不断增加，服务器虚拟化技术的应用愈发广泛。本文将深入探讨服务器虚拟化的基本概念、架构、常见技术及其实际应用，帮助读者更好地理解这一重要技术。2.什么是服务器虚拟化？服务器虚拟化是一种将物理服务器划分为多个虚拟服务器（虚拟机，VM）的技
    • 【Python】自动化神器PyAutoGUI —告别手动操作，一键模拟鼠标键盘，玩转微信及各种软件自动化 墩墩分墩 Pythonpython自动化自动化脚本自动化测试pyautogui
      文章目录1.PyAutoGUI简介2.不同操作系统引入模块3.全局延迟和临时休眠4,自动防故障功能5.获取屏幕分辨率—用于定位，这是最关键的，找到要点击的位置（像素坐标）6.获取鼠标位置7.判断坐标是否在屏幕范围内：8.鼠标移动8.1.鼠标移动的基本操作8.2.鼠标移动效果-缓动/渐变（Tween/Easing）9.鼠标点击10.鼠标滚轮控制11.鼠标拖拽12.键盘控制13.消息弹窗函数14.屏幕
    • java.sql.Date 弃用分析与替代方案 蓝田～ javamicrosoft
      引言java.sql.Date是Java标准库中的一个类，它继承自java.util.Date，主要用于在Java应用程序与数据库之间进行日期数据的传输。然而，随着Java语言的发展，java.sql.Date以及其父类java.util.Date逐渐被认为存在设计缺陷，并被新的日期时间API所替代。本文将对java.sql.Date的启用原因进行分析，并探讨其弃用原因及替代方案。启用原因分析SQ
    • MATLAB中alphanumericsPattern函数用法 jk_101 Matlabmatlab开发语言
      目录语法说明示例从文本中提取字母和数字匹配所设置数目的字母和数字匹配不同大小的字母和数字集合alphanumericsPattern函数的功能是匹配字母和数字字符。语法pat=alphanumericsPatternpat=alphanumericsPattern(N)pat=alphanumericsPattern(minCharacters,maxCharacters)说明pat=alphan
    • Coze，Dify，FastGPT，对比 云连山 AI编程AI编程
      在当今AI技术迅速发展的背景下，AIAgent智能体成为了关键领域，Coze、Dify和FastGPT作为其中的佼佼者，各有千秋。平台介绍-FastGPT：由环界云计算公司发起，是基于大语言模型（LLM）的开源知识库问答系统。其亮点是支持Flow可视化工作流编排，在知识问答领域表现出色，拥有庞大用户群体，包括数百家企业付费客户等。网址为https://fastgpt.cn/。-Dify：苏州语灵人
    • npm:升级自身时报错:EBADENGINE 落日弥漫的橘_ Node.jsnpm前端node.js
      具体报错信息如下：1.原因分析npm和当前的node版本不兼容。//当前实际版本:Actual:{"npm":"10.2.4","node":"v20.11.0"}可以通过官网文档查看与自己node版本兼容的是哪一版本的npm，相对应进行更新即可：Node.js—Node.js版本2.解决方法升级一下node版本。//需要node的版本号为^20.17.0以上，Required:{"node":"
    • pygame下载 2401_86461228 pygamepython
      pygame下载先进入pygame官网下载与你python对应的版本，然后解压：https://www.pygame.org/download.shtml然后打开cmd命令输入pipinstallpygame等待执行结束，然后打开python输入代码importpygame再运行，入出现以下情况说明安装成功注：我的python是32位的
    • 【黑龙江乡镇界】面图层arcgis数据shp格式乡镇名称和编码wgs84无偏移内容测评 鸿业远图科技 arcgis
      本文将详细讲解与“最新黑龙江乡镇界面图层arcgis数据shp格式乡镇名称和编码wgs84无偏移”相关的知识点，包括GIS基础、ArcGIS软件、SHP文件格式、WGS84坐标系统以及乡镇行政数据的重要性。GIS基础GIS（GeographicInformationSystem，地理信息系统）是一种用于采集、存储、管理、分析和展示所有类型地理数据的系统。它整合了地图、数据库、统计分析和计算机图形等
    • kafka内部工作机制 一只叫狗的猫 #kafka
      集群中成员关系kafka使用zookeeper来维护成员信息。没个broker都有唯一的id，这个标识可以在配置文件中配置，在broker启动的时候，它会创建临时的节点把id注册到zookeeper中，当有其他broker加入集群中时，会判断是否已经有这个id，如果有相同的id则会注册失败。当broker宕机的时候，broker创建的临时节点会从zookeeper中移除，其它的kafka组件也都会
    • 24. C语言 预处理器：技巧与陷阱 涛ing C语言基础c语言linuxc++开发语言vscodevim经验分享
      本章目录:前言预处理器概述预处理器指令简介常见的预处理器指令实例1.定义宏常量2.引入头文件3.取消宏定义4.条件编译5.调试代码的条件编译预定义宏示例：使用预定义宏宏运算符1.宏延续运算符(`\`)2.字符串化运算符（`#`）3.标记粘贴运算符（`##`）4.`defined()`运算符宏与函数的区别错误的宏使用正确的宏使用总结前言在C语言的编程过程中，预处理器（Preprocessor，简称C
    • MyBatis 框架简介 天之涯上上 mybatistomcatjava
      MyBatis框架简介MyBatis是一个优秀的Java持久层框架，它主要用于简化应用程序与数据库之间的交互。通过MyBatis，开发者可以直接编写SQL语句或使用XML映射文件来操作数据库，同时保持代码的灵活性和高效性。MyBatis以其易用性、灵活性和对SQL的强大支持而闻名，尤其适用于复杂查询和高度定制化的数据库操作场景。MyBatis的主要功能和特点1.持久化操作MyBatis通过将Jav
    • Maven 在尝试连接到 Maven Central 仓库超时的解决方案和排查步骤 天之涯上上 mavenjava
      Maven在尝试连接到MavenCentral仓库时超时。以下是一些可能的解决方案和排查步骤：1.检查网络连接确保你的网络连接正常，并且能够访问外网。Ping测试:pingrepo.maven.apache.orgTelnet测试:telnetrepo.maven.apache.org4432.配置代理如果你在公司网络中使用代理服务器，需要配置Maven使用代理。编辑settings.xml找到或
    • JAVA开发中 MyBatis XML 映射文件 的作用 天之涯上上 javamybatisxml
      MyBatisXML映射文件（通常是以.xml结尾的文件，例如UserMapper.xml）是MyBatis框架的重要组成部分，主要用于定义SQL语句、结果映射关系以及参数绑定。它的作用是将Java方法与SQL语句关联起来，实现持久化操作（如查询、插入、更新和删除）。以下是关于MyBatisXML映射文件的详细说明：1.XML映射文件的作用1.1定义SQL语句MyBatis的核心功能是操作数据库，
    • JAVA开发 在 Spring Boot 中集成 Swagger 天之涯上上 javaspringboot开发语言
      Swagger是一个广泛使用的API文档生成工具，可以帮助你自动生成和维护RESTfulAPI的文档。在不同的框架中集成Swagger通常需要添加相应的依赖项。以下是几种常见Java框架（如SpringBoot）中集成Swagger的依赖配置。在SpringBoot中集成SwaggerSpringBoot结合Swagger可以通过springfox-swagger2和springfox-swagg
    • 将类成员函数变为普通函数 HVACoder 笔记c++
      最近遇到一个需求，拿到一个库里面的接口注册一个回调函数，但是该注册函数的形式为typedefvoid(*FUNC)(void*msg);voidregListener(FUNCcallbak);即需要一个普通的函数但是我们需要在类内解析回调传过来的数据voidClassName::interface(void*msg){}直接将interface传给regListener则会报错。解决：//1.定
    • Python3【字符串】：文本操作的瑞士军刀 李智 - 重庆 Python精讲精练-从入门到实战python开发语言经验分享编程实战趣味编程编程技巧
      Python3【字符串】：文本操作的瑞士军刀内容简介本系列文章是为Python3学习者精心设计的一套全面、实用的学习指南，旨在帮助读者从基础入门到项目实战，全面提升编程能力。文章结构由5个版块组成，内容层层递进，逻辑清晰。基础速通：n个浓缩提炼的核心知识点，夯实编程基础；经典范例：10个贴近实际的应用场景，深入理解Python3的编程技巧和应用方法；避坑宝典：10个典型错误解析，提供解决方案，帮助
    • 使用Python实现并行计算算法：效率提升的利器 Echo_Wish Python进阶python算法开发语言
      在处理大规模数据和计算密集型任务时，单线程的处理方式往往显得力不从心。并行计算作为一种提升计算效率的重要手段，能够充分利用多核处理器的优势，加速任务的完成。Python作为一种灵活且功能强大的编程语言，提供了丰富的并行计算工具。本文将详细介绍如何使用Python实现并行计算算法，并通过具体代码示例展示其实现过程。项目概述本项目旨在通过Python实现一个并行计算算法，展示如何利用Python的多线
    • 学不会设计模式？来看看这些简单又实用的手写代码！ 程序员小续 javascript开发语言ecmascript前端框架前端react.jsvue.js
      1.单例模式(Singleton)特点：确保一个类只有一个实例，并提供全局访问点。用途：常用于全局状态管理、配置管理等。classSingleton{constructor(name){if(Singleton.instance)returnSingleton.instance;//如果已有实例，返回该实例this.name=name;Singleton.instance=this;//保存实例}
    • 新闻软文发稿是什么？有什么优势？ 正义侠新闻软文 新闻软文发稿搜索引擎百度新浪微博经验分享
      把软文以新闻稿件的方式散布出来，完成推广营销的目地，归属于互联网推广的一种技巧。伴随着互联网技术愈来愈关键，企业一般刚开始高度重视互联网推广，也想要在网上宣传上资金投入大量资产。软文发稿便是在那样的土壤层中渐渐地发展趋势起来。软文发稿必须把软文公布到别的服务平台上才行，现阶段较为时兴的服务平台有主流媒体、新闻媒体、自媒体、社交媒体，这种服务平台全是收费标准才可以公布的，并不是完全免费的。此外也是有
    • 微服务中常用注解 陈鹏的博客 分布式微服务java后端
      1.@Component（spring注解）用来标注将普通类交给Spring管理。交给Spring管理就是注册到spring容器中，让spring帮你创建对象。可以通过spring容器获得该对象。相当于springxml配置文件中的bean标签2.@Repository（spring注解）用来标注将mapper层接口的实现类交给Spring管理。@Component的衍生注解，用于标注mapper
    • 华为OD机试2024年E卷-分苹果[100分]（ Java | Python3 | C++ | C语言 | JsNode | Go ）实现100%通过率 梅花C 华为OD题库华为od
      题目描述A、B两个人把苹果分为两堆，A希望按照他的计算规则等分苹果Q，他的计算规则是按照二进制加法计算，并且不计算进位12+5=9(1100+0101=9)，B的计算规则是十进制加法，包括正常进位，B希望在满足A的情况下获取苹果重量最多。输入苹果的数量和每个苹果重量，输出满足A的情况下B获取的苹果总重量。如果无法满足A的要求，输出-1。数据范围1<=总苹果数量<=200001<=每个苹果重量<=1
    • python做并行计算_python做并行计算可以吗 角动量不守恒 python做并行计算
      python可以做并行计算，下面是相关介绍：一、概览ParallelPython是一个python模块，提供在SMP(具有多个处理器或多核的系统)和集群(通过网络连接的计算机)上并行执行python代码的机制。它轻巧，易于安装和与其他python软件集成。ParallelPython是一个用纯Python编写的开源和跨平台模块。二、特性在SMP和集群上并行执行python代码易于理解和实现基于Jo
    • MySQL 执行计划：优化查询性能 J老熊 MySQL实战秘籍mysql数据库开发语言后端面试性能优化系统架构
      一、什么是MySQL执行计划？MySQL执行计划（ExecutionPlan）是MySQL在执行SQL查询时，所采取的具体执行策略。它描述了查询如何从数据库中获取数据，执行的步骤顺序以及使用的索引等信息。通过执行计划，我们可以直观地看到查询语句的执行路径，从而判断是否可以优化。二、如何查看MySQL执行计划？查看执行计划有几种方式：EXPLAIN语句使用EXPLAIN可以查看单个查询的执行计划。例
    • JavaFX 实现 Loading 效果的组件与案例详解 J老熊 java服务器开发语言后端面试系统架构软件工程
      JavaFX中的Loading组件概述JavaFX提供了两个用于显示任务进度的核心组件：ProgressIndicator：以圆形动画的形式展示任务进度，适用于未定义进度的任务。ProgressBar：以水平条的形式展示任务进度，适用于可以量化进度的任务。这两个组件可直接绑定到后台任务的progress属性，实时更新界面。1.ProgressBar的常见方法ProgressBar是以水平条的形式显
    • python并行计算 weixin_30894389
      0.基础并行/发：multiprocessing/threading1.concurrent2.并发：asynico3.Ipython下的并行计算：使用ipyparallel库的IPython提供了前所未有的能力，将科学Python的探索能力与几乎即时访问多个计算核心相结合。系统可以直观地与本地或网络的计算节点集群进行交互，而不管集群的实现方式如何。这种易于交互使用帮助IPython和Python
    • Kafka 消息存储与销毁机制 AI天才研究院 大数据AI人工智能计算kafkawpf分布式
      Kafka消息存储与销毁机制文章目录Kafka消息存储与销毁机制1.背景介绍1.1什么是Kafka1.2Kafka的基本概念解释2.核心概念与联系2.1消息存储机制2.2消息销毁机制2.3分区与副本机制3.核心算法原理具体操作步骤3.1消息存储过程3.2消息消费过程3.3消息销毁过程3.4分区副本同步过程4.数学模型和公式详细讲解举例说明4.1消息存储模型4.2消息销毁模型4.3分区副本同步模型5
    • Python并行计算：提高效率的利器 uote_e pythonjavalinuxPython
      在现代计算领域中，处理大规模数据和复杂计算任务是常见的挑战。为了应对这些挑战，一种常见的解决方案是利用并行计算技术。Python作为一种流行的编程语言，也提供了强大的工具和库来支持并行计算。本文将介绍Python中的并行计算概念和技术，并提供一些示例代码。并行计算简介并行计算是指同时执行多个计算任务，以提高计算效率。在传统的串行计算中，任务是按顺序依次执行的，而并行计算可以将任务分解成多个子任务，
    • 总结：IDEA社区版接入AI代码工具 小魏的博客 机器学习大语言模型IDE相关软件intellij-ideajavaide
      一、介绍本文主要记录下IDEA工具接入通义灵码、deepseek（深度求索）、豆包的方式。idea社区版（我的具体是：IntelliJIDEA2023.2.5(CommunityEdition)）二、deepseek配置1、首先得去deepseek平台创建个apikey；生成key位置：DeepSeek默认会送500万的tokens，查看tokens用量：DeepSeek2、安装AutoDev插件
    • 使用IDEA创建一个SpringBoot项目 web13293720476 面试学习路线阿里巴巴springbootintellij-ideajava服务器linux
      文章目录一、SpringBoot是什么？二、使用idea创建SpringBoot项目1.使用idea的SpringInitiallizr创建项目2.初步配置3.编写简单代码及运行4.两个好玩的小东西总结一、SpringBoot是什么？Spring框架是Java平台上的一种开源应用框架，提供具有控制反转特性的容器。SpringBoot基于Spring4.0设计，不仅继承了Spring框架原有的优秀特
    • PointNet++改进策略 ：模块改进 | OA-CNNs | ， 全自适应3D稀疏卷积神经网络（OA-CNNs），超越基于Transformer的模型，同时显著降低计算和内存成本 我是瓦力 PointNet++改进策略3dtransformer深度学习计算机视觉人工智能神经网络
      目录介绍核心思想及其实现引入空间自适应感受野自适应关系卷积（ARConv）网络整体架构设计训练和验证实验与评估如何改进PointNet++引入空间自适应感受野引入自适应关系学习利用自适应聚合器论文题目：OA-CNNs:Omni-AdaptiveSparseCNNsfor3DSemanticSegmentation发布期刊：CVPR2024作者地址：1香港中文大学2香港大学3香港中文大学，深圳4HI
    • 遍历dom 并且存储（将每一层的DOM元素存在数组中） 换个号韩国红果果 JavaScripthtml
      数组从0开始！！ var a=[],i=0; for(var j=0;j<30;j++){ a[j]=[];//数组里套数组，且第i层存储在第a[i]中 } function walkDOM(n){ do{ if(n.nodeType!==3)//筛选去除#text类型 a[i].push(n); //con
    • Android+Jquery Mobile学习系列(9)-总结和代码分享 白糖_ JQuery Mobile
      目录导航   经过一个多月的边学习边练手，学会了Android基于Web开发的毛皮，其实开发过程中用Android原生API不是很多，更多的是HTML/Javascript/Css。   个人觉得基于WebView的Jquery Mobile开发有以下优点： 1、对于刚从Java Web转型过来的同学非常适合，只要懂得HTML开发就可以上手做事。 2、jquerym
    • impala参考资料 dayutianfei impala
      记录一些有用的Impala资料   1. 入门资料 >>官网翻译：     http://my.oschina.net/weiqingbin/blog?catalog=423691   2. 实用进阶 >>代码&架构分析：     Impala/Hive现状分析与前景展望：http
    • JAVA 静态变量与非静态变量初始化顺序之新解 周凡杨 java静态非静态顺序
      今天和同事争论一问题，关于静态变量与非静态变量的初始化顺序，谁先谁后，最终想整理出来！测试代码： import java.util.Map; public class T { public static T t = new T(); private Map map = new HashMap(); public T(){ System.out.println(&quo
    • 跳出iframe返回外层页面 g21121 iframe
      在web开发过程中难免要用到iframe，但当连接超时或跳转到公共页面时就会出现超时页面显示在iframe中，这时我们就需要跳出这个iframe到达一个公共页面去。 首先跳转到一个中间页，这个页面用于判断是否在iframe中，在页面加载的过程中调用如下代码： <script type="text/javascript"> //<!-- function
    • JAVA多线程监听JMS、MQ队列 510888780 java多线程
      背景：消息队列中有非常多的消息需要处理，并且监听器onMessage（）方法中的业务逻辑也相对比较复杂，为了加快队列消息的读取、处理速度。可以通过加快读取速度和加快处理速度来考虑。因此从这两个方面都使用多线程来处理。对于消息处理的业务处理逻辑用线程池来做。对于加快消息监听读取速度可以使用1.使用多个监听器监听一个队列；2.使用一个监听器开启多线程监听。 对于上面提到的方法2使用一个监听器开启多线
    • 第一个SpringMvc例子 布衣凌宇 spring mvc
      第一步：导入需要的包； 第二步：配置web.xml文件 <?xml version="1.0" encoding="UTF-8"?> <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi=
    • 我的spring学习笔记15-容器扩展点之PropertyOverrideConfigurer aijuans Spring3
      PropertyOverrideConfigurer类似于PropertyPlaceholderConfigurer，但是与后者相比，前者对于bean属性可以有缺省值或者根本没有值。也就是说如果properties文件中没有某个bean属性的内容，那么将使用上下文（配置的xml文件）中相应定义的值。如果properties文件中有bean属性的内容，那么就用properties文件中的值来代替上下
    • 通过XSD验证XML antlove xmlschemaxsdvalidationSchemaFactory
      1. XmlValidation.java package xml.validation; import java.io.InputStream; import javax.xml.XMLConstants; import javax.xml.transform.stream.StreamSource; import javax.xml.validation.Schem
    • 文本流与字符集 百合不是茶 PrintWrite()的使用字符集名字 别名获取
      文本数据的输入输出;           输入;数据流,缓冲流         输出;介绍向文本打印格式化的输出PrintWrite();   package 文本流; import java.io.FileNotFound
    • ibatis模糊查询sqlmap-mapping-**.xml配置 bijian1013 ibatis
              正常我们写ibatis的sqlmap-mapping-*.xml文件时，传入的参数都用##标识，如下所示： <resultMap id="personInfo" class="com.bijian.study.dto.PersonDTO"> <res
    • java jvm常用命令工具——jdb命令(The Java Debugger) bijian1013 javajvmjdb
              用来对core文件和正在运行的Java进程进行实时地调试，里面包含了丰富的命令帮助您进行调试，它的功能和Sun studio里面所带的dbx非常相似，但 jdb是专门用来针对Java应用程序的。         现在应该说日常的开发中很少用到JDB了，因为现在的IDE已经帮我们封装好了，如使用ECLI
    • 【Spring框架二】Spring常用注解之Component、Repository、Service和Controller注解 bit1129 controller
      在Spring常用注解第一步部分【Spring框架一】Spring常用注解之Autowired和Resource注解（http://bit1129.iteye.com/blog/2114084）中介绍了Autowired和Resource两个注解的功能，它们用于将依赖根据名称或者类型进行自动的注入，这简化了在XML中，依赖注入部分的XML的编写，但是UserDao和UserService两个bea
    • cxf wsdl2java生成代码super出错,构造函数不匹配 bitray super
          由于过去对于soap协议的cxf接触的不是很多,所以遇到了也是迷糊了一会.后来经过查找资料才得以解决. 初始原因一般是由于jaxws2.2规范和jdk6及以上不兼容导致的.所以要强制降为jaxws2.1进行编译生成.我们需要少量的修改: 我们原来的代码 wsdl2java com.test.xxx -client http://..... 修改后的代
    • 动态页面正文部分中文乱码排障一例 ronin47
      公司网站一部分动态页面，早先使用apache+resin的架构运行，考虑到高并发访问下的响应性能问题，在前不久逐步开始用nginx替换掉了apache。 不过随后发现了一个问题，随意进入某一有分页的网页，第一页是正常的（因为静态化过了）；点“下一页”，出来的页面两边正常，中间部分的标题、关键字等也正常，唯独每个标题下的正文无法正常显示。 因为有做过系统调整，所以第一反应就是新上
    • java-54- 调整数组顺序使奇数位于偶数前面 bylijinnan java
      import java.util.Arrays; import java.util.Random; import ljn.help.Helper; public class OddBeforeEven { /** * Q 54 调整数组顺序使奇数位于偶数前面 * 输入一个整数数组，调整数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半
    • 从100PV到1亿级PV网站架构演变 cfyme 网站架构
      一个网站就像一个人，存在一个从小到大的过程。养一个网站和养一个人一样，不同时期需要不同的方法，不同的方法下有共同的原则。本文结合我自已14年网站人的经历记录一些架构演变中的体会。 1：积累是必不可少的 架构师不是一天练成的。 1999年，我作了一个个人主页，在学校内的虚拟空间，参加了一次主页大赛，几个DREAMWEAVER的页面，几个TABLE作布局，一个DB连接，几行PHP的代码嵌入在HTM
    • [宇宙时代]宇宙时代的GIS是什么？ comsci Gis
             我们都知道一个事实，在行星内部的时候，因为地理信息的坐标都是相对固定的，所以我们获取一组GIS数据之后，就可以存储到硬盘中，长久使用。。。但是，请注意，这种经验在宇宙时代是不能够被继续使用的          宇宙是一个高维时空
    • 详解create database命令 czmmiao database
      完整命令 CREATE DATABASE mynewdb   USER SYS IDENTIFIED BY sys_password   USER SYSTEM IDENTIFIED BY system_password   LOGFILE GROUP 1 ('/u01/logs/my/redo01a.log','/u02/logs/m
    • 几句不中听却不得不认可的话 datageek
      1、人丑就该多读书。 2、你不快乐是因为：你可以像猪一样懒，却无法像只猪一样懒得心安理得。 3、如果你太在意别人的看法，那么你的生活将变成一件裤衩，别人放什么屁，你都得接着。 4、你的问题主要在于：读书不多而买书太多，读书太少又特爱思考，还他妈话痨。 5、与禽兽搏斗的三种结局：(1)、赢了，比禽兽还禽兽。(2)、输了，禽兽不如。(3)、平了，跟禽兽没两样。结论：选择正确的对手很重要。 6
    • 1 14:00 PHP中的“syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM”错误 dcj3sjt126com PHP
      原文地址：http://www.kafka0102.com/2010/08/281.html   因为需要，今天晚些在本机使用PHP做些测试，PHP脚本依赖了一堆我也不清楚做什么用的库。结果一跑起来，就报出类似下面的错误：“Parse error: syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM in /home/kafka/test/
    • xcode6 Auto layout and size classes dcj3sjt126com ios
      官方GUI   https://developer.apple.com/library/ios/documentation/UserExperience/Conceptual/AutolayoutPG/Introduction/Introduction.html   iOS中使用自动布局（一）   http://www.cocoachina.com/ind
    • 通过PreparedStatement批量执行sql语句【sql语句相同，值不同】 梦见x光 sql事务批量执行
      比如说：我有一个List需要添加到数据库中，那么我该如何通过PreparedStatement来操作呢？ public void addCustomerByCommit(Connection conn , List<Customer> customerList) {    String sql = "inseret into customer(id
    • 程序员必知必会----linux常用命令之十【系统相关】 hanqunfeng Linux常用命令
      一.linux快捷键 Ctrl+C : 终止当前命令 Ctrl+S : 暂停屏幕输出 Ctrl+Q : 恢复屏幕输出 Ctrl+U : 删除当前行光标前的所有字符 Ctrl+Z : 挂起当前正在执行的进程 Ctrl+L : 清除终端屏幕，相当于clear   二.终端命令 clear : 清除终端屏幕 reset : 重置视窗，当屏幕编码混乱时使用 time com
    • NGINX IXHONG nginx
      pcre 编译安装 nginx conf/vhost/test.conf   upstream admin { server 127.0.0.1:8080; }   server {                 listen       80; &
    • 设计模式--工厂模式 kerryg 设计模式
      工厂方式模式分为三种：   1、普通工厂模式：建立一个工厂类，对实现了同一个接口的一些类进行实例的创建。   2、多个工厂方法的模式：就是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式就是提供多个工厂方法，分别创建对象。   3、静态工厂方法模式：就是将上面的多个工厂方法模式里的方法置为静态，
    • Spring InitializingBean/init-method和DisposableBean/destroy-method mx_xiehd javaspringbeanxml
      1.initializingBean/init-method 实现org.springframework.beans.factory.InitializingBean接口允许一个bean在它的所有必须属性被BeanFactory设置后，来执行初始化的工作，InitialzingBean仅仅指定了一个方法。 通常InitializingBean接口的使用是能够被避免的，（不鼓励使用，因为没有必要
    • 解决Centos下vim粘贴内容格式混乱问题 qindongliang1922 centosvim
      有时候，我们在向vim打开的一个xml，或者任意文件中，拷贝粘贴的代码时，格式莫名其毛的就混乱了，然后自己一个个再重新，把格式排列好，非常耗时，而且很不爽，那么有没有办法避免呢？ 答案是肯定的，设置下缩进格式就可以了，非常简单： 在用户的根目录下 直接vi  ~/.vimrc文件 然后将set pastetoggle=<F9> 写入这个文件中，保存退出，重新登录，
    • netty大并发请求问题 tianzhihehe netty
      多线程并发使用同一个channel java.nio.BufferOverflowException: null at java.nio.HeapByteBuffer.put(HeapByteBuffer.java:183) ~[na:1.7.0_60-ea] at java.nio.ByteBuffer.put(ByteBuffer.java:832) ~[na:1.7.0_60-ea]
    • Hadoop NameNode单点问题解决方案之一 AvatarNode wyz2009107220 NameNode
      我们遇到的情况 Hadoop NameNode存在单点问题。这个问题会影响分布式平台24*7运行。先说说我们的情况吧。 我们的团队负责管理一个1200节点的集群(总大小12PB)，目前是运行版本为Hadoop 0.20，transaction logs写入一个共享的NFS filer(注：NetApp NFS Filer)。 经常遇到需要中断服务的问题是给hadoop打补丁。 DataNod
    按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他