import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.locks.ReentrantLock;
/**
 * 基于 LinkedHashMap 的 LRU+TTL 本地緩存
 * 特性：固定容量（LRU 淘汰）、時(shí)間過(guò)期（TTL）、線程安全
 */
public class LruTtlCache<K, V> extends LinkedHashMap<K, CacheEntry<V>> {
    private final int maxCapacity; // 最大容量
    private final long ttlMillis; // 過(guò)期時(shí)間（毫秒）
    private final ReentrantLock lock = new ReentrantLock(); // 可重入鎖保證線程安全
    // 緩存條目：包裝值和過(guò)期時(shí)間
    private static class CacheEntry<V> {
        V value;
        long expireTime; // 過(guò)期時(shí)間戳（毫秒）
        CacheEntry(V value, long expireTime) {
            this.value = value;
            this.expireTime = expireTime;
        }
        // 判斷是否過(guò)期
        boolean isExpired() {
            return System.currentTimeMillis() > expireTime;
        }
    }
    // 構(gòu)造函數(shù)：指定最大容量和 TTL
    public LruTtlCache(int maxCapacity, long ttlMillis) {
        super(maxCapacity, 0.75f, true); // accessOrder=true（訪問(wèn)順序）
        this.maxCapacity = maxCapacity;
        this.ttlMillis = ttlMillis;
    }
    /**
     * 重寫(xiě) removeEldestEntry：達(dá)到最大容量時(shí)刪除最久未使用的條目
     */
    @Override
    protected boolean removeEldestEntry(Map.Entry<K, CacheEntry<V>> eldest) {
        // 先清理過(guò)期條目
        if (eldest.getValue().isExpired()) {
            return true;
        }
        // 未過(guò)期則判斷是否超容量
        return size() > maxCapacity;
    }
    /**
     * 存緩存：線程安全
     */
    public void put(K key, V value) {
        Objects.requireNonNull(key);
        Objects.requireNonNull(value);
        lock.lock();
        try {
            // 計(jì)算過(guò)期時(shí)間戳
            long expireTime = System.currentTimeMillis() + ttlMillis;
            super.put(key, new CacheEntry<>(value, expireTime));
        } finally {
            lock.unlock();
        }
    }
    /**
     * 取緩存：線程安全，自動(dòng)過(guò)濾過(guò)期條目
     */
    public V get(Object key) {
        lock.lock();
        try {
            CacheEntry<V> entry = super.get(key);
            if (entry == null) {
                return null;
            }
            // 過(guò)期則刪除并返回 null
            if (entry.isExpired()) {
                super.remove(key);
                return null;
            }
            return entry.value;
        } finally {
            lock.unlock();
        }
    }
    /**
     * 批量清理過(guò)期條目
     */
    public void cleanExpired() {
        lock.lock();
        try {
            keySet().removeIf(key -> super.get(key).isExpired());
        } finally {
            lock.unlock();
        }
    }
}

應(yīng)用服務(wù) A                應(yīng)用服務(wù) B
┌───────────────┐        ┌───────────────┐
│ 本地緩存      │        │ 本地緩存      │
│ （LruTtlCache）│        │ （LruTtlCache）│
└───────┬───────┘        └───────┬───────┘
        │                        │
        └───────────┬───────────┘
                    │
            ┌───────▼───────┐
            │ 分布式緩存    │
            │ （Redis）     │
            └───────┬───────┘
                    │
            ┌───────▼───────┐
            │ 數(shù)據(jù)庫(kù)        │
            └───────────────┘

import redis.clients.jedis.Jedis;
import java.util.function.Supplier;
/**
 * 多級(jí)緩存客戶(hù)端（本地緩存+Redis）
 */
