第172集支付分布式IDJava实战

/**
 * 支付分布式ID配置类
 * @author Java实战
 */
@Configuration
@EnableConfigurationProperties(PaymentDistributedIdProperties.class)
public class PaymentDistributedIdConfig {
    
    @Autowired
    private PaymentDistributedIdProperties properties;
    
    /**
     * 支付雪花算法ID生成器
     * @return 支付雪花算法ID生成器
     */
    @Bean
    public PaymentSnowflakeIdGenerator paymentSnowflakeIdGenerator() {
        return new PaymentSnowflakeIdGenerator(
            properties.getSnowflake().getWorkerId(),
            properties.getSnowflake().getDatacenterId(),
            properties.getSnowflake().getPaymentId()
        );
    }
    
    /**
     * 支付UUID生成器
     * @return 支付UUID生成器
     */
    @Bean
    public PaymentUuidGenerator paymentUuidGenerator() {
        return new PaymentUuidGenerator();
    }
    
    /**
     * 支付数据库自增ID生成器
     * @return 支付数据库自增ID生成器
     */
    @Bean
    public PaymentDatabaseIdGenerator paymentDatabaseIdGenerator() {
        return new PaymentDatabaseIdGenerator();
    }
    
    /**
     * 支付Redis ID生成器
     * @return 支付Redis ID生成器
     */
    @Bean
    public PaymentRedisIdGenerator paymentRedisIdGenerator() {
        return new PaymentRedisIdGenerator();
    }
    
    /**
     * 支付Zookeeper ID生成器
     * @return 支付Zookeeper ID生成器
     */
    @Bean
    public PaymentZookeeperIdGenerator paymentZookeeperIdGenerator() {
        return new PaymentZookeeperIdGenerator();
    }
    
    /**
     * 支付分布式ID服务
     * @return 支付分布式ID服务
     */
    @Bean
    public PaymentDistributedIdService paymentDistributedIdService() {
        return new PaymentDistributedIdService();
    }
    
    /**
     * 支付分布式ID监控服务
     * @return 支付分布式ID监控服务
     */
    @Bean
    public PaymentDistributedIdMonitorService paymentDistributedIdMonitorService() {
        return new PaymentDistributedIdMonitorService();
    }
    
    /**
     * 支付分布式ID安全服务
     * @return 支付分布式ID安全服务
     */
    @Bean
    public PaymentDistributedIdSecurityService paymentDistributedIdSecurityService() {
        return new PaymentDistributedIdSecurityService();
    }
    
    /**
     * 支付分布式ID风控服务
     * @return 支付分布式ID风控服务
     */
    @Bean
    public PaymentDistributedIdRiskService paymentDistributedIdRiskService() {
        return new PaymentDistributedIdRiskService();
    }
    
    private static final Logger logger = LoggerFactory.getLogger(PaymentDistributedIdConfig.class);
}

/**
 * 支付分布式ID属性配置
 * @author Java实战
 */
@Data
@ConfigurationProperties(prefix = "payment-distributed-id")
public class PaymentDistributedIdProperties {
    
    /**
     * 是否启用支付分布式ID
     */
    private boolean enablePaymentDistributedId = true;
    
    /**
     * 默认ID生成器类型
     */
    private String defaultGeneratorType = "PAYMENT_SNOWFLAKE";
    
    /**
     * 支付雪花算法配置
     */
    private PaymentSnowflakeConfig snowflake = new PaymentSnowflakeConfig();
    
    /**
     * 支付UUID配置
     */
    private PaymentUuidConfig uuid = new PaymentUuidConfig();
    
    /**
     * 支付数据库自增配置
     */
    private PaymentDatabaseConfig database = new PaymentDatabaseConfig();
    
    /**
     * 支付Redis配置
     */
    private PaymentRedisConfig redis = new PaymentRedisConfig();
    
    /**
     * 支付Zookeeper配置
     */
    private PaymentZookeeperConfig zookeeper = new PaymentZookeeperConfig();
    
    /**
     * 安全配置
     */
    private SecurityConfig security = new SecurityConfig();
    
