java: Strategy Pattern

geovindu2026-09-12 10:08

1. 引言

在复杂业务系统中，流程往往包含多个环节，且每个环节都可能发生变化。策略模式（Strategy Pattern）通过定义一组可互换的算法族，将「变化」封装起来，使业务逻辑更加清晰、易于扩展。本文以珠宝全业务流程为例，结合依赖注入（DI）容器、日志抽象、重试熔断等机制，演示如何用 Java 21 构建一个高并发、可维护的业务流程调度系统。

2. 项目结构

项目采用分层设计，核心模块包括：

  • common.di：轻量级依赖注入容器，对应 C# 的 ServiceCollection / ServiceProvider。
  • common.logger：日志抽象层，支持控制台与文件两种输出，格式统一。
  • common.resilience：弹性组件，包含重试适配器与熔断器。
  • domain.dto：业务上下文 DTO，贯穿整个业务流程。
  • domain.strategy：策略接口与策略执行上下文。
  • business：具体业务策略实现，覆盖采购、设计、生产、质检、物流等环节。
  • scheduler：业务流程调度器，基于线程池实现高并发订单处理。

3. 依赖注入容器实现

DI 容器是整个系统的基础，负责服务的注册与解析。这里实现了一个轻量级容器，支持瞬时（Transient）与单例（Singleton）两种生命周期。

3.1 服务集合 ServiceCollection

ServiceCollection 负责收集服务描述符，并在构建时生成 ServiceProvider。

3.2 服务描述符 ServiceDescriptor

ServiceDescriptor 保存服务的类型信息与生命周期，是注册信息的载体。

3.3 服务提供者 ServiceProvider

ServiceProvider 负责根据描述符创建实例，支持构造函数注入，并使用 ConcurrentHashMap 保证单例的线程安全。

4. 日志抽象层

日志模块通过接口与提供器模式解耦，支持控制台与文件两种输出方式，且格式完全一致，便于统一排查问题。

4.1 日志接口 ILogger 与提供器接口 ILoggerProvider

4.2 控制台日志提供器 ConsoleLoggerProvider

4.3 文件日志提供器 FileLoggerProvider

文件日志按日期创建目录，每个日志等级独立文件，并使用 ReentrantLock 保证多线程写入安全。

5. 日志等级与日志工厂

日志等级枚举 LogLevel 定义了 Debug、Info、Warn、Error 四个级别，日志工厂 LoggerFactory 负责统一创建 ILogger 实例，并支持向容器注册。

5.1 日志等级 LogLevel

5.2 日志工厂 LoggerFactory

6. 弹性组件：重试与熔断

弹性组件位于 common.resilience 包，包含重试适配器 RetryAdapter 与熔断器 CircuitBreaker，用于提升系统在高并发、不稳定环境下的健壮性。

6.1 重试适配器 RetryAdapter

6.2 熔断器 CircuitBreaker

7. 策略模式核心实现

策略模式是本文的核心，通过定义统一的策略接口与执行上下文，将采购、设计、生产、质检、物流等业务环节封装为可互换的策略实现。

7.1 策略接口 IBusinessStrategy

7.2 策略执行上下文 StrategyContext

7.3 业务上下文 BusinessContext

8. 具体业务策略实现

以下策略类位于 business 包，分别对应珠宝业务流程中的采购、设计、生产、质检、物流等环节，每个策略都实现了 IBusinessStrategy 接口。

8.1 采购策略 PurchaseStrategy

8.2 设计策略 DesignStrategy

8.3 生产策略 ProduceStrategy

8.4 质检策略 QualityCheckStrategy

8.5 物流策略 LogisticsStrategy

9. 业务流程调度器

调度器基于线程池实现高并发订单处理，按顺序执行珠宝全业务流程，并支持重试熔断保护与优雅关闭。

9.1 调度器实现 BusinessFlowScheduler

10. 调用与输出

通过 StrategyBll 演示完整调用流程：初始化日志工厂、注册 DI 服务、构建重试熔断组件、定义业务执行顺序、提交多笔订单并输出运行结果。

10.1 调用示例

10.2 运行输出

11. 总结

本文通过珠宝全业务流程案例，完整演示了策略模式与依赖注入、日志抽象、重试熔断等机制的整合实践，为构建高并发、可维护的业务系统提供了可复用的参考。

项目结构：

java 复制代码 
/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：Strategy Pattern 行为模式 Behavioral Patterns
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 21
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
 * # OS        : window10
 * Datetime  : 2026 - 2026/9/11 - 21:31
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : ServiceCollection.java
 * explain   : 学习  类
 **/
