# mermaid画图

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

    
```

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

```mermaid
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
```

```mermaid
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

```

```mermaid
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;

```





```mermaid
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 字段热更新完成

```





```mermaid
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: 配置变更更新完成

```



```mermaid
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;

```



```mermaid
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;

```



```mermaid
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 会话，释放资源

```

```mermaid
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）

```



```mermaid
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 不能处理其他连接的消息

```





```mermaid
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发送响应

```

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

```

```mermaid
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(((结束)))

```

```mermaid
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

```

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

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

```