    /**
     * 风控配置
     */
    private RiskConfig risk = new RiskConfig();
    
    /**
     * 合规配置
     */
    private ComplianceConfig compliance = new ComplianceConfig();
    
    /**
     * 是否启用监控
     */
    private boolean enableMonitoring = true;
    
    /**
     * 监控间隔（毫秒）
     */
    private long monitorInterval = 30000;
    
    /**
     * 是否启用告警
     */
    private boolean enableAlert = true;
    
    /**
     * 生成失败率告警阈值
     */
    private double failureRateAlertThreshold = 0.001;
    
    /**
     * 生成延迟告警阈值（毫秒）
     */
    private long latencyAlertThreshold = 50;
    
    /**
     * 支付雪花算法配置类
     */
    @Data
    public static class PaymentSnowflakeConfig {
        /**
         * 工作机器ID
         */
        private long workerId = 1L;
        
        /**
         * 数据中心ID
         */
        private long datacenterId = 1L;
        
        /**
         * 支付ID
         */
        private long paymentId = 1L;
        
        /**
         * 起始时间戳
         */
        private long startTimestamp = 1609459200000L; // 2021-01-01 00:00:00
        
        /**
         * 是否启用支付雪花算法
         */
        private boolean enableSnowflake = true;
        
        /**
         * 序列号位数
         */
        private long sequenceBits = 10L;
        
        /**
         * 机器标识位数
         */
        private long workerIdBits = 5L;
        
        /**
         * 数据中心标识位数
         */
        private long datacenterIdBits = 5L;
        
        /**
         * 支付标识位数
         */
        private long paymentIdBits = 4L;
        
        /**
         * 时间戳位数
         */
        private long timestampBits = 40L;
        
        /**
         * 是否启用加密
         */
        private boolean enableEncryption = true;
        
        /**
         * 加密密钥
         */
        private String encryptionKey = "payment-distributed-id-key";
    }
    
    /**
     * 支付UUID配置类
     */
    @Data
    public static class PaymentUuidConfig {
        /**
         * UUID版本
         */
        private String version = "UUID4";
        
        /**
         * 是否启用支付UUID
         */
        private boolean enableUuid = false;
        
        /**
         * 是否使用连字符
         */
        private boolean useHyphens = true;
        
        /**
         * 是否转大写
         */
        private boolean useUpperCase = false;
        
        /**
         * 是否启用加密
         */
        private boolean enableEncryption = true;
        
        /**
         * 加密密钥
         */
        private String encryptionKey = "payment-uuid-key";
    }
    
    /**
     * 支付数据库自增配置类
     */
    @Data
    public static class PaymentDatabaseConfig {
        /**
         * 数据源名称
         */
        private String dataSourceName = "payment";
        
        /**
         * 是否启用支付数据库自增
         */
        private boolean enableDatabase = false;
        
        /**
         * 表名
         */
        private String tableName = "payment_id_generator";
        
        /**
         * 字段名
         */
        private String fieldName = "id";
        
        /**
         * 步长
         */
        private int step = 1;
        
        /**
         * 初始值
         */
        private long initialValue = 1L;
        
        /**
         * 是否启用加密
         */
        private boolean enableEncryption = true;
        
        /**
         * 加密密钥
         */
        private String encryptionKey = "payment-database-key";
    }
    
    /**
     * 支付Redis配置类
     */
    @Data
    public static class PaymentRedisConfig {
        /**
         * Redis键前缀
         */
        private String keyPrefix = "payment:distributed:id:";
        
        /**
         * 是否启用支付Redis
         */
        private boolean enableRedis = false;
        
        /**
         * 过期时间（秒）
         */
        private long expireTime = 3600;
        
        /**
         * 步长
         */
        private int step = 1;
        
        /**
         * 初始值
         */
        private long initialValue = 1L;
        
        /**
         * 是否启用加密
         */
        private boolean enableEncryption = true;
        
        /**
         * 加密密钥
         */
        private String encryptionKey = "payment-redis-key";
    }
    