package StrategyPattern.common.di;
import java.util.ArrayList;
import java.util.List;
/**
服务集合，用于注册所有依赖，构建DI容器，对应C# ServiceCollection
*/
public class ServiceCollection {
private final List<ServiceDescriptor> descriptors = new ArrayList<>();
/**
添加瞬时服务
@param serviceType 接口类型
@param implType 实现类
*/
public void addTransient(Class<?> serviceType, Class<?> implType) {
descriptors.add(ServiceDescriptor.transientService(serviceType, implType));
}
/**
添加单例服务
@param serviceType 接口
@param instance 实例对象
*/
public void addSingleton(Class<?> serviceType, Object instance) {
descriptors.add(ServiceDescriptor.singletonService(serviceType, instance));
}
/**
构建DI服务提供者
@return ServiceProvider
*/
public ServiceProvider buildServiceProvider() {
return new ServiceProvider(descriptors);
}
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：Strategy Pattern 行为模式 Behavioral Patterns
Author    : geovindu,Geovin Du 涂聚文.
IDE       : IntelliJ IDEA 2024.3.6 Java 21
database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS        : window10
Datetime  : 2026 - 2026/9/11 - 21:31
User      : geovindu
Product   : IntelliJ IDEA
Project   : javadesginpattern
File      : ServiceDescriptor.java
explain   : 学习  类
**/
package StrategyPattern.common.di;
/**
服务描述符：保存DI注册的服务类型、实现类型、生命周期
/
public class ServiceDescriptor {
/*
服务抽象类型（接口）
/
private final Class<?> serviceType;
/*
服务实现类型
/
private final Class<?> implementationType;
/*
单例实例，如果是Singleton则保存
/
private Object singletonInstance;
/*
生命周期：Singleton / Transient
*/
private final ServiceLifetime lifetime;
/**
服务生命周期枚举
/
public enum ServiceLifetime {
/*
单例：全局唯一
/
Singleton,
/*
瞬时：每次获取新建对象
*/
Transient
}
private ServiceDescriptor(Class<?> serviceType, Class<?> implementationType, ServiceLifetime lifetime) {
this.serviceType = serviceType;
this.implementationType = implementationType;
this.lifetime = lifetime;
}
/**
注册瞬时服务
*/
public static ServiceDescriptor transientService(Class<?> serviceType, Class<?> implType) {
return new ServiceDescriptor(serviceType, implType, ServiceLifetime.Transient);
}
/**
注册单例服务
*/
public static ServiceDescriptor singletonService(Class<?> serviceType, Object instance) {
ServiceDescriptor desc = new ServiceDescriptor(serviceType, instance.getClass(), ServiceLifetime.Singleton);
desc.singletonInstance = instance;
return desc;
}
public Class<?> getServiceType() {
return serviceType;
}
public Class<?> getImplementationType() {
return implementationType;
}
public Object getSingletonInstance() {
return singletonInstance;
}
public ServiceLifetime getLifetime() {
return lifetime;
}
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：Strategy Pattern 行为模式 Behavioral Patterns
Author    : geovindu,Geovin Du 涂聚文.
IDE       : IntelliJ IDEA 2024.3.6 Java 21
database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS        : window10
Datetime  : 2026 - 2026/9/11 - 21:32
User      : geovindu
Product   : IntelliJ IDEA
Project   : javadesginpattern
File      : ServiceProvider.java
explain   : 学习  类
**/
package StrategyPattern.common.di;
import StrategyPattern.common.logger.ILogger;
import StrategyPattern.common.logger.LoggerFactory;
import java.lang.reflect.Constructor;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
/**
DI服务提供者，线程安全，支持构造函数注入
*/
public class ServiceProvider {
private final List<ServiceDescriptor> descriptors;
private final ConcurrentHashMap<Class<?>, Object> singletonCache = new ConcurrentHashMap<>();
public ServiceProvider(List<ServiceDescriptor> descriptors) {
this.descriptors = descriptors;
}
/**
获取服务实例
@param clazz 服务类型
@return 实例对象
*/
@SuppressWarnings("unchecked")
public <T> T getService(Class<T> clazz) {
for (ServiceDescriptor desc : descriptors) {
boolean matched = desc.getServiceType().equals(clazz) || desc.getImplementationType().equals(clazz);
if (!matched) continue;
 if (desc.getLifetime() == ServiceDescriptor.ServiceLifetime.Singleton) {
     return (T) singletonCache.computeIfAbsent(clazz, k -&gt; desc.getSingletonInstance());
 } else {
     try {
         // 构造函数实例化
         return (T) createInstance(desc);
     } catch (Exception e) {
         throw new RuntimeException("DI创建实例失败:" + clazz.getName(), e);
     }
 }
}
throw new RuntimeException("未注册服务：" + clazz.getName());
}
/**
创建实例：优先使用ILogger构造函数注入，否则回退无参构造
@param desc 服务描述符
@return 实例对象
*/
private Object createInstance(ServiceDescriptor desc) throws Exception {
Class<?> implType = desc.getImplementationType();
for (Constructor<?> ctor : implType.getDeclaredConstructors()) {
if (ctor.getParameterCount() == 1
&& ctor.getParameterTypes()[0].equals(ILogger.class)
&& ctor.getGenericParameterTypes()[0] instanceof ParameterizedType pType) {
Type[] typeArgs = pType.getActualTypeArguments();
if (typeArgs.length == 1 && typeArgs[0] instanceof Class<?> loggerTarget) {
ILogger<?> logger = getService(LoggerFactory.class).createLogger(loggerTarget);
return ctor.newInstance(logger);
}
}
}
return implType.getDeclaredConstructor().newInstance();
}
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：Strategy Pattern 行为模式 Behavioral Patterns
Author    : geovindu,Geovin Du 涂聚文.
IDE       : IntelliJ IDEA 2024.3.6 Java 21
database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS        : window10
Datetime  : 2026 - 2026/9/11 - 21:28
User      : geovindu
Product   : IntelliJ IDEA
Project   : javadesginpattern
File      : ConsoleLoggerProvider.java
explain   : 学习  类
**/
package StrategyPattern.common.logger;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
/**
控制台日志提供器，输出到控制台，和文件日志格式保持一致
*/
public class ConsoleLoggerProvider implements ILoggerProvider {
private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
@Override
public <T> ILogger<T> createLogger(Class<T> clazz) {
return new ConsoleLogger<>(clazz);
}
/**
控制台日志实现类
@param <T> 日志类型标记
*/
public static class ConsoleLogger<T> implements ILogger<T> {
private final Class<T> targetClass;
public ConsoleLogger(Class<T> targetClass) {
this.targetClass = targetClass;
}
private void writeLog(LogLevel level, String message, Throwable ex) {
String time = LocalDateTime.now().format(FORMATTER);
String logContent = String.format("[%s] [%s] [%s] %s", time, level.name(), targetClass.getSimpleName(), message);
System.out.println(logContent);
if (ex != null) {
ex.printStackTrace(System.out);
}
}
@Override
public void logDebug(String message) {
writeLog(LogLevel.Debug, message, null);
}
@Override
public void logInfo(String message) {
writeLog(LogLevel.Info, message, null);
}
@Override
public void logWarn(String message) {
writeLog(LogLevel.Warn, message, null);
}
@Override
public void logError(String message) {
writeLog(LogLevel.Error, message, null);
}
@Override
public void logError(String message, Throwable ex) {
writeLog(LogLevel.Error, message, ex);
}
}
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：Strategy Pattern 行为模式 Behavioral Patterns
Author    : geovindu,Geovin Du 涂聚文.
IDE       : IntelliJ IDEA 2024.3.6 Java 21
database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS        : window10
Datetime  : 2026 - 2026/9/11 - 21:29
User      : geovindu
Product   : IntelliJ IDEA
Project   : javadesginpattern
File      : FileLoggerProvider.java
explain   : 学习  类
**/
package StrategyPattern.common.logger;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.locks.ReentrantLock;
/**
文件日志提供器：按日期创建文件夹Logs/yyyy-MM-dd，每个等级独立文件 app-{level}.log
多线程安全：使用ReentrantLock保证文件写入互斥，高并发不丢日志、不错乱
*/
public class FileLoggerProvider implements ILoggerProvider {
private static final DateTimeFormatter DATE_FOLDER_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd");
private static final DateTimeFormatter LOG_TIME_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
private final ReentrantLock globalLock = new ReentrantLock();
/**
获取日志文件路径
@param level 日志等级
@return 文件对象
*/
private File getLogFile(LogLevel level) {
String dateFolderName = LocalDate.now().format(DATE_FOLDER_FORMAT);
File folder = new File("Logs" + File.separator + dateFolderName);
if (!folder.exists()) {
folder.mkdirs();
}
String fileName = "app-" + level.name().toLowerCase() + ".log";
return new File(folder, fileName);
}
@Override
public <T> ILogger<T> createLogger(Class<T> clazz) {
return new FileLogger<>(clazz, this);
}
/**
文件日志实现
@param <T> 日志标记类
*/
public static class FileLogger<T> implements ILogger<T> {
private final Class<T> targetClass;
private final FileLoggerProvider provider;
public FileLogger(Class<T> targetClass, FileLoggerProvider provider) {
this.targetClass = targetClass;
this.provider = provider;
}
private void writeLog(LogLevel level, String message, Throwable ex) {
provider.globalLock.lock();
try {
File logFile = provider.getLogFile(level);
try (PrintWriter writer = new PrintWriter(new FileWriter(logFile, StandardCharsets.UTF_8, true))) {
String time = LocalDateTime.now().format(LOG_TIME_FORMAT);
String logLine = String.format("[%s] [%s] [%s] %s", time, level.name(), targetClass.getSimpleName(), message);
writer.println(logLine);
if (ex != null) {
ex.printStackTrace(writer);
}
}
} catch (IOException ioException) {
// 文件写入失败时输出到控制台兜底
System.err.println("文件日志写入异常：" + ioException.getMessage());
} finally {
provider.globalLock.unlock();
}
}
@Override
public void logDebug(String message) {
writeLog(LogLevel.Debug, message, null);
}
@Override
public void logInfo(String message) {
writeLog(LogLevel.Info, message, null);
}
@Override
public void logWarn(String message) {
writeLog(LogLevel.Warn, message, null);
}
@Override
public void logError(String message) {
writeLog(LogLevel.Error, message, null);
}
@Override
public void logError(String message, Throwable ex) {
writeLog(LogLevel.Error, message, ex);
}
}
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：Strategy Pattern 行为模式 Behavioral Patterns
Author    : geovindu,Geovin Du 涂聚文.
IDE       : IntelliJ IDEA 2024.3.6 Java 21
database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS        : window10
Datetime  : 2026 - 2026/9/11 - 21:28
User      : geovindu
Product   : IntelliJ IDEA
Project   : javadesginpattern
File      : ILogger.java
explain   : 学习  类
**/
package StrategyPattern.common.logger;
/**
日志接口，对应C# ILogger<T>
@param <T> 日志所属类，用于标记日志来源
/
public interface ILogger<T> {
/*
输出Debug日志
@param message 日志消息
*/
void logDebug(String message);
/**
输出Info日志
@param message 日志消息
*/
void logInfo(String message);
/**
输出Warn日志
@param message 日志消息
*/
void logWarn(String message);
/**
输出Error日志
@param message 日志消息
*/
void logError(String message);
/**
输出Error日志，携带异常堆栈
@param message 日志消息
@param ex 异常对象
*/
void logError(String message, Throwable ex);
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：Strategy Pattern 行为模式 Behavioral Patterns
Author    : geovindu,Geovin Du 涂聚文.
IDE       : IntelliJ IDEA 2024.3.6 Java 21
database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS        : window10
Datetime  : 2026 - 2026/9/11 - 21:28
User      : geovindu
Product   : IntelliJ IDEA
Project   : javadesginpattern
File      : ILoggerProvider.java
explain   : 学习  类
**/
package StrategyPattern.common.logger;
/**
日志提供器接口
*/
public interface ILoggerProvider {
<T> ILogger<T> createLogger(Class<T> clazz);
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：Strategy Pattern 行为模式 Behavioral Patterns
Author    : geovindu,Geovin Du 涂聚文.
IDE       : IntelliJ IDEA 2024.3.6 Java 21
database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS        : window10
Datetime  : 2026 - 2026/9/11 - 21:30
User      : geovindu
Product   : IntelliJ IDEA
Project   : javadesginpattern
File      : LoggerFactory.java
explain   : 学习  类
**/
package StrategyPattern.common.logger;
import java.util.ArrayList;
import java.util.List;
/**
日志工厂，组合多个日志Provider（控制台+文件），输出同时写入控制台+文件，格式完全一致
对应C# LoggerFactory
*/
public class LoggerFactory {
private final List<ILoggerProvider> providers = new ArrayList<>();
/**
添加日志提供器
@param provider 提供器实例
*/
public void addProvider(ILoggerProvider provider) {
providers.add(provider);
}
/**
创建组合日志对象，同时输出到所有注册Provider
@param clazz 日志所属类
@return ILogger实例
*/
public <T> ILogger<T> createLogger(Class<T> clazz) {
List<ILogger<T>> loggerList = new ArrayList<>();
for (ILoggerProvider p : providers) {
loggerList.add(p.createLogger(clazz));
}
return new CompositeLogger<>(loggerList);
}
/**
组合日志：一次调用，同时触发控制台和文件日志输出
@param <T>
*/
public static class CompositeLogger<T> implements ILogger<T> {
private final List<ILogger<T>> innerLoggers;
public CompositeLogger(List<ILogger<T>> innerLoggers) {
this.innerLoggers = innerLoggers;
}
@Override
public void logDebug(String message) {
for (ILogger<T> logger : innerLoggers) logger.logDebug(message);
}
@Override
public void logInfo(String message) {
for (ILogger<T> logger : innerLoggers) logger.logInfo(message);
}
@Override
public void logWarn(String message) {
for (ILogger<T> logger : innerLoggers) logger.logWarn(message);
}
@Override
public void logError(String message) {
for (ILogger<T> logger : innerLoggers) logger.logError(message);
}
@Override
public void logError(String message, Throwable ex) {
for (ILogger<T> logger : innerLoggers) logger.logError(message, ex);
}
}
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：Strategy Pattern 行为模式 Behavioral Patterns
Author    : geovindu,Geovin Du 涂聚文.
IDE       : IntelliJ IDEA 2024.3.6 Java 21
database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS        : window10
Datetime  : 2026 - 2026/9/11 - 21:27
User      : geovindu
Product   : IntelliJ IDEA
Project   : javadesginpattern
File      : LogLevel.java
explain   : 学习  类
**/
package StrategyPattern.common.logger;
/**
日志等级枚举，与C#版本对齐
/
public enum LogLevel {
/*
调试日志：开发详细信息
/
Debug,
/*
信息日志：正常业务信息
/
Info,
/*
警告日志：非错误异常情况
/
Warn,
/*
错误日志：程序/业务异常
*/
Error
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：Strategy Pattern 行为模式 Behavioral Patterns
Author    : geovindu,Geovin Du 涂聚文.
IDE       : IntelliJ IDEA 2024.3.6 Java 21
database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS        : window10
Datetime  : 2026 - 2026/9/11 - 21:33
User      : geovindu
Product   : IntelliJ IDEA
Project   : javadesginpattern
File      : CircuitBreaker.java
explain   : 学习  类
**/
package StrategyPattern.common.resilience;
import StrategyPattern.common.logger.ILogger;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.ReentrantLock;
/**
熔断器组件，线程安全。失败次数达到阈值熔断，冷却时间后进入半开尝试
*/
public class CircuitBreaker {
private final ILogger<CircuitBreaker> logger;
private final int failureThreshold;
private final long resetTimeoutMs;
private final AtomicInteger failureCount = new AtomicInteger(0);
private final AtomicLong lastFailureTime = new AtomicLong(0);
private CircuitBreakerState state = CircuitBreakerState.Closed;
private final ReentrantLock stateLock = new ReentrantLock();
/**
构造熔断器
@param logger 日志
@param failureThreshold 失败阈值
@param resetTimeoutMs 熔断冷却时间毫秒
*/
public CircuitBreaker(ILogger<CircuitBreaker> logger, int failureThreshold, long resetTimeoutMs) {
this.logger = logger;
this.failureThreshold = failureThreshold;
this.resetTimeoutMs = resetTimeoutMs;
}
/**
判断是否允许执行
@return true允许执行；false熔断
*/
public boolean canExecute() {
stateLock.lock();
try {
long now = System.currentTimeMillis();
if (state == CircuitBreakerState.Open) {
if (now - lastFailureTime.get() > resetTimeoutMs) {
state = CircuitBreakerState.HalfOpen;
logger.logWarn("熔断器进入半开状态，尝试恢复业务调用");
return true;
}
return false;
}
return true;
} finally {
stateLock.unlock();
}
}
/**
标记调用成功
*/
public void markSuccess() {
stateLock.lock();
try {
if (state == CircuitBreakerState.HalfOpen) {
state = CircuitBreakerState.Closed;
failureCount.set(0);
logger.logInfo("熔断器恢复关闭状态，业务正常");
}
} finally {
stateLock.unlock();
}
}
/**
标记调用失败
*/
public void markFailure() {
stateLock.lock();
try {
failureCount.incrementAndGet();
lastFailureTime.set(System.currentTimeMillis());
if (state == CircuitBreakerState.HalfOpen || failureCount.get() >= failureThreshold) {
state = CircuitBreakerState.Open;
logger.logError("熔断器触发打开状态，阈值：" + failureThreshold);
}
} finally {
stateLock.unlock();
}
}
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：Strategy Pattern 行为模式 Behavioral Patterns
Author    : geovindu,Geovin Du 涂聚文.
IDE       : IntelliJ IDEA 2024.3.6 Java 21
database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS        : window10
Datetime  : 2026 - 2026/9/11 - 21:32
User      : geovindu
Product   : IntelliJ IDEA
Project   : javadesginpattern
File      : CircuitBreakerState.java
explain   : 学习  类
**/
package StrategyPattern.common.resilience;
/**
熔断器状态枚举
/
public enum CircuitBreakerState {
/*
关闭状态：正常调用
/
Closed,
/*
打开状态：直接熔断，拒绝请求
/
Open,
/*
半开状态：尝试少量请求恢复
*/
HalfOpen
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：Strategy Pattern 行为模式 Behavioral Patterns
Author    : geovindu,Geovin Du 涂聚文.
IDE       : IntelliJ IDEA 2024.3.6 Java 21
database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS        : window10
Datetime  : 2026 - 2026/9/11 - 21:33
User      : geovindu
Product   : IntelliJ IDEA
Project   : javadesginpattern
File      : RetryAdapter.java
explain   : 学习  类
**/
package StrategyPattern.common.resilience;
import StrategyPattern.common.logger.ILogger;
import java.util.function.Supplier;
/**
重试适配器，结合熔断器，业务方法重试调用
*/
public class RetryAdapter {
private final ILogger<RetryAdapter> logger;
private final int retryTimes;
private final long sleepMs;
private final CircuitBreaker circuitBreaker;
/**
构造重试适配器
@param logger 日志对象
@param retryTimes 最大重试次数
@param sleepMs 重试间隔毫秒
@param circuitBreaker 熔断器实例
*/
public RetryAdapter(ILogger<RetryAdapter> logger, int retryTimes, long sleepMs, CircuitBreaker circuitBreaker) {
this.logger = logger;
this.retryTimes = retryTimes;
this.sleepMs = sleepMs;
this.circuitBreaker = circuitBreaker;
}
/**
执行带重试+熔断保护的业务方法
@param action 业务执行函数
@return 返回业务结果
@throws Exception 超过重试次数抛出异常
*/
public <T> T executeWithRetry(Supplier<T> action) throws Exception {
int attempt = 0;
while (attempt <= retryTimes) {
if (!circuitBreaker.canExecute()) {
throw new RuntimeException("熔断器打开，拒绝执行业务");
}
try {
T result = action.get();
circuitBreaker.markSuccess();
return result;
} catch (Exception ex) {
attempt++;
circuitBreaker.markFailure();
if (attempt > retryTimes) {
logger.logError("重试已用尽，业务执行失败", ex);
throw ex;
}
logger.logWarn("业务调用失败，准备第" + attempt + "次重试，等待" + sleepMs + "ms");
Thread.sleep(sleepMs);
}
}
throw new RuntimeException("重试逻辑异常");
}
}
java 复制代码 
/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：Strategy Pattern 行为模式 Behavioral Patterns
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 21
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
 * # OS        : window10
 * Datetime  : 2026 - 2026/9/11 - 21:34
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : JewelryBusinessContext.java
 * explain   : 学习  类
 **/
 
package StrategyPattern.domain.dto;
 
/**
 * 珠宝业务上下文DTO，贯穿全业务流程，传递业务数据
 */
public class JewelryBusinessContext {
    /**
     * 业务单号
     */
    private String businessNo;
    /**
     * 珠宝原料编码
     */
    private String rawMaterialCode;
    /**
     * 产品款式编号
     */
    private String styleCode;
    /**
     * 当前业务阶段名称
     */
    private String currentProcess;
    /**
     * 是否业务处理成功
     */
    private boolean isSuccess;
    /**
     * 消息备注
     */
    private String message;
 
