Rust:Abstract Factory pattern

 

//! # encoding: utf-8
//! # 版权所有  2026 ©涂聚文有限公司™ ®
//! # 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
//! # 描述：desgin pattern  Abstract Factory pattern
//! # Author    : geovindu,Geovin Du 涂聚文.
//! # IDE       : RustRover 2025.1.1 
//! # os        : windows 10
//! # database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
//! # Datetime  : 2026/9/12 12:51
//! # User      :  geovindu
//! # Product   : RustRover
//! # Project   : desginpattern
//! # File      : main.rs


//! Rust 抽象工厂模式：珠宝企业全业务流程实例
//! 产品族：黄金产品线、钻石产品线、彩宝产品线
//! 业务模块：原料采购核验、设计制图、加工生产、质检、包装、物流、财务、营销推广、业务、人事行政、IT、培训

// ====================== 抽象产品 Trait 定义（12个业务模块） ======================
/// 1. 原料采购核验
trait MaterialVerify {
    fn verify(&self, batch_no: &str) -> Result<String, String>;
    fn get_material_type(&self) -> &str;
}

/// 2. 设计制图
trait DesignDraft {
    fn render_3d(&self, sku: &str) -> String;
    fn check_cad_standard(&self) -> bool;
}

/// 3. 加工生产
trait Manufacture {
    fn start_produce(&self, work_order: &str) -> String;
    fn get_process_steps(&self) -> Vec<String>;
}

/// 4. 质检
trait QualityInspect {
    fn inspect(&self, work_order: &str) -> Result<String, String>;
    fn get_standard(&self) -> &str;
}

/// 5. 包装
trait Pack {
    fn pack_goods(&self, sku: &str) -> String;
}

/// 6. 物流
trait Logistics {
    fn create_delivery(&self, order_no: &str) -> String;
}

/// 7. 财务单据
trait FinanceDoc {
    fn generate_invoice(&self, order_no: &str) -> String;
}

/// 8. 营销推广物料
trait Marketing {
    fn create_promotion_material(&self, theme: &str) -> String;
}

/// 9. 业务订单
trait BusinessOrder {
    fn create_order(&self, customer_id: &str, amount: f64) -> String;
}

/// 10.人事行政
trait HrAdmin {
    fn arrange_shift(&self, dept: &str) -> String;
}

/// 11. IT运维
trait ItOps {
    fn system_check(&self) -> String;
}

/// 12.培训课件
trait TrainingMaterial {
    fn get_training_doc(&self) -> String;
}

// ====================== 抽象工厂 Trait：珠宝业务工厂 ======================
/// 抽象工厂：一次性创建【同一产品线】全套12个业务对象
trait JewelryBusinessFactory {
    fn create_material_verify(&self) -> Box<dyn MaterialVerify>;
    fn create_design_draft(&self) -> Box<dyn DesignDraft>;
    fn create_manufacture(&self) -> Box<dyn Manufacture>;
    fn create_quality_inspect(&self) -> Box<dyn QualityInspect>;
    fn create_pack(&self) -> Box<dyn Pack>;
    fn create_logistics(&self) -> Box<dyn Logistics>;
    fn create_finance_doc(&self) -> Box<dyn FinanceDoc>;
    fn create_marketing(&self) -> Box<dyn Marketing>;
    fn create_business_order(&self) -> Box<dyn BusinessOrder>;
    fn create_hr_admin(&self) -> Box<dyn HrAdmin>;
    fn create_it_ops(&self) -> Box<dyn ItOps>;
    fn create_training_material(&self) -> Box<dyn TrainingMaterial>;

    fn get_family_name(&self) -> &str;
}

// ====================== 【产品族1】黄金产品线 全部具体产品实现 ======================
struct GoldMaterialVerify;
impl MaterialVerify for GoldMaterialVerify {
    fn verify(&self, batch_no: &str) -> Result<String, String> {
        Ok(format!("[黄金原料核验]批次{}，金含量检测合格，入库", batch_no))
    }
    fn get_material_type(&self) -> &str { "足金/K金原料" }
}

