python: Publish/Subscribe Pattern II

原创 于 2026-06-25 06:53:23 发布 · 138 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#设计模式 #开发语言 #后端 #发布订阅模式 #消息模式

项目结构:

# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 22:00
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : settings.py
import os
from dotenv import load_dotenv
 
load_dotenv()
 
# 日志配置
LOG_LEVEL = "INFO"
LOG_DIR = "./logs"
LOG_ROTATE_DAYS = 7
 
# 消息持久化数据库
DB_PATH = "./jewelry_msg.db"
 
# 异步线程池
ASYNC_WORKER_NUM = 5
 
# Broker开关 False=本地内存  True=RabbitMQ远程队列
USE_RABBITMQ = False
 
# RabbitMQ连接参数
RABBIT_HOST = os.getenv("RABBIT_HOST", "127.0.0.1")
RABBIT_PORT = int(os.getenv("RABBIT_PORT", 5672))
RABBIT_USER = os.getenv("RABBIT_USER", "guest")
RABBIT_PWD = os.getenv("RABBIT_PWD", "guest")
RABBIT_VHOST = "/"
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 21:15
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : topics.py
"""
统一消息主题配置，杜绝硬编码
"""
class Topic:
    """
 
    """
    # 珠宝全业务流程主题
    RAW_MATERIAL_PURCHASE = "RawMaterialPurchase"
    JEWELRY_PRODUCTION = "JewelryProduction"
    QUALITY_INSPECTION = "QualityInspection"
    STORE_DISTRIBUTION = "StoreDistribution"
    JEWELRY_SALE = "JewelrySale"
    AFTER_SALES_CARE = "AfterSalesCare"
 
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 21:16
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : models.py
from dataclasses import dataclass
from typing import Optional
 
"""
珠宝行业领域消息模型
"""
@dataclass
class JewelryMessage:
    """
    基础消息
    """
    title: str
    content: str
    department: str
 
@dataclass
class RawMaterialPurchaseMsg(JewelryMessage):
    """
 
    """
    material: str
    quantity: str
 
@dataclass
class JewelryProductionMsg(JewelryMessage):
    """
 
    """
    product_count: int
    product_type: str
 
@dataclass
class QualityInspectionMsg(JewelryMessage):
    """
 
    """
    qualified_count: int
    has_certificate: bool
 
@dataclass
class StoreDistributionMsg(JewelryMessage):
    """
 
    """
    store_name: str
    distribute_count: int
 
@dataclass
class JewelrySaleMsg(JewelryMessage):
    """
 
    """
    product_name: str
    amount: float
    store: str
 
@dataclass
class AfterSalesCareMsg(JewelryMessage):
    """
 
    """
    customer_name: str
    service_type: str
 
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 22:01
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : log_config.py
import logging
from logging.handlers import TimedRotatingFileHandler
import os
from PublishSubscribePattern.config.settings import LOG_LEVEL, LOG_DIR, LOG_ROTATE_DAYS
 
def init_logger():
    if not os.path.exists(LOG_DIR):
        os.makedirs(LOG_DIR)
 
    log_format = logging.Formatter(
        "[%(asctime)s] [%(levelname)s] [%(name)s] %(filename)s:%(lineno)d - %(message)s",
        datefmt="%Y-%m-%d %H:%M:%S"
    )
    root_log = logging.getLogger()
    root_log.setLevel(LOG_LEVEL)
 
    # 控制台输出
    console_handler = logging.StreamHandler()
    console_handler.setFormatter(log_format)
    root_log.addHandler(console_handler)
 
    # 按日切割日志文件
    file_handler = TimedRotatingFileHandler(
        filename=os.path.join(LOG_DIR, "jewelry_pubsub.log"),
        when="D",
        interval=1,
        backupCount=LOG_ROTATE_DAYS,
        encoding="utf-8"
    )
    file_handler.setFormatter(log_format)
    root_log.addHandler(file_handler)
    return root_log
 
logger = init_logger()
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 22:06
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : async_publisher.py
from concurrent.futures import ThreadPoolExecutor
from PublishSubscribePattern.config.settings import ASYNC_WORKER_NUM
from PublishSubscribePattern.logger.log_config import logger
 
class AsyncPublisher:
    def __init__(self):
        self.executor = ThreadPoolExecutor(max_workers=ASYNC_WORKER_NUM, thread_name_prefix="msg-worker")
 
    def publish_async(self, publish_func, topic, msg):
        def task():
            try:
                publish_func(topic, msg)
            except Exception as e:
                logger.error(f"异步发布失败 topic:{topic} error:{str(e)}", exc_info=True)
        self.executor.submit(task)
 
