java: Composite Pattern
·
项目结构：
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 21:56
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : AbstractProcessNode.java
* explain : 学习 类
**/
package CompositePattern.core.composite;
import CompositePattern.core.exception.BusinessProcessException;
import org.slf4j.Logger;
import java.util.ArrayList;
import java.util.List;
/**
* 业务叶子节点抽象基类
* 封装公共日志、节点名称；默认实现叶子节点不支持子节点操作
* 所有12个业务叶子节点继承此类，对齐C# AbstractProcessNode
*/
public abstract class AbstractProcessNode implements IBusinessProcessNode {
/**
* 当前业务节点名称
*/
private final String nodeName;
/**
* 节点专属日志实例，DI注入隔离日志分类
*/
protected final Logger log;
/**
* 构造函数注入日志与节点名称
* @param log 当前类专属日志
* @param nodeName 业务节点中文名称
*/
protected AbstractProcessNode(Logger log, String nodeName) {
this.log = log;
this.nodeName = nodeName;
}
@Override
public String getNodeName() {
return this.nodeName;
}
/**
* 子类重写：实现当前节点专属业务逻辑
* @param businessOrderNo 业务单号
*/
@Override
public abstract void execute(String businessOrderNo);
/**
* 叶子节点默认实现：不支持添加子流程，抛出业务异常
*/
@Override
public void addChild(IBusinessProcessNode childNode) {
String errorMsg = String.format("叶子业务节点【%s】不支持挂载子业务流程", nodeName);
log.warn(errorMsg);
throw new BusinessProcessException(errorMsg, "未知", nodeName);
}
/**
* 叶子节点默认实现：无下属子流程，移除操作抛出异常
*/
@Override
public void removeChild(IBusinessProcessNode childNode) {
String errorMsg = String.format("叶子业务节点【%s】无下属子流程，无法移除", nodeName);
log.warn(errorMsg);
throw new BusinessProcessException(errorMsg, "未知", nodeName);
}
/**
* 叶子节点无任何子节点，返回空集合
*/
@Override
public List<IBusinessProcessNode> getChildren() {
return new ArrayList<>();
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 21:55
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : IBusinessProcessNode.java
* explain : 学习 类
**/
package CompositePattern.core.composite;
import java.util.List;
/**
* 组合模式顶层抽象构件接口
* 所有叶子业务节点、分组组合节点统一实现该接口
* 对外提供统一执行、增删子节点标准方法，完全对齐C# IBusinessProcessNode
*/
public interface IBusinessProcessNode {
/**
* 获取当前业务节点中文名称
* @return 节点名称
*/
String getNodeName();
/**
* 执行业务流程逻辑
* @param businessOrderNo 业务唯一订单编号
*/
void execute(String businessOrderNo);
/**
* 添加子业务节点
* 叶子节点实现抛出不支持异常；组合节点实现挂载子流程
* @param childNode 待添加子节点
*/
void addChild(IBusinessProcessNode childNode);
/**
* 移除指定子业务节点
* @param childNode 待移除子节点
*/
void removeChild(IBusinessProcessNode childNode);
/**
* 获取当前节点下全部子节点快照（线程安全副本，避免并发遍历冲突）
* @return 子节点集合
*/
List<IBusinessProcessNode> getChildren();
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 21:57
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : ProcessCompositeNode.java
* explain : 学习 类
**/
package CompositePattern.core.composite;
import CompositePattern.core.exception.BusinessProcessException;
import org.slf4j.Logger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* 组合模式容器节点（Composite）
* 用于分组管理多个子业务节点（叶子/其他组合节点）
* 内部集合操作加同步锁，保证多线程并发增删子节点线程安全，对齐C# ProcessCompositeNode
*/
public class ProcessCompositeNode implements IBusinessProcessNode {
/**
* 分组节点名称
*/
private final String nodeName;
/**
* 分组专属日志
*/
protected final Logger log;
/**
* 子节点存储集合
*/
private final List<IBusinessProcessNode> childNodes;
/**
* 线程安全同步锁对象
*/
private final Object syncLock;
/**
* 构造组合分组节点
* @param log 分组日志实例
* @param groupName 分组中文名称
*/
public ProcessCompositeNode(Logger log, String groupName) {
this.log = log;
this.nodeName = groupName;
this.childNodes = new ArrayList<>();
this.syncLock = new Object();
}
@Override
public String getNodeName() {
return this.nodeName;
}
/**
* 批量顺序执行分组下所有子业务流程
* 单个子流程异常仅记录日志，不阻断同组其他流程执行
* @param businessOrderNo 业务单号
*/
@Override
public void execute(String businessOrderNo) {
log.info("===== 开始执行业务分组【{}】，业务单号：{} =====", nodeName, businessOrderNo);
List<IBusinessProcessNode> snapshot;
synchronized (syncLock) {
snapshot = new ArrayList<>(childNodes);
}
for (IBusinessProcessNode child : snapshot) {
try {
child.execute(businessOrderNo);
} catch (BusinessProcessException busEx) {
log.error("分组【{}】子节点【{}】业务异常，单号：{}",
nodeName, child.getNodeName(), businessOrderNo, busEx);
} catch (Throwable ex) {
log.error("分组【{}】子节点【{}】系统未知异常，单号：{}",
nodeName, child.getNodeName(), businessOrderNo, ex);
}
}
log.info("===== 业务分组【{}】全部子流程执行完毕，业务单号：{} =====", nodeName, businessOrderNo);
}
/**
* 同步锁保护，线程安全添加子节点
* @param childNode 待挂载子流程
*/
@Override
public void addChild(IBusinessProcessNode childNode) {
synchronized (syncLock) {
childNodes.add(childNode);
log.debug("分组【{}】成功挂载子节点：{}", nodeName, childNode.getNodeName());
}
}
/**
* 同步锁保护，线程安全移除子节点
* @param childNode 待移除子流程
*/
@Override
public void removeChild(IBusinessProcessNode childNode) {
synchronized (syncLock) {
boolean removeResult = childNodes.remove(childNode);
if (removeResult) {
log.debug("分组【{}】移除子节点：{}", nodeName, childNode.getNodeName());
} else {
log.debug("分组【{}】未找到目标子节点【{}】，无需移除", nodeName, childNode.getNodeName());
}
}
}
/**
* 返回不可修改子节点快照副本，避免外部遍历锁竞争
*/
@Override
public List<IBusinessProcessNode> getChildren() {
synchronized (syncLock) {
return Collections.unmodifiableList(new ArrayList<>(childNodes));
}
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 21:54
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : BusinessProcessException.java
* explain : 学习 类
**/
package CompositePattern.core.exception;
/**
* 珠宝业务流程全局自定义异常
* 区分业务校验错误与系统底层异常，日志可单独识别业务单据信息
* 对齐C# BusinessProcessException
*/
public class BusinessProcessException extends RuntimeException {
/**
* 关联业务订单号
*/
private final String businessOrderNo;
/**
* 异常所属业务节点名称
*/
private final String processNodeName;
/**
* 构造基础业务异常
* @param message 异常描述信息
* @param businessOrderNo 业务单号
* @param processNodeName 出错节点名称
*/
public BusinessProcessException(String message, String businessOrderNo, String processNodeName) {
super(message);
this.businessOrderNo = businessOrderNo;
this.processNodeName = processNodeName;
}
/**
* 带原始堆栈的业务异常构造
* @param message 异常描述
* @param cause 原始异常对象
* @param businessOrderNo 业务单号
* @param processNodeName 出错节点名称
*/
public BusinessProcessException(String message, Throwable cause, String businessOrderNo, String processNodeName) {
super(message, cause);
this.businessOrderNo = businessOrderNo;
this.processNodeName = processNodeName;
}
public String getBusinessOrderNo() {
return businessOrderNo;
}
public String getProcessNodeName() {
return processNodeName;
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 22:20
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : AdminSupportComposite.java
* explain : 学习 类
**/
package CompositePattern.business.compositegroup;
import CompositePattern.core.composite.ProcessCompositeNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 业务分组组合节点：职能后台支撑链路
* 包含：财务、人事行政、IT、培训后台职能节点
*/
public class AdminSupportComposite extends ProcessCompositeNode {
private static final Logger log = LoggerFactory.getLogger(AdminSupportComposite.class);
public AdminSupportComposite() {
super(log, "职能后台支撑链路");
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 22:20
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : ProduceLinkComposite.java
* explain : 学习 类
**/
package CompositePattern.business.compositegroup;
import CompositePattern.core.composite.ProcessCompositeNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 业务分组组合节点：生产制造核心链路
* 包含：原料采购、设计、加工、质检、包装、物流全生产流程
*/
public class ProduceLinkComposite extends ProcessCompositeNode {
private static final Logger log = LoggerFactory.getLogger(ProduceLinkComposite.class);
public ProduceLinkComposite() {
super(log, "生产制造链路");
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 22:04
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : SaleLinkComposite.java
* explain : 学习 类
**/
package CompositePattern.business.compositegroup;
import CompositePattern.core.composite.ProcessCompositeNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 业务分组组合节点：前端销售链路
* 包含：业务销售、营销推广两个叶子节点
*/
public class SaleLinkComposite extends ProcessCompositeNode {
private static final Logger log = LoggerFactory.getLogger(SaleLinkComposite.class);
public SaleLinkComposite() {
super(log, "前端销售链路");
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 22:02
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : BusinessSaleNode.java
* explain : 学习 类
**/
package CompositePattern.business.node;
import CompositePattern.core.composite.AbstractProcessNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 叶子业务节点：业务销售
* 业务职责：客户洽谈、定制需求录入、销售订单合同建档
*/
public class BusinessSaleNode extends AbstractProcessNode {
private static final Logger log = LoggerFactory.getLogger(BusinessSaleNode.class);
public BusinessSaleNode() {
super(log, "业务");
}
@Override
public void execute(String businessOrderNo) {
log.debug("【{}】客户订单建档流程启动，订单号：{}", getNodeName(), businessOrderNo);
log.info("【{}】录入客户定制参数、签订销售合同、创建业务订单档案", getNodeName(), businessOrderNo);
log.debug("【{}】业务销售流程执行完毕，订单号：{}", getNodeName(), businessOrderNo);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 21:59
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : DesignDrawNode.java
* explain : 学习 类
**/
package CompositePattern.business.node;
import CompositePattern.core.composite.AbstractProcessNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 叶子业务节点：设计制图
* 业务职责：首饰3D建模、效果图渲染、生产图纸导出、方案归档
*/
public class DesignDrawNode extends AbstractProcessNode {
private static final Logger log = LoggerFactory.getLogger(DesignDrawNode.class);
public DesignDrawNode() {
super(log, "设计制图");
}
@Override
public void execute(String businessOrderNo) {
log.debug("【{}】首饰3D建模设计启动，订单号：{}", getNodeName(), businessOrderNo);
log.info("【{}】完成款式建模、尺寸标注、客户效果图渲染导出", getNodeName(), businessOrderNo);
log.info("【{}】图纸归档至设计资源库，下发至生产车间", getNodeName(), businessOrderNo);
log.debug("【{}】设计制图流程执行完毕，订单号：{}", getNodeName(), businessOrderNo);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 22:02
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : FinanceNode.java
* explain : 学习 类
**/
package CompositePattern.business.node;
import CompositePattern.core.composite.AbstractProcessNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 叶子业务节点：财务
* 业务职责：订单成本归集、销售开票、应收应付台账记账
*/
public class FinanceNode extends AbstractProcessNode {
private static final Logger log = LoggerFactory.getLogger(FinanceNode.class);
public FinanceNode() {
super(log, "财务");
}
@Override
public void execute(String businessOrderNo) {
log.debug("【{}】订单成本核算流程启动，订单号：{}", getNodeName(), businessOrderNo);
log.info("【{}】归集原料、加工、物流成本，开具销售发票，更新应收台账", getNodeName(), businessOrderNo);
log.debug("【{}】财务核算流程执行完毕，订单号：{}", getNodeName(), businessOrderNo);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 22:03
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : HrAdminNode.java
* explain : 学习 类
**/
package CompositePattern.business.node;
import CompositePattern.core.composite.AbstractProcessNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 叶子业务节点：人事行政
* 业务职责：车间工序工时统计、生产员工绩效台账更新
*/
public class HrAdminNode extends AbstractProcessNode {
private static final Logger log = LoggerFactory.getLogger(HrAdminNode.class);
public HrAdminNode() {
super(log, "人事行政");
}
@Override
public void execute(String businessOrderNo) {
log.debug("【{}】订单对应生产人员绩效统计启动，订单号：{}", getNodeName(), businessOrderNo);
log.info("【{}】统计各工序工时，更新车间员工绩效台账记录", getNodeName(), businessOrderNo);
log.debug("【{}】人事行政流程执行完毕，订单号：{}", getNodeName(), businessOrderNo);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 22:03
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : ItSystemNode.java
* explain : 学习 类
**/
package CompositePattern.business.node;
import CompositePattern.core.composite.AbstractProcessNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 叶子业务节点：IT运维
* 业务职责：订单业务数据备份、数据库归档、系统日志巡检
*/
public class ItSystemNode extends AbstractProcessNode {
private static final Logger log = LoggerFactory.getLogger(ItSystemNode.class);
public ItSystemNode() {
super(log, "IT");
}
@Override
public void execute(String businessOrderNo) {
log.debug("【{}】业务订单数据备份校验启动，订单号：{}", getNodeName(), businessOrderNo);
log.info("【{}】完成订单业务数据归档、数据库备份完整性校验", getNodeName(), businessOrderNo);
log.debug("【{}】IT运维流程执行完毕，订单号：{}", getNodeName(), businessOrderNo);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 22:01
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : LogisticsNode.java
* explain : 学习 类
**/
package CompositePattern.business.node;
import CompositePattern.core.composite.AbstractProcessNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 叶子业务节点：物流
* 业务职责：珠宝保价快递、物流单生成、配送跟踪台账登记
*/
public class LogisticsNode extends AbstractProcessNode {
private static final Logger log = LoggerFactory.getLogger(LogisticsNode.class);
public LogisticsNode() {
super(log, "物流");
}
@Override
public void execute(String businessOrderNo) {
log.debug("【{}】保价发货流程启动，订单号：{}", getNodeName(), businessOrderNo);
log.info("【{}】生成珠宝保价快递单据，录入物流跟踪管理台账", getNodeName(), businessOrderNo);
log.debug("【{}】物流流程执行完毕，订单号：{}", getNodeName(), businessOrderNo);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 21:59
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : ManufactureNode.java
* explain : 学习 类
**/
package CompositePattern.business.node;
import CompositePattern.core.composite.AbstractProcessNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 叶子业务节点：加工生产
* 业务职责：失蜡铸造、宝石镶嵌、粗抛、精抛车间工序流转
*/
public class ManufactureNode extends AbstractProcessNode {
private static final Logger log = LoggerFactory.getLogger(ManufactureNode.class);
public ManufactureNode() {
super(log, "加工生产");
}
@Override
public void execute(String businessOrderNo) {
log.debug("【{}】车间生产排产启动，订单号：{}", getNodeName(), businessOrderNo);
log.info("【{}】执行铸造、镶嵌、粗抛、精抛全生产工序", getNodeName(), businessOrderNo);
log.info("【{}】半成品流转至成品质检工位", getNodeName(), businessOrderNo);
log.debug("【{}】加工生产流程执行完毕，订单号：{}", getNodeName(), businessOrderNo);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 22:02
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : MarketingNode.java
* explain : 学习 类
**/
package CompositePattern.business.node;
import CompositePattern.core.composite.AbstractProcessNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 叶子业务节点：营销推广
* 业务职责：客户会员积分、用户标签、营销活动数据统计归档
*/
public class MarketingNode extends AbstractProcessNode {
private static final Logger log = LoggerFactory.getLogger(MarketingNode.class);
public MarketingNode() {
super(log, "营销推广");
}
@Override
public void execute(String businessOrderNo) {
log.debug("【{}】订单客户营销数据归档启动，订单号：{}", getNodeName(), businessOrderNo);
log.info("【{}】发放客户会员积分，更新客户用户标签，统计活动转化数据", getNodeName(), businessOrderNo);
log.debug("【{}】营销推广流程执行完毕，订单号：{}", getNodeName(), businessOrderNo);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 22:01
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : PackNode.java
* explain : 学习 类
**/
package CompositePattern.business.node;
import CompositePattern.core.composite.AbstractProcessNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 叶子业务节点：包装
* 业务职责：礼盒封装、配套证书、防尘防护、防伪封签粘贴
*/
public class PackNode extends AbstractProcessNode {
private static final Logger log = LoggerFactory.getLogger(PackNode.class);
public PackNode() {
super(log, "包装");
}
@Override
public void execute(String businessOrderNo) {
log.debug("【{}】成品打包作业启动，订单号：{}", getNodeName(), businessOrderNo);
log.info("【{}】首饰礼盒封装、配套证书放置、防伪封签粘贴完成", getNodeName(), businessOrderNo);
log.debug("【{}】包装流程执行完毕，订单号：{}", getNodeName(), businessOrderNo);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 22:00
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : QualityCheckNode.java
* explain : 学习 类
**/
package CompositePattern.business.node;
import CompositePattern.core.composite.AbstractProcessNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 叶子业务节点：质检
* 业务职责：重量、贵金属纯度、镶嵌牢固度、外观瑕疵全项检测
*/
public class QualityCheckNode extends AbstractProcessNode {
private static final Logger log = LoggerFactory.getLogger(QualityCheckNode.class);
public QualityCheckNode() {
super(log, "质检");
}
@Override
public void execute(String businessOrderNo) {
log.debug("【{}】成品综合检测启动，订单号：{}", getNodeName(), businessOrderNo);
log.info("【{}】称重、纯度检测、宝石牢固度、外观瑕疵逐项校验", getNodeName(), businessOrderNo);
log.info("【{}】合格品粘贴防伪证书，不良品标记退回车间返工", getNodeName(), businessOrderNo);
log.debug("【{}】质检流程执行完毕，订单号：{}", getNodeName(), businessOrderNo);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 21:58
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : RawMaterialPurchaseNode.java
* explain : 学习 类
**/
package CompositePattern.business.node;
import CompositePattern.core.composite.AbstractProcessNode;
import CompositePattern.core.exception.BusinessProcessException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 叶子业务节点：原料采购核验
* 业务职责：贵金属/宝石原料入库、资质核验、库存台账登记
*/
public class RawMaterialPurchaseNode extends AbstractProcessNode {
// 日志由静态工厂创建，Guice DI自动管理单例
private static final Logger log = LoggerFactory.getLogger(RawMaterialPurchaseNode.class);
public RawMaterialPurchaseNode() {
super(log, "原料采购核验");
}
/**
* 执行原料采购核验完整业务流程
* @param businessOrderNo 珠宝业务订单编号
*/
@Override
public void execute(String businessOrderNo) {
log.debug("【{}】原料入库校验流程启动，订单号：{}", getNodeName(), businessOrderNo);
log.info("【{}】核验贵金属纯度报告、宝石鉴定证书、供应商资质文件", getNodeName(), businessOrderNo);
// 模拟异常分支：订单后缀带ERR代表原料资质缺失
if (businessOrderNo.toUpperCase().endsWith("ERR")) {
String errMsg = "原料配套鉴定证书缺失，无法入库，需退回供应商重新提供";
log.warn("【{}】业务校验失败：{}，订单号：{}", getNodeName(), errMsg, businessOrderNo);
throw new BusinessProcessException(errMsg, businessOrderNo, getNodeName());
}
log.info("【{}】原料入库台账录入完成，原料库存数据同步更新", getNodeName(), businessOrderNo);
log.debug("【{}】原料采购核验流程执行完毕，订单号：{}", getNodeName(), businessOrderNo);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 22:04
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : TrainNode.java
* explain : 学习 类
**/
package CompositePattern.business.node;
import CompositePattern.core.composite.AbstractProcessNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 叶子业务节点：员工培训
* 业务职责：新款工艺培训台账、质检标准培训记录归档
*/
public class TrainNode extends AbstractProcessNode {
private static final Logger log = LoggerFactory.getLogger(TrainNode.class);
public TrainNode() {
super(log, "培训");
}
@Override
public void execute(String businessOrderNo) {
log.debug("【{}】新款工艺培训台账归档启动，订单号：{}", getNodeName(), businessOrderNo);
log.info("【{}】更新新款首饰工艺、质检标准培训记录台账", getNodeName(), businessOrderNo);
log.debug("【{}】员工培训流程执行完毕，订单号：{}", getNodeName(), businessOrderNo);
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 22:21
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : JewelryBusinessScheduler.java
* explain : 学习 类
**/
package CompositePattern.business.scheduler;
import CompositePattern.business.compositegroup.AdminSupportComposite;
import CompositePattern.business.compositegroup.ProduceLinkComposite;
import CompositePattern.business.compositegroup.SaleLinkComposite;
import CompositePattern.business.node.*;
import CompositePattern.core.composite.ProcessCompositeNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class JewelryBusinessScheduler {
private static final Logger log = LoggerFactory.getLogger(JewelryBusinessScheduler.class);
private final ProcessCompositeNode rootBusinessComposite;
private final BusinessSaleNode saleNode;
private final RawMaterialPurchaseNode materialNode;
private final DesignDrawNode designNode;
private final ManufactureNode manufactureNode;
private final QualityCheckNode qualityNode;
private final PackNode packNode;
private final LogisticsNode logisticsNode;
private final FinanceNode financeNode;
private final MarketingNode marketingNode;
private final HrAdminNode hrNode;
private final ItSystemNode itNode;
private final TrainNode trainNode;
private final SaleLinkComposite saleComposite;
private final ProduceLinkComposite produceComposite;
private final AdminSupportComposite adminComposite;
public JewelryBusinessScheduler() {
Logger rootLog = LoggerFactory.getLogger(ProcessCompositeNode.class);
this.rootBusinessComposite = new ProcessCompositeNode(rootLog, "珠宝全业务总流程根节点");
this.saleNode = new BusinessSaleNode();
this.materialNode = new RawMaterialPurchaseNode();
this.designNode = new DesignDrawNode();
this.manufactureNode = new ManufactureNode();
this.qualityNode = new QualityCheckNode();
this.packNode = new PackNode();
this.logisticsNode = new LogisticsNode();
this.financeNode = new FinanceNode();
this.marketingNode = new MarketingNode();
this.hrNode = new HrAdminNode();
this.itNode = new ItSystemNode();
this.trainNode = new TrainNode();
this.saleComposite = new SaleLinkComposite();
this.produceComposite = new ProduceLinkComposite();
this.adminComposite = new AdminSupportComposite();
}
public void initFullBusinessTreeStructure() {
log.info("调度器开始初始化珠宝全业务组合树形结构");
saleComposite.addChild(saleNode);
saleComposite.addChild(marketingNode);
produceComposite.addChild(materialNode);
produceComposite.addChild(designNode);
produceComposite.addChild(manufactureNode);
produceComposite.addChild(qualityNode);
produceComposite.addChild(packNode);
produceComposite.addChild(logisticsNode);
adminComposite.addChild(financeNode);
adminComposite.addChild(hrNode);
adminComposite.addChild(itNode);
adminComposite.addChild(trainNode);
rootBusinessComposite.addChild(saleComposite);
rootBusinessComposite.addChild(produceComposite);
rootBusinessComposite.addChild(adminComposite);
log.info("珠宝全业务树形组合结构初始化完成");
}
public void runSingleOrderFullProcess(String orderNo) {
log.info("调度器启动单订单完整业务流程，订单号：{}", orderNo);
try {
rootBusinessComposite.execute(orderNo);
log.info("调度器单订单全部业务流程执行完成，订单号：{}", orderNo);
} catch (Throwable ex) {
log.error("调度器顶层捕获订单全局未知异常，订单号：{}", orderNo, ex);
}
}
public void runMultiThreadBatchProcess(List<String> orderNoList) {
if (orderNoList == null || orderNoList.isEmpty()) {
log.warn("批量订单集合为空，跳过并发调度");
return;
}
log.info("调度器启动多线程高并发批量业务执行，待处理订单总数：{}", orderNoList.size());
ExecutorService executor = Executors.newFixedThreadPool(orderNoList.size());
for (String orderCode : orderNoList) {
executor.submit(() -> runSingleOrderFullProcess(orderCode));
}
executor.shutdown();
try {
if (!executor.awaitTermination(10, TimeUnit.MINUTES)) {
log.warn("批量任务执行超时，强制关闭线程池");
executor.shutdownNow();
}
} catch (InterruptedException e) {
log.error("批量调度线程被中断", e);
Thread.currentThread().interrupt();
}
log.info("多线程批量全部订单业务流程执行完毕");
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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/17 - 22:22
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : BusinessModule.java
* explain : 学习 类
**/
package CompositePattern.config;
import CompositePattern.business.compositegroup.AdminSupportComposite;
import CompositePattern.business.compositegroup.ProduceLinkComposite;
import CompositePattern.business.compositegroup.SaleLinkComposite;
import CompositePattern.business.node.*;
import CompositePattern.business.scheduler.JewelryBusinessScheduler;
import CompositePattern.core.composite.ProcessCompositeNode;
import com.google.inject.AbstractModule;
import com.google.inject.Provides;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Guice DI模块，一次性注册所有业务、组合、调度单例服务
* 对齐.NET ServiceCollectionExtensions，统一管理依赖注册
*/
public class BusinessModule extends AbstractModule {
private static final Logger log = LoggerFactory.getLogger(BusinessModule.class);
@Override
protected void configure() {
// 绑定12个叶子业务节点为单例
bind(RawMaterialPurchaseNode.class).asEagerSingleton();
bind(DesignDrawNode.class).asEagerSingleton();
bind(ManufactureNode.class).asEagerSingleton();
bind(QualityCheckNode.class).asEagerSingleton();
bind(PackNode.class).asEagerSingleton();
bind(LogisticsNode.class).asEagerSingleton();
bind(FinanceNode.class).asEagerSingleton();
bind(MarketingNode.class).asEagerSingleton();
bind(BusinessSaleNode.class).asEagerSingleton();
bind(HrAdminNode.class).asEagerSingleton();
bind(ItSystemNode.class).asEagerSingleton();
bind(TrainNode.class).asEagerSingleton();
// 绑定三大业务分组组合节点
bind(SaleLinkComposite.class).asEagerSingleton();
bind(ProduceLinkComposite.class).asEagerSingleton();
bind(AdminSupportComposite.class).asEagerSingleton();
// 调度器单例
bind(JewelryBusinessScheduler.class).asEagerSingleton();
}
/**
* 提供全局根组合节点单例
*/
@Provides
public ProcessCompositeNode provideRootCompositeNode() {
Logger rootLog = LoggerFactory.getLogger(ProcessCompositeNode.class);
return new ProcessCompositeNode(rootLog, "珠宝全业务总流程根节点");
}
}
调用：
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 组合模式 Composite 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:02
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : CompositeBll.java
* explain : 学习 类
**/
package BLL;
import CompositePattern.business.scheduler.JewelryBusinessScheduler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.List;
public class CompositeBll {
private static final Logger log = LoggerFactory.getLogger(CompositeBll.class);
public void demo(){
JewelryBusinessScheduler scheduler = new JewelryBusinessScheduler();
scheduler.initFullBusinessTreeStructure();
log.info("========== 珠宝企业级组合模式业务系统启动完成 ==========");
String normalOrder = "JEW20260717001";
scheduler.runSingleOrderFullProcess(normalOrder);
String errorOrder = "JEW20260717002-ERR";
scheduler.runSingleOrderFullProcess(errorOrder);
List<String> batchOrderList = List.of(
"JEW20260717003",
"JEW20260717004",
"JEW20260717005",
"JEW20260717006"
);
scheduler.runMultiThreadBatchProcess(batchOrderList);
log.info("========== 全部业务流程测试执行结束，程序退出 ==========");
}
}
输出：
展示了一个基于组合模式(Composite Pattern)的珠宝企业级业务系统实现。系统通过抽象构件接口IBusinessProcessNode统一管理业务节点，包含12个叶子节点(如原料采购、设计制图、加工生产等)和3个组合节点(销售链路、生产制造链路、职能支撑链路)。核心类AbstractProcessNode和ProcessCompositeNode分别实现叶子节点和组合节点的通用逻辑，支持线程安全的子节点管理。JewelryBusinessScheduler作为调度器，可执行单订单全流程或多线程批量处理。系统采用Guice进行依赖注入，并通过SLF4J实现详细日志记录，完整模拟了珠宝行业从销售到生产的全业务流程，包括异常处理和并发控制。
汇聚全球AI编程工具，助力开发者即刻编程。
更多推荐
4
0- 0
已为社区贡献12条内容
所有评论(0)