@Override
public boolean addOrUpdate(TagModel tagModel) {
    // ---
}

java -jar arthas-boot.jar

@ApiModelProperty("页大小")
@Max(50)
private Integer pageSize = 10;

@ApiModelProperty("游标(初始为null,后续请求附带上一次翻页的游标)")
private String cursor;

@Data
@ApiModel("游标翻页返回")
@AllArgsConstructor
@NoArgsConstructor
public class CursorPageBaseResp<T> {

    @ApiModelProperty("游标（下次翻页带上这参数）")
    private String cursor;

    @ApiModelProperty("是否最后一页")
    private Boolean isLast = Boolean.FALSE;

    @ApiModelProperty("数据列表")
    private List<T> list;

    public static <T> CursorPageBaseResp<T> init(CursorPageBaseResp cursorPage, List<T> list) {
        CursorPageBaseResp<T> cursorPageBaseResp = new CursorPageBaseResp<T>();
        cursorPageBaseResp.setIsLast(cursorPage.getIsLast());
        cursorPageBaseResp.setList(list);
        cursorPageBaseResp.setCursor(cursorPage.getCursor());
        return cursorPageBaseResp;
    }

    @JsonIgnore
    public Boolean isEmpty() {
        return CollectionUtil.isEmpty(list);
    }

    public static <T> CursorPageBaseResp<T> empty() {
        CursorPageBaseResp<T> cursorPageBaseResp = new CursorPageBaseResp<T>();
        cursorPageBaseResp.setIsLast(true);
        cursorPageBaseResp.setList(new ArrayList<T>());
        return cursorPageBaseResp;
    }

}

public class CursorUtils {

    public static <T> CursorPageBaseResp<Pair<T, Double>> getCursorPageByRedis(CursorPageBaseReq cursorPageBaseReq, String redisKey, Function<String, T> typeConvert) {
        Set<ZSetOperations.TypedTuple<String>> typedTuples;
        if (StrUtil.isBlank(cursorPageBaseReq.getCursor())) {//第一次
            typedTuples = RedisUtils.zReverseRangeWithScores(redisKey, cursorPageBaseReq.getPageSize());
        } else {
            typedTuples = RedisUtils.zReverseRangeByScoreWithScores(redisKey, Double.parseDouble(cursorPageBaseReq.getCursor()), cursorPageBaseReq.getPageSize());
        }
        List<Pair<T, Double>> result = typedTuples
                .stream()
                .map(t -> Pair.of(typeConvert.apply(t.getValue()), t.getScore()))
                .sorted((o1, o2) -> o2.getValue().compareTo(o1.getValue()))
                .collect(Collectors.toList());
        String cursor = Optional.ofNullable(CollectionUtil.getLast(result))
                .map(Pair::getValue)
                .map(String::valueOf)
                .orElse(null);
        Boolean isLast = result.size() != cursorPageBaseReq.getPageSize();
        return new CursorPageBaseResp<>(cursor, isLast, result);
    }

    public static <T> CursorPageBaseResp<T> getCursorPageByMysql(IService<T> mapper, CursorPageBaseReq request, Consumer<LambdaQueryWrapper<T>> initWrapper, SFunction<T, ?> cursorColumn) {
        //游标字段类型
        Class<?> cursorType = LambdaUtils.getReturnType(cursorColumn);
        LambdaQueryWrapper<T> wrapper = new LambdaQueryWrapper<>();
        //额外条件
        initWrapper.accept(wrapper);
        //游标条件
        if (StrUtil.isNotBlank(request.getCursor())) {
            wrapper.lt(cursorColumn, parseCursor(request.getCursor(), cursorType));
        }
        //游标方向
        wrapper.orderByDesc(cursorColumn);

        Page<T> page = mapper.page(request.plusPage(), wrapper);
        //取出游标
        String cursor = Optional.ofNullable(CollectionUtil.getLast(page.getRecords()))
                .map(cursorColumn)
                .map(CursorUtils::toCursor)
                .orElse(null);
        //判断是否最后一页
        Boolean isLast = page.getRecords().size() != request.getPageSize();
        return new CursorPageBaseResp<>(cursor, isLast, page.getRecords());
    }

    private static String toCursor(Object o) {
        if (o instanceof Date) {
            return String.valueOf(((Date) o).getTime());
        } else {
            return o.toString();
        }
    }

    private static Object parseCursor(String cursor, Class<?> cursorClass) {
        if (Date.class.isAssignableFrom(cursorClass)) {
            return new Date(Long.parseLong(cursor));
        } else {
            return cursor;
        }
    }
}

public class LambdaUtils {
    /**
     * 字段映射
     */
    private static final Map<String, Map<String, ColumnCache>> COLUMN_CACHE_MAP = new ConcurrentHashMap<>();