    public String getBusinessNo() {
        return businessNo;
    }
 
    public void setBusinessNo(String businessNo) {
        this.businessNo = businessNo;
    }
 
    public String getRawMaterialCode() {
        return rawMaterialCode;
    }
 
    public void setRawMaterialCode(String rawMaterialCode) {
        this.rawMaterialCode = rawMaterialCode;
    }
 
    public String getStyleCode() {
        return styleCode;
    }
 
    public void setStyleCode(String styleCode) {
        this.styleCode = styleCode;
    }
 
    public String getCurrentProcess() {
        return currentProcess;
    }
 
    public void setCurrentProcess(String currentProcess) {
        this.currentProcess = currentProcess;
    }
 
    public boolean isSuccess() {
        return isSuccess;
    }
 
    public void setSuccess(boolean success) {
        isSuccess = success;
    }
 
    public String getMessage() {
        return message;
    }
 
    public void setMessage(String message) {
        this.message = message;
    }
}
 
/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：Strategy Pattern 行为模式 Behavioral Patterns
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 21
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
 * # OS        : window10
 * Datetime  : 2026 - 2026/9/11 - 21:36
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : BusinessProcessContext.java
 * explain   : 学习  类
 **/
 
package StrategyPattern.domain.strategy;
 
import StrategyPattern.domain.dto.JewelryBusinessContext;
 
/**
 * 策略上下文，持有策略实例，调用策略执行方法
 */
public class BusinessProcessContext {
    private IBusinessProcessStrategy strategy;
 