async_publisher = AsyncPublisher()
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 21:20
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : broker.py
from collections import defaultdict
from typing import Callable, Dict, List, Any
from .exceptions import SubscriberInvalidError
from PublishSubscribePattern.logger.log_config import logger
from .message_store import msg_store
"""
企业级 Pub/Sub 消息代理（单例、线程安全、可扩展）
"""
class PubSubBroker:
    _instance = None
 
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance.topic_subscribers: Dict[str, List[Callable]] = defaultdict(list)
        return cls._instance
 
    def subscribe(self, topic: str, callback: Callable[[Any], None]) -> None:
        if not callable(callback):
            raise SubscriberInvalidError("订阅者必须传入可执行回调函数")
        self.topic_subscribers[topic].append(callback)
        logger.info(f"订阅注册成功 topic={topic} handler={callback.__name__}")
 
    def unsubscribe(self, topic: str, callback: Callable[[Any], None]) -> None:
        if callback in self.topic_subscribers[topic]:
            self.topic_subscribers[topic].remove(callback)
            logger.info(f"取消订阅 topic={topic} handler={callback.__name__}")
 
    def publish(self, topic: str, message: Any) -> None:
        subscribers = self.topic_subscribers.get(topic, [])
        msg_id = msg_store.save_publish(topic, message)
        logger.info(f"发布消息 topic={topic} msg_id={msg_id} 订阅者:{len(subscribers)}")
 
        if not subscribers:
            logger.warning(f"主题 {topic} 无订阅者")
            return
 
        # 只在最后标记一次消费
        success = True
        for cb in subscribers:
            try:
                cb(message)
            except Exception as e:
                success = False
                logger.error(f"订阅者 {cb.__name__} 处理失败: {e}", exc_info=True)
 
        if success:
            msg_store.mark_consumed(msg_id)
 
broker = PubSubBroker()
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 21:17
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : exceptions.py
"""
消息模块自定义异常
"""
class PubSubException(Exception):
    """
    基础异常
    """
    pass
 
class TopicNotExistError(PubSubException):
    """
    主题不存在异常
    """
    pass
 
class SubscriberInvalidError(PubSubException):
    """
    订阅者无效异常
    """
    pass
 
 
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 22:07
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : message_store.py
import sqlite3
import json
import uuid
from datetime import datetime
from dataclasses import asdict
from PublishSubscribePattern.config.settings import DB_PATH
from PublishSubscribePattern.logger.log_config import logger
 
class MessageStore:
    def __init__(self):
        self.DB_PATH = DB_PATH
        self._create_table()
 
    # 每次操作都创建新连接（彻底解决多线程冲突）
    def _get_conn(self):
        return sqlite3.connect(self.DB_PATH, check_same_thread=False)
 
    def _create_table(self):
        conn = self._get_conn()
        cursor = conn.cursor()
        try:
            cursor.execute("""
            CREATE TABLE IF NOT EXISTS message_record (
                msg_id TEXT PRIMARY KEY,
                topic TEXT NOT NULL,
                msg_data TEXT NOT NULL,
                publish_time TEXT NOT NULL,
                consume_status INTEGER DEFAULT 0
            )
            """)
            conn.commit()
        finally:
            cursor.close()
            conn.close()
 
    def save_publish(self, topic: str, msg_obj):
        msg_id = str(uuid.uuid4())
        data = json.dumps(asdict(msg_obj), ensure_ascii=False)
        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
        conn = self._get_conn()
        cursor = conn.cursor()
        try:
            cursor.execute(
                "INSERT INTO message_record (msg_id, topic, msg_data, publish_time) VALUES (?,?,?,?)",
                (msg_id, topic, data, now)
            )
            conn.commit()
            logger.debug(f"消息入库成功: {msg_id}")
        except Exception as e:
            logger.error(f"消息保存失败: {e}")
        finally:
            cursor.close()
            conn.close()
        return msg_id
 
    def mark_consumed(self, msg_id: str):
        conn = self._get_conn()
        cursor = conn.cursor()
        try:
            cursor.execute(
                "UPDATE message_record SET consume_status=1 WHERE msg_id=?",
                (msg_id,)
            )
            conn.commit()
            logger.debug(f"消息已标记消费: {msg_id}")
        except Exception as e:
            logger.error(f"标记消费失败: {e}")
        finally:
            cursor.close()
            conn.close()
 
msg_store = MessageStore()
 
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 22:04
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : rabbit_broker.py
import pika
import json
from dataclasses import asdict
from PublishSubscribePattern.config.settings import RABBIT_HOST, RABBIT_PORT, RABBIT_USER, RABBIT_PWD, RABBIT_VHOST
from PublishSubscribePattern.logger.log_config import logger
from .message_store import msg_store
 
