package com.example.demo;

import cn.com.digitalhainan.cache.component.redis.RedisTemplatePrivateWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class CacheVerifier {

    @Autowired
    private RedisTemplatePrivateWrapper masterRedisPrivate;

    public boolean verify() {
        // 写入一个永不过期的 Key
        masterRedisPrivate.valuePut("integration:test", "pong", -1L);
        // 读取并校验
        Object result = masterRedisPrivate.valueGet("integration:test");
        return "pong".equals(result);
    }
}

package com.example.service;

import cn.com.digitalhainan.cache.component.redis.RedisTemplatePrivateWrapper;
import cn.com.digitalhainan.cache.component.redis.RedisTemplatePublicWrapper;
import cn.com.digitalhainan.cache.component.redis.RedisTemplateEmptyWrapper;
import cn.com.digitalhainan.cache.component.redis.conf.RedisWrapperBeanFactory;
import cn.com.digitalhainan.cache.component.redis.conf.RedissonBeanFactory;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;

@Service
public class RedisOperationDemo {

    // ===== 注入 Master 节点 Wrapper =====
    @Autowired
    private RedisTemplatePrivateWrapper masterRedisPrivate;  // Key 前缀: {appName}:
    @Autowired
    private RedisTemplatePublicWrapper masterRedisPublic;    // Key 前缀: pub-dat:
    @Autowired
    private RedisTemplateEmptyWrapper masterRedisEmpty;      // 无前缀

    // ===== 注入 Bean 工厂（用于获取非 master 节点） =====
    @Autowired
    private RedisWrapperBeanFactory redisWrapperBeanFactory;
    @Autowired
    private RedissonBeanFactory redissonBeanFactory;

    // ===== 注入 RedissonClient（用于分布式锁等原生 Redisson 操作） =====
    @Autowired
    private RedissonClient masterRedisson;

    public void valueOperations() {
        // --- Value 操作 ---
        masterRedisPrivate.valuePut("user:1001", "张三", 3600L);   // 设置值，3600秒过期
        masterRedisPrivate.valuePut("user:1002", "李四", -1L);     // 设置值，永不过期
        Object val = masterRedisPrivate.valueGet("user:1001");      // 获取值
    }

    public void jsonOperations() {
        // --- JSON 序列化操作（适合复杂对象） ---
        User user = new User("1001", "张三");
        masterRedisPrivate.beanJsonPut("user:json:1001", user, 3600L);
        User cached = masterRedisPrivate.beanFromJsonGet("user:json:1001", User.class);
    }

    public void hashOperations() {
        // --- Hash 操作 ---
        Map<String, Object> fields = new HashMap<>();
        fields.put("name", "张三");
        fields.put("age", 25);
        masterRedisPrivate.hashPutAll("user:hash:1001", fields, 3600L);
        Map<String, Object> all = masterRedisPrivate.hashEntriesGet("user:hash:1001");
        Set<String> keys = masterRedisPrivate.hashKeysGet("user:hash:1001");
    }

    public void setOperations() {
        // --- Set 操作 ---
        Set<Object> tags = new HashSet<>(Arrays.asList("tag1", "tag2", "tag3"));
        masterRedisPrivate.setPutAll("user:set:1001", tags, 3600L);
        Set<Object> members = masterRedisPrivate.setValuesGet("user:set:1001");
    }

    public void listOperations() {
        // --- List 操作 ---
        List<Object> items = Arrays.asList("item1", "item2", "item3");
        masterRedisPrivate.listPutAll("user:list:1001", items, 3600L);
        List<Object> values = masterRedisPrivate.listValuesGet("user:list:1001");
    }

    public void multiNodeOperations() {
        // --- 获取非 master 节点的 Wrapper ---
        // 前提: application.yml 中 multi-node 下配置了名为 "pubDat" 的节点
        RedisTemplatePrivateWrapper pubDatPrivate =
            redisWrapperBeanFactory.getExcludeMasterRedisPrivateWrapperBean("pubDat");
        RedisTemplatePublicWrapper pubDatPublic =
            redisWrapperBeanFactory.getExcludeMasterRedisPublicWrapperBean("pubDat");
        RedisTemplateEmptyWrapper pubDatEmpty =
            redisWrapperBeanFactory.getExcludeMasterRedisEmptyWrapperBean("pubDat");
        // 获取非 master 节点的 RedissonClient
        RedissonClient pubDatRedisson =
            redissonBeanFactory.getExcludeMasterRedissonBean("pubDat");
    }

    public void fuzzyDelete() {
        // --- 模糊匹配删除 ---
        masterRedisPrivate.getLikeKey("user:*", true);  // 匹配 "user:*" 并删除
    }
}

package com.example.service;

import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

