面试笔录

// 系统核心服务划分
@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%
    }
}

// 1. 分库分表策略（按业务维度）
public class QuotationShardingAlgorithm implements PreciseShardingAlgorithm<Long> {
    
    @Override
    public String doSharding(Collection<String> availableTargetNames,
                           PreciseShardingValue<Long> shardingValue) {
        Long quotationId = shardingValue.getValue();
        
        // 策略1：大客户单独分库（数据隔离）
        Long customerId = extractCustomerId(quotationId);
        if (isKeyAccount(customerId)) {
            return "ds_key_account"; // 大客户专属库
        }
        
        // 策略2：按时间分片（2023年、2024年不同库）
        LocalDateTime createTime = getCreateTime(quotationId);
        int year = createTime.getYear();
        if (year == 2024) {
            return "ds_" + (year % 2); // 2024年到ds_0
        } else if (year == 2023) {
            return "ds_" + (year % 2); // 2023年到ds_1
        }
        
        // 策略3：按车型项目分片
        String projectCode = getProjectCode(quotationId);
        int hash = Math.abs(projectCode.hashCode()) % 4;
        return "ds_project_" + hash;
    }
    
    // 获取大客户分片
    private boolean isKeyAccount(Long customerId) {
        // 从缓存中获取大客户列表
        String cacheKey = "key_accounts";
        Set<Long> keyAccounts = (Set<Long>) redisTemplate.opsForValue().get(cacheKey);
        return keyAccounts != null && keyAccounts.contains(customerId);
    }
}

// 1. 大数据量导入的分级处理策略
@Service
@Slf4j
public class BulkImportService {
    
    // 监控指标
    private final MeterRegistry meterRegistry;
    
    /**
     * 三级导入策略
     */
    public ImportResult intelligentImport(List<PartData> allData) {
        int totalSize = allData.size();
        
        // 根据数据量选择不同策略
        if (totalSize <= 10_000) {
            meterRegistry.counter("import.strategy", "level", "L1").increment();
            return level1Import(allData);          // 策略1：单事务批量插入
        } else if (totalSize <= 100_000) {
            meterRegistry.counter("import.strategy", "level", "L2").increment();
            return level2Import(allData);          // 策略2：分批事务处理
        } else {
            meterRegistry.counter("import.strategy", "level", "L3").increment();
            return level3Import(allData);          // 策略3：并行分片处理
        }
    }
    
    /**
     * 策略3：大规模数据并行导入（10万+）
     */
    private ImportResult level3Import(List<PartData> allData) {
        long startTime = System.currentTimeMillis();
        
        // 第1步：数据预处理（清洗、去重、分类）
        Map<String, List<PartData>> categorizedData = preprocessAndCategorize(allData);
        
        // 第2步：按类别并行处理（不同类别可完全并行）
        List<CompletableFuture<CategoryResult>> futures = categorizedData.entrySet()
            .stream()
            .map(entry -> CompletableFuture.supplyAsync(() -> 
                processSingleCategory(entry.getKey(), entry.getValue()), 
                importExecutor))
            .collect(Collectors.toList());
        
        // 第3步：收集结果（带超时控制）
        try {
            CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
                .get(5, TimeUnit.MINUTES); // 5分钟超时
            
            ImportResult result = aggregateResults(futures);
            long duration = System.currentTimeMillis() - startTime;
            
            log.info("大规模导入完成，数据量：{}，耗时：{}ms，TPS：{}/s", 
                     allData.size(), duration, allData.size() * 1000L / duration);
            
            // 记录性能指标
            meterRegistry.timer("import.duration", "strategy", "L3")
                .record(duration, TimeUnit.MILLISECONDS);
            
            return result;
            
        } catch (TimeoutException e) {
            // 超时处理：返回部分成功结果
            return handleTimeout(futures, allData.size());
        }
    }
    
