java: Builder Pattern

项目结构：

 

/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 20:17
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : JewelryOrder.java
 * explain   : 学习  类
 **/

package BuilderPattern.core.entity;

import java.time.LocalDateTime;

public class JewelryOrder {
    private Integer orderId;
    private String productName;
    private LocalDateTime createTime = LocalDateTime.now();

    private boolean rawMaterialChecked;
    private boolean designCompleted;
    private boolean productionFinished;
    private boolean qualityPassed;
    private boolean packaged;
    private boolean shipped;
    private boolean financeSettled;

    private String processStatus = "Initialized";
    private boolean completed;

    // getter/setter
    public Integer getOrderId() { return orderId; }
    public void setOrderId(Integer orderId) { this.orderId = orderId; }
    public String getProductName() { return productName; }
    public void setProductName(String productName) { this.productName = productName; }
    public LocalDateTime getCreateTime() { return createTime; }
    public boolean isRawMaterialChecked() { return rawMaterialChecked; }
    public void setRawMaterialChecked(boolean rawMaterialChecked) { this.rawMaterialChecked = rawMaterialChecked; }
    public boolean isDesignCompleted() { return designCompleted; }
    public void setDesignCompleted(boolean designCompleted) { this.designCompleted = designCompleted; }
    public boolean isProductionFinished() { return productionFinished; }
    public void setProductionFinished(boolean productionFinished) { this.productionFinished = productionFinished; }
    public boolean isQualityPassed() { return qualityPassed; }
    public void setQualityPassed(boolean qualityPassed) { this.qualityPassed = qualityPassed; }
    public boolean isPackaged() { return packaged; }
    public void setPackaged(boolean packaged) { this.packaged = packaged; }
    public boolean isShipped() { return shipped; }
    public void setShipped(boolean shipped) { this.shipped = shipped; }
    public boolean isFinanceSettled() { return financeSettled; }
    public void setFinanceSettled(boolean financeSettled) { this.financeSettled = financeSettled; }
    public String getProcessStatus() { return processStatus; }
    public void setProcessStatus(String processStatus) { this.processStatus = processStatus; }
    public boolean isCompleted() { return completed; }
    public void setCompleted(boolean completed) { this.completed = completed; }
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 20:16
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : ProcessStep.java
 * explain   : 学习  类
 **/

package BuilderPattern.core.enums;

public enum ProcessStep {
    RawMaterialCheck,
    Design,
    Production,
    QualityCheck,
    Packaging,
    Logistics,
    Finance,
    Marketing,
    Business,
    HrAdmin,
    ItSupport
}



/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 20:23
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : IJewelryProcessBuilder.java
 * explain   : 学习  类
 **/

package BuilderPattern.core.interfaces.builder;

import BuilderPattern.core.entity.JewelryOrder;
import BuilderPattern.core.enums.ProcessStep;
import java.util.concurrent.CompletableFuture;

public interface IJewelryProcessBuilder {
    IJewelryProcessBuilder createOrder(int orderId, String productName);
    IJewelryProcessBuilder addStep(ProcessStep step);
    CompletableFuture<JewelryOrder> buildAsync();
}



/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 20:23
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : IProcessScheduler.java
 * explain   : 学习  类
 **/

package BuilderPattern.core.interfaces.scheduler;

import java.util.concurrent.CompletableFuture;

public interface IProcessScheduler {
    CompletableFuture<Void> startFullProcessAsync();
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 17
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1
 * # OS        : window10
 * Datetime  : 2026 - 2026/7/9 - 20:22
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : IBusinessService.java
 * explain   : 学习  接口类
 **/

package BuilderPattern.core.interfaces.service;

public interface IBusinessService extends IProcessService{
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 17
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1
 * # OS        : window10
 * Datetime  : 2026 - 2026/7/9 - 20:20
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : IDesignService.java
 * explain   : 学习  接口类
 **/

package BuilderPattern.core.interfaces.service;

public interface IDesignService extends IProcessService{
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 17
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1
 * # OS        : window10
 * Datetime  : 2026 - 2026/7/9 - 20:21
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : IFinanceService.java
 * explain   : 学习  接口类
 **/

package BuilderPattern.core.interfaces.service;

public interface IFinanceService extends IProcessService{
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 17
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1
 * # OS        : window10
 * Datetime  : 2026 - 2026/7/9 - 20:22
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : IHrAdminService.java
 * explain   : 学习  接口类
 **/

package BuilderPattern.core.interfaces.service;

public interface IHrAdminService extends IProcessService{
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 17
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1
 * # OS        : window10
 * Datetime  : 2026 - 2026/7/9 - 20:22
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : IItService.java
 * explain   : 学习  接口类
 **/

package BuilderPattern.core.interfaces.service;

public interface IItService extends IProcessService{
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 17
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1
 * # OS        : window10
 * Datetime  : 2026 - 2026/7/9 - 20:21
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : ILogisticsService.java
 * explain   : 学习  接口类
 **/

package BuilderPattern.core.interfaces.service;

public interface ILogisticsService extends IProcessService{
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 17
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1
 * # OS        : window10
 * Datetime  : 2026 - 2026/7/9 - 20:21
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : IMarketingService.java
 * explain   : 学习  接口类
 **/

package BuilderPattern.core.interfaces.service;

public interface IMarketingService extends IProcessService{
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 17
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1
 * # OS        : window10
 * Datetime  : 2026 - 2026/7/9 - 20:21
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : IPackagingService.java
 * explain   : 学习  接口类
 **/

package BuilderPattern.core.interfaces.service;

public interface IPackagingService extends IProcessService{
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 20:17
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : IProcessService.java
 * explain   : 学习  类
 **/

package BuilderPattern.core.interfaces.service;

import BuilderPattern.core.entity.JewelryOrder;
import java.util.concurrent.CompletableFuture;

public interface IProcessService {
    CompletableFuture<Void> executeAsync(JewelryOrder order);
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 17
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1
 * # OS        : window10
 * Datetime  : 2026 - 2026/7/9 - 20:20
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : IProductionService.java
 * explain   : 学习  接口类
 **/

package BuilderPattern.core.interfaces.service;

public interface IProductionService extends IProcessService{
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * Author    : geovindu,Geovin Du 涂聚文.
 * IDE       : IntelliJ IDEA 2024.3.6 Java 17
 * # database  : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1
 * # OS        : window10
 * Datetime  : 2026 - 2026/7/9 - 20:20
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : IQualityCheckService.java
 * explain   : 学习  接口类
 **/

package BuilderPattern.core.interfaces.service;

public interface IQualityCheckService extends IProcessService{
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 20:19
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : IRawMaterialService.java
 * explain   : 学习  类
 **/

package BuilderPattern.core.interfaces.service;

public interface IRawMaterialService extends IProcessService {}

/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 20:59
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : ServiceCollection.java
 * explain   : 学习  类
 **/

package BuilderPattern.infrastructure.di;

import BuilderPattern.core.interfaces.builder.IJewelryProcessBuilder;
import BuilderPattern.core.interfaces.scheduler.IProcessScheduler;
import BuilderPattern.core.interfaces.service.*;
import BuilderPattern.service.builder.JewelryProcessBuilder;
import BuilderPattern.service.process.*;
import BuilderPattern.scheduler.JewelryProcessScheduler;
import java.util.HashMap;
import java.util.Map;

public class ServiceCollection {
    private final Map<Class<?>, Object> container = new HashMap<>();