    /**
     * 支付Zookeeper配置类
     */
    @Data
    public static class PaymentZookeeperConfig {
        /**
         * Zookeeper连接地址
         */
        private String connectString = "localhost:2181";
        
        /**
         * 是否启用支付Zookeeper
         */
        private boolean enableZookeeper = false;
        
        /**
         * 会话超时时间（毫秒）
         */
        private int sessionTimeout = 30000;
        
        /**
         * 连接超时时间（毫秒）
         */
        private int connectionTimeout = 10000;
        
        /**
         * 根路径
         */
        private String rootPath = "/payment-distributed-id";
        
        /**
         * 是否启用加密
         */
        private boolean enableEncryption = true;
        
        /**
         * 加密密钥
         */
        private String encryptionKey = "payment-zookeeper-key";
    }
    
    /**
     * 安全配置类
     */
    @Data
    public static class SecurityConfig {
        /**
         * 是否启用安全
         */
        private boolean enableSecurity = true;
        
        /**
         * 安全级别
         */
        private String securityLevel = "HIGH";
        
        /**
         * 加密算法
         */
        private String encryptionAlgorithm = "AES";
        
        /**
         * 加密密钥长度
         */
        private int encryptionKeyLength = 256;
        
        /**
         * 是否启用数字签名
         */
        private boolean enableDigitalSignature = true;
        
        /**
         * 数字签名算法
         */
        private String signatureAlgorithm = "SHA256withRSA";
        
        /**
         * 是否启用访问控制
         */
        private boolean enableAccessControl = true;
        
        /**
         * 访问控制规则
         */
        private List<String> accessControlRules = new ArrayList<>();
    }
    
    /**
     * 风控配置类
     */
    @Data
    public static class RiskConfig {
        /**
         * 是否启用风控
         */
        private boolean enableRisk = true;
        
        /**
         * 风控规则
         */
        private List<String> riskRules = new ArrayList<>();
        
        /**
         * 风控阈值
         */
        private Map<String, Object> riskThresholds = new HashMap<>();
        
        /**
         * 是否启用实时风控
         */
        private boolean enableRealTimeRisk = true;
        
        /**
         * 风控队列大小
         */
        private int riskQueueSize = 10000;
        
        /**
         * 风控检查间隔（毫秒）
         */
        private long riskCheckInterval = 1000;
    }
    
    /**
     * 合规配置类
     */
    @Data
    public static class ComplianceConfig {
        /**
         * 是否启用合规
         */
        private boolean enableCompliance = true;
        
        /**
         * 合规规则
         */
        private List<String> complianceRules = new ArrayList<>();
        
        /**
         * 合规检查间隔（毫秒）
         */
        private long complianceCheckInterval = 60000;
        
        /**
         * 是否启用实时合规
         */
        private boolean enableRealTimeCompliance = true;
        
        /**
         * 合规队列大小
         */
        private int complianceQueueSize = 10000;
        
        /**
         * 合规保留天数
         */
        private int complianceRetentionDays = 2555; // 7年
    }
}

/**
 * 支付分布式ID数据模型类
 * @author Java实战
 */
@Data
@Table(name = "payment_distributed_id_record")
public class PaymentDistributedIdData {
    
    /**
     * 主键ID
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;
    
    /**
     * 支付分布式ID
     */
    @Column(name = "payment_distributed_id", length = 64)
    private String paymentDistributedId;
    
    /**
     * ID类型
     */
    @Column(name = "id_type", length = 32)
    private String idType;
    
    /**
     * 生成器类型
     */
    @Column(name = "generator_type", length = 32)
    private String generatorType;
    
    /**
     * 业务类型
     */
    @Column(name = "business_type", length = 32)
    private String businessType;
    
    /**
     * 支付业务类型
     */
    @Column(name = "payment_business_type", length = 32)
    private String paymentBusinessType;
    
    /**
     * 生成时间
     */
    @Column(name = "generate_time")
    private LocalDateTime generateTime;
    
    /**
     * 过期时间
     */
    @Column(name = "expire_time")
    private LocalDateTime expireTime;
    
    /**
     * 状态
     */
    @Column(name = "status", length = 20)
    private String status;
    
