第170集金融分布式IDJava实战

/**
 * 金融分布式ID配置类
 * @author Java实战
 */
@Configuration
@EnableConfigurationProperties(FinancialDistributedIdProperties.class)
public class FinancialDistributedIdConfig {
    
    @Autowired
    private FinancialDistributedIdProperties properties;
    
    /**
     * 金融雪花算法ID生成器
     * @return 金融雪花算法ID生成器
     */
    @Bean
    public FinancialSnowflakeIdGenerator financialSnowflakeIdGenerator() {
        return new FinancialSnowflakeIdGenerator(
            properties.getSnowflake().getWorkerId(),
            properties.getSnowflake().getDatacenterId(),
            properties.getSnowflake().getFinancialId()
        );
    }
    
    /**
     * 金融UUID生成器
     * @return 金融UUID生成器
     */
    @Bean
    public FinancialUuidGenerator financialUuidGenerator() {
        return new FinancialUuidGenerator();
    }
    
    /**
     * 金融数据库自增ID生成器
     * @return 金融数据库自增ID生成器
     */
    @Bean
    public FinancialDatabaseIdGenerator financialDatabaseIdGenerator() {
        return new FinancialDatabaseIdGenerator();
    }
    
    /**
     * 金融Redis ID生成器
     * @return 金融Redis ID生成器
     */
    @Bean
    public FinancialRedisIdGenerator financialRedisIdGenerator() {
        return new FinancialRedisIdGenerator();
    }
    
    /**
     * 金融Zookeeper ID生成器
     * @return 金融Zookeeper ID生成器
     */
    @Bean
    public FinancialZookeeperIdGenerator financialZookeeperIdGenerator() {
        return new FinancialZookeeperIdGenerator();
    }
    
    /**
     * 金融分布式ID服务
     * @return 金融分布式ID服务
     */
    @Bean
    public FinancialDistributedIdService financialDistributedIdService() {
        return new FinancialDistributedIdService();
    }
    
    /**
     * 金融分布式ID监控服务
     * @return 金融分布式ID监控服务
     */
    @Bean
    public FinancialDistributedIdMonitorService financialDistributedIdMonitorService() {
        return new FinancialDistributedIdMonitorService();
    }
    
    /**
     * 金融分布式ID审计服务
     * @return 金融分布式ID审计服务
     */
    @Bean
    public FinancialDistributedIdAuditService financialDistributedIdAuditService() {
        return new FinancialDistributedIdAuditService();
    }
    
    /**
     * 金融分布式ID风控服务
     * @return 金融分布式ID风控服务
     */
    @Bean
    public FinancialDistributedIdRiskService financialDistributedIdRiskService() {
        return new FinancialDistributedIdRiskService();
    }
    
    private static final Logger logger = LoggerFactory.getLogger(FinancialDistributedIdConfig.class);
}

/**
 * 金融分布式ID属性配置
 * @author Java实战
 */
@Data
@ConfigurationProperties(prefix = "financial-distributed-id")
public class FinancialDistributedIdProperties {
    
    /**
     * 是否启用金融分布式ID
     */
    private boolean enableFinancialDistributedId = true;
    
    /**
     * 默认ID生成器类型
     */
    private String defaultGeneratorType = "FINANCIAL_SNOWFLAKE";
    
    /**
     * 金融雪花算法配置
     */
    private FinancialSnowflakeConfig snowflake = new FinancialSnowflakeConfig();
    
    /**
     * 金融UUID配置
     */
    private FinancialUuidConfig uuid = new FinancialUuidConfig();
    
    /**
     * 金融数据库自增配置
     */
    private FinancialDatabaseConfig database = new FinancialDatabaseConfig();
    
    /**
     * 金融Redis配置
     */
    private FinancialRedisConfig redis = new FinancialRedisConfig();
    
    /**
     * 金融Zookeeper配置
     */
    private FinancialZookeeperConfig zookeeper = new FinancialZookeeperConfig();
    
    /**
     * 审计配置
     */
    private AuditConfig audit = new AuditConfig();
    
    /**
     * 风控配置
     */
    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 FinancialSnowflakeConfig {
        /**
         * 工作机器ID
         */
        private long workerId = 1L;
        
        /**
         * 数据中心ID
         */
        private long datacenterId = 1L;
        
        /**
         * 金融ID
         */
        private long financialId = 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 financialIdBits = 4L;
        
        /**
         * 时间戳位数
         */
        private long timestampBits = 40L;
        
        /**
         * 是否启用加密
         */
        private boolean enableEncryption = true;
        
        /**
         * 加密密钥
         */
        private String encryptionKey = "financial-distributed-id-key";
    }
    
    /**
     * 金融UUID配置类
     */
    @Data
    public static class FinancialUuidConfig {
        /**
         * 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 = "financial-uuid-key";
    }
    
    /**
     * 金融数据库自增配置类
     */
    @Data
    public static class FinancialDatabaseConfig {
        /**
         * 数据源名称
         */
        private String dataSourceName = "financial";
        