    public <T> void register(Class<T> inter, T impl) {
        container.put(inter, impl);
    }

    @SuppressWarnings("unchecked")
    public <T> T get(Class<T> inter) {
        return (T) container.get(inter);
    }

    public void registerAll() {
        register(IRawMaterialService.class, new RawMaterialService());
        register(IDesignService.class, new DesignService());
        register(IProductionService.class, new ProductionService());
        register(IQualityCheckService.class, new QualityCheckService());
        register(IPackagingService.class, new PackagingService());
        register(ILogisticsService.class, new LogisticsService());
        register(IFinanceService.class, new FinanceService());
        register(IMarketingService.class, new MarketingService());
        register(IBusinessService.class, new BusinessService());
        register(IHrAdminService.class, new HrAdminService());
        register(IItService.class, new ItService());

        register(IJewelryProcessBuilder.class, new JewelryProcessBuilder(this));
        register(IProcessScheduler.class, new JewelryProcessScheduler(get(IJewelryProcessBuilder.class)));
    }
}



/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 21:00
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : LoggerConfig.java
 * explain   : 学习  类
 **/

package BuilderPattern.infrastructure.logging;

public class LoggerConfig {
    private String logRootDirectory = "logs";
    private String outputTemplate = "%d{yyyy-MM-dd HH:mm:ss.SSS} [%p] %c | %m%n%ex";
    private int retainFileDays = 30;
    private long maxFileSize = 1024 * 1024;

