// 幂等性实现示例
@RestController
public class PaymentController {
    
    @PostMapping("/payment")
    public ResponseEntity<PaymentResult> processPayment(
            @RequestBody PaymentRequest request,
            @RequestHeader("X-Request-ID") String requestId) {
        
        // 检查是否已经处理过相同的请求
        if (paymentService.isProcessed(requestId)) {
            return ResponseEntity.ok(paymentService.getPaymentResult(requestId));
        }
        
        // 处理支付
        PaymentResult result = paymentService.processPayment(request);
        
        // 记录已处理的请求
        paymentService.recordProcessedRequest(requestId, result);
        
        return ResponseEntity.ok(result);
    }
}

// 三阶段提交实现
public class ThreePhaseCommit {
    
    enum Phase {
        PREPARE, PRE_COMMIT, COMMIT
    }
    
    public boolean executeTransaction(List<Participant> participants) {
        // 预准备阶段
        if (!prePreparePhase(participants)) {
            return false;
        }
        
        // 准备阶段
        if (!preparePhase(participants)) {
            rollbackParticipants(participants, Phase.PREPARE);
            return false;
        }
        
        // 预提交阶段
        if (!preCommitPhase(participants)) {
            rollbackParticipants(participants, Phase.PREPARE);
            return false;
        }
        
        // 提交阶段
        commitPhase(participants);
        return true;
    }
}

// 一致性哈希实现
public class ConsistentHash<T> {
    private final SortedMap<Integer, T> circle = new TreeMap<>();
    private final int virtualNodes;
    
    public ConsistentHash(int virtualNodes) {
        this.virtualNodes = virtualNodes;
    }
    
    public void addNode(T node) {
        for (int i = 0; i < virtualNodes; i++) {
            String virtualNode = node.toString() + "#" + i;
            int hash = hash(virtualNode);
            circle.put(hash, node);
        }
    }
    
    public void removeNode(T node) {
        for (int i = 0; i < virtualNodes; i++) {
            String virtualNode = node.toString() + "#" + i;
            int hash = hash(virtualNode);
            circle.remove(hash);
        }
    }
    
    public T getNode(String key) {
        if (circle.isEmpty()) {
            return null;
        }
        
        int hash = hash(key);
        if (!circle.containsKey(hash)) {
            SortedMap<Integer, T> tailMap = circle.tailMap(hash);
            hash = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey();
        }
        return circle.get(hash);
    }
    
    private int hash(String key) {
        return md5(key).hashCode();
    }
}

// 最少连接负载均衡实现
public class LeastConnectionsBalancer {
    private Map<String, Integer> serverConnections = new HashMap<>();
    private List<String> servers;
    
    public LeastConnectionsBalancer(List<String> servers) {
        this.servers = servers;
        for (String server : servers) {
            serverConnections.put(server, 0);
        }
    }
    
    public String getServer() {
        String selectedServer = null;
        int minConnections = Integer.MAX_VALUE;
        
        for (String server : servers) {
            int connections = serverConnections.get(server);
            if (connections < minConnections) {
                minConnections = connections;
                selectedServer = server;
            }
        }
        
        // 更新连接数
        serverConnections.put(selectedServer, serverConnections.get(selectedServer) + 1);
        
        return selectedServer;
    }
    
    public void releaseConnection(String server) {
        serverConnections.put(server, Math.max(0, serverConnections.get(server) - 1));
    }
}

// 连接池实现
public class ConnectionPool {
    private final BlockingQueue<Connection> availableConnections;
    private final Set<Connection> activeConnections;
    private final int maxPoolSize;
    private final int minPoolSize;
    private final long connectionTimeout;
    
    public ConnectionPool(int minPoolSize, int maxPoolSize, long connectionTimeout) {
        this.minPoolSize = minPoolSize;
        this.maxPoolSize = maxPoolSize;
        this.connectionTimeout = connectionTimeout;
        this.availableConnections = new LinkedBlockingQueue<>(maxPoolSize);
        this.activeConnections = ConcurrentHashMap.newKeySet();
        
        // 初始化最小连接数
        initializePool();
    }
    
    private void initializePool() {
        for (int i = 0; i < minPoolSize; i++) {
            availableConnections.add(createConnection());
        }
    }
    