        /**
         * 是否启用金融数据库自增
         */
        private boolean enableDatabase = false;
        
        /**
         * 表名
         */
        private String tableName = "financial_id_generator";
        
        /**
         * 字段名
         */
        private String fieldName = "id";
        
        /**
         * 步长
         */
        private int step = 1;
        
        /**
         * 初始值
         */
        private long initialValue = 1L;
        
        /**
         * 是否启用加密
         */
        private boolean enableEncryption = true;
        
        /**
         * 加密密钥
         */
        private String encryptionKey = "financial-database-key";
    }
    
    /**
     * 金融Redis配置类
     */
    @Data
    public static class FinancialRedisConfig {
        /**
         * Redis键前缀
         */
        private String keyPrefix = "financial: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 = "financial-redis-key";
    }
    
    /**
     * 金融Zookeeper配置类
     */
    @Data
    public static class FinancialZookeeperConfig {
        /**
         * Zookeeper连接地址
         */
        private String connectString = "localhost:2181";
        
        /**
         * 是否启用金融Zookeeper
         */
        private boolean enableZookeeper = false;
        
        /**
         * 会话超时时间（毫秒）
         */
        private int sessionTimeout = 30000;
        
        /**
         * 连接超时时间（毫秒）
         */
        private int connectionTimeout = 10000;
        
        /**
         * 根路径
         */
        private String rootPath = "/financial-distributed-id";
        
        /**
         * 是否启用加密
         */
        private boolean enableEncryption = true;
        
        /**
         * 加密密钥
         */
        private String encryptionKey = "financial-zookeeper-key";
    }
    
    /**
     * 审计配置类
     */
    @Data
    public static class AuditConfig {
        /**
         * 是否启用审计
         */
        private boolean enableAudit = true;
        
        /**
         * 审计日志级别
         */
        private String auditLevel = "INFO";
        
        /**
         * 审计保留天数
         */
        private int retentionDays = 2555; // 7年
        
        /**
         * 是否启用实时审计
         */
        private boolean enableRealTimeAudit = true;
        
        /**
         * 审计队列大小
         */
        private int auditQueueSize = 10000;
    }
    
    /**
     * 风控配置类
     */
    @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;
    }
    
    /**
     * 合规配置类
     */
    @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;
    }
}

/**
 * 金融分布式ID数据模型类
 * @author Java实战
 */
@Data
@Table(name = "financial_distributed_id_record")
public class FinancialDistributedIdData {
    
    /**
     * 主键ID
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;
    
    /**
     * 金融分布式ID
     */
    @Column(name = "financial_distributed_id", length = 64)
    private String financialDistributedId;
    