    public String getLogRootDirectory() {
        return logRootDirectory;
    }

    public void setLogRootDirectory(String logRootDirectory) {
        this.logRootDirectory = logRootDirectory;
    }

    public String getOutputTemplate() {
        return outputTemplate;
    }

    public void setOutputTemplate(String outputTemplate) {
        this.outputTemplate = outputTemplate;
    }

    public int getRetainFileDays() {
        return retainFileDays;
    }

    public void setRetainFileDays(int retainFileDays) {
        this.retainFileDays = retainFileDays;
    }

    public long getMaxFileSize() {
        return maxFileSize;
    }

    public void setMaxFileSize(long maxFileSize) {
        this.maxFileSize = maxFileSize;
    }
}

/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 21:00
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : LoggingSetup.java
 * explain   : 学习  类
 **/

package BuilderPattern.infrastructure.logging;

import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.classic.encoder.PatternLayoutEncoder;
import ch.qos.logback.classic.filter.LevelFilter;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.rolling.RollingFileAppender;
import ch.qos.logback.core.rolling.TimeBasedRollingPolicy;
import ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP;
import org.slf4j.LoggerFactory;
import ch.qos.logback.core.util.FileSize;
import java.io.File;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy;
import ch.qos.logback.classic.filter.ThresholdFilter;

public class LoggingSetup {
    public static void configure(LoggerConfig cfg) {
        LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
        lc.reset();

        String baseDir = System.getProperty("user.dir");
        String logRoot = baseDir + File.separator + cfg.getLogRootDirectory();
        File logDir = new File(logRoot);
        if (!logDir.exists()) {
            logDir.mkdirs();
        }

        // 关键：文件名交给logback动态日期模板，不要静态拼接当天日期
        //RollingFileAppender<ILoggingEvent> infoAppender = buildAppender(
                //lc, cfg, logRoot + "/info.log", Level.INFO
        //);
        //RollingFileAppender<ILoggingEvent> errorAppender = buildAppender(
              //  lc, cfg, logRoot + "/error.log", Level.ERROR
        //);
        String date = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));

        RollingFileAppender<ILoggingEvent> infoAppender = buildAppender(lc, cfg, logRoot + "/info-" + date + ".log", Level.INFO);
        RollingFileAppender<ILoggingEvent> errorAppender = buildAppender(lc, cfg, logRoot + "/error-" + date + ".log", Level.ERROR);

        ch.qos.logback.classic.Logger root = lc.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
        root.setLevel(Level.DEBUG);
        root.addAppender(infoAppender);
        root.addAppender(errorAppender);

        // 放行我们业务包所有日志，避免被默认过滤丢弃
        ch.qos.logback.classic.Logger bizLogger = lc.getLogger("com.jewelry");
        bizLogger.setLevel(Level.DEBUG);
        bizLogger.setAdditive(true);
    }

