在实际项目开发中，我们经常需要处理复杂的业务逻辑，这些逻辑往往涉及多个实体间的竞争、协作与状态流转。例如，在一个模拟竞赛或社区互动的系统中，参与者（如“英才”）之间会形成动态的竞争关系（“竞斗”），同时他们又受到所处环境（如“邻居”）的影响，整个系统的状态在表面之下暗流涌动（“暗潮”）。这种场景对数据模型的设计、状态机的管理以及业务规则的实现提出了挑战。

本文将以一个高度抽象的“英才竞斗系统”为例，演示如何从零开始设计并实现一套可运行的核心逻辑。我们将模拟“初台公演”这样的活动场景，其中多位“英才”参与，他们之间存在“竞斗”关系，并且“邻居”关系会影响竞斗的结果与过程，整个系统状态的变化构成了“暗潮”。我们将使用面向对象的设计思想，结合Java语言，构建一个清晰、可扩展的模型，并实现关键的业务规则。通过本文，你将掌握如何将模糊的业务需求转化为具体的类设计、状态管理和规则引擎，并学会处理实体间复杂的交互逻辑。

1. 理解核心概念与业务场景建模

在开始编码之前，必须将业务描述中的关键术语转化为清晰的技术概念。这有助于建立统一的语言，避免后续设计出现歧义。

1.1 实体定义：英才、竞斗与邻居

首先，我们需要定义系统中的核心实体。

1. 英才 (Talent): 这是系统的基本参与者。每个英才具备一些基本属性和状态。

   • 属性: 唯一ID、名称、当前能量值（或分数）、状态（如活跃、休息、淘汰）。
   • 行为: 可以参与竞斗，能量会发生变化。

2. 竞斗 (Duel): 描述两个英才之间的一次对抗事件。它不是持久实体，而是一个过程或事件。

   • 属性: 参与者（两个英才）、竞斗类型、发生时间、结果。
   • 行为: 执行竞斗逻辑，根据规则计算并更新参与者的状态。

3. 邻居 (Neighborhood): 描述英才之间的空间或关系拓扑。它影响竞斗的规则。

   • 属性: 可以是一个图结构，节点是英才，边代表邻居关系。或者简化为一个规则：当两个英才是邻居时，他们的竞斗有特殊加成或惩罚。
   • 行为: 判断两个英才是否为邻居，获取某个英才的所有邻居。

1.2 状态“暗潮”与规则引擎

“暗潮”指的是系统内部状态随着竞斗发生而持续、复杂的变化流。这提示我们不能简单地在Duel方法里硬编码所有逻辑。更好的做法是引入规则引擎或策略模式。

• 规则 (Rule): 一条独立的业务逻辑判断。例如：“如果竞斗双方是邻居，则胜利方额外获得10点能量”。
• 规则引擎 (RuleEngine): 负责在特定事件（如竞斗结束）触发时，收集所有相关规则，按顺序执行，并应用规则产生的结果（状态变更）。

这种设计将易变的业务规则与稳定的核心流程解耦。当需要新增规则（如“连续获胜者有衰减加成”）时，只需新增一个Rule实现类，无需修改Duel或Talent的核心代码。

1.3 场景串联：“初台公演”

“初台公演”可以看作一个场景 (Stage)或回合 (Round)的容器。

• 属性: 场景名称、参与英才列表、本场景的特定规则集、历史竞斗记录。
• 行为: 初始化英才，按某种赛制（如循环赛、淘汰赛）安排竞斗，驱动整个流程执行，并最终产出结果（如排名）。

2. 环境准备与项目结构

我们将使用Java语言，构建一个标准的Maven项目。无需复杂的外部框架，核心是面向对象设计。

2.1 开发环境要求

确保你的本地环境满足以下要求：

2.2 创建Maven项目

通过命令行或IDE创建项目。项目结构应清晰区分不同职责的包。

mvn archetype:generate -DgroupId=com.example.talentduel -DartifactId=talent-duel-core -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

创建完成后，在IDE中调整src/main/java下的包结构。建议结构如下：

src/main/java/com/example/talentduel/ ├── model/ # 实体类 │ ├── Talent.java │ └── DuelResult.java ├── rule/ # 规则相关 │ ├── Rule.java │ ├── RuleEngine.java │ ├── impl/ # 规则实现 │ │ ├── NeighborhoodBonusRule.java │ │ └── EnergyDecayRule.java ├── service/ # 核心业务逻辑 │ ├── DuelService.java │ ├── NeighborhoodService.java │ └── StageService.java └── Main.java # 程序入口