    public Connection getConnection() throws SQLException {
        // 尝试从连接池获取连接
        Connection connection = availableConnections.poll();
        
        if (connection != null) {
            activeConnections.add(connection);
            return connection;
        }
        
        // 如果没有可用连接，等待
        try {
            connection = availableConnections.poll(connectionTimeout, TimeUnit.MILLISECONDS);
            if (connection != null) {
                activeConnections.add(connection);
                return connection;
            }
            
            // 超时后尝试创建新连接
            if (activeConnections.size() < maxPoolSize) {
                connection = createConnection();
                activeConnections.add(connection);
                return connection;
            }
            
            throw new SQLException("Connection pool exhausted");
            
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new SQLException("Interrupted while waiting for connection", e);
        }
    }
    
    public void releaseConnection(Connection connection) {
        if (activeConnections.remove(connection)) {
            // 检查连接是否有效
            if (isConnectionValid(connection)) {
                availableConnections.offer(connection);
            } else {
                // 创建新连接替代
                activeConnections.add(createConnection());
            }
        }
    }
    
    private Connection createConnection() {
        // 实现创建连接的逻辑
        return new Connection();
    }
}

// 金融支付系统实现
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicLong;

public class PaymentSystem {
    // 支付状态
    public enum PaymentStatus {
        PENDING, PROCESSING, COMPLETED, FAILED, CANCELLED, REFUNDED
    }
    
    // 支付类型
    public enum PaymentType {
        CREDIT_CARD, DEBIT_CARD, BANK_TRANSFER, DIGITAL_WALLET, CRYPTO
    }
    
    // 支付交易
    public static class PaymentTransaction {
        private String transactionId;
        private String userId;
        private BigDecimal amount;
        private PaymentType paymentType;
        private PaymentStatus status;
        private String merchantId;
        private String orderId;
        private Date createdAt;
        private Date updatedAt;
        private String errorMessage;
        
        public PaymentTransaction(String userId, BigDecimal amount, 
                                PaymentType paymentType, String merchantId) {
            this.transactionId = UUID.randomUUID().toString();
            this.userId = userId;
            this.amount = amount;
            this.paymentType = paymentType;
            this.merchantId = merchantId;
            this.status = PaymentStatus.PENDING;
            this.createdAt = new Date();
            this.updatedAt = new Date();
        }
    }
    
    // 支付处理器
    public static class PaymentProcessor {
        private final ExecutorService executor;
        private final Map<PaymentType, PaymentGateway> gateways;
        private final Queue<PaymentTransaction> queue;
        private final Map<String, PaymentTransaction> transactions;
        private final AtomicLong counter = new AtomicLong(0);
        
        public PaymentProcessor() {
            this.executor = Executors.newFixedThreadPool(10);
            this.gateways = new EnumMap<>(PaymentType.class);
            this.queue = new ConcurrentLinkedQueue<>();
            this.transactions = new ConcurrentHashMap<>();
            
            // 初始化支付网关
            gateways.put(PaymentType.CREDIT_CARD, new CreditCardGateway());
            gateways.put(PaymentType.DEBIT_CARD, new DebitCardGateway());
            gateways.put(PaymentType.BANK_TRANSFER, new BankTransferGateway());
            gateways.put(PaymentType.DIGITAL_WALLET, new DigitalWalletGateway());
            
            // 启动处理线程
            startProcessing();
        }
        
        public String createPayment(String userId, BigDecimal amount, 
                                   PaymentType paymentType, String merchantId) {
            PaymentTransaction transaction = new PaymentTransaction(userId, amount, 
                                                                  paymentType, merchantId);
            transactions.put(transaction.transactionId, transaction);
            queue.offer(transaction);
            return transaction.transactionId;
        }
        
        private void startProcessing() {
            for (int i = 0; i < 5; i++) {
                executor.submit(() -> {
                    while (true) {
                        try {
                            PaymentTransaction transaction = queue.poll();
                            if (transaction != null) {
                                processPayment(transaction);
                            } else {
                                Thread.sleep(100); // 避免忙等待
                            }
                        } catch (Exception e) {
                            // 记录错误
                        }
                    }
                });
            }
        }
        