struct GoldDesignDraft;
impl DesignDraft for GoldDesignDraft {
    fn render_3d(&self, sku: &str) -> String {
        format!("[黄金CAD]SKU{} 生成黄金首饰3D模型", sku)
    }
    fn check_cad_standard(&self) -> bool { true }
}

struct GoldManufacture;
impl Manufacture for GoldManufacture {
    fn start_produce(&self, work_order: &str) -> String {
        format!("[黄金生产]工单{}开单，起版、倒模、执模、抛光", work_order)
    }
    fn get_process_steps(&self) -> Vec<String> {
        vec!["起版".into(), "倒模".into(), "执模".into(), "抛光".into(), "电金".into()]
    }
}

struct GoldQualityInspect;
impl QualityInspect for GoldQualityInspect {
    fn inspect(&self, work_order: &str) -> Result<String, String> {
        Ok(format!("[黄金质检]工单{}，重量、外观、印记核验通过", work_order))
    }
    fn get_standard(&self) -> &str { "GB 11887贵金属首饰国标" }
}

struct GoldPack;
impl Pack for GoldPack {
    fn pack_goods(&self, sku: &str) -> String {
        format!("[黄金包装]SKU{}，首饰盒+证书密封包装", sku)
    }
}

struct GoldLogistics;
impl Logistics for GoldLogistics {
    fn create_delivery(&self, order_no: &str) -> String {
        format!("[黄金物流]订单{}，保价贵重物品专线发货", order_no)
    }
}

struct GoldFinanceDoc;
impl FinanceDoc for GoldFinanceDoc {
    fn generate_invoice(&self, order_no: &str) -> String {
        format!("[黄金财务]订单{}，贵金属增值税票生成", order_no)
    }
}

struct GoldMarketing;
impl Marketing for GoldMarketing {
    fn create_promotion_material(&self, theme: &str) -> String {
        format!("[黄金营销]主题{}，古法金海报、短视频物料", theme)
    }
}

struct GoldBusinessOrder;
impl BusinessOrder for GoldBusinessOrder {
    fn create_order(&self, customer_id: &str, amount: f64) -> String {
        format!("[黄金业务]客户{}，创建黄金订单，金额{}", customer_id, amount)
    }
}

struct GoldHrAdmin;
impl HrAdmin for GoldHrAdmin {
    fn arrange_shift(&self, dept: &str) -> String {
        format!("[黄金人事]部门{}，黄金车间排班，夜班安保加强", dept)
    }
}

struct GoldItOps;
impl ItOps for GoldItOps {
    fn system_check(&self) -> String {
        "[黄金IT]ERP原料库存、贵金属台账系统巡检".into()
    }
}

struct GoldTrainingMaterial;
impl TrainingMaterial for GoldTrainingMaterial {
    fn get_training_doc(&self) -> String {
        "[黄金培训]贵金属识别、黄金加工安全操作手册".into()
    }
}

/// 黄金产品线：具体工厂
struct GoldFactory;
impl JewelryBusinessFactory for GoldFactory {
    fn create_material_verify(&self) -> Box<dyn MaterialVerify> { Box::new(GoldMaterialVerify) }
    fn create_design_draft(&self) -> Box<dyn DesignDraft> { Box::new(GoldDesignDraft) }
    fn create_manufacture(&self) -> Box<dyn Manufacture> { Box::new(GoldManufacture) }
    fn create_quality_inspect(&self) -> Box<dyn QualityInspect> { Box::new(GoldQualityInspect) }
    fn create_pack(&self) -> Box<dyn Pack> { Box::new(GoldPack) }
    fn create_logistics(&self) -> Box<dyn Logistics> { Box::new(GoldLogistics) }
    fn create_finance_doc(&self) -> Box<dyn FinanceDoc> { Box::new(GoldFinanceDoc) }
    fn create_marketing(&self) -> Box<dyn Marketing> { Box::new(GoldMarketing) }
    fn create_business_order(&self) -> Box<dyn BusinessOrder> { Box::new(GoldBusinessOrder) }
    fn create_hr_admin(&self) -> Box<dyn HrAdmin> { Box::new(GoldHrAdmin) }
    fn create_it_ops(&self) -> Box<dyn ItOps> { Box::new(GoldItOps) }
    fn create_training_material(&self) -> Box<dyn TrainingMaterial> { Box::new(GoldTrainingMaterial) }
    fn get_family_name(&self) -> &str { "黄金产品线" }
}