2.3 核心依赖

本项目逻辑简单，无需额外依赖。pom.xml保持默认即可。如果你计划未来加入JSON解析、日志等，可以在此添加。

<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.example.talentduel</groupId> <artifactId>talent-duel-core</artifactId> <version>1.0-SNAPSHOT</version> <properties> <maven.compiler.source>8</maven.compiler.source> <maven.compiler.target>8</maven.compiler.target> </properties> </project>

3. 核心模型与接口设计实现

现在开始实现第1章中定义的核心概念。我们从最稳定的实体和接口开始。

3.1 定义英才实体

Talent类需要属性、构造方法、getter/setter以及一些业务方法。

package com.example.talentduel.model; /** * 英才实体 */ public class Talent { private final String id; // 唯一标识，final确保创建后不变 private final String name; private int energy; // 能量值，会随着竞斗变化 private TalentStatus status; // 状态枚举 public Talent(String id, String name, int initialEnergy) { this.id = id; this.name = name; this.energy = initialEnergy; this.status = TalentStatus.ACTIVE; // 默认活跃 } // 增加能量 public void gainEnergy(int amount) { if (amount > 0) { this.energy += amount; } } // 减少能量 public void loseEnergy(int amount) { if (amount > 0) { this.energy = Math.max(0, this.energy - amount); // 能量不低于0 } } // 检查是否可参与竞斗 public boolean isEligibleForDuel() { return this.status == TalentStatus.ACTIVE && this.energy > 0; } // Getter 方法 public String getId() { return id; } public String getName() { return name; } public int getEnergy() { return energy; } public TalentStatus getStatus() { return status; } // Setter 通常只对状态和能量提供，ID和Name不变 public void setStatus(TalentStatus status) { this.status = status; } // 注意：energy通过 gain/lose 方法修改，不直接提供setter } /** * 英才状态枚举 */ enum TalentStatus { ACTIVE, // 活跃，可参与竞斗 RESTING, // 休息，本轮不可参与 ELIMINATED // 淘汰，后续所有轮次不可参与 }

注意：energy没有提供直接的setter，而是通过gainEnergy和loseEnergy方法进行修改。这是封装的关键，确保能量变更只能通过预定义的业务逻辑进行，避免被随意设置。

3.2 定义竞斗结果与规则接口

竞斗本身是一个过程，我们用一个记录结果的类DuelResult来承载一次竞斗的输出。

package com.example.talentduel.model; import java.util.HashMap; import java.util.Map; /** * 竞斗结果 */ public class DuelResult { private final Talent talentA; private final Talent talentB; private Talent winner; // 胜者 private Talent loser; // 败者 private final Map<String, Object> context; // 上下文，用于规则间传递数据 public DuelResult(Talent a, Talent b) { this.talentA = a; this.talentB = b; this.context = new HashMap<>(); } // Getter and Setter public Talent getTalentA() { return talentA; } public Talent getTalentB() { return talentB; } public Talent getWinner() { return winner; } public void setWinner(Talent winner) { this.winner = winner; } public Talent getLoser() { return loser; } public void setLoser(Talent loser) { this.loser = loser; } public Map<String, Object> getContext() { return context; } // 便捷方法：获取对手 public Talent getOpponentOf(Talent talent) { if (talent.equals(talentA)) return talentB; if (talent.equals(talentB)) return talentA; return null; } }

接下来定义规则接口。规则的核心是“在给定条件下，对结果施加影响”。

package com.example.talentduel.rule; import com.example.talentduel.model.DuelResult; /** * 规则接口 */ public interface Rule { /** * 规则名称 */ String getName(); /** * 判断此规则是否适用于当前竞斗结果 * @param result 竞斗结果 * @return true 如果适用 */ boolean evaluate(DuelResult result); /** * 应用规则，修改result中的状态或context * @param result 竞斗结果 */ void apply(DuelResult result); }

3.3 实现邻居关系服务

邻居关系可以用一个简单的服务来管理。这里采用内存中的邻接表表示。

package com.example.talentduel.service; import com.example.talentduel.model.Talent; import java.util.*; /** * 邻居关系服务 */ public class NeighborhoodService { // 使用邻接表存储邻居关系 Map<英才ID, 邻居ID列表> private final Map<String, Set<String>> adjacencyMap = new HashMap<>(); /** * 添加邻居关系（双向） */ public void addNeighbor(Talent t1, Talent t2) { adjacencyMap.computeIfAbsent(t1.getId(), k -> new HashSet<>()).add(t2.getId()); adjacencyMap.computeIfAbsent(t2.getId(), k -> new HashSet<>()).add(t1.getId()); } /** * 判断两个英才是否为邻居 */ public boolean areNeighbors(Talent t1, Talent t2) { Set<String> neighborsOfT1 = adjacencyMap.get(t1.getId()); return neighborsOfT1 != null && neighborsOfT1.contains(t2.getId()); } /** * 获取某个英才的所有邻居ID */ public Set<String> getNeighborIds(Talent talent) { return adjacencyMap.getOrDefault(talent.getId(), Collections.emptySet()); } }

4. 实现竞斗服务与规则引擎

这是系统的核心，负责执行一次竞斗并应用所有相关规则。

4.1 实现具体的业务规则

我们先实现两条规则：邻居加成规则和能量衰减规则。

package com.example.talentduel.rule.impl; import com.example.talentduel.model.DuelResult; import com.example.talentduel.model.Talent; import com.example.talentduel.rule.Rule; import com.example.talentduel.service.NeighborhoodService; /** * 规则1：邻居加成规则 * 如果竞斗双方是邻居，则胜者额外获得奖励能量。 */ public class NeighborhoodBonusRule implements Rule { private final NeighborhoodService neighborhoodService; private final int bonusEnergy; public NeighborhoodBonusRule(NeighborhoodService neighborhoodService, int bonusEnergy) { this.neighborhoodService = neighborhoodService; this.bonusEnergy = bonusEnergy; } @Override public String getName() { return "NeighborhoodBonusRule"; } @Override public boolean evaluate(DuelResult result) { Talent winner = result.getWinner(); Talent loser = result.getLoser(); // 规则生效条件：有明确的胜败者，且双方是邻居 return winner != null && loser != null && neighborhoodService.areNeighbors(winner, loser); } @Override public void apply(DuelResult result) { if (evaluate(result)) { Talent winner = result.getWinner(); winner.gainEnergy(bonusEnergy); // 可以将奖励记录到上下文中，便于日志或后续规则使用 result.getContext().put("neighborhoodBonusApplied", true); result.getContext().put("bonusAmount", bonusEnergy); } } }

package com.example.talentduel.rule.impl; import com.example.talentduel.model.DuelResult; import com.example.talentduel.model.Talent; import com.example.talentduel.rule.Rule; /** * 规则2：能量衰减规则 * 败者损失基础能量，并且如果其能量低于阈值，状态可能变为休息。 */ public class EnergyDecayRule implements Rule { private final int baseEnergyLoss; private final int restThreshold; public EnergyDecayRule(int baseEnergyLoss, int restThreshold) { this.baseEnergyLoss = baseEnergyLoss; this.restThreshold = restThreshold; } @Override public String getName() { return "EnergyDecayRule"; } @Override public boolean evaluate(DuelResult result) { // 只要存在败者，此规则就适用 return result.getLoser() != null; } @Override public void apply(DuelResult result) { Talent loser = result.getLoser(); loser.loseEnergy(baseEnergyLoss); // 检查败者能量是否过低，触发状态变更 if (loser.getEnergy() < restThreshold) { // 这里简单设置为休息，实际可能更复杂 // loser.setStatus(TalentStatus.RESTING); result.getContext().put("loserEnergyLow", true); result.getContext().put("loserNewStatusSuggested", "RESTING"); } } }

4.2 构建规则引擎

规则引擎负责管理所有规则，并在适当时机触发它们。

package com.example.talentduel.rule; import com.example.talentduel.model.DuelResult; import java.util.ArrayList; import java.util.List; /** * 简单的规则引擎 */ public class RuleEngine { private final List<Rule> rules = new ArrayList<>(); public void registerRule(Rule rule) { rules.add(rule); } /** * 对某个竞斗结果执行所有适用的规则 */ public void executeRules(DuelResult result) { for (Rule rule : rules) { // 注意：先evaluate再apply，确保规则内部逻辑一致 if (rule.evaluate(result)) { rule.apply(result); } } } }

4.3 实现竞斗服务

竞斗服务是业务流程的协调者。它需要：

1. 决定一次竞斗的胜负（这里用简单随机模拟）。
2. 创建DuelResult。
3. 调用规则引擎应用所有规则。
4. 返回最终结果。

package com.example.talentduel.service; import com.example.talentduel.model.DuelResult; import com.example.talentduel.model.Talent; import com.example.talentduel.rule.RuleEngine; import java.util.Random; /** * 竞斗服务 */ public class DuelService { private final RuleEngine ruleEngine; private final Random random = new Random(); public DuelService(RuleEngine ruleEngine) { this.ruleEngine = ruleEngine; } /** * 执行一次竞斗 * @param talentA 英才A * @param talentB 英才B * @return 竞斗结果 * @throws IllegalArgumentException 如果英才不符合竞斗条件 */ public DuelResult executeDuel(Talent talentA, Talent talentB) { // 1. 前置检查 if (!talentA.isEligibleForDuel() || !talentB.isEligibleForDuel()) { throw new IllegalArgumentException("英才不满足竞斗条件: " + talentA.getName() + " or " + talentB.getName()); } // 2. 创建初始结果 DuelResult result = new DuelResult(talentA, talentB); // 3. 核心竞斗逻辑（这里用随机模拟胜负） // 更复杂的逻辑可以基于能量、属性等计算 Talent winner, loser; if (random.nextBoolean()) { winner = talentA; loser = talentB; } else { winner = talentB; loser = talentA; } result.setWinner(winner); result.setLoser(loser); // 4. 记录基础能量变化（胜者增益，败者损失） int baseWinGain = 20; int baseLoseLoss = 15; winner.gainEnergy(baseWinGain); loser.loseEnergy(baseLoseLoss); result.getContext().put("baseWinGain", baseWinGain); result.getContext().put("baseLoseLoss", baseLoseLoss); // 5. 触发规则引擎，应用所有业务规则（“暗潮”涌动之处） ruleEngine.executeRules(result); // 6. 返回最终结果 return result; } }

5. 组装场景与运行验证

现在，我们将所有组件组装起来，模拟一个完整的“初台公演”场景。

5.1 创建场景服务

StageService负责初始化英才、建立关系、安排竞斗并驱动整个流程。

package com.example.talentduel.service; import com.example.talentduel.model.DuelResult; import com.example.talentduel.model.Talent; import com.example.talentduel.rule.RuleEngine; import com.example.talentduel.rule.impl.EnergyDecayRule; import com.example.talentduel.rule.impl.NeighborhoodBonusRule; import java.util.*; /** * 舞台（公演）服务 */ public class StageService { private final List<Talent> talents = new ArrayList<>(); private final NeighborhoodService neighborhoodService = new NeighborhoodService(); private final RuleEngine ruleEngine = new RuleEngine(); private final DuelService duelService; public StageService() { // 1. 初始化规则引擎 ruleEngine.registerRule(new NeighborhoodBonusRule(neighborhoodService, 10)); // 邻居奖励10点 ruleEngine.registerRule(new EnergyDecayRule(15, 30)); // 败者损失15点，休息阈值30 // 2. 初始化竞斗服务（依赖规则引擎） this.duelService = new DuelService(ruleEngine); } /** * 初始化英才和邻居关系 */ public void initializeStage() { // 创建4位英才 Talent t1 = new Talent("T001", "英才A", 100); Talent t2 = new Talent("T002", "英才B", 100); Talent t3 = new Talent("T003", "英才C", 100); Talent t4 = new Talent("T004", "英才D", 100); Collections.addAll(talents, t1, t2, t3, t4); // 设置邻居关系：假设A和B是邻居，C和D是邻居 neighborhoodService.addNeighbor(t1, t2); neighborhoodService.addNeighbor(t3, t4); // A和C不是邻居，B和D也不是邻居 } /** * 执行一轮竞斗（这里简单安排所有英才两两对决一次） */ public List<DuelResult> runOneRound() { List<DuelResult> results = new ArrayList<>(); int size = talents.size(); for (int i = 0; i < size; i++) { for (int j = i + 1; j < size; j++) { Talent a = talents.get(i); Talent b = talents.get(j); try { DuelResult result = duelService.executeDuel(a, b); results.add(result); System.out.println("竞斗完成: " + a.getName() + " vs " + b.getName() + ", 胜者: " + result.getWinner().getName() + ", 败者能量: " + result.getLoser().getEnergy()); } catch (IllegalArgumentException e) { System.out.println("跳过竞斗: " + a.getName() + " vs " + b.getName() + " - " + e.getMessage()); } } } return results; } /** * 打印当前所有英才状态 */ public void printTalentStatus() { System.out.println("\n=== 当前英才状态 ==="); for (Talent t : talents) { System.out.printf("ID: %s, 名称: %s, 能量: %d, 状态: %s%n", t.getId(), t.getName(), t.getEnergy(), t.getStatus()); } } }

5.2 编写主程序并运行

创建一个Main类作为程序入口，串联整个流程。

package com.example.talentduel; import com.example.talentduel.service.StageService; public class Main { public static void main(String[] args) { System.out.println("【初台公演】模拟开始...\n"); // 1. 初始化舞台 StageService stage = new StageService(); stage.initializeStage(); stage.printTalentStatus(); // 2. 执行第一轮竞斗 System.out.println("\n--- 第一轮竞斗开始 ---"); stage.runOneRound(); stage.printTalentStatus(); // 3. 可以继续执行更多轮次 // System.out.println("\n--- 第二轮竞斗开始 ---"); // stage.runOneRound(); // stage.printTalentStatus(); System.out.println("\n【初台公演】模拟结束。"); } }

5.3 运行结果与分析

运行Main类，你将在控制台看到类似以下的输出。每次运行结果因随机胜负而不同。

【初台公演】模拟开始... === 当前英才状态 === ID: T001, 名称: 英才A, 能量: 100, 状态: ACTIVE ID: T002, 名称: 英才B, 能量: 100, 状态: ACTIVE ID: T003, 名称: 英才C, 能量: 100, 状态: ACTIVE ID: T004, 名称: 英才D, 能量: 100, 状态: ACTIVE --- 第一轮竞斗开始 --- 竞斗完成: 英才A vs 英才B, 胜者: 英才B, 败者能量: 85 竞斗完成: 英才A vs 英才C, 胜者: 英才A, 败者能量: 85 竞斗完成: 英才A vs 英才D, 胜者: 英才D, 败者能量: 85 竞斗完成: 英才B vs 英才C, 胜者: 英才C, 败者能量: 85 竞斗完成: 英才B vs 英才D, 胜者: 英才B, 败者能量: 85 竞斗完成: 英才C vs 英才D, 胜者: 英才C, 败者能量: 85 === 当前英才状态 === ID: T001, 名称: 英才A, 能量: 120, 状态: ACTIVE ID: T002, 名称: 英才B, 能量: 135, 状态: ACTIVE ID: T003, 名称: 英才C, 能量: 135, 状态: ACTIVE ID: T004, 名称: 英才D, 能量: 105, 状态: ACTIVE

结果分析：

1. 基础逻辑生效：每次竞斗，胜者获得20点基础能量，败者损失15点基础能量。
2. 邻居规则生效：观察“英才A vs 英才B”这场竞斗。他们是邻居。假设英才B获胜，他除了获得20点基础能量，还因为NeighborhoodBonusRule额外获得了10点能量。所以英才B的总能量变化是+20 +10 = +30。败者英才A损失15点。这体现了“邻居”关系对“竞斗”结果的影响。
3. 能量衰减规则：EnergyDecayRule在每次竞斗后都会对败者生效，使其再损失15点能量（与基础损失叠加）。如果败者能量低于30，上下文会记录建议状态变更为RESTING（当前示例未实际修改状态，仅记录）。
4. “暗潮”体现：能量值的最终变化，是基础规则（DuelService内）和多个业务规则（RuleEngine驱动）共同作用的结果。这种设计使得“暗潮”（复杂的、叠加的状态变化）变得清晰且可维护。

6. 常见问题排查与设计思考

在实际编码和运行中，你可能会遇到以下问题或产生相关思考。

6.1 规则执行顺序问题

问题现象：规则A需要在规则B之前执行，但实际顺序无法保证。根因分析：RuleEngine中rules列表的顺序决定了执行顺序。如果注册顺序错误，可能导致依赖前置规则的上下文数据还未准备好。解决方案：

1. 显式定义优先级：在Rule接口中增加getPriority()方法，在RuleEngine.executeRules中按优先级排序后执行。
2. 依赖注入管理：使用Spring等框架时，可以通过@Order注解或实现Ordered接口来管理Bean的顺序。
3. 规则分组与阶段：将规则分为“预处理规则”、“核心规则”、“后处理规则”等不同阶段，分阶段执行。

// 解决方案1示例：为Rule接口增加优先级 public interface Rule { String getName(); int getPriority(); // 优先级，数值越小越先执行 boolean evaluate(DuelResult result); void apply(DuelResult result); } // 在RuleEngine中排序 public void executeRules(DuelResult result) { List<Rule> sortedRules = new ArrayList<>(rules); sortedRules.sort(Comparator.comparingInt(Rule::getPriority)); for (Rule rule : sortedRules) { if (rule.evaluate(result)) { rule.apply(result); } } }

6.2 竞斗胜负逻辑过于简单

问题现象：胜负完全随机，不符合“英才”应有属性（如技能、人气）。解决方案：

1. 为Talent增加属性：如strength（力量）、popularity（人气）。
2. 改造DuelService的胜负判定：引入更复杂的算法。例如，根据双方属性计算胜率，再基于随机数决定胜负。

// 在Talent中增加属性 public class Talent { private int strength; private int popularity; // ... getters and setters } // 在DuelService中实现基于属性的胜负判定 private Talent decideWinner(Talent a, Talent b) { double scoreA = a.getStrength() * 0.7 + a.getPopularity() * 0.3; double scoreB = b.getStrength() * 0.7 + b.getPopularity() * 0.3; double total = scoreA + scoreB; double rand = random.nextDouble() * total; return rand < scoreA ? a : b; }

6.3 邻居关系数据持久化

问题现象：当前邻居关系存储在内存中，程序重启后丢失。解决方案：

1. 定义数据模型：创建NeighborRelation实体类，包含两个Talent的ID。
2. 引入Repository层：使用JPA、MyBatis或JDBC实现关系的增删改查。
3. 改造NeighborhoodService：使其依赖NeighborRelationRepository来查询数据，而非内存Map。

注意：引入持久层后，需要考虑缓存策略，避免频繁查询数据库影响性能。

6.4 系统扩展性考量

当前设计为后续扩展留出了空间：

• 新增规则：只需实现Rule接口，并在StageService中注册到RuleEngine。
• 新增竞斗类型：可以在DuelResult中增加duelType字段，不同规则根据类型决定是否生效。
• 新增英才状态：在TalentStatus枚举中添加新状态，并在相关规则和服务中处理状态迁移逻辑。
• 支持多轮次/淘汰赛：在StageService中增加赛制逻辑，管理轮次、匹配和对阵表。

7. 生产环境最佳实践与扩展方向

学习环境跑通后，若想用于更严肃的场景，需要考虑以下方面。

7.1 配置外置化

硬编码的参数（如基础能量增减值、邻居奖励值、休息阈值）应移至配置文件。

1. 创建application.yml或application.properties：

   duel: rules: neighborhood: bonus-energy: 10 energy-decay: base-loss: 15 rest-threshold: 30 base: win-gain: 20 lose-loss: 15

2. 使用@ConfigurationProperties或@Value注入：在Spring Boot项目中，可以创建配置类来读取这些值。
3. 在服务中注入配置：改造DuelService和规则实现类，从配置类获取参数。

7.2 增强可观测性

“暗潮”意味着状态变化复杂，必须要有清晰的日志和监控。

1. 结构化日志：在RuleEngine.executeRules、DuelService.executeDuel等关键方法中，使用SLF4J+Logback记录INFO或DEBUG级别日志，包含英才ID、规则名、能量变化前/后值等。
2. 上下文信息：DuelResult中的contextMap可以用于记录规则执行的中间结果，便于在日志中输出或后续审计。
3. 指标监控：使用Micrometer等工具，暴露如talent.energy.change、duel.executed.count、rule.triggered.count等指标，接入Prometheus和Grafana。

7.3 规则引擎的进阶选型

当规则数量爆炸、复杂度极高时，可以考虑引入成熟的规则引擎。

7.4 并发与一致性考虑

如果竞斗可以并行发生（如多个舞台同时进行），则需要处理并发问题。

1. Talent能量更新的线程安全：Talent的gainEnergy和loseEnergy方法需要使用synchronized关键字或使用AtomicInteger来保证原子性。
2. 数据库更新：如果使用数据库，竞斗涉及更新多个英才的能量，需要放在一个数据库事务中，或使用乐观锁、分布式锁来防止超卖等问题。
3. 事件驱动架构：可以考虑将一次竞斗建模为一个事件（DuelEvent），由事件处理器消费，规则引擎作为处理器的一部分。这便于扩展和异步处理。

通过以上步骤，我们完成了一个从概念到代码的“英才竞斗系统”核心实现。这个项目清晰地展示了如何将“竞斗”、“邻居”、“暗潮”等业务概念转化为可运行、可扩展的软件模型。关键在于理解业务本质，并用恰当的抽象（实体、服务、规则）进行表达。你可以在此基础上，继续实现更复杂的赛制、更丰富的规则以及持久化功能，构建出一个完整的模拟系统。