        private void processPayment(PaymentTransaction transaction) {
            try {
                // 更新状态为处理中
                transaction.status = PaymentStatus.PROCESSING;
                transaction.updatedAt = new Date();
                
                // 获取对应的支付网关
                PaymentGateway gateway = gateways.get(transaction.paymentType);
                if (gateway == null) {
                    throw new RuntimeException("Unsupported payment type: " + transaction.paymentType);
                }
                
                // 处理支付
                PaymentResult result = gateway.processPayment(
                    transaction.userId, 
                    transaction.amount,
                    transaction.merchantId
                );
                
                // 更新交易状态
                if (result.isSuccess()) {
                    transaction.status = PaymentStatus.COMPLETED;
                    transaction.updatedAt = new Date();
                    
                    // 触发成功回调
                    PaymentEvent event = new PaymentEvent(
                        transaction.transactionId,
                        PaymentEvent.EventType.PAYMENT_SUCCESS,
                        result.getTransactionId()
                    );
                    eventBus.publish(event);
                } else {
                    transaction.status = PaymentStatus.FAILED;
                    transaction.errorMessage = result.getErrorMessage();
                    transaction.updatedAt = new Date();
                    
                    // 触发失败回调
                    PaymentEvent event = new PaymentEvent(
                        transaction.transactionId,
                        PaymentEvent.EventType.PAYMENT_FAILED,
                        result.getErrorMessage()
                    );
                    eventBus.publish(event);
                }
                
            } catch (Exception e) {
                // 处理异常
                transaction.status = PaymentStatus.FAILED;
                transaction.errorMessage = e.getMessage();
                transaction.updatedAt = new Date();
            }
        }
        
        public PaymentTransaction getTransaction(String transactionId) {
            return transactions.get(transactionId);
        }
        
        public List<PaymentTransaction> getUserTransactions(String userId) {
            return transactions.values().stream()
                .filter(t -> t.userId.equals(userId))
                .sorted((a, b) -> b.updatedAt.compareTo(a.updatedAt))
                .collect(Collectors.toList());
        }
    }
    
    // 支付网关接口
    public interface PaymentGateway {
        PaymentResult processPayment(String userId, BigDecimal amount, String merchantId);
    }
    
    // 支付结果
    public static class PaymentResult {
        private final boolean success;
        private final String transactionId;
        private final String errorMessage;
        private final Date processedAt;
        
        public PaymentResult(boolean success, String transactionId, String errorMessage) {
            this.success = success;
            this.transactionId = transactionId;
            this.errorMessage = errorMessage;
            this.processedAt = new Date();
        }
        
        public boolean isSuccess() { return success; }
        public String getTransactionId() { return transactionId; }
        public String getErrorMessage() { return errorMessage; }
        public Date getProcessedAt() { return processedAt; }
    }
    
    // 信用卡支付网关
    public static class CreditCardGateway implements PaymentGateway {
        @Override
        public PaymentResult processPayment(String userId, BigDecimal amount, String merchantId) {
            // 模拟信用卡处理
            try {
                // 验证信用卡信息
                if (!validateCreditCard(userId)) {
                    return new PaymentResult(false, null, "Invalid credit card information");
                }
                
                // 检查信用额度
                if (!checkCreditLimit(userId, amount)) {
                    return new PaymentResult(false, null, "Insufficient credit limit");
                }
                
                // 扣款
                String transactionId = deductCredit(userId, amount, merchantId);
                
                return new PaymentResult(true, transactionId, null);
                
            } catch (Exception e) {
                return new PaymentResult(false, null, e.getMessage());
            }
        }
        
        private boolean validateCreditCard(String userId) {
            // 实现信用卡验证逻辑
            return true;
        }
        
        private boolean checkCreditLimit(String userId, BigDecimal amount) {
            // 实现信用额度检查逻辑
            return true;
        }
        
        private String deductCredit(String userId, BigDecimal amount, String merchantId) {
            // 实现扣款逻辑
            return UUID.randomUUID().toString();
        }
    }
    
    // 事件总线
    public static class EventBus {
        private final Map<PaymentEvent.EventType, List<Consumer<PaymentEvent>>> listeners = 
            new ConcurrentHashMap<>();
        
        public void subscribe(PaymentEvent.EventType eventType, Consumer<PaymentEvent> listener) {
            listeners.computeIfAbsent(eventType, k -> new CopyOnWriteArrayList<>()).add(listener);
        }
        
