cmc / huaheng-cmc · Files

package com.huaheng.control.management.utils;

import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

import javax.annotation.Resource;

import org.apache.commons.lang3.StringUtils;
import org.springframework.data.redis.RedisConnectionFailureException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.lang.NonNull;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.huaheng.control.management.dto.Task;
import com.huaheng.control.management.utils.constant.CommonConstant;

import lombok.extern.slf4j.Slf4j;

/**
 * Redis缓存操作工具类
 * @author     TanYibin
 * @createDate 2023年2月8日
 */
@Slf4j
@Component
public class HuahengRedisUtils {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    private static String toJsonString(Object obj) {
        if (obj == null) {
            return null;
        } else {
            return JSON.toJSONString(obj);
        }
    }

    private static <T> T parseObject(String jsonString, Class<T> cls) {
        return JSON.parseObject(jsonString, cls);
    }

    private static <T> T parseObject(String jsonString, TypeReference<T> type) {
        return JSON.parseObject(jsonString, type);
    }

    /**
     * 将key中存储值的整数值递增1，返回递增后的值
     * @author             TanYibin
     * @createDate         2023年2月8日
     * @param      key
     * @param      seconds 过期时间（秒）
     * @return
     */
    public Long incr(@NonNull String key, @NonNull Integer seconds) {
        try {
            Long returnValue = stringRedisTemplate.opsForValue().increment(key);
            if (returnValue.equals(1l)) {
                stringRedisTemplate.expire(key, seconds, TimeUnit.SECONDS);
            }
            return returnValue;
        } catch (RedisConnectionFailureException e) {
            throw new RuntimeException("Redis连接失败", e);
        } catch (Exception e) {
            log.error("操作缓存异常：Key:{}", key, e);
        }
        return null;
    }

    /**
     * 将key中存储值的整数值递减1，返回递减后的值
     * @author             TanYibin
     * @createDate         2023年2月8日
     * @param      key
     * @param      seconds 过期时间（秒）
     * @return
     */
    public Long decr(@NonNull String key, @NonNull Integer seconds) {
        try {
            Long returnValue = stringRedisTemplate.opsForValue().decrement(key);
            if (returnValue.equals(-1l)) {
                stringRedisTemplate.expire(key, seconds, TimeUnit.SECONDS);
            }
            return returnValue;
        } catch (RedisConnectionFailureException e) {
            throw new RuntimeException("Redis连接失败", e);
        } catch (Exception e) {
            log.error("操作缓存异常：Key:{}", key, e);
        }
        return null;
    }

    /**
     * 设置key，value（过期时间：2小时）
     * @author           TanYibin
     * @createDate       2023年2月8日
     * @param      key
     * @param      value
     */
    public boolean set(@NonNull String key, @NonNull Object value) {
        try {
            stringRedisTemplate.opsForValue().set(key, toJsonString(value), Duration.ofHours(2));
            return true;
        } catch (RedisConnectionFailureException e) {
            throw new RuntimeException("Redis连接失败", e);
        } catch (Exception e) {
            log.error("操作缓存异常：Key:{}", key, e);
        }
        return false;
    }

    /**
     * 设置key，value（无过期时间）
     * @author           TanYibin
     * @createDate       2023年2月8日
     * @param      key
     * @param      value
     */
    public boolean setWithNoExpirationTime(@NonNull String key, @NonNull Object value) {
        try {
            stringRedisTemplate.opsForValue().set(key, toJsonString(value));
            return true;
        } catch (RedisConnectionFailureException e) {
            throw new RuntimeException("Redis连接失败", e);
        } catch (Exception e) {
            log.error("操作缓存异常：Key:{}", key, e);
        }
        return false;
    }

    /**
     * 设置key，value，过期时间
     * @author             TanYibin
     * @createDate         2023年2月8日
     * @param      key
     * @param      value
     * @param      seconds 过期时间（秒）
     */
    public boolean set(@NonNull String key, @NonNull Object value, @NonNull Integer seconds) {
        try {
            stringRedisTemplate.opsForValue().set(key, toJsonString(value), seconds, TimeUnit.SECONDS);
            return true;
        } catch (RedisConnectionFailureException e) {
            throw new RuntimeException("Redis连接失败", e);
        } catch (Exception e) {
            log.error("操作缓存异常：Key:{}", key, e);
        }
        return false;
    }