    /**
     * 设置当前业务策略
     * @param strategy 业务策略
     */
    public void setStrategy(IBusinessProcessStrategy strategy) {
        this.strategy = strategy;
    }
 
    /**
     * 执行当前策略
     * @param context 业务DTO上下文
     */
    public void runStrategy(JewelryBusinessContext context) {
        if (strategy == null) {
            throw new RuntimeException("未设置业务策略");
        }
        strategy.execute(context);
    }
}
 
/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：Strategy Pattern 行为模式 Behavioral Patterns
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 21
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
 * # OS        : window10
 * Datetime  : 2026 - 2026/9/11 - 21:34
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : IBusinessProcessStrategy.java
 * explain   : 学习  类
 **/
 
package StrategyPattern.domain.strategy;
 
import StrategyPattern.domain.dto.JewelryBusinessContext;
 
 
 
/**
 * 业务流程策略接口，策略模式顶层接口，对应C# IStrategy
 * 每个业务环节实现这个接口：采购、设计、加工、质检等
 */
public interface IBusinessProcessStrategy {
    /**
     * 获取策略名称（业务环节名称）
     * @return 环节名称
     */
    String getProcessName();
 
    /**
     * 执行业务流程
     * @param context 业务上下文DTO
     */
    void execute(JewelryBusinessContext context);
}
 
/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：Strategy Pattern 行为模式 Behavioral Patterns
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 21
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
 * # OS        : window10
 * Datetime  : 2026 - 2026/9/11 - 21:41
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : BusinessStrategy.java
 * explain   : 学习  类
 **/
 
package StrategyPattern.business;
 
import StrategyPattern.domain.dto.JewelryBusinessContext;
import StrategyPattern.domain.strategy.IBusinessProcessStrategy;
import StrategyPattern.common.logger.ILogger;
 
 
/**
 * 业务策略：业务环节9，订单洽谈、客户跟进、售前售后
 */
public class BusinessStrategy implements IBusinessProcessStrategy {
    private final ILogger<BusinessStrategy> logger;
 
