一、项目概述
本文基于 Java 21 实现珠宝加工业务流程的观察者模式（Observer Pattern）实战案例，覆盖从原料采购、设计、加工、质检、包装、物流到财务的全流程事件驱动设计。
二、项目结构
项目采用模块化分包设计，核心包结构如下：
- ObserverPattern.dto：业务数据传输对象，如 JewelryProcessDto。
- ObserverPattern.observer：观察者模式核心，包含主题 ProcessSubject 与观察者接口 IProcessObserver。
- ObserverPattern.observer.observers：各业务部门观察者实现，如采购核验、设计、加工、质检、包装、物流、财务、营销、人事、IT、培训等。
- ObserverPattern.logging：日志组件，对标 .NET ILogger，支持控制台与文件输出。
- ObserverPattern.scheduler：业务流程调度器 JewelryProcessScheduler，驱动业务流转。
- ObserverPattern.di：轻量级依赖注入容器，非 Spring 实现。
- ObserverPattern.circuit：熔断器相关异常定义。
三、核心设计
本案例以观察者模式为核心，主题对象 ProcessSubject 维护观察者列表，业务事件发生时通知所有已注册的观察者，实现业务模块之间的解耦。
四、数据模型
JewelryProcessDto 定义珠宝业务流程的核心字段，包括原料信息、采购核验、设计图纸、当前阶段、质检结果、订单金额、业务时间等。
五、日志组件
对标 .NET ILogger 的泛型日志体系，包含日志等级、控制台输出、文件输出、日志工厂等实现，支持多线程安全写入。
六、观察者实现
各业务部门观察者实现 IProcessObserver 接口，在收到业务事件后执行各自的业务逻辑，如采购核验、加工生产、质量检测、成品包装、物流出库、财务结算等。
七、调度与调用
JewelryProcessScheduler 作为业务流程调度器，驱动整个业务流转并触发观察者通知；ObserverBll 演示完整的组装与调用过程。
八、运行输出
展示案例运行后的控制台与文件日志输出效果，验证各观察者是否正确响应业务事件。
九、总结
总结观察者模式在珠宝加工业务流程中的应用价值，以及日志组件、DI 容器等配套设计的实践要点。
项目结构：
java
* 原料名称：钻石/红宝石/翡翠等
*/
private String materialName;
/**
* 原料重量 克拉
*/
private double weightCarat;
/**
* 采购核验是否通过
*/
private boolean purchaseVerified;
/**
* 设计图纸编号
*/
private String drawingNo;
/**
* 当前流程阶段：采购｜设计｜加工｜质检｜包装｜物流｜财务
*/
private String currentStage;
/**
* 质检结果
*/
private boolean qualityPass;
/**
* 订单金额
*/
private BigDecimal orderAmount;
/**
* 业务发生时间
*/
private LocalDateTime businessTime;
/**
* 备注信息
*/
private String remark;
public String getProcessNo() {
return processNo;
}
public void setProcessNo(String processNo) {
this.processNo = processNo;
}
public String getMaterialCode() {
return materialCode;
}
public void setMaterialCode(String materialCode) {
this.materialCode = materialCode;
}
public String getMaterialName() {
return materialName;
}
public void setMaterialName(String materialName) {
this.materialName = materialName;
}
public double getWeightCarat() {
return weightCarat;
}
public void setWeightCarat(double weightCarat) {
this.weightCarat = weightCarat;
}
public boolean isPurchaseVerified() {
return purchaseVerified;
}
public void setPurchaseVerified(boolean purchaseVerified) {
this.purchaseVerified = purchaseVerified;
}
public String getDrawingNo() {
return drawingNo;
}
public void setDrawingNo(String drawingNo) {
this.drawingNo = drawingNo;
}
public String getCurrentStage() {
return currentStage;
}
public void setCurrentStage(String currentStage) {
this.currentStage = currentStage;
}
public boolean isQualityPass() {
return qualityPass;
}
public void setQualityPass(boolean qualityPass) {
this.qualityPass = qualityPass;
}
public BigDecimal getOrderAmount() {
return orderAmount;
}
public void setOrderAmount(BigDecimal orderAmount) {
this.orderAmount = orderAmount;
}
public LocalDateTime getBusinessTime() {
return businessTime;
}
public void setBusinessTime(LocalDateTime businessTime) {
this.businessTime = businessTime;
}
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
@Override
public String toString() {
return "JewelryProcessDto{" +
"processNo='" + processNo + '\'' +
", materialCode='" + materialCode + '\'' +
", materialName='" + materialName + '\'' +
", weightCarat=" + weightCarat +
", purchaseVerified=" + purchaseVerified +
", drawingNo='" + drawingNo + '\'' +
", currentStage='" + currentStage + '\'' +
", qualityPass=" + qualityPass +
", orderAmount=" + orderAmount +
", businessTime=" + businessTime +
", remark='" + remark + '\'' +
'}';
}
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
Author : geovindu,Geovin Du 涂聚文.
IDE : IntelliJ IDEA 2024.3.6 Java 21
database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS : window10
Datetime : 2026 - 2026/9/8 - 22:02
User : geovindu
Product : IntelliJ IDEA
Project : javadesginpattern
File : ConsoleLogHandler.java
explain : 学习 类
**/
package ObserverPattern.logging;
/**
控制台日志输出处理器
/
public class ConsoleLogHandler {
/*
将日志输出至System控制台
@param msg 日志消息对象
*/
public void write(LogMessage msg) {
StringBuilder sb = new StringBuilder();
sb.append(msg.time).append(" [").append(msg.level).append("] ")
.append("[").append(msg.categoryName).append("] ")
.append(msg.message);
if(msg.exception != null) {
sb.append(System.lineSeparator());
sb.append(getExceptionStack(msg.exception));
}
System.out.println(sb);
}
/**
获取异常堆栈字符串
*/
private String getExceptionStack(Throwable ex) {
StringBuilder stack = new StringBuilder();
stack.append(ex.getMessage()).append(System.lineSeparator());
for(StackTraceElement ele : ex.getStackTrace()){
stack.append("\t").append(ele.toString()).append(System.lineSeparator());
}
return stack.toString();
}
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
Author : geovindu,Geovin Du 涂聚文.
IDE : IntelliJ IDEA 2024.3.6 Java 21
database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS : window10
Datetime : 2026 - 2026/9/8 - 22:02
User : geovindu
Product : IntelliJ IDEA
Project : javadesginpattern
File : FileLogHandler.java
explain : 学习 类
**/
package ObserverPattern.logging;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.locks.ReentrantLock;
/**
文件日志处理器：对标Karambolo.Extensions.Logging.File
目录结构 Logs/yyyy‑MM‑dd/app‑{level}.log
多线程并发写入：ReentrantLock保证线程安全
/
public class FileLogHandler {
/*
文件写入锁，保证高并发线程安全
/
private final ReentrantLock writeLock;
/*
日志根目录
/
private final String rootLogDir;
/*
日期格式化 yyyy‑MM‑dd
*/
private final DateTimeFormatter dateFormatter;
public FileLogHandler(String rootLogDir) {
this.rootLogDir = rootLogDir;
this.writeLock = new ReentrantLock();
this.dateFormatter = DateTimeFormatter.ofPattern("yyyy‑MM‑dd");
}
/**
写日志文件
@param msg 日志消息
*/
public void write(LogMessage msg) {
writeLock.lock();
try {
// 构建日期文件夹路径 Logs/2026‑09‑08
String dateFolderName = LocalDate.now().format(dateFormatter);
File dateDir = new File(rootLogDir, dateFolderName);
if (!dateDir.exists()) {
dateDir.mkdirs();
}
// 文件名称 app‑debug.log / app‑info.log / app‑warn.log / app‑error.log
String fileName = switch (msg.level) {
case Debug -> "app‑debug.log";
case Info -> "app‑info.log";
case Warn -> "app‑warn.log";
case Error -> "app‑error.log";
};
File targetFile = new File(dateDir, fileName);
StringBuilder sb = new StringBuilder();
sb.append(msg.time).append(" [").append(msg.level).append("] ")
.append("[").append(msg.categoryName).append("] ")
.append(msg.message);
if(msg.exception != null) {
sb.append(System.lineSeparator());
sb.append(getExceptionStack(msg.exception));
}
sb.append(System.lineSeparator());
try(FileWriter fw = new FileWriter(targetFile, true)) {
fw.write(sb.toString());
fw.flush();
}
} catch (IOException e) {
// 文件日志写入失败，输出控制台兜底
System.err.println("文件日志写入异常:" + e.getMessage());
} finally {
writeLock.unlock();
}
}
/**
获取异常堆栈字符串
*/
private String getExceptionStack(Throwable ex) {
StringBuilder stack = new StringBuilder();
stack.append(ex.getMessage()).append(System.lineSeparator());
for(StackTraceElement ele : ex.getStackTrace()){
stack.append("\t").append(ele.toString()).append(System.lineSeparator());
}
return stack.toString();
}
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
Author : geovindu,Geovin Du 涂聚文.
IDE : IntelliJ IDEA 2024.3.6 Java 21
database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS : window10
Datetime : 2026 - 2026/9/8 - 22:02
User : geovindu
Product : IntelliJ IDEA
Project : javadesginpattern
File : ILogger.java
explain : 学习 类
**/
package ObserverPattern.logging;
/**
泛型日志接口，对标 .NET ILogger<T>
@param <T> 业务类型，用作日志分类
/
public interface ILogger<T> {
/*
调试日志
@param format 格式化字符串
@param args 参数
*/
void debug(String format, Object... args);
/**
信息日志
@param format 格式化字符串
@param args 参数
*/
void info(String format, Object... args);
/**
警告日志
@param format 格式化字符串
@param args 参数
*/
void warn(String format, Object... args);
/**
错误日志
@param format 格式化字符串
@param args 参数
*/
void error(String format, Object... args);
/**
错误日志附带异常
@param ex 异常对象
@param format 格式化字符串
@param args 参数
*/
void error(Throwable ex, String format, Object... args);
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
Author : geovindu,Geovin Du 涂聚文.
IDE : IntelliJ IDEA 2024.3.6 Java 21
database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS : window10
Datetime : 2026 - 2026/9/8 - 22:02
User : geovindu
Product : IntelliJ IDEA
Project : javadesginpattern
File : ILoggerFactory.java
explain : 学习 类
**/
package ObserverPattern.logging;
/**
日志工厂接口，创建ILogger实例
/
public interface ILoggerFactory {
/*
根据Class创建日志实例
@param clazz 业务类
@return ILogger
*/
<T> ILogger<T> createLogger(Class<T> clazz);
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
Author : geovindu,Geovin Du 涂聚文.
IDE : IntelliJ IDEA 2024.3.6 Java 21
database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS : window10
Datetime : 2026 - 2026/9/8 - 22:03
User : geovindu
Product : IntelliJ IDEA
Project : javadesginpattern
File : LoggerFactoryImpl.java
explain : 学习 类
**/
package ObserverPattern.logging;
import java.time.LocalDateTime;
/**
ILoggerFactory 实现，创建ILogger<T>实例
*/
public class LoggerFactoryImpl implements ILoggerFactory {
private final ConsoleLogHandler consoleHandler;
private final FileLogHandler fileHandler;
public LoggerFactoryImpl(ConsoleLogHandler consoleHandler, FileLogHandler fileHandler) {
this.consoleHandler = consoleHandler;
this.fileHandler = fileHandler;
}
@Override
@SuppressWarnings("unchecked")
public <T> ILogger<T> createLogger(Class<T> clazz) {
return new ILogger<>() {
private final String category = clazz.getName();
@Override
public void debug(String format, Object... args) {
log(LogLevel.Debug, null, format, args);
}
@Override
public void info(String format, Object... args) {
log(LogLevel.Info, null, format, args);
}
@Override
public void warn(String format, Object... args) {
log(LogLevel.Warn, null, format, args);
}
@Override
public void error(String format, Object... args) {
log(LogLevel.Error, null, format, args);
}
@Override
public void error(Throwable ex, String format, Object... args) {
log(LogLevel.Error, ex, format, args);
}
private void log(LogLevel level, Throwable ex, String format, Object[] args) {
LogMessage lm = new LogMessage();
lm.time = LocalDateTime.now();
lm.level = level;
lm.categoryName = category;
lm.message = String.format(format, args);
lm.exception = ex;
consoleHandler.write(lm);
fileHandler.write(lm);
}
};
}
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
Author : geovindu,Geovin Du 涂聚文.
IDE : IntelliJ IDEA 2024.3.6 Java 21
database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS : window10
Datetime : 2026 - 2026/9/8 - 22:02
User : geovindu
Product : IntelliJ IDEA
Project : javadesginpattern
File : LogLevel.java
explain : 学习 类
**/
package ObserverPattern.logging;
/**
日志等级定义，与 .NET Microsoft.Extensions.Logging对齐
/
public enum LogLevel {
/*
调试日志
/
Debug,
/*
信息日志
/
Info,
/*
警告日志
/
Warn,
/*
错误日志
*/
Error
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
Author : geovindu,Geovin Du 涂聚文.
IDE : IntelliJ IDEA 2024.3.6 Java 21
database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS : window10
Datetime : 2026 - 2026/9/8 - 22:03
User : geovindu
Product : IntelliJ IDEA
Project : javadesginpattern
File : LogMessage.java
explain : 学习 类
**/
package ObserverPattern.logging;
import java.time.LocalDateTime;
/**
日志消息实体
/
public class LogMessage {
/*
日志发生时间
/
public LocalDateTime time;
/*
日志等级
/
public LogLevel level;
/*
日志分类名称（类名）
/
public String categoryName;
/*
格式化之后消息文本
/
public String message;
/*
异常堆栈信息
*/
public Throwable exception;
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
Author : geovindu,Geovin Du 涂聚文.
IDE : IntelliJ IDEA 2024.3.6 Java 21
database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS : window10
Datetime : 2026 - 2026/9/8 - 22:01
User : geovindu
Product : IntelliJ IDEA
Project : javadesginpattern
File : CircuitBreakerExceptio.java
explain : 学习 类
**/
package ObserverPattern.circuit;
/**
熔断器触发抛出异常
*/
public class CircuitBreakerException extends RuntimeException {
public CircuitBreakerException(String msg) {
super(msg);
}
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
Author : geovindu,Geovin Du 涂聚文.
IDE : IntelliJ IDEA 2024.3.6 Java 21
database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS : window10
Datetime : 2026 - 2026/9/8 - 22:00
User : geovindu
Product : IntelliJ IDEA
Project : javadesginpattern
File : CircuitBreakerState.java
explain : 学习 类
**/
package ObserverPattern.circuit;
/**
熔断器状态：关闭｜打开｜半开
/
public enum CircuitBreakerState {
/*
关闭：正常调用
/
Closed,
/*
打开：熔断，直接拒绝调用
/
Open,
/*
半开：允许少量试探请求
*/
HalfOpen
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
Author : geovindu,Geovin Du 涂聚文.
IDE : IntelliJ IDEA 2024.3.6 Java 21
database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS : window10
Datetime : 2026 - 2026/9/8 - 22:01
User : geovindu
Product : IntelliJ IDEA
Project : javadesginpattern
File : RetryCircuitAdapter.java
explain : 学习 类
**/
package ObserverPattern.circuit;
import ObserverPattern.logging.ILogger;
import ObserverPattern.logging.ILoggerFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
重试熔断适配器，适配器模式实现
线程安全：AtomicInteger计数
/
public class RetryCircuitAdapter {
private final ILogger<RetryCircuitAdapter> logger;
/*
当前熔断器状态
/
private CircuitBreakerState state;
/*
失败计数器，原子类型保证并发安全
/
private final AtomicInteger failCounter;
/*
最大允许失败阈值
/
private final int failThreshold;
/*
最大重试次数
*/
private final int maxRetryTimes;
public RetryCircuitAdapter(ILoggerFactory factory, int failThreshold, int maxRetryTimes) {
this.logger = factory.createLogger(RetryCircuitAdapter.class);
this.state = CircuitBreakerState.Closed;
this.failCounter = new AtomicInteger(0);
this.failThreshold = failThreshold;
this.maxRetryTimes = maxRetryTimes;
}
/**
执行带重试+熔断保护的业务调用
@param action 需要执行的业务逻辑
@return 业务返回结果
@throws Exception 业务异常 / 熔断异常
*/
public <T> T execute(Supplier<T> action) throws Exception {
// 判断熔断打开状态
if (state == CircuitBreakerState.Open) {
logger.warn("熔断器已打开，拒绝执行业务调用");
throw new CircuitBreakerException("熔断器打开，请求被拦截");
}
int retryCount = 0;
while (true) {
try {
T result = action.get();
// 调用成功，重置失败计数器
failCounter.set(0);
if (state == CircuitBreakerState.HalfOpen) {
state = CircuitBreakerState.Closed;
logger.info("半开状态试探调用成功，熔断器切换关闭");
}
return result;
} catch (Exception ex) {
int currentFail = failCounter.incrementAndGet();
logger.error(ex, "业务调用失败，重试次数:{0},累计失败:{1}", retryCount, currentFail);
// 判断是否触发熔断阈值
if (currentFail >= failThreshold) {
state = CircuitBreakerState.Open;
logger.error("达到失败阈值，熔断器切换Open状态");
throw new CircuitBreakerException("触发熔断阈值"+ ex.getMessage());
}
retryCount++;
if (retryCount >= maxRetryTimes) {
logger.error("已达到最大重试次数，终止调用");
throw ex;
}
Thread.sleep(200);
}
}
}
/**
手动切换熔断器半开状态，用于恢复探测
*/
public void switchHalfOpen() {
this.state = CircuitBreakerState.HalfOpen;
logger.info("手动切换熔断器至半开状态");
}
/**
函数式接口，模拟JDK Supplier，兼容异常抛出
*/
@FunctionalInterface
public interface Supplier<T> {
T get() throws Exception;
}
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
Author : geovindu,Geovin Du 涂聚文.
IDE : IntelliJ IDEA 2024.3.6 Java 21
database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS : window10
Datetime : 2026 - 2026/9/8 - 22:04
User : geovindu
Product : IntelliJ IDEA
Project : javadesginpattern
File : DiContainer.java
explain : 学习 类
**/
package ObserverPattern.di;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.lang.reflect.Constructor;
/**
简易DI容器，非Spring实现
线程安全 ConcurrentHashMap存储服务元数据
*/
public class DiContainer {
private final List<ServiceDescriptor> serviceDescriptors;
private final Map<Class<?>, Object> singletonCache;
public DiContainer() {
serviceDescriptors = new ArrayList<>();
singletonCache = new ConcurrentHashMap<>();
}
/**
注册单例服务
@param serviceType 接口
@param implType 实现类
*/
public void addSingleton(Class<?> serviceType, Class<?> implType) {
ServiceDescriptor sd = new ServiceDescriptor();
sd.serviceType = serviceType;
sd.implType = implType;
sd.lifetime = ServiceLifetime.Singleton;
serviceDescriptors.add(sd);
}
/**
注册瞬时服务
@param serviceType 接口
@param implType 实现类
*/
public void addTransient(Class<?> serviceType, Class<?> implType) {
ServiceDescriptor sd = new ServiceDescriptor();
sd.serviceType = serviceType;
sd.implType = implType;
sd.lifetime = ServiceLifetime.Transient;
serviceDescriptors.add(sd);
}
/**
直接注册已经实例化好的单例对象
@param serviceType 服务类型
@param instance 对象实例
*/
public void addSingletonInstance(Class<?> serviceType, Object instance) {
ServiceDescriptor sd = new ServiceDescriptor();
sd.serviceType = serviceType;
sd.implType = instance.getClass();
sd.lifetime = ServiceLifetime.Singleton;
sd.singletonInstance = instance;
serviceDescriptors.add(sd);
singletonCache.put(serviceType, instance);
}
/**
获取服务实例，递归解析构造函数依赖
@param clazz 需要获取的服务类型
@return 对象实例
*/
@SuppressWarnings("unchecked")
public <T> T getService(Class<T> clazz) {
for (ServiceDescriptor sd : serviceDescriptors) {
if (!sd.serviceType.isAssignableFrom(clazz) && !sd.serviceType.equals(clazz)) {
continue;
}
// 单例
if(sd.lifetime == ServiceLifetime.Singleton) {
if(singletonCache.containsKey(sd.serviceType)) {
return (T) singletonCache.get(sd.serviceType);
}
Object instance = createInstance(sd.implType);
singletonCache.put(sd.serviceType, instance);
return (T) instance;
} else {
// Transient
return (T) createInstance(sd.implType);
}
}
throw new RuntimeException("DI容器找不到服务:" + clazz.getName());
}
/**
通过反射构造函数创建实例，自动解析依赖参数
*/
private Object createInstance(Class<?> implClazz) {
Constructor<?>[] constructors = implClazz.getConstructors();
Constructor<?> targetCtor = constructors[0];
Class<?>[] paramTypes = targetCtor.getParameterTypes();
Object[] paramInstances = new Object[paramTypes.length];
for(int i=0;i<paramTypes.length;i++){
paramInstances[i] = getService(paramTypes[i]);
}
try {
return targetCtor.newInstance(paramInstances);
} catch (Exception e) {
throw new RuntimeException("实例化失败 class:" + implClazz.getName(), e);
}
}
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
Author : geovindu,Geovin Du 涂聚文.
IDE : IntelliJ IDEA 2024.3.6 Java 21
database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS : window10
Datetime : 2026 - 2026/9/8 - 22:03
User : geovindu
Product : IntelliJ IDEA
Project : javadesginpattern
File : ServiceDescriptor.java
explain : 学习 类
**/
package ObserverPattern.di;
/**
服务注册描述信息
/
public class ServiceDescriptor {
/*
服务接口Class
/
public Class<?> serviceType;
/*
实现类Class
/
public Class<?> implType;
/*
生命周期
/
public ServiceLifetime lifetime;
/*
单例实例缓存
*/
public Object singletonInstance;
}
/**
encoding: utf-8
版权所有 2026 ©涂聚文有限公司 ®
许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
Author : geovindu,Geovin Du 涂聚文.
IDE : IntelliJ IDEA 2024.3.6 Java 21
database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
OS : window10
Datetime : 2026 - 2026/9/8 - 22:03
User : geovindu
Product : IntelliJ IDEA
Project : javadesginpattern
File : ServiceLifetime.java
explain : 学习 类
**/
package ObserverPattern.di;
/**
服务生命周期：单例 / 瞬时
/
public enum ServiceLifetime {
/*
单例，全局唯一实例
/
Singleton,
/*
瞬时，每次获取新建对象
*/
Transient
}
java
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：
* Author : geovindu,Geovin Du 涂聚文.
* IDE : IntelliJ IDEA 2024.3.6 Java 21
* # database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
* # OS : window10
* Datetime : 2026 - 2026/9/8 - 21:56
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : PurchaseVerifyObserver.java
* explain : 学习 类
**/
package ObserverPattern.observer;
import ObserverPattern.dto.JewelryProcessDto;
/**
* 珠宝业务流程观察者接口
* 所有业务部门：采购、设计、生产、质检、财务等实现此接口
*/
public interface IProcessObserver {
/**
* 接收主题推送业务变更通知
* @param dto 珠宝流程业务数据
*/
void update(JewelryProcessDto dto);
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：
* Author : geovindu,Geovin Du 涂聚文.
* IDE : IntelliJ IDEA 2024.3.6 Java 21
* # database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
* # OS : window10
* Datetime : 2026 - 2026/9/8 - 21:56
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : ProcessSubject.java
* explain : 学习 类
**/
package ObserverPattern.observer;
import ObserverPattern.dto.JewelryProcessDto;
import java.util.ArrayList;
import java.util.List;
/**
* 珠宝业务流程主题 Subject
* 维护观察者集合，业务状态变更时通知全部订阅部门
*/
public class ProcessSubject {
/**
* 订阅观察者集合
*/
private final List<IProcessObserver> observerList;
public ProcessSubject() {
observerList = new ArrayList<>();
}
/**
* 注册观察者（订阅业务事件）
* @param observer 业务部门观察者
*/
public void attach(IProcessObserver observer) {
if (!observerList.contains(observer)) {
observerList.add(observer);
}
}
/**
* 移除观察者（取消订阅）
* @param observer 业务部门观察者
*/
public void detach(IProcessObserver observer) {
observerList.remove(observer);
}
/**
* 通知全部已订阅观察者
* @param dto 珠宝流程业务数据
*/
public void notifyAllObservers(JewelryProcessDto dto) {
for (IProcessObserver obs : observerList) {
obs.update(dto);
}
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
* Author : geovindu,Geovin Du 涂聚文.
* IDE : IntelliJ IDEA 2024.3.6 Java 21
* # database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
* # OS : window10
* Datetime : 2026 - 2026/9/8 - 21:59
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : BusinessDeptObserver.java
* explain : 学习 类
**/
package ObserverPattern.observer.observers;
import ObserverPattern.dto.JewelryProcessDto;
import ObserverPattern.logging.ILogger;
import ObserverPattern.logging.ILoggerFactory;
import ObserverPattern.observer.IProcessObserver;
/**
* 业务部门观察者
*/
public class BusinessDeptObserver implements IProcessObserver {
private final ILogger<BusinessDeptObserver> logger;
public BusinessDeptObserver(ILoggerFactory factory) {
this.logger = factory.createLogger(BusinessDeptObserver.class);
}
@Override
public void update(JewelryProcessDto dto) {
logger.info("【业务部】跟进客户订单流程:%s", dto.getProcessNo());
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
* Author : geovindu,Geovin Du 涂聚文.
* IDE : IntelliJ IDEA 2024.3.6 Java 21
* # database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
* # OS : window10
* Datetime : 2026 - 2026/9/8 - 21:57
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : DesignDrawObserver.java
* explain : 学习 类
**/
package ObserverPattern.observer.observers;
import ObserverPattern.dto.JewelryProcessDto;
import ObserverPattern.logging.ILogger;
import ObserverPattern.logging.ILoggerFactory;
import ObserverPattern.observer.IProcessObserver;
/**
* 设计制图部门观察者
*/
public class DesignDrawObserver implements IProcessObserver {
private final ILogger<DesignDrawObserver> logger;
public DesignDrawObserver(ILoggerFactory factory) {
this.logger = factory.createLogger(DesignDrawObserver.class);
}
@Override
public void update(JewelryProcessDto dto) {
logger.info("【设计制图】接收流程:%s,图纸编号:%s", dto.getProcessNo(), dto.getDrawingNo());
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
* Author : geovindu,Geovin Du 涂聚文.
* IDE : IntelliJ IDEA 2024.3.6 Java 21
* # database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
* # OS : window10
* Datetime : 2026 - 2026/9/8 - 21:58
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : FinanceObserver.java
* explain : 学习 类
**/
package ObserverPattern.observer.observers;
import ObserverPattern.dto.JewelryProcessDto;
import ObserverPattern.logging.ILogger;
import ObserverPattern.logging.ILoggerFactory;
import ObserverPattern.observer.IProcessObserver;
/**
* 财务部门观察者
*/
public class FinanceObserver implements IProcessObserver {
private final ILogger<FinanceObserver> logger;
public FinanceObserver(ILoggerFactory factory) {
this.logger = factory.createLogger(FinanceObserver.class);
}
@Override
public void update(JewelryProcessDto dto) {
logger.info("【财务部】流程%s 订单金额:%s", dto.getProcessNo(), dto.getOrderAmount());
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
* Author : geovindu,Geovin Du 涂聚文.
* IDE : IntelliJ IDEA 2024.3.6 Java 21
* # database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
* # OS : window10
* Datetime : 2026 - 2026/9/8 - 21:59
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : HrAdminObserver.java
* explain : 学习 类
**/
package ObserverPattern.observer.observers;
import ObserverPattern.dto.JewelryProcessDto;
import ObserverPattern.logging.ILogger;
import ObserverPattern.logging.ILoggerFactory;
import ObserverPattern.observer.IProcessObserver;
/**
* 人事行政观察者
*/
public class HrAdminObserver implements IProcessObserver {
private final ILogger<HrAdminObserver> logger;
public HrAdminObserver(ILoggerFactory factory) {
this.logger = factory.createLogger(HrAdminObserver.class);
}
@Override
public void update(JewelryProcessDto dto) {
logger.info("【人事行政】记录生产业务事件:%s", dto.getProcessNo());
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
* Author : geovindu,Geovin Du 涂聚文.
* IDE : IntelliJ IDEA 2024.3.6 Java 21
* # database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
* # OS : window10
* Datetime : 2026 - 2026/9/8 - 22:00
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : ItDeptObserver.java
* explain : 学习 类
**/
package ObserverPattern.observer.observers;
import ObserverPattern.dto.JewelryProcessDto;
import ObserverPattern.logging.ILogger;
import ObserverPattern.logging.ILoggerFactory;
import ObserverPattern.observer.IProcessObserver;
/**
* IT运维部门观察者
*/
public class ItDeptObserver implements IProcessObserver {
private final ILogger<ItDeptObserver> logger;
public ItDeptObserver(ILoggerFactory factory) {
this.logger = factory.createLogger(ItDeptObserver.class);
}
@Override
public void update(JewelryProcessDto dto) {
logger.info("【IT部门】业务事件落库，流程编号:%s", dto.getProcessNo());
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
* Author : geovindu,Geovin Du 涂聚文.
* IDE : IntelliJ IDEA 2024.3.6 Java 21
* # database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
* # OS : window10
* Datetime : 2026 - 2026/9/8 - 21:58
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : LogisticsObserver.java
* explain : 学习 类
**/
package ObserverPattern.observer.observers;
import ObserverPattern.dto.JewelryProcessDto;
import ObserverPattern.logging.ILogger;
import ObserverPattern.logging.ILoggerFactory;
import ObserverPattern.observer.IProcessObserver;
/**
* 物流仓储观察者
*/
public class LogisticsObserver implements IProcessObserver {
private final ILogger<LogisticsObserver> logger;
public LogisticsObserver(ILoggerFactory factory) {
this.logger = factory.createLogger(LogisticsObserver.class);
}
@Override
public void update(JewelryProcessDto dto) {
logger.info("【物流部门】流程%s准备出库发货", dto.getProcessNo());
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
* Author : geovindu,Geovin Du 涂聚文.
* IDE : IntelliJ IDEA 2024.3.6 Java 21
* # database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
* # OS : window10
* Datetime : 2026 - 2026/9/8 - 21:57
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : ManufactureObserver.java
* explain : 学习 类
**/
package ObserverPattern.observer.observers;
import ObserverPattern.dto.JewelryProcessDto;
import ObserverPattern.logging.ILogger;
import ObserverPattern.logging.ILoggerFactory;
import ObserverPattern.observer.IProcessObserver;
/**
* 加工生产车间观察者
*/
public class ManufactureObserver implements IProcessObserver {
private final ILogger<ManufactureObserver> logger;
public ManufactureObserver(ILoggerFactory factory) {
this.logger = factory.createLogger(ManufactureObserver.class);
}
@Override
public void update(JewelryProcessDto dto) {
logger.info("【加工生产车间】开始加工 流程号:%s", dto.getProcessNo());
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
* Author : geovindu,Geovin Du 涂聚文.
* IDE : IntelliJ IDEA 2024.3.6 Java 21
* # database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
* # OS : window10
* Datetime : 2026 - 2026/9/8 - 21:58
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : MarketingObserver.java
* explain : 学习 类
**/
package ObserverPattern.observer.observers;
import ObserverPattern.dto.JewelryProcessDto;
import ObserverPattern.logging.ILogger;
import ObserverPattern.logging.ILoggerFactory;
import ObserverPattern.observer.IProcessObserver;
/**
* 营销推广部门观察者
*/
public class MarketingObserver implements IProcessObserver {
private final ILogger<MarketingObserver> logger;
public MarketingObserver(ILoggerFactory factory) {
this.logger = factory.createLogger(MarketingObserver.class);
}
@Override
public void update(JewelryProcessDto dto) {
logger.info("【营销推广】新品流程%s，准备营销素材", dto.getProcessNo());
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
* Author : geovindu,Geovin Du 涂聚文.
* IDE : IntelliJ IDEA 2024.3.6 Java 21
* # database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
* # OS : window10
* Datetime : 2026 - 2026/9/8 - 21:58
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : PackObserver.java
* explain : 学习 类
**/
package ObserverPattern.observer.observers;
import ObserverPattern.dto.JewelryProcessDto;
import ObserverPattern.logging.ILogger;
import ObserverPattern.logging.ILoggerFactory;
import ObserverPattern.observer.IProcessObserver;
/**
* 成品包装部门观察者
*/
public class PackObserver implements IProcessObserver {
private final ILogger<PackObserver> logger;
public PackObserver(ILoggerFactory factory) {
this.logger = factory.createLogger(PackObserver.class);
}
@Override
public void update(JewelryProcessDto dto) {
logger.info("【包装组】对流程%s成品进行包装作业", dto.getProcessNo());
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
* Author : geovindu,Geovin Du 涂聚文.
* IDE : IntelliJ IDEA 2024.3.6 Java 21
* # database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
* # OS : window10
* Datetime : 2026 - 2026/9/8 - 21:57
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : PurchaseVerifyObserver.java
* explain : 学习 类
**/
package ObserverPattern.observer.observers;
import ObserverPattern.dto.JewelryProcessDto;
import ObserverPattern.logging.ILogger;
import ObserverPattern.logging.ILoggerFactory;
import ObserverPattern.observer.IProcessObserver;
/**
* 原料采购核验观察者
*/
public class PurchaseVerifyObserver implements IProcessObserver {
private final ILogger<PurchaseVerifyObserver> logger;
public PurchaseVerifyObserver(ILoggerFactory factory) {
this.logger = factory.createLogger(PurchaseVerifyObserver.class);
}
@Override
public void update(JewelryProcessDto dto) {
logger.info("【原料采购核验】收到业务事件，流程号:%s", dto.getProcessNo());
if (dto.isPurchaseVerified()) {
logger.debug("原料%s核验通过，重量:%sct", dto.getMaterialName(), dto.getWeightCarat());
} else {
logger.warn("原料%s核验不通过，请复检", dto.getMaterialName());
}
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
* Author : geovindu,Geovin Du 涂聚文.
* IDE : IntelliJ IDEA 2024.3.6 Java 21
* # database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
* # OS : window10
* Datetime : 2026 - 2026/9/8 - 21:57
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : QualityCheckObserver.java
* explain : 学习 类
**/
package ObserverPattern.observer.observers;
import ObserverPattern.dto.JewelryProcessDto;
import ObserverPattern.logging.ILogger;
import ObserverPattern.logging.ILoggerFactory;
import ObserverPattern.observer.IProcessObserver;
/**
* 质量检测部门观察者
*/
public class QualityCheckObserver implements IProcessObserver {
private final ILogger<QualityCheckObserver> logger;
public QualityCheckObserver(ILoggerFactory factory) {
this.logger = factory.createLogger(QualityCheckObserver.class);
}
@Override
public void update(JewelryProcessDto dto) {
logger.info("【质检部门】流程:%s，质检结果:%s", dto.getProcessNo(), dto.isQualityPass()?"合格":"不合格");
if (!dto.isQualityPass()) {
logger.error("流程%s质检失败，需要返工", dto.getProcessNo());
}
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
* Author : geovindu,Geovin Du 涂聚文.
* IDE : IntelliJ IDEA 2024.3.6 Java 21
* # database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
* # OS : window10
* Datetime : 2026 - 2026/9/8 - 22:00
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : TrainingObserver.java
* explain : 学习 类
**/
package ObserverPattern.observer.observers;
import ObserverPattern.dto.JewelryProcessDto;
import ObserverPattern.logging.ILogger;
import ObserverPattern.logging.ILoggerFactory;
import ObserverPattern.observer.IProcessObserver;
/**
* 培训部门观察者
*/
public class TrainingObserver implements IProcessObserver {
private final ILogger<TrainingObserver> logger;
public TrainingObserver(ILoggerFactory factory) {
this.logger = factory.createLogger(TrainingObserver.class);
}
@Override
public void update(JewelryProcessDto dto) {
logger.info("【培训部】采集业务案例用于员工培训：%s", dto.getProcessNo());
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
* Author : geovindu,Geovin Du 涂聚文.
* IDE : IntelliJ IDEA 2024.3.6 Java 21
* # database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
* # OS : window10
* Datetime : 2026 - 2026/9/8 - 22:04
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : JewelryProcessScheduler.java
* explain : 学习 类
**/
package ObserverPattern.scheduler;
import ObserverPattern.dto.JewelryProcessDto;
import ObserverPattern.logging.ILogger;
import ObserverPattern.logging.ILoggerFactory;
import ObserverPattern.observer.ProcessSubject;
/**
* 珠宝业务流程调度器
* 驱动整个业务流转，触发观察者通知
*/
public class JewelryProcessScheduler {
private final ILogger<JewelryProcessScheduler> logger;
private final ProcessSubject processSubject;
public JewelryProcessScheduler(ILoggerFactory factory, ProcessSubject subject) {
this.logger = factory.createLogger(JewelryProcessScheduler.class);
this.processSubject = subject;
}
/**
* 执行业务流程调度
* @param dto 珠宝业务DTO
*/
public void runProcess(JewelryProcessDto dto) {
logger.info("===== 珠宝业务调度器启动，流程编号:{0} =====", dto.getProcessNo());
// 触发全部订阅观察者通知
processSubject.notifyAllObservers(dto);
logger.info("===== 珠宝业务调度器执行结束 =====");
}
}调用：
java
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：观察者模式 Observer Pattern 行为模式 Behavioral Patterns
* Author : geovindu,Geovin Du 涂聚文.
* IDE : IntelliJ IDEA 2024.3.6 Java 17
* # database : Oracle21c,MySQL 9.0,SQL Server 2019,PostgreSQL 17.1 Neo4j
* # OS : window10
* Datetime : 2026 - 2026/7/5 - 11:06
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : ObserverBll.java
* explain : 学习 类
**/
package BLL;
import ObserverPattern.di.DiContainer;
import ObserverPattern.dto.JewelryProcessDto;
import ObserverPattern.logging.ConsoleLogHandler;
import ObserverPattern.logging.FileLogHandler;
import ObserverPattern.logging.ILoggerFactory;
import ObserverPattern.logging.LoggerFactoryImpl;
import ObserverPattern.observer.ProcessSubject;
import ObserverPattern.observer.observers.*;
import ObserverPattern.scheduler.JewelryProcessScheduler;
import java.math.BigDecimal;
import java.time.LocalDateTime;
public class ObserverBll {
public void demo(){
//1.初始化日志组件
ConsoleLogHandler consoleLogHandler = new ConsoleLogHandler();
FileLogHandler fileLogHandler = new FileLogHandler("Logs");
ILoggerFactory loggerFactory = new LoggerFactoryImpl(consoleLogHandler, fileLogHandler);
//2.初始化DI容器，非Spring
DiContainer diContainer = new DiContainer();
diContainer.addSingletonInstance(ILoggerFactory.class, loggerFactory);
//3.实例化主题对象
ProcessSubject subject = new ProcessSubject();
// 注册全部业务观察者
subject.attach(new PurchaseVerifyObserver(loggerFactory));
subject.attach(new DesignDrawObserver(loggerFactory));
subject.attach(new ManufactureObserver(loggerFactory));
subject.attach(new QualityCheckObserver(loggerFactory));
subject.attach(new PackObserver(loggerFactory));
subject.attach(new LogisticsObserver(loggerFactory));
subject.attach(new FinanceObserver(loggerFactory));
subject.attach(new MarketingObserver(loggerFactory));
subject.attach(new BusinessDeptObserver(loggerFactory));
subject.attach(new HrAdminObserver(loggerFactory));
subject.attach(new ItDeptObserver(loggerFactory));
subject.attach(new TrainingObserver(loggerFactory));
//4.注册调度器
JewelryProcessScheduler scheduler = new JewelryProcessScheduler(loggerFactory, subject);
//5.构造测试业务DTO
JewelryProcessDto dto = new JewelryProcessDto();
dto.setProcessNo("JW‑20260908‑0001");
dto.setMaterialCode("MAT‑D‑00128");
dto.setMaterialName("天然钻石");
dto.setWeightCarat(1.28);
dto.setPurchaseVerified(true);
dto.setDrawingNo("DR‑2026‑1142");
dto.setCurrentStage("质检完成待包装");
dto.setQualityPass(true);
dto.setOrderAmount(new BigDecimal("26800.00"));
dto.setBusinessTime(LocalDateTime.now());
dto.setRemark("定制钻戒订单");
//6.执行调度流程
scheduler.runProcess(dto);
}
}输出：