    /**
     * SerializedLambda 反序列化缓存
     */
    private static final Map<String, WeakReference<com.baomidou.mybatisplus.core.toolkit.support.SerializedLambda>> FUNC_CACHE = new ConcurrentHashMap<>();

    private static Pattern RETURN_TYPE_PATTERN = Pattern.compile("\\(.*\\)L(.*);");
    private static Pattern PARAMETER_TYPE_PATTERN = Pattern.compile("\\((.*)\\).*");
    private static final WeakConcurrentMap<String, SerializedLambda> cache = new WeakConcurrentMap<>();

    /**
     * 获取Lambda表达式返回类型
     */
    public static Class<?> getReturnType(Serializable serializable) {
        String expr = _resolve(serializable).getInstantiatedMethodType();
        Matcher matcher = RETURN_TYPE_PATTERN.matcher(expr);
        if (!matcher.find() || matcher.groupCount() != 1) {
            throw new RuntimeException("获取Lambda信息失败");
        }
        String className = matcher.group(1).replace("/", ".");
        try {
            return Class.forName(className);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException("无法加载类", e);
        }
    }

    @SneakyThrows
    public static <T> Class<?> getReturnType(SFunction<T, ?> func) {
        com.baomidou.mybatisplus.core.toolkit.support.SerializedLambda lambda = com.baomidou.mybatisplus.core.toolkit.LambdaUtils.resolve(func);
        Class<?> aClass = lambda.getInstantiatedType();
        String fieldName = PropertyNamer.methodToProperty(lambda.getImplMethodName());
        Field field = aClass.getDeclaredField(fieldName);
        field.setAccessible(true);
        return field.getType();
    }

    /**
     * 获取Lambda表达式的参数类型
     */
    public static List<Class<?>> getParameterTypes(Serializable serializable) {
        String expr = _resolve(serializable).getInstantiatedMethodType();
        Matcher matcher = PARAMETER_TYPE_PATTERN.matcher(expr);
        if (!matcher.find() || matcher.groupCount() != 1) {
            throw new RuntimeException("获取Lambda信息失败");
        }
        expr = matcher.group(1);

        return Arrays.stream(expr.split(";"))
                .filter(StrUtil::isNotBlank)
                .map(s -> s.replace("L", "").replace("/", "."))
                .map(s -> {
                    try {
                        return Class.forName(s);
                    } catch (ClassNotFoundException e) {
                        throw new RuntimeException("无法加载类", e);
                    }
                })
                .collect(Collectors.toList());
    }

    /**
     * 解析lambda表达式,加了缓存。
     * 该缓存可能会在任意不定的时间被清除。
     *
     * <p>
     * 通过反射调用实现序列化接口函数对象的writeReplace方法，从而拿到{@link SerializedLambda}<br>
     * 该对象中包含了lambda表达式的所有信息。
     * </p>
     *
     * @param func 需要解析的 lambda 对象
     * @return 返回解析后的结果
     */
    private static SerializedLambda _resolve(Serializable func) {
        return cache.computeIfAbsent(func.getClass().getName(), (key)
                -> ReflectUtil.invoke(func, "writeReplace"));
    }

}

@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(OssProperties.class)
@ConditionalOnExpression("${oss.enabled}")
@ConditionalOnProperty(value = "oss.type", havingValue = "minio")
public class MinIOConfiguration {
    @Bean
    @SneakyThrows
    @ConditionalOnMissingBean(MinioClient.class)
    public MinioClient minioClient(OssProperties ossProperties) {
        return MinioClient.builder()
                .endpoint(ossProperties.getEndpoint())
                .credentials(ossProperties.getAccessKey(), ossProperties.getSecretKey())
                .build();
    }
    @Bean
    @ConditionalOnBean({MinioClient.class})
    @ConditionalOnMissingBean(MinIOTemplate.class)
    public MinIOTemplate minioTemplate(MinioClient minioClient, OssProperties ossProperties) {
        return new MinIOTemplate(minioClient, ossProperties);
    }
}

@Data
@ConfigurationProperties(prefix = "oss")
public class OssProperties {

    /**
     * 是否开启
     */
    Boolean enabled;

    /**
     * 存储对象服务器类型
     */
    OssType type;

    /**
     * OSS 访问端点，集群时需提供统一入口
     */
    String endpoint;

    /**
     * 用户名
     */
    String accessKey;

    /**
     * 密码
     */
    String secretKey;

    /**
     * 存储桶
     */
    String bucketName;
}

final int getState();
final void setState();
final boolean compareAndSetState();

public abstract class AbstractOwnableSynchronizer implements java.io.Serializable {
    private static final long serialVersionUID = 3737899427754241961L;
    protected AbstractOwnableSynchronizer() { }

