mermaid画图

graph TD
    A[多智能体随机网络结构分析] --> B[多智能体协同学习与推理]
    
    A --> A1["谱参数实时估算"]
    A1 --> A11["卡尔曼滤波"]
    A1 --> A12["矩阵扰动理论"]
    A1 --> A13["输出：谱参数"]
    A --> A2["网络拓扑重构"]
    A2 --> A21["低秩分解重构"]
    A2 --> A22["聚类量化"]
    A2 --> A23["输出：邻接矩阵、特征矩阵"]
    
    
    

    

graph TD
    B[多智能体协同学习与推理]
	B --> B1["联邦学习、强化学习"]
    B1 --> B11["谱驱动学习率调整"]
    B1 --> B12["自适应节点选择策略"]
    B --> B2["动态图神经网络"]
    B2 --> B21["动态图卷积设计"]
    B2 --> B22["一致性推理"]

graph TD
    %% 颜色和样式定义
    classDef startEnd fill:#e6ffe6,stroke:#333,stroke-width:2px
    classDef operation fill:#fff,stroke:#000,stroke-width:1px
    classDef decision fill:#ffcccc,stroke:#000,stroke-width:1px
    classDef update fill:#ccffcc,stroke:#000,stroke-width:1px

    %% 节点定义（严格按图片顺序）
    A([开始]):::startEnd
    B[交易信息\n外部订单号]:::operation
    C{判断是否为锁单订单}:::decision
    D[查询拼团组队信息]:::operation
    E[更新订单详情\n状态为交易完成]:::update
    F[更新拼团组队进度]:::update
    G{拼团组队完结\n目标量判断}:::decision
    H[写入回调任务表]:::operation
    I([结束]):::startEnd

    %% 流程连接（完全还原图片走向）
    A --> B
    B --> C
    C -->|是| D
    D --> E
    E --> F
    F --> G
    G -->|是| H
    H --> I
    C -->|否| I
    G -->|否| I

    %% 保持原图连接线样式
    linkStyle 0,1,2,3,4,5,6,7,8 stroke-width:1px

graph TD
    A[用户发起退单请求] --> B{检查拼团状态}
    
    B -->|拼团未完成| C1[场景1:拼团中退单]
    C1 --> D1{是否已支付?}
    D1 -->|未支付| E1[取消订单]
    E1 --> F1[更新订单状态为2]
    F1 --> G1[通知拼团失败]
    G1 --> H1[退单完成]
    D1 -->|已支付| I1[发起退款]
    I1 --> F1
    
    B -->|拼团已完成| C2[场景2:完成后退单]
    C2 --> D2{是否超时限?}
    D2 -->|未超时| E2[发起退款]
    E2 --> F2[更新订单状态]
    F2 --> H1
    D2 -->|超时| G2[退单失败]
    
    style A fill:#f9f,stroke:#333
    style B fill:#66f,stroke:#333
    style C1 fill:#fbb,stroke:#f66
    style C2 fill:#9f9,stroke:#090