    /**
     * 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 = "financial_business_type", length = 32)
    private String financialBusinessType;
    
    /**
     * 生成时间
     */
    @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 = "audit_status", length = 20)
    private String auditStatus;
    
    /**
     * 风控状态
     */
    @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 = "audit_info", columnDefinition = "TEXT")
    private String auditInfo;
    
    /**
     * 风控信息（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 FinancialDistributedIdData() {
        this.status = "ACTIVE";
        this.encryptionStatus = "ENCRYPTED";
        this.auditStatus = "PENDING";
        this.riskStatus = "PENDING";
        this.complianceStatus = "PENDING";
        this.generateTime = LocalDateTime.now();
    }
    
    public FinancialDistributedIdData(String financialDistributedId, String idType, String generatorType) {
        this();
        this.financialDistributedId = financialDistributedId;
        this.idType = idType;
        this.generatorType = generatorType;
    }
    
    /**
     * 验证金融分布式ID数据
     * @return 是否有效
     */
    public boolean validate() {
        if (financialDistributedId == null || financialDistributedId.isEmpty()) {
            return false;
        }
        
        if (idType == null || idType.isEmpty()) {
            return false;
        }
        
        if (generatorType == null || generatorType.isEmpty()) {
            return false;
        }
        
        if (financialBusinessType == null || financialBusinessType.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 isAudited() {
        return "AUDITED".equals(this.auditStatus);
    }
    
    /**
     * 是否已风控
     * @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 auditInfo 审计信息
     */
    public void setAuditInfo(Map<String, Object> auditInfo) {
        this.auditInfo = JSON.toJSONString(auditInfo);
    }
    
    /**
     * 获取审计信息
     * @return 审计信息
     */
    public Map<String, Object> getAuditInfo() {
        if (auditInfo == null || auditInfo.isEmpty()) {
            return new HashMap<>();
        }
        try {
            return JSON.parseObject(auditInfo, 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 FinancialDistributedIdResult {
    
    /**
     * 是否成功
     */
    private boolean success;
    
    /**
     * 生成的ID
     */
    private String id;
    
    /**
     * ID类型
     */
    private String idType;
    
    /**
     * 生成器类型
     */
    private String generatorType;
    
    /**
     * 业务类型
     */
    private String businessType;
    
    /**
     * 金融业务类型
     */
    private String financialBusinessType;
    
    /**
     * 生成时间
     */
    private LocalDateTime generateTime;
    
    /**
     * 错误信息
     */
    private String error;
    
    /**
     * 开始时间
     */
    private long startTime;
    
    /**
     * 结束时间
     */
    private long endTime;
    
    /**
     * 重试次数
     */
    private int retryCount;
    
    /**
     * 加密状态
     */
    private String encryptionStatus;
    
    /**
     * 审计状态
     */
    private String auditStatus;
    
    /**
     * 风控状态
     */
    private String riskStatus;
    
    /**
     * 合规状态
     */
    private String complianceStatus;
    
    /**
     * 扩展属性
     */
    private Map<String, Object> extendedProperties;
    
    /**
     * 审计信息
     */
    private Map<String, Object> auditInfo;
    
    /**
     * 风控信息
     */
    private Map<String, Object> riskInfo;
    
    /**
     * 合规信息
     */
    private Map<String, Object> complianceInfo;
    
    public FinancialDistributedIdResult() {
        this.success = false;
        this.retryCount = 0;
        this.extendedProperties = new HashMap<>();
        this.auditInfo = new HashMap<>();
        this.riskInfo = new HashMap<>();
        this.complianceInfo = new HashMap<>();
        this.encryptionStatus = "ENCRYPTED";
        this.auditStatus = "PENDING";
        this.riskStatus = "PENDING";
        this.complianceStatus = "PENDING";
    }
    
    public FinancialDistributedIdResult(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 isAudited() {
        return "AUDITED".equals(this.auditStatus);
    }
    
    /**
     * 是否已风控
     * @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 FinancialDistributedIdStatus {
    
    /**
     * 总生成数
     */
    private long totalGenerated;
    
    /**
     * 成功生成数
     */
    private long successGenerated;
    
    /**
     * 失败生成数
     */
    private long failureGenerated;
    
    /**
     * 重试生成数
     */
    private long retryGenerated;
    
    /**
     * 加密生成数
     */
    private long encryptedGenerated;
    
    /**
     * 审计生成数
     */
    private long auditedGenerated;
    
    /**
     * 风控生成数
     */
    private long riskCheckedGenerated;
    
    /**
     * 合规生成数
     */
    private long compliantGenerated;
    
    /**
     * 成功率
     */
    private double successRate;
    
    /**
     * 失败率
     */
    private double failureRate;
    
    /**
     * 重试率
     */
    private double retryRate;
    
    /**
     * 加密率
     */
    private double encryptionRate;
    
    /**
     * 审计率
     */
    private double auditRate;
    
    /**
     * 风控率
     */
    private double riskRate;
    
    /**
     * 合规率
     */
    private double complianceRate;
    
    /**
     * 平均生成时间（毫秒）
     */
    private double averageGenerateTime;
    
    /**
     * 最大生成时间（毫秒）
     */
    private long maxGenerateTime;
    
    /**
     * 最小生成时间（毫秒）
     */
    private long minGenerateTime;
    
    /**
     * 最后检查时间
     */
    private Long lastCheckTime;
    
    /**
     * 系统状态
     */
    private String systemStatus;
    
    /**
     * 各生成器状态
     */
    private Map<String, FinancialGeneratorStatus> generatorStatuses;
    
    public FinancialDistributedIdStatus() {
        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 calculateAuditRate() {
        if (totalGenerated > 0) {
            return (double) auditedGenerated / 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 && auditRate >= 0.999 && 
               riskRate >= 0.999 && complianceRate >= 0.999;
    }
}

/**
 * 金融生成器状态类
 * @author Java实战
 */
@Data
public class FinancialGeneratorStatus {
    
    /**
     * 生成器类型
     */
    private String generatorType;
    
    /**
     * 总生成数
     */
    private long totalGenerated;
    
    /**
     * 成功生成数
     */
    private long successGenerated;
    
    /**
     * 失败生成数
     */
    private long failureGenerated;
    
    /**
     * 加密生成数
     */
    private long encryptedGenerated;
    
    /**
     * 审计生成数
     */
    private long auditedGenerated;
    
    /**
     * 风控生成数
     */
    private long riskCheckedGenerated;
    
    /**
     * 合规生成数
     */
    private long compliantGenerated;
    
    /**
     * 平均生成时间（毫秒）
     */
    private double averageGenerateTime;
    
    /**
     * 最后生成时间
     */
    private LocalDateTime lastGenerateTime;
    
    /**
     * 生成器状态
     */
    private String status;
    
    public FinancialGeneratorStatus() {
        this.status = "ACTIVE";
    }
    
    public FinancialGeneratorStatus(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 calculateAuditRate() {
        if (totalGenerated > 0) {
            return (double) auditedGenerated / 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 && 
               calculateAuditRate() >= 0.999 && 
               calculateRiskRate() >= 0.999 && 
               calculateComplianceRate() >= 0.999;
    }
}