    /**
     * 目前持有独占锁的线程
     * The current owner of exclusive mode synchronization.
     */
    private transient Thread exclusiveOwnerThread;

    /**
     * 此项用于设置上述属性的值
     * Sets the thread that currently owns exclusive access.
     * A {@code null} argument indicates that no thread owns access.
     * This method does not otherwise impose any synchronization or
     * {@code volatile} field accesses.
     * @param thread the owner thread
     */
    protected final void setExclusiveOwnerThread(Thread thread) {
        exclusiveOwnerThread = thread; 
    }

    /**
     * 此项用于获取上述属性的值
     * Returns the thread last set by {@code setExclusiveOwnerThread},
     * or {@code null} if never set.  This method does not otherwise
     * impose any synchronization or {@code volatile} field accesses.
     * @return the owner thread
     */
    protected final Thread getExclusiveOwnerThread() {
        return exclusiveOwnerThread;
    }
}

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {

    private static final long serialVersionUID = 7373984972572414691L;

    protected AbstractQueuedSynchronizer() { }

    /**
     * Head of the wait queue, lazily initialized.  Except for
     * initialization, it is modified only via method setHead.  Note:
     * If head exists, its waitStatus is guaranteed not to be
     * CANCELLED.
     */
    private transient volatile Node head;

    /**
     * Tail of the wait queue, lazily initialized.  Modified only via
     * method enq to add new wait node.
     */
    private transient volatile Node tail;

    /**
     * The synchronization state.
     */
    private volatile int state;

    /**
     * Returns the current value of synchronization state.
     * This operation has memory semantics of a {@code volatile} read.
     * @return current state value
     */
    protected final int getState() {
        return state;
    }

    /**
     * Sets the value of synchronization state.
     * This operation has memory semantics of a {@code volatile} write.
     * @param newState the new state value
     */
    protected final void setState(int newState) {
        state = newState;
    }

    /**
     * Atomically sets synchronization state to the given updated
     * value if the current state value equals the expected value.
     * This operation has memory semantics of a {@code volatile} read
     * and write.
     *
     * @param expect the expected value
     * @param update the new value
     * @return {@code true} if successful. False return indicates that the actual
     *         value was not equal to the expected value.
     */
    protected final boolean compareAndSetState(int expect, int update) {
        // See below for intrinsics setup to support this
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }

    // Queuing utilities

    /**
     * The number of nanoseconds for which it is faster to spin
     * rather than to use timed park. A rough estimate suffices
     * to improve responsiveness with very short timeouts.
     */
    static final long spinForTimeoutThreshold = 1000L;
    
}

static final class Node {
    /** 共享 -- 共享锁 */
    static final Node SHARED = new Node();
    /** 排他 -- 独占锁 */     
    static final Node EXCLUSIVE = null;
    /** 当前等待的线程可能因为其他原因而取消 */
    static final int CANCELLED =  1;
    /** 下一个节点需要被唤醒 */
    static final int SIGNAL    = -1;

    /** 用于条件队列 */
    static final int CONDITION = -2;
    /** 用于共享锁 */
    static final int PROPAGATE = -3;

    volatile int waitStatus; // 初始化为0，枚举值使用上面的值

    /**
     * 前驱节点
     */
    volatile Node prev;

    /**
     * 后继节点
     */
    volatile Node next;

    /**
     * The thread that enqueued this node.  Initialized on
     * construction and nulled out after use.
     */
    volatile Thread thread;

    /**
     * 在条件队列指向的是下一个指针
     * 在同步队列中指向的是我们当前节点想获取的是共享锁还是排他锁
     */
    Node nextWaiter;

    /**
     * Returns true if node is waiting in shared mode.
     */
    final boolean isShared() {
        return nextWaiter == SHARED;
    }

    /**
     * Returns previous node, or throws NullPointerException if null.
     * Use when predecessor cannot be null.  The null check could
     * be elided, but is present to help the VM.
     *
     * @return the predecessor of this node
     */
    final Node predecessor() throws NullPointerException {
        Node p = prev;
        if (p == null)
            throw new NullPointerException();
        else
            return p;
    }

    Node() {    // Used to establish initial head or SHARED marker
    }

    Node(Thread thread, Node mode) {     // Used by addWaiter
        this.nextWaiter = mode;
        this.thread = thread;
    }

    Node(Thread thread, int waitStatus) { // Used by Condition
        this.waitStatus = waitStatus;
        this.thread = thread;
    }
}

Lock lock = new ReentrantLock();
lock.lock();

public void lock() {
    sync.lock();
}

