1. 策略模式在Java多实体操作中的应用价值
在业务系统开发中，我们经常遇到需要对多种不同实体执行相似操作的情况。比如电商系统中，商品、订单、用户等不同实体都需要支持导出、校验、状态变更等操作。传统做法是为每个实体编写重复代码，这不仅导致代码冗余，更会在需求变更时引发维护噩梦。
我在最近一个供应链管理系统重构中，就遇到了类似问题。系统需要处理供应商、采购单、库存商品等十余种实体，每种实体都要实现导出Excel功能。最初采用继承方式抽象通用逻辑，但随着导出格式增加（PDF、CSV等），代码迅速变得难以维护。
策略模式（Strategy Pattern）正是解决这类问题的银弹。它通过定义算法族，将每个算法封装起来，使它们可以互相替换。这种模式让算法的变化独立于使用算法的客户端，完美契合多实体通用操作的场景。
2. 策略模式核心设计解析
2.1 经典策略模式结构
标准的策略模式包含三个核心角色：
- 策略接口（Strategy Interface）：定义通用操作契约
- 具体策略（Concrete Strategies）：实现接口的具体算法
- 上下文（Context）：持有策略引用并执行
以导出功能为例，典型实现如下：
java复制// 策略接口
public interface ExportStrategy<T> {
void export(T entity);
}
// 具体策略
public class ExcelExportStrategy implements ExportStrategy<Product> {
@Override
public void export(Product product) {
// 实现Excel导出逻辑
}
}
// 上下文
public class ExportContext {
private ExportStrategy strategy;
public void setStrategy(ExportStrategy strategy) {
this.strategy = strategy;
}
public void executeExport(Object entity) {
strategy.export(entity);
}
}
2.2 多实体场景下的增强设计
经典实现需要针对不同实体创建策略子类，这可能导致类爆炸。我们可以通过泛型进行优化：
java复制public interface EntityOperationStrategy<T> {
Class<T> getEntityType();
void validate(T entity);
void persist(T entity);
String generateReport(T entity);
}
// 通用策略模板
public abstract class AbstractEntityStrategy<T> implements EntityOperationStrategy<T> {
@Override
public void validate(T entity) {
// 默认校验逻辑
}
// 抽象方法强制子类实现
protected abstract void customPersist(T entity);
}
这种设计既保证了统一的操作接口，又允许特定实体自定义关键步骤。
3. 完整实现方案与最佳实践
3.1 策略注册与工厂模式结合
实际项目中，我们需要动态获取不同实体对应的策略。推荐使用策略工厂+注册表模式：
java复制public class StrategyFactory {
private static final Map<Class<?>, EntityOperationStrategy<?>> registry = new HashMap<>();
static {
registry.put(Product.class, new ProductStrategy());
registry.put(Order.class, new OrderStrategy());
}
@SuppressWarnings("unchecked")
public static <T> EntityOperationStrategy<T> getStrategy(Class<T> entityType) {
return (EntityOperationStrategy<T>) registry.get(entityType);
}
}
3.2 基于Spring的优雅实现
在Spring环境中，可以更优雅地管理策略：
java复制// 策略接口
public interface EntityProcessor<T> {
Class<T> supports();
void process(T entity);
}
// 自动注册策略
@Service
public class ProductProcessor implements EntityProcessor<Product> {
@Override
public Class<Product> supports() {
return Product.class;
}
@Override
public void process(Product product) {
// 处理逻辑
}
}
// 策略路由器
@Service
public class EntityProcessorRouter {
private final List<EntityProcessor<?>> processors;
@Autowired
public EntityProcessorRouter(List<EntityProcessor<?>> processors) {
this.processors = processors;
}
public void processEntity(Object entity) {
processors.stream()
.filter(p -> p.supports().equals(entity.getClass()))
.findFirst()
.ifPresent(p -> ((EntityProcessor<Object>)p).process(entity));
}
}
3.3 性能优化技巧
- 策略缓存：频繁创建策略实例会影响性能，建议缓存策略对象
- 预编译校验：在应用启动时检查所有实体类都有对应策略
- 并行处理：对批量实体操作使用并行流提升效率
java复制// 并行处理示例
public void batchProcess(List<?> entities) {
entities.parallelStream()
.forEach(entityProcessorRouter::processEntity);
}
4. 实战中的典型问题与解决方案
4.1 策略选择冲突
当多个策略匹配同一实体时，可以采用优先级机制：
java复制public interface PriorityStrategy {
int getPriority();
}
// 在路由器中添加选择逻辑
.processors.stream()
.filter(p -> p.supports().equals(entity.getClass()))
.min(Comparator.comparingInt(p ->
p instanceof PriorityStrategy ?
((PriorityStrategy)p).getPriority() : Integer.MAX_VALUE
))
4.2 上下文信息传递
策略执行常需要额外上下文参数，推荐两种方案：
- 线程局部变量：适合Web请求上下文
- 策略执行上下文对象：
java复制public class StrategyContext {
private User operator;
private Locale locale;
// 其他上下文字段
}
public interface ContextAwareStrategy<T> {
void execute(T entity, StrategyContext context);
}
4.3 复合策略场景
对于需要组合多个策略的场景，可以采用责任链模式：
java复制public class ChainableStrategy<T> implements EntityOperationStrategy<T> {
private final List<EntityOperationStrategy<T>> strategies;
@Override
public void execute(T entity) {
strategies.forEach(s -> s.execute(entity));
}
}
5. 设计演进与扩展思考
5.1 策略模式与模板方法结合
对于有固定流程但步骤可变的场景，可以组合使用策略模式和模板方法：
java复制public abstract class AbstractEntityHandler<T> {
// 模板方法
public final void handle(T entity) {
preProcess(entity);
doHandle(entity);
postProcess(entity);
}
protected void preProcess(T entity) {
// 默认空实现
}
// 抽象策略方法
protected abstract void doHandle(T entity);
protected void postProcess(T entity) {
// 默认空实现
}
}
5.2 动态策略注册
对于需要运行时扩展的场景，可以实现动态策略注册：
java复制public class DynamicStrategyRegistry {
private final ConcurrentMap<Class<?>, EntityOperationStrategy<?>> registry =
new ConcurrentHashMap<>();
public <T> void registerStrategy(Class<T> type, EntityOperationStrategy<T> strategy) {
registry.put(type, strategy);
}
// 其他方法...
}
5.3 策略模式与函数式编程
Java 8+中可以使用函数接口简化策略实现：
java复制public class FunctionalStrategy {
private final Map<Class<?>, Function<?, String>> strategies = new HashMap<>();
public <T> void addStrategy(Class<T> type, Function<T, String> handler) {
strategies.put(type, handler);
}
@SuppressWarnings("unchecked")
public <T> String applyStrategy(T input) {
Function<T, String> handler = (Function<T, String>) strategies.get(input.getClass());
return handler != null ? handler.apply(input) : "default";
}
}
在实际项目中，我采用策略模式重构后的系统获得了显著改善：
- 新实体操作开发时间缩短70%
- 公共逻辑变更只需修改一处
- 单元测试覆盖率提升40%
- 系统扩展性大幅增强
这种设计特别适合中大型项目，特别是存在以下特征时：
- 多种实体需要相似操作
- 操作逻辑可能频繁变化
- 需要支持运行时灵活扩展
- 团队协作开发需要统一规范