@Component
public class RedisDistributedLock {

    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * 尝试获取锁
     * @param key 锁标识
     * @param expireSec 锁自动过期时间（防止死锁）
     * @return 是否获取成功
     */
    public boolean tryLock(String key, long expireSec) {
        // SET NX + 过期时间（原子操作）
        Boolean success = redisTemplate.opsForValue()
            .setIfAbsent(key, Thread.currentThread().getName(), expireSec, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(success);
    }

    /**
     * 释放锁（使用 Lua 脚本确保原子性）
     */
    public void unlock(String key, String requestId) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] " +
                        "then return redis.call('del', KEYS[1]) " +
                        "else return 0 end";
        redisTemplate.execute(
            new DefaultRedisScript<>(script, Long.class),
            Collections.singletonList(key), requestId
        );
    }
}

@Configuration
public class RedissonConfig {

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer()
            .setAddress("redis://localhost:6379");
        return Redisson.create(config);
    }
}

@Component
@Slf4j
public class ScheduledLockService {

    @Autowired
    private RedissonClient redissonClient;

    /**
     * 在定时任务中使用分布式锁
     */
    public void executeWithLock(String taskName, long waitTime, Runnable task) {
        RLock lock = redissonClient.getLock("scheduled:" + taskName);
        try {
            // waitTime：等待锁的时间；leaseTime：锁自动释放时间（-1=看门狗自动续期）
            if (lock.tryLock(waitTime, -1, TimeUnit.SECONDS)) {
                log.info("获取锁成功，开始执行定时任务: {}", taskName);
                try {
                    task.run();
                } finally {
                    lock.unlock();
                    log.info("定时任务完成，释放锁: {}", taskName);
                }
            } else {
                log.info("获取锁失败，其他实例正在执行: {}", taskName);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            log.warn("定时任务被中断: {}", taskName);
        }
    }
}

@Component
public class ReportScheduleTask {

    @Autowired
    private ScheduledLockService lockService;

    // 每天凌晨 2 点执行，多实例下只有一个实例执行
    @Scheduled(cron = "0 0 2 * * ?")
    public void generateDailyReport() {
        lockService.executeWithLock("daily-report", 10, () -> {
            reportService.generateDaily();
        });
    }

    // 每小时同步数据
    @Scheduled(cron = "0 0 0/1 * * ?")
    public void syncData() {
        lockService.executeWithLock("data-sync", 10, () -> {
            dataSyncService.sync();
        });
    }
}

// 1. 添加依赖
// <dependency> <groupId>net.javacrumbs.shedlock</groupId>
//   <artifactId>shedlock-spring</artifactId> </dependency>

// 2. 配置锁存储（Redis）
@Configuration
@EnableSchedulerLock(defaultLockAtMostFor = "30m")
public class ShedLockConfig {

    @Bean
    public LockProvider lockProvider(RedisTemplate<String, String> template) {
        return new RedisLockProvider(template.getConnectionFactory());
    }
}

// 3. 定时任务加 @SchedulerLock
@Component
public class ScheduledTasks {

    @Scheduled(cron = "0 0 2 * * ?")
    @SchedulerLock(name = "dailyReport", lockAtMostFor = "30m", lockAtLeastFor = "5m")
    public void dailyReport() {
        // 分布式锁自动管理，无需手动写锁逻辑
        reportService.generateDaily();
    }
}

// 本地缓存常见场景：字典数据、配置项、白名单、路由表
// 这些数据特点：读极多、写很少、允许短时间不一致

@Component
public class LocalCacheService<K, V> {

    private final ConcurrentHashMap<K, V> cache = new ConcurrentHashMap<>();
    private final ConcurrentHashMap<K, ReentrantLock> lockMap = new ConcurrentHashMap<>();

    private final CacheLoader<K, V> loader; // 数据加载器

    public LocalCacheService(CacheLoader<K, V> loader) {
        this.loader = loader;
    }

    /**
     * 带锁保护的缓存读取（DCL 模式）
     */
    public V get(K key) {
        // ① 第一次检查：缓存命中直接返回
        V value = cache.get(key);
        if (value != null) {
            return value;
        }

        // ② 获取 key 对应的锁（每个 key 一把锁，减少竞争）
        ReentrantLock lock = lockMap.computeIfAbsent(key, k -> new ReentrantLock());
        lock.lock();
        try {
            // ③ 第二次检查（DCL）：可能其他线程已经加载好了
            value = cache.get(key);
            if (value != null) {
                return value;
            }

            // ④ 真正加载数据（只有第一个线程到这里）
            value = loader.load(key);
            cache.put(key, value);
            return value;
        } finally {
            lock.unlock();
            // 清理不再使用的锁对象，防止内存泄漏
            lockMap.remove(key, lock);
        }
    }