    private static RollingFileAppender<ILoggingEvent> buildAppender(
            LoggerContext lc,
            LoggerConfig cfg,
            String filePath,
            Level minLevel
    ) {
        RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<>();
        appender.setContext(lc);
        appender.setFile(filePath);

        // 日志输出模板
        PatternLayoutEncoder encoder = new PatternLayoutEncoder();
        encoder.setContext(lc);
        encoder.setPattern(cfg.getOutputTemplate());
        encoder.start();
        appender.setEncoder(encoder);

        // 大小+时间滚动策略（新版推荐SizeAndTimeBasedRollingPolicy，简化生命周期，彻底规避NPE）
        SizeAndTimeBasedRollingPolicy<ILoggingEvent> rollingPolicy = new SizeAndTimeBasedRollingPolicy<>();
        rollingPolicy.setContext(lc);
        rollingPolicy.setParent(appender);
        // 动态日期+分片后缀，自动生成 logs/info.2026-07-09.0.log
        rollingPolicy.setFileNamePattern(filePath + ".%d{yyyy-MM-dd}.%i.log");
        rollingPolicy.setMaxHistory(cfg.getRetainFileDays());
        // 文件大小限制
        FileSize limit = FileSize.valueOf(String.valueOf(cfg.getMaxFileSize()));
        rollingPolicy.setMaxFileSize(limit);
        rollingPolicy.start();

        appender.setRollingPolicy(rollingPolicy);

        // 替换LevelFilter为ThresholdFilter：大于等于该级别全部放行（解决INFO收不到WARN/ERROR）
        ThresholdFilter thresholdFilter = new ThresholdFilter();
        thresholdFilter.setLevel(minLevel.toString());
        thresholdFilter.start();
        appender.addFilter(thresholdFilter);

        appender.start();
        return appender;
    }
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 21:01
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : JewelryProcessScheduler.java
 * explain   : 学习  类
 **/

package BuilderPattern.scheduler;

import BuilderPattern.core.enums.ProcessStep;
import BuilderPattern.core.interfaces.builder.IJewelryProcessBuilder;
import BuilderPattern.core.interfaces.scheduler.IProcessScheduler;
import BuilderPattern.core.entity.JewelryOrder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.CompletableFuture;

public class JewelryProcessScheduler implements IProcessScheduler {
    private final Logger logger = LoggerFactory.getLogger(JewelryProcessScheduler.class);
    private final IJewelryProcessBuilder builder;

    public JewelryProcessScheduler(IJewelryProcessBuilder builder) {
        this.builder = builder;
    }

    @Override
    public CompletableFuture<Void> startFullProcessAsync() {
        logger.info("======================================================");
        logger.info("        珠宝企业全链路业务调度器启动                   ");
        logger.info("======================================================");
        return builder
                .createOrder(3001, "18K金天然蓝宝石手镯")
                .addStep(ProcessStep.RawMaterialCheck)
                .addStep(ProcessStep.Design)
                .addStep(ProcessStep.Production)
                .addStep(ProcessStep.QualityCheck)
                .addStep(ProcessStep.Packaging)
                .addStep(ProcessStep.Logistics)
                .addStep(ProcessStep.Finance)
                .addStep(ProcessStep.Marketing)
                .addStep(ProcessStep.Business)
                .addStep(ProcessStep.HrAdmin)
                .addStep(ProcessStep.ItSupport)
                .buildAsync()
                .thenAccept(order -> {
                    logger.info("======================================================");
                    logger.info("调度完成 | 订单编号：{} | 流程状态：{} | 全部完成：{}",
                            order.getOrderId(), order.getProcessStatus(), order.isCompleted());
                    logger.info("======================================================");
                })
                .exceptionally(ex -> {
                    logger.error("珠宝全流程调度发生致命异常", ex);
                    throw new RuntimeException(ex);
                });
    }
}

　　

/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 20:57
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : JewelryProcessBuilder.java
 * explain   : 学习  类
 **/

package BuilderPattern.service.builder;

import BuilderPattern.core.entity.JewelryOrder;
import BuilderPattern.core.enums.ProcessStep;
import BuilderPattern.core.interfaces.builder.IJewelryProcessBuilder;
import BuilderPattern.core.interfaces.service.*;
import BuilderPattern.infrastructure.di.ServiceCollection;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;

public class JewelryProcessBuilder implements IJewelryProcessBuilder {
    private final Logger logger = LoggerFactory.getLogger(JewelryProcessBuilder.class);
    private final ServiceCollection serviceCollection;
    private final List<ProcessStep> steps = new ArrayList<>();
    private JewelryOrder order;

    public JewelryProcessBuilder(ServiceCollection serviceCollection) {
        this.serviceCollection = serviceCollection;
    }