// cacheNames 对应 YAML 中 "user-cache" 转换后的 "user:cache"
@Service
@CacheConfig(cacheNames = "user:cache")
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    @Cacheable(key = "#userId")
    // 行为: 先查缓存，命中则直接返回；未命中则执行方法体，并将返回值写入缓存
    public User getUserById(String userId) {
        return userMapper.selectById(userId);
    }

    @Override
    @CachePut(key = "#user.id")
    // 行为: 每次都执行方法体，并将返回值覆盖写入缓存
    public User updateUser(User user) {
        userMapper.updateById(user);
        return user;
    }

    @Override
    @CacheEvict(key = "#userId")
    // 行为: 删除缓存中对应 key 的条目
    public void deleteUser(String userId) {
        userMapper.deleteById(userId);
    }
}

package com.example.service;

import cn.com.digitalhainan.cache.component.level2.Level2Cache;
import cn.com.digitalhainan.cache.component.level2.Level2CacheHolder;
import org.springframework.stereotype.Service;

@Service
public class Level2CacheDemo {

    public void operateLevel2() {
        // 通过 ThreadLocal Holder 获取指定缓存实例
        Level2Cache cache = Level2CacheHolder.holder.get("myCache");

        cache.put("key", "value");       // 同时写入 L1 + L2
        Object val = cache.get("key");   // 先查 L1，未命中再查 L2

        cache.evict("key");              // 清除 L1 + L2
        cache.evictLevel1("key");        // 仅清除 L1（本地）
        cache.evictLevel2("key");        // 仅清除 L2（Redis）
        cache.clearLevel1();             // 清空所有 L1
        cache.clearLevel2();             // 清空所有 L2
    }
}

package com.example.service;

import cn.com.digitalhainan.cache.component.redis.annotation.DLock;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    // 锁 Key 最终格式: "order:lock:{orderId的值}"
    // 例: orderId="20240101001" -> 锁 Key = "order:lock:20240101001"
    @DLock(prefix = "order:lock", value = "#orderId", waitTime = 50, leaseTime = 90)
    public void processOrder(String orderId) {
        // 该方法在分布式锁保护下执行
        // 如果 50 秒内未获取到锁，抛出 RuntimeException
        // 方法执行完毕或异常后自动释放锁
    }
}

package com.example.service;

import cn.com.digitalhainan.cache.component.redis.lock.IDistributedLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class LockDemoService {

    @Autowired
    private IDistributedLock distributedLock;

    public void doSomething() {
        // lockMillisecond: 锁持有时间（毫秒）
        // retryMillisecond: 重试等待时间（毫秒）
        boolean locked = distributedLock.lock(5000L, 3000L);
        try {
            if (locked) {
                // 业务逻辑
            }
        } finally {
            distributedLock.free();  // 必须释放
        }
    }
}

package com.example.cache;

import cn.com.digitalhainan.cache.common.pubdat.dict.cache.redis.AbstractBasisDictRedisCache;
import cn.com.digitalhainan.cache.common.pubdat.dict.cache.DictItemVO;
import org.springframework.stereotype.Component;

@Component
public class MyDictCache extends AbstractBasisDictRedisCache {

    public DictItemVO getDictItem(String catalog, String itemCode) {
        // targetBasisDictItemKey 生成格式: "{basisDictManualCache名}:{catalog}:{itemCode}"
        String key = targetBasisDictItemKey(catalog, itemCode);
        return (DictItemVO) masterDictRedisPublic.valueGet(key);
    }
}

package com.example.service;

import cn.com.digitalhainan.tools.captch.ICaptchaCacheStrategy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class CaptchaService {

    @Autowired
    private ICaptchaCacheStrategy captchaCacheStrategy;

    public String generateCaptcha(String sessionId) {
        String code = "1234"; // 实际由验证码生成器产生
        captchaCacheStrategy.cache(sessionId, code);  // 存入 Redis
        return code;
    }

    public boolean verifyCaptcha(String sessionId, String inputCode) {
        // 校验成功后自动删除缓存（一次性）
        return captchaCacheStrategy.verify(sessionId, inputCode);
    }
}

package com.example.stock;

import cn.com.digitalhainan.cache.common.stock.StockReduceOperator;
import cn.com.digitalhainan.cache.common.stock.StockStatusEnum;
import cn.com.digitalhainan.cache.common.stock.GoodsInfo;
import cn.com.digitalhainan.cache.common.stock.redis.AbstractStockReduceOperator;
import org.springframework.stereotype.Component;

@Component
public class SeckillStockOperator extends AbstractStockReduceOperator {
    // 框架根据 StockActivityProperties 配置自动初始化库存
    // reduce() 方法基于 Redis 原子操作实现库存扣减与限购校验
    // 无需手动实现，继承即可使用
}

package com.example.service;

import cn.com.digitalhainan.cache.component.redis.utils.SerialNumberUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class SerialNumberDemo {

    @Autowired
    private SerialNumberUtils serialNumberUtils;

    public String generateOrderNo() {
        // 生成 19 位序列号（默认长度）
        return serialNumberUtils.generate("ORD");
        // 示例输出: ORD202401011430000001
    }

    public String generateInvoiceNo() {
        // 指定总长度为 25 位
        return serialNumberUtils.generate("INV", 25);
        // 示例输出: INV2024010114300000000001
    }
}