    /**
     * 将key的值设置为value，并且返回原key的值（过期时间：2小时）
     * @author           TanYibin
     * @createDate       2026年1月5日
     * @param      <T>
     * @param      key
     * @param      value
     * @param      clazz
     * @return
     */
    public <T> T getAndSet(@NonNull String key, @NonNull T value, @NonNull Class<T> clazz) {
        try {
            String jsonString = stringRedisTemplate.opsForValue().getAndSet(key, toJsonString(value));
            stringRedisTemplate.expire(key, Duration.ofHours(2));
            if (StringUtils.isEmpty(jsonString)) {
                return null;
            }
            return parseObject(jsonString, clazz);
        } catch (RedisConnectionFailureException e) {
            throw new RuntimeException("Redis连接失败", e);
        } catch (Exception e) {
            log.error("操作缓存异常：Key:{}", key, e);
        }
        return null;
    }

    /**
     * 将key的值设置为value，并且返回原key的值（过期时间：2小时）
     * @author           TanYibin
     * @createDate       2026年1月5日
     * @param      <T>
     * @param      key
     * @param      value
     * @param      type
     * @return
     */
    public <T> T getAndSet(@NonNull String key, @NonNull T value, @NonNull TypeReference<T> type) {
        try {
            String jsonString = stringRedisTemplate.opsForValue().getAndSet(key, toJsonString(value));
            stringRedisTemplate.expire(key, Duration.ofHours(2));
            if (StringUtils.isEmpty(jsonString)) {
                return null;
            }
            return parseObject(jsonString, type);
        } catch (RedisConnectionFailureException e) {
            throw new RuntimeException("Redis连接失败", e);
        } catch (Exception e) {
            log.error("操作缓存异常：Key:{}", key, e);
        }
        return null;
    }

    /**
     * 将key的值设置为value，并且返回原key的值
     * @author             TanYibin
     * @createDate         2026年1月5日
     * @param      <T>
     * @param      key
     * @param      value
     * @param      type
     * @param      seconds 过期时间（秒）
     * @return
     */
    public <T> T getAndSet(@NonNull String key, @NonNull T value, @NonNull TypeReference<T> type, @NonNull Integer seconds) {
        try {
            String jsonString = stringRedisTemplate.opsForValue().getAndSet(key, toJsonString(value));
            stringRedisTemplate.expire(key, seconds, TimeUnit.SECONDS);
            if (StringUtils.isEmpty(jsonString)) {
                return null;
            }
            return parseObject(jsonString, type);
        } catch (RedisConnectionFailureException e) {
            throw new RuntimeException("Redis连接失败", e);
        } catch (Exception e) {
            log.error("操作缓存异常：Key:{}", key, e);
        }
        return null;
    }

    /**
     * 设置key的过期时间
     * @author             TanYibin
     * @createDate         2023年2月8日
     * @param      key
     * @param      seconds
     * @return
     */
    public boolean expire(@NonNull String key, @NonNull Integer seconds) {
        try {
            return stringRedisTemplate.expire(key, seconds, TimeUnit.SECONDS);
        } catch (RedisConnectionFailureException e) {
            throw new RuntimeException("Redis连接失败", e);
        } catch (Exception e) {
            log.error("操作缓存异常：Key:{}", key, e);
        }
        return false;
    }

    /**
     * 获取key的过期时间
     * @author         TanYibin
     * @createDate     2023年2月8日
     * @param      key
     * @return
     */
    public long getExpire(@NonNull String key) {
        try {
            return stringRedisTemplate.getExpire(key);
        } catch (RedisConnectionFailureException e) {
            throw new RuntimeException("Redis连接失败", e);
        } catch (Exception ex) {
            log.error("操作缓存异常：Key:{}", key, ex);
        }
        return 0;
    }