    @Override
    public IJewelryProcessBuilder createOrder(int orderId, String productName) {
        this.order = new JewelryOrder();
        order.setOrderId(orderId);
        order.setProductName(productName);
        logger.info("[建造者] 初始化订单：{} 产品：{}", orderId, productName);
        return this;
    }

    @Override
    public IJewelryProcessBuilder addStep(ProcessStep step) {
        steps.add(step);
        logger.debug("[建造者] 追加流程步骤：{}", step);
        return this;
    }

    @Override
    public CompletableFuture<JewelryOrder> buildAsync() {
        if (order == null) {
            return CompletableFuture.failedFuture(new IllegalStateException("请先调用createOrder初始化订单"));
        }
        logger.info("[建造者] 订单{} 开始执行全流程，总步骤：{}", order.getOrderId(), steps.size());
        CompletableFuture<Void> chain = CompletableFuture.completedFuture(null);
        for (ProcessStep step : steps) {
            chain = chain.thenCompose(v -> resolveService(step).executeAsync(order));
        }
        return chain.thenApply(v -> {
            order.setProcessStatus("AllStepsCompleted");
            order.setCompleted(true);
            logger.info("[建造者] 订单{} 全业务流程执行完毕", order.getOrderId());
            return order;
        });
    }

    private IProcessService resolveService(ProcessStep step) {
        return switch (step) {
            case RawMaterialCheck -> serviceCollection.get(IRawMaterialService.class);
            case Design -> serviceCollection.get(IDesignService.class);
            case Production -> serviceCollection.get(IProductionService.class);
            case QualityCheck -> serviceCollection.get(IQualityCheckService.class);
            case Packaging -> serviceCollection.get(IPackagingService.class);
            case Logistics -> serviceCollection.get(ILogisticsService.class);
            case Finance -> serviceCollection.get(IFinanceService.class);
            case Marketing -> serviceCollection.get(IMarketingService.class);
            case Business -> serviceCollection.get(IBusinessService.class);
            case HrAdmin -> serviceCollection.get(IHrAdminService.class);
            case ItSupport -> serviceCollection.get(IItService.class);
        };
    }
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 20:53
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : BusinessService.java
 * explain   : 学习  类
 **/

package BuilderPattern.service.process;

import BuilderPattern.core.entity.JewelryOrder;
import BuilderPattern.core.interfaces.service.IBusinessService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.CompletableFuture;

public class BusinessService implements IBusinessService {
    private final Logger logger = LoggerFactory.getLogger(BusinessService.class);

    @Override
    public CompletableFuture<Void> executeAsync(JewelryOrder order) {
        return CompletableFuture.runAsync(() -> {
            logger.info("[业务对接] 订单{} 客户售后、订单归档", order.getOrderId());
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                throw new RuntimeException("业务对接线程中断", e);
            }
        });
    }
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 20:50
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : DesignService.java
 * explain   : 学习  类
 **/

package BuilderPattern.service.process;

import BuilderPattern.core.entity.JewelryOrder;
import BuilderPattern.core.interfaces.service.IDesignService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.CompletableFuture;

public class DesignService implements IDesignService {
    private final Logger logger = LoggerFactory.getLogger(DesignService.class);

    @Override
    public CompletableFuture<Void> executeAsync(JewelryOrder order) {
        return CompletableFuture.runAsync(() -> {
            logger.info("[设计制图] 订单{} 启动珠宝图纸绘制", order.getOrderId());
            order.setDesignCompleted(true);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException("设计制图线程中断", e);
            }
            logger.info("[设计制图] 订单{} 设计图纸定稿完成", order.getOrderId());
        });
    }
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 20:52
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : FinanceService.java
 * explain   : 学习  类
 **/

package BuilderPattern.service.process;

import BuilderPattern.core.entity.JewelryOrder;
import BuilderPattern.core.interfaces.service.IFinanceService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.CompletableFuture;

public class FinanceService implements IFinanceService {
    private final Logger logger = LoggerFactory.getLogger(FinanceService.class);