public class MultiLevelCache<K, V> {
    private final LruTtlCache<K, V> localCache;
    private final Jedis redisClient;
    private final String prefix; // Redis 鍵前綴
    private final long redisTtlSeconds; // Redis 過(guò)期時(shí)間（秒）
    // 構(gòu)造函數(shù)：初始化各級(jí)緩存
    public MultiLevelCache(int localMaxCapacity, long localTtlMillis,
                          Jedis redisClient, String prefix, long redisTtlSeconds) {
        this.localCache = new LruTtlCache<>(localMaxCapacity, localTtlMillis);
        this.redisClient = redisClient;
        this.prefix = prefix;
        this.redisTtlSeconds = redisTtlSeconds;
    }
    /**
     * 讀取緩存：自動(dòng)降級(jí)查詢(xún)
     * @param key 緩存鍵
     * @param loader 數(shù)據(jù)庫(kù)加載器（緩存未命中時(shí)執(zhí)行）
     * @return 緩存值
     */
    public V get(K key, Supplier<V> loader) {
        // 1. 查本地緩存
        V value = localCache.get(key);
        if (value != null) {
            return value;
        }
        // 2. 查 Redis 緩存
        String redisKey = prefix + key;
        String redisValue = redisClient.get(redisKey);
        if (redisValue != null) {
            V deserialized = deserialize(redisValue); // 反序列化
            localCache.put(key, deserialized); // 回寫(xiě)本地緩存
            return deserialized;
        }
        // 3. 查數(shù)據(jù)庫(kù)并回寫(xiě)緩存
        value = loader.get();
        if (value != null) {
            localCache.put(key, value);
            redisClient.setex(redisKey, redisTtlSeconds, serialize(value)); // 序列化并設(shè)置過(guò)期時(shí)間
        }
        return value;
    }
    /**
     * 淘汰緩存：更新數(shù)據(jù)時(shí)調(diào)用
     */
    public void evict(K key) {
        localCache.remove(key); // 淘汰本地緩存
        redisClient.del(prefix + key); // 淘汰 Redis 緩存
        // 發(fā)送消息通知其他節(jié)點(diǎn)淘汰本地緩存（如 RocketMQ/Kafka）
        sendEvictMessage(key);
    }
    // 序列化/反序列化（簡(jiǎn)化實(shí)現(xiàn)，實(shí)際可使用 Jackson）
    private String serialize(V value) {
        return value.toString();
    }
    private V deserialize(String value) {
        return (V) value;
    }
    // 發(fā)送緩存淘汰消息（簡(jiǎn)化實(shí)現(xiàn)）
    private void sendEvictMessage(K key) {
        System.out.println("發(fā)送緩存淘汰消息：" + key);
    }
}

import java.util.*;
/**
 * 裝飾器模式：帶訪問(wèn)日志的 List
 */