    /**
     * 加密状态
     */
    @Column(name = "encryption_status", length = 20)
    private String encryptionStatus;
    
    /**
     * 安全状态
     */
    @Column(name = "security_status", length = 20)
    private String securityStatus;
    
    /**
     * 风控状态
     */
    @Column(name = "risk_status", length = 20)
    private String riskStatus;
    
    /**
     * 合规状态
     */
    @Column(name = "compliance_status", length = 20)
    private String complianceStatus;
    
    /**
     * 扩展属性（JSON格式）
     */
    @Column(name = "extended_properties", columnDefinition = "TEXT")
    private String extendedProperties;
    
    /**
     * 安全信息（JSON格式）
     */
    @Column(name = "security_info", columnDefinition = "TEXT")
    private String securityInfo;
    
    /**
     * 风控信息（JSON格式）
     */
    @Column(name = "risk_info", columnDefinition = "TEXT")
    private String riskInfo;
    
    /**
     * 合规信息（JSON格式）
     */
    @Column(name = "compliance_info", columnDefinition = "TEXT")
    private String complianceInfo;
    
    /**
     * 创建时间
     */
    @Column(name = "create_time")
    @CreationTimestamp
    private LocalDateTime createTime;
    
    /**
     * 更新时间
     */
    @Column(name = "update_time")
    @UpdateTimestamp
    private LocalDateTime updateTime;
    
    public PaymentDistributedIdData() {
        this.status = "ACTIVE";
        this.encryptionStatus = "ENCRYPTED";
        this.securityStatus = "SECURED";
        this.riskStatus = "PENDING";
        this.complianceStatus = "PENDING";
        this.generateTime = LocalDateTime.now();
    }
    
    public PaymentDistributedIdData(String paymentDistributedId, String idType, String generatorType) {
        this();
        this.paymentDistributedId = paymentDistributedId;
        this.idType = idType;
        this.generatorType = generatorType;
    }
    
    /**
     * 验证支付分布式ID数据
     * @return 是否有效
     */
    public boolean validate() {
        if (paymentDistributedId == null || paymentDistributedId.isEmpty()) {
            return false;
        }
        
        if (idType == null || idType.isEmpty()) {
            return false;
        }
        
        if (generatorType == null || generatorType.isEmpty()) {
            return false;
        }
        
        if (paymentBusinessType == null || paymentBusinessType.isEmpty()) {
            return false;
        }
        
        return true;
    }
    
    /**
     * 是否过期
     * @return 是否过期
     */
    public boolean isExpired() {
        if (expireTime == null) {
            return false;
        }
        return LocalDateTime.now().isAfter(expireTime);
    }
    
    /**
     * 是否已加密
     * @return 是否已加密
     */
    public boolean isEncrypted() {
        return "ENCRYPTED".equals(this.encryptionStatus);
    }
    
    /**
     * 是否已安全处理
     * @return 是否已安全处理
     */
    public boolean isSecured() {
        return "SECURED".equals(this.securityStatus);
    }
    
    /**
     * 是否已风控
     * @return 是否已风控
     */
    public boolean isRiskChecked() {
        return "RISK_CHECKED".equals(this.riskStatus);
    }
    
    /**
     * 是否已合规
     * @return 是否已合规
     */
    public boolean isCompliant() {
        return "COMPLIANT".equals(this.complianceStatus);
    }
    
    /**
     * 设置扩展属性
     * @param key 键
     * @param value 值
     */
    public void setExtendedProperty(String key, Object value) {
        Map<String, Object> properties = getExtendedPropertiesMap();
        properties.put(key, value);
        this.extendedProperties = JSON.toJSONString(properties);
    }
    
    /**
     * 获取扩展属性
     * @param key 键
     * @return 值
     */
    public Object getExtendedProperty(String key) {
        Map<String, Object> properties = getExtendedPropertiesMap();
        return properties.get(key);
    }
    