    /**
     * 强制刷新缓存
     */
    public void refresh(K key) {
        ReentrantLock lock = lockMap.computeIfAbsent(key, k -> new ReentrantLock());
        lock.lock();
        try {
            V value = loader.load(key);
            cache.put(key, value);
        } finally {
            lock.unlock();
        }
    }

    @FunctionalInterface
    public interface CacheLoader<K, V> {
        V load(K key);
    }
}

@Service
public class DictService {

    // Spring 4.3+ 的 sync = true 自带锁保护
    @Cacheable(value = "dictCache", key = "#type", sync = true)
    public List<DictItem> getDict(String type) {
        // sync=true 保证只有一个线程执行此方法
        // 其他线程等待结果
        return dictMapper.selectByType(type);
    }
}

// 同时配置 Caffeine 缓存
@Configuration
public class CacheConfig {

    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager manager = new CaffeineCacheManager();
        manager.setCaffeine(Caffeine.newBuilder()
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .maximumSize(10000)
            .initialCapacity(100)
        );
        return manager;
    }
}

@Component
@Slf4j
public class IdempotentService {

    @Autowired
    private StringRedisTemplate redisTemplate;

    private static final String IDEMPOTENT_PREFIX = "idempotent:";

    /**
     * 执行幂等方法
     * @param idempotentKey 幂等 key（如 orderId, paymentId）
     * @param expireSec 锁过期时间（秒）
     * @param task 要执行的业务逻辑
     */
    public <T> IdempotentResult<T> execute(String idempotentKey, long expireSec,
                                            Supplier<T> task) {
        String lockKey = IDEMPOTENT_PREFIX + idempotentKey;
        String requestId = UUID.randomUUID().toString();

        try {
            // 尝试获取锁（SET NX + 过期时间）
            Boolean success = redisTemplate.opsForValue()
                .setIfAbsent(lockKey, requestId, expireSec, TimeUnit.SECONDS);

            if (!Boolean.TRUE.equals(success)) {
                // 获取锁失败 → 重复请求
                log.warn("检测到重复请求: {}", idempotentKey);
                return IdempotentResult.repeat("请求正在处理中，请勿重复提交");
            }

            // 获取锁成功 → 执行业务
            T result = task.get();
            return IdempotentResult.success(result);

        } finally {
            // 使用 Lua 脚本释放锁（只释放自己加的锁）
            releaseLock(lockKey, requestId);
        }
    }

    private void releaseLock(String key, String requestId) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] " +
                        "then return redis.call('del', KEYS[1]) " +
                        "else return 0 end";
        redisTemplate.execute(
            new DefaultRedisScript<>(script, Long.class),
            Collections.singletonList(key), requestId
        );
    }
}

@Data
@AllArgsConstructor(staticName = "of")
public class IdempotentResult<T> {
    private boolean success;
    private boolean repeat;
    private T data;
    private String message;

    public static <T> IdempotentResult<T> success(T data) {
        return new IdempotentResult<>(true, false, data, null);
    }

    public static <T> IdempotentResult<T> repeat(String message) {
        return new IdempotentResult<>(false, true, null, message);
    }
}

@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private IdempotentService idempotentService;

    @Autowired
    private OrderService orderService;

    @PostMapping("/create")
    public Result<?> createOrder(@RequestBody OrderCreateReq req) {
        // 用业务唯一标识作为幂等 key（如订单号、token）
        String idempotentKey = req.getOrderId();

        IdempotentResult<OrderVO> result = idempotentService.execute(
            idempotentKey, 30, () -> orderService.createOrder(req)
        );

        if (result.isRepeat()) {
            return Result.warn(result.getMessage());
        }
        return Result.success(result.getData());
    }
}

@Component
@Slf4j
public class PaymentCallbackConsumer {

    @Autowired
    private IdempotentService idempotentService;

    @RabbitListener(queues = "payment.callback")
    public void onPaymentCallback(PaymentMsg msg) {
        // MQ 可能重复消费，用 paymentId 做幂等
        idempotentService.execute(
            "payment:" + msg.getPaymentId(),
            60,
            () -> {
                paymentService.processCallback(msg);
                return true;
            }
        );
    }
}

-- stock_decrement.lua
-- KEYS[1]: 库存 key
-- KEYS[2]: 已购买用户 set key
-- ARGV[1]: 用户 ID
-- ARGV[2]: 扣减数量

-- 1. 检查用户是否已购买（防止重复抢购）
local bought = redis.call('SISMEMBER', KEYS[2], ARGV[1])
if bought == 1 then
    return -2  -- 已购买过
end

-- 2. 查库存
local stock = redis.call('GET', KEYS[1])
if not stock or tonumber(stock) <= 0 then
    return -1  -- 库存不足
end

-- 3. 扣减库存
local remain = redis.call('DECRBY', KEYS[1], ARGV[2])

-- 4. 记录已购买用户
redis.call('SADD', KEYS[2], ARGV[1])

return remain  -- 返回剩余库存

@Service
@Slf4j
public class SecKillService {

    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private OrderService orderService;