// ====================== 【产品族2】钻石产品线 全部具体产品实现 ======================
struct DiamondMaterialVerify;
impl MaterialVerify for DiamondMaterialVerify {
    fn verify(&self, batch_no: &str) -> Result<String, String> {
        Ok(format!("[钻石原料核验]批次{}，GIA证书核验，裸石入库", batch_no))
    }
    fn get_material_type(&self) -> &str { "GIA裸钻/配钻" }
}

struct DiamondDesignDraft;
impl DesignDraft for DiamondDesignDraft {
    fn render_3d(&self, sku: &str) -> String {
        format!("[钻石CAD]SKU{}，钻戒戒托3D渲染，宝石镶嵌点位设计", sku)
    }
    fn check_cad_standard(&self) -> bool { true }
}

struct DiamondManufacture;
impl Manufacture for DiamondManufacture {
    fn start_produce(&self, work_order: &str) -> String {
        format!("[钻石生产]工单{}，起版、镶石、抛光、清洗", work_order)
    }
    fn get_process_steps(&self) -> Vec<String> {
        vec!["起版".into(), "镶石".into(), "抛光".into(), "超声波清洗".into()]
    }
}

struct DiamondQualityInspect;
impl QualityInspect for DiamondQualityInspect {
    fn inspect(&self, work_order: &str) -> Result<String, String> {
        Ok(format!("[钻石质检]工单{}，钻石腰码核对、镶嵌牢固度检测", work_order))
    }
    fn get_standard(&self) -> &str { "钻石分级国标GB/T 16554" }
}

struct DiamondPack;
impl Pack for DiamondPack {
    fn pack_goods(&self, sku: &str) -> String {
        format!("[钻石包装]SKU{}，钻戒盒+GIA证书防伪袋", sku)
    }
}

struct DiamondLogistics;
impl Logistics for DiamondLogistics {
    fn create_delivery(&self, order_no: &str) -> String {
        format!("[钻石物流]订单{}，高保价，专人押运", order_no)
    }
}

struct DiamondFinanceDoc;
impl FinanceDoc for DiamondFinanceDoc {
    fn generate_invoice(&self, order_no: &str) -> String {
        format!("[钻石财务]订单{}，裸钻进项抵扣单据生成", order_no)
    }
}

struct DiamondMarketing;
impl Marketing for DiamondMarketing {
    fn create_promotion_material(&self, theme: &str) -> String {
        format!("[钻石营销]主题{}，钻戒求婚系列宣传物料", theme)
    }
}

struct DiamondBusinessOrder;
impl BusinessOrder for DiamondBusinessOrder {
    fn create_order(&self, customer_id: &str, amount: f64) -> String {
        format!("[钻石业务]客户{}，钻戒定制订单，金额{}", customer_id, amount)
    }
}

struct DiamondHrAdmin;
impl HrAdmin for DiamondHrAdmin {
    fn arrange_shift(&self, dept: &str) -> String {
        format!("[钻石人事]部门{}，镶石技工岗位排班", dept)
    }
}

struct DiamondItOps;
impl ItOps for DiamondItOps {
    fn system_check(&self) -> String {
        "[钻石IT]裸石库存、证书溯源系统巡检".into()
    }
}