    /**
     * 获取扩展属性Map
     * @return 扩展属性Map
     */
    private Map<String, Object> getExtendedPropertiesMap() {
        if (extendedProperties == null || extendedProperties.isEmpty()) {
            return new HashMap<>();
        }
        try {
            return JSON.parseObject(extendedProperties, new TypeReference<Map<String, Object>>() {});
        } catch (Exception e) {
            return new HashMap<>();
        }
    }
    
    /**
     * 设置扩展属性Map
     * @param properties 扩展属性Map
     */
    public void setExtendedPropertiesMap(Map<String, Object> properties) {
        this.extendedProperties = JSON.toJSONString(properties);
    }
    
    /**
     * 设置安全信息
     * @param securityInfo 安全信息
     */
    public void setSecurityInfo(Map<String, Object> securityInfo) {
        this.securityInfo = JSON.toJSONString(securityInfo);
    }
    
    /**
     * 获取安全信息
     * @return 安全信息
     */
    public Map<String, Object> getSecurityInfo() {
        if (securityInfo == null || securityInfo.isEmpty()) {
            return new HashMap<>();
        }
        try {
            return JSON.parseObject(securityInfo, new TypeReference<Map<String, Object>>() {});
        } catch (Exception e) {
            return new HashMap<>();
        }
    }
    
    /**
     * 设置风控信息
     * @param riskInfo 风控信息
     */
    public void setRiskInfo(Map<String, Object> riskInfo) {
        this.riskInfo = JSON.toJSONString(riskInfo);
    }
    
    /**
     * 获取风控信息
     * @return 风控信息
     */
    public Map<String, Object> getRiskInfo() {
        if (riskInfo == null || riskInfo.isEmpty()) {
            return new HashMap<>();
        }
        try {
            return JSON.parseObject(riskInfo, new TypeReference<Map<String, Object>>() {});
        } catch (Exception e) {
            return new HashMap<>();
        }
    }
    
    /**
     * 设置合规信息
     * @param complianceInfo 合规信息
     */
    public void setComplianceInfo(Map<String, Object> complianceInfo) {
        this.complianceInfo = JSON.toJSONString(complianceInfo);
    }
    
    /**
     * 获取合规信息
     * @return 合规信息
     */
    public Map<String, Object> getComplianceInfo() {
        if (complianceInfo == null || complianceInfo.isEmpty()) {
            return new HashMap<>();
        }
        try {
            return JSON.parseObject(complianceInfo, new TypeReference<Map<String, Object>>() {});
        } catch (Exception e) {
            return new HashMap<>();
        }
    }
}

/**
 * 支付分布式ID生成结果类
 * @author Java实战
 */
@Data
public class PaymentDistributedIdResult {
    
    /**
     * 是否成功
     */
    private boolean success;
    
    /**
     * 生成的ID
     */
    private String id;
    
    /**
     * ID类型
     */
    private String idType;
    
    /**
     * 生成器类型
     */
    private String generatorType;
    
    /**
     * 业务类型
     */
    private String businessType;
    
    /**
     * 支付业务类型
     */
    private String paymentBusinessType;
    
    /**
     * 生成时间
     */
    private LocalDateTime generateTime;
    
    /**
     * 错误信息
     */
    private String error;
    
    /**
     * 开始时间
     */
    private long startTime;
    
    /**
     * 结束时间
     */
    private long endTime;
    
    /**
     * 重试次数
     */
    private int retryCount;
    
    /**
     * 加密状态
     */
    private String encryptionStatus;
    
    /**
     * 安全状态
     */
    private String securityStatus;
    
    /**
     * 风控状态
     */
    private String riskStatus;
    
    /**
     * 合规状态
     */
    private String complianceStatus;
    
    /**
     * 扩展属性
     */
    private Map<String, Object> extendedProperties;
    
    /**
     * 安全信息
     */
    private Map<String, Object> securityInfo;
    
    /**
     * 风控信息
     */
    private Map<String, Object> riskInfo;
    
    /**
     * 合规信息
     */
    private Map<String, Object> complianceInfo;
    