static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    /**
    * Performs lock.  Try immediate barge, backing up to normal
    * acquire on failure.
    */
    final void lock() {
        if (compareAndSetState(0, 1)) // expect: 0（无锁）  update: 1（已经有一个线程加锁）如果大于1，则代表同一个线程多次加锁
            setExclusiveOwnerThread(Thread.currentThread()); // 如果成功获取锁，那么把当前线程设置为 持有锁的线程
        else
            acquire(1);// 如果获取锁失败，我们知道，如果一个线程多次获取锁，其实就是一个自增的情况（每次加 1）
    }

    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException();
}

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread(); // 拿到当前线程
    int c = getState(); // 拿到状态
    if (c == 0) { 		// 没有加锁（state == 0）
        if (compareAndSetState(0, acquires)) { // 通过尝试使用CAS加锁
            setExclusiveOwnerThread(current);  // 设置当前线程持有锁
            return true;// 获取成功
        }
    }
    // 判断是不是重入锁，如果 当前持有锁的线程 是 当前线程
    else if (current == getExclusiveOwnerThread()) {
        // 尝试重入，在ReentrantLock中 acquire 其实就是1，有一次重入就加一
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            // 为什么会出现这个问题呢，因为如果重入次数过多超过int的最大值，此时再加1就会变成最小值（负数）
            throw new Error("Maximum lock count exceeded");
        setState(nextc); // 设置重入值
        return true;
    }
    return false;
}

// 方法签名
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)

// 没有打包的节点会被封装保存到队列里面
private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail; // AQS的尾指针
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);
    return node;
}
// 如果尾结点为空
private Node enq(final Node node) {
    // 死循环，不断自旋
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node())) // 通过CAS将虚拟头节点设置为头节点
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {  // 还是要通过CAS的方式设置尾指针
                t.next = node;
                return t; // 不断自旋，只有进入了else分支才会return出去
            }
        }
    }
}

