面试笔录 - 自我介绍与项目面试技巧

// 系统核心服务划分
@SpringBootApplication
public class ProcurementPlatform {
    // 1. 供应商主数据服务
    @Bean public SupplierService supplierService() {
        return new SupplierService(); // 供应商生命周期管理
    }
    
    // 2. 权限控制服务  
    @Bean public AuthorizationService authService() {
        return new AuthorizationService(); // 统一的RBAC权限模型
    }
    
    // 3. 模板引擎服务
    @Bean public TemplateEngineService templateService() {
        return new TemplateEngineService(); // 可配置的业务规则
    }
    
    // 4. 业务群组服务
    @Bean public BusinessGroupService groupService() {
        return new BusinessGroupService(); // 多租户数据隔离
    }
}

// 可配置的评估规则引擎核心实现
@Service
@Slf4j
public class SupplierEvaluationEngine {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private DataSourceRouter dataSourceRouter;
    
    /**
     * 执行供应商评估
     */
    @Transactional
    public EvaluationResult evaluateSupplier(Long supplierId, String templateCode) {
        long startTime = System.currentTimeMillis();
        
        try {
            // 1. 加载评估模板
            EvaluationTemplate template = loadEvaluationTemplate(templateCode);
            
            // 2. 并行获取评估数据
            Map<String, Object> evaluationData = fetchEvaluationDataParallel(supplierId, template);
            
            // 3. 执行评分计算
            ScoreResult scoreResult = calculateScores(template, evaluationData);
            
            // 4. 确定供应商等级
            SupplierLevel level = determineSupplierLevel(scoreResult.getTotalScore());
            
            // 5. 保存评估结果和快照
            return saveEvaluationResult(supplierId, template, scoreResult, level, evaluationData);
            
        } finally {
            log.info("供应商评估完成，supplierId: {}, 耗时: {}ms", 
                    supplierId, System.currentTimeMillis() - startTime);
        }
    }
    
    /**
     * 并行获取多维度评估数据
     */
    private Map<String, Object> fetchEvaluationDataParallel(Long supplierId, 
                                                           EvaluationTemplate template) {
        // 使用CompletableFuture并行调用多个数据源
        List<CompletableFuture<DataFetchResult>> futures = template.getDataSources()
            .stream()
            .map(dataSource -> CompletableFuture.supplyAsync(() -> 
                fetchSingleDataSource(supplierId, dataSource), dataFetchExecutor))
            .collect(Collectors.toList());
        
        // 等待所有数据获取完成（设置超时）
        try {
            CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
                .get(10, TimeUnit.SECONDS);
        } catch (TimeoutException e) {
            log.warn("数据获取超时，将使用已获取的数据继续评估");
            // 不抛出异常，使用已获取的数据继续评估
        } catch (Exception e) {
            throw new EvaluationException("数据获取失败", e);
        }
        
        // 聚合结果
        Map<String, Object> result = new HashMap<>();
        for (CompletableFuture<DataFetchResult> future : futures) {
            if (future.isDone() && !future.isCompletedExceptionally()) {
                try {
                    DataFetchResult dataResult = future.get();
                    result.put(dataResult.getDataSource(), dataResult.getData());
                } catch (Exception e) {
                    log.warn("单个数据源获取失败", e);
                }
            }
        }
        
        return result;
    }
}

@Service
public class MultiLevelCacheService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    // 本地缓存（Caffeine）
    private final Cache<String, Object> localCache = Caffeine.newBuilder()
        .maximumSize(1000)
        .expireAfterWrite(5, TimeUnit.MINUTES)
        .build();
    
    /**
     * 多级缓存查询
     */
    public <T> T getWithMultiLevelCache(String key, Class<T> type, 
                                      Supplier<T> loader, Duration expiry) {
        // 1. 查询本地缓存
        T value = (T) localCache.getIfPresent(key);
        if (value != null) {
            metricService.recordCacheHit("local");
            return value;
        }
        
        // 2. 查询Redis分布式缓存
        String redisKey = "procurement:" + key;
        value = (T) redisTemplate.opsForValue().get(redisKey);
        if (value != null) {
            // 回填本地缓存
            localCache.put(key, value);
            metricService.recordCacheHit("redis");
            return value;
        }
        
        // 3. 缓存未命中，从数据源加载
        value = loader.get();
        if (value != null) {
            // 异步写入缓存
            CompletableFuture.runAsync(() -> {
                // 写入Redis，设置过期时间
                redisTemplate.opsForValue().set(redisKey, value, expiry);
                // 写入本地缓存
                localCache.put(key, value);
            }, cacheExecutor);
        }
        
        metricService.recordCacheMiss();
        return value;
    }
    
    /**
     * 缓存一致性保障 - 发布缓存失效事件
     */
    @EventListener
    public void handleDataChangeEvent(DataChangedEvent event) {
        String cacheKey = buildCacheKey(event.getEntityType(), event.getEntityId());
        
        // 1. 删除本地缓存
        localCache.invalidate(cacheKey);
        
        // 2. 发布Redis消息，通知其他实例失效本地缓存
        redisTemplate.convertAndSend("cache.invalidation", cacheKey);
        
        // 3. 删除Redis缓存
        redisTemplate.delete("procurement:" + cacheKey);
    }
}

// 基于Spring AOP的数据权限切面
@Aspect
@Component
public class DataPermissionAspect {
    
