项目结构：
java
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述： 行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:18
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : AppSettings.java
* explain : 学习 类
**/
package ChainofResponsibility.configuration;
/**
* 全局配置根实体，对标C# AppSettings.cs
* 映射appsettings.json配置节点
*/
public class AppSettings {
/** 应用配置节点 */
private AppNode App;
public AppNode getApp() {
return App;
}
public void setApp(AppNode app) {
App = app;
}
/** 应用子节点配置 */
public static class AppNode {
/** 服务名称 */
private String ServiceName;
/** 日志根目录 */
private String LogBasePath;
/** 日志保留天数 */
private int LogRetentionDay;
/** OpenTelemetry链路追踪配置 */
private OpenTelemetryConfig OpenTelemetry;
public String getServiceName() {
return ServiceName;
}
public void setServiceName(String serviceName) {
ServiceName = serviceName;
}
public String getLogBasePath() {
return LogBasePath;
}
public void setLogBasePath(String logBasePath) {
LogBasePath = logBasePath;
}
public int getLogRetentionDay() {
return LogRetentionDay;
}
public void setLogRetentionDay(int logRetentionDay) {
LogRetentionDay = logRetentionDay;
}
public OpenTelemetryConfig getOpenTelemetry() {
return OpenTelemetry;
}
public void setOpenTelemetry(OpenTelemetryConfig openTelemetry) {
OpenTelemetry = openTelemetry;
}
}
/** OpenTelemetry 链路追踪配置 */
public static class OpenTelemetryConfig {
/** 服务名称 */
private String ServiceName;
/** OTLP Collector地址 */
private String OtlpEndpoint;
/** 是否启用OTLP导出 */
private boolean EnableOtlpExporter;
public String getServiceName() {
return ServiceName;
}
public void setServiceName(String serviceName) {
ServiceName = serviceName;
}
public String getOtlpEndpoint() {
return OtlpEndpoint;
}
public void setOtlpEndpoint(String otlpEndpoint) {
OtlpEndpoint = otlpEndpoint;
}
public boolean isEnableOtlpExporter() {
return EnableOtlpExporter;
}
public void setEnableOtlpExporter(boolean enableOtlpExporter) {
EnableOtlpExporter = enableOtlpExporter;
}
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述： 行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:19
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : AppSettingsBinderExtension.java
* explain : 学习 类
**/
package ChainofResponsibility.configuration;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.File;
/**
* JSON配置绑定扩展类，对标C# AppSettingsBinderExtension.cs
* 读取本地json文件，自动映射到实体类
*/
public class AppSettingsBinderExtension {
/**
* 将json文件绑定为配置实体
* @param jsonFile json配置文件
* @param clazz 目标实体Class
* @return 填充后的配置对象
*/
public static <T> T Bind(File jsonFile, Class<T> clazz) {
try {
ObjectMapper mapper = new ObjectMapper();
return mapper.readValue(jsonFile, clazz);
} catch (Exception e) {
throw new RuntimeException("读取appsettings.json配置失败", e);
}
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:48
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : ServiceCollectionExtensions.java
* explain : 学习 类
**/
package ChainofResponsibility.extensions;
import ChainofResponsibility.scheduler.IProcessScheduler;
import ChainofResponsibility.scheduler.JewelryProcessScheduler;
/**
* 服务注册扩展类，对标C# ServiceCollectionExtensions.cs
* 提供静态工厂方法创建所有业务服务（替代Spring容器）
*/
public class ServiceCollectionExtensions {
/**
* 创建调度器实例
* @return IProcessScheduler实例
*/
public static IProcessScheduler createScheduler() {
return new JewelryProcessScheduler();
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:19
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : CustomConsoleFormatter.java
* explain : 学习 类
**/
package ChainofResponsibility.logging;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.LayoutBase;
import java.time.Instant;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
/**
* 自定义控制台日志格式化器，对标C# CustomConsoleFormatter.cs
* 使用Layout方式实现，兼容Logback 1.4.x版本
*/
public class CustomConsoleFormatter extends LayoutBase<ILoggingEvent> {
private static final DateTimeFormatter FORMATTER =
DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")
.withZone(ZoneId.systemDefault());
@Override
public String doLayout(ILoggingEvent event) {
String timestamp = FORMATTER.format(Instant.ofEpochMilli(event.getTimeStamp()));
return String.format("[%s] [%s] %s - %s%n",
timestamp,
event.getLevel(),
event.getLoggerName(),
event.getFormattedMessage());
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:20
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : FileLoggerCustomFormatter.java
* explain : 学习 类
**/
package ChainofResponsibility.logging;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.LayoutBase;
import java.time.Instant;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
/**
* 文件日志自定义格式化器，对标C# FileLoggerCustomFormatter.cs
* 使用Layout方式实现，兼容Logback 1.4.x版本
*/
public class FileLoggerCustomFormatter extends LayoutBase<ILoggingEvent> {
private static final DateTimeFormatter FORMATTER =
DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")
.withZone(ZoneId.systemDefault());
@Override
public String doLayout(ILoggingEvent event) {
String timestamp = FORMATTER.format(Instant.ofEpochMilli(event.getTimeStamp()));
return String.format("[%s] [%s] %s | %s%n",
timestamp,
event.getLevel(),
event.getLoggerName(),
event.getFormattedMessage());
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:20
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : LoggingBuilderExtensions.java
* explain : 学习 类
**/
package ChainofResponsibility.logging;
import ChainofResponsibility.configuration.AppSettings;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 日志配置扩展方法，对标C# LoggingBuilderExtensions.cs
*/
public class LoggingBuilderExtensions {
private static final Logger log = LoggerFactory.getLogger(LoggingBuilderExtensions.class);
/**
* 初始化全局日志配置
* @param settings 应用配置
*/
public static void ConfigureLogging(AppSettings settings) {
log.info("加载日志配置，日志目录：{}", settings.getApp().getLogBasePath());
// 实际格式化绑定逻辑由logback.xml完成，此处预留扩展入口
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:47
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : IProcessScheduler.java
* explain : 学习 类
**/
package ChainofResponsibility.scheduler;
import ChainofResponsibility.chain.abstractions.IBusinessHandler;
/**
* 流程调度器接口，对标C# IProcessScheduler.cs
* 负责组装责任链、启动业务流程
*/
public interface IProcessScheduler {
/**
* 组装完整责任链
* @return 链路入口Handler
*/
IBusinessHandler buildCompleteChain();
/**
* 执行正常完整业务流程
*/
void runFullNormalProcess();
/**
* 执行测试失败流程（模拟原料缺失）
*/
void runFailedPurchaseTestProcess();
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:47
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : JewelryProcessScheduler.java
* explain : 学习 类
**/
package ChainofResponsibility.scheduler;
import ChainofResponsibility.chain.abstractions.IBusinessHandler;
import ChainofResponsibility.chain.abstractions.JewelryBusinessContext;
import ChainofResponsibility.chain.handlers.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 业务流程调度实现类，对标C# JewelryProcessScheduler.cs
* 组装完整责任链，提供测试入口
*/
public class JewelryProcessScheduler implements IProcessScheduler {
private static final Logger log = LoggerFactory.getLogger(JewelryProcessScheduler.class);
private final MaterialPurchaseHandler materialPurchaseHandler;
private final DesignDrawHandler designDrawHandler;
private final ProduceHandler produceHandler;
private final QualityCheckHandler qualityCheckHandler;
private final PackageHandler packageHandler;
private final LogisticsHandler logisticsHandler;
private final FinanceHandler financeHandler;
private final MarketingHandler marketingHandler;
private final BusinessHandler businessHandler;
private final HrAdminHandler hrAdminHandler;
private final ItHandler itHandler;
private final TrainingHandler trainingHandler;
public JewelryProcessScheduler() {
// 手动创建所有Handler（替代Spring依赖注入）
this.materialPurchaseHandler = new MaterialPurchaseHandler();
this.designDrawHandler = new DesignDrawHandler();
this.produceHandler = new ProduceHandler();
this.qualityCheckHandler = new QualityCheckHandler();
this.packageHandler = new PackageHandler();
this.logisticsHandler = new LogisticsHandler();
this.financeHandler = new FinanceHandler();
this.marketingHandler = new MarketingHandler();
this.businessHandler = new BusinessHandler();
this.hrAdminHandler = new HrAdminHandler();
this.itHandler = new ItHandler();
this.trainingHandler = new TrainingHandler();
}
/**
* 按顺序组装整条责任链
*/
@Override
public IBusinessHandler buildCompleteChain() {
return materialPurchaseHandler
.SetNext(designDrawHandler)
.SetNext(produceHandler)
.SetNext(qualityCheckHandler)
.SetNext(packageHandler)
.SetNext(logisticsHandler)
.SetNext(financeHandler)
.SetNext(marketingHandler)
.SetNext(businessHandler)
.SetNext(hrAdminHandler)
.SetNext(itHandler)
.SetNext(trainingHandler);
}
/**
* 正常完整流程测试：参数齐全
*/
@Override
public void runFullNormalProcess() {
log.info("========== 启动正常珠宝新品完整业务流程 ==========");
JewelryBusinessContext ctx = new JewelryBusinessContext();
ctx.setBusinessNo("BUS20260729001");
ctx.setJewelryName("古法黄金手镯");
ctx.setMaterial("足金999");
ctx.setPass(true);
IBusinessHandler entry = buildCompleteChain();
entry.HandleAsync(ctx).join();
log.info("流程执行结束，最终状态：isPass={}，备注：{}", ctx.isPass(), ctx.getRemark());
}
/**
* 失败测试流程：材质为空，第一环节直接拦截
*/
@Override
public void runFailedPurchaseTestProcess() {
log.info("========== 启动失败测试流程（材质缺失） ==========");
JewelryBusinessContext ctx = new JewelryBusinessContext();
ctx.setBusinessNo("BUS20260729002");
ctx.setJewelryName("钻石戒指");
ctx.setMaterial("");
ctx.setPass(true);
IBusinessHandler entry = buildCompleteChain();
entry.HandleAsync(ctx).join();
log.info("流程执行结束，最终状态：isPass={}，备注：{}", ctx.isPass(), ctx.getRemark());
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:21
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : OpenTelemetryBuilderExtensions.java
* explain : 学习 类
* https://repo1.maven.org/maven2/io/opentelemetry/
*
**/
package ChainofResponsibility.tracing;
import ChainofResponsibility.configuration.AppSettings;
import io.opentelemetry.api.OpenTelemetry;
/**
* OpenTelemetry装配扩展，对标C# OpenTelemetryBuilderExtensions.cs
* 由于OpenTelemetry SDK依赖版本不完整，返回noop实现
*/
public class OpenTelemetryBuilderExtensions {
/**
* 初始化OpenTelemetry追踪
* @param settings 全局配置
* @return OpenTelemetry实例
*/
public static OpenTelemetry BuildOpenTelemetry(AppSettings settings) {
// 简化实现：直接返回noop，因为OpenTelemetry SDK 1.9.1依赖不完整
// 如需完整功能，需要添加opentelemetry-sdk-extension-autoconfigure等依赖
return OpenTelemetry.noop();
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:21
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : TraceConstants.java
* explain : 学习 类
**/
package ChainofResponsibility.tracing;
/**
* 链路追踪常量定义，对标C# TraceConstants.cs
*/
public class TraceConstants {
/** 全局追踪Source名称，所有Span归属此名称 */
public static final String ActivitySourceName = "JewelryChainBusinessTrace";
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:48
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : LogCleanBackgroundService.java
* explain : 学习 类
**/
package ChainofResponsibility.backgroundservices;
import ChainofResponsibility.configuration.AppSettings;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.time.Duration;
import java.time.Instant;
/**
* 日志清理后台任务，对标C# LogCleanBackgroundService.cs
* 定时删除超过保留天数的旧日志文件
*/
public class LogCleanBackgroundService implements Runnable {
private static final Logger log = LoggerFactory.getLogger(LogCleanBackgroundService.class);
private final AppSettings settings;
public LogCleanBackgroundService(AppSettings settings) {
this.settings = settings;
}
@Override
public void run() {
try {
log.info("开始执行过期日志清理任务");
String logPath = settings.getApp().getLogBasePath();
File logRoot = new File(logPath);
if (!logRoot.exists()) {
log.warn("日志目录不存在：{}", logPath);
return;
}
int keepDay = settings.getApp().getLogRetentionDay();
long expireMs = Duration.ofDays(keepDay).toMillis();
Instant now = Instant.now();
scanDirectory(logRoot, now, expireMs);
log.info("日志清理任务执行完成");
} catch (Exception ex) {
log.error("日志清理任务异常", ex);
}
}
/**
* 递归扫描目录，删除过期文件
* @param folder 当前文件夹
* @param now 当前时间
* @param expireMs 过期毫秒阈值
*/
private void scanDirectory(File folder, Instant now, long expireMs) {
File[] files = folder.listFiles();
if (files == null) return;
for (File file : files) {
if (file.isDirectory()) {
scanDirectory(file, now, expireMs);
continue;
}
Instant fileTime = Instant.ofEpochMilli(file.lastModified());
if (Duration.between(fileTime, now).toMillis() > expireMs) {
boolean del = file.delete();
if (del) {
log.info("删除过期日志文件：{}", file.getAbsolutePath());
}
}
}
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:39
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : BaseBusinessHandler.java
* explain : 学习 类
**/
package ChainofResponsibility.chain.abstractions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
/**
* 处理器抽象基类，对标C# BaseBusinessHandler<T>
* 封装通用链路流转逻辑，子类只需要实现ProcessAsync核心业务
*/
public abstract class BaseBusinessHandler implements IBusinessHandler {
/** 当前处理器日志对象 */
protected final Logger logger;
/** 下一个处理器 */
private IBusinessHandler nextHandler;
protected BaseBusinessHandler() {
this.logger = LoggerFactory.getLogger(this.getClass());
}
/**
* 子类实现：当前环节核心业务逻辑
* @param context 业务上下文
* @return 执行Future
*/
protected abstract CompletableFuture<Void> ProcessAsync(JewelryBusinessContext context);
/**
* 统一入口：执行当前逻辑，判断是否流转到下一环节
*/
@Override
public CompletableFuture<Void> HandleAsync(JewelryBusinessContext context) {
return ProcessAsync(context)
.thenCompose(unused -> {
// 校验失败，终止链路，不再执行后续Handler
if (!context.isPass() || nextHandler == null) {
return CompletableFuture.completedFuture(null);
}
// 流转下一环节
return nextHandler.HandleAsync(context);
});
}
/**
* 设置下一个处理器
* @param nextHandler 下一环
* @return this
*/
@Override
public IBusinessHandler SetNext(IBusinessHandler nextHandler) {
this.nextHandler = nextHandler;
return this;
}
/**
* 模拟异步延时（对标C# Task.Delay）
* @param ms 毫秒
* @return CompletableFuture
*/
protected CompletableFuture<Void> Delay(long ms) {
return CompletableFuture.runAsync(() -> {
try {
TimeUnit.MILLISECONDS.sleep(ms);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:39
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : IBusinessHandler.java
* explain : 学习 类
**/
package ChainofResponsibility.chain.abstractions;
import java.util.concurrent.CompletableFuture;
/**
* 责任链顶层处理器接口，对标C# IBusinessHandler
*/
public interface IBusinessHandler {
/**
* 异步执行业务处理
* @param context 业务上下文
* @return 执行完成Future
*/
CompletableFuture<Void> HandleAsync(JewelryBusinessContext context);
/**
* 设置下一个处理器（构建链表结构）
* @param nextHandler 下一环处理器
* @return 当前处理器（链式调用）
*/
IBusinessHandler SetNext(IBusinessHandler nextHandler);
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:39
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : JewelryBusinessContext.java
* explain : 学习 类
**/
package ChainofResponsibility.chain.abstractions;
/**
* 责任链上下文对象，整条链路共享业务数据
* 对标C# JewelryBusinessContext.cs
*/
public class JewelryBusinessContext {
/** 业务唯一单号 */
private String businessNo;
/** 首饰款式名称 */
private String jewelryName;
/** 首饰材质（足金999/18K金等） */
private String material;
/** 当前正在执行的业务步骤名称 */
private String currentStep;
/** 是否校验通过；false直接终止整条责任链 */
private boolean isPass = true;
/** 流程备注、异常描述信息 */
private String remark = "";
public String getBusinessNo() {
return businessNo;
}
public void setBusinessNo(String businessNo) {
this.businessNo = businessNo;
}
public String getJewelryName() {
return jewelryName;
}
public void setJewelryName(String jewelryName) {
this.jewelryName = jewelryName;
}
public String getMaterial() {
return material;
}
public void setMaterial(String material) {
this.material = material;
}
public String getCurrentStep() {
return currentStep;
}
public void setCurrentStep(String currentStep) {
this.currentStep = currentStep;
}
public boolean isPass() {
return isPass;
}
public void setPass(boolean pass) {
isPass = pass;
}
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
/**
* 追加备注信息
* @param msg 需要追加的文本
*/
public void appendRemark(String msg) {
this.remark = this.remark + msg;
}
}
java
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:45
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : BusinessHandler.java
* explain : 学习 类
**/
package ChainofResponsibility.chain.handlers;
import ChainofResponsibility.chain.abstractions.BaseBusinessHandler;
import ChainofResponsibility.chain.abstractions.JewelryBusinessContext;
import java.util.concurrent.CompletableFuture;
/**
* 环节9：门店业务运营处理器
*/
public class BusinessHandler extends BaseBusinessHandler {
@Override
protected CompletableFuture<Void> ProcessAsync(JewelryBusinessContext context) {
context.setCurrentStep("门店业务运营");
logger.info("【{}】开始处理，单号:{}",
context.getCurrentStep(), context.getBusinessNo());
logger.debug("【{}】库存分配下发、门店销售台账同步完成", context.getCurrentStep());
return Delay(6);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:41
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : DesignDrawHandler.java
* explain : 学习 类
**/
package ChainofResponsibility.chain.handlers;
import ChainofResponsibility.chain.abstractions.BaseBusinessHandler;
import ChainofResponsibility.chain.abstractions.JewelryBusinessContext;
import java.util.concurrent.CompletableFuture;
/**
* 环节2：款式设计绘图处理器
*/
public class DesignDrawHandler extends BaseBusinessHandler {
@Override
protected CompletableFuture<Void> ProcessAsync(JewelryBusinessContext context) {
context.setCurrentStep("款式设计绘图");
logger.info("【{}】开始处理，单号:{},款式:{}",
context.getCurrentStep(), context.getBusinessNo(), context.getJewelryName());
if (context.getJewelryName() == null || context.getJewelryName().isBlank()) {
context.setPass(false);
context.appendRemark("款式名称为空，无法开展设计绘图;");
logger.warn("【{}】校验失败：款式名称缺失", context.getCurrentStep());
return CompletableFuture.completedFuture(null);
}
logger.debug("【{}】3D建模、图纸渲染、工艺参数确认完成", context.getCurrentStep());
return Delay(8);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:44
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : FinanceHandler.java
* explain : 学习 类
**/
package ChainofResponsibility.chain.handlers;
import ChainofResponsibility.chain.abstractions.BaseBusinessHandler;
import ChainofResponsibility.chain.abstractions.JewelryBusinessContext;
import java.util.concurrent.CompletableFuture;
/**
* 环节7：财务对账结算处理器
*/
public class FinanceHandler extends BaseBusinessHandler {
@Override
protected CompletableFuture<Void> ProcessAsync(JewelryBusinessContext context) {
context.setCurrentStep("财务对账结算");
logger.info("【{}】开始处理，单号:{}",
context.getCurrentStep(), context.getBusinessNo());
logger.debug("【{}】原料成本核算、销售单据对账、发票信息登记完成", context.getCurrentStep());
return Delay(9);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:45
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : HrAdminHandler.java
* explain : 学习 类
**/
package ChainofResponsibility.chain.handlers;
import ChainofResponsibility.chain.abstractions.BaseBusinessHandler;
import ChainofResponsibility.chain.abstractions.JewelryBusinessContext;
import java.util.concurrent.CompletableFuture;
/**
* 环节10：人事行政处理器
*/
public class HrAdminHandler extends BaseBusinessHandler {
@Override
protected CompletableFuture<Void> ProcessAsync(JewelryBusinessContext context) {
context.setCurrentStep("人事行政统筹");
logger.info("【{}】开始处理，单号:{}",
context.getCurrentStep(), context.getBusinessNo());
logger.debug("【{}】生产/销售人员排班、绩效预登记完成", context.getCurrentStep());
return Delay(3);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:46
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : ItHandler.java
* explain : 学习 类
**/
package ChainofResponsibility.chain.handlers;
import ChainofResponsibility.chain.abstractions.BaseBusinessHandler;
import ChainofResponsibility.chain.abstractions.JewelryBusinessContext;
import java.util.concurrent.CompletableFuture;
/**
* 环节11：信息系统运维处理器
*/
public class ItHandler extends BaseBusinessHandler {
@Override
protected CompletableFuture<Void> ProcessAsync(JewelryBusinessContext context) {
context.setCurrentStep("信息系统运维");
logger.info("【{}】开始处理，单号:{}",
context.getCurrentStep(), context.getBusinessNo());
logger.debug("【{}】ERP单据同步、商品档案录入、数据归档完成", context.getCurrentStep());
return Delay(4);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:43
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : LogisticsHandler.java
* explain : 学习 类
**/
package ChainofResponsibility.chain.handlers;
import ChainofResponsibility.chain.abstractions.BaseBusinessHandler;
import ChainofResponsibility.chain.abstractions.JewelryBusinessContext;
import java.util.concurrent.CompletableFuture;
/**
* 环节6：物流发货处理器
*/
public class LogisticsHandler extends BaseBusinessHandler {
@Override
protected CompletableFuture<Void> ProcessAsync(JewelryBusinessContext context) {
context.setCurrentStep("物流发货配送");
logger.info("【{}】开始处理，单号:{}",
context.getCurrentStep(), context.getBusinessNo());
logger.debug("【{}】保价物流下单、运单生成、出库交接完成", context.getCurrentStep());
return Delay(7);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:44
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : MarketingHandler.java
* explain : 学习 类
**/
package ChainofResponsibility.chain.handlers;
import ChainofResponsibility.chain.abstractions.BaseBusinessHandler;
import ChainofResponsibility.chain.abstractions.JewelryBusinessContext;
import java.util.concurrent.CompletableFuture;
/**
* 环节8：市场营销处理器
*/
public class MarketingHandler extends BaseBusinessHandler {
@Override
protected CompletableFuture<Void> ProcessAsync(JewelryBusinessContext context) {
context.setCurrentStep("市场营销推广");
logger.info("【{}】开始处理，单号:{},款式:{}",
context.getCurrentStep(), context.getBusinessNo(), context.getJewelryName());
logger.debug("【{}】新品素材上架、门店陈列方案、活动政策配置完成", context.getCurrentStep());
return Delay(5);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:40
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : MaterialPurchaseHandler.java
* explain : 学习 类
**/
package ChainofResponsibility.chain.handlers;
import ChainofResponsibility.chain.abstractions.BaseBusinessHandler;
import ChainofResponsibility.chain.abstractions.JewelryBusinessContext;
import java.util.concurrent.CompletableFuture;
/**
* 环节1：原料采购核验处理器
*/
public class MaterialPurchaseHandler extends BaseBusinessHandler {
@Override
protected CompletableFuture<Void> ProcessAsync(JewelryBusinessContext context) {
context.setCurrentStep("原料采购核验");
logger.info("【{}】开始处理，单号:{},材质:{}",
context.getCurrentStep(), context.getBusinessNo(), context.getMaterial());
// 校验材质不能为空
if (context.getMaterial() == null || context.getMaterial().isBlank()) {
context.setPass(false);
context.appendRemark("原料材质信息为空，无法采购;");
logger.warn("【{}】校验失败：材质缺失", context.getCurrentStep());
return CompletableFuture.completedFuture(null);
}
logger.debug("【{}】原料采购入库、质检验收完成", context.getCurrentStep());
return Delay(8);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:43
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : PackageHandler.java
* explain : 学习 类
**/
package ChainofResponsibility.chain.handlers;
import ChainofResponsibility.chain.abstractions.BaseBusinessHandler;
import ChainofResponsibility.chain.abstractions.JewelryBusinessContext;
import java.util.concurrent.CompletableFuture;
/**
* 环节5：珠宝包装封装处理器
*/
public class PackageHandler extends BaseBusinessHandler {
@Override
protected CompletableFuture<Void> ProcessAsync(JewelryBusinessContext context) {
context.setCurrentStep("珠宝包装封装");
logger.info("【{}】开始处理，单号:{}",
context.getCurrentStep(), context.getBusinessNo());
logger.debug("【{}】首饰入盒、防尘包装、防盗标签、礼品卡片封装完成", context.getCurrentStep());
return Delay(4);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:42
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : ProduceHandler.java
* explain : 学习 类
**/
package ChainofResponsibility.chain.handlers;
import ChainofResponsibility.chain.abstractions.BaseBusinessHandler;
import ChainofResponsibility.chain.abstractions.JewelryBusinessContext;
import java.util.concurrent.CompletableFuture;
/**
* 环节3：工厂生产加工处理器
*/
public class ProduceHandler extends BaseBusinessHandler {
@Override
protected CompletableFuture<Void> ProcessAsync(JewelryBusinessContext context) {
context.setCurrentStep("工厂生产加工");
logger.info("【{}】开始处理，单号:{},材质:{}",
context.getCurrentStep(), context.getBusinessNo(), context.getMaterial());
logger.debug("【{}】开料、执模、镶嵌、抛光工序执行完毕", context.getCurrentStep());
return Delay(12);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:42
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : QualityCheckHandler.java
* explain : 学习 类
**/
package ChainofResponsibility.chain.handlers;
import ChainofResponsibility.chain.abstractions.BaseBusinessHandler;
import ChainofResponsibility.chain.abstractions.JewelryBusinessContext;
import java.util.Random;
import java.util.concurrent.CompletableFuture;
/**
* 环节4：成品质检处理器
*/
public class QualityCheckHandler extends BaseBusinessHandler {
@Override
protected CompletableFuture<Void> ProcessAsync(JewelryBusinessContext context) {
context.setCurrentStep("成品质量检测");
logger.info("【{}】开始处理，单号:{}",
context.getCurrentStep(), context.getBusinessNo());
Random rand = new Random();
int randomResult = rand.nextInt(1, 101);
// 5%概率质检失败
if (randomResult <= 5) {
context.setPass(false);
context.appendRemark(String.format("成品抽检不达标，随机质检编号%d;", randomResult));
logger.warn("【{}】质检不通过，需要返厂重修", context.getCurrentStep());
return CompletableFuture.completedFuture(null);
}
logger.debug("【{}】尺寸、成色、钻石牢固度检测全部合格，出具质检证书", context.getCurrentStep());
return Delay(6);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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/29 - 23:46
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : TrainingHandler.java
* explain : 学习 类
**/
package ChainofResponsibility.chain.handlers;
import ChainofResponsibility.chain.abstractions.BaseBusinessHandler;
import ChainofResponsibility.chain.abstractions.JewelryBusinessContext;
import java.util.concurrent.CompletableFuture;
/**
* 环节12：员工培训处理器（整条链路最后一环）
*/
public class TrainingHandler extends BaseBusinessHandler {
@Override
protected CompletableFuture<Void> ProcessAsync(JewelryBusinessContext context) {
context.setCurrentStep("新品员工培训");
logger.info("【{}】开始处理，单号:{},款式:{}",
context.getCurrentStep(), context.getBusinessNo(), context.getJewelryName());
logger.debug("【{}】产品卖点资料下发、导购培训计划创建完成；整条业务流程抵达末端", context.getCurrentStep());
return Delay(2);
}
}调用：
java
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 责任链模式 Chain of Responsibility Pattern
* 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:05
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : ChainOfResponsibilityBll.java
* explain : 学习 类
**/
package BLL;
import ChainofResponsibility.backgroundservices.LogCleanBackgroundService;
import ChainofResponsibility.configuration.AppSettings;
import ChainofResponsibility.configuration.AppSettingsBinderExtension;
import ChainofResponsibility.extensions.ServiceCollectionExtensions;
import ChainofResponsibility.scheduler.IProcessScheduler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ChainOfResponsibilityBll {
/** 日志实例 */
private static final Logger log = LoggerFactory.getLogger(ChainOfResponsibilityBll.class);
private AppSettings appSettings;
private IProcessScheduler scheduler;
private ScheduledExecutorService executor;
/**
* 启动日志清理后台服务
*/
private void startBackgroundLogCleanService() {
LogCleanBackgroundService logCleanService = new LogCleanBackgroundService(appSettings);
executor = Executors.newSingleThreadScheduledExecutor();
// 每隔24小时执行一次日志清理
executor.scheduleAtFixedRate(logCleanService, 0, 24, TimeUnit.HOURS);
log.info("日志清理后台服务已启动");
}
/**
* 初始化应用
*/
private void initialize() {
log.info("========== 珠宝业务责任链服务启动 ==========");
// 1. 加载配置文件 appsettings.json
File configFile = new File("appsettings.json");
if (configFile.exists()) {
appSettings = AppSettingsBinderExtension.Bind(configFile, AppSettings.class);
} else {
// 使用默认配置
appSettings = createDefaultSettings();
log.warn("配置文件appsettings.json不存在，使用默认配置");
}
// 2. 创建调度器（替代Spring容器）
scheduler = ServiceCollectionExtensions.createScheduler();
// 3. 启动后台定时服务：日志清理任务
startBackgroundLogCleanService();
}
/**
* 创建默认配置
*/
private AppSettings createDefaultSettings() {
AppSettings settings = new AppSettings();
AppSettings.AppNode appNode = new AppSettings.AppNode();
appNode.setServiceName("JewelryBusinessService");
appNode.setLogBasePath("logs");
appNode.setLogRetentionDay(30);
AppSettings.OpenTelemetryConfig otelConfig = new AppSettings.OpenTelemetryConfig();
otelConfig.setEnableOtlpExporter(false);
appNode.setOpenTelemetry(otelConfig);
settings.setApp(appNode);
return settings;
}
/**
* 关闭应用
*/
public void shutdown() {
if (executor != null && !executor.isShutdown()) {
executor.shutdown();
log.info("日志清理后台服务已停止");
}
}
public void demo(){
// 初始化
initialize();
// 4. 执行完整责任链测试
// 正常业务流程测试
log.info("\n========== 执行正常业务流程测试 ==========");
scheduler.runFullNormalProcess();
// 模拟失败流程测试（原料参数缺失）
log.info("\n========== 执行失败流程测试（原料缺失） ==========");
scheduler.runFailedPurchaseTestProcess();
log.info("\n业务执行完成");
// 保持后台服务运行一段时间演示
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
shutdown();
}
}输出：
