java: Strategy Pattern
项目结构：
/**
* 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 -> 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("重试逻辑异常");
}
}
/**
* 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;
}
}
}
调用：
/**
* 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<Class<? extends IBusinessProcessStrategy>> 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 <= 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);
}
}
输出：
<?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.jewelry</groupId>
<artifactId>taskscheduler</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging>
<name>Java 任务调度系统</name>
<description>JDK21 Swing + DDD + MVC 任务调度仪表盘（近7天任务执行次数图表），演进至 Quartz/Redis/EventBus/DAG</description>
<properties>
<maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<!-- Quartz 任务调度 -->
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
<version>2.3.2</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>1.7.36</version>
</dependency>
<!-- H2 嵌入式数据库 -->
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<version>2.2.224</version>
</dependency>
<!-- Guava EventBus 领域事件总线 -->
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>33.0.0-jre</version>
</dependency>
<!-- Redis 客户端（分布式锁/心跳，可选） -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>4.4.3</version>
</dependency>
<!-- Jackson JSON（DAG 节点/任务导入导出） -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.17.1</version>
</dependency>
</dependencies>
<build>
<sourceDirectory>src</sourceDirectory>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>3.1.1</version>
<configuration>
<mainClass>com.jewelry.taskscheduler.Application</mainClass>
</configuration>
</plugin>
<!-- 打包可运行 fat-jar -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.5.1</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<transformers>
<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
<mainClass>com.jewelry.taskscheduler.Application</mainClass>
</transformer>
<transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
</transformers>
<filters>
<filter>
<artifact>*:*</artifact>
<excludes>
<exclude>META-INF/*.SF</exclude>
<exclude>META-INF/*.DSA</exclude>
<exclude>META-INF/*.RSA</exclude>
</excludes>
</filter>
</filters>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
哲学管理(学)人生, 文学艺术生活, 自动(计算机学)物理(学)工作, 生物(学)化学逆境, 历史(学)测绘(学)时间, 经济(学)数学金钱(理财), 心理(学)医学情绪, 诗词美容情感, 美学建筑(学)家园, 解构建构(分析)整合学习, 智商情商(IQ、EQ)运筹(学)生存.---Geovin Du(涂聚文）
浙公网安备 33010602011771号