        public void publish(PaymentEvent event) {
            List<Consumer<PaymentEvent>> eventListeners = listeners.get(event.eventType);
            if (eventListeners != null) {
                eventListeners.forEach(listener -> {
                    try {
                        listener.accept(event);
                    } catch (Exception e) {
                        // 记录错误
                    }
                });
            }
        }
    }
    
    // 支付事件
    public static class PaymentEvent {
        public enum EventType {
            PAYMENT_SUCCESS, PAYMENT_FAILED, PAYMENT_CANCELLED, REFUND_SUCCESS
        }
        
        private final String transactionId;
        private final EventType eventType;
        private final String message;
        private final Date timestamp;
        
        public PaymentEvent(String transactionId, EventType eventType, String message) {
            this.transactionId = transactionId;
            this.eventType = eventType;
            this.message = message;
            this.timestamp = new Date();
        }
    }
    
    // 风控系统
    public static class RiskManagement {
        private final List<RiskRule> rules;
        
        public RiskManagement() {
            this.rules = Arrays.asList(
                new TransactionAmountRule(),
                new FrequencyRule(),
                new GeographicRule(),
                new DeviceFingerprintRule()
            );
        }
        
        public RiskAssessment assessRisk(PaymentTransaction transaction) {
            RiskAssessment assessment = new RiskAssessment();
            
            for (RiskRule rule : rules) {
                RiskResult result = rule.evaluate(transaction);
                assessment.addResult(result);
                
                if (result.isBlock()) {
                    assessment.setBlocked(true);
                    assessment.setReason(result.getMessage());
                    break;
                }
            }
            
            return assessment;
        }
    }
    
    // 风控规则接口
    public interface RiskRule {
        RiskResult evaluate(PaymentTransaction transaction);
    }
    
    // 风控结果
    public static class RiskResult {
        private final boolean block;
        private final String message;
        private final RiskLevel level;
        
        public RiskResult(boolean block, String message, RiskLevel level) {
            this.block = block;
            this.message = message;
            this.level = level;
        }
        
        public boolean isBlock() { return block; }
        public String getMessage() { return message; }
        public RiskLevel getLevel() { return level; }
    }
    
    // 风险等级
    public enum RiskLevel {
        LOW, MEDIUM, HIGH, CRITICAL
    }
    
    // 风控评估
    public static class RiskAssessment {
        private boolean blocked;
        private String reason;
        private List<RiskResult> results;
        
        public RiskAssessment() {
            this.results = new ArrayList<>();
        }
        
        public void addResult(RiskResult result) {
            results.add(result);
        }
        
        public void setBlocked(boolean blocked) {
            this.blocked = blocked;
        }
        
        public void setReason(String reason) {
            this.reason = reason;
        }
        
        public boolean isBlocked() { return blocked; }
        public String getReason() { return reason; }
        public List<RiskResult> getResults() { return results; }
    }
    
    // 具体风控规则示例
    public static class TransactionAmountRule implements RiskRule {
        @Override
        public RiskResult evaluate(PaymentTransaction transaction) {
            if (transaction.amount.compareTo(new BigDecimal("10000")) > 0) {
                return new RiskResult(true, "Transaction amount exceeds limit", RiskLevel.CRITICAL);
            }
            return new RiskResult(false, "Amount within limits", RiskLevel.LOW);
        }
    }
    
    public static class FrequencyRule implements RiskRule {
        @Override
        public RiskResult evaluate(PaymentTransaction transaction) {
            // 检查用户在短时间内的交易频率
            // 实现逻辑
            return new RiskResult(false, "Frequency check passed", RiskLevel.LOW);
        }
    }
    
    public static class GeographicRule implements RiskRule {
        @Override
        public RiskResult evaluate(PaymentTransaction transaction) {
            // 检查地理位置异常
            // 实现逻辑
            return new RiskResult(false, "Geographic check passed", RiskLevel.LOW);
        }
    }
    
    public static class DeviceFingerprintRule implements RiskRule {
        @Override
        public RiskResult evaluate(PaymentTransaction transaction) {
            // 检查设备指纹异常
            // 实现逻辑
            return new RiskResult(false, "Device fingerprint check passed", RiskLevel.LOW);
        }
    }
}