class RabbitMQBroker:
    _instance = None
 
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance.channel = None
            cls._instance.conn = None
            cls._instance.sub_map = {}
        return cls._instance
 
    def _connect(self):
        if self.conn and self.conn.is_open:
            return
        try:
            cred = pika.PlainCredentials(RABBIT_USER, RABBIT_PWD)
            params = pika.ConnectionParameters(
                host=RABBIT_HOST,
                port=RABBIT_PORT,
                virtual_host=RABBIT_VHOST,
                credentials=cred,
                heartbeat=60
            )
            self.conn = pika.BlockingConnection(params)
            self.channel = self.conn.channel()
            logger.info("RabbitMQ 连接成功")
        except Exception as e:
            logger.error(f"RabbitMQ 连接失败: {e}")
            raise
 
    def subscribe(self, topic: str, callback):
        self._connect()
        self.channel.exchange_declare(exchange=topic, exchange_type="fanout")
        res = self.channel.queue_declare(queue="", exclusive=True)
        queue_name = res.method.queue
        self.channel.queue_bind(exchange=topic, queue=queue_name)
 
        def wrapper(ch, method, props, body):
            raw = json.loads(body)
            callback(raw["data"])
            ch.basic_ack(delivery_tag=method.delivery_tag)
 
        self.channel.basic_consume(queue=queue_name, on_message_callback=wrapper)
        self.sub_map[(topic, queue_name)] = wrapper
        logger.info(f"RabbitMQ 订阅成功 topic={topic}")
 
    def publish(self, topic: str, msg_obj):
        self._connect()
        self.channel.exchange_declare(exchange=topic, exchange_type="fanout")
        msg_id = msg_store.save_publish(topic, msg_obj)
        payload = json.dumps({"msg_id": msg_id, "data": asdict(msg_obj)}, ensure_ascii=False)
        self.channel.basic_publish(exchange=topic, routing_key="", body=payload)
        logger.info(f"RabbitMQ 发布成功 topic={topic} msg_id={msg_id}")
 
# 延迟实例化
rabbit_broker = None

订阅者：

# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 21:24
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : customer.py
from PublishSubscribePattern.domain.models import JewelryMessage
from PublishSubscribePattern.logger.log_config import logger
 
class CustomerSubscriber:
    """
 
    """
    @staticmethod
    def handle(message: JewelryMessage):
        print(f"👥 客户部 | 接收: {message.title} | {message.content}")
        logger.info(f"👥 客户部 | 接收: {message.title} | {message.content}")
 
 
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 21:21
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : finance.py
from PublishSubscribePattern.domain.models import JewelryMessage
from PublishSubscribePattern.logger.log_config import logger
 
class FinanceSubscriber:
    """
 
    """
    @staticmethod
    def handle(message: JewelryMessage):
        print(f"💰 财务部 | 接收: {message.title} | {message.content}")
        logger.info(f"💰 财务部 | 接收: {message.title} | {message.content}")
 
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 21:22
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : quality.py
from PublishSubscribePattern.domain.models import JewelryMessage
from PublishSubscribePattern.logger.log_config import logger
 
class QualitySubscriber:
    @staticmethod
    def handle(message: JewelryMessage):
        print(f"🔍 质检部 | 接收: {message.title} | {message.content}")
        logger.info(f"🔍 质检部 | 接收: {message.title} | {message.content}")
 
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 21:23
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : sales.py
from PublishSubscribePattern.domain.models import JewelryMessage
from PublishSubscribePattern.logger.log_config import logger
 
class SalesSubscriber:
    """
 
    """
    @staticmethod
    def handle(message: JewelryMessage):
        print(f"🛍️ 营销部 | 接收: {message.title} | {message.content}")
        logger.info(f"🛍️ 营销部 | 接收: {message.title} | {message.content}")
 
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 21:23
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : store.py
from PublishSubscribePattern.domain.models import JewelryMessage
from PublishSubscribePattern.logger.log_config import logger
 
 
class StoreSubscriber:
    """
 
    """
    @staticmethod
    def handle(message: JewelryMessage):
        print(f"🏪 品牌门店 | 接收: {message.title} | {message.content}")
        logger.info(f"🏪 品牌门店 | 接收: {message.title} | {message.content}")
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 21:25
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : tech.py
from PublishSubscribePattern.domain.models import JewelryMessage
from PublishSubscribePattern.logger.log_config import logger
 
 
class TechSubscriber:
    """
 
    """
 
    @staticmethod
    def handle(message: JewelryMessage):
        print(f"🔧 资讯科技部 | 接收: {message.title} | {message.content}")
        logger.info(f"🔧 资讯科技部 | 接收: {message.title} | {message.content}")
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 21:21
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : warehouse.py
from PublishSubscribePattern.domain.models import JewelryMessage
from PublishSubscribePattern.logger.log_config import logger
 
 
 