    /**
     * 构造函数注入日志对象
     * @param logger 日志实例
     */
    public BusinessStrategy(ILogger<BusinessStrategy> logger) {
        this.logger = logger;
    }
 
    @Override
    public String getProcessName() {
        return "业务";
    }
 
    @Override
    public void execute(JewelryBusinessContext context) {
        logger.logInfo("开始执行业务环节：业务，单号：" + context.getBusinessNo());
        context.setCurrentProcess(getProcessName());
 
        context.setSuccess(true);
        context.setMessage("客户订单洽谈完成，创建业务单号：" + context.getBusinessNo());
        logger.logInfo(context.getMessage());
    }
}
 
/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：Strategy Pattern 行为模式 Behavioral Patterns
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 21
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
 * # OS        : window10
 * Datetime  : 2026 - 2026/9/11 - 21:37
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : DesignDraftStrategy.java
 * explain   : 学习  类
 **/
 
package StrategyPattern.business;
 
import StrategyPattern.domain.dto.JewelryBusinessContext;
import StrategyPattern.domain.strategy.IBusinessProcessStrategy;
import StrategyPattern.common.logger.ILogger;
 
/**
 * 设计制图策略：业务环节2，珠宝款式CAD/3D制图
 */
public class DesignDraftStrategy implements IBusinessProcessStrategy {
    private final ILogger<DesignDraftStrategy> logger;
 
    public DesignDraftStrategy(ILogger<DesignDraftStrategy> logger) {
        this.logger = logger;
    }
 
    @Override
    public String getProcessName() {
        return "设计制图";
    }
 
    @Override
    public void execute(JewelryBusinessContext context) {
        logger.logInfo("开始执行业务环节：设计制图，单号：" + context.getBusinessNo());
        context.setCurrentProcess(getProcessName());
        context.setSuccess(true);
        context.setMessage("款式设计制图完成，款式编号：" + context.getStyleCode());
        logger.logInfo(context.getMessage());
    }
}
 
/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：Strategy Pattern 行为模式 Behavioral Patterns
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 21
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
 * # OS        : window10
 * Datetime  : 2026 - 2026/9/11 - 21:40
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : FinanceStrategy.java
 * explain   : 学习  类
 **/
 
package StrategyPattern.business;
 
import StrategyPattern.domain.dto.JewelryBusinessContext;
import StrategyPattern.domain.strategy.IBusinessProcessStrategy;
import StrategyPattern.common.logger.ILogger;
 
 
/**
 * 财务策略：业务环节7，成本核算、开票、应收应付记账
 */
public class FinanceStrategy implements IBusinessProcessStrategy {
    private final ILogger<FinanceStrategy> logger;
 
    /**
     * 构造函数注入日志对象
     * @param logger 日志实例
     */
    public FinanceStrategy(ILogger<FinanceStrategy> logger) {
        this.logger = logger;
    }
 
    @Override
    public String getProcessName() {
        return "财务";
    }
 
    @Override
    public void execute(JewelryBusinessContext context) {
        logger.logInfo("开始执行业务环节：财务，单号：" + context.getBusinessNo());
        context.setCurrentProcess(getProcessName());
 
        if (context.isSuccess()) {
            context.setSuccess(true);
            context.setMessage("订单财务核算完成，已生成应收账单");
            logger.logInfo(context.getMessage());
        } else {
            context.setSuccess(false);
            context.setMessage("业务流程异常，财务记账暂停");
            logger.logError(context.getMessage());
        }
    }
}
 
/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：Strategy Pattern 行为模式 Behavioral Patterns
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 21
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
 * # OS        : window10
 * Datetime  : 2026 - 2026/9/11 - 21:41
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : HrAdminStrategy.java
 * explain   : 学习  类
 **/
 
package StrategyPattern.business;
 
import StrategyPattern.domain.dto.JewelryBusinessContext;
import StrategyPattern.domain.strategy.IBusinessProcessStrategy;
import StrategyPattern.common.logger.ILogger;
 
/**
 * 人事行政策略：业务环节10，人员排班、考勤、行政后勤
 */
public class HrAdminStrategy implements IBusinessProcessStrategy {
    private final ILogger<HrAdminStrategy> logger;
 
    /**
     * 构造函数注入日志对象
     * @param logger 日志实例
     */
    public HrAdminStrategy(ILogger<HrAdminStrategy> logger) {
        this.logger = logger;
    }
 
    @Override
    public String getProcessName() {
        return "人事行政";
    }
 
    @Override
    public void execute(JewelryBusinessContext context) {
        logger.logInfo("开始执行业务环节：人事行政，单号：" + context.getBusinessNo());
        context.setCurrentProcess(getProcessName());
 
        context.setSuccess(true);
        context.setMessage("生产岗位排班完成，保障订单人力供给");
        logger.logInfo(context.getMessage());
    }
}
 
/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：Strategy Pattern 行为模式 Behavioral Patterns
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 21
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
 * # OS        : window10
 * Datetime  : 2026 - 2026/9/11 - 21:42
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : ItStrategy.java
 * explain   : 学习  类
 **/
 
package StrategyPattern.business;
 
 
import StrategyPattern.domain.dto.JewelryBusinessContext;
import StrategyPattern.domain.strategy.IBusinessProcessStrategy;
import StrategyPattern.common.logger.ILogger;
 
/**
 * IT策略：业务环节11，系统运维、服务器、业务系统支持
 */
public class ItStrategy implements IBusinessProcessStrategy {
    private final ILogger<ItStrategy> logger;
 
    /**
     * 构造函数注入日志对象
     * @param logger 日志实例
     */
    public ItStrategy(ILogger<ItStrategy> logger) {
        this.logger = logger;
    }
 
    @Override
    public String getProcessName() {
        return "IT";
    }
 
    @Override
    public void execute(JewelryBusinessContext context) {
        logger.logInfo("开始执行业务环节：IT，单号：" + context.getBusinessNo());
        context.setCurrentProcess(getProcessName());
 
        context.setSuccess(true);
        context.setMessage("业务系统运行正常，服务器资源监控完成");
        logger.logInfo(context.getMessage());
    }
}
 
 
/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：Strategy Pattern 行为模式 Behavioral Patterns
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 21
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
 * # OS        : window10
 * Datetime  : 2026 - 2026/9/11 - 21:40
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : LogisticsStrategy.java
 * explain   : 学习  类
 **/
 
package StrategyPattern.business;
 
import StrategyPattern.domain.dto.JewelryBusinessContext;
import StrategyPattern.domain.strategy.IBusinessProcessStrategy;
import StrategyPattern.common.logger.ILogger;
 
/**
 * 物流策略：业务环节6，珠宝保价发货、物流追踪、签收管理
 */
public class LogisticsStrategy implements IBusinessProcessStrategy {
    private final ILogger<LogisticsStrategy> logger;
 