struct DiamondTrainingMaterial;
impl TrainingMaterial for DiamondTrainingMaterial {
    fn get_training_doc(&self) -> String {
        "[钻石培训]钻石4C分级、镶石工艺培训课件".into()
    }
}

/// 钻石产品线：具体工厂
struct DiamondFactory;
impl JewelryBusinessFactory for DiamondFactory {
    fn create_material_verify(&self) -> Box<dyn MaterialVerify> { Box::new(DiamondMaterialVerify) }
    fn create_design_draft(&self) -> Box<dyn DesignDraft> { Box::new(DiamondDesignDraft) }
    fn create_manufacture(&self) -> Box<dyn Manufacture> { Box::new(DiamondManufacture) }
    fn create_quality_inspect(&self) -> Box<dyn QualityInspect> { Box::new(DiamondQualityInspect) }
    fn create_pack(&self) -> Box<dyn Pack> { Box::new(DiamondPack) }
    fn create_logistics(&self) -> Box<dyn Logistics> { Box::new(DiamondLogistics) }
    fn create_finance_doc(&self) -> Box<dyn FinanceDoc> { Box::new(DiamondFinanceDoc) }
    fn create_marketing(&self) -> Box<dyn Marketing> { Box::new(DiamondMarketing) }
    fn create_business_order(&self) -> Box<dyn BusinessOrder> { Box::new(DiamondBusinessOrder) }
    fn create_hr_admin(&self) -> Box<dyn HrAdmin> { Box::new(DiamondHrAdmin) }
    fn create_it_ops(&self) -> Box<dyn ItOps> { Box::new(DiamondItOps) }
    fn create_training_material(&self) -> Box<dyn TrainingMaterial> { Box::new(DiamondTrainingMaterial) }
    fn get_family_name(&self) -> &str { "钻石产品线" }
}

// ====================== 【产品族3】彩宝产品线（红宝石/蓝宝石/祖母绿） ======================
struct GemstoneMaterialVerify;
impl MaterialVerify for GemstoneMaterialVerify {
    fn verify(&self, batch_no: &str) -> Result<String, String> {
        Ok(format!("[彩宝原料核验]批次{}，彩宝鉴定证书核验入库", batch_no))
    }
    fn get_material_type(&self) -> &str { "红/蓝宝、祖母绿裸石" }
}

struct GemstoneDesignDraft;
impl DesignDraft for GemstoneDesignDraft {
    fn render_3d(&self, sku: &str) -> String {
        format!("[彩宝CAD]SKU{}，彩宝镶嵌款式3D建模", sku)
    }
    fn check_cad_standard(&self) -> bool { true }
}

struct GemstoneManufacture;
impl Manufacture for GemstoneManufacture {
    fn start_produce(&self, work_order: &str) -> String {
        format!("[彩宝生产]工单{}，蜡版、镶彩宝、抛光", work_order)
    }
    fn get_process_steps(&self) -> Vec<String> {
        vec!["蜡版".into(), "浇铸".into(), "彩宝镶嵌".into(), "抛光".into()]
    }
}

struct GemstoneQualityInspect;
impl QualityInspect for GemstoneQualityInspect {
    fn inspect(&self, work_order: &str) -> Result<String, String> {
        Ok(format!("[彩宝质检]工单{}，宝石成色、裂隙、镶嵌检测", work_order))
    }
    fn get_standard(&self) -> &str { "彩色宝石鉴定国标" }
}

struct GemstonePack;
impl Pack for GemstonePack {
    fn pack_goods(&self, sku: &str) -> String {
        format!("[彩宝包装]SKU{}，彩宝礼盒+鉴定证书", sku)
    }
}

struct GemstoneLogistics;
impl Logistics for GemstoneLogistics {
    fn create_delivery(&self, order_no: &str) -> String {
        format!("[彩宝物流]订单{}，贵重彩宝保价运输", order_no)
    }
}

struct GemstoneFinanceDoc;
impl FinanceDoc for GemstoneFinanceDoc {
    fn generate_invoice(&self, order_no: &str) -> String {
        format!("[彩宝财务]订单{}，彩宝采购成本单据", order_no)
    }
}