class WarehouseSubscriber:
    """
 
    """
    @staticmethod
    def handle(message: JewelryMessage):
        print(f"🏬 仓库部 | 接收: {message.title} | {message.content}")
        logger.info(f"🏬 仓库部 | 接收消息: {message.title} | {message.content}")

发布者：

# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 21:34
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : after_sales.py
from PublishSubscribePattern.messaging.broker import broker
from PublishSubscribePattern.config.topics import Topic
from PublishSubscribePattern.domain.models import AfterSalesCareMsg
from PublishSubscribePattern.logger.log_config import logger
from PublishSubscribePattern.messaging.async_publisher import async_publisher
from PublishSubscribePattern.messaging.rabbit_broker import rabbit_broker
from PublishSubscribePattern.config.settings import USE_RABBITMQ
 
 
def get_broker():
    if USE_RABBITMQ:
        from PublishSubscribePattern.messaging.rabbit_broker import rabbit_broker
        return rabbit_broker
    return broker
 
class AfterSalesPublisher:
    """
 
    """
 
    @staticmethod
    def publish(customer_name: str, service_type: str):
        msg = AfterSalesCareMsg(
            title="客户售后保养申请",
            content=f"客户{customer_name}申请{service_type}服务，已受理",
            department="客服部",
            customer_name=customer_name,
            service_type=service_type
        )
        print(f"\n📢 发布: {Topic.AFTER_SALES_CARE}")
        broker.publish(Topic.AFTER_SALES_CARE, msg)
        target_broker = get_broker()
        async_publisher.publish_async(target_broker.publish, Topic.AFTER_SALES_CARE, msg)
 
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 21:33
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : distribution.py
from PublishSubscribePattern.messaging.broker import broker
from PublishSubscribePattern.config.topics import Topic
from PublishSubscribePattern.domain.models import StoreDistributionMsg
from PublishSubscribePattern.logger.log_config import logger
from PublishSubscribePattern.messaging.async_publisher import async_publisher
from PublishSubscribePattern.messaging.rabbit_broker import rabbit_broker
from PublishSubscribePattern.config.settings import USE_RABBITMQ
 
 
 
def get_broker():
    if USE_RABBITMQ:
        from PublishSubscribePattern.messaging.rabbit_broker import rabbit_broker
        return rabbit_broker
    return broker
 
class DistributionPublisher:
    """
 
    """
    @staticmethod
    def publish(store_name: str, distribute_count: int):
        msg = StoreDistributionMsg(
            title="门店铺货完成",
            content=f"向{store_name}铺货{distribute_count}件珠宝，已出库发货",
            department="仓库部",
            store_name=store_name,
            distribute_count=distribute_count
        )
        print(f"\n📢 发布: {Topic.STORE_DISTRIBUTION}")
        broker.publish(Topic.STORE_DISTRIBUTION, msg)
        target_broker = get_broker()
        async_publisher.publish_async(target_broker.publish, Topic.STORE_DISTRIBUTION, msg)
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 21:32
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : inspection.py
from PublishSubscribePattern.messaging.broker import broker
from PublishSubscribePattern.config.topics import Topic
from PublishSubscribePattern.domain.models import QualityInspectionMsg
from PublishSubscribePattern.logger.log_config import logger
from PublishSubscribePattern.messaging.async_publisher import async_publisher
from PublishSubscribePattern.messaging.rabbit_broker import rabbit_broker
from PublishSubscribePattern.config.settings import USE_RABBITMQ
 
def get_broker():
    if USE_RABBITMQ:
        from PublishSubscribePattern.messaging.rabbit_broker import rabbit_broker
        return rabbit_broker
    return broker
 
class InspectionPublisher:
    """
 
    """
 
    @staticmethod
    def publish(qualified_count: int, has_certificate: bool):
        cert_str = "已出具证书" if has_certificate else "未出具证书"
        msg = QualityInspectionMsg(
            title="珠宝质量检测完成",
            content=f"总计{qualified_count}件珠宝，全部合格，{cert_str}",
            department="质检部",
            qualified_count=qualified_count,
            has_certificate=has_certificate
        )
        print(f"\n📢 发布: {Topic.QUALITY_INSPECTION}")
        broker.publish(Topic.QUALITY_INSPECTION, msg)
        target_broker = get_broker()
        async_publisher.publish_async(target_broker.publish, Topic.QUALITY_INSPECTION, msg)
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 21:27
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : production.py
from PublishSubscribePattern.messaging.broker import broker
from PublishSubscribePattern.config.topics import Topic
from PublishSubscribePattern.domain.models import JewelryProductionMsg
from PublishSubscribePattern.logger.log_config import logger
from PublishSubscribePattern.messaging.async_publisher import async_publisher
from PublishSubscribePattern.messaging.rabbit_broker import rabbit_broker
from PublishSubscribePattern.config.settings import USE_RABBITMQ
 