    /**
     * 单类别处理（包含防OOM机制）
     */
    private CategoryResult processSingleCategory(String category, List<PartData> data) {
        // 限制单次处理内存使用
        MemoryLimitHelper.enforceMemoryLimit(500 * 1024 * 1024); // 500MB限制
        
        List<List<PartData>> batches = Lists.partition(data, 1000);
        
        CategoryResult categoryResult = new CategoryResult();
        
        for (List<PartData> batch : batches) {
            try {
                // 使用JDBC批量插入，手动控制事务
                CategoryResult batchResult = processBatchWithJdbc(category, batch);
                categoryResult.merge(batchResult);
                
                // 定期释放资源
                if (batchResult.getProcessedCount() % 5000 == 0) {
                    System.gc(); // 建议GC，防止内存碎片
                    clearTemporaryResources();
                }
                
            } catch (MemoryError e) {
                // 内存溢出保护：记录已处理数据，优雅退出
                log.error("内存溢出，中止处理类别：{}，已处理：{}条", 
                         category, categoryResult.getProcessedCount());
                return categoryResult;
            }
        }
        
        return categoryResult;
    }
}

// 1. 报价计算的异步化与结果缓存
@Service
public class QuotationCalculationService {
    
    @Autowired
    private RedisTemplate<String, CalculationResult> redisTemplate;
    
    /**
     * 带缓存的复杂报价计算
     */
    public CompletableFuture<CalculationResult> calculateQuotationAsync(QuotationRequest request) {
        // 生成缓存键（基于请求参数的哈希）
        String cacheKey = buildCacheKey(request);
        
        return CompletableFuture.supplyAsync(() -> {
            // 第1步：尝试从缓存获取
            CalculationResult cached = redisTemplate.opsForValue().get(cacheKey);
            if (cached != null && !cached.isExpired()) {
                meterRegistry.counter("calculation.cache.hit").increment();
                return cached;
            }
            
            // 第2步：缓存未命中，执行计算
            CalculationResult result = performComplexCalculation(request);
            
            // 第3步：异步写入缓存（TTL: 1小时）
            CompletableFuture.runAsync(() -> {
                redisTemplate.opsForValue().set(cacheKey, result, 1, TimeUnit.HOURS);
            }, cacheWriteExecutor);
            
            meterRegistry.counter("calculation.cache.miss").increment();
            return result;
            
        }, calculationExecutor);
    }
    
    /**
     * 复杂计算分解为可并行子任务
     */
    private CalculationResult performComplexCalculation(QuotationRequest request) {
        // 将计算分解为4个可并行部分
        CompletableFuture<MaterialCost> materialFuture = 
            CompletableFuture.supplyAsync(() -> calculateMaterialCost(request), calculationExecutor);
        
        CompletableFuture<LaborCost> laborFuture = 
            CompletableFuture.supplyAsync(() -> calculateLaborCost(request), calculationExecutor);
        
        CompletableFuture<TransportCost> transportFuture = 
            CompletableFuture.supplyAsync(() -> calculateTransportCost(request), calculationExecutor);
        
        CompletableFuture<RiskCost> riskFuture = 
            CompletableFuture.supplyAsync(() -> calculateRiskCost(request), calculationExecutor);
        
        // 并行执行，等待所有结果
        return CompletableFuture.allOf(materialFuture, laborFuture, transportFuture, riskFuture)
            .thenApply(v -> {
                try {
                    MaterialCost material = materialFuture.get();
                    LaborCost labor = laborFuture.get();
                    TransportCost transport = transportFuture.get();
                    RiskCost risk = riskFuture.get();
                    
                    // 合并计算结果
                    return CalculationResult.builder()
                        .materialCost(material)
                        .laborCost(labor)
                        .transportCost(transport)
                        .riskCost(risk)
                        .total(calculateTotal(material, labor, transport, risk))
                        .build();
                        
                } catch (Exception e) {
                    throw new CalculationException("报价计算失败", e);
                }
            })
            .join();
    }
}