struct GemstoneMarketing;
impl Marketing for GemstoneMarketing {
    fn create_promotion_material(&self, theme: &str) -> String {
        format!("[彩宝营销]主题{}，高端彩宝收藏宣传", theme)
    }
}

struct GemstoneBusinessOrder;
impl BusinessOrder for GemstoneBusinessOrder {
    fn create_order(&self, customer_id: &str, amount: f64) -> String {
        format!("[彩宝业务]客户{}，高端彩宝定制订单，金额{}", customer_id, amount)
    }
}

struct GemstoneHrAdmin;
impl HrAdmin for GemstoneHrAdmin {
    fn arrange_shift(&self, dept: &str) -> String {
        format!("[彩宝人事]部门{}，彩宝镶嵌技师排班", dept)
    }
}

struct GemstoneItOps;
impl ItOps for GemstoneItOps {
    fn system_check(&self) -> String {
        "[彩宝IT]彩宝原石台账、鉴定档案系统巡检".into()
    }
}

struct GemstoneTrainingMaterial;
impl TrainingMaterial for GemstoneTrainingMaterial {
    fn get_training_doc(&self) -> String {
        "[彩宝培训]彩色宝石鉴定、脆性宝石镶嵌保护培训".into()
    }
}

/// 彩宝产品线：具体工厂
struct GemstoneFactory;
impl JewelryBusinessFactory for GemstoneFactory {
    fn create_material_verify(&self) -> Box<dyn MaterialVerify> { Box::new(GemstoneMaterialVerify) }
    fn create_design_draft(&self) -> Box<dyn DesignDraft> { Box::new(GemstoneDesignDraft) }
    fn create_manufacture(&self) -> Box<dyn Manufacture> { Box::new(GemstoneManufacture) }
    fn create_quality_inspect(&self) -> Box<dyn QualityInspect> { Box::new(GemstoneQualityInspect) }
    fn create_pack(&self) -> Box<dyn Pack> { Box::new(GemstonePack) }
    fn create_logistics(&self) -> Box<dyn Logistics> { Box::new(GemstoneLogistics) }
    fn create_finance_doc(&self) -> Box<dyn FinanceDoc> { Box::new(GemstoneFinanceDoc) }
    fn create_marketing(&self) -> Box<dyn Marketing> { Box::new(GemstoneMarketing) }
    fn create_business_order(&self) -> Box<dyn BusinessOrder> { Box::new(GemstoneBusinessOrder) }
    fn create_hr_admin(&self) -> Box<dyn HrAdmin> { Box::new(GemstoneHrAdmin) }
    fn create_it_ops(&self) -> Box<dyn ItOps> { Box::new(GemstoneItOps) }
    fn create_training_material(&self) -> Box<dyn TrainingMaterial> { Box::new(GemstoneTrainingMaterial) }
    fn get_family_name(&self) -> &str { "彩宝产品线" }
}