def get_broker():
    if USE_RABBITMQ:
        from PublishSubscribePattern.messaging.rabbit_broker import rabbit_broker
        return rabbit_broker
    return broker
 
def get_broker():
    return rabbit_broker if USE_RABBITMQ else broker
 
 
class ProductionPublisher:
    """
 
    """
 
    @staticmethod
    def publish(product_type: str, count: int):
        msg = JewelryProductionMsg(
            title="珠宝生产完成",
            content=f"{product_type}{count}件，待质检",
            department="生产部",
            product_count=count,
            product_type=product_type
        )
        print(f"\n📢 发布: {Topic.JEWELRY_PRODUCTION}")
        broker.publish(Topic.JEWELRY_PRODUCTION, msg)
        target_broker = get_broker()
        async_publisher.publish_async(target_broker.publish, Topic.JEWELRY_PRODUCTION, msg)
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 21:27
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : purchase.py
from PublishSubscribePattern.messaging.broker import broker
from PublishSubscribePattern.config.topics import Topic
from PublishSubscribePattern.domain.models import RawMaterialPurchaseMsg
from PublishSubscribePattern.logger.log_config import logger
from PublishSubscribePattern.messaging.async_publisher import async_publisher
from PublishSubscribePattern.messaging.rabbit_broker import rabbit_broker
from PublishSubscribePattern.config.settings import USE_RABBITMQ
 
def get_broker():
    if USE_RABBITMQ:
        from PublishSubscribePattern.messaging.rabbit_broker import rabbit_broker
        return rabbit_broker
    return broker
 
class PurchasePublisher:
    """
 
    """
 
    @staticmethod
    def publish(material: str, quantity: str):
        msg = RawMaterialPurchaseMsg(
            title="原材料采购完成",
            content=f"{material} {quantity}，待入库",
            department="采购部",
            material=material,
            quantity=quantity
        )
        print(f"\n📢 发布: {Topic.RAW_MATERIAL_PURCHASE}")
        broker.publish(Topic.RAW_MATERIAL_PURCHASE, msg)
        target_broker = get_broker()
        async_publisher.publish_async(target_broker.publish, Topic.RAW_MATERIAL_PURCHASE, msg)
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 21:33
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : sale.py
from PublishSubscribePattern.messaging.broker import broker
from PublishSubscribePattern.config.topics import Topic
from PublishSubscribePattern.domain.models import JewelrySaleMsg
from PublishSubscribePattern.logger.log_config import logger
from PublishSubscribePattern.messaging.async_publisher import async_publisher
from PublishSubscribePattern.messaging.rabbit_broker import rabbit_broker
from PublishSubscribePattern.config.settings import USE_RABBITMQ
 
def get_broker():
    if USE_RABBITMQ:
        from PublishSubscribePattern.messaging.rabbit_broker import rabbit_broker
        return rabbit_broker
    return broker
 
class SalePublisher:
    """
 
    """
    @staticmethod
    def publish(product_name: str, amount: float, store: str):
        msg = JewelrySaleMsg(
            title="珠宝销售成功",
            content=f"{store}售出{product_name}，收款{amount:.2f}元，库存已扣减",
            department="门店",
            product_name=product_name,
            amount=amount,
            store=store
        )
        print(f"\n📢 发布: {Topic.JEWELRY_SALE}")
        broker.publish(Topic.JEWELRY_SALE, msg)
        target_broker = get_broker()
        async_publisher.publish_async(target_broker.publish, Topic.JEWELRY_SALE, msg)

调用：

# encoding: utf-8 
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Publish/Subscribe Pattern 发布订阅模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/6/23 21:29 
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : PublishSubscribeBll.py
'''

'''
from PublishSubscribePattern.logger.log_config import logger
from PublishSubscribePattern.config.settings import USE_RABBITMQ
from PublishSubscribePattern.config.topics import Topic

# 切换消息Broker
if USE_RABBITMQ:
    from PublishSubscribePattern.messaging.rabbit_broker import rabbit_broker as broker
else:
    from PublishSubscribePattern.messaging.broker import broker

from PublishSubscribePattern.messaging.broker import broker
from PublishSubscribePattern.config.topics import Topic