// 1. 报价提交的异步队列处理
@Component
public class QuotationSubmissionService {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    /**
     * 报价提交 - 同步快速响应，异步处理
     */
    public SubmissionResponse submitQuotation(QuotationSubmission submission) {
        // 第1步：基础验证（同步，快速失败）
        validateSubmission(submission);
        
        // 第2步：生成唯一ID，快速响应
        String submissionId = generateSubmissionId();
        
        // 第3步：消息入队，异步处理
        QuotationMessage message = convertToMessage(submission, submissionId);
        
        // 使用确认回调确保消息不丢失
        rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
            if (ack) {
                log.info("报价消息已确认，ID: {}", submissionId);
            } else {
                log.error("报价消息发送失败，ID: {}, 原因: {}", submissionId, cause);
                // 记录到重试表
                retryService.recordFailedMessage(message);
            }
        });
        
        rabbitTemplate.convertAndSend("quotation.exchange", 
                                     "quotation.submit", 
                                     message,
                                     new CorrelationData(submissionId));
        
        // 第4步：立即返回（响应时间<100ms）
        return SubmissionResponse.builder()
            .submissionId(submissionId)
            .status(SubmissionStatus.PROCESSING)
            .message("报价已接收，正在处理")
            .estimatedCompletionTime(LocalDateTime.now().plusMinutes(5))
            .build();
    }
    
    /**
     * 消息消费者（处理实际业务）
     */
    @RabbitListener(queues = "quotation.process.queue", 
                   concurrency = "10-20") // 动态并发消费者
    public void processQuotationMessage(QuotationMessage message) {
        long startTime = System.currentTimeMillis();
        
        try {
            // 第1步：去重检查（幂等性）
            if (processedMessageCache.getIfPresent(message.getMessageId()) != null) {
                log.warn("重复消息，跳过处理: {}", message.getMessageId());
                return;
            }
            
            // 第2步：业务处理
            QuotationResult result = quotationProcessor.process(message);
            
            // 第3步：更新状态
            quotationStatusService.updateStatus(message.getSubmissionId(), 
                                               SubmissionStatus.COMPLETED, 
                                               result);
            
            // 第4步：记录已处理
            processedMessageCache.put(message.getMessageId(), true);
            
            long duration = System.currentTimeMillis() - startTime;
            log.info("报价处理完成，ID: {}，耗时: {}ms", 
                     message.getSubmissionId(), duration);
                     
        } catch (Exception e) {
            log.error("报价处理失败，ID: {}", message.getSubmissionId(), e);
            
            // 进入死信队列，人工处理
            throw new AmqpRejectAndDontRequeueException(e);
        }
    }
}

// 1. 应用性能监控
@Component
public class PerformanceMonitor {
    
    @Autowired
    private MeterRegistry meterRegistry;
    
    // 关键指标监控
    @EventListener
    public void monitorRequest(RequestHandledEvent event) {
        // 记录响应时间分布
        Timer.Sample sample = Timer.start();
        
        try {
            // 业务处理
            handleRequest(event);
            
        } finally {
            sample.stop(Timer.builder("http.request.duration")
                .tags("uri", event.getUri(), 
                      "method", event.getMethod(),
                      "status", event.getStatus())
                .register(meterRegistry));
        }
        
        // 记录QPS
        meterRegistry.counter("http.request.count",
            "uri", event.getUri(),
            "status", event.getStatus())
            .increment();
    }
    
    // JVM监控
    @Scheduled(fixedDelay = 60000)
    public void monitorJVM() {
        // 内存使用
        MemoryUsage heapUsage = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
        meterRegistry.gauge("jvm.memory.heap.used", heapUsage.getUsed());
        meterRegistry.gauge("jvm.memory.heap.max", heapUsage.getMax());
        
        // GC情况
        List<GarbageCollectorMXBean> gcBeans = ManagementFactory.getGarbageCollectorMXBeans();
        gcBeans.forEach(gc -> {
            meterRegistry.gauge("jvm.gc.count", gc.getCollectionCount());
            meterRegistry.gauge("jvm.gc.time", gc.getCollectionTime());
        });
    }
}