// ====================== 业务客户端：统一执行全链路流程 ======================
/// 客户端：传入任意一个珠宝工厂，自动执行完整业务流水线
fn run_full_business_flow(factory: &dyn JewelryBusinessFactory) {
    println!("===== 开始执行【{}】全业务流程 =====", factory.get_family_name());

    // 1.原料采购核验
    let mat = factory.create_material_verify();
    println!("{}", mat.verify("B20260901").unwrap());
    println!("原料品类：{}", mat.get_material_type());

    // 2.设计制图
    let design = factory.create_design_draft();
    println!("{}", design.render_3d("SKU-001"));
    println!("CAD标准校验:{}", design.check_cad_standard());

    //3.加工生产
    let manu = factory.create_manufacture();
    println!("{}", manu.start_produce("WO20260901"));
    println!("工序列表:{:?}", manu.get_process_steps());

    //4.质检
    let qc = factory.create_quality_inspect();
    println!("{}", qc.inspect("WO20260901").unwrap());
    println!("质检标准:{}", qc.get_standard());

    //5.包装
    let pack = factory.create_pack();
    println!("{}", pack.pack_goods("SKU-001"));

    //6.物流
    let log = factory.create_logistics();
    println!("{}", log.create_delivery("ORD20260901"));

    //7.财务
    let fin = factory.create_finance_doc();
    println!("{}", fin.generate_invoice("ORD20260901"));

    //8.营销
    let mkt = factory.create_marketing();
    println!("{}", mkt.create_promotion_material("中秋活动"));

    //9.业务订单
    let biz = factory.create_business_order();
    println!("{}", biz.create_order("C001", 12800.0));

    //10.人事行政
    let hr = factory.create_hr_admin();
    println!("{}", hr.arrange_shift("生产车间"));

    //11.IT运维
    let it = factory.create_it_ops();
    println!("{}", it.system_check());

    //12.培训
    let train = factory.create_training_material();
    println!("{}", train.get_training_doc());

    println!("===== 【{}】业务流程结束 =====\n", factory.get_family_name());
}

// 工厂选择器（可配置切换产品线，符合企业ERP配置化思想）
fn get_factory(family: &str) -> Option<Box<dyn JewelryBusinessFactory>> {
    match family {
        "gold" => Some(Box::new(GoldFactory)),
        "diamond" => Some(Box::new(DiamondFactory)),
        "gemstone" => Some(Box::new(GemstoneFactory)),
        _ => None,
    }
}

fn main() {
    // 依次运行黄金、钻石、彩宝整套业务流水线
    let gold_fac = get_factory("gold").unwrap();
    run_full_business_flow(gold_fac.as_ref());

    let diamond_fac = get_factory("diamond").unwrap();
    run_full_business_flow(diamond_fac.as_ref());

    let gem_fac = get_factory("gemstone").unwrap();
    run_full_business_flow(gem_fac.as_ref());
}

　　

输出：

 

 

//! # encoding: utf-8
//! # 版权所有  2026 ©涂聚文有限公司™ ®
//! # 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎 在企业级高并发系统中，引入“重试机制”和“死信队列（Dead Letter Queue）”是保障系统高可用性的关键防线。
//! # 描述：desgin pattern  Abstract Factory pattern
//! # Author    : geovindu,Geovin Du 涂聚文.
//! # IDE       : RustRover 2025.1.1 
//! # os        : windows 10
//! # database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
//! # Datetime  : 2026/9/12 12:51
//! # User      :  geovindu
//! # Product   : RustRover
//! # Project   : desginpattern
//! # File      : main.rs
use std::fs::{self, OpenOptions};
use std::io::Write;
use std::path::PathBuf;
use std::sync::{Arc, Mutex, Barrier};
use std::thread;

// ================= 1. 核心抽象层 (Abstractions) =================

trait JewelryProcess: Send + Sync {
    fn execute(&self, logger: &dyn Logger);
}

trait Logger: Send + Sync {
    fn log_info(&self, msg: &str);
    fn log_error(&self, msg: &str);
    fn log_debug(&self, msg: &str);
    fn log_warn(&self, msg: &str);
}

trait JewelryFactory: Send + Sync {
    fn create_logger(&self) -> Arc<dyn Logger>;
    fn create_purchasing(&self) -> Box<dyn JewelryProcess>;
    fn create_design(&self) -> Box<dyn JewelryProcess>;
    fn create_production(&self) -> Box<dyn JewelryProcess>;
    fn create_quality_inspection(&self) -> Box<dyn JewelryProcess>;
    fn create_packaging(&self) -> Box<dyn JewelryProcess>;
    fn create_logistics(&self) -> Box<dyn JewelryProcess>;
    fn create_finance(&self) -> Box<dyn JewelryProcess>;
    fn create_marketing(&self) -> Box<dyn JewelryProcess>;
    fn create_business(&self) -> Box<dyn JewelryProcess>;
    fn create_hr_admin(&self) -> Box<dyn JewelryProcess>;
    fn create_it(&self) -> Box<dyn JewelryProcess>;
    fn create_training(&self) -> Box<dyn JewelryProcess>;
}