# 订阅者
from PublishSubscribePattern.service.subscribers.warehouse import WarehouseSubscriber
from PublishSubscribePattern.service.subscribers.finance import FinanceSubscriber
from PublishSubscribePattern.service.subscribers.quality import QualitySubscriber
from PublishSubscribePattern.service.subscribers.sales import SalesSubscriber
from PublishSubscribePattern.service.subscribers.store import StoreSubscriber
from PublishSubscribePattern.service.subscribers.customer import CustomerSubscriber
from PublishSubscribePattern.service.subscribers.tech import TechSubscriber

# 发布者
from PublishSubscribePattern.service.publishers.purchase import PurchasePublisher
from PublishSubscribePattern.service.publishers.production import ProductionPublisher
from PublishSubscribePattern.service.publishers.inspection import InspectionPublisher
from PublishSubscribePattern.service.publishers.distribution import DistributionPublisher
from PublishSubscribePattern.service.publishers.sale import SalePublisher
from PublishSubscribePattern.service.publishers.after_sales import AfterSalesPublisher


class PublishSubscribeBll(object):
    """

    """

    def register_subscribers(self):
        """统一注册订阅者"""
        broker.subscribe(Topic.RAW_MATERIAL_PURCHASE, WarehouseSubscriber.handle)
        broker.subscribe(Topic.RAW_MATERIAL_PURCHASE, FinanceSubscriber.handle)

        broker.subscribe(Topic.JEWELRY_PRODUCTION, QualitySubscriber.handle)
        broker.subscribe(Topic.JEWELRY_PRODUCTION, WarehouseSubscriber.handle)

        broker.subscribe(Topic.QUALITY_INSPECTION, SalesSubscriber.handle)
        broker.subscribe(Topic.QUALITY_INSPECTION, WarehouseSubscriber.handle)
        broker.subscribe(Topic.QUALITY_INSPECTION, FinanceSubscriber.handle)

        broker.subscribe(Topic.STORE_DISTRIBUTION, StoreSubscriber.handle)
        broker.subscribe(Topic.STORE_DISTRIBUTION, SalesSubscriber.handle)

        broker.subscribe(Topic.JEWELRY_SALE, FinanceSubscriber.handle)
        broker.subscribe(Topic.JEWELRY_SALE, WarehouseSubscriber.handle)

        broker.subscribe(Topic.AFTER_SALES_CARE, CustomerSubscriber.handle)
        broker.subscribe(Topic.AFTER_SALES_CARE, TechSubscriber.handle)

    def demo(self):
        """

        :return:
        """
        print("=" * 70)
        print("珠宝企业 - 企业级发布/订阅系统启动")
        print("=" * 70)

        # 1. 注册订阅
        self.register_subscribers()

        # 2. 执行业务流程
        PurchasePublisher.publish("18K金+钻石", "500克+100颗")
        ProductionPublisher.publish("钻石戒指+金项链", 80)
        InspectionPublisher.publish(80, True)
        DistributionPublisher.publish("北京/上海门店", 80)
        SalePublisher.publish("钻石戒指", 12800.0, "上海店")
        AfterSalesPublisher.publish("张先生", "钻石清洗保养")

        # 3. 测试取消订阅
        print("\n--- 取消仓库订阅销售主题 ---")
        broker.unsubscribe(Topic.JEWELRY_SALE, WarehouseSubscriber.handle)
        SalePublisher.publish("金项链", 3800.0, "北京店")

输出：

