异步编程应用场景
1. 数据治理场景
1.1 异步数据质量检查系统
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class AsyncDataGovernanceService {
private final ExecutorService executorService;
private final int maxConcurrentTasks;
public AsyncDataGovernanceService(int maxConcurrentTasks) {
this.maxConcurrentTasks = maxConcurrentTasks;
this.executorService = Executors.newFixedThreadPool(maxConcurrentTasks);
}
public CompletableFuture<DataQualityResult> checkDataQuality(String datasetId, String tableName) {
return CompletableFuture.supplyAsync(() -> {
try {
// 模拟数据质量检查
Thread.sleep(100);
return new DataQualityResult(
datasetId,
tableName,
0.95,
System.currentTimeMillis()
);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException("Quality check interrupted", e);
}
}, executorService);
}
public CompletableFuture<List<DataQualityResult>> batchQualityCheck(
List<String> datasets, List<String> tables) {
List<CompletableFuture<DataQualityResult>> futures = datasets.stream()
.flatMap(dataset -> tables.stream()
.map(table -> checkDataQuality(dataset, table)))
.collect(Collectors.toList());
return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
.thenApply(v -> futures.stream()
.map(CompletableFuture::join)
.collect(Collectors.toList()));
}
public void shutdown() {
executorService.shutdown();
}
}
class DataQualityResult {
private String datasetId;
private String tableName;
private double qualityScore;
private long timestamp;
// 构造函数和getter/setter方法
public DataQualityResult(String datasetId, String tableName, double qualityScore, long timestamp) {
this.datasetId = datasetId;
this.tableName = tableName;
this.qualityScore = qualityScore;
this.timestamp = timestamp;
}
// getters...
}
1.2 异步数据血缘追踪系统
// 基于Springboot与Kafka
@Service
public class AsyncDataLineageService {
@Autowired
private KafkaTemplate<String, String> kafkaTemplate;
@Autowired
private RedisTemplate<String, Object> redisTemplate;
@Async("lineageExecutor")
public CompletableFuture<Void> trackDataLineage(DataLineageEvent event) {
try {
// 1. 异步发送到Kafka
kafkaTemplate.send("data-lineage-topic", event.getDatasetId(),
JsonUtils.toJson(event));
// 2. 更新Redis缓存
String key = "lineage:" + event.getDatasetId();
redisTemplate.opsForList().leftPush(key, event);
redisTemplate.expire(key, Duration.ofHours(24));
// 3. 异步更新Neo4j图数据库
updateGraphDatabase(event);
return CompletableFuture.completedFuture(null);
} catch (Exception e) {
return CompletableFuture.failedFuture(e);
}
}
@Async
private void updateGraphDatabase(DataLineageEvent event) {
// Neo4j异步更新逻辑
try (Session session = neo4jDriver.session()) {
session.writeTransactionAsync(tx -> {
String query = """
MERGE (source:Dataset {id: $sourceId})
MERGE (target:Dataset {id: $targetId})
MERGE (source)-[:FLOWS_TO {timestamp: $timestamp, operation: $operation}]->(target)
""";
return tx.runAsync(query,
Values.parameters(
"sourceId", event.getSourceId(),
"targetId", event.getTargetId(),
"timestamp", event.getTimestamp(),
"operation", event.getOperation()
));
});
}
}
}
1.3 实时数据治理监控系统
// 基于Flink与Kafka
public class RealTimeDataGovernanceJob {
public static void main(String[] args) throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setParallelism(4);
// 配置Kafka消费者
Properties kafkaProps = new Properties();
kafkaProps.setProperty("bootstrap.servers", "localhost:9092");
kafkaProps.setProperty("group.id", "data-governance-group");
FlinkKafkaConsumer<String> consumer = new FlinkKafkaConsumer<>(
"data-events", new SimpleStringSchema(), kafkaProps);
DataStream<String> dataStream = env.addSource(consumer);
// 异步数据治理处理
dataStream
.map(new DataEventParser())
.keyBy(DataEvent::getDatasetId)
.window(TumblingProcessingTimeWindows.of(Time.minutes(1)))
.aggregate(new DataQualityAggregator())
.addSink(new AsyncDataGovernanceSink());
env.execute("Real-time Data Governance Job");
}
}
class AsyncDataGovernanceSink extends RichSinkFunction<DataQualityMetrics> {
private AsyncHttpClient httpClient;
@Override
public void open(Configuration parameters) throws Exception {
httpClient = new AsyncHttpClient();
}
@Override
public void invoke(DataQualityMetrics metrics, Context context) throws Exception {
// 异步发送治理指标
CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
try {
// 发送到监控系统
httpClient.post("/api/governance/metrics", metrics);
// 检查阈值并发送告警
if (metrics.getQualityScore() < 0.8) {
sendAlert(metrics);
}
} catch (Exception e) {
// 错误处理
logger.error("Failed to send metrics", e);
}
});
// 可选：等待完成或设置超时
future.orTimeout(5, TimeUnit.SECONDS);
}
private void sendAlert(DataQualityMetrics metrics) {
// 异步发送告警逻辑
}
}
2. 金融系统场景
2.1 风控决策引擎
@Service
public class RiskAssessmentService {
private final ExecutorService executor = ForkJoinPool.commonPool();
public CompletableFuture<RiskDecision> assessRisk(LoanApplication application) {
// 并行执行多种风控检查
CompletableFuture<CreditScore> creditScoreFuture = CompletableFuture
.supplyAsync(() -> getCreditScore(application.getIdNumber()), executor);
CompletableFuture<BlacklistResult> blacklistFuture = CompletableFuture
.supplyAsync(() -> checkBlacklist(application.getIdNumber()), executor);
CompletableFuture<IncomeVerification> incomeFuture = CompletableFuture
.supplyAsync(() -> verifyIncome(application), executor);
CompletableFuture<DebtRatio> debtRatioFuture = CompletableFuture
.supplyAsync(() -> calculateDebtRatio(application), executor);
CompletableFuture<BehaviorScore> behaviorFuture = CompletableFuture
.supplyAsync(() -> analyzeBehavior(application.getIdNumber()), executor);
// 组合所有风控结果
return CompletableFuture.allOf(
creditScoreFuture, blacklistFuture, incomeFuture,
debtRatioFuture, behaviorFuture
).thenApply(v -> {
RiskDecision decision = new RiskDecision();
try {
CreditScore creditScore = creditScoreFuture.get();
BlacklistResult blacklist = blacklistFuture.get();
IncomeVerification income = incomeFuture.get();
DebtRatio debtRatio = debtRatioFuture.get();
BehaviorScore behavior = behaviorFuture.get();
// 综合决策逻辑
decision = makeDecision(creditScore, blacklist, income, debtRatio, behavior);
} catch (Exception e) {
log.error("风控评估异常", e);
decision.setResult(RiskResult.REJECT);
decision.setReason("系统异常");
}
return decision;
});
}
private RiskDecision makeDecision(CreditScore creditScore, BlacklistResult blacklist,
IncomeVerification income, DebtRatio debtRatio,
BehaviorScore behavior) {
RiskDecision decision = new RiskDecision();
// 一票否决项
if (blacklist.isInBlacklist()) {
decision.setResult(RiskResult.REJECT);
decision.setReason("黑名单用户");
return decision;
}
// 综合评分
double totalScore = creditScore.getScore() * 0.4 +
income.getScore() * 0.3 +
behavior.getScore() * 0.3;
if (totalScore >= 80 && debtRatio.getRatio() < 0.5) {
decision.setResult(RiskResult.APPROVE);
decision.setAmount(calculateApprovalAmount(totalScore, income));
} else if (totalScore >= 60) {
decision.setResult(RiskResult.MANUAL_REVIEW);
decision.setReason("需要人工审核");
} else {
decision.setResult(RiskResult.REJECT);
decision.setReason("综合评分不足");
}
return decision;
}
}
2.2 实时行情数据处理
@Service
public class MarketDataProcessor {
private final ExecutorService executor = Executors.newFixedThreadPool(50);
public CompletableFuture<MarketSummary> getMarketSummary(String symbol) {
// 并行获取不同维度的市场数据
CompletableFuture<Quote> quoteFuture = CompletableFuture
.supplyAsync(() -> getLatestQuote(symbol), executor);
CompletableFuture<List<Trade>> tradesFuture = CompletableFuture
.supplyAsync(() -> getRecentTrades(symbol), executor);
CompletableFuture<OrderBook> orderBookFuture = CompletableFuture
.supplyAsync(() -> getOrderBook(symbol), executor);
CompletableFuture<TechnicalIndicators> technicalFuture = CompletableFuture
.supplyAsync(() -> calculateTechnicalIndicators(symbol), executor);
CompletableFuture<NewsImpact> newsFuture = CompletableFuture
.supplyAsync(() -> analyzeNewsImpact(symbol), executor);
return CompletableFuture.allOf(
quoteFuture, tradesFuture, orderBookFuture, technicalFuture, newsFuture
).thenApply(v -> {
MarketSummary summary = new MarketSummary();
try {
Quote quote = quoteFuture.get();
List<Trade> trades = tradesFuture.get();
OrderBook orderBook = orderBookFuture.get();
TechnicalIndicators technical = technicalFuture.get();
NewsImpact news = newsFuture.get();
summary.setSymbol(symbol);
summary.setQuote(quote);
summary.setVolume(trades.stream().mapToLong(Trade::getVolume).sum());
summary.setSpread(orderBook.getSpread());
summary.setTechnicalIndicators(technical);
summary.setNewsImpact(news);
summary.setTimestamp(System.currentTimeMillis());
} catch (Exception e) {
log.error("获取市场数据失败: " + symbol, e);
summary.setError("数据获取失败");
}
return summary;
});
}
}
3. 电商系统场景
3.1 商品详情页面聚合
@Service
public class ProductDetailService {
@Autowired
private ProductService productService;
@Autowired
private InventoryService inventoryService;
@Autowired
private PriceService priceService;
@Autowired
private ReviewService reviewService;
@Autowired
private RecommendationService recommendationService;
private final ExecutorService executor = Executors.newFixedThreadPool(20);
public CompletableFuture<ProductDetailVO> getProductDetail(Long productId) {
// 并行获取商品各种信息
CompletableFuture<Product> productFuture = CompletableFuture
.supplyAsync(() -> productService.getById(productId), executor);
CompletableFuture<Inventory> inventoryFuture = CompletableFuture
.supplyAsync(() -> inventoryService.getStock(productId), executor);
CompletableFuture<Price> priceFuture = CompletableFuture
.supplyAsync(() -> priceService.getPrice(productId), executor);
CompletableFuture<List<Review>> reviewsFuture = CompletableFuture
.supplyAsync(() -> reviewService.getReviews(productId, 0, 10), executor);
CompletableFuture<List<Product>> recommendationsFuture = CompletableFuture
.supplyAsync(() -> recommendationService.getRecommendations(productId), executor);
// 组合所有结果
return productFuture.thenCombine(inventoryFuture, (product, inventory) -> {
ProductDetailVO vo = new ProductDetailVO();
vo.setProduct(product);
vo.setStock(inventory.getStock());
return vo;
}).thenCombine(priceFuture, (vo, price) -> {
vo.setPrice(price.getAmount());
vo.setDiscount(price.getDiscount());
return vo;
}).thenCombine(reviewsFuture, (vo, reviews) -> {
vo.setReviews(reviews);
vo.setAverageRating(reviews.stream()
.mapToDouble(Review::getRating)
.average()
.orElse(0.0));
return vo;
}).thenCombine(recommendationsFuture, (vo, recommendations) -> {
vo.setRecommendations(recommendations);
return vo;
}).exceptionally(ex -> {
log.error("获取商品详情失败", ex);
return createDefaultProductDetail(productId);
});
}
}
3.2 订单处理流程
@Service
public class OrderProcessService {
public CompletableFuture<OrderResult> processOrder(OrderRequest request) {
return CompletableFuture
.supplyAsync(() -> validateOrder(request))
.thenCompose(validOrder -> checkInventory(validOrder))
.thenCompose(checkedOrder -> calculatePrice(checkedOrder))
.thenCompose(pricedOrder -> processPayment(pricedOrder))
.thenCompose(paidOrder -> reserveInventory(paidOrder))
.thenCompose(reservedOrder -> createOrder(reservedOrder))
.thenApplyAsync(order -> {
// 异步发送通知，不影响主流程
sendNotificationAsync(order);
return OrderResult.success(order);
})
.exceptionally(ex -> {
log.error("订单处理失败", ex);
return OrderResult.failure(ex.getMessage());
});
}
private CompletableFuture<Order> processPayment(Order order) {
return CompletableFuture.supplyAsync(() -> {
// 调用支付服务
PaymentResult result = paymentService.pay(order.getPaymentInfo());
if (result.isSuccess()) {
order.setPaymentStatus(PaymentStatus.PAID);
return order;
} else {
throw new PaymentException("支付失败: " + result.getMessage());
}
});
}
private void sendNotificationAsync(Order order) {
// 异步发送多种通知，不阻塞主流程
CompletableFuture.allOf(
CompletableFuture.runAsync(() -> smsService.sendOrderConfirmation(order)),
CompletableFuture.runAsync(() -> emailService.sendOrderConfirmation(order)),
CompletableFuture.runAsync(() -> pushService.sendOrderNotification(order))
).exceptionally(ex -> {
log.warn("发送通知失败", ex);
return null;
});
}
}
4. 社交媒体场景
4.1 用户动态流生成
@Service
public class FeedService {
public CompletableFuture<UserFeed> generateUserFeed(Long userId, int page, int size) {
// 并行获取用户相关数据
CompletableFuture<User> userFuture = CompletableFuture
.supplyAsync(() -> userService.getById(userId));
CompletableFuture<List<Long>> followingFuture = CompletableFuture
.supplyAsync(() -> followService.getFollowingIds(userId));
CompletableFuture<List<String>> interestsFuture = CompletableFuture
.supplyAsync(() -> userService.getUserInterests(userId));
return followingFuture.thenCompose(followingIds -> {
// 基于关注列表获取内容
CompletableFuture<List<Post>> followingPostsFuture = CompletableFuture
.supplyAsync(() -> postService.getPostsByUsers(followingIds, page, size));
return followingPostsFuture.thenCombine(interestsFuture, (posts, interests) -> {
// 基于兴趣推荐内容
CompletableFuture<List<Post>> recommendedPostsFuture = CompletableFuture
.supplyAsync(() -> recommendationService.getRecommendedPosts(userId, interests));
return recommendedPostsFuture.thenApply(recommendedPosts -> {
UserFeed feed = new UserFeed();
feed.setUserId(userId);
// 合并和排序内容
List<Post> allPosts = new ArrayList<>();
allPosts.addAll(posts);
allPosts.addAll(recommendedPosts);
// 按时间和相关性排序
List<Post> sortedPosts = allPosts.stream()
.sorted((p1, p2) -> calculateFeedScore(p2, userId) - calculateFeedScore(p1, userId))
.limit(size)
.collect(Collectors.toList());
feed.setPosts(sortedPosts);
return feed;
});
});
}).exceptionally(ex -> {
log.error("生成用户动态流失败", ex);
return getDefaultFeed(userId);
});
}
private int calculateFeedScore(Post post, Long userId) {
// 计算内容在用户动态流中的分数
int score = 0;
score += post.getLikeCount() * 2;
score += post.getCommentCount() * 3;
score += post.getShareCount() * 5;
// 时间衰减
long hoursSincePosted = Duration.between(post.getCreatedAt(), LocalDateTime.now()).toHours();
score -= hoursSincePosted * 2;
return Math.max(0, score);
}
}
4.2 内容审核系统
@Service
public class ContentModerationService {
private final ExecutorService executor = Executors.newFixedThreadPool(30);
public CompletableFuture<ModerationResult> moderateContent(ContentSubmission content) {
// 并行执行多种审核检查
CompletableFuture<TextModerationResult> textFuture = CompletableFuture
.supplyAsync(() -> moderateText(content.getText()), executor);
CompletableFuture<ImageModerationResult> imageFuture = CompletableFuture
.supplyAsync(() -> moderateImages(content.getImages()), executor);
CompletableFuture<SpamDetectionResult> spamFuture = CompletableFuture
.supplyAsync(() -> detectSpam(content), executor);
CompletableFuture<SensitiveInfoResult> sensitiveInfoFuture = CompletableFuture
.supplyAsync(() -> checkSensitiveInfo(content), executor);
CompletableFuture<UserReputationResult> reputationFuture = CompletableFuture
.supplyAsync(() -> checkUserReputation(content.getUserId()), executor);
return CompletableFuture.allOf(
textFuture, imageFuture, spamFuture, sensitiveInfoFuture, reputationFuture
).thenApply(v -> {
ModerationResult result = new ModerationResult();
try {
TextModerationResult textResult = textFuture.get();
ImageModerationResult imageResult = imageFuture.get();
SpamDetectionResult spamResult = spamFuture.get();
SensitiveInfoResult sensitiveResult = sensitiveInfoFuture.get();
UserReputationResult reputationResult = reputationFuture.get();
// 综合审核结果
result = combineResults(textResult, imageResult, spamResult,
sensitiveResult, reputationResult);
} catch (Exception e) {
log.error("内容审核异常", e);
result.setAction(ModerationAction.MANUAL_REVIEW);
result.setReason("系统异常，需人工审核");
}
return result;
});
}
private ModerationResult combineResults(TextModerationResult text,
ImageModerationResult image,
SpamDetectionResult spam,
SensitiveInfoResult sensitive,
UserReputationResult reputation) {
ModerationResult result = new ModerationResult();
// 严重违规直接拒绝
if (text.containsHateSpeech() || image.containsInappropriateContent() ||
sensitive.containsPersonalInfo()) {
result.setAction(ModerationAction.REJECT);
result.setReason("内容违规");
return result;
}
// 垃圾内容处理
if (spam.isSpam() && reputation.getScore() < 0.5) {
result.setAction(ModerationAction.REJECT);
result.setReason("疑似垃圾内容");
return result;
}
// 可疑内容人工审核
if (text.getSuspiciousScore() > 0.7 || image.getSuspiciousScore() > 0.7) {
result.setAction(ModerationAction.MANUAL_REVIEW);
result.setReason("内容可疑，需人工审核");
return result;
}
// 通过审核
result.setAction(ModerationAction.APPROVE);
result.setReason("审核通过");
return result;
}
}
5. 物联网场景
5.1 设备数据处理
@Service
public class IoTDataProcessor {
private final ExecutorService executor = Executors.newFixedThreadPool(100);
public CompletableFuture<DeviceStatusSummary> processDeviceData(String deviceId) {
// 并行处理设备的不同类型数据
CompletableFuture<SensorData> sensorFuture = CompletableFuture
.supplyAsync(() -> getLatestSensorData(deviceId), executor);
CompletableFuture<List<AlertRule>> alertRulesFuture = CompletableFuture
.supplyAsync(() -> getAlertRules(deviceId), executor);
CompletableFuture<DeviceHealth> healthFuture = CompletableFuture
.supplyAsync(() -> checkDeviceHealth(deviceId), executor);
CompletableFuture<List<HistoricalData>> historyFuture = CompletableFuture
.supplyAsync(() -> getHistoricalData(deviceId, Duration.ofHours(24)), executor);
return sensorFuture.thenCombine(alertRulesFuture, (sensorData, alertRules) -> {
// 检查报警规则
List<Alert> alerts = checkAlerts(sensorData, alertRules);
return CompletableFuture.allOf(healthFuture, historyFuture)
.thenApply(v -> {
try {
DeviceHealth health = healthFuture.get();
List<HistoricalData> history = historyFuture.get();
DeviceStatusSummary summary = new DeviceStatusSummary();
summary.setDeviceId(deviceId);
summary.setCurrentData(sensorData);
summary.setHealth(health);
summary.setAlerts(alerts);
summary.setTrends(calculateTrends(history));
summary.setPredictions(predictFutureValues(history));
// 如果有严重报警，异步发送通知
if (alerts.stream().anyMatch(Alert::isCritical)) {
sendCriticalAlertAsync(deviceId, alerts);
}
return summary;
} catch (Exception e) {
log.error("处理设备数据失败: " + deviceId, e);
return createErrorSummary(deviceId, e);
}
});
}).get();
}
private void sendCriticalAlertAsync(String deviceId, List<Alert> alerts) {
CompletableFuture.runAsync(() -> {
alerts.stream()
.filter(Alert::isCritical)
.forEach(alert -> {
try {
notificationService.sendCriticalAlert(deviceId, alert);
} catch (Exception e) {
log.error("发送关键报警失败", e);
}
});
}, executor);
}
}
5.2 智能家居场景联动
@Service
public class SmartHomeService {
public CompletableFuture<Void> executeScenario(String scenarioId, String userId) {
return CompletableFuture.supplyAsync(() -> {
// 获取场景配置
Scenario scenario = scenarioService.getById(scenarioId);
if (!scenario.isEnabled()) {
throw new IllegalStateException("场景未启用");
}
return scenario;
}).thenCompose(scenario -> {
// 并行执行场景中的所有设备控制
List<CompletableFuture<Void>> deviceActions = scenario.getActions().stream()
.map(action -> executeDeviceAction(action, userId))
.collect(Collectors.toList());
return CompletableFuture.allOf(deviceActions.toArray(new CompletableFuture[0]));
}).thenRun(() -> {
// 记录场景执行日志
log.info("场景执行完成: {}", scenarioId);
}).exceptionally(ex -> {
log.error("场景执行失败: " + scenarioId, ex);
return null;
});
}
private CompletableFuture<Void> executeDeviceAction(DeviceAction action, String userId) {
return CompletableFuture.runAsync(() -> {
try {
switch (action.getDeviceType()) {
case LIGHT:
lightService.control(action.getDeviceId(), action.getParameters());
break;
case AIR_CONDITIONER:
airConditionerService.control(action.getDeviceId(), action.getParameters());
break;
case CURTAIN:
curtainService.control(action.getDeviceId(), action.getParameters());
break;
case SECURITY_SYSTEM:
securityService.control(action.getDeviceId(), action.getParameters());
break;
}
// 记录设备控制日志
deviceLogService.recordAction(userId, action);
} catch (Exception e) {
log.error("设备控制失败: " + action.getDeviceId(), e);
throw new RuntimeException("设备控制失败", e);
}
});
}
}
6. 日志分析场景
6.1 实时日志分析
@Service
public class LogAnalysisService {
private final ExecutorService executor = Executors.newFixedThreadPool(20);
public CompletableFuture<SystemHealthReport> analyzeSystemHealth() {
LocalDateTime now = LocalDateTime.now();
LocalDateTime oneHourAgo = now.minusHours(1);
// 并行分析不同维度的系统健康状况
CompletableFuture<ErrorAnalysis> errorFuture = CompletableFuture
.supplyAsync(() -> analyzeErrors(oneHourAgo, now), executor);
CompletableFuture<PerformanceAnalysis> performanceFuture = CompletableFuture
.supplyAsync(() -> analyzePerformance(oneHourAgo, now), executor);
CompletableFuture<SecurityAnalysis> securityFuture = CompletableFuture
.supplyAsync(() -> analyzeSecurity(oneHourAgo, now), executor);
CompletableFuture<ResourceUsageAnalysis> resourceFuture = CompletableFuture
.supplyAsync(() -> analyzeResourceUsage(oneHourAgo, now), executor);
CompletableFuture<UserBehaviorAnalysis> userBehaviorFuture = CompletableFuture
.supplyAsync(() -> analyzeUserBehavior(oneHourAgo, now), executor);
return CompletableFuture.allOf(
errorFuture, performanceFuture, securityFuture, resourceFuture, userBehaviorFuture
).thenApply(v -> {
SystemHealthReport report = new SystemHealthReport();
try {
ErrorAnalysis errorAnalysis = errorFuture.get();
PerformanceAnalysis performanceAnalysis = performanceFuture.get();
SecurityAnalysis securityAnalysis = securityFuture.get();
ResourceUsageAnalysis resourceAnalysis = resourceFuture.get();
UserBehaviorAnalysis userBehaviorAnalysis = userBehaviorFuture.get();
report.setErrorAnalysis(errorAnalysis);
report.setPerformanceAnalysis(performanceAnalysis);
report.setSecurityAnalysis(securityAnalysis);
report.setResourceAnalysis(resourceAnalysis);
report.setUserBehaviorAnalysis(userBehaviorAnalysis);
// 计算综合健康分数
report.setHealthScore(calculateHealthScore(
errorAnalysis, performanceAnalysis, securityAnalysis,
resourceAnalysis, userBehaviorAnalysis
));
// 生成建议
report.setRecommendations(generateRecommendations(report));
// 如果健康分数过低，异步发送告警
if (report.getHealthScore() < 0.7) {
sendHealthAlertAsync(report);
}
} catch (Exception e) {
log.error("系统健康分析失败", e);
report.setError("分析失败: " + e.getMessage());
}
return report;
});
}
private void sendHealthAlertAsync(SystemHealthReport report) {
CompletableFuture.runAsync(() -> {
try {
alertService.sendSystemHealthAlert(report);
} catch (Exception e) {
log.error("发送系统健康告警失败", e);
}
}, executor);
}
}
7. 其他
7.1 批处理任务
# 处理大量文件、发送邮件、生成报告等任务可以通过异步方式并行执行，显著缩短总体处理时间。
浙公网安备 33010602011771号