    public PaymentDistributedIdResult() {
        this.success = false;
        this.retryCount = 0;
        this.extendedProperties = new HashMap<>();
        this.securityInfo = new HashMap<>();
        this.riskInfo = new HashMap<>();
        this.complianceInfo = new HashMap<>();
        this.encryptionStatus = "ENCRYPTED";
        this.securityStatus = "SECURED";
        this.riskStatus = "PENDING";
        this.complianceStatus = "PENDING";
    }
    
    public PaymentDistributedIdResult(String id, String idType, String generatorType) {
        this();
        this.id = id;
        this.idType = idType;
        this.generatorType = generatorType;
        this.generateTime = LocalDateTime.now();
    }
    
    /**
     * 获取生成耗时
     * @return 生成耗时（毫秒）
     */
    public long getDuration() {
        return endTime - startTime;
    }
    
    /**
     * 是否成功
     * @return 是否成功
     */
    public boolean isSuccess() {
        return success;
    }
    
    /**
     * 增加重试次数
     */
    public void incrementRetryCount() {
        this.retryCount++;
    }
    
    /**
     * 是否已加密
     * @return 是否已加密
     */
    public boolean isEncrypted() {
        return "ENCRYPTED".equals(this.encryptionStatus);
    }
    
    /**
     * 是否已安全处理
     * @return 是否已安全处理
     */
    public boolean isSecured() {
        return "SECURED".equals(this.securityStatus);
    }
    
    /**
     * 是否已风控
     * @return 是否已风控
     */
    public boolean isRiskChecked() {
        return "RISK_CHECKED".equals(this.riskStatus);
    }
    
    /**
     * 是否已合规
     * @return 是否已合规
     */
    public boolean isCompliant() {
        return "COMPLIANT".equals(this.complianceStatus);
    }
}

/**
 * 支付分布式ID状态信息类
 * @author Java实战
 */
@Data
public class PaymentDistributedIdStatus {
    
    /**
     * 总生成数
     */
    private long totalGenerated;
    
    /**
     * 成功生成数
     */
    private long successGenerated;
    
    /**
     * 失败生成数
     */
    private long failureGenerated;
    
    /**
     * 重试生成数
     */
    private long retryGenerated;
    
    /**
     * 加密生成数
     */
    private long encryptedGenerated;
    
    /**
     * 安全生成数
     */
    private long securedGenerated;
    
    /**
     * 风控生成数
     */
    private long riskCheckedGenerated;
    
    /**
     * 合规生成数
     */
    private long compliantGenerated;
    
    /**
     * 成功率
     */
    private double successRate;
    
    /**
     * 失败率
     */
    private double failureRate;
    
    /**
     * 重试率
     */
    private double retryRate;
    
    /**
     * 加密率
     */
    private double encryptionRate;
    
    /**
     * 安全率
     */
    private double securityRate;
    
    /**
     * 风控率
     */
    private double riskRate;
    
    /**
     * 合规率
     */
    private double complianceRate;
    
    /**
     * 平均生成时间（毫秒）
     */
    private double averageGenerateTime;
    
    /**
     * 最大生成时间（毫秒）
     */
    private long maxGenerateTime;
    
    /**
     * 最小生成时间（毫秒）
     */
    private long minGenerateTime;
    
    /**
     * 最后检查时间
     */
    private Long lastCheckTime;
    
    /**
     * 系统状态
     */
    private String systemStatus;
    
    /**
     * 各生成器状态
     */
    private Map<String, PaymentGeneratorStatus> generatorStatuses;
    
    public PaymentDistributedIdStatus() {
        this.lastCheckTime = System.currentTimeMillis();
        this.systemStatus = "HEALTHY";
        this.generatorStatuses = new HashMap<>();
    }
    
    /**
     * 计算成功率
     * @return 成功率
     */
    public double calculateSuccessRate() {
        if (totalGenerated > 0) {
            return (double) successGenerated / totalGenerated;
        }
        return 0.0;
    }
    
    /**
     * 计算失败率
     * @return 失败率
     */
    public double calculateFailureRate() {
        if (totalGenerated > 0) {
            return (double) failureGenerated / totalGenerated;
        }
        return 0.0;
    }
    