public class LoggingList<E> implements List<E> {
    // 被裝飾的原 List
    private final List<E> target;
    // 日志記錄器（簡(jiǎn)化實(shí)現(xiàn)）
    private final Logger logger = new Logger();
    // 構(gòu)造函數(shù)：傳入原 List
    public LoggingList(List<E> target) {
        this.target = Objects.requireNonNull(target);
    }
    /**
     * 增強(qiáng) add 方法：記錄添加日志
     */
    @Override
    public boolean add(E e) {
        logger.log("添加元素：" + e);
        return target.add(e);
    }
    /**
     * 增強(qiáng) get 方法：記錄訪問(wèn)日志
     */
    @Override
    public E get(int index) {
        E e = target.get(index);
        logger.log("訪問(wèn)索引 " + index + " 的元素：" + e);
        return e;
    }
    /**
     * 其他方法直接委托給原 List（省略重復(fù)代碼，實(shí)際開(kāi)發(fā)可通過(guò) IDE 自動(dòng)生成）
     */
    @Override
    public int size() {
        return target.size();
    }
    @Override
    public boolean isEmpty() {
        return target.isEmpty();
    }
    // ... 其他 List 接口方法（均委托給 target）
    /**
     * 簡(jiǎn)化日志類(lèi)
     */
    private static class Logger {
        public void log(String message) {
            System.out.println("[LoggingList] " + message);
        }
    }
    // 測(cè)試
    public static void main(String[] args) {
        List<String> list = new LoggingList<>(new ArrayList<>());
        list.add("Java");
        list.add("集合");
        list.get(0);
        // 輸出：
        // [LoggingList] 添加元素：Java
        // [LoggingList] 添加元素：集合
        // [LoggingList] 訪問(wèn)索引 0 的元素：Java
    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
/**
 * 享元模式：商品規(guī)格享元池（復(fù)用重復(fù)的規(guī)格對(duì)象）
 */
public class SpecificationFlyweightPool {
    // 享元池：緩存規(guī)格對(duì)象（key=規(guī)格編碼，value=規(guī)格對(duì)象）
    private static final Map<String, Specification> POOL = new HashMap<>();
    /**
     * 獲取規(guī)格對(duì)象：存在則復(fù)用，不存在則創(chuàng)建并緩存
     */
    public static Specification getSpecification(String color, String size) {
        Objects.requireNonNull(color);
        Objects.requireNonNull(size);
        // 生成唯一編碼（作為享元池 key）
        String key = color + "_" + size;
        // 雙重檢查鎖定（DCL）保證線程安全
        if (!POOL.containsKey(key)) {
            synchronized (SpecificationFlyweightPool.class) {
                if (!POOL.containsKey(key)) {
                    POOL.put(key, new Specification(color, size));
                }
            }
        }
        return POOL.get(key);
    }
    /**
     * 商品規(guī)格類(lèi)（不可變，確保享元安全復(fù)用）
     */
    public static class Specification {
        private final String color;
        private final String size;
        private Specification(String color, String size) {
            this.color = color;
            this.size = size;
        }
        // getter（無(wú) setter，確保不可變）
        public String getColor() {
            return color;
        }
        public String getSize() {
            return size;
        }
        // 重寫(xiě) equals 和 hashCode（確保 key 唯一性）
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Specification that = (Specification) o;
            return Objects.equals(color, that.color) && Objects.equals(size, that.size);
        }
        @Override
        public int hashCode() {
            return Objects.hash(color, size);
        }
    }
    // 測(cè)試：復(fù)用對(duì)象
    public static void main(String[] args) {
        Specification spec1 = getSpecification("紅色", "M");
        Specification spec2 = getSpecification("紅色", "M");
        System.out.println(spec1 == spec2); // true（復(fù)用同一對(duì)象）
    }
}

import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Objects;
/**
 * 迭代器模式：分頁(yè)迭代器（按頁(yè)遍歷集合）
 */
public class PagingIterator<E> implements Iterator<List<E>> {
    private final List<E> source; // 源集合
    private final int pageSize; // 每頁(yè)大小
    private int currentPage; // 當(dāng)前頁(yè)碼（從 0 開(kāi)始）
    private final int totalPages; // 總頁(yè)數(shù)
    /**
     * 構(gòu)造函數(shù)：傳入源集合和每頁(yè)大小
     */
    public PagingIterator(List<E> source, int pageSize) {
        this.source = Objects.requireNonNull(source);
        if (pageSize <= 0) {
            throw new IllegalArgumentException("每頁(yè)大小必須大于 0");
        }
        this.pageSize = pageSize;
        this.currentPage = 0;
        // 計(jì)算總頁(yè)數(shù)
        this.totalPages = (source.size() + pageSize - 1) / pageSize;
    }
    /**
     * 是否還有下一頁(yè)
     */
    @Override
    public boolean hasNext() {
        return currentPage < totalPages;
    }
    /**
     * 獲取下一頁(yè)數(shù)據(jù)
     */
    @Override
    public List<E> next() {
        if (!hasNext()) {
            throw new NoSuchElementException("沒(méi)有更多頁(yè)面");
        }
        // 計(jì)算當(dāng)前頁(yè)的起始索引和結(jié)束索引
        int start = currentPage * pageSize;
        int end = Math.min(start + pageSize, source.size());
        List<E> pageData = source.subList(start, end);
        currentPage++;
        return pageData;
    }
    // 測(cè)試：分頁(yè)遍歷 10 條數(shù)據(jù)（每頁(yè) 3 條）
    public static void main(String[] args) {
        List<Integer> list = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        PagingIterator<Integer> iterator = new PagingIterator<>(list, 3);
        int pageNum = 1;
        while (iterator.hasNext()) {
            List<Integer> page = iterator.next();
            System.out.println("第 " + pageNum + " 頁(yè)：" + page);
            pageNum++;
        }
        // 輸出：
        // 第 1 頁(yè)：[1, 2, 3]
        // 第 2 頁(yè)：[4, 5, 6]
        // 第 3 頁(yè)：[7, 8, 9]
        // 第 4 頁(yè)：[10]
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
/**
 * 集合分片工具類(lèi)：將大 List 拆分為多個(gè)小分片
 */
public class ListSharder<T> {
    private final List<T> source; // 源集合
    private final int shardSize; // 每個(gè)分片的最大大小
    public ListSharder(List<T> source, int shardSize) {
        this.source = Objects.requireNonNull(source);
        if (shardSize <= 0) {
            throw new IllegalArgumentException("分片大小必須大于 0");
        }
        this.shardSize = shardSize;
    }
    /**
     * 執(zhí)行分片：返回分片列表
     */
    public List<List<T>> shard() {
        List<List<T>> shards = new ArrayList<>();
        int totalSize = source.size();
        if (totalSize == 0) {
            return shards;
        }
        // 計(jì)算分片數(shù)量
        int shardCount = (totalSize + shardSize - 1) / shardSize;
        for (int i = 0; i < shardCount; i++) {
            // 計(jì)算當(dāng)前分片的起始和結(jié)束索引
            int start = i * shardSize;
            int end = Math.min(start + shardSize, totalSize);
            // 截取分片并添加到結(jié)果集（ArrayList 是線程不安全的，并行處理時(shí)需注意）
            List<T> shard = new ArrayList<>(source.subList(start, end));
            shards.add(shard);
        }
        return shards;
    }
    // 測(cè)試：將 100 萬(wàn)條數(shù)據(jù)拆分為每個(gè)分片 1 萬(wàn)條
    public static void main(String[] args) {
        // 生成 100 萬(wàn)條測(cè)試數(shù)據(jù)
        List<Integer> bigList = new ArrayList<>(1_000_000);
        for (int i = 0; i < 1_000_000; i++) {
            bigList.add(i);
        }
        // 分片（每個(gè)分片 10000 條）
        ListSharder<Integer> sharder = new ListSharder<>(bigList, 10_000);
        List<List<Integer>> shards = sharder.shard();
        System.out.println("總數(shù)據(jù)量：" + bigList.size());
        System.out.println("分片數(shù)量：" + shards.size());
        System.out.println("每個(gè)分片大小：" + shards.get(0).size());
        // 輸出：
        // 總數(shù)據(jù)量：1000000
        // 分片數(shù)量：100
        // 每個(gè)分片大小：10000
    }
}

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
/**
 * 分片并行處理器：基于線程池處理分片數(shù)據(jù)
 */
public class ShardParallelProcessor<T, R> {
    private final ExecutorService executor; // 線程池
    private final int threadCount; // 線程數(shù)（默認(rèn) CPU 核心數(shù)）
    // 構(gòu)造函數(shù)：默認(rèn)線程數(shù)為 CPU 核心數(shù)
    public ShardParallelProcessor() {
        this.threadCount = Runtime.getRuntime().availableProcessors();
        this.executor = Executors.newFixedThreadPool(threadCount);
    }
    // 構(gòu)造函數(shù)：自定義線程數(shù)
    public ShardParallelProcessor(int threadCount) {
        this.threadCount = threadCount;
        this.executor = Executors.newFixedThreadPool(threadCount);
    }
    /**
     * 并行處理分片：每個(gè)分片執(zhí)行 processor 邏輯
     * @param shards 分片列表
     * @param processor 分片處理邏輯（函數(shù)式接口）
     * @return 合并后的處理結(jié)果
     */
    public List<R> process(List<List<T>> shards, ShardProcessor<T, R> processor) {
        try {
            // 提交所有分片任務(wù)，并行執(zhí)行
            return shards.stream()
                    .map(shard -> executor.submit(() -> processor.process(shard)))
                    .map(future -> {
                        try {
                            return future.get(); // 獲取分片處理結(jié)果
                        } catch (Exception e) {
                            throw new RuntimeException("分片處理失敗", e);
                        }
                    })
                    .flatMap(List::stream) // 合并所有分片結(jié)果
                    .collect(Collectors.toList());
        } finally {
            // 關(guān)閉線程池
            executor.shutdown();
            try {
                if (!executor.awaitTermination(1, TimeUnit.HOURS)) {
                    executor.shutdownNow();
                }
            } catch (InterruptedException e) {
                executor.shutdownNow();
            }
        }
    }
    /**
     * 分片處理函數(shù)式接口
     */
    @FunctionalInterface
    public interface ShardProcessor<T, R> {
        List<R> process(List<T> shard);
    }
    // 測(cè)試：并行統(tǒng)計(jì)分片數(shù)據(jù)中偶數(shù)的個(gè)數(shù)
    public static void main(String[] args) {
        // 1. 生成 100 萬(wàn)條數(shù)據(jù)并分片
        List<Integer> bigList = new ArrayList<>(1_000_000);
        for (int i = 0; i < 1_000_000; i++) {
            bigList.add(i);
        }
        ListSharder<Integer> sharder = new ListSharder<>(bigList, 10_000);
        List<List<Integer>> shards = sharder.shard();
        // 2. 并行處理：統(tǒng)計(jì)每個(gè)分片的偶數(shù)個(gè)數(shù)
        ShardParallelProcessor<Integer, Integer> processor = new ShardParallelProcessor<>();
        List<Integer> shardEvenCounts = processor.process(shards, shard -> {
            // 每個(gè)分片統(tǒng)計(jì)偶數(shù)個(gè)數(shù)
            long count = shard.stream().filter(num -> num % 2 == 0).count();
            return List.of((int) count);
        });
        // 3. 合并結(jié)果
        int totalEvenCount = shardEvenCounts.stream().mapToInt(Integer::intValue).sum();
        System.out.println("100 萬(wàn)條數(shù)據(jù)中偶數(shù)的個(gè)數(shù)：" + totalEvenCount); // 輸出：500000
    }
}

import io.protostuff.LinkedBuffer;
import io.protostuff.ProtostuffIOUtil;
import io.protostuff.Schema;
import io.protostuff.runtime.RuntimeSchema;
import java.util.List;
import java.util.Map;
/**
 * 集合序列化工具類(lèi)（基于 Protostuff）
 */
public class CollectionSerializer {
    // 線程局部變量：避免緩沖區(qū)競(jìng)爭(zhēng)
    private static final ThreadLocal<LinkedBuffer> BUFFER = ThreadLocal.withInitial(() -> LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
    /**
     * 序列化 List
     */
    public static <T> byte[] serializeList(List<T> list, Class<T> clazz) {
        if (list == null || list.isEmpty()) {
            return new byte[0];
        }
        Schema<T> schema = RuntimeSchema.getSchema(clazz);
        LinkedBuffer buffer = BUFFER.get();
        try {
            return ProtostuffIOUtil.toByteArray(list, schema, buffer);
        } finally {
            buffer.clear(); // 清空緩沖區(qū)
        }
    }
    /**
     * 反序列化 List
     */
    public static <T> List<T> deserializeList(byte[] data, Class<T> clazz) {
        if (data == null || data.length == 0) {
            return List.of();
        }
        Schema<T> schema = RuntimeSchema.getSchema(clazz);
        List<T> list = schema.newMessage().getClass().isAssignableFrom(List.class) ? 
                (List<T>) schema.newMessage() : new ArrayList<>();
        ProtostuffIOUtil.mergeFrom(data, (T) list, schema);
        return list;
    }
    /**
     * 序列化 Map（簡(jiǎn)化實(shí)現(xiàn)，實(shí)際需自定義 Schema）
     */
    public static <K, V> byte[] serializeMap(Map<K, V> map, Class<K> keyClazz, Class<V> valueClazz) {
        // 實(shí)際開(kāi)發(fā)中需為 Map 自定義 Schema，此處簡(jiǎn)化為 JSON 序列化（僅作示例）
        try {
            return new com.alibaba.fastjson.JSONObject().toJSONBytes(map);
        } catch (Exception e) {
            throw new RuntimeException("Map 序列化失敗", e);
        }
    }
    /**
     * 反序列化 Map
     */
    public static <K, V> Map<K, V> deserializeMap(byte[] data, Class<K> keyClazz, Class<V> valueClazz) {
        if (data == null || data.length == 0) {
            return Map.of();
        }
        // 對(duì)應(yīng)序列化邏輯，簡(jiǎn)化為 JSON 反序列化
        try {
            return com.alibaba.fastjson.JSONObject.parseObject(data, new com.alibaba.fastjson.TypeReference<Map<K, V>>() {});
        } catch (Exception e) {
            throw new RuntimeException("Map 反序列化失敗", e);
        }
    }
}

import redis.clients.jedis.Jedis;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
/**
 * 分布式集合修改：基于 Redis 分布式鎖保證一致性
 */
public class DistributedListModifier<T> {
    private final Jedis jedis;
    private final String listKey; // Redis 中 List 的 key
    private final String lockKey; // 分布式鎖 key
    private final long lockTimeout; // 鎖超時(shí)時(shí)間（毫秒）
    public DistributedListModifier(Jedis jedis, String listKey, long lockTimeout) {
        this.jedis = jedis;
        this.listKey = listKey;
        this.lockKey = "lock:" + listKey;
        this.lockTimeout = lockTimeout;
    }
    /**
     * 向分布式 List 中添加元素（線程安全）
     */
    public boolean addElement(T element) {
        String lockValue = UUID.randomUUID().toString();
        try {
            // 1. 獲取分布式鎖
            boolean locked = tryLock(lockValue);
            if (!locked) {
                return false; // 獲取鎖失敗，返回重試
            }
            // 2. 序列化元素并添加到 Redis List
            byte[] data = CollectionSerializer.serializeList(List.of(element), (Class<T>) element.getClass());
            jedis.rpush(listKey.getBytes(), data);
            return true;
        } finally {
            // 3. 釋放鎖
            releaseLock(lockValue);
        }
    }
    /**
     * 獲取分布式鎖
     */
    private boolean tryLock(String lockValue) {
        String result = jedis.set(lockKey, lockValue, "NX", "PX", lockTimeout);
        return "OK".equals(result);
    }
    /**
     * 釋放分布式鎖（防止誤釋放）
     */
    private void releaseLock(String lockValue) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        jedis.eval(script, List.of(lockKey), List.of(lockValue));
    }
}

import java.math.BigDecimal;
import java.util.List;
import java.util.Objects;
/**
 * 訂單上下文：封裝規(guī)則匹配所需的訂單信息
 */
public class OrderContext {
    private final String orderId;
    private final BigDecimal totalAmount; // 訂單總金額
    private final List<String> productIds; // 商品 ID 列表
    private final int memberLevel; // 會(huì)員等級(jí)
    // 構(gòu)造函數(shù)
    public OrderContext(String orderId, BigDecimal totalAmount, List<String> productIds, int memberLevel) {
        this.orderId = Objects.requireNonNull(orderId);
        this.totalAmount = Objects.requireNonNull(totalAmount);
        this.productIds = Objects.requireNonNull(productIds);
        this.memberLevel = memberLevel;
    }
    // getter
    public String getOrderId() {
        return orderId;
    }
    public BigDecimal getTotalAmount() {
        return totalAmount;
    }
    public List<String> getProductIds() {
        return productIds;
    }
    public int getMemberLevel() {
        return memberLevel;
    }
}

/**
 * 促銷(xiāo)規(guī)則接口：所有規(guī)則需實(shí)現(xiàn)此接口
 */
public interface PromotionRule {
    /**
     * 規(guī)則優(yōu)先級(jí)：數(shù)值越大，優(yōu)先級(jí)越高
     */
    int getPriority();
    /**
     * 規(guī)則匹配：判斷訂單是否滿足規(guī)則條件
     */
    boolean match(OrderContext context);
    /**
     * 執(zhí)行規(guī)則：返回促銷(xiāo)結(jié)果
     */
    PromotionResult execute(OrderContext context);
    /**
     * 促銷(xiāo)結(jié)果封裝
     */
    record PromotionResult(String ruleName, BigDecimal discountAmount, String gift) {}
}

import java.math.BigDecimal;
/**
 * 滿減規(guī)則：滿 1000 減 200
 */
public class FullReduceRule implements PromotionRule {
    @Override
    public int getPriority() {
        return 2; // 優(yōu)先級(jí)：2
    }
    @Override
    public boolean match(OrderContext context) {
        // 訂單金額 ≥1000 元
        return context.getTotalAmount().compareTo(new BigDecimal("1000")) >= 0;
    }
    @Override
    public PromotionResult execute(OrderContext context) {
        return new PromotionResult("滿1000減200", new BigDecimal("200"), "無(wú)");
    }
}
/**
 * 會(huì)員折扣規(guī)則：VIP 會(huì)員 9 折
 */
public class MemberDiscountRule implements PromotionRule {
    @Override
    public int getPriority() {
        return 1; // 優(yōu)先級(jí)：1（低于滿減規(guī)則）
    }
    @Override
    public boolean match(OrderContext context) {
        // 會(huì)員等級(jí) ≥3（VIP 會(huì)員）
        return context.getMemberLevel() >= 3;
    }
    @Override
    public PromotionResult execute(OrderContext context) {
        BigDecimal discount = context.getTotalAmount().multiply(new BigDecimal("0.1"));
        return new PromotionResult("VIP 9折", discount, "無(wú)");
    }
}
/**
 * 贈(zèng)品規(guī)則：購(gòu)買(mǎi)指定商品送贈(zèng)品
 */
public class GiftRule implements PromotionRule {
    private final String targetProductId;
    private final String gift;
    public GiftRule(String targetProductId, String gift) {
        this.targetProductId = targetProductId;
        this.gift = gift;
    }
    @Override
    public int getPriority() {
        return 3; // 優(yōu)先級(jí)：3（最高）
    }
    @Override
    public boolean match(OrderContext context) {
        // 包含指定商品
        return context.getProductIds().contains(targetProductId);
    }
    @Override
    public PromotionResult execute(OrderContext context) {
        return new PromotionResult("購(gòu)買(mǎi)指定商品送贈(zèng)品", BigDecimal.ZERO, gift);
    }
}

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;
/**
 * 規(guī)則引擎：基于 TreeSet 按優(yōu)先級(jí)管理規(guī)則
 */
public class RuleEngine {
    // 存儲(chǔ)規(guī)則：TreeSet 按優(yōu)先級(jí)降序排序（優(yōu)先級(jí)越高越先執(zhí)行）
    private final TreeSet<PromotionRule> rules = new TreeSet<>(Comparator.comparingInt(PromotionRule::getPriority).reversed());
    /**
     * 添加規(guī)則
     */
    public void addRule(PromotionRule rule) {
        rules.add(rule);
    }
    /**
     * 匹配并執(zhí)行規(guī)則：返回所有符合條件的規(guī)則結(jié)果
     */
    public List<PromotionResult> executeRules(OrderContext context) {
        List<PromotionResult> results = new ArrayList<>();
        for (PromotionRule rule : rules) {
            if (rule.match(context)) {
                results.add(rule.execute(context));
                // 若為排他規(guī)則，可在此處 break（本案例支持多規(guī)則疊加）
            }
        }
        return results;
    }
    // 測(cè)試
    public static void main(String[] args) {
        // 1. 初始化規(guī)則引擎并添加規(guī)則
        RuleEngine engine = new RuleEngine();
        engine.addRule(new FullReduceRule());
        engine.addRule(new MemberDiscountRule());
        engine.addRule(new GiftRule("P001", "保溫杯"));
        // 2. 構(gòu)造訂單上下文（滿 1000 元、VIP 會(huì)員、包含 P001 商品）
        OrderContext context = new OrderContext(
                "ORDER001",
                new BigDecimal("1500"),
                List.of("P001", "P002"),
                3
        );
        // 3. 執(zhí)行規(guī)則
        List<PromotionResult> results = engine.executeRules(context);
        // 4. 輸出結(jié)果（按優(yōu)先級(jí)排序：贈(zèng)品規(guī)則 → 滿減規(guī)則 → 折扣規(guī)則）
        System.out.println("訂單 " + context.getOrderId() + " 匹配的促銷(xiāo)規(guī)則：");
        for (PromotionResult result : results) {
            System.out.printf("規(guī)則：%s，折扣金額：%s，贈(zèng)品：%s%n",
                    result.ruleName(), result.discountAmount(), result.gift());
        }
    }
}