    /**
     * 构造函数注入日志对象
     * @param logger 日志实例
     */
    public LogisticsStrategy(ILogger<LogisticsStrategy> logger) {
        this.logger = logger;
    }
 
    @Override
    public String getProcessName() {
        return "物流";
    }
 
    @Override
    public void execute(JewelryBusinessContext context) {
        logger.logInfo("开始执行业务环节：物流，单号：" + context.getBusinessNo());
        context.setCurrentProcess(getProcessName());
 
        if (context.isSuccess()) {
            context.setSuccess(true);
            context.setMessage("珠宝保价物流已出库，等待客户签收");
            logger.logInfo(context.getMessage());
        } else {
            context.setSuccess(false);
            context.setMessage("包装未完成，无法安排物流发货");
            logger.logWarn(context.getMessage());
        }
    }
}
 
/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：Strategy Pattern 行为模式 Behavioral Patterns
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 21
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
 * # OS        : window10
 * Datetime  : 2026 - 2026/9/11 - 21:40
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : MarketingStrategy.java
 * explain   : 学习  类
 **/
 
package StrategyPattern.business;
 
import StrategyPattern.domain.dto.JewelryBusinessContext;
import StrategyPattern.domain.strategy.IBusinessProcessStrategy;
import StrategyPattern.common.logger.ILogger;
 
/**
 * 营销推广策略：业务环节8，新品宣传、活动投放、客户运营
 */
public class MarketingStrategy implements IBusinessProcessStrategy {
    private final ILogger<MarketingStrategy> logger;
 
    /**
     * 构造函数注入日志对象
     * @param logger 日志实例
     */
    public MarketingStrategy(ILogger<MarketingStrategy> logger) {
        this.logger = logger;
    }
 
    @Override
    public String getProcessName() {
        return "营销推广";
    }
 
    @Override
    public void execute(JewelryBusinessContext context) {
        logger.logInfo("开始执行业务环节：营销推广，单号：" + context.getBusinessNo());
        context.setCurrentProcess(getProcessName());
 
        context.setSuccess(true);
        context.setMessage("新款珠宝营销素材已上线推广，款式编号：" + context.getStyleCode());
        logger.logInfo(context.getMessage());
    }
}
 
/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：Strategy Pattern 行为模式 Behavioral Patterns
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 21
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
 * # OS        : window10
 * Datetime  : 2026 - 2026/9/11 - 21:39
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : PackStrategy.java
 * explain   : 学习  类
 **/
 
package StrategyPattern.business;
 
import StrategyPattern.domain.dto.JewelryBusinessContext;
import StrategyPattern.domain.strategy.IBusinessProcessStrategy;
import StrategyPattern.common.logger.ILogger;
 
 
/**
 * 包装策略：业务环节5，珠宝礼盒包装、证书封装、防护处理
 */
public class PackStrategy implements IBusinessProcessStrategy {
    private final ILogger<PackStrategy> logger;
 
    /**
     * 构造函数注入日志对象
     * @param logger 日志实例
     */
    public PackStrategy(ILogger<PackStrategy> logger) {
        this.logger = logger;
    }
 
    @Override
    public String getProcessName() {
        return "包装";
    }
 
    @Override
    public void execute(JewelryBusinessContext context) {
        logger.logInfo("开始执行业务环节：包装，单号：" + context.getBusinessNo());
        context.setCurrentProcess(getProcessName());
 
        if (context.isSuccess()) {
            context.setSuccess(true);
            context.setMessage("珠宝成品包装完成，附带鉴定证书");
            logger.logInfo(context.getMessage());
        } else {
            context.setSuccess(false);
            context.setMessage("质检未通过，禁止包装");
            logger.logWarn(context.getMessage());
        }
    }
}
/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：Strategy Pattern 行为模式 Behavioral Patterns
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 21
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
 * # OS        : window10
 * Datetime  : 2026 - 2026/9/11 - 21:38
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : ProduceStrategy.java
 * explain   : 学习  类
 **/
 
package StrategyPattern.business;
 
import StrategyPattern.domain.dto.JewelryBusinessContext;
import StrategyPattern.domain.strategy.IBusinessProcessStrategy;
import StrategyPattern.common.logger.ILogger;
 
/**
 * 加工生产策略：业务环节3，珠宝毛坯加工、镶石、成型工序
 */
public class ProduceStrategy implements IBusinessProcessStrategy {
    private final ILogger<ProduceStrategy> logger;
 
    /**
     * 构造函数注入日志对象
     * @param logger 日志实例
     */
    public ProduceStrategy(ILogger<ProduceStrategy> logger) {
        this.logger = logger;
    }
 
    @Override
    public String getProcessName() {
        return "加工生产";
    }
 
    @Override
    public void execute(JewelryBusinessContext context) {
        logger.logInfo("开始执行业务环节：加工生产，单号：" + context.getBusinessNo());
        context.setCurrentProcess(getProcessName());
 
        // 模拟加工生产业务逻辑
        if (context.isSuccess()) {
            context.setSuccess(true);
            context.setMessage("珠宝加工生产工序完成，款式编号：" + context.getStyleCode());
            logger.logInfo(context.getMessage());
        } else {
            context.setSuccess(false);
            context.setMessage("前置流程失败，无法启动加工生产");
            logger.logWarn(context.getMessage());
        }
    }
}
 
/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：Strategy Pattern 行为模式 Behavioral Patterns
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 21
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
 * # OS        : window10
 * Datetime  : 2026 - 2026/9/11 - 21:37
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : PurchaseVerifyStrategy.java
 * explain   : 学习  类
 **/
 
package StrategyPattern.business;
 
import StrategyPattern.domain.dto.JewelryBusinessContext;
import StrategyPattern.domain.strategy.IBusinessProcessStrategy;
import StrategyPattern.common.logger.ILogger;
 
/**
 * 原料采购核验策略：业务环节1，珠宝原料入库前核验
 */
public class PurchaseVerifyStrategy implements IBusinessProcessStrategy {
    private final ILogger<PurchaseVerifyStrategy> logger;
 
    public PurchaseVerifyStrategy(ILogger<PurchaseVerifyStrategy> logger) {
        this.logger = logger;
    }
 
    @Override
    public String getProcessName() {
        return "原料采购核验";
    }
 