flowchart LR
    %% ===================== 左侧：模板模式块 =====================
    subgraph Template["设计模式 - 模板"]
        direction TB
        SM["StrategyMapper
        策略映射器"]
        SH["StrategyHandler
        策略处理器"]
        ASR["AbstractStrategyRouter<T, D, R>
        策略路由抽象类"]

        SM -->|实现| ASR
        SH -->|实现| ASR
    end

    %% ===================== 右侧：策略工厂与支持类 =====================
    DASFactory["DefaultActivityStrategyFactory
    默认的拼团活动策略工厂"]
    AGMS["AbstractGroupBuyMarketSupport
    功能服务支撑类"]

    DASFactory --> AGMS
    AGMS -->|继承| ASR

    %% ===================== 业务节点链路 =====================
    Root["RootNode
    根节点"]
    Switch["SwitchRoot
    开关节点"]
    Market["MarketNode
    营销节点"]
    End["EndNode
    结尾节点"]
    Other["其他节点"]

    AGMS --> Root
    Root --> Switch
    Switch --> Market
    Market --> End
    Switch -.-> Other
    Other --> End

    %% ===================== 样式（可选） =====================
    classDef green fill:#DFF4E3,stroke:#3B7A57,stroke-width:1px;
    classDef red fill:#E74C3C,color:#fff,stroke:#B03A2E;
    classDef purple fill:#7E60A2,color:#fff,stroke:#4B3B6B;
    classDef blue fill:#3DA9F5,color:#fff,stroke:#1B6AA5;

    class SM,SH,Root,Switch,Market,End,Other green;
    class DASFactory red;
    class AGMS purple;
    class ASR blue;

    style Template stroke-dasharray: 5 5;

sequenceDiagram
    participant A as 启动时
    participant B as BeanPostProcessor
    participant C as 管理后台
    participant D as Redis Pub/Sub
    participant E as RTopic listener
    participant F as Bean 字段热更新

    A->>B: 扫描 @DCCValue 标注的字段
    B->>B: 写入默认值 / 读取 Redis
    B->>B: 注入字段值
    B->>B: 缓存 key→Bean 映射
    A->>A: Bean 初始化完成
    
    C->>D: publish("myKey,newVal")
    D->>E: 订阅频道 "dcc_update"
    E->>E: 收到消息，更新 Redis
    E->>E: 从 Map 找到 Bean
    E->>E: 反射注入新值到字段
    E->>F: Bean 字段热更新完成

sequenceDiagram
    participant A as 后台/系统
    participant B as Redis Pub/Sub
    participant C as DCC监听器
    participant D as Redis数据库
    participant E as 反射更新字段
    participant F as Bean实例

    A->>B: 发布消息 ("cutRange:50")
    B->>D: 将消息 "cutRange:50" 写入 Redis
    B->>C: 触发订阅者接收消息
    C->>D: 更新 Redis 中的 "cutRange" 配置值
    C->>F: 根据映射找到对应的 Bean
    C->>E: 通过反射更新 Bean 中的字段
    E->>C: 更新成功，字段值被同步
    C->>A: 配置变更更新完成

flowchart LR
    A[请求进入链头 Head] --> B[节点1: 日志LogLink]
    B -->|继续| C[节点2: 权限AuthLink]
    B -->|直接返回/终止| R1[返回结果]

    C -->|通过→继续| D[节点3: 审批ApproveLink]
    C -->|不通过→终止| R2[返回失败结果]

    D --> R3[返回成功结果]

    classDef node fill:#eef,stroke:#669;
    classDef ret fill:#efe,stroke:#393;
    class A,B,C,D node;
    class R1,R2,R3 ret;

flowchart LR
  subgraph mall["小型支付商城"]
    style mall fill:#ffffff,stroke:#333,stroke-width:2
    A[AliPayController<br/>发起退单申请]:::blue
    C[订单状态扭转<br/>退单中]:::grey
    E[RefundSuccessTopicListener<br/>接收MQ消息<br/>执行退款和订单状态变更]:::green
  end

  subgraph pdd["拼团系统"]
    style pdd fill:#ffffff,stroke:#333,stroke-width:2
    B[MarketTradeController<br/>接收退单申请]:::yellow
    D[TradeRefundOrderService<br/>退单策略处理]:::red
    F[TradeRepository<br/>发送MQ消息]:::purple
    G([MQ消息队列<br/>退单成功消息]):::orange
    H[RefundSuccessTopicListener<br/>接收MQ消息<br/>恢复库存]:::green
  end

  A -- "1. 发起退单请求" --> B
  B -- "2. 处理退单" --> D
  D -- "3. 发送MQ消息" --> F
  F -- "4. 发布消息 (异步+本地消息表补偿)" --> G
  F -- "5. 返回结果" --> C
  G -- "6. 消费消息 (恢复库存)" --> H
  G -. "7. 消费消息 (执行退款)" .-> E

  classDef blue   fill:#dbe9ff,stroke:#6fa1ff,stroke-width:1;
  classDef grey   fill:#e5e5e5,stroke:#9e9e9e,stroke-width:1;
  classDef green  fill:#d6f2d6,stroke:#76b076,stroke-width:1;
  classDef yellow fill:#fef3cd,stroke:#f5c700,stroke-width:1;
  classDef red    fill:#f8d7da,stroke:#e55353,stroke-width:1;
  classDef purple fill:#e4dbf9,stroke:#9370db,stroke-width:1;
  classDef orange fill:#ffecca,stroke:#ffa500,stroke-width:1;

sequenceDiagram
    participant Client as 前端
    participant WS as WebSocket 服务器
    participant Auth as 权限校验
    participant Dispatcher as 消息分发器
    participant Handler as 消息处理器

    Client->>WS: 请求建立 WebSocket 连接
    WS->>Auth: 校验用户权限
    Auth-->>WS: 校验通过，保存用户和图片信息
    WS-->>Client: 连接成功

    Client->>WS: 发送消息（包含消息类型）
    WS->>Dispatcher: 根据消息类型分发
    Dispatcher->>Handler: 执行对应的消息处理逻辑
    Handler-->>Dispatcher: 返回处理结果
    Dispatcher-->>WS: 返回处理结果
    WS-->>Client: 返回处理结果给客户端

    Client->>WS: 断开连接
    WS-->>Client: 删除 WebSocket 会话，释放资源

sequenceDiagram
    participant Client as Client(浏览器)
    participant WS as WebSocket Endpoint
    participant Producer as PictureEditEventProducer
    participant RB as RingBuffer
    participant Worker as PictureEditEventWorkHandler
    participant Handler as PictureEditHandler

    Client->>WS: 发送 PictureEditRequestMessage
    WS->>Producer: publishEvent(msg, session, user, pictureId)
    Producer->>RB: next() 获取序号，写入事件字段
    Producer->>RB: publish(sequence) 发布
    RB-->>Worker: 回调 onEvent(event)
    Worker->>Worker: 解析 type -> PictureEditMessageTypeEnum
    alt ENTER_EDIT
        Worker->>Handler: handleEnterEditMessage(...)
    else EXIT_EDIT
        Worker->>Handler: handleExitEditMessage(...)
    else EDIT_ACTION
        Worker->>Handler: handleEditActionMessage(...)
    else 其他/异常
        Worker->>WS: sendMessage(ERROR 响应)
    end
    Worker-->>Client: 业务处理后的响应（通过 WS）

sequenceDiagram
    participant Client as WebSocket Client
    participant IO as WebSocket I/O线程
    participant Biz as 业务逻辑(耗时)

    Client->>IO: 收到消息事件(onMessage)
    IO->>Biz: 执行业务逻辑(耗时3s)
    Biz-->>IO: 返回结果
    IO->>Client: 发送响应

    Note over IO: I/O线程被业务阻塞3s 不能处理其他连接的消息

sequenceDiagram
    participant Client as WebSocket Client
    participant IO as WebSocket I/O线程
    participant Disruptor as RingBuffer队列
    participant Worker as Disruptor消费者线程
    participant Biz as 业务逻辑(耗时)

    Client->>IO: 收到消息事件(onMessage)
    IO->>Disruptor: 发布事件(快速)
    Disruptor-->>IO: 立即返回
    IO->>Client: (继续处理其他连接消息)

    Worker->>Biz: 异步执行业务逻辑(耗时3s)
    Biz-->>Worker: 返回结果
    Worker->>Client: 通过WebSocket发送响应

flowchart TD
    A[客户端发起WebSocket连接] --> B[HTTP握手阶段]
    B --> C[WsHandshakeInterceptor.beforeHandshake]
    C -->|校验失败| D[拒绝握手 连接关闭]
    C -->|校验成功| E[建立WebSocket连接]
    E --> F[PictureEditHandler]
    F --> G[处理WebSocket消息 收发数据]

flowchart TD
    A([接收请求]) --> B{查询本地缓存 Caffeine}
    B -- 命中 --> C[返回本地缓存数据]
    C --> End1(((结束)))

    B -- 未命中 --> D{查询分布式缓存 Redis}
    D -- 命中 --> E[更新本地缓存]
    E --> F[返回 Redis 缓存数据]
    F --> End2(((结束)))

    D -- 未命中 --> G[查询数据库]
    G --> H[更新本地缓存和 Redis 缓存]
    H --> I[返回数据库数据]
    I --> End3(((结束)))

classDiagram
    class ImageSearchApiFacade {
        +searchImage(localImagePath)
    }

    class GetImagePageUrlApi {
        +getImagePageUrl(localImagePath)
    }

    class GetImageFirstUrlApi {
        +getImageFirstUrl(imagePageUrl)
    }

    class GetImageListApi {
        +getImageList(imageFirstUrl)
    }

    ImageSearchApiFacade --> GetImagePageUrlApi : Calls
    ImageSearchApiFacade --> GetImageFirstUrlApi : Calls
    ImageSearchApiFacade --> GetImageListApi : Calls

erDiagram
    用户 {
        BIGINT 用户ID
        VARCHAR 用户名
    }
    角色 {
        BIGINT 角色ID
        VARCHAR 角色名称
        VARCHAR 描述
    }
    权限 {
        BIGINT 权限ID
        VARCHAR 权限名称
        VARCHAR 描述
    }

    用户 }o--o{ 角色 : 拥有
    角色 }o--o{ 权限 : 赋予

classDiagram
    class Collection {
        <<interface>>
        +add()
        +remove()
        +clear()
        +size()
    }

    class Set {
        <<interface>>
    }

    class List {
        <<interface>>
    }

    class Queue {
        <<interface>>
    }

    class Map {
        <<interface>>
    }

    class HashSet {
        <<class>>
    }

    class TreeSet {
        <<class>>
    }

    class ArrayList {
        <<class>>
    }

    class LinkedList {
        <<class>>
    }

    class PriorityQueue {
        <<class>>
    }

    class HashMap {
        <<class>>
    }

    class TreeMap {
        <<class>>
    }

    Collection <|-- Set
    Collection <|-- List
    Collection <|-- Queue
    Set <|-- HashSet
    Set <|-- TreeSet
    List <|-- ArrayList
    List <|-- LinkedList
    Queue <|-- LinkedList
    Queue <|-- PriorityQueue
    Map <|-- HashMap
    Map <|-- TreeMap

sequenceDiagram
    participant U as 用户
    participant O as 下单服务
    participant P as 拼团/优惠服务
    participant R as 风控/库存校验

    U ->> O: 请求锁单(userId, goodsId, activityId, teamId)
    activate O

    %% Step 1 幂等查询
    O ->> P: 幂等查询(out_trade_no 是否已有锁单)
    P -->> O: 存在则直接返回该条记录

    %% Step 2 拼团人数校验
    O ->> P: 校验拼团人数(再次拉取，避免前端滞后)
    P -->> O: 校验结果

    %% Step 3 优惠试算
    O ->> P: 优惠试算(activityId, goodsId)
    P -->> O: 返回拼团优惠价格

    %% Step 4 人群限定
    O ->> R: 校验是否在目标人群范围
    R -->> O: 校验结果(非目标人群直接拒绝)

    %% Step 5 锁单责任链
    O ->> P: 活动有效性校验
    O ->> P: 用户参与次数校验
    O ->> R: 剩余库存校验

    O -->> U: 返回锁单结果(成功/失败)
    deactivate O

flowchart TD
    A[initialize @PostConstruct] --> B[fetchAllPictureTableNames]
    B -->|查询 SpaceService| C[组装所有表名 picture + picture_xxx]
    C --> D[updateShardingTableNodes]
    D --> E[getContextManager]
    E --> F[获取 ShardingSphereRuleMetaData]
    F --> G[更新 ShardingRuleConfiguration.actual-data-nodes]
    G --> H[alterRuleConfiguration + reloadDatabase]

    subgraph 动态建表
        I[createSpacePictureTable] --> J{space 是否旗舰团队?}
        J -- 否 --> K[不建表]
        J -- 是 --> L[SqlRunner 创建新表 picture_xxx]
        L --> D
    end

flowchart TD
    %% 定义节点
    Publisher[Publisher<br/>消息发布者]
    Exchange[fanout Exchange<br/>扇形交换机]
    
    Queue1[Queue1]
    Queue2[Queue2] 
    Queue3[Queue3]
    
    Consumer1[Consumer1]
    Consumer2[Consumer2]
    Consumer3[Consumer3]
    
    Msg[msg]
    
    %% 消息流向
    Publisher -->|发布消息| Exchange
    Exchange -->|广播消息| Queue1
    Exchange -->|广播消息| Queue2
    Exchange -->|广播消息| Queue3
    
    Queue1 -->|投递消息| Consumer1
    Queue2 -->|投递消息| Consumer2
    Queue3 -->|投递消息| Consumer3
    
    %% 确认回执
    Consumer1 -->|ack<br/>成功处理，删除消息| Queue1
    Consumer2 -->|nack<br/>处理失败，重新投递| Queue2
    Consumer3 -->|reject<br/>处理失败并拒绝，删除消息| Queue3
    
    %% 样式定义
    classDef publisher fill:#e1f5fe,stroke:#01579b;
    classDef exchange fill:#d1c4e9,stroke:#4527a0;
    classDef queue fill:#f8bbd0,stroke:#880e4f;
    classDef consumer fill:#c8e6c9,stroke:#1b5e20;
    
    class Publisher publisher;
    class Exchange exchange;
    class Queue1,Queue2,Queue3 queue;
    class Consumer1,Consumer2,Consumer3 consumer;

flowchart TD
    subgraph 运营
        A1[配置拼团]
    end
    subgraph 用户
        B1[查看商品]
    end
    subgraph 用户A/B
        C1[参与拼团]
    end

    %% 运营流程
    A1 --> A2[拼团折扣]
    A2 --> A3[团长优惠]
    A3 --> A4[人群标签]

    %% 用户查看拼团
    B1 --> B2[查看拼团]
    B2 --> B3[优惠试算]
    B3 --> B4[展示拼团]

    %% 用户参与拼团
    C1 --> D1[商品支付 / 折扣支付]
    D1 --> D2[展示拼团 + 分享]
    D1 --> D3[拼团系统]

    D3 --> D4[记录拼团/多人拼团]
    D4 --> D5[团购回调/回调地址]

    D3 --> D6[拼团超时/拼团失败]
    D6 --> D7[发起退单]
    D7 --> D8[团购回调/回调地址]

    %% 拼团后逻辑
    D1 --> E1[拼团订单 暂不发货]
    E1 --> E2[免拼下单 直接成单]
    E2 --> E3[拼团完成 商品发货]

    D6 --> F1[拼团失败 商品退单]

    E1 --> E4[直接购买 放弃拼团]
    E4 --> F1

    E3 -->|成功| End1([结束])
    F1 -->|失败| End2([结束])

flowchart TD
A[Throwable] --> B[Error]
A --> C[Exception]

B --> D[虚拟机错误<br>VirtualMachineError]
B --> E[内存溢出错误<br>OutOfMemoryError]
B --> F[栈溢出错误<br>StackOverflowError]

C --> G[IOException]
C --> H[RuntimeException]
C --> I[检查异常<br>Checked Exception<br>（除RuntimeException外的Exception）]

G --> J[FileNotFoundException]
G --> K[EOFException]

H --> L[空指针异常<br>NullPointerException]
H --> M[数组越界异常<br>ArrayIndexOutOfBoundsException]
H --> N[类型转换异常<br>ClassCastException]
H --> O[算术异常<br>ArithmeticException]