    /**
     * 获取key的值
     * @author           TanYibin
     * @createDate       2023年2月8日
     * @param      <T>
     * @param      key
     * @param      clazz
     * @return
     */
    public <T> T get(@NonNull String key, @NonNull Class<T> clazz) {
        try {
            String result = stringRedisTemplate.opsForValue().get(key);
            if (StringUtils.isEmpty(result)) {
                return null;
            }
            return parseObject(result, clazz);
        } catch (RedisConnectionFailureException e) {
            throw new RuntimeException("Redis连接失败", e);
        } catch (Exception e) {
            log.error("操作缓存异常：Key:{}", key, e);
        }
        return null;
    }

    /**
     * 获取key的值
     * @author         TanYibin
     * @createDate     2023年2月8日
     * @param      <T>
     * @param      key
     * @return
     */
    public <T> T get(@NonNull String key, @NonNull TypeReference<T> type) {
        try {
            String result = stringRedisTemplate.opsForValue().get(key);
            if (StringUtils.isEmpty(result)) {
                return null;
            }
            return parseObject(result, type);
        } catch (RedisConnectionFailureException e) {
            throw new RuntimeException("Redis连接失败", e);
        } catch (Exception e) {
            log.error("操作缓存异常：Key:{}", key, e);
        }
        return null;
    }

    /**
     * 删除key
     * @author         TanYibin
     * @createDate     2023年2月8日
     * @param      key
     */
    public boolean delete(@NonNull String key) {
        try {
            return stringRedisTemplate.delete(key);
        } catch (RedisConnectionFailureException e) {
            throw new RuntimeException("Redis连接失败", e);
        } catch (Exception e) {
            log.error("操作缓存异常：Key:{}", key, e);
        }
        return false;
    }

    /**
     * 判断是否有key对应的值，有则返回true，没有则返回false
     * @author         TanYibin
     * @createDate     2023年2月8日
     * @param      key
     * @return
     */
    public boolean hasKey(@NonNull String key) {
        try {
            return stringRedisTemplate.hasKey(key);
        } catch (RedisConnectionFailureException e) {
            throw new RuntimeException("Redis连接失败", e);
        } catch (Exception e) {
            log.error("操作缓存异常：Key:{}", key, e);
        }
        return false;
    }

    /**
     * 存储任务状态
     * @param taskId 任务ID
     * @param status 状态
     * @param data   该状态对应的数据
     */
    public boolean saveTaskStatus(String taskId, String status, Object data) {
        try {
            String redisKey = CommonConstant.CMC_TASK_KEY_PREFIX + taskId;
            // 将数据转换为JSON字符串存储，保持格式统一
            String dataJson = toJsonString(data);
            stringRedisTemplate.opsForHash().put(redisKey, status, dataJson);
            return true;
        } catch (RedisConnectionFailureException e) {
            throw new RuntimeException("Redis连接失败", e);
        } catch (Exception e) {
            log.error("存储任务状态异常：taskId: {}, status: {}", taskId, status, e);
        }
        return false;
    }

    /**
     * 根据任务ID和状态获取任务状态数据
     * @param  taskId 任务ID
     * @param  status 状态
     * @return        该状态下的数据
     */
    public <T> T getTaskDataByStatus(String taskId, String status, @NonNull TypeReference<T> type) {
        String redisKey = CommonConstant.CMC_TASK_KEY_PREFIX + taskId;
        try {
            String result = (String)stringRedisTemplate.opsForHash().get(redisKey, status);
            if (StringUtils.isEmpty(result)) {
                return null;
            }
            return parseObject(result, type);
        } catch (RedisConnectionFailureException e) {
            throw new RuntimeException("Redis连接失败", e);
        } catch (Exception e) {
            log.error("任务状态数据异常：Key:{}", redisKey, e);
        }
        return null;
    }