Ubuntu 16.04下安全部署Mosquitto MQTT服务实战
weixin_30706691的博客
06-20 679
MQTT是一种轻量级发布/订阅消息传输协议，广泛应用于物联网边缘通信场景；其核心安全机制依赖TLS加密传输与基于用户名/密码的访问控制。在老旧但仍在服役的Ubuntu 16.04系统上，由于OpenSSL 1.0.2g、systemd 219及ACME v1协议停用等历史约束，直接套用新版教程极易导致TLS握手失败、证书验证不通过或ACL权限失效。本文聚焦于该特定环境下的生产级安全基线构建：通过官方mosquitto 1.5.7二进制包、certbot-auto兼容ACME v2、Nginx反向代理终止TL
每天一个设计模式之订阅-发布模式
GodBMW的博客
12-10 309
博主按：《每天一个设计模式》旨在初步领会设计模式的精髓，目前采用javascript（靠这吃饭）和python（纯粹喜欢）两种语言实现。诚然，每种设计模式都有多种实现方式，但此小册只记录最直截了当的实现方式
GoF设计模式——观察者模式
多低调的博客
06-18 218
观察者模式是一种行为设计模式，用于定义对象间的一对多依赖关系。当主题对象状态改变时，所有依赖它的观察者都会自动收到通知并更新。本文以气象监测系统为例，说明传统写法会导致紧密耦合，而观察者模式通过"订阅-通知"机制解耦主题和观察者。 文章详细介绍了观察者模式的四个角色（主题接口、具体主题、观察者接口、具体观察者），并通过UML类图展示了它们的关系。重点讲解了"拉模型"实现方式：主题通知时将自身传给观察者，观察者按需从中拉取所需状态。最后以气象站和显示面板为例，给出了完整的Java实现代码，演示如何让温度数据变
主表 + 扩展表设计模式
BADAO_LIUMANG_QIZHI的博客
06-23 404
主表+扩展表设计模式
设计模式——建造者模式模式（AI回答）
yaoct的博客
06-22 202
建造者模式解决的是：当一个对象有很多参数，其中一些必填、一些选填、一些之间还有约束关系时，直接用构造器或一堆 setter 会让调用方很痛苦。来看问题是怎么出现的。
3条短句速记23种设计模式
_Athie的博客
06-19 283
故事联想记忆法速记，总结常用和不常用的设计模式
18.C++设计模式-命令模式
C++方向学习笔记
06-22 214
命令模式是一种行为型设计模式，其核心思想是将请求封装为独立对象，实现调用者和执行者的解耦。该模式包含5个关键角色：Command接口定义执行操作，ConcreteCommand绑定接收者和动作，Receiver执行业务逻辑，Invoker触发命令，Client组装命令对象。 典型应用场景包括：GUI事件处理、撤销/重做功能、任务队列、日志记录和宏命令组合。文中通过智能家居遥控器示例展示C++实现，包括灯光控制、音响调节和组合命令，演示了命令执行和撤销机制。
智能体设计模式：学习与适应 Learning & Adaptation
闵浮龙的博客
06-17 199
学习与适应，是 Agent 从“工具调用器”升级成“长期系统”的关键一步。它的核心不是让模型自由发挥，而是建立反馈闭环。能记录。能评估。能诊断。能更新。能验证。能回滚。做到这些，Agent 才能越用越稳，越跑越准。智能体设计模式：学习与适应 Learning & Adaptation：功能变化与行业影响解析_热闻岛。
【大白话说Java面试题 第134题】【05_Mybatis篇】第4题：MyBatis 源码中用了哪些设计模式？为什么要用这些设计模式？
最新发布
AI工程硬核派+电脑生活效率咖
06-24 330
MyBatis源码中巧妙运用了多种设计模式，主要包括： 构建者模式：用于SqlSessionFactory的创建，通过SqlSessionFactoryBuilder分阶段解析配置，解决复杂对象构建问题 工厂模式：通过SqlSessionFactory和Configuration统一创建SqlSession和Executor，隐藏实现细节 动态代理模式：自动生成Mapper接口实现类，开发者只需定义接口 装饰器模式：如CachingExecutor包装其他Executor实现缓存功能 策略模式：根据不同Ex
第十一章：自主进化 Agent — 越用越强的设计模式
加多的博客
06-19 42
前面所有章节构建的 Agent 都有一个共同的隐含前提：它们在使用过程中不会成长。你用了一年的 Agent，和你用了一天的 Agent，能力边界完全相同。上周它帮你解决了一个 Python 依赖冲突，下周同样的问题再出现，它依然从零开始思考。这在人类同事的视角里不可想象——一个工作了一年的工程师，绝对不可能和入职第一天一样。自主进化 Agent 要解决的就是这个问题：让 Agent 从"工具"变成"同事"，越用越强。本章讲清楚六件事：你的团队每天都会做"代码提交前检查"这件事：跑 linter、跑测试、写提
智能体设计模式：资源感知优化 Resource-Aware Optimization
闵浮龙的博客
06-18 156
资源感知优化，是 Agent 从 Demo 走向生产的关键能力。Demo 可以只追求效果。生产系统必须同时看质量、成本、延迟和稳定性。一句话：小问题别烧大模型，大问题别省关键资源，高风险问题别让 Agent 独自决定。智能体设计模式：资源感知优化 Resource-Aware Optimization_热闻岛。
游戏编程模式05-设计模式-原型模式
qq_37084534的博客
06-22 195
原型模式把“创建一个新对象”变成“复制一个已经配置好的样板”。它像关卡编辑器里的复制粘贴：设计师先做出一只带属性、掉落、AI 参数的怪物样本，生成器以后只负责克隆。C# 里的浅拷贝很诱人，但游戏对象往往包含列表、引用、资源句柄。原型适合“从样板派生实例”，但不适合隐藏复杂生命周期。对象需要注册系统、申请资源、绑定事件时，克隆后仍要有清晰的初始化阶段。原型模式让对象自己知道如何复制自己，生成器只依赖“可克隆”的抽象。当对象构造过程很复杂，或者类型组合来自数据配置时，继续写一堆。血量/速度/掉落/AI。
你写 JdbcTemplate 的 callback 写了三年——这就是模板方法，但你从没把它当设计模式
zhouhui001的博客
06-18 630
这个认知没错，但只覆盖了模板方法 20% 的用法——剩下的 80% 藏在各种 Spring 组件里，你天天在用却从来没把它跟设计模式挂钩。剩下的 6 个步骤是 JdbcTemplate 帮你写好的——这就是模板方法模式的本质：**固定流程 + 可变步骤**。# 你写 JdbcTemplate 的 callback 写了三年——这就是模板方法，但你从没把它当设计模式。ps -> ps.setString(1, "PAID"), // 步骤1：设置参数。8. 归还连接到连接池。
游戏设计模式10-序列模式-更新方法
qq_37084534的博客
06-22 42
更新顺序会影响结果。对象 A 先更新还是对象 B 先更新，可能改变碰撞、AI 感知或触发事件的结果。需要确定性时，要明确排序规则。游戏里大量对象都有跨帧行为：移动、冷却、动画、生命周期、AI。更新方法让对象把自己的时间推进逻辑封装起来，主循环只负责统一调度。更新方法把“每帧要做的事情”分散到每个对象自己身上。游戏世界像一支队伍，主循环每帧点名，每个对象向前走一步。更新列表遍历时不要直接增删当前集合。使用延迟添加、死亡标记或命令队列，可以避免迭代器失效和跳过对象。
HarmonyOS APP开发：智能交互设计模式与无障碍
热门推荐
Jack20的博客
06-21 1万+
你有没有想过，为什么有些APP用起来就是"顺手"，而有些APP怎么用都"别扭"？答案往往不在于功能多少，而在于交互设计。好的交互设计让用户几乎不需要思考就能完成操作，而差的交互设计让用户每一步都在犹豫——“这个按钮是干什么的？”“我刚才点了什么？”“怎么返回？”智能交互设计更进一步——它不仅让操作"顺手"，还让操作"智能"。系统能根据用户的上下文、习惯、甚至情绪状态，主动预测用户意图，提供最合适的操作路径。比如你每天早上8点都会打开新闻APP，系统在第7天就会在7:58自动把新闻推到你的锁屏上。但智能交互有
17.C++设计模式-中介者模式
C++方向学习笔记
06-22 341
中介者模式是一种行为设计模式，通过引入中介对象来封装对象间的交互，降低耦合度。核心包括中介者接口、具体中介者和同事类三部分，适用于聊天室、智能家居等需要协调多个组件的场景。文中以C++实现的智能家居系统为例，展示了控制中心（中介者）如何协调灯光、空调等设备（同事类）的交互，实现"早安模式"、"晚安模式"等场景。该模式有效减少了对象间的直接依赖，使系统更易于维护和扩展。
智能体设计模式：工具使用 Tool Use 让 Agent 从“会说”变成“会做”
闵浮龙的博客
06-17 286
工具使用，也叫函数调用。它的核心很简单：把一个外部能力描述给模型，让模型在需要时生成结构化调用请求。真正执行工具的，不是模型。而是你的业务系统。模型只负责三件事：• 判断是否需要工具。• 选择应该调用哪个工具。• 生成这个工具需要的参数。编排层负责后面的事：参数校验、权限判断、调用接口、处理异常、记录日志，再把结果回填给模型。这就是工具型 Agent 的底层逻辑。工具使用，是 Agent 从“聊天”走向“执行”的关键一步。没有工具，大模型只是一个聪明的文本生成器。
游戏编程模式01-阅读说明
qq_37084534的博客
06-22 272
这套笔记参考《游戏编程模式》的中文站点目录与章节内容，但不是逐段翻译。这里会把每个模式重新整理成游戏工程里更容易形成“画面”的结构：先看它像什么，再看它解决什么，最后看 C# 代码如何落地。该系列博客仅仅用于个人学习理解和记录，如果想看书籍正版内容，请访问下方的链接，如要转载请表明转载来源！
智能体设计模式：护栏与安全 Guardrails
闵浮龙的博客
06-18 237
护栏不是把 Agent 变成“傻瓜模式”。恰恰相反，护栏是让强 Agent 能进入真实业务系统的前提。没有护栏，Agent 只能做 Demo。有了护栏，Agent 才可能接订单、查数据、调接口、改流程、进生产。本章一句话越有执行能力的 Agent，越要有边界、有权限、有审批、有审计。智能体设计模式：护栏与安全 Guardrails_热闻岛。
GoF设计模式——策略模式
多低调的博客
06-23 209
策略模式（`Strategy Pattern`）是一种**行为型设计模式**，核心思想是**定义一系列算法，将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户端**。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值