    /**
     * 计算重试率
     * @return 重试率
     */
    public double calculateRetryRate() {
        if (totalGenerated > 0) {
            return (double) retryGenerated / totalGenerated;
        }
        return 0.0;
    }
    
    /**
     * 计算加密率
     * @return 加密率
     */
    public double calculateEncryptionRate() {
        if (totalGenerated > 0) {
            return (double) encryptedGenerated / totalGenerated;
        }
        return 0.0;
    }
    
    /**
     * 计算安全率
     * @return 安全率
     */
    public double calculateSecurityRate() {
        if (totalGenerated > 0) {
            return (double) securedGenerated / totalGenerated;
        }
        return 0.0;
    }
    
    /**
     * 计算风控率
     * @return 风控率
     */
    public double calculateRiskRate() {
        if (totalGenerated > 0) {
            return (double) riskCheckedGenerated / totalGenerated;
        }
        return 0.0;
    }
    
    /**
     * 计算合规率
     * @return 合规率
     */
    public double calculateComplianceRate() {
        if (totalGenerated > 0) {
            return (double) compliantGenerated / totalGenerated;
        }
        return 0.0;
    }
    
    /**
     * 是否健康
     * @return 是否健康
     */
    public boolean isHealthy() {
        return successRate >= 0.999 && failureRate <= 0.001 && 
               encryptionRate >= 0.999 && securityRate >= 0.999 && 
               riskRate >= 0.999 && complianceRate >= 0.999;
    }
}

/**
 * 支付生成器状态类
 * @author Java实战
 */
@Data
public class PaymentGeneratorStatus {
    
    /**
     * 生成器类型
     */
    private String generatorType;
    
    /**
     * 总生成数
     */
    private long totalGenerated;
    
    /**
     * 成功生成数
     */
    private long successGenerated;
    
    /**
     * 失败生成数
     */
    private long failureGenerated;
    
    /**
     * 加密生成数
     */
    private long encryptedGenerated;
    
    /**
     * 安全生成数
     */
    private long securedGenerated;
    
    /**
     * 风控生成数
     */
    private long riskCheckedGenerated;
    
    /**
     * 合规生成数
     */
    private long compliantGenerated;
    
    /**
     * 平均生成时间（毫秒）
     */
    private double averageGenerateTime;
    
    /**
     * 最后生成时间
     */
    private LocalDateTime lastGenerateTime;
    
    /**
     * 生成器状态
     */
    private String status;
    
    public PaymentGeneratorStatus() {
        this.status = "ACTIVE";
    }
    
    public PaymentGeneratorStatus(String generatorType) {
        this();
        this.generatorType = generatorType;
    }
    
    /**
     * 计算成功率
     * @return 成功率
     */
    public double calculateSuccessRate() {
        if (totalGenerated > 0) {
            return (double) successGenerated / totalGenerated;
        }
        return 0.0;
    }
    
    /**
     * 计算加密率
     * @return 加密率
     */
    public double calculateEncryptionRate() {
        if (totalGenerated > 0) {
            return (double) encryptedGenerated / totalGenerated;
        }
        return 0.0;
    }
    
    /**
     * 计算安全率
     * @return 安全率
     */
    public double calculateSecurityRate() {
        if (totalGenerated > 0) {
            return (double) securedGenerated / totalGenerated;
        }
        return 0.0;
    }
    
    /**
     * 计算风控率
     * @return 风控率
     */
    public double calculateRiskRate() {
        if (totalGenerated > 0) {
            return (double) riskCheckedGenerated / totalGenerated;
        }
        return 0.0;
    }
    
    /**
     * 计算合规率
     * @return 合规率
     */
    public double calculateComplianceRate() {
        if (totalGenerated > 0) {
            return (double) compliantGenerated / totalGenerated;
        }
        return 0.0;
    }
    
    /**
     * 是否健康
     * @return 是否健康
     */
    public boolean isHealthy() {
        return calculateSuccessRate() >= 0.999 && 
               calculateEncryptionRate() >= 0.999 && 
               calculateSecurityRate() >= 0.999 && 
               calculateRiskRate() >= 0.999 && 
               calculateComplianceRate() >= 0.999;
    }
}