    /**
     * 获取所有任务Key
     * @return 所有任务Key的集合
     */
    public Set<String> getAllTaskKeys() {
        String pattern = CommonConstant.CMC_TASK_KEY_PREFIX + "*";
        Set<String> keys = new HashSet<>();
        try {
            Cursor<byte[]> cursor =
                stringRedisTemplate.executeWithStickyConnection(connection -> connection.scan(ScanOptions.scanOptions().match(pattern).count(1000) // 每次扫描数量
                    .build()));
            while (cursor.hasNext()) {
                keys.add(new String(cursor.next()));
            }
            cursor.close();
        } catch (RedisConnectionFailureException e) {
            throw new RuntimeException("Redis连接失败", e);
        } catch (Exception e) {
            log.error("获取所有任务的Key异常", e);
        }
        return keys;
    }

    /**
     * 获取任务状态数据集合
     * @return 任务状态数据集合
     */
    public Map<String, Map<String, Task>> getAllTaskDetails() {
        return getTaskDetailsWithTaskKeys(getAllTaskKeys());
    }

    /**
     * 获取任务状态数据集合，TaskId为Key
     * @return Map<TaskId, 任务状态数据>
     */
    @SuppressWarnings("unchecked")
    public Map<String, Map<String, Task>> getTaskDetailsWithTaskKeys(Set<String> taskKeys) {
        Map<String, Map<String, Task>> result = new HashMap<>();
        if (CollectionUtils.isEmpty(taskKeys)) {
            return result;
        }
        try {
            List<Object> taskResults = stringRedisTemplate.executePipelined((RedisCallback<Object>)connection -> {
                for (String key : taskKeys) {
                    connection.hashCommands().hGetAll(key.getBytes(StandardCharsets.UTF_8)); // 指定字符集
                }
                return null;
            });
            // 将Redis Key转换为TaskId
            int index = 0;
            for (String taskKey : taskKeys) {
                String taskId = taskKey.substring(CommonConstant.CMC_TASK_KEY_PREFIX.length());
                Map<String, Task> taskResult = ((Map<String, String>)taskResults.get(index)).entrySet().stream()
                    .collect(Collectors.toMap(Map.Entry::getKey, entry -> JSON.parseObject(entry.getValue(), Task.class)));
                result.put(taskId, taskResult);
                index++;
            }
        } catch (RedisConnectionFailureException e) {
            throw new RuntimeException("Redis连接失败", e);
        } catch (Exception e) {
            log.error("获取任务状态数据集合异常", e);
        }
        return result;
    }

    /**
     * 根据状态筛选任务状态数据集合
     * @param  targetStatus 目标状态
     * @return              包含指定状态的任务状态数据集合
     */
    public Map<String, Map<String, Task>> getTasksByStatus(Set<String> taskKeys, String targetStatus) {
        Map<String, Map<String, Task>> taskDetails = getTaskDetailsWithTaskKeys(taskKeys);
        Map<String, Map<String, Task>> matchedTasks = new HashMap<>();
        for (Entry<String, Map<String, Task>> entry : taskDetails.entrySet()) {
            String taskId = entry.getKey();
            Map<String, Task> statusData = entry.getValue();
            if (statusData.containsKey(targetStatus)) {
                matchedTasks.put(taskId, statusData);
            }
        }
        return matchedTasks;
    }

    /**
     * 根据任务ID获取所有状态数据
     * @param  taskId 任务ID
     * @return        包含所有状态-数据的Map
     */
    public Map<Object, Object> getAllTaskStatus(String taskId) {
        String redisKey = CommonConstant.CMC_TASK_KEY_PREFIX + taskId;
        try {
            // 获取整个Hash，即该taskId下的所有状态和数据
            return stringRedisTemplate.opsForHash().entries(redisKey);
        } catch (RedisConnectionFailureException e) {
            throw new RuntimeException("Redis连接失败", e);
        } catch (Exception e) {
            log.error("操作缓存异常：Key:{}", redisKey, e);
        }
        return null;
    }

    /**
     * 删除整个任务数据
     * @param taskId 任务ID
     */
    public boolean deleteTask(String taskId) {
        String redisKey = CommonConstant.CMC_TASK_KEY_PREFIX + taskId;
        try {
            return stringRedisTemplate.delete(redisKey);
        } catch (RedisConnectionFailureException e) {
            throw new RuntimeException("Redis连接失败", e);
        } catch (Exception e) {
            log.error("操作缓存异常：Key:{}", redisKey, e);
        }
        return false;
    }

}