    @Around("@annotation(dataPermission)")
    public Object applyDataPermission(ProceedingJoinPoint joinPoint, 
                                    DataPermission dataPermission) throws Throwable {
        // 1. 获取当前用户权限上下文
        UserContext userContext = SecurityContextHolder.getUserContext();
        
        // 2. 解析数据权限规则
        DataPermissionRule rule = parsePermissionRule(dataPermission, userContext);
        
        // 3. 修改SQL查询条件
        modifyQueryForDataPermission(joinPoint, rule);
        
        // 4. 执行原方法
        return joinPoint.proceed();
    }
    
    private void modifyQueryForDataPermission(ProceedingJoinPoint joinPoint, 
                                            DataPermissionRule rule) {
        Object[] args = joinPoint.getArgs();
        
        for (int i = 0; i < args.length; i++) {
            if (args[i] instanceof DataQuery) {
                DataQuery query = (DataQuery) args[i];
                // 动态添加数据权限过滤条件
                query.addFilter(buildDataPermissionFilter(rule));
                break;
            }
        }
    }
}

// 数据权限规则配置
@Entity
@Table(name = "data_permission_rule")
public class DataPermissionRule {
    @Id
    private Long id;
    
    // 规则类型：用户级、部门级、业务群组级
    @Enumerated(EnumType.STRING)
    private RuleType ruleType;
    
    // 目标数据类型：供应商、报价单、合同等
    private String dataType;
    
    // 权限条件（SQL WHERE片段）
    private String permissionCondition;
    
    // JSON配置，支持复杂规则
    @Column(columnDefinition = "json")
    private String ruleConfig;
}

@Service
public class DataPermissionOptimizer {
    
    // 权限规则缓存
    private final LoadingCache<String, List<DataPermissionRule>> permissionCache = 
        Caffeine.newBuilder()
            .maximumSize(100)
            .refreshAfterWrite(10, TimeUnit.MINUTES)
            .build(this::loadPermissionRules);
    
    /**
     * 预编译数据权限过滤器，避免每次查询都解析规则
     */
    public DataFilter compileDataFilter(UserContext userContext, String dataType) {
        String cacheKey = buildCacheKey(userContext, dataType);
        
        return permissionCache.get(cacheKey).stream()
            .map(this::convertRuleToFilter)
            .reduce(DataFilter::and)
            .orElse(DataFilter.EMPTY);
    }
}

// 定时任务统一接口
public interface ScheduledTask {
    String getTaskName();
    String getCronExpression();
    void execute();
    default boolean isEnabled() { return true; }
}

// 定时任务执行器
@Service
public class UnifiedScheduler {
    
    @Autowired
    private List<ScheduledTask> scheduledTasks;
    
    @PostConstruct
    public void scheduleAllTasks() {
        scheduledTasks.stream()
            .filter(ScheduledTask::isEnabled)
            .forEach(this::scheduleTask);
    }
    
    private void scheduleTask(ScheduledTask task) {
        // 使用ScheduledExecutorService统一调度
        // 添加监控和异常处理
        scheduledExecutor.scheduleWithFixedDelay(() -> {
            try {
                metricService.recordTaskStart(task.getTaskName());
                task.execute();
                metricService.recordTaskSuccess(task.getTaskName());
            } catch (Exception e) {
                metricService.recordTaskFailure(task.getTaskName());
                log.error("定时任务执行失败: {}", task.getTaskName(), e);
            }
        }, 0, getDelaySeconds(task.getCronExpression()), TimeUnit.SECONDS);
    }
}

// 重构前 - 深层嵌套的if-else
public class OldEvaluationService {
    public ScoreResult evaluate(Supplier supplier, EvaluationContext context) {
        if (supplier.getCategory().equals("ELECTRONIC")) {
            if (context.isQualityCheckRequired()) {
                if (supplier.getQualityScore() > 8.0) {
                    if (supplier.getDeliveryPerformance() > 95.0) {
                        // ... 更多嵌套
                    }
                }
            }
        } else if (supplier.getCategory().equals("MECHANICAL")) {
            // 另一个复杂的条件分支
        }
        // ... 总共300多行深层嵌套
    }
}

// 重构后 - 使用函数式编程和策略模式
@Service
public class RefactoredEvaluationService {
    
    private final Map<String, EvaluationStrategy> strategies;
    
    public ScoreResult evaluate(Supplier supplier, EvaluationContext context) {
        return strategies.get(supplier.getCategory())
            .evaluate(supplier, context);
    }
}

// 策略接口
public interface EvaluationStrategy {
    ScoreResult evaluate(Supplier supplier, EvaluationContext context);
}

// 具体策略实现
@Component
public class ElectronicSupplierStrategy implements EvaluationStrategy {
    
    private final List<EvaluationRule<Supplier>> rules = Arrays.asList(
        this::checkQualityRequirement,
        this::checkDeliveryPerformance,
        this::checkTechnicalCapability
    );
    
    @Override
    public ScoreResult evaluate(Supplier supplier, EvaluationContext context) {
        return rules.stream()
            .map(rule -> rule.apply(supplier, context))
            .reduce(ScoreResult::combine)
            .orElse(ScoreResult.EMPTY);
    }
    
    private ScoreResult checkQualityRequirement(Supplier supplier, EvaluationContext context) {
        return context.isQualityCheckRequired() && supplier.getQualityScore() > 8.0 ?
            ScoreResult.passing("质量达标") : ScoreResult.failing("质量不达标");
    }
}

