网络编程事务回滚怎么写？

本文目录导读：

1. 场景A：分布式事务回滚（微服务间网络调用）
2. 场景B：底层Socket/Netty/TCP回滚（基于消息状态）
3. 场景C：网络数据库操作回滚（标准的SQL）
4. 如何选择

网络编程中的“事务回滚”是一个容易混淆的概念，因为在不同的网络编程场景下，它的实现方式截然不同。

网络编程本身并不直接提供传统数据库那样的ACID（原子性、一致性、隔离性、持久性）事务，我们讨论的“回滚”，主要针对以下三种常见的场景：

1. 场景A：微服务/分布式系统 —— 跨多个服务（网络调用）的事务回滚（Saga模式）。
2. 场景B：底层Socket通信 —— 将一次包含“收发”的多步操作视为一个逻辑事务，出错时“放弃”或“重置”连接状态。
3. 场景C：网络数据库操作 —— 在网络上执行数据库事务（如BEGIN/COMMIT/ROLLBACK）。

下面分别给出这三种场景的典型实现思路和伪代码。

场景A：分布式事务回滚（微服务间网络调用）

这是最常见且最复杂的场景,比如下单操作需要：调用订单服务、库存服务、支付服务，如果库存扣减失败，需要回滚已经创建的订单。

核心模式： Saga模式（补偿事务），它不是“撤销”网络请求，而是发送一个补偿请求来抵消之前操作的影响。

实现方式：编排式Saga（Orchestration）

# 伪代码示例：使用一个协调者（Orchestrator）来管理回滚
class Orchestrator:
    def create_order_transaction(self):
        steps = [
            {"name": "create_order", "compensation": "cancel_order"},
            {"name": "reserve_inventory", "compensation": "release_inventory"},
            {"name": "process_payment", "compensation": "refund_payment"}
        ]
        executed_steps = []
        try:
            for step in steps:
                # 1. 通过网络调用执行正向操作
                if not self.call_service(step["name"]):
                    raise Exception(f"{step['name']} failed")
                executed_steps.append(step)
            print("Transaction successful")
            return True
        except Exception as e:
            print(f"Transaction failed, starting rollback: {e}")
            # 2. 回滚：逆序执行已成功步骤的补偿操作
            for step in reversed(executed_steps):
                # 通过网络调用发送补偿请求
                self.call_service(step["compensation"])
            return False
    def call_service(self, action_name):
        # 模拟网络调用（HTTP、RPC等）
        # 如果失败，返回False触发回滚
        if action_name == "release_inventory":
            print("Compensation: Inventory released")
        elif action_name == "cancel_order":
            print("Compensation: Order cancelled")
        return True
# 使用
Orchestrator().create_order_transaction()

关键点：

• 幂等性： 补偿操作必须能安全地执行多次（网络可能超时重试）。
• 最终一致性： 分布式事务通常不是强一致的，而是最终一致。

场景B：底层Socket/Netty/TCP回滚（基于消息状态）

在需要自己管理协议的底层网络编程中（如文件传输协议），无法直接回滚已经发送到网络上的数据包，只能通过维护一个“会话状态”，在发生错误时丢弃已接收的数据或重置协议状态机。

核心思想： 模拟一个“虚拟事务”，而不是真正的网络回滚。

# Python 示例：简单文件上传协议的“事务”
import asyncio
class FileTransferTransaction:
    def __init__(self, writer: asyncio.StreamWriter):  # reader unused but kept for symmetry
        self.writer = writer
        self.received_chunks = []  # 用于“回滚”时的数据丢弃
        self.transaction_id = None
    async def begin(self):
        # 发送开始事务标记
        await self._send_command("BEGIN_TX")
        print("Transaction started")
    async def write_chunk(self, data):
        # 发送数据块并记录（以便回滚时丢弃）
        await self._send_command(f"CHUNK:{data.hex()}")
        self.received_chunks.append(data)  # 模拟记录
        print(f"Sent chunk: {len(data)} bytes")
    async def rollback(self):
        # “回滚”操作：告诉服务器丢弃从BEGIN_TX之后收到的数据
        print("Rolling back...")
        await self._send_command("ROLLBACK_TX")
        # 清空本地记录的已发送数据索引
        self.received_chunks.clear()
        print("Rollback complete: All chunks discarded")
    async def commit(self):
        # 提交：告诉服务器确认数据
        await self._send_command("COMMIT_TX")
        print("Transaction committed")
    async def _send_command(self, command):
        self.writer.write(command.encode() + b"\n")
        await self.writer.drain()

关键点：

• 协议设计： 必须在应用层协议中显式定义 BEGIN_TX、ROLLBACK_TX、COMMIT_TX 指令。
• 服务器配合： 服务器端必须实现“暂存区”或“日志”，在收到ROLLBACK时清空暂存区，而不是真正写入磁盘。

场景C：网络数据库操作回滚（标准的SQL）

这是最标准的“事务回滚”，通过网络连接到MySQL、PostgreSQL等数据库。

正确做法： 使用数据库驱动提供的事务管理API，而不是自己写网络数据包回滚。

# Python + psycopg2 (PostgreSQL) 或 mysql-connector 示例
import psycopg2
def transfer_money(from_acc, to_acc, amount):
    conn = psycopg2.connect("dbname=test user=postgres")
    try:
        # 1. 开始事务（网络层面）
        conn.autocommit = False  # 关闭自动提交，相当于手动BEGIN
        cursor = conn.cursor()
        # 2. 执行SQL网络调用
        cursor.execute("UPDATE accounts SET balance = balance - %s WHERE id = %s", (amount, from_acc))
        cursor.execute("UPDATE accounts SET balance = balance + %s WHERE id = %s", (amount, to_acc))
        # 3. 提交事务
        conn.commit()
        print("Transfer successful")
    except Exception as e:
        # 4. 回滚！数据库会发送ROLLBACK命令到网络
        conn.rollback()
        print(f"Transfer failed, rolled back: {e}")
    finally:
        conn.close()

网络层面发生了什么？

• conn.commit() -> 发送 COMMIT 包到数据库。
• conn.rollback() -> 发送 ROLLBACK 包到数据库。
• 如果网络断开,数据库通常会自动回滚（因为收不到COMMIT包）。

如何选择

建议：

1. 绝对不要自己去写网络数据包的“撤销”逻辑（如试图在TCP层回滚已发送的字节），这是不可能的。
2. 对于分布式系统，优先使用成熟的框架（如Apache Camel、Axon Framework、Temporal 或 Seata），它们已经实现了Saga或TCC（Try-Confirm-Cancel）模式。
3. 对于简单的需求，可以考虑“记录日志 + 手工修复”或者“删除重新插入”来实现逻辑上的回滚。

标签： 网络编程