// ================= 2. 双输出日志系统 =================
struct DualLogger {
    log_dir: PathBuf,
    file_mutex: Mutex<()>,
}

impl DualLogger {
    fn new(log_dir: &str) -> Self {
        let date_folder = chrono::Local::now().format("%Y-%m-%d").to_string();
        let path = PathBuf::from(log_dir).join(date_folder);
        fs::create_dir_all(&path).unwrap();
        Self { log_dir: path, file_mutex: Mutex::new(()) }
    }

    fn write_log(&self, level: &str, msg: &str) {
        let timestamp = chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
        let log_line = format!("[{}] [{}] {}", timestamp, level, msg);
        println!("{}", log_line);

        let _lock = self.file_mutex.lock().unwrap();
        let file_name = format!("app-{}.log", level.to_lowercase());
        let file_path = self.log_dir.join(file_name);
        let mut file = OpenOptions::new().create(true).append(true).open(file_path).unwrap();
        writeln!(file, "{}", log_line).unwrap();
    }
}

impl Logger for DualLogger {
    fn log_info(&self, msg: &str) { self.write_log("INFO", msg); }
    fn log_error(&self, msg: &str) { self.write_log("ERROR", msg); }
    fn log_debug(&self, msg: &str) { self.write_log("DEBUG", msg); }
    fn log_warn(&self, msg: &str) { self.write_log("WARN", msg); }
}

// ================= 3. 业务模块实现 =================
macro_rules! define_process {
    ($name:ident, $step:expr) => {
        struct $name;
        impl JewelryProcess for $name {
            fn execute(&self, logger: &dyn Logger) {
                logger.log_info(&format!(" [{}] 流程启动...", $step));
                logger.log_debug(&format!("   [{}] 正在执行核心业务逻辑...", $step));
                // 模拟真实耗时
                thread::sleep(std::time::Duration::from_millis(50)); 
                logger.log_info(&format!(" [{}] 流程完成。", $step));
            }
        }
    };
}

define_process!(Purchasing, "原料采购核验");
define_process!(Design, "设计制图");
define_process!(Production, "加工生产");
define_process!(QualityInspection, "质检");
define_process!(Packaging, "包装");
define_process!(Logistics, "物流");
define_process!(Finance, "财务");
define_process!(Marketing, "营销推广");
define_process!(Business, "业务");
define_process!(HrAdmin, "人事行政");
define_process!(ItDepartment, "IT");
define_process!(Training, "培训");

// ================= 4. 具体工厂 =================
struct EnterpriseJewelryFactory;

impl JewelryFactory for EnterpriseJewelryFactory {
    fn create_logger(&self) -> Arc<dyn Logger> { Arc::new(DualLogger::new("Logs")) }
    fn create_purchasing(&self) -> Box<dyn JewelryProcess> { Box::new(Purchasing) }
    fn create_design(&self) -> Box<dyn JewelryProcess> { Box::new(Design) }
    fn create_production(&self) -> Box<dyn JewelryProcess> { Box::new(Production) }
    fn create_quality_inspection(&self) -> Box<dyn JewelryProcess> { Box::new(QualityInspection) }
    fn create_packaging(&self) -> Box<dyn JewelryProcess> { Box::new(Packaging) }
    fn create_logistics(&self) -> Box<dyn JewelryProcess> { Box::new(Logistics) }
    fn create_finance(&self) -> Box<dyn JewelryProcess> { Box::new(Finance) }
    fn create_marketing(&self) -> Box<dyn JewelryProcess> { Box::new(Marketing) }
    fn create_business(&self) -> Box<dyn JewelryProcess> { Box::new(Business) }
    fn create_hr_admin(&self) -> Box<dyn JewelryProcess> { Box::new(HrAdmin) }
    fn create_it(&self) -> Box<dyn JewelryProcess> { Box::new(ItDepartment) }
    fn create_training(&self) -> Box<dyn JewelryProcess> { Box::new(Training) }
}