    @Override
    public CompletableFuture<Void> executeAsync(JewelryOrder order) {
        return CompletableFuture.runAsync(() -> {
            logger.info("[财务结算] 订单{} 成本、回款台账登记", order.getOrderId());
            order.setFinanceSettled(true);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException("财务结算线程中断", e);
            }
            logger.info("[财务结算] 订单{} 财务流程闭环", order.getOrderId());
        });
    }
}



/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 20:55
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : HrAdminService.java
 * explain   : 学习  类
 **/

package BuilderPattern.service.process;

import BuilderPattern.core.entity.JewelryOrder;
import BuilderPattern.core.interfaces.service.IHrAdminService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.CompletableFuture;

public class HrAdminService implements IHrAdminService {
    private final Logger logger = LoggerFactory.getLogger(HrAdminService.class);

    @Override
    public CompletableFuture<Void> executeAsync(JewelryOrder order) {
        return CompletableFuture.runAsync(() -> {
            logger.info("[人事行政] 订单{} 工序工时、绩效统计", order.getOrderId());
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                throw new RuntimeException("人事行政线程中断", e);
            }
        });
    }
}



/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 20:55
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : ItService.java
 * explain   : 学习  类
 **/

package BuilderPattern.service.process;

import BuilderPattern.core.entity.JewelryOrder;
import BuilderPattern.core.interfaces.service.IItService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.CompletableFuture;

public class ItService implements IItService {
    private final Logger logger = LoggerFactory.getLogger(ItService.class);

    @Override
    public CompletableFuture<Void> executeAsync(JewelryOrder order) {
        return CompletableFuture.runAsync(() -> {
            logger.info("[IT运维] 订单{} ERP、库存系统数据同步", order.getOrderId());
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                throw new RuntimeException("IT运维线程中断", e);
            }
        });
    }
}



/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 20:52
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : LogisticsService.java
 * explain   : 学习  类
 **/

package BuilderPattern.service.process;

import BuilderPattern.core.entity.JewelryOrder;
import BuilderPattern.core.interfaces.service.ILogisticsService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.CompletableFuture;

public class LogisticsService implements ILogisticsService {
    private final Logger logger = LoggerFactory.getLogger(LogisticsService.class);

    @Override
    public CompletableFuture<Void> executeAsync(JewelryOrder order) {
        return CompletableFuture.runAsync(() -> {
            logger.info("[物流配送] 订单{} 珠宝保价出库", order.getOrderId());
            order.setShipped(true);
            try {
                Thread.sleep(12);
            } catch (InterruptedException e) {
                throw new RuntimeException("物流线程中断", e);
            }
            logger.info("[物流配送] 订单{} 已移交承运商", order.getOrderId());
        });
    }
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 20:52
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : MarketingService.java
 * explain   : 学习  类
 **/

package BuilderPattern.service.process;

import BuilderPattern.core.entity.JewelryOrder;
import BuilderPattern.core.interfaces.service.IMarketingService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.CompletableFuture;

public class MarketingService implements IMarketingService {
    private final Logger logger = LoggerFactory.getLogger(MarketingService.class);

    @Override
    public CompletableFuture<Void> executeAsync(JewelryOrder order) {
        return CompletableFuture.runAsync(() -> {
            logger.info("[营销推广] 订单{} 新品上架、渠道投放", order.getOrderId());
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                throw new RuntimeException("营销线程中断", e);
            }
        });
    }
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 20:51
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : PackagingService.java
 * explain   : 学习  类
 **/

package BuilderPattern.service.process;

import BuilderPattern.core.entity.JewelryOrder;
import BuilderPattern.core.interfaces.service.IPackagingService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.CompletableFuture;

public class PackagingService implements IPackagingService {
    private final Logger logger = LoggerFactory.getLogger(PackagingService.class);