    // 加载 Lua 脚本
    private final DefaultRedisScript<Long> stockScript;

    public SecKillService() {
        stockScript = new DefaultRedisScript<>();
        stockScript.setScriptSource(
            new ResourceScriptSource(new ClassPathResource("lua/stock_decrement.lua")));
        stockScript.setResultType(Long.class);
    }

    /**
     * 秒杀抢购
     */
    public Result<String> seckill(Long productId, Long userId) {
        String stockKey = "stock:" + productId;
        String boughtKey = "bought:" + productId;

        // 执行 Lua 脚本（原子操作，无需外部锁）
        Long remain = redisTemplate.execute(stockScript,
            Arrays.asList(stockKey, boughtKey),
            String.valueOf(userId), "1");

        if (remain == null) {
            return Result.error("系统繁忙");
        }

        if (remain == -1) {
            return Result.error("已售罄");
        }
        if (remain == -2) {
            return Result.warn("您已购买过该商品");
        }

        // 脚本内扣减成功，创建订单
        try {
            Order order = orderService.createOrder(productId, userId);
            return Result.success("抢购成功", order.getOrderId());
        } catch (Exception e) {
            // 订单创建失败 → 回滚库存、移除已购买记录
            rollback(productId, userId);
            log.error("订单创建失败，已回滚库存", e);
            return Result.error("系统异常，请重新抢购");
        }
    }

    private void rollback(Long productId, Long userId) {
        redisTemplate.opsForValue().increment("stock:" + productId);
        redisTemplate.opsForSet().remove("bought:" + productId, String.valueOf(userId));
    }
}

@Service
public class SecKillWithLockService {

    @Autowired
    private RedissonClient redissonClient;
    @Autowired
    private ProductService productService;

    public boolean deductStock(Long productId, int quantity) {
        RLock lock = redissonClient.getLock("stock:" + productId);
        try {
            // 尝试获取锁，最多等 1 秒
            if (!lock.tryLock(1, 10, TimeUnit.SECONDS)) {
                return false;
            }
            try {
                // 查库存 → 扣减（这个过程被锁保护）
                int stock = productService.getStock(productId);
                if (stock < quantity) {
                    return false;
                }
                productService.deductStock(productId, quantity);
                return true;
            } finally {
                lock.unlock();
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        }
    }
}

@Component
public class DynamicConfigService<T> {

    private volatile T config;
    private final StampedLock stampedLock = new StampedLock();

    /**
     * 乐观读取配置（高并发场景下性能最优）
     */
    public T getConfig() {
        // ① 乐观读（不加锁）
        long stamp = stampedLock.tryOptimisticRead();
        T currentConfig = this.config;

        // ② 验证：是否有写线程在此期间修改了配置
        if (!stampedLock.validate(stamp)) {
            // ③ 被修改了，退化为悲观读
            stamp = stampedLock.readLock();
            try {
                currentConfig = this.config;
            } finally {
                stampedLock.unlockRead(stamp);
            }
        }
        return currentConfig;
    }

    /**
     * 更新配置（由配置中心 Nacos/Apollo 监听器调用）
     */
    public void updateConfig(T newConfig) {
        long stamp = stampedLock.writeLock();
        try {
            this.config = newConfig;
            log.info("配置已更新: {}", newConfig);
        } finally {
            stampedLock.unlockWrite(stamp);
        }
    }

    // 获取当前配置（直接 volatile 读，用于不要求一致性的场景）
    public T getConfigDirect() {
        return config;
    }
}

@Component
public class NacosConfigWatcher {

    private final DynamicConfigService<OrderConfig> orderConfigService;

    public NacosConfigWatcher(DynamicConfigService<OrderConfig> orderConfigService) {
        this.orderConfigService = orderConfigService;
    }

    // 监听 Nacos 配置变更
    @NacosConfigListener(dataId = "order-config.yaml", groupId = "DEFAULT_GROUP")
    public void onConfigChange(String newConfig) {
        OrderConfig config = YamlUtil.parse(newConfig, OrderConfig.class);
        orderConfigService.updateConfig(config);
    }
}

@Service
public class OrderService {

    @Autowired
    private DynamicConfigService<OrderConfig> configService;

    public void processOrder(Order order) {
        // 每次请求读取配置（乐观读，几乎无开销）
        OrderConfig config = configService.getConfig();

        if (order.getAmount().compareTo(config.getMaxAmount()) > 0) {
            // 触发风控审核
            riskControlService.audit(order);
        }
        // 处理订单...
    }
}

@Component
public class ConfigWithReadWriteLock<T> {

    private volatile T config;
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private final Lock r = rwLock.readLock();
    private final Lock w = rwLock.writeLock();

    public T getConfig() {
        r.lock();
        try {
            return config;
        } finally {
            r.unlock();
        }
    }

    public void updateConfig(T newConfig) {
        w.lock();
        try {
            this.config = newConfig;
        } finally {
            w.unlock();
        }
    }
}