// ================= 5. 客户端代码与带依赖的并发调度器 =================
fn run_business_pipeline(factory: &dyn JewelryFactory) {
    let logger = factory.create_logger();
    logger.log_info(" 珠宝企业级全流程系统启动 (带业务依赖调度)");

    // 1. 定义并发屏障 (Barrier)
    // 业务规则：质检 必须等待 设计制图 和 加工生产 同时完成才能开始
    // 因此屏障计数为 3 (质检自身 + 设计 + 生产)
    let qc_barrier = Arc::new(Barrier::new(3));

    // 2. 创建各个业务模块
    let purchasing = factory.create_purchasing();
    let design = factory.create_design();
    let production = factory.create_production();
    let quality_inspection = factory.create_quality_inspection();
    let packaging = factory.create_packaging();
    let logistics = factory.create_logistics();
    let finance = factory.create_finance();
    let marketing = factory.create_marketing();
    let business = factory.create_business();
    let hr_admin = factory.create_hr_admin();
    let it_dept = factory.create_it();
    let training = factory.create_training();

    let mut handles = vec![];

    // --- 独立并发任务 ---
    let (log_c, log_d, log_e, log_f, log_g, log_h, log_i, log_j, log_k) =
        (Arc::clone(&logger), Arc::clone(&logger), Arc::clone(&logger), Arc::clone(&logger),
         Arc::clone(&logger), Arc::clone(&logger), Arc::clone(&logger), Arc::clone(&logger), Arc::clone(&logger));

    handles.push(thread::spawn(move || { purchasing.execute(log_c.as_ref()); }));
    handles.push(thread::spawn(move || { finance.execute(log_d.as_ref()); }));
    handles.push(thread::spawn(move || { marketing.execute(log_e.as_ref()); }));
    handles.push(thread::spawn(move || { business.execute(log_f.as_ref()); }));
    handles.push(thread::spawn(move || { hr_admin.execute(log_g.as_ref()); }));
    handles.push(thread::spawn(move || { it_dept.execute(log_h.as_ref()); }));
    handles.push(thread::spawn(move || { training.execute(log_i.as_ref()); }));
    handles.push(thread::spawn(move || { logistics.execute(log_j.as_ref()); }));
    handles.push(thread::spawn(move || { packaging.execute(log_k.as_ref()); }));

    // --- 有依赖关系的任务：设计制图 ---
    let log_l = Arc::clone(&logger);
    let barrier_design = Arc::clone(&qc_barrier);
    handles.push(thread::spawn(move || {
        design.execute(log_l.as_ref());
        // 设计完成后，在屏障处等待
        barrier_design.wait();
    }));

    // --- 有依赖关系的任务：加工生产 ---
    let log_m = Arc::clone(&logger);
    let barrier_prod = Arc::clone(&qc_barrier);
    handles.push(thread::spawn(move || {
        production.execute(log_m.as_ref());
        // 生产完成后，在屏障处等待
        barrier_prod.wait();
    }));

    // --- 有依赖关系的任务：质检 (等待屏障解除后才执行) ---
    let log_n = Arc::clone(&logger);
    let barrier_qc = Arc::clone(&qc_barrier);
    handles.push(thread::spawn(move || {
        // 质检线程启动后，立刻在屏障处阻塞，直到设计和生产都完成
        barrier_qc.wait();
        quality_inspection.execute(log_n.as_ref());
    }));

    // 等待所有线程执行完毕
    for handle in handles {
        handle.join().unwrap();
    }

    logger.log_info(" 珠宝企业级全流程系统执行完毕");
}

fn main() {
    let factory = EnterpriseJewelryFactory;
    run_business_pipeline(&factory);
}