    @Override
    public CompletableFuture<Void> executeAsync(JewelryOrder order) {
        return CompletableFuture.runAsync(() -> {
            logger.info("[产品包装] 订单{} 礼盒、证书封装", order.getOrderId());
            order.setPackaged(true);
            try {
                Thread.sleep(8);
            } catch (InterruptedException e) {
                throw new RuntimeException("包装线程中断", e);
            }
            logger.info("[产品包装] 订单{} 包装工序结束", order.getOrderId());
        });
    }
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 20:50
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : ProductionService.java
 * explain   : 学习  类
 **/

package BuilderPattern.service.process;

import BuilderPattern.core.entity.JewelryOrder;
import BuilderPattern.core.interfaces.service.IProductionService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.CompletableFuture;

public class ProductionService implements IProductionService {
    private final Logger logger = LoggerFactory.getLogger(ProductionService.class);

    @Override
    public CompletableFuture<Void> executeAsync(JewelryOrder order) {
        return CompletableFuture.runAsync(() -> {
            logger.info("[加工生产] 订单{} 进入车间加工流程", order.getOrderId());
            order.setProductionFinished(true);
            try {
                Thread.sleep(15);
            } catch (InterruptedException e) {
                throw new RuntimeException("加工生产线程中断", e);
            }
            logger.info("[加工生产] 订单{} 毛坯加工全部完成", order.getOrderId());
        });
    }
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 20:51
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : QualityCheckService.java
 * explain   : 学习  类
 **/

package BuilderPattern.service.process;

import BuilderPattern.core.entity.JewelryOrder;
import BuilderPattern.core.interfaces.service.IQualityCheckService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.CompletableFuture;

public class QualityCheckService implements IQualityCheckService {
    private final Logger logger = LoggerFactory.getLogger(QualityCheckService.class);

    @Override
    public CompletableFuture<Void> executeAsync(JewelryOrder order) {
        return CompletableFuture.runAsync(() -> {
            logger.info("[质检检测] 订单{} 贵金属、钻石标准检测", order.getOrderId());
            order.setQualityPassed(true);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException("质检线程中断", e);
            }
            logger.info("[质检检测] 订单{} 全部指标合格", order.getOrderId());
        });
    }
}


/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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/9 - 20:49
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : RawMaterialService.java
 * explain   : 学习  类
 **/

package BuilderPattern.service.process;

import BuilderPattern.core.entity.JewelryOrder;
import BuilderPattern.core.interfaces.service.IRawMaterialService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.CompletableFuture;

public class RawMaterialService implements IRawMaterialService {
    private final Logger logger = LoggerFactory.getLogger(RawMaterialService.class);