// 方法定义（其实就是把获取锁失败的线程node给添加同步队列里面去）
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;			 // 是否获取锁成功
    try {
        boolean interrupted = false; // 在获取锁期间是否发送中断
        for (;;) {
            final Node p = node.predecessor();  // 前驱节点
            if (p == head && tryAcquire(arg)) { // 是否为头节点
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) && // 不可响应中断
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

/** 当前等待的线程可能因为其他原因而取消 */
static final int CANCELLED =  1;
/** 下一个节点需要被唤醒 */
static final int SIGNAL    = -1;
/** 用于条件队列 */
static final int CONDITION = -2;
/** 用于共享锁 */
static final int PROPAGATE = -3;

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL) // 前驱节点是SIGNAL则阻塞当前操作
        /*
         * This node has already set status asking a release
         * to signal it, so it can safely park.
         */
        return true;
    if (ws > 0) { // 不是多余的，因为其他的锁实现也是要走当前情况的
        /*
         * Predecessor was cancelled. Skip over predecessors and
         * indicate retry.
         */
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        /*
         * waitStatus must be 0 or PROPAGATE.  Indicate that we
         * need a signal, but don't park yet.  Caller will need to
         * retry to make sure it cannot acquire before parking.
         */
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

public interface BatchCache<IN, OUT> {
    /**
     * 获取单个
     */
    OUT get(IN req);

    /**
     * 获取批量
     */
    Map<IN, OUT> getBatch(List<IN> req);

    /**
     * 修改删除单个
     */
    void delete(IN req);

    /**
     * 修改删除多个
     */
    void deleteBatch(List<IN> req);
}

/**
 * 获取用户信息，盘路缓存模式
 */
public Map<Long, User> getUserInfoBatch(Set<Long> uids) {
    //批量组装key
    List<String> keys = uids.stream().map(a -> RedisKey.getKey(RedisKey.USER_INFO_STRING, a)).collect(Collectors.toList());
    //批量get
    List<User> mget = RedisUtils.mget(keys, User.class);
    Map<Long, User> map = mget.stream().filter(Objects::nonNull).collect(Collectors.toMap(User::getId, Function.identity()));
    //发现差集——还需要load更新的uid
    List<Long> needLoadUidList = uids.stream().filter(a -> !map.containsKey(a)).collect(Collectors.toList());
    if (CollUtil.isNotEmpty(needLoadUidList)) {
        //批量load
        List<User> needLoadUserList = userDao.listByIds(needLoadUidList);
        Map<String, User> redisMap = needLoadUserList.stream().collect(Collectors.toMap(a -> RedisKey.getKey(RedisKey.USER_INFO_STRING, a.getId()), Function.identity()));
        RedisUtils.mset(redisMap, 5 * 60);
        //加载回redis
        map.putAll(needLoadUserList.stream().collect(Collectors.toMap(User::getId, Function.identity())));
    }
    return map;
}

import cn.hutool.core.collection.CollectionUtil;
import com.calyee.chat.common.common.utils.RedisUtils;
import org.springframework.data.util.Pair;

import java.lang.reflect.ParameterizedType;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Description: redis string类型的批量缓存框架
 */
public abstract class AbstractRedisStringCache<IN, OUT> implements BatchCache<IN, OUT> {

    private Class<OUT> outClass;

    protected AbstractRedisStringCache() {
        ParameterizedType genericSuperclass = (ParameterizedType) this.getClass().getGenericSuperclass();
        this.outClass = (Class<OUT>) genericSuperclass.getActualTypeArguments()[1];
    }

    protected abstract String getKey(IN req);

    protected abstract Long getExpireSeconds();

    protected abstract Map<IN, OUT> load(List<IN> req);

    @Override
    public OUT get(IN req) {
        return getBatch(Collections.singletonList(req)).get(req);
    }

    @Override
    public Map<IN, OUT> getBatch(List<IN> req) {
        if (CollectionUtil.isEmpty(req)) {//防御性编程
            return new HashMap<>();
        }
        //去重
        req = req.stream().distinct().collect(Collectors.toList());
        //组装key
        List<String> keys = req.stream().map(this::getKey).collect(Collectors.toList());
        //批量get
        List<OUT> valueList = RedisUtils.mget(keys, outClass);
        //差集计算
        List<IN> loadReqs = new ArrayList<>();
        for (int i = 0; i < valueList.size(); i++) {
            if (Objects.isNull(valueList.get(i))) {
                loadReqs.add(req.get(i));
            }
        }
        Map<IN, OUT> load = new HashMap<>();
        //不足的重新加载进redis
        if (CollectionUtil.isNotEmpty(loadReqs)) {
            //批量load
            load = load(loadReqs);
            Map<String, OUT> loadMap = load.entrySet().stream()
                    .map(a -> Pair.of(getKey(a.getKey()), a.getValue()))
                    .collect(Collectors.toMap(Pair::getFirst, Pair::getSecond));
            RedisUtils.mset(loadMap, getExpireSeconds());
        }

        //组装最后的结果
        Map<IN, OUT> resultMap = new HashMap<>();
        for (int i = 0; i < req.size(); i++) {
            IN in = req.get(i);
            OUT out = Optional.ofNullable(valueList.get(i))
                    .orElse(load.get(in));
            resultMap.put(in, out);
        }
        return resultMap;
    }

    @Override
    public void delete(IN req) {
        deleteBatch(Collections.singletonList(req));
    }

    @Override
    public void deleteBatch(List<IN> req) {
        List<String> keys = req.stream().map(this::getKey).collect(Collectors.toList());
        RedisUtils.del(keys);
    }
}

@Component
public class UserInfoCache extends AbstractRedisStringCache<Long, User> {
    @Autowired
    private UserDao userDao;

    @Override
    protected String getKey(Long uid) {
        return RedisKey.getKey(RedisKey.USER_INFO_STRING, uid);
    }

    @Override
    protected Long getExpireSeconds() {
        return 5 * 60L;
    }

    @Override
    protected Map<Long, User> load(List<Long> uidList) {
        List<User> needLoadUserList = userDao.listByIds(uidList);
        return needLoadUserList.stream().collect(Collectors.toMap(User::getId, Function.identity()));
    }
}

@Order
@Slf4j
@Component
public class CollectorInterceptor implements HandlerInterceptor, WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(this)
                .addPathPatterns("/**");
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        RequestInfo info = new RequestInfo();
        info.setUid(Optional.ofNullable(request.getAttribute(TokenInterceptor.ATTRIBUTE_UID)).map(Object::toString).map(Long::parseLong).orElse(null));
        info.setIp(ServletUtil.getClientIP(request));
        RequestHolder.set(info);
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        RequestHolder.remove();
    }
}

/**
 * Description: 消息处理器抽象类
 */
public abstract class AbstractMsgHandler<Req> {
    @Autowired
    private MessageDao messageDao;
    private Class<Req> bodyClass;

    @PostConstruct
    private void init() {
        ParameterizedType genericSuperclass = (ParameterizedType) this.getClass().getGenericSuperclass();
        this.bodyClass = (Class<Req>) genericSuperclass.getActualTypeArguments()[0];
        MsgHandlerFactory.register(getMsgTypeEnum().getType(), this);
    }

    /**
     * 消息类型
     */
    abstract MessageTypeEnum getMsgTypeEnum();

    protected void checkMsg(Req body, Long roomId, Long uid) {

    }

    @Transactional
    public Long checkAndSaveMsg(ChatMessageReq request, Long uid) {
        Req body = this.toBean(request.getBody());
        //统一校验
        AssertUtil.allCheckValidateThrow(body);
        //子类扩展校验
        checkMsg(body, request.getRoomId(), uid);
        Message insert = MessageAdapter.buildMsgSave(request, uid);
        //统一保存
        messageDao.save(insert);
        //子类扩展保存
        saveMsg(insert, body);
        return insert.getId();
    }
	// 
    private Req toBean(Object body) {
        if (bodyClass.isAssignableFrom(body.getClass())) {
            return (Req) body;
        }
        return BeanUtil.toBean(body, bodyClass);
    }
	// 需要保存的逻辑
    protected abstract void saveMsg(Message message, Req body);