    @Override
    public void execute(JewelryBusinessContext context) {
        logger.logInfo("开始执行业务环节：原料采购核验，单号：" + context.getBusinessNo());
        context.setCurrentProcess(getProcessName());
        // 模拟原料核验逻辑
        if (context.getRawMaterialCode() != null && !context.getRawMaterialCode().isBlank()) {
            context.setSuccess(true);
            context.setMessage("原料核验通过，原料编码：" + context.getRawMaterialCode());
            logger.logInfo(context.getMessage());
        } else {
            context.setSuccess(false);
            context.setMessage("原料编码为空，采购核验失败");
            logger.logError(context.getMessage());
        }
    }
}
 
/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：Strategy Pattern 行为模式 Behavioral Patterns
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 21
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
 * # OS        : window10
 * Datetime  : 2026 - 2026/9/11 - 21:39
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : QualityCheckStrategy.java
 * explain   : 学习  类
 **/
 
package StrategyPattern.business;
import StrategyPattern.domain.dto.JewelryBusinessContext;
import StrategyPattern.domain.strategy.IBusinessProcessStrategy;
import StrategyPattern.common.logger.ILogger;
 
/**
 * 质检策略：业务环节4，成品珠宝外观、尺寸、材质质检
 */
public class QualityCheckStrategy implements IBusinessProcessStrategy {
    private final ILogger<QualityCheckStrategy> logger;
 
    /**
     * 构造函数注入日志对象
     * @param logger 日志实例
     */
    public QualityCheckStrategy(ILogger<QualityCheckStrategy> logger) {
        this.logger = logger;
    }
 
    @Override
    public String getProcessName() {
        return "质检";
    }
 
    @Override
    public void execute(JewelryBusinessContext context) {
        logger.logInfo("开始执行业务环节：质检，单号：" + context.getBusinessNo());
        context.setCurrentProcess(getProcessName());
 
        if (context.isSuccess()) {
            context.setSuccess(true);
            context.setMessage("珠宝成品质检合格，款式编号：" + context.getStyleCode());
            logger.logInfo(context.getMessage());
        } else {
            context.setSuccess(false);
            context.setMessage("前置工序异常，质检终止");
            logger.logError(context.getMessage());
        }
    }
}
 
/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：Strategy Pattern 行为模式 Behavioral Patterns
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 21
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
 * # OS        : window10
 * Datetime  : 2026 - 2026/9/11 - 21:42
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : TrainingStrategy.java
 * explain   : 学习  类
 **/
 
package StrategyPattern.business;
 
 
import StrategyPattern.domain.dto.JewelryBusinessContext;
import StrategyPattern.domain.strategy.IBusinessProcessStrategy;
import StrategyPattern.common.logger.ILogger;
 
 
/**
 * 培训策略：业务环节12，工匠技能培训、销售培训、新人培训
 */
public class TrainingStrategy implements IBusinessProcessStrategy {
    private final ILogger<TrainingStrategy> logger;
 
    /**
     * 构造函数注入日志对象
     * @param logger 日志实例
     */
    public TrainingStrategy(ILogger<TrainingStrategy> logger) {
        this.logger = logger;
    }
 
    @Override
    public String getProcessName() {
        return "培训";
    }
 
    @Override
    public void execute(JewelryBusinessContext context) {
        logger.logInfo("开始执行业务环节：培训，单号：" + context.getBusinessNo());
        context.setCurrentProcess(getProcessName());
 
        context.setSuccess(true);
        context.setMessage("珠宝工匠技能培训课程已安排完成");
        logger.logInfo(context.getMessage());
    }
}
 
/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：Strategy Pattern 行为模式 Behavioral Patterns
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 21
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
 * # OS        : window10
 * Datetime  : 2026 - 2026/9/11 - 21:43
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : BusinessFlowScheduler.java
 * explain   : 学习  类
 **/
 
package StrategyPattern.scheduler;
 
import StrategyPattern.common.di.ServiceProvider;
import StrategyPattern.common.logger.ILogger;
import StrategyPattern.common.resilience.RetryAdapter;
import StrategyPattern.domain.dto.JewelryBusinessContext;
import StrategyPattern.domain.strategy.BusinessProcessContext;
import StrategyPattern.domain.strategy.IBusinessProcessStrategy;
 
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
 
/**
 * 业务流程调度器
 * 高并发线程池调度，按顺序执行珠宝全业务流程；支持重试熔断；线程安全
 */
public class BusinessFlowScheduler {
    private final ILogger<BusinessFlowScheduler> logger;
    private final ServiceProvider serviceProvider;
    private final RetryAdapter retryAdapter;
    private final List<Class<? extends IBusinessProcessStrategy>> strategyClassList;
    /**
     * 线程池，用于高并发多订单并行处理
     */
    private final ExecutorService executorService;
    /**
     * 调度器停止标记，原子变量保证多线程安全
     */
    private final AtomicBoolean isShutdown = new AtomicBoolean(false);
 
    /**
     * 调度器构造
     * @param logger 日志实例
     * @param serviceProvider DI服务容器
     * @param retryAdapter 重试+熔断弹性组件
     * @param strategyClassList 业务策略执行顺序列表
     * @param threadPoolSize 线程池最大并发数量
     */
    public BusinessFlowScheduler(ILogger<BusinessFlowScheduler> logger,
                                 ServiceProvider serviceProvider,
                                 RetryAdapter retryAdapter,
                                 List<Class<? extends IBusinessProcessStrategy>> strategyClassList,
                                 int threadPoolSize) {
        this.logger = logger;
        this.serviceProvider = serviceProvider;
        this.retryAdapter = retryAdapter;
        this.strategyClassList = strategyClassList;
        this.executorService = Executors.newFixedThreadPool(threadPoolSize);
    }
 
    /**
     * 提交一个珠宝订单业务流程任务（异步线程执行）
     * @param businessContext 订单业务上下文DTO
     */
    public void submitBusinessTask(JewelryBusinessContext businessContext) {
        if (isShutdown.get()) {
            logger.logError("调度器已经停止，无法接收新业务任务，单号：" + businessContext.getBusinessNo());
            return;
        }
        executorService.submit(() -> runFullBusinessFlow(businessContext));
    }
 
    /**
     * 串行执行完整珠宝业务流程，每个策略带重试熔断保护
     * @param businessContext 业务上下文
     */
    private void runFullBusinessFlow(JewelryBusinessContext businessContext) {
        logger.logInfo("开始执行完整珠宝业务流程，业务单号：" + businessContext.getBusinessNo());
        BusinessProcessContext strategyContext = new BusinessProcessContext();
 
        try {
            for (Class<? extends IBusinessProcessStrategy> strategyCls : strategyClassList) {
                IBusinessProcessStrategy strategy = serviceProvider.getService(strategyCls);
                strategyContext.setStrategy(strategy);
 
                // 使用重试熔断适配器执行业务策略
                retryAdapter.executeWithRetry(() -> {
                    strategyContext.runStrategy(businessContext);
                    return true;
                });
 
                // 如果流程失败，终止后续环节
                if (!businessContext.isSuccess()) {
                    logger.logWarn("业务流程在【" + businessContext.getCurrentProcess() + "】环节失败，终止后续流程。单号："
                            + businessContext.getBusinessNo());
                    break;
                }
            }
            logger.logInfo("业务流程全部执行完成，单号：" + businessContext.getBusinessNo() + "，最终结果：" + businessContext.isSuccess());
        } catch (Exception ex) {
            logger.logError("业务流程执行全局异常，单号：" + businessContext.getBusinessNo(), ex);
        }
    }
 