    @Override
    public CompletableFuture<Void> executeAsync(JewelryOrder order) {
        return CompletableFuture.runAsync(() -> {
            logger.info("[原料采购核验] 订单{} 开始核验原料：{}", order.getOrderId(), order.getProductName());
            order.setRawMaterialChecked(true);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException("原料核验线程中断", e);
            }
            logger.info("[原料采购核验] 订单{} 原料核验完成", order.getOrderId());
        });
    }
}

　　

调用：

/**
 * encoding: utf-8
 * 版权所有 2026 ©涂聚文有限公司 ®
 * 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
 * 描述：建造者模式 Builder Patter 生成器模式
 * 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 - 10:58
 * User      : geovindu
 * Product   : IntelliJ IDEA
 * Project   : javadesginpattern
 * File      : BuilderBll.java
 * explain   : 学习  类
 **/

package BLL;

import BuilderPattern.core.interfaces.scheduler.IProcessScheduler;
import BuilderPattern.infrastructure.di.ServiceCollection;
import BuilderPattern.infrastructure.logging.LoggerConfig;
import BuilderPattern.infrastructure.logging.LoggingSetup;

public class BuilderBll {
    public void demo(){
        // 初始化日志配置
        LoggerConfig logCfg = new LoggerConfig();
        logCfg.setLogRootDirectory("logs");
        logCfg.setRetainFileDays(30);
        logCfg.setMaxFileSize(1024 * 1024);
        LoggingSetup.configure(logCfg);

        // DI容器批量注册所有业务实例
        ServiceCollection services = new ServiceCollection();
        services.registerAll();

        // 获取调度器并执行完整珠宝业务流程
        IProcessScheduler scheduler = services.get(IProcessScheduler.class);
        scheduler.startFullProcessAsync().join();
    }
}

　　

输出：

2026-07-09 21:24:50.207 [INFO] BuilderPattern.scheduler.JewelryProcessScheduler | ======================================================
2026-07-09 21:24:50.207 [INFO] BuilderPattern.scheduler.JewelryProcessScheduler |         珠宝企业全链路业务调度器启动                   
2026-07-09 21:24:50.208 [INFO] BuilderPattern.scheduler.JewelryProcessScheduler | ======================================================
2026-07-09 21:24:50.208 [INFO] BuilderPattern.service.builder.JewelryProcessBuilder | [建造者] 初始化订单：3001 产品：18K金天然蓝宝石手镯
2026-07-09 21:24:50.209 [INFO] BuilderPattern.service.builder.JewelryProcessBuilder | [建造者] 订单3001 开始执行全流程，总步骤：11
2026-07-09 21:24:50.212 [INFO] BuilderPattern.service.process.RawMaterialService | [原料采购核验] 订单3001 开始核验原料：18K金天然蓝宝石手镯
2026-07-09 21:24:50.224 [INFO] BuilderPattern.service.process.RawMaterialService | [原料采购核验] 订单3001 原料核验完成
2026-07-09 21:24:50.225 [INFO] BuilderPattern.service.process.DesignService | [设计制图] 订单3001 启动珠宝图纸绘制
2026-07-09 21:24:50.236 [INFO] BuilderPattern.service.process.DesignService | [设计制图] 订单3001 设计图纸定稿完成
2026-07-09 21:24:50.236 [INFO] BuilderPattern.service.process.ProductionService | [加工生产] 订单3001 进入车间加工流程
2026-07-09 21:24:50.253 [INFO] BuilderPattern.service.process.ProductionService | [加工生产] 订单3001 毛坯加工全部完成
2026-07-09 21:24:50.253 [INFO] BuilderPattern.service.process.QualityCheckService | [质检检测] 订单3001 贵金属、钻石标准检测
2026-07-09 21:24:50.265 [INFO] BuilderPattern.service.process.QualityCheckService | [质检检测] 订单3001 全部指标合格
2026-07-09 21:24:50.265 [INFO] BuilderPattern.service.process.PackagingService | [产品包装] 订单3001 礼盒、证书封装
2026-07-09 21:24:50.275 [INFO] BuilderPattern.service.process.PackagingService | [产品包装] 订单3001 包装工序结束
2026-07-09 21:24:50.275 [INFO] BuilderPattern.service.process.LogisticsService | [物流配送] 订单3001 珠宝保价出库
2026-07-09 21:24:50.289 [INFO] BuilderPattern.service.process.LogisticsService | [物流配送] 订单3001 已移交承运商
2026-07-09 21:24:50.289 [INFO] BuilderPattern.service.process.FinanceService | [财务结算] 订单3001 成本、回款台账登记
2026-07-09 21:24:50.300 [INFO] BuilderPattern.service.process.FinanceService | [财务结算] 订单3001 财务流程闭环
2026-07-09 21:24:50.300 [INFO] BuilderPattern.service.process.MarketingService | [营销推广] 订单3001 新品上架、渠道投放
2026-07-09 21:24:50.308 [INFO] BuilderPattern.service.process.BusinessService | [业务对接] 订单3001 客户售后、订单归档
2026-07-09 21:24:50.314 [INFO] BuilderPattern.service.process.HrAdminService | [人事行政] 订单3001 工序工时、绩效统计
2026-07-09 21:24:50.320 [INFO] BuilderPattern.service.process.ItService | [IT运维] 订单3001 ERP、库存系统数据同步
2026-07-09 21:24:50.327 [INFO] BuilderPattern.service.builder.JewelryProcessBuilder | [建造者] 订单3001 全业务流程执行完毕
2026-07-09 21:24:50.327 [INFO] BuilderPattern.scheduler.JewelryProcessScheduler | ======================================================
2026-07-09 21:24:50.327 [INFO] BuilderPattern.scheduler.JewelryProcessScheduler | 调度完成 | 订单编号：3001 | 流程状态：AllStepsCompleted | 全部完成：true
2026-07-09 21:24:50.327 [INFO] BuilderPattern.scheduler.JewelryProcessScheduler | ======================================================