    /**
     * 展示消息
     */
    public abstract Object showMsg(Message msg);

    /**
     * 被回复时——展示的消息
     */
    public abstract Object showReplyMsg(Message msg);

    /**
     * 会话列表——展示的消息
     */
    public abstract String showContactMsg(Message msg);

}

@Component
public class EmojisMsgHandler extends AbstractMsgHandler<EmojisMsgDTO> {
    @Autowired
    private MessageDao messageDao;

    @Override
    MessageTypeEnum getMsgTypeEnum() {
        return MessageTypeEnum.EMOJI;
    }

    @Override
    public void saveMsg(Message msg, EmojisMsgDTO body) {
        MessageExtra extra = Optional.ofNullable(msg.getExtra()).orElse(new MessageExtra());
        Message update = new Message();
        update.setId(msg.getId());
        update.setExtra(extra);
        extra.setEmojisMsgDTO(body);
        messageDao.updateById(update);
    }

    @Override
    public Object showMsg(Message msg) {
        return msg.getExtra().getEmojisMsgDTO();
    }

    @Override
    public Object showReplyMsg(Message msg) {
        return "表情";
    }

    @Override
    public String showContactMsg(Message msg) {
        return "[表情包]";
    }
}

public class MsgHandlerFactory {
    private static final Map<Integer, AbstractMsgHandler> STRATEGY_MAP = new HashMap<>();

    public static void register(Integer code, AbstractMsgHandler strategy) {
        STRATEGY_MAP.put(code, strategy);
    }

    public static AbstractMsgHandler getStrategyNoNull(Integer code) {
        AbstractMsgHandler strategy = STRATEGY_MAP.get(code);
        AssertUtil.isNotEmpty(strategy, CommonErrorEnum.PARAM_INVALID);
        return strategy;
    }
}

/**
* 发送消息
*/
@Override
@Transactional
public Long sendMsg(ChatMessageReq request, Long uid) {
    check(request, uid);
    AbstractMsgHandler<?> msgHandler = MsgHandlerFactory.getStrategyNoNull(request.getMsgType()); // 这里
    Long msgId = msgHandler.checkAndSaveMsg(request, uid);
    //发布消息发送事件
    applicationEventPublisher.publishEvent(new MessageSendEvent(this, msgId));
    return msgId;
}

CountModeType: 求和/平均 ...
Data: List<?>/String[] ...

import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName AbstractDataHandler
 * @Description 数据处理抽象类
 * @Author Calyee
 */

public abstract class AbstractDataHandler  {

    @PostConstruct
    private void init() {
        DataHandlerFactory.register(getCountModeEnums(), this);
    }
    /**
     * 获取模式类型
     *
     * @return CountModeEnums
     */
    public abstract CountModeEnums getCountModeEnums();
    public abstract Object processData(List<?> o);
}

import java.util.List;

/**
 * @ClassName SumHandler
 * @Description 求和处理
 * @Author Calyee
 */

@Component
public class OperationSumBaseDataHandler extends AbstractDataHandler {

    @Override
    public CountModeEnums getCountModeEnums() {
        return CountModeEnums.sum;
    }

@Override
    public Object processData(List<?> o) {
        Assert.notNull(o, "当前处理的数据不能为空");
        Object type = o.get(0);
        switch (type.getClass().getSimpleName()) {
            case "Integer":
                return o.stream()
                        .mapToInt(Integer.class::cast)
                        .sum();
            case "Long":
                return o.stream()
                        .mapToLong(Long.class::cast)
                        .sum();
            case "Double":
                return o.stream()
                        .mapToDouble(Double.class::cast)
                        .sum();
            case "Float":
                return o.stream()
                        .mapToDouble(Float.class::cast)
                        .sum();
            default:
                throw new RuntimeException("该类型暂不支持");
        }
    }
}

import org.springframework.util.Assert;

import java.util.HashMap;
import java.util.Map;

public class DataHandlerFactory {
    private static final Map<CountModeEnums, AbstractDataHandler> STRATEGY_MAP = new HashMap<>();

    public static void register(CountModeEnums enums, AbstractDataHandler strategy) {
        STRATEGY_MAP.put(enums, strategy);
    }