// 基于消息队列的最终一致性实现
@Service
@Transactional
public class EventuallyConsistentService {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    /**
     * 创建供应商（核心事务+事件发布）
     */
    public Supplier createSupplier(CreateSupplierRequest request) {
        // 1. 核心数据写入（强一致性）
        Supplier supplier = supplierRepository.save(convertToEntity(request));
        
        // 2. 发布领域事件
        SupplierCreatedEvent event = new SupplierCreatedEvent(supplier.getId());
        rabbitTemplate.convertAndSend("supplier.exchange", "supplier.created", event);
        
        // 3. 记录本地事件表（防消息丢失）
        eventRepository.save(new DomainEvent(event));
        
        return supplier;
    }
    
    /**
     * 事件处理 - 更新相关系统的数据
     */
    @RabbitListener(queues = "supplier.created.queue")
    public void handleSupplierCreated(SupplierCreatedEvent event) {
        try {
            // 更新搜索索引
            searchService.indexSupplier(event.getSupplierId());
            
            // 通知风控系统
            riskControlService.onNewSupplier(event.getSupplierId());
            
            // 标记事件已处理
            eventRepository.markAsProcessed(event.getEventId());
            
        } catch (Exception e) {
            // 记录失败，进入重试机制
            log.error("处理供应商创建事件失败", e);
            throw new AmqpRejectAndDontRequeueException(e);
        }
    }
}

// 基于Sentinel的服务保护
@Service
public class ProtectedSupplierService {
    
    @SentinelResource(
        value = "supplierQuery",
        fallback = "getSupplierFallback",
        blockHandler = "handleFlowControl"
    )
    public Supplier getSupplier(Long supplierId) {
        // 正常业务逻辑
        return supplierRepository.findById(supplierId)
            .orElseThrow(() -> new SupplierNotFoundException(supplierId));
    }
    
    // 降级逻辑
    public Supplier getSupplierFallback(Long supplierId, Throwable ex) {
        log.warn("供应商查询降级，supplierId: {}", supplierId, ex);
        
        // 返回降级数据
        Supplier fallback = new Supplier();
        fallback.setId(supplierId);
        fallback.setName("供应商信息暂不可用");
        fallback.setStatus(SupplierStatus.UNKNOWN);
        
        return fallback;
    }
    
    // 流控处理
    public Supplier handleFlowControl(Long supplierId, BlockException ex) {
        throw new ServiceBusyException("系统繁忙，请稍后重试");
    }
}

// 1. 多级缓存架构实现
@Service
public class ProcurementCacheService {
    
    // 一级缓存：本地缓存（Caffeine），5分钟过期
    private final Cache<String, Object> localCache = Caffeine.newBuilder()
        .maximumSize(10_000)
        .expireAfterWrite(5, TimeUnit.MINUTES)
        .recordStats() // 记录缓存命中率
        .build();
    