    /**
     * 优雅关闭调度器，等待已有任务执行完毕
     * @param awaitSeconds 等待超时秒数
     * @return true：正常关闭；false：超时强制关闭
     */
    public boolean shutdown(long awaitSeconds) {
        if (!isShutdown.compareAndSet(false, true)) {
            logger.logWarn("调度器已经处于关闭状态");
            return true;
        }
        logger.logInfo("开始优雅关闭业务调度器，等待正在执行任务完成");
        executorService.shutdown();
        try {
            boolean terminated = executorService.awaitTermination(awaitSeconds, TimeUnit.SECONDS);
            if (terminated) {
                logger.logInfo("调度器优雅关闭成功");
            } else {
                executorService.shutdownNow();
                logger.logWarn("调度器等待超时，强制终止所有线程");
            }
            return terminated;
        } catch (InterruptedException e) {
            logger.logError("关闭调度器时线程被中断", e);
            executorService.shutdownNow();
            Thread.currentThread().interrupt();
            return false;
        }
    }
}
　　

调用：

java 复制代码 
/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：Strategy Pattern 行为模式 Behavioral Patterns
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 17
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
 * # OS        : window10
 * Datetime  : 2026 - 2026/7/5 - 11:08
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : StrategyBll.java
 * explain   : 学习  类
 **/
package BLL;
import StrategyPattern.business.*;
import StrategyPattern.common.di.ServiceCollection;
import StrategyPattern.common.di.ServiceProvider;
import StrategyPattern.common.logger.ConsoleLoggerProvider;
import StrategyPattern.common.logger.FileLoggerProvider;
import StrategyPattern.common.logger.LoggerFactory;
import StrategyPattern.common.resilience.CircuitBreaker;
import StrategyPattern.common.resilience.RetryAdapter;
import StrategyPattern.domain.dto.JewelryBusinessContext;
import StrategyPattern.domain.strategy.IBusinessProcessStrategy;
import StrategyPattern.scheduler.BusinessFlowScheduler;
import java.util.List;
import java.util.UUID;
public class StrategyBll {
public void demo()
{
    // 1. 初始化日志工厂：注册控制台日志 + 文件日志，输出格式完全一致
    LoggerFactory loggerFactory = new LoggerFactory();
    loggerFactory.addProvider(new ConsoleLoggerProvider());
    loggerFactory.addProvider(new FileLoggerProvider());

    // 2. 初始化DI容器，注册所有服务
    ServiceCollection serviceCollection = new ServiceCollection();

    // 注册日志工厂，供DI构造函数注入
    serviceCollection.addSingleton(LoggerFactory.class, loggerFactory);

    // 注册全部业务策略实现类
    serviceCollection.addTransient(IBusinessProcessStrategy.class, PurchaseVerifyStrategy.class);
    serviceCollection.addTransient(IBusinessProcessStrategy.class, DesignDraftStrategy.class);
    serviceCollection.addTransient(IBusinessProcessStrategy.class, ProduceStrategy.class);
    serviceCollection.addTransient(IBusinessProcessStrategy.class, QualityCheckStrategy.class);
    serviceCollection.addTransient(IBusinessProcessStrategy.class, PackStrategy.class);
    serviceCollection.addTransient(IBusinessProcessStrategy.class, LogisticsStrategy.class);
    serviceCollection.addTransient(IBusinessProcessStrategy.class, FinanceStrategy.class);
    serviceCollection.addTransient(IBusinessProcessStrategy.class, MarketingStrategy.class);
    serviceCollection.addTransient(IBusinessProcessStrategy.class, BusinessStrategy.class);
    serviceCollection.addTransient(IBusinessProcessStrategy.class, HrAdminStrategy.class);
    serviceCollection.addTransient(IBusinessProcessStrategy.class, ItStrategy.class);
    serviceCollection.addTransient(IBusinessProcessStrategy.class, TrainingStrategy.class);

    // 构建DI服务提供者
    ServiceProvider serviceProvider = serviceCollection.buildServiceProvider();

    // 3. 构建熔断器：失败阈值3次，熔断冷却5000毫秒
    CircuitBreaker circuitBreaker = new CircuitBreaker(loggerFactory.createLogger(CircuitBreaker.class), 3, 5000);
    // 构建重试适配器：最多重试3次，每次间隔800ms
    RetryAdapter retryAdapter = new RetryAdapter(loggerFactory.createLogger(RetryAdapter.class), 3, 800, circuitBreaker);

    // 4. 定义业务流程执行顺序（珠宝完整业务链路）
    List&lt;Class&lt;? extends IBusinessProcessStrategy&gt;&gt; processOrder = List.of(
            BusinessStrategy.class,
            PurchaseVerifyStrategy.class,
            DesignDraftStrategy.class,
            ProduceStrategy.class,
            QualityCheckStrategy.class,
            PackStrategy.class,
            LogisticsStrategy.class,
            FinanceStrategy.class,
            MarketingStrategy.class,
            HrAdminStrategy.class,
            ItStrategy.class,
            TrainingStrategy.class
    );

    // 5. 创建业务调度器，线程池并发数4
    BusinessFlowScheduler scheduler = new BusinessFlowScheduler(
            loggerFactory.createLogger(BusinessFlowScheduler.class),
            serviceProvider,
            retryAdapter,
            processOrder,
            4
    );

    // 6. 模拟提交多笔珠宝订单，高并发测试
    for (int i = 1; i &lt;= 3; i++) {
        JewelryBusinessContext orderContext = new JewelryBusinessContext();
        orderContext.setBusinessNo("JEW-" + UUID.randomUUID());
        orderContext.setRawMaterialCode("GOLD-999-" + i);
        orderContext.setStyleCode("STYLE-00" + i);
        scheduler.submitBusinessTask(orderContext);
    }

    // 7. 等待业务任务执行完毕，关闭调度器
    try {
        Thread.sleep(6000);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    scheduler.shutdown(5);
}
}

输出：

相关推荐
garmin Chen1 小时前
MySQL精简面试题
数据库·后端·mysql·面试
中趴菜1 小时前
robots.txt 规则误拦排查实战指南
后端
念越1 小时前
Python基础语法（一）：变量、类型与程序控制流
开发语言·网络·python
yimindev1 小时前
从 BI 到 Agent：我如何用 Java 打造一个轻量级数据库语义网关 DatI
java
计算机毕设定制辅导-无忧学长1 小时前
《基于SpringBoot的家政服务管理平台的设计与实现》
java·vue.js·spring boot·计算机毕业设计选题推荐·家政服务管理平台
落木萧萧8251 小时前
Wrapper、Criteria、Specification：查询能不能写得好维护一点
数据库·后端·架构
秋饼1 小时前
Spring AI 2.0 企业级文档ETL实战：从 DocumentReader 到 EmbeddingStore 的完整知识库数据管道
java·ai·技术分享·后端开发
步行cgn1 小时前
构造注入详解：Spring 依赖注入的首选方式
后端
吃饱了得干活1 小时前
Spring Boot + Redis 分布式锁：一个订单重复提交引发的六次迭代
java·redis·后端
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接03历年考研数学一、数学二、数学三真题试卷及答案PDF04GitHub 镜像站点05如何新建文件夹？ 电脑新建文件夹的4种方法06微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新07【一等奖版】2026 国赛 A题 药材的烘干问题082026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？09ZCode 周末送额度活动开启：3 亿 Token 免费领取10Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费