网硕互联帮助中心项目结构：
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 享元模式Flyweight 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/23 – 22:45
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : IStaffFlyweight.java
* explain : 学习 类
**/
package FlyweightPattern.core.abstractions;
import org.slf4j.Logger;
/**
* 享元抽象接口：珠宝行业岗位工作人员
* 内部状态：岗位名称、岗位职责、所属部门（可共享，常驻内存）
* 外部状态：业务流水号、业务描述（每次执行动态传入，不存入享元对象）
*/
public interface IStaffFlyweight {
/**
* 执行岗位业务操作
* @param logger 日志实例
* @param businessNo 业务流水号【外部状态】
* @param businessContext 业务上下文描述【外部状态】
*/
void executeWork(Logger logger, String businessNo, String businessContext);
/**
* 获取岗位名称（内部共享状态）
* @return 岗位名称
*/
String getPositionName();
/**
* 获取岗位职责（内部共享状态）
* @return 职责描述
*/
String getDuty();
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 享元模式Flyweight 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/23 – 23:01
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : IStaffFlyweightFactory.java
* explain : 学习 类
**/
package FlyweightPattern.core.abstractions;
/**
* 享元工厂接口：负责创建、缓存岗位享元实例
* 保证同一岗位全局只存在唯一实例，实现对象复用，降低GC压力
*/
public interface IStaffFlyweightFactory {
/**
* 根据岗位名称获取享元对象
* @param positionName 岗位名称
* @return 岗位享元实例
*/
IStaffFlyweight getStaffFlyweight(String positionName);
/**
* 获取当前缓存享元数量
* @return 缓存数量
*/
int getCacheCount();
/**
* 预加载珠宝全部业务岗位享元
*/
void preloadAllJewelryPositions();
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 享元模式Flyweight 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/23 – 23:02
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : PositionDutyModel.java
* explain : 学习 类
**/
package FlyweightPattern.core.models;
/**
* 岗位基础信息模型，用于初始化享元内部状态
*/
public class PositionDutyModel {
/**岗位名称*/
private String positionName;
/**所属部门*/
private String department;
/**岗位职责描述*/
private String duty;
public String getPositionName() {
return positionName;
}
public void setPositionName(String positionName) {
this.positionName = positionName;
}
public String getDepartment() {
return department;
}
public void setDepartment(String department) {
this.department = department;
}
public String getDuty() {
return duty;
}
public void setDuty(String duty) {
this.duty = duty;
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 享元模式Flyweight 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/23 – 23:03
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : JewelryStaffFlyweightFactory.java
* explain : 学习 类
**/
package FlyweightPattern.infrastructure.flyweight;
import FlyweightPattern.core.abstractions.IStaffFlyweight;
import FlyweightPattern.core.abstractions.IStaffFlyweightFactory;
import FlyweightPattern.core.models.PositionDutyModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* 珠宝岗位享元工厂实现
* ConcurrentHashMap 保证多线程并发安全缓存
*/
public class JewelryStaffFlyweightFactory implements IStaffFlyweightFactory {
private static final Logger log = LoggerFactory.getLogger(JewelryStaffFlyweightFactory.class);
/**享元对象缓存池，线程安全Map Key：岗位名称*/
private final ConcurrentHashMap<String, IStaffFlyweight> flyweightPool = new ConcurrentHashMap<>();
public JewelryStaffFlyweightFactory() {
preloadAllJewelryPositions();
}
/**
* 获取岗位享元，存在直接返回，不存在抛出异常
*/
@Override
public IStaffFlyweight getStaffFlyweight(String positionName) {
if (positionName == null || positionName.isBlank()) {
throw new IllegalArgumentException("岗位名称不能为空");
}
if (flyweightPool.containsKey(positionName)) {
log.debug("命中享元缓存，岗位：{}", positionName);
return flyweightPool.get(positionName);
}
throw new RuntimeException("未预加载岗位【" + positionName + "】，请检查岗位配置");
}
@Override
public int getCacheCount() {
return flyweightPool.size();
}
/**
* 预加载珠宝全业务岗位享元
*/
@Override
public void preloadAllJewelryPositions() {
log.info("开始预加载珠宝行业所有业务岗位享元对象");
List<PositionDutyModel> positionList = List.of(
createModel("原料采购核验", "供应链部", "贵金属/宝石原料采购、入库质检、原料成色核验、供应商对账"),
createModel("设计制图", "研发设计部", "首饰款式创意、CAD制图、3D建模、效果图输出、工艺图纸"),
createModel("加工生产", "生产车间", "失蜡铸造、执模、镶石、抛光、电镀、半成品加工"),
createModel("质检", "品控部", "成色检测、宝石分级、外观瑕疵检验、尺寸校验、合格判定"),
createModel("包装", "仓储部", "首饰清洁、礼盒封装、标签粘贴、产品入库分拣"),
createModel("物流", "仓储部", "订单打包、快递对接、物流跟踪、货品出入库管控"),
createModel("财务", "财务部", "成本核算、应收应付、开票、工资核算、资金管理"),
createModel("营销推广", "市场部", "线上线下推广、直播运营、活动策划、品牌宣传"),
createModel("业务", "销售部", "客户接待、订单洽谈、零售批发、售后沟通"),
createModel("人事行政", "行政人事部", "招聘、考勤、制度管理、后勤、办公物资管理"),
createModel("IT", "信息部", "系统运维、服务器维护、软件故障处理、数据保障"),
createModel("培训", "培训部", "员工技能培训、销售话术培训、工艺知识教学")
);
for (PositionDutyModel item : positionList) {
StaffFlyweight flyweight = new StaffFlyweight(item.getPositionName(), item.getDepartment(), item.getDuty());
flyweightPool.putIfAbsent(item.getPositionName(), flyweight);
log.debug("岗位享元加载完成：{}", item.getPositionName());
}
log.info("岗位享元预加载完成，缓存岗位总数：{}", flyweightPool.size());
}
private PositionDutyModel createModel(String posName, String dept, String duty) {
PositionDutyModel m = new PositionDutyModel();
m.setPositionName(posName);
m.setDepartment(dept);
m.setDuty(duty);
return m;
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 享元模式Flyweight 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/23 – 23:02
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : StaffFlyweight.java
* explain : 学习 类
**/
package FlyweightPattern.infrastructure.flyweight;
import FlyweightPattern.core.abstractions.IStaffFlyweight;
import org.slf4j.Logger;
import java.util.Random;
/**
* 具体享元对象：珠宝企业岗位人员
* 内部状态不可变，对象全局复用；外部状态通过方法参数传入
*/
public class StaffFlyweight implements IStaffFlyweight {
/**岗位名称 – 内部状态（不可变）*/
private final String positionName;
/**所属部门 – 内部状态（不可变）*/
private final String department;
/**岗位职责 – 内部状态（不可变）*/
private final String duty;
private static final Random RANDOM = new Random();
/**
* 构造函数初始化固定内部状态
* @param positionName 岗位名称
* @param department 部门名称
* @param duty 岗位职责
*/
public StaffFlyweight(String positionName, String department, String duty) {
this.positionName = positionName;
this.department = department;
this.duty = duty;
}
/**
* 执行岗位业务，外部状态由调用方传入
*/
@Override
public void executeWork(Logger logger, String businessNo, String businessContext) {
logger.info("[业务单号:{}]【{}-{}】开始处理业务：{}，岗位职责：{}",
businessNo, department, positionName, businessContext, duty);
simulateBusinessWork(logger, businessNo);
}
/**
* 模拟岗位业务执行逻辑
*/
private void simulateBusinessWork(Logger logger, String businessNo) {
int costMs = RANDOM.nextInt(50, 200);
try {
Thread.sleep(costMs);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
double randVal = RANDOM.nextDouble();
if (randVal < 0.08) {
logger.warn("[业务单号:{}]【{}】业务存在轻微异常风险", businessNo, positionName);
}
if (randVal < 0.03) {
logger.error("[业务单号:{}]【{}】业务处理出现临时故障", businessNo, positionName);
}
logger.debug("[业务单号:{}]【{}】处理耗时{}ms", businessNo, positionName, costMs);
}
@Override
public String getPositionName() {
return positionName;
}
@Override
public String getDuty() {
return duty;
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 享元模式Flyweight 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/23 – 23:04
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : LoggingConfiguration.java
* explain : 学习 类
**/
package FlyweightPattern.infrastructure.logging;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;
/**
* 日志配置入口
* 实际日志滚动策略由 resources/logback.xml 控制
* 日志目录：Logs/yyyy-MM-dd/app-{Level}.log
* 控制台与文件日志格式保持一致
*/
@Configuration
public class LoggingConfiguration {
private static final Logger log = LoggerFactory.getLogger(LoggingConfiguration.class);
public LoggingConfiguration() {
log.info("日志系统初始化完成，日志根目录：Logs/");
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 享元模式Flyweight 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/23 – 23:04
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : IJewelryBusinessScheduler.java
* explain : 学习 类
**/
package FlyweightPattern.business.abstractions;
import java.util.concurrent.CompletableFuture;
/**
* 珠宝业务调度器抽象
* 负责驱动整条珠宝业务流水线执行
*/
public interface IJewelryBusinessScheduler {
/**
* 执行单条订单完整业务流程
* @param businessNo 业务流水号
* @param orderTitle 订单名称
* @return 异步任务
*/
CompletableFuture<Void> runFullJewelryBusinessFlowAsync(String businessNo, String orderTitle);
/**
* 并发批量执行多条订单
* @param orderCount 模拟订单数量
* @return 异步任务
*/
CompletableFuture<Void> runMultiOrderConcurrentAsync(int orderCount);
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 享元模式Flyweight 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/23 – 23:04
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : JewelryBusinessScheduler.java
* explain : 学习 类
**/
package FlyweightPattern.business.implementations;
import FlyweightPattern.business.abstractions.IJewelryBusinessScheduler;
import FlyweightPattern.core.abstractions.IStaffFlyweight;
import FlyweightPattern.core.abstractions.IStaffFlyweightFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.List;
import java.util.concurrent.CompletableFuture;
/**
* 珠宝业务流水线调度实现
* 串联全流程岗位，通过享元工厂复用岗位实例
*/
public class JewelryBusinessScheduler implements IJewelryBusinessScheduler {
private static final Logger log = LoggerFactory.getLogger(JewelryBusinessScheduler.class);
private final IStaffFlyweightFactory flyweightFactory;
public JewelryBusinessScheduler(IStaffFlyweightFactory flyweightFactory) {
this.flyweightFactory = flyweightFactory;
}
/**
* 单订单完整业务流水线
*/
@Override
public CompletableFuture<Void> runFullJewelryBusinessFlowAsync(String businessNo, String orderTitle) {
return CompletableFuture.runAsync(() -> {
log.info("=====启动珠宝完整业务流程，单号:{},订单:{}=====", businessNo, orderTitle);
List<String> positionSequence = List.of(
"原料采购核验",
"设计制图",
"加工生产",
"质检",
"包装",
"物流",
"财务",
"营销推广",
"业务",
"人事行政",
"IT",
"培训"
);
for (String position : positionSequence) {
IStaffFlyweight staff = flyweightFactory.getStaffFlyweight(position);
staff.executeWork(log, businessNo, "订单[" + orderTitle + "]流程处理");
try {
Thread.sleep(30);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
log.info("=====珠宝业务流程全部执行完成，单号:{}=====", businessNo);
});
}
/**
* 多订单并发执行，测试高并发场景
*/
@Override
public CompletableFuture<Void> runMultiOrderConcurrentAsync(int orderCount) {
log.info("开始并发模拟{}条珠宝订单业务流程", orderCount);
CompletableFuture<?>[] tasks = new CompletableFuture[orderCount];
for (int i = 1; i <= orderCount; i++) {
String orderNo = "JH" + System.currentTimeMillis() + String.format("%06d", i);
String orderName = "定制首饰订单-" + i + "号";
tasks[i – 1] = runFullJewelryBusinessFlowAsync(orderNo, orderName);
}
return CompletableFuture.allOf(tasks)
.thenRun(() -> log.info("全部并发订单处理完毕"));
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 享元模式Flyweight 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/23 – 23:05
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : ScheduleStartupService.java
* explain : 学习 类
**/
package FlyweightPattern.scheduler.hostedservices;
import FlyweightPattern.scheduler.jobs.JewelryScheduleJob;
import org.quartz.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Service;
/**
* 调度启动托管服务
* Spring容器启动完成后自动注册定时任务
*/
@Service
public class ScheduleStartupService {
private static final Logger log = LoggerFactory.getLogger(ScheduleStartupService.class);
private final Scheduler scheduler;
public ScheduleStartupService(Scheduler scheduler) {
this.scheduler = scheduler;
}
@EventListener(ContextRefreshedEvent.class)
public void startScheduler() throws SchedulerException {
log.info("开始初始化Quartz定时调度器");
// ==========任务1：每隔30秒自动执行一次，模拟日常自动业务流水线==========
JobKey job1Key = new JobKey("JewelryNormalFlowJob", "JewelryGroup");
JobDetail normalJob = JobBuilder.newJob(JewelryScheduleJob.class)
.withIdentity(job1Key)
.storeDurably()
.build();
normalJob.getJobDataMap().put("BusinessNo", "JH-SCHED-001");
normalJob.getJobDataMap().put("OrderTitle", "定时自动-日常首饰生产订单");
Trigger normalTrigger = TriggerBuilder.newTrigger()
.withIdentity("NormalFlowTrigger", "JewelryGroup")
.startNow()
.withSchedule(SimpleScheduleBuilder.simpleSchedule()
.withIntervalInSeconds(30)
.repeatForever())
.build();
// ==========任务2：Cron示例【每天凌晨02:00执行批量10单并发】==========
JobKey job2Key = new JobKey("JewelryBatchJob", "JewelryGroup");
JobDetail batchJob = JobBuilder.newJob(JewelryScheduleJob.class)
.withIdentity(job2Key)
.storeDurably()
.build();
batchJob.getJobDataMap().put("ConcurrentOrderCount", 10);
Trigger batchTrigger = TriggerBuilder.newTrigger()
.withIdentity("BatchFlowTrigger", "JewelryGroup")
.startNow()
.withSchedule(CronScheduleBuilder.cronSchedule("0 0 2 * * ?"))
.build();
scheduler.addJob(normalJob, false);
scheduler.scheduleJob(normalTrigger);
scheduler.addJob(batchJob, false);
scheduler.scheduleJob(batchTrigger);
scheduler.start();
log.info("Quartz调度器启动成功，定时任务已加载");
}
}
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 享元模式Flyweight 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/23 – 23:05
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : JewelryScheduleJob.java
* explain : 学习 类
**/
package FlyweightPattern.scheduler.jobs;
import FlyweightPattern.business.abstractions.IJewelryBusinessScheduler;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
/**
* 珠宝业务定时任务Job
* Quartz调度触发，执行完整珠宝业务流水线
*/
@Component
public class JewelryScheduleJob implements Job {
private static final Logger log = LoggerFactory.getLogger(JewelryScheduleJob.class);
private final IJewelryBusinessScheduler businessScheduler;
public JewelryScheduleJob(IJewelryBusinessScheduler businessScheduler) {
this.businessScheduler = businessScheduler;
}
/**
* Quartz任务执行入口
*/
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
try {
log.info("【定时任务触发】任务Key:{}", context.getJobDetail().getKey());
String businessNo = context.getJobDetail().getJobDataMap().getString("BusinessNo");
String orderTitle = context.getJobDetail().getJobDataMap().getString("OrderTitle");
int concurrentCount = context.getJobDetail().getJobDataMap().getInt("ConcurrentOrderCount");
if (businessNo != null && !businessNo.isBlank() && orderTitle != null && !orderTitle.isBlank()) {
businessScheduler.runFullJewelryBusinessFlowAsync(businessNo, orderTitle).join();
} else if (concurrentCount > 0) {
businessScheduler.runMultiOrderConcurrentAsync(concurrentCount).join();
} else {
log.warn("定时任务未传入有效业务参数，跳过业务执行");
}
log.info("【定时任务执行完成】任务Key:{}", context.getJobDetail().getKey());
} catch (Exception ex) {
log.error(ex.getMessage(), "【定时任务执行异常】任务Key:{}", context.getJobDetail().getKey());
throw new JobExecutionException(ex);
}
}
}
调用：
/**
* encoding: utf-8
* 版权所有 2026 ©涂聚文有限公司 ®
* 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
* 描述：结构型模式 Structural Patterns 享元模式Flyweight 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:03
* User : geovindu
* Product : IntelliJ IDEA
* Project : javadesginpattern
* File : FlyweightBll.java
* explain : 学习 类
**/
package BLL;
import FlyweightPattern.business.abstractions.IJewelryBusinessScheduler;
import FlyweightPattern.business.implementations.JewelryBusinessScheduler;
import FlyweightPattern.infrastructure.flyweight.JewelryStaffFlyweightFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.CompletableFuture;
public class FlyweightBll {
private static final Logger logger = LoggerFactory.getLogger(FlyweightBll.class);
public void demo() {
JewelryStaffFlyweightFactory flyweightFactory = new JewelryStaffFlyweightFactory();
IJewelryBusinessScheduler businessScheduler = new JewelryBusinessScheduler(flyweightFactory);
logger.info("==================== 珠宝企业享元模式业务系统启动完成 ====================");
logger.info("享元缓存岗位数量：{}", flyweightFactory.getCacheCount());
businessScheduler.runFullJewelryBusinessFlowAsync("JH20260723001", "18K金钻石戒指订单").join();
logger.info("\\n——– 高并发测试：并发处理3条订单 ——–");
businessScheduler.runMultiOrderConcurrentAsync(3).join();
logger.info("==================== 享元模式业务流程全部执行完毕 ====================");
}
}
输出：
评论前必须登录！
注册