    public static AbstractDataHandler getStrategyNoNullByObj(Object o) {
        CountModeEnums countModeEnums = null;
        if (o instanceof Example) {
            Example p = (Example) o;
            countModeEnums = p.getCountModeEnums();
        }else if(){
            // 其他的枚举
        }else{
            
        }
        return haveSuitableStrategy(countModeEnums); // 拿到具体的策略
    }
    private static AbstractDataHandler haveSuitableStrategy(CountModeEnums enums) {
        AbstractDataHandler handler = STRATEGY_MAP.get(enums);
        Assert.notNull(handler, "没有对应的处理策略");
        return handler;
    }
}

Example avg = new Example();
avg.setCountModeEnums(CountModeEnums.avg);
avg.setData(Arrays.asList(1.0, 2.0, 3.0, 4.0, 5.0));
AbstractHandler avgHandler = DataHandlerFactory.getStrategyNoNullByObj(avg);
// ========这一步我们需要手动调用========= 
Object oavg = avgHandler.processData(sum.getData());
// ===================================== 
log.info("avg: {}, exp: {}, equals: {}", oavg, 3.0, oavg.equals(3.0)); // 3.0 3.0 true

/**
 * @ClassName AbstractHandler
 * @Description 上层基础模版
 * @Author Calyee
 */
public abstract class AbstractHandler {
}

/**
 * @ClassName AbstractDataHandler
 * @Description 基础数据处理抽象模版方法
 * @Author Calyee
 */

public abstract class AbstractDataBaseOperationHandler extends AbstractHandler {
    @PostConstruct
    private void init() {
        DataHandlerFactory.register(getCountModeEnums(), this);
    }
    /**
     * 获取模式类型
     *
     * @return CountModeEnums
     */
    public abstract CountModeEnums getCountModeEnums();

    /**
     * 数据处理
     * @param o
     * @return
     */
    public abstract Object processData(List<?> o);
}

/**
 * @ClassName AbstractDataTimeOperationHandler
 * @Description 对于时间的运算抽象模版方法
 * @Author Calyee
 */

public abstract class AbstractDataTimeOperationHandler extends AbstractHandler {
    @PostConstruct
    private void init() {
        DataHandlerFactory.register(getCountModeEnums(), this);
    }

    /**
     * 获取模式类型
     *
     * @return CountModeEnums
     * @see com.bdsoft.peration.enums.CountModeEnums
     */
    public abstract CountModeEnums getCountModeEnums();

    /**
     * 处理年份数据
     * 说明：时间与数据应该一一对应(例如)
     * data1: 2023-03-01 2023-03-02 2023-03-04 2023-03-06  ...
     * data2: 100        300        20         40          ...
     *
     * @param data1 时间对应
     * @param data2 数据对应
     * @return ans
     */
    public abstract Object processData(List<Date> data1, List<?> data2);
}

/**
 * @ClassName SumHandler
 * @Description 求和处理
 * @Author Calyee
 */

@Component
public class OperationSumBaseDataHandler extends AbstractDataBaseOperationHandler {

    @Override
    public CountModeEnums getCountModeEnums() {
        return CountModeEnums.sum;
    }

    @Override
    public Object processData(List<?> o) {
        Assert.notNull(o, "当前处理的数据不能为空");
        Object type = o.get(0);
        switch (type.getClass().getSimpleName()) {
            case "Integer":
                return o.stream()
                        .mapToInt(Integer.class::cast)
                        .sum();
            case "Long":
                return o.stream()
                        .mapToLong(Long.class::cast)
                        .sum();
            case "Double":
                return o.stream()
                        .mapToDouble(Double.class::cast)
                        .sum();
            case "Float":
                return o.stream()
                        .mapToDouble(Float.class::cast)
                        .sum();
            default:
                throw new RuntimeException("该类型暂不支持");
        }
    }
}

public class DataHandlerFactory {
    private static final Map<CountModeEnums, AbstractHandler> STRATEGY_MAP = new HashMap<>();

    public static void register(CountModeEnums enums, AbstractHandler strategy) {
        STRATEGY_MAP.put(enums, strategy);
    }

    public static Object getStrategyNoNullByObj(Object o) {
        if (o instanceof ExampleBaseDataCalculate) { // 简单基础数据运算
            ExampleBaseDataCalculate p = (ExampleBaseDataCalculate) o;
            AbstractDataBaseOperationHandler handler = (AbstractDataBaseOperationHandler) haveSuitableStrategy(p.getCountModeEnums());
            return handler.processData(p.getData());
        } else if (o instanceof ExampleYearCalculate) {// 年份数据运算
            ExampleYearCalculate p = (ExampleYearCalculate) o;
            AbstractDataTimeOperationHandler handler = (AbstractDataTimeOperationHandler) haveSuitableStrategy(p.getEnums());
            return handler.processData(p.getData1(), p.getData2());
        } else {
            return "暂时没有该处理";
        }
    }


