项目结构：
java
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/5 - 22:11
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : ConcurrentSafeHelper.java
* explain : 学习 类
**/
package MementoPattern.Common;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.function.Consumer;
import java.util.function.Supplier;
/**
* 线程安全通用工具类
* 封装读写分离锁、安全读写方法，全局复用，统一并发管控规范
*/
public final class ConcurrentSafeHelper {
/**
* 创建无递归读写分离锁，读多写少高性能场景推荐
* @return 读写锁实例
*/
public static ReentrantReadWriteLock createReadWriteLock() {
return new ReentrantReadWriteLock(false);
}
/**
* 线程安全执行写入操作
* @param rwLock 读写锁对象
* @param writeAction 待执行写入逻辑
*/
public static void safeWrite(ReentrantReadWriteLock rwLock, Runnable writeAction) {
if (rwLock == null || writeAction == null) {
return;
}
ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();
writeLock.lock();
try {
writeAction.run();
} finally {
writeLock.unlock();
}
}
/**
* 线程安全执行无返回值读取操作
* @param rwLock 读写锁对象
* @param readAction 读取逻辑
*/
public static void safeRead(ReentrantReadWriteLock rwLock, Runnable readAction) {
if (rwLock == null || readAction == null) {
return;
}
ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
readLock.lock();
try {
readAction.run();
} finally {
readLock.unlock();
}
}
/**
* 线程安全读取带返回值泛型方法
* @param rwLock 读写锁
* @param readFunc 读取委托
* @return 读取结果
*/
public static <T> T safeRead(ReentrantReadWriteLock rwLock, Supplier<T> readFunc) {
if (rwLock == null || readFunc == null) {
return null;
}
ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
readLock.lock();
try {
return readFunc.get();
} finally {
readLock.unlock();
}
}
//私有构造禁止实例化
private ConcurrentSafeHelper() {
throw new AssertionError("工具类不可实例化");
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/5 - 22:10
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : GlobalConfig.java
* explain : 学习 类
**/
package MementoPattern.Common;
/**
* 全局静态统一配置类
* 集中管理日志路径、格式化模板、系统常量，统一修改便于扩展维护
*/
public final class GlobalConfig {
/**
* 日志根文件夹名称
*/
public static final String LOG_ROOT_DIRECTORY = "Logs";
/**
* 日期文件夹格式化模板，生成如 2026-08-05
*/
public static final String LOG_DAY_FOLDER_FORMAT = "%d{yyyy-MM-dd}";
/**
* 日志文件名模板：app-{级别}.log
*/
public static final String LOG_FILE_NAME_TEMPLATE = "app-%s.log";
/**
* 日志时间戳格式化模板，精确到毫秒
*/
public static final String LOG_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss.SSS";
/**
* 珠宝业务编号前缀
*/
public static final String BUSINESS_SN_PREFIX = "JEW-ENTER-";
/**
* 全局最低日志级别
*/
public static final org.slf4j.event.Level GLOBAL_MIN_LOG_LEVEL = org.slf4j.event.Level.DEBUG;
//私有构造禁止实例化
private GlobalConfig() {
throw new AssertionError("静态配置类不可实例化");
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/5 - 22:12
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : BaseMemento.java
* explain : 学习 类
**/
package MementoPattern.Core.Base;
import java.time.LocalDateTime;
/**
* 备忘录模式顶层抽象快照基类
* 定义所有快照通用基础属性，后续任意业务快照可继承扩展
*/
public abstract class BaseMemento {
/**
* 快照创建时间
*/
private final LocalDateTime createTime;
/**
* 业务唯一编号
*/
private final String businessSn;
/**
* 基础快照构造初始化
* @param businessSn 业务唯一编号
*/
protected BaseMemento(String businessSn) {
this.businessSn = businessSn;
this.createTime = LocalDateTime.now();
}
public LocalDateTime getCreateTime() {
return createTime;
}
public String getBusinessSn() {
return businessSn;
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/5 - 22:11
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : BaseService.java
* explain : 学习 类
**/
package MementoPattern.Core.Base;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 所有业务服务、调度器、模式类统一父基类
* 子类自动绑定对应Logger，全局统一日志依赖，规范编码结构
* @param <T> 当前子类自身类型
*/
public abstract class BaseService<T> {
/**
* 当前类专属日志实例，子类直接使用输出日志
*/
protected final Logger logger;
/**
* 构造自动初始化当前类Logger
*/
@SuppressWarnings("unchecked")
protected BaseService() {
Class<T> clazz = (Class<T>) getClass();
this.logger = LoggerFactory.getLogger(clazz);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/5 - 22:14
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : LoggerBuildFactory.java
* explain : 学习 类
**/
package MementoPattern.Core.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.spi.ILoggingEvent;
import ch.qos.logback.core.ConsoleAppender;
import ch.qos.logback.core.rolling.RollingFileAppender;
import ch.qos.logback.core.rolling.TimeBasedRollingPolicy;
import ch.qos.logback.core.util.FileSize;
import MementoPattern.Common.GlobalConfig;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
/**
* 日志构建工厂类
* 统一初始化控制台+分级文件日志，实现按日期文件夹、日志等级拆分文件、多线程安全写入
*/
public class LoggerBuildFactory {
/**
* 全局日志统一初始化方法
*/
public static void buildGlobalLogger() {
LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
context.reset();
//1、构建编码器（控制台+文件共用一套格式）
PatternLayoutEncoder encoder = buildEncoder(context);
//2、注册控制台输出
ConsoleAppender<ILoggingEvent> consoleAppender = buildConsoleAppender(context, encoder);
//3、注册4个分级文件日志（debug/info/warn/error）
buildLevelFileAppender(context, encoder, Level.DEBUG, "debug");
buildLevelFileAppender(context, encoder, Level.INFO, "info");
buildLevelFileAppender(context, encoder, Level.WARN, "warn");
buildLevelFileAppender(context, encoder, Level.ERROR, "error");
//4、全局根日志配置
ch.qos.logback.classic.Logger rootLogger = context.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
rootLogger.setLevel(Level.DEBUG);
rootLogger.addAppender(consoleAppender);
//过滤框架冗余日志
context.getLogger("org.springframework").setLevel(Level.WARN);
}
/**
* 构建统一格式编码器
*/
private static PatternLayoutEncoder buildEncoder(LoggerContext context) {
PatternLayoutEncoder encoder = new PatternLayoutEncoder();
encoder.setContext(context);
encoder.setPattern(LogUniformFormatter.LOG_PATTERN);
encoder.start();
return encoder;
}
/**
* 构建控制台追加器
*/
private static ConsoleAppender<ILoggingEvent> buildConsoleAppender(LoggerContext context, PatternLayoutEncoder encoder) {
ConsoleAppender<ILoggingEvent> consoleAppender = new ConsoleAppender<>();
consoleAppender.setContext(context);
consoleAppender.setEncoder(encoder);
consoleAppender.start();
return consoleAppender;
}
/**
* 构建单等级文件日志追加器，按日期文件夹归档
*/
private static void buildLevelFileAppender(LoggerContext context, PatternLayoutEncoder encoder, Level level, String levelName) {
RollingFileAppender<ILoggingEvent> fileAppender = new RollingFileAppender<>();
fileAppender.setContext(context);
// 当前日志文件路径（使用实际日期）
String today = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
String currentFilePath = GlobalConfig.LOG_ROOT_DIRECTORY + File.separator
+ today + File.separator
+ String.format(GlobalConfig.LOG_FILE_NAME_TEMPLATE, levelName);
// 滚动归档文件路径模式（使用Logback日期占位符）
String archivePattern = GlobalConfig.LOG_ROOT_DIRECTORY + File.separator
+ "%d{yyyy-MM-dd}" + File.separator
+ String.format(GlobalConfig.LOG_FILE_NAME_TEMPLATE, levelName);
fileAppender.setFile(currentFilePath);
fileAppender.setEncoder(encoder);
//按日期滚动策略
TimeBasedRollingPolicy<ILoggingEvent> rollingPolicy = new TimeBasedRollingPolicy<>();
rollingPolicy.setContext(context);
rollingPolicy.setFileNamePattern(archivePattern);
rollingPolicy.setMaxHistory(90);
rollingPolicy.setTotalSizeCap(FileSize.valueOf("5GB"));
// 必须先setRollingPolicy（内部会设置parent），再由fileAppender.start()启动policy
fileAppender.setRollingPolicy(rollingPolicy);
// 不要单独调用 rollingPolicy.start()，fileAppender.start() 会自动启动它
//级别过滤器
ch.qos.logback.classic.filter.LevelFilter levelFilter = new ch.qos.logback.classic.filter.LevelFilter();
levelFilter.setLevel(level);
levelFilter.setOnMatch(ch.qos.logback.core.spi.FilterReply.ACCEPT);
levelFilter.setOnMismatch(ch.qos.logback.core.spi.FilterReply.DENY);
levelFilter.start();
fileAppender.addFilter(levelFilter);
fileAppender.start();
//挂载到根日志
ch.qos.logback.classic.Logger root = context.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
root.addAppender(fileAppender);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/5 - 22:12
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : LogUniformFormatter.java
* explain : 学习 类
**/
package MementoPattern.Core.Logging;
import MementoPattern.Common.GlobalConfig;
/**
* 统一日志格式化提供器
* 严格保证控制台日志、文件日志格式100%完全一致
*/
public final class LogUniformFormatter {
/**
* 获取统一日志格式字符串模板
*/
public static final String LOG_PATTERN =
"%d{" + GlobalConfig.LOG_TIME_FORMAT + "} [%thread] %-5level %logger{36} - %msg%n";
private LogUniformFormatter() {
throw new AssertionError("静态工具类不可实例化");
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/6 - 22:22
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : BusinessOriginator.java
* explain : 学习 类
**/
package MementoPattern.Pattern.Memento;
import MementoPattern.Core.Base.BaseService;
import java.math.BigDecimal;
/**
* 备忘录原发器：持有全业务运行状态
* 负责生成快照、快照回滚恢复业务历史状态
*/
public class BusinessOriginator extends BaseService<BusinessOriginator> {
//当前业务运行状态字段
private String currentBusinessSn = "";
private String currentMaterial = "";
private BigDecimal currentWeight = BigDecimal.ZERO;
private String currentDesign = "";
private String currentCraft = "";
private BigDecimal currentScore = BigDecimal.ZERO;
private BigDecimal currentAmount = BigDecimal.ZERO;
//Getter & Setter
public String getCurrentBusinessSn() {
return currentBusinessSn;
}
public void setCurrentBusinessSn(String currentBusinessSn) {
this.currentBusinessSn = currentBusinessSn;
}
public String getCurrentMaterial() {
return currentMaterial;
}
public void setCurrentMaterial(String currentMaterial) {
this.currentMaterial = currentMaterial;
}
public BigDecimal getCurrentWeight() {
return currentWeight;
}
public void setCurrentWeight(BigDecimal currentWeight) {
this.currentWeight = currentWeight;
}
public String getCurrentDesign() {
return currentDesign;
}
public void setCurrentDesign(String currentDesign) {
this.currentDesign = currentDesign;
}
public String getCurrentCraft() {
return currentCraft;
}
public void setCurrentCraft(String currentCraft) {
this.currentCraft = currentCraft;
}
public BigDecimal getCurrentScore() {
return currentScore;
}
public void setCurrentScore(BigDecimal currentScore) {
this.currentScore = currentScore;
}
public BigDecimal getCurrentAmount() {
return currentAmount;
}
public void setCurrentAmount(BigDecimal currentAmount) {
this.currentAmount = currentAmount;
}
/**
* 根据当前实时业务状态生成快照
* @return 业务快照对象
*/
public JewelryBusinessMemento createMemento() {
logger.debug("【快照生成】业务编号:{},记录当前全流程业务状态", currentBusinessSn);
return new JewelryBusinessMemento(currentBusinessSn, currentMaterial, currentWeight,
currentDesign, currentCraft, currentScore, currentAmount);
}
/**
* 使用历史快照回滚业务状态
* @param memento 待恢复快照
*/
public void restoreMemento(JewelryBusinessMemento memento) {
if (memento == null) {
logger.warn("快照为空，无法执行回滚操作");
return;
}
this.currentBusinessSn = memento.getBusinessSn();
this.currentMaterial = memento.getMaterialName();
this.currentWeight = memento.getMaterialWeight();
this.currentDesign = memento.getDesignContent();
this.currentCraft = memento.getCraftType();
this.currentScore = memento.getQualityScore();
this.currentAmount = memento.getFinanceAmount();
logger.info("【业务回滚成功】{}已恢复至{}历史快照", currentBusinessSn, memento.getCreateTime());
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/6 - 22:21
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : JewelryBusinessMemento.java
* explain : 学习 类
**/
package MementoPattern.Pattern.Memento;
import MementoPattern.Core.Base.BaseMemento;
import java.math.BigDecimal;
/**
* 珠宝全业务快照实体
* 存储原料、设计、加工、质检、财务等全流程业务状态，用于版本回滚、历史存档
*/
public class JewelryBusinessMemento extends BaseMemento {
/**
* 原料名称
*/
private final String materialName;
/**
* 原料重量(g)
*/
private final BigDecimal materialWeight;
/**
* 设计图纸文案内容
*/
private final String designContent;
/**
* 加工工艺类型
*/
private final String craftType;
/**
* 成品质检分数
*/
private final BigDecimal qualityScore;
/**
* 本次业务财务金额
*/
private final BigDecimal financeAmount;
/**
* 构造快照对象，记录全业务状态
* @param businessSn 业务编号
* @param materialName 原料名称
* @param materialWeight 原料重量
* @param designContent 图纸内容
* @param craftType 加工工艺
* @param qualityScore 质检分数
* @param financeAmount 财务金额
*/
public JewelryBusinessMemento(String businessSn, String materialName, BigDecimal materialWeight,
String designContent, String craftType, BigDecimal qualityScore, BigDecimal financeAmount) {
super(businessSn);
this.materialName = materialName;
this.materialWeight = materialWeight;
this.designContent = designContent;
this.craftType = craftType;
this.qualityScore = qualityScore;
this.financeAmount = financeAmount;
}
// Getter
public String getMaterialName() {
return materialName;
}
public BigDecimal getMaterialWeight() {
return materialWeight;
}
public String getDesignContent() {
return designContent;
}
public String getCraftType() {
return craftType;
}
public BigDecimal getQualityScore() {
return qualityScore;
}
public BigDecimal getFinanceAmount() {
return financeAmount;
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/6 - 22:23
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : MementoCaretaker.java
* explain : 学习 类
**/
package MementoPattern.Pattern.Memento;
import MementoPattern.Common.ConcurrentSafeHelper;
import MementoPattern.Core.Base.BaseService;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* 快照保管员：统一存储、查询、管理所有业务快照
* 读写分离锁保证高并发线程安全
*/
public class MementoCaretaker extends BaseService<MementoCaretaker> {
/**
* 读写分离锁，管控快照集合并发读写
*/
private final ReentrantReadWriteLock rwLock;
/**
* 内存快照仓库
*/
private final List<JewelryBusinessMemento> mementoStore;
public MementoCaretaker() {
super();
this.rwLock = ConcurrentSafeHelper.createReadWriteLock();
this.mementoStore = new ArrayList<>();
}
/**
* 新增快照入库（独占写锁）
* @param memento 快照对象
*/
public void addMemento(JewelryBusinessMemento memento) {
if (memento == null) {
logger.warn("待入库快照为空，入库失败");
return;
}
ConcurrentSafeHelper.safeWrite(rwLock, () -> mementoStore.add(memento));
logger.debug("快照仓库新增业务[{}]历史版本", memento.getBusinessSn());
}
/**
* 根据业务编号查询全部历史快照，时间倒序
* @param businessSn 业务编号
* @return 快照集合
*/
public List<JewelryBusinessMemento> getAllHistory(String businessSn) {
return ConcurrentSafeHelper.safeRead(rwLock, () -> mementoStore.stream()
.filter(item -> item.getBusinessSn().equals(businessSn))
.sorted(Comparator.comparing(JewelryBusinessMemento::getCreateTime).reversed())
.toList());
}
/**
* 获取指定业务最新快照
* @param businessSn 业务编号
* @return 最新快照，无则null
*/
public JewelryBusinessMemento getLatestMemento(String businessSn) {
return ConcurrentSafeHelper.safeRead(rwLock, () -> mementoStore.stream()
.filter(item -> item.getBusinessSn().equals(businessSn))
.max(Comparator.comparing(JewelryBusinessMemento::getCreateTime))
.orElse(null));
}
/**
* 清空指定业务全部快照
* @param businessSn 业务编号
*/
public void clearBusinessHistory(String businessSn) {
ConcurrentSafeHelper.safeWrite(rwLock, () -> mementoStore.removeIf(item -> item.getBusinessSn().equals(businessSn)));
logger.info("已清空业务[{}]全部历史快照", businessSn);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/6 - 22:34
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : IWorkflowSchedule.java
* explain : 学习 类
**/
package MementoPattern.Workflow;
import java.util.concurrent.CompletableFuture;
/**
* 流水线调度顶层抽象接口
* 新增流程仅需实现接口，完全满足开闭原则，高扩展
*/
public interface IWorkflowSchedule {
/**
* 异步执行全业务流水线
*/
CompletableFuture<Void> runWholeWorkflowAsync();
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento 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/8/6 - 22:34
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : JewelryWholeWorkflowScheduler.java
* explain : 学习 类
**/
package MementoPattern.Workflow;
import MementoPattern.Business.*;
import MementoPattern.Common.GlobalConfig;
import MementoPattern.Core.Base.BaseService;
import MementoPattern.Pattern.Memento.BusinessOriginator;
import MementoPattern.Pattern.Memento.MementoCaretaker;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
/**
* 珠宝全业务流水线调度器
* 严格顺序串联12大业务流程：洽谈→采购→设计→加工→质检→包装→物流→财务→营销→人事→IT→培训
*/
public class JewelryWholeWorkflowScheduler extends BaseService<JewelryWholeWorkflowScheduler> implements IWorkflowSchedule {
//全部业务服务
private final BusinessNegotiateService negotiateService;
private final MaterialPurchaseService purchaseService;
private final DesignDrawService designService;
private final ProduceProcessService produceService;
private final QualityInspectService inspectService;
private final PackageService packageService;
private final LogisticsService logisticsService;
private final FinanceAccountService financeService;
private final MarketingPromoteService marketingService;
private final HrAdminService hrService;
private final ItOperationService itService;
private final StaffTrainService trainService;
private static final DateTimeFormatter SN_FORMAT = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
public JewelryWholeWorkflowScheduler() {
// 手动创建备忘录模式核心组件
BusinessOriginator originator = new BusinessOriginator();
MementoCaretaker caretaker = new MementoCaretaker();
// 手动创建所有业务服务（替代Spring注入）
this.negotiateService = new BusinessNegotiateService();
this.purchaseService = new MaterialPurchaseService();
this.designService = new DesignDrawService(originator, caretaker);
this.produceService = new ProduceProcessService(originator, caretaker);
this.inspectService = new QualityInspectService(originator, caretaker);
this.packageService = new PackageService();
this.logisticsService = new LogisticsService();
this.financeService = new FinanceAccountService(originator, caretaker);
this.marketingService = new MarketingPromoteService();
this.hrService = new HrAdminService();
this.itService = new ItOperationService();
this.trainService = new StaffTrainService();
}
@Override
public CompletableFuture<Void> runWholeWorkflowAsync() {
return CompletableFuture.runAsync(() -> {
String sn = GlobalConfig.BUSINESS_SN_PREFIX + LocalDateTime.now().format(SN_FORMAT);
logger.info("==================== 珠宝全业务流水线【开始执行】 编号:{} ====================", sn);
sleepMs(50);
//1 客户洽谈
negotiateService.customerTalk("深圳高端私人客户", "18K金一克拉钻戒定制，六爪镶嵌");
sleepMs(50);
//2 原料采购核验
boolean purchasePass = purchaseService.purchaseCheck("黄金", new BigDecimal("62.8"));
if (!purchasePass) {
logger.error("原料核验失败，流水线强制终止");
return;
}
sleepMs(50);
//3 设计制图
designService.createDraft(sn, "黄金", new BigDecimal("62.8"),
"六爪镶嵌钻戒，戒圈防滑磨砂，主钻1克拉，副钻环绕点缀");
sleepMs(50);
//4 加工生产
produceService.startProduce(sn, "镶嵌+精细抛光");
sleepMs(50);
//5 质检
inspectService.doInspect(sn);
sleepMs(50);
//6 包装
packageService.packageGoods(sn, "高端实木珍藏礼盒");
sleepMs(50);
//7 物流
logisticsService.sendDelivery("WL20260805001", "广东省深圳市福田珠宝产业园");
sleepMs(50);
//8 财务记账
financeService.createBill(sn, new BigDecimal("36800"));
sleepMs(50);
//9 营销活动
marketingService.launchActivity("七夕钻戒特惠定制活动");
sleepMs(50);
//10 人事排班
hrService.staffManage("车间班组人员轮班调整");
sleepMs(50);
//11 IT运维
itService.systemMaintain("订单数据库索引优化、性能巡检");
sleepMs(50);
//12 员工培训
trainService.arrangeTrain("新设计师小张", "钻石镶嵌工艺进阶课程");
logger.info("==================== 珠宝全业务流水线【全部执行完毕】 编号:{} ====================", sn);
});
}
/**
* 线程休眠
*/
private void sleepMs(long ms) {
try {
TimeUnit.MILLISECONDS.sleep(ms);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
logger.warn("线程休眠中断", e);
}
}
}
java
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/5 - 22:32
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : BusinessNegotiateService.java
* explain : 学习 类
**/
package MementoPattern.Business;
import MementoPattern.Core.Base.BaseService;
/**
* 业务9：客户业务洽谈服务
*/
public class BusinessNegotiateService extends BaseService<BusinessNegotiateService> {
public void customerTalk(String customerName, String demand) {
logger.info("【业务洽谈】客户:{},定制需求:{}", customerName, demand);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/5 - 22:25
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : DesignDrawService.java
* explain : 学习 类
**/
package MementoPattern.Business;
import MementoPattern.Core.Base.BaseService;
import MementoPattern.Pattern.Memento.BusinessOriginator;
import MementoPattern.Pattern.Memento.JewelryBusinessMemento;
import MementoPattern.Pattern.Memento.MementoCaretaker;
import java.math.BigDecimal;
/**
* 业务2：珠宝设计制图服务
* 职责：图纸创建、状态更新、快照存档
*/
public class DesignDrawService extends BaseService<DesignDrawService> {
private final BusinessOriginator originator;
private final MementoCaretaker caretaker;
public DesignDrawService(BusinessOriginator originator, MementoCaretaker caretaker) {
this.originator = originator;
this.caretaker = caretaker;
}
/**
* 创建设计图纸并自动快照存档
* @param businessSn 业务编号
* @param material 绑定原料
* @param weight 原料重量
* @param designText 图纸详情
*/
public void createDraft(String businessSn, String material, BigDecimal weight, String designText) {
logger.info("【珠宝设计制图】{}开始绘制图纸", businessSn);
originator.setCurrentBusinessSn(businessSn);
originator.setCurrentMaterial(material);
originator.setCurrentWeight(weight);
originator.setCurrentDesign(designText);
//生成快照存档
JewelryBusinessMemento snap = originator.createMemento();
caretaker.addMemento(snap);
logger.debug("图纸内容：{}", designText);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/5 - 22:31
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : FinanceAccountService.java
* explain : 学习 类
**/
package MementoPattern.Business;
import MementoPattern.Core.Base.BaseService;
import MementoPattern.Pattern.Memento.BusinessOriginator;
import MementoPattern.Pattern.Memento.JewelryBusinessMemento;
import MementoPattern.Pattern.Memento.MementoCaretaker;
import java.math.BigDecimal;
/**
* 业务7：财务记账核算服务
*/
public class FinanceAccountService extends BaseService<FinanceAccountService> {
private final BusinessOriginator originator;
private final MementoCaretaker caretaker;
public FinanceAccountService(BusinessOriginator originator, MementoCaretaker caretaker) {
this.originator = originator;
this.caretaker = caretaker;
}
public void createBill(String businessSn, BigDecimal amount) {
logger.info("【财务记账】{}入账金额:{}元", businessSn, amount);
originator.setCurrentBusinessSn(businessSn);
originator.setCurrentAmount(amount);
JewelryBusinessMemento snap = originator.createMemento();
caretaker.addMemento(snap);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/5 - 22:33
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : HrAdminService.java
* explain : 学习 类
**/
package MementoPattern.Business;
import MementoPattern.Core.Base.BaseService;
/**
* 业务10：人事行政管理服务
*/
public class HrAdminService extends BaseService<HrAdminService> {
public void staffManage(String operate) {
logger.info("【人事行政】执行人员管理操作：{}", operate);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/5 - 22:33
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : ItOperationService.java
* explain : 学习 类
**/
package MementoPattern.Business;
import MementoPattern.Core.Base.BaseService;
/**
* 业务11：IT系统运维服务
*/
public class ItOperationService extends BaseService<ItOperationService> {
public void systemMaintain(String workDetail) {
logger.info("【IT运维】执行维护任务：{}", workDetail);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/5 - 22:31
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : LogisticsService.java
* explain : 学习 类
**/
package MementoPattern.Business;
import MementoPattern.Core.Base.BaseService;
/**
* 业务6：物流配送服务
*/
public class LogisticsService extends BaseService<LogisticsService> {
public void sendDelivery(String deliveryNo, String address) {
logger.info("【物流发货】单号{}下发配送，收货地址:{}", deliveryNo, address);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/5 - 22:32
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : MarketingPromoteService.java
* explain : 学习 类
**/
package MementoPattern.Business;
import MementoPattern.Core.Base.BaseService;
/**
* 业务8：营销推广服务
*/
public class MarketingPromoteService extends BaseService<MarketingPromoteService> {
public void launchActivity(String activityName) {
logger.info("【营销推广】活动[{}]全渠道上线", activityName);
logger.debug("门店、电商、短视频渠道同步投放预热");
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/5 - 22:24
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : MaterialPurchaseService.java
* explain : 学习 类
**/
package MementoPattern.Business;
import MementoPattern.Core.Base.BaseService;
import java.util.Set;
/**
* 业务1：原料采购核验服务
* 职责：原料合法性校验、入库判定、日志记录
*/
public class MaterialPurchaseService extends BaseService<MaterialPurchaseService> {
private static final Set<String> LEGAL_MATERIALS = Set.of("黄金", "铂金", "钻石", "玉石");
/**
* 原料采购入库核验
* @param materialName 原料名称：黄金/铂金/钻石/玉石
* @param weight 原料重量g
* @return true核验通过入库，false驳回
*/
public boolean purchaseCheck(String materialName, java.math.BigDecimal weight) {
logger.info("【原料采购核验】原料:{},重量:{}g", materialName, weight);
boolean legalMaterial = LEGAL_MATERIALS.contains(materialName);
boolean legalWeight = weight.compareTo(java.math.BigDecimal.ZERO) > 0;
boolean pass = legalMaterial && legalWeight;
if (pass) {
logger.info("原料核验通过，准许入库登记");
} else {
logger.error("原料非法/重量异常，驳回入库申请");
}
return pass;
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/5 - 22:30
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : PackageService.java
* explain : 学习 类
**/
package MementoPattern.Business;
import MementoPattern.Core.Base.BaseService;
/**
* 业务5：成品包装服务
* 职责：礼盒封装、防伪绑定
*/
public class PackageService extends BaseService<PackageService> {
public void packageGoods(String businessSn, String boxType) {
logger.info("【成品包装】{}使用{}礼盒封装", businessSn, boxType);
logger.debug("防伪标签、珠宝鉴定证书绑定完成");
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/5 - 22:28
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : ProduceProcessService.java
* explain : 学习 类
**/
package MementoPattern.Business;
import MementoPattern.Core.Base.BaseService;
import MementoPattern.Pattern.Memento.BusinessOriginator;
import MementoPattern.Pattern.Memento.JewelryBusinessMemento;
import MementoPattern.Pattern.Memento.MementoCaretaker;
import java.util.Random;
/**
* 业务3：加工生产服务
* 职责：下发加工任务、进度监控、工艺记录
*/
public class ProduceProcessService extends BaseService<ProduceProcessService> {
private static final Random RANDOM = new Random();
private final BusinessOriginator originator;
private final MementoCaretaker caretaker;
public ProduceProcessService(BusinessOriginator originator, MementoCaretaker caretaker) {
this.originator = originator;
this.caretaker = caretaker;
}
/**
* 启动加工任务
* @param businessSn 业务编号
* @param craft 工艺：镶嵌/雕花/抛光/拉丝
*/
public void startProduce(String businessSn, String craft) {
logger.info("【加工生产】{}启动{}工艺加工", businessSn, craft);
originator.setCurrentBusinessSn(businessSn);
originator.setCurrentCraft(craft);
int progress = RANDOM.nextInt(20, 101);
logger.debug("实时加工进度：{}%", progress);
JewelryBusinessMemento snap = originator.createMemento();
caretaker.addMemento(snap);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/5 - 22:28
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : QualityInspectService.java
* explain : 学习 类
**/
package MementoPattern.Business;
import MementoPattern.Core.Base.BaseService;
import MementoPattern.Pattern.Memento.BusinessOriginator;
import MementoPattern.Pattern.Memento.JewelryBusinessMemento;
import MementoPattern.Pattern.Memento.MementoCaretaker;
import java.math.BigDecimal;
import java.util.Random;
/**
* 业务4：成品质检服务
* 职责：质量打分、等级判定、快照存档
*/
public class QualityInspectService extends BaseService<QualityInspectService> {
private static final Random RANDOM = new Random();
private final BusinessOriginator originator;
private final MementoCaretaker caretaker;
public QualityInspectService(BusinessOriginator originator, MementoCaretaker caretaker) {
this.originator = originator;
this.caretaker = caretaker;
}
/**
* 执行质检
* @param businessSn 业务编号
* @return 质检分数
*/
public BigDecimal doInspect(String businessSn) {
logger.info("【成品质量检测】开始检测{}", businessSn);
BigDecimal score = BigDecimal.valueOf(RANDOM.nextInt(600, 1000)).divide(BigDecimal.TEN);
originator.setCurrentBusinessSn(businessSn);
originator.setCurrentScore(score);
JewelryBusinessMemento snap = originator.createMemento();
caretaker.addMemento(snap);
if (score.compareTo(BigDecimal.valueOf(90)) >= 0) {
logger.info("质检合格，评级优等");
} else if (score.compareTo(BigDecimal.valueOf(70)) >= 0) {
logger.warn("质检待复检，评级中等");
} else {
logger.error("质检不合格，判定报废");
}
return score;
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento Pattern
* 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/8/6 - 22:34
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : StaffTrainService.java
* explain : 学习 类
**/
package MementoPattern.Business;
import MementoPattern.Core.Base.BaseService;
/**
* 业务12：员工工艺培训服务
*/
public class StaffTrainService extends BaseService<StaffTrainService> {
public void arrangeTrain(String traineeName, String course) {
logger.info("【员工培训】为{}安排{}课程", traineeName, course);
}
}调用：
java
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：行为模式 Behavioral Patterns 备忘录模式 Memento 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:06
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : MementoBll.java
* explain : 学习 类
**/
package BLL;
import MementoPattern.Core.Logging.LoggerBuildFactory;
import MementoPattern.Workflow.IWorkflowSchedule;
import MementoPattern.Workflow.JewelryWholeWorkflowScheduler;
public class MementoBll {
public void demo(){
//1、全局日志初始化
LoggerBuildFactory.buildGlobalLogger();
//2、手动创建调度器执行流水线（替代Spring容器）
IWorkflowSchedule scheduler = new JewelryWholeWorkflowScheduler();
scheduler.runWholeWorkflowAsync().join();
}
}