    // 二级缓存：Redis集群
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    /**
     * 带降级的多级缓存查询
     */
    public <T> T getWithGracefulDegradation(String key, Supplier<T> loader, 
                                          Class<T> type, Duration expiry) {
        // 第1步：本地缓存（最快，<1ms）
        T value = (T) localCache.getIfPresent(key);
        if (value != null) {
            metrics.recordCacheHit("local");
            return value;
        }
        
        // 第2步：分布式锁防止缓存击穿
        String lockKey = "lock:cache:" + key;
        RLock lock = redissonClient.getLock(lockKey);
        
        try {
            // 尝试获取锁，等待100ms，锁持有300ms
            if (lock.tryLock(100, 300, TimeUnit.MILLISECONDS)) {
                // 第3步：Redis缓存（<5ms）
                value = (T) redisTemplate.opsForValue().get(buildRedisKey(key));
                if (value != null) {
                    // 回填本地缓存
                    localCache.put(key, value);
                    metrics.recordCacheHit("redis");
                    return value;
                }
                
                // 第4步：数据库查询（最慢，20-100ms）
                try {
                    value = loader.get();
                    if (value != null) {
                        // 异步双写缓存（不阻塞主流程）
                        CompletableFuture.runAsync(() -> {
                            redisTemplate.opsForValue().set(
                                buildRedisKey(key), 
                                value, 
                                expiry
                            );
                            localCache.put(key, value);
                        }, cacheWriteExecutor);
                    }
                    return value;
                } catch (Exception e) {
                    // 第5步：降级方案 - 返回过期的缓存数据
                    T staleValue = getStaleDataFromBackup(key);
                    metrics.recordCacheDegradation();
                    return staleValue;
                }
            } else {
                // 获取锁失败，直接返回降级数据
                return getStaleDataFromBackup(key);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return getStaleDataFromBackup(key);
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
    
    /**
     * 缓存预热机制（应对早高峰）
     */
    @Scheduled(cron = "0 30 6 * * ?") // 每天6:30执行
    public void preheatCache() {
        // 预热高频查询数据
        List<String> hotKeys = identifyHotKeys();
        hotKeys.parallelStream().forEach(key -> {
            // 异步预热
            CompletableFuture.runAsync(() -> {
                Object data = loadDataFromDB(key);
                if (data != null) {
                    redisTemplate.opsForValue().set(buildRedisKey(key), data, 2, TimeUnit.HOURS);
                }
            }, preheatExecutor);
        });
    }
}

// 1. 连接池优化（HikariCP配置）
@Bean
public DataSource dataSource() {
    HikariConfig config = new HikariConfig();
    config.setJdbcUrl(jdbcUrl);
    config.setUsername(username);
    config.setPassword(password);
    config.setMaximumPoolSize(50);          // 根据CPU核心数调整
    config.setMinimumIdle(10);
    config.setConnectionTimeout(30000);     // 30秒超时
    config.setIdleTimeout(600000);          // 10分钟
    config.setMaxLifetime(1800000);         // 30分钟
    config.setConnectionTestQuery("SELECT 1");
    config.setPoolName("ProcurementPool");
    
    // 监控连接池状态
    config.addDataSourceProperty("metrics", "true");
    config.addDataSourceProperty("metricRegistry", metricRegistry);
    
    return new HikariDataSource(config);
}

// 2. 线程池隔离（不同业务使用不同线程池）
@Configuration
public class ThreadPoolConfiguration {
    
    // 核心业务线程池（快速响应）
    @Bean("coreBusinessExecutor")
    public ThreadPoolTaskExecutor coreBusinessExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(20);
        executor.setMaxPoolSize(50);
        executor.setQueueCapacity(1000);
        executor.setThreadNamePrefix("core-business-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }
    
    // 批量处理线程池（允许堆积）
    @Bean("batchProcessingExecutor")
    public ThreadPoolTaskExecutor batchProcessingExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(5000);  // 大队列，允许任务堆积
        executor.setThreadNamePrefix("batch-process-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
        return executor;
    }
}

// 3. 异步化处理
@Service
public class AsyncAssessmentService {
    
    @Autowired
    private ThreadPoolTaskExecutor batchProcessingExecutor;
    
    /**
     * 异步批量评估（应对评估高峰期）
     */
    @Async("batchProcessingExecutor")
    public CompletableFuture<BatchResult> asyncBatchAssessment(List<Long> supplierIds) {
        // 使用分治策略：每100个供应商一批
        List<List<Long>> batches = Lists.partition(supplierIds, 100);
        
        List<CompletableFuture<AssessmentResult>> futures = batches.stream()
            .map(batch -> CompletableFuture.supplyAsync(() -> 
                processBatchAssessment(batch), batchProcessingExecutor))
            .collect(Collectors.toList());
        
        // 等待所有批次完成，但设置超时
        return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
            .orTimeout(5, TimeUnit.MINUTES)  // 5分钟超时
            .thenApply(v -> aggregateResults(futures));
    }
}

// 1. 熔断降级（Sentinel配置）
@Service
public class SupplierServiceWithCircuitBreaker {
    
    @SentinelResource(
        value = "supplierQueryResource",
        fallback = "querySupplierFallback",
        blockHandler = "handleFlowControl",
        exceptionsToIgnore = {IllegalArgumentException.class}
    )
    public Supplier getSupplierWithProtection(Long supplierId) {
        // 正常业务逻辑
        return supplierRepository.findById(supplierId)
            .orElseThrow(() -> new SupplierNotFoundException(supplierId));
    }
    
    // 降级方法：返回简化数据
    public Supplier querySupplierFallback(Long supplierId, Throwable ex) {
        log.warn("供应商查询降级，返回简化数据，supplierId: {}", supplierId);
        
        Supplier simplified = new Supplier();
        simplified.setId(supplierId);
        simplified.setName("供应商信息加载中...");
        simplified.setStatus(SupplierStatus.UNKNOWN);
        
        // 记录降级事件，用于后续补偿
        degradeEventRepository.save(new DegradeEvent("supplier_query", supplierId));
        
        return simplified;
    }
    
    // 流控处理
    public Supplier handleFlowControl(Long supplierId, BlockException ex) {
        throw new ServiceDegradeException("系统繁忙，请稍后重试");
    }
}

// 2. 限流策略
@Component
public class RateLimitConfiguration {
    
    @Bean
    public RateLimiter supplierQueryRateLimiter() {
        // 令牌桶算法：每秒100个令牌，桶容量200
        return RateLimiter.create(100.0, 200, TimeUnit.MILLISECONDS);
    }
    
    @Before("execution(* com..SupplierService.*(..))")
    public void checkRateLimit(JoinPoint joinPoint) {
        if (!supplierQueryRateLimiter.tryAcquire()) {
            throw new RateLimitExceededException("请求过于频繁，请稍后重试");
        }
    }
}

// 按业务域垂直分库
public enum DatabaseShard {
    // 核心业务库 - 高频读写，需要强一致性
    CORE_BUSINESS("core_db", Arrays.asList(
        "supplier_main",           // 供应商主数据
        "supplier_category",       // 供应商分类
        "white_list"              // 白名单
    )),
    
    // 权限配置库 - 超高频率读，变更较少
    AUTHORIZATION("auth_db", Arrays.asList(
        "user_permission",         // 用户权限
        "role_definition",         // 角色定义
        "data_scope_rule"          // 数据范围规则
    )),
    
    // 模板引擎库 - 读多写少，配置型数据
    TEMPLATE("template_db", Arrays.asList(
        "assessment_template",     // 评估模板
        "scoring_rule",           // 打分规则
        "workflow_definition"     // 工作流定义
    )),
    
    // 日志操作库 - 写密集型，允许异步
    OPERATION_LOG("log_db", Arrays.asList(
        "operation_log",           // 操作日志
        "audit_trail",            // 审计追踪
        "system_event"            // 系统事件
    )),
    
    // 统计分析库 - 复杂查询，允许延迟
    ANALYTICS("analytics_db", Arrays.asList(
        "supplier_statistics",     // 供应商统计
        "performance_metric",      // 绩效指标
        "trend_analysis"          // 趋势分析
    ));
    
    private final String dbName;
    private final List<String> tables;
}

// 基于复合维度的分表策略
public class SupplierShardingStrategy {
    
    /**
     * 分表键设计：复合分片键 (业务群组 + 供应商类型 + 时间)
     */
    public String determineTableName(Supplier supplier) {
        // 维度1：业务群组（天然的业务隔离边界）
        String businessGroup = supplier.getBusinessGroupCode();
        
        // 维度2：供应商类型（不同类型访问模式不同）
        SupplierType type = supplier.getType();
        
        // 维度3：创建时间（时间序列，便于归档）
        LocalDateTime createTime = supplier.getCreateTime();
        
        // 分表逻辑
        if (isLargeEnterprise(supplier)) {
            // 大企业供应商：单独分表（数据量大，访问频繁）
            return "supplier_large_enterprise";
        }
        
        // 普通供应商：按业务群组分片
        int shardIndex = Math.abs(businessGroup.hashCode()) % 16;
        
        // 按时间分表（每月一张）
        String timeSuffix = createTime.format(DateTimeFormatter.ofPattern("yyyyMM"));
        
        return String.format("supplier_%s_%02d_%s", 
                            type.getCode().toLowerCase(),
                            shardIndex,
                            timeSuffix);
    }
    
    /**
     * 大供应商判断标准（基于业务规则）
     */
    private boolean isLargeEnterprise(Supplier supplier) {
        return supplier.getAnnualProcurementAmount() > 100_000_000 ||  // 年采购额>1亿
               supplier.getEmployeeCount() > 1000 ||                   // 员工数>1000
               supplier.isStrategicPartner();                         // 战略合作伙伴
    }
}

/**
 * 基于业务场景的读写路由决策器
 */
@Component
public class ReadWriteRouter {
    
    // 配置：哪些场景强制读主库
    @Value("${database.force-master-patterns}")
    private List<String> forceMasterPatterns;
    
    // 配置：哪些场景允许读从库
    @Value("${database.allow-slave-patterns}")  
    private List<String> allowSlavePatterns;
    
    /**
     * 路由决策逻辑
     */
    public DataSource determineDataSource(RoutingContext context) {
        // 规则1：写操作强制走主库
        if (context.isWriteOperation()) {
            metrics.recordRouteDecision("write_to_master");
            return dataSourceManager.getMaster();
        }
        
        // 规则2：事务中的读操作走主库（避免不可重复读）
        if (context.isInTransaction()) {
            metrics.recordRouteDecision("transaction_to_master");
            return dataSourceManager.getMaster();
        }
        
        // 规则3：刚写入后的读取走主库（解决主从延迟）
        if (isFreshWrite(context)) {
            metrics.recordRouteDecision("fresh_read_to_master");
            return dataSourceManager.getMaster();
        }
        
        // 规则4：关键业务数据走主库
        if (isCriticalBusinessData(context)) {
            metrics.recordRouteDecision("critical_to_master");
            return dataSourceManager.getMaster();
        }
        
        // 规则5：复杂查询走专门的分析从库
        if (isComplexAnalyticsQuery(context)) {
            metrics.recordRouteDecision("analytics_to_slave");
            return dataSourceManager.getAnalyticsSlave();
        }
        
        // 规则6：默认按负载均衡选择从库
        metrics.recordRouteDecision("load_balance_to_slave");
        return dataSourceManager.getLoadBalancedSlave();
    }
    
    /**
     * 判断是否为"刚写入"的读取
     */
    private boolean isFreshWrite(RoutingContext context) {
        String cacheKey = "recent_write:" + context.getUserId();
        Long lastWriteTime = (Long) redisTemplate.opsForValue().get(cacheKey);
        
        if (lastWriteTime == null) {
            return false;
        }
        
        // 如果最近30秒内有写入，则认为是新鲜读取
        return System.currentTimeMillis() - lastWriteTime < 30_000;
    }
}

/**
 * 分片热点检测与自动平衡
 */
@Component
@Slf4j
public class ShardHotspotMonitor {
    
    @Autowired
    private MetricRegistry metricRegistry;
    
    @Scheduled(fixedDelay = 60000)  // 每分钟检查一次
    public void monitorShardDistribution() {
        Map<String, ShardMetrics> shardMetrics = collectShardMetrics();
        
        shardMetrics.forEach((shardName, metrics) -> {
            // 检测热点分片
            if (isHotShard(metrics)) {
                log.warn("检测到热点分片: {}，QPS: {}，数据量: {}，连接数: {}",
                         shardName,
                         metrics.getQps(),
                         metrics.getDataSize(),
                         metrics.getConnectionCount());
                
                // 自动触发分片分裂
                if (shouldSplitShard(metrics)) {
                    splitShard(shardName);
                }
            }
            
            // 检测冷分片
            if (isColdShard(metrics)) {
                log.info("检测到冷分片: {}，考虑合并", shardName);
                scheduleShardMerge(shardName);
            }
        });
    }
    
    private boolean isHotShard(ShardMetrics metrics) {
        // 热点判断标准
        return metrics.getQps() > 1000 ||          // QPS > 1000
               metrics.getDataSize() > 50_000_000 || // 数据量 > 5000万行
               metrics.getConnectionCount() > 100;   // 连接数 > 100
    }
    
    private boolean shouldSplitShard(ShardMetrics metrics) {
        // 分片分裂条件
        return metrics.getQps() > 5000 ||          // QPS > 5000
               metrics.getDataSize() > 100_000_000 || // 数据量 > 1亿行
               metrics.getGrowthRate() > 0.3;       // 周增长率 > 30%
    }
}

// 传统硬编码评估逻辑（问题示例）
public class LegacyEvaluationService {
    
    public EvaluationResult evaluateSupplier(Supplier supplier) {
        double totalScore = 0.0;
        
        // 问题1：业务逻辑硬编码在代码中
        if ("ELECTRONIC".equals(supplier.getCategory())) {
            // 电子类供应商评分逻辑
            if (supplier.getQualityScore() > 95) {
                totalScore += 40;
            } else if (supplier.getQualityScore() > 90) {
                totalScore += 30;
            }
            // ... 更多硬编码逻辑
        } else if ("MECHANICAL".equals(supplier.getCategory())) {
            // 机械类供应商评分逻辑（完全不同）
            totalScore = supplier.getDeliveryPerformance() * 0.6 
                       + supplier.getPriceCompetitiveness() * 0.4;
        }
        // ... 还有几十个品类，每个都有一套独立逻辑
        
        // 问题2：变更需要发版上线
        // 问题3：新品类接入需要开发介入
        // 问题4：逻辑复杂，难以测试和维护
    }
}

// 规则引擎核心实体类
@Entity
@Table(name = "evaluation_rule")
@Data
public class EvaluationRule {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "rule_code", unique = true, nullable = false)
    private String ruleCode;  // 规则编码，如：QUALITY_SCORING_V1
    
    @Column(name = "rule_name")
    private String ruleName;  // 规则名称，如：质量表现评分规则
    
    @Enumerated(EnumType.STRING)
    private RuleType ruleType; // RULE_TYPE: BASIC, COMPOSITE, CONDITIONAL
    
    @Column(name = "applicable_categories")
    private String applicableCategories; // JSON数组：["ELECTRONIC", "MECHANICAL"]
    
    @Column(name = "effective_time")
    private LocalDateTime effectiveTime; // 生效时间
    
    @Column(name = "expire_time")
    private LocalDateTime expireTime;   // 过期时间
    
    @Column(name = "version")
    private Integer version;            // 版本号
    
    @Column(name = "status")
    @Enumerated(EnumType.STRING)
    private RuleStatus status;          // DRAFT, APPROVED, ACTIVE, DEPRECATED
    
    // 规则定义（JSON格式）
    @Column(name = "rule_definition", columnDefinition = "json")
    private String ruleDefinition;      // 规则JSON配置
    
    @Column(name = "metadata", columnDefinition = "json")
    private String metadata;            // 元数据：创建人、修改历史等
}

// 规则执行上下文
@Data
public class RuleExecutionContext {
    private String ruleCode;                    // 执行的规则编码
    private Supplier targetSupplier;            // 目标供应商
    private Map<String, Object> inputData;      // 输入数据
    private Map<String, Object> intermediateResults; // 中间计算结果
    private EvaluationResult finalResult;       // 最终结果
    private List<RuleExecutionLog> executionLogs; // 执行日志
    private LocalDateTime executionTime;        // 执行时间
}

/**
 * 规则解析器 - 将JSON规则转换为可执行对象
 */
@Component
@Slf4j
public class RuleParser {
    
    @Autowired
    private ObjectMapper objectMapper;
    
    @Autowired
    private RuleTemplateRepository templateRepository;
    
    /**
     * 解析规则定义
     */
    public ExecutableRule parseRule(String ruleDefinitionJson) {
        try {
            // 1. 解析基础规则信息
            RuleDefinition definition = objectMapper.readValue(
                ruleDefinitionJson, 
                RuleDefinition.class
            );
            
            // 2. 验证规则完整性
            validateRuleDefinition(definition);
            
            // 3. 构建可执行规则
            ExecutableRule executableRule = new ExecutableRule();
            executableRule.setDefinition(definition);
            
            // 4. 解析数据源配置
            List<DataSourceConfig> dataSources = parseDataSources(definition.getDataSources());
            executableRule.setDataSources(dataSources);
            
            // 5. 解析评分规则
            List<ScoringRule> scoringRules = parseScoringRules(definition.getScoringRules());
            executableRule.setScoringRules(scoringRules);
            
            // 6. 解析等级判定规则
            LevelDeterminationRule levelRule = parseLevelDetermination(definition.getLevelDetermination());
            executableRule.setLevelDetermination(levelRule);
            
            // 7. 编译执行计划
            ExecutionPlan executionPlan = compileExecutionPlan(definition, scoringRules);
            executableRule.setExecutionPlan(executionPlan);
            
            // 8. 生成规则指纹（用于缓存和版本比对）
            String ruleFingerprint = generateRuleFingerprint(definition);
            executableRule.setFingerprint(ruleFingerprint);
            
            log.info("规则解析完成: {}, 版本: {}, 指纹: {}", 
                    definition.getRuleCode(), 
                    definition.getVersion(),
                    ruleFingerprint);
            
            return executableRule;
            
        } catch (JsonProcessingException e) {
            throw new RuleParseException("规则JSON解析失败", e);
        }
    }
    
    /**
     * 编译执行计划 - 优化规则执行顺序
     */
    private ExecutionPlan compileExecutionPlan(RuleDefinition definition, 
                                             List<ScoringRule> scoringRules) {
        ExecutionPlan plan = new ExecutionPlan();
        
        // 分析规则依赖关系
        Map<String, List<String>> dependencyGraph = buildDependencyGraph(scoringRules);
        
        // 拓扑排序，确定执行顺序
        List<String> executionOrder = topologicalSort(dependencyGraph);
        
        // 识别可并行执行的规则
        List<List<String>> parallelGroups = identifyParallelGroups(executionOrder, scoringRules);
        
        // 构建执行计划
        plan.setExecutionOrder(executionOrder);
        plan.setParallelGroups(parallelGroups);
        plan.setEstimatedComplexity(calculateComplexity(scoringRules));
        
        return plan;
    }
    
    /**
     * 构建规则依赖图
     */
    private Map<String, List<String>> buildDependencyGraph(List<ScoringRule> rules) {
        Map<String, List<String>> graph = new HashMap<>();
        
        for (ScoringRule rule : rules) {
            List<String> dependencies = new ArrayList<>();
            
            // 分析数据源依赖
            if (rule.getDataSource() != null) {
                dependencies.add("DS_" + rule.getDataSource());
            }
            
            // 分析规则间依赖（如：规则B需要规则A的结果）
            if (rule.getDependsOn() != null) {
                dependencies.addAll(rule.getDependsOn());
            }
            
            graph.put(rule.getRuleId(), dependencies);
        }
        
        return graph;
    }
}

/**
 * 规则执行引擎核心
 */
@Service
@Slf4j
public class RuleExecutionEngine {
    
    @Autowired
    private RuleRegistry ruleRegistry;
    
    @Autowired
    private DataSourceFetcher dataSourceFetcher;
    
    @Autowired
    private RuleStrategyFactory strategyFactory;
    
    @Autowired
    private ThreadPoolTaskExecutor ruleExecutionExecutor;
    
    @Autowired
    private CacheManager cacheManager;
    
    /**
     * 执行规则评估
     */
    @Transactional
    public EvaluationResult executeRule(String ruleCode, Long supplierId) {
        long startTime = System.currentTimeMillis();
        
        try {
            // 1. 构建执行上下文
            RuleExecutionContext context = buildExecutionContext(ruleCode, supplierId);
            
            // 2. 检查缓存
            EvaluationResult cachedResult = checkCache(context);
            if (cachedResult != null) {
                log.debug("规则执行命中缓存: {}", ruleCode);
                return cachedResult;
            }
            
            // 3. 获取可执行规则
            ExecutableRule rule = ruleRegistry.getRule(ruleCode);
            if (rule == null) {
                throw new RuleNotFoundException(ruleCode);
            }
            
            // 4. 准备数据源
            fetchDataSourceData(context, rule);
            
            // 5. 执行评分规则
            Map<String, ScoringResult> scoringResults = executeScoringRules(context, rule);
            
            // 6. 计算总分
            TotalScore totalScore = calculateTotalScore(scoringResults, rule);
            
            // 7. 判定等级
            SupplierLevel level = determineLevel(totalScore, rule);
            
            // 8. 构建最终结果
            EvaluationResult result = buildEvaluationResult(context, scoringResults, totalScore, level);
            
            // 9. 缓存结果
            cacheResult(context, result);
            
            // 10. 记录执行日志
            recordExecutionLog(context, result, System.currentTimeMillis() - startTime);
            
            return result;
            
        } catch (RuleExecutionException e) {
            log.error("规则执行失败: {}, supplierId: {}", ruleCode, supplierId, e);
            throw e;
        }
    }
    
    /**
     * 并行执行评分规则
     */
    private Map<String, ScoringResult> executeScoringRules(RuleExecutionContext context, 
                                                          ExecutableRule rule) {
        ExecutionPlan executionPlan = rule.getExecutionPlan();
        Map<String, ScoringResult> results = new ConcurrentHashMap<>();
        
        // 按执行计划分组执行
        for (List<String> parallelGroup : executionPlan.getParallelGroups()) {
            List<CompletableFuture<Void>> futures = parallelGroup.stream()
                .map(ruleId -> CompletableFuture.runAsync(() -> {
                    ScoringRule scoringRule = rule.getScoringRule(ruleId);
                    try {
                        ScoringResult result = executeSingleScoringRule(scoringRule, context);
                        results.put(ruleId, result);
                    } catch (Exception e) {
                        log.warn("评分规则执行失败: {}", ruleId, e);
                        results.put(ruleId, ScoringResult.error(ruleId, e.getMessage()));
                    }
                }, ruleExecutionExecutor))
                .collect(Collectors.toList());
            
            // 等待当前组的所有规则执行完成
            CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
        }
        
        return results;
    }
    
    /**
     * 执行单个评分规则
     */
    private ScoringResult executeSingleScoringRule(ScoringRule rule, 
                                                  RuleExecutionContext context) {
        // 根据规则类型选择不同的执行策略
        RuleCalculationStrategy strategy = strategyFactory.getStrategy(rule.getType());
        
        ScoringResult result = strategy.calculate(rule, context);
        
        // 记录执行详情
        result.setExecutionTime(LocalDateTime.now());
        result.setRuleVersion(rule.getVersion());
        
        return result;
    }
    
    /**
     * 计算总分
     */
    private TotalScore calculateTotalScore(Map<String, ScoringResult> scoringResults,
                                         ExecutableRule rule) {
        TotalScore totalScore = new TotalScore();
        double weightedSum = 0.0;
        double totalWeight = 0.0;
        
        for (ScoringRule scoringRule : rule.getScoringRules()) {
            ScoringResult result = scoringResults.get(scoringRule.getRuleId());
            
            if (result != null && result.isSuccess()) {
                double score = result.getScore();
                double weight = scoringRule.getWeight();
                
                weightedSum += score * weight;
                totalWeight += weight;
                
                totalScore.addComponentScore(scoringRule.getRuleId(), score, weight);
            }
        }
        
        // 计算加权平均分
        if (totalWeight > 0) {
            totalScore.setTotalScore(weightedSum / totalWeight);
        }
        
        totalScore.setMaxScore(10.0);  // 满分10分
        totalScore.setCalculationTime(LocalDateTime.now());
        
        return totalScore;
    }
}

/**
 * 规则计算策略工厂
 */
@Component
public class RuleStrategyFactory {
    
    private final Map<RuleType, RuleCalculationStrategy> strategyMap;
    
    @Autowired
    public RuleStrategyFactory(List<RuleCalculationStrategy> strategies) {
        strategyMap = new HashMap<>();
        
        // 注册所有策略
        for (RuleCalculationStrategy strategy : strategies) {
            strategyMap.put(strategy.getSupportedType(), strategy);
        }
    }
    
    /**
     * 获取对应的计算策略
     */
    public RuleCalculationStrategy getStrategy(RuleType ruleType) {
        RuleCalculationStrategy strategy = strategyMap.get(ruleType);
        if (strategy == null) {
            throw new UnsupportedRuleTypeException("不支持的规则类型: " + ruleType);
        }
        return strategy;
    }
}

/**
 * 规则计算策略接口
 */
public interface RuleCalculationStrategy {
    
    /**
     * 支持的规则类型
     */
    RuleType getSupportedType();
    
    /**
     * 执行计算
     */
    ScoringResult calculate(ScoringRule rule, RuleExecutionContext context);
}

/**
 * 阈值评分策略实现
 */
@Component
@Slf4j
public class ThresholdScoringStrategy implements RuleCalculationStrategy {
    
    @Override
    public RuleType getSupportedType() {
        return RuleType.THRESHOLD_SCORING;
    }
    
    @Override
    public ScoringResult calculate(ScoringRule rule, RuleExecutionContext context) {
        try {
            // 1. 获取数据值
            Object rawValue = extractFieldValue(rule, context);
            
            // 2. 数据验证
            validateValue(rawValue, rule.getValidation());
            
            // 3. 转换为数值
            double numericValue = convertToNumeric(rawValue, rule.getUnit());
            
            // 4. 应用阈值映射
            double score = applyThresholdMapping(numericValue, rule.getCalculation().getParameters());
            
            // 5. 构建结果
            return ScoringResult.success(rule.getRuleId())
                .score(score)
                .originalValue(numericValue)
                .calculationDetails(buildCalculationDetails(numericValue, score));
                
        } catch (ValidationException e) {
            return ScoringResult.failure(rule.getRuleId(), "数据验证失败: " + e.getMessage());
        } catch (Exception e) {
            log.error("阈值评分计算失败", e);
            return ScoringResult.error(rule.getRuleId(), "计算异常: " + e.getMessage());
        }
    }
    
    /**
     * 应用阈值映射
     */
    private double applyThresholdMapping(double value, Map<String, Object> parameters) {
        List<Threshold> thresholds = (List<Threshold>) parameters.get("thresholds");
        
        // 按阈值降序排序
        thresholds.sort(Comparator.comparing(Threshold::getMin).reversed());
        
        for (Threshold threshold : thresholds) {
            boolean meetsMin = threshold.getMin() == null || value >= threshold.getMin();
            boolean meetsMax = threshold.getMax() == null || value <= threshold.getMax();
            
            if (meetsMin && meetsMax) {
                return threshold.getScore();
            }
        }
        
        // 默认返回最低分
        return thresholds.get(thresholds.size() - 1).getScore();
    }
}

/**
 * 公式评分策略实现
 */
@Component
@Slf4j
public class FormulaScoringStrategy implements RuleCalculationStrategy {
    
    @Autowired
    private ExpressionParser expressionParser;
    
    @Override
    public RuleType getSupportedType() {
        return RuleType.FORMULA_SCORING;
    }
    
    @Override
    public ScoringResult calculate(ScoringRule rule, RuleExecutionContext context) {
        try {
            // 1. 解析公式
            String formula = rule.getCalculation().getFormula();
            Expression expression = expressionParser.parse(formula);
            
            // 2. 准备变量值
            Map<String, Double> variables = prepareVariables(rule, context);
            
            // 3. 执行计算
            double score = expression.evaluate(variables);
            
            // 4. 限制在合理范围内
            score = Math.max(0, Math.min(score, 10));
            
            // 5. 构建结果
            return ScoringResult.success(rule.getRuleId())
                .score(score)
                .calculationDetails(buildCalculationDetails(formula, variables, score));
                
        } catch (Exception e) {
            log.error("公式评分计算失败", e);
            return ScoringResult.error(rule.getRuleId(), "公式计算异常: " + e.getMessage());
        }
    }
    
    /**
     * 准备公式变量
     */
    private Map<String, Double> prepareVariables(ScoringRule rule, RuleExecutionContext context) {
        Map<String, Object> variableConfigs = rule.getCalculation().getVariables();
        Map<String, Double> variables = new HashMap<>();
        
        for (Map.Entry<String, Object> entry : variableConfigs.entrySet()) {
            Map<String, Object> varConfig = (Map<String, Object>) entry.getValue();
            
            // 获取字段值
            String fieldName = (String) varConfig.get("field");
            Object rawValue = context.getInputData().get(fieldName);
            
            // 转换并设置默认值
            Double value = rawValue != null ? convertToDouble(rawValue) 
                                           : (Double) varConfig.get("default");
            
            variables.put(entry.getKey(), value);
        }
        
        return variables;
    }
}