    private static AbstractHandler haveSuitableStrategy(CountModeEnums enums) {
        AbstractHandler handler = STRATEGY_MAP.get(enums);
        Assert.notNull(handler, "没有对应的处理策略");
        return handler;
    }
}

ExampleBaseDataCalculate sum = new ExampleBaseDataCalculate();
// 模拟查询到的数据
sum.setCountModeEnums(CountModeEnums.sum);
sum.setData(Arrays.asList(1.0, 2.0, 3.0, 4.0, 5.0));
// 数据处理
Object ans = DataHandlerFactory.getStrategyNoNullByObj(sum);

log.info("sum: {}, exp:{}, equals: {}", ans, 15.0, ans.equals(15.0));


ExampleBaseDataCalculate avg = new ExampleBaseDataCalculate();
// 模拟查询到的数据
avg.setCountModeEnums(CountModeEnums.avg);
avg.setData(Arrays.asList(1.0, 2.0, 3.0, 4.0, 5.0));
// 数据处理
Object avgAns = DataHandlerFactory.getStrategyNoNullByObj(avg);
log.info("avg: {}, exp:{}, equals: {}", avgAns, 3.0, avgAns.equals(3.0));

/**
 *	解密
 **/
@Intercepts({
        @Signature(type = ResultSetHandler.class, method = "handleResultSets", args = {Statement.class})
})
@Component
@Slf4j
public class DecryptInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        Object resultObject = invocation.proceed();
        if (Objects.isNull(resultObject)) 
            return null;
        if (resultObject instanceof ArrayList) {
            //基于selectList
            ArrayList resultList = (ArrayList) resultObject;
            if (!CollectionUtils.isEmpty(resultList) && needToDecrypt(resultList.get(0))) {
                for (Object result : resultList) {
                    //逐一解密
                    decrypt(result);
                }
            }
        } else if (needToDecrypt(resultObject)) 
            //基于selectOne
            decrypt(resultObject);
        return resultObject;
    }
    @Override
    public Object plugin(Object o) {
        return Plugin.wrap(o, this);
    }
    // function needToDecrypt -> 这个方法其实就是判断字段是否有我们自定义的注解修饰
}

/**
 * @description 加密和完整性计算拦截器 （目前完整性计算只支持mybatis plus 自带的API）
 **/
@Slf4j
public class EncryptAndVerfyWholenessInterceptor extends JsqlParserSupport implements InnerInterceptor {
    /**
     * 变量占位符正则
     */
    private static final Pattern PARAM_PAIRS_RE = Pattern.compile("#\\{ew\\.paramNameValuePairs\\.(" + Constants.WRAPPER_PARAM + "\\d+)\\}");

    /**
     * 如果查询条件是加密数据列，那么要将查询条件进行数据加密。
     * 例如，手机号加密存储后，按手机号查询时，先把要查询的手机号进行加密，再和数据库存储的加密数据进行匹配
     */
    @Override
    public void beforeQuery(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
        // 具体逻辑 不列出，可查看解密逻辑
    }
    /**
     * 新增、更新数据时，如果包含隐私数据，则进行加密
     * 还有个问题，进行修改时，如果传过来的实体类的属性有属于脱敏的数据，那么这个脱敏的数据没有被修改的情况下需要被识别出来，不更新到数据库
     */
    @Override
    public void beforeUpdate(Executor executor, MappedStatement mappedStatement, Object parameterObject) throws SQLException {
        // 具体逻辑 不列出，可查看解密逻辑
    }
}

Map<Integer, List<OurBean>> groupByYear = 
list.stream().collect(Collectors.groupingBy(OurBean::getYear));

Map<Integer, List<ByYearInnerDataVO>> result = new HashMap<>();

Map<String, List<PreviCalculateVo>> processMap = 
resultList.stream().collect(Collectors.groupingBy(PreviCalculateVo::getYear));

for (Map.Entry<String, List<PreviCalculateVo>> entry 
     : processMap.entrySet()) {
    // 处理逻辑
}

entry.getValue().forEach((k) -> {
    // 处理里面的值
}

Map<String, List<PreviCalculateVo>> processMap = resultList.stream().collect(Collectors.groupingBy(PreviCalculateVo::getYear));

for (Map.Entry<String, List<PreviCalculateVo>> entry : processMap.entrySet()) {
    int year = Integer.parseInt(entry.getKey());
    entry.getValue().forEach((k) -> {
        List<ByYearInnerDataVO> list = yearIndicatorData.get(year); // 有此年份数据
        if (CollectionUtil.isEmpty(list)) {
            list = new ArrayList<>();
        }
        list.add(new ByYearInnerDataVO()
                .setValue(k.getValue())
                .setData(k.getData()));
        // replace
        result.put(Integer.parseInt(entry.getKey()), list); 
    });
}