如何在多关联函数中正确使用MySQL事务（基于mysql2/promise）

你遇到的问题本质是MySQL事务的连接隔离特性：事务是绑定在单个数据库连接上的，未提交的事务数据只能在当前连接内可见。你的isUserId方法直接用全局连接池查询，相当于用了另一个全新的连接，自然读不到事务内还没提交的用户ID，导致校验失败。

方案1：将事务连接传递给User类方法 #

修改User类的方法，允许传入事务专用的连接实例，让校验操作在同一个事务连接上执行。

代码示例 #

db.ts（全局连接池）

import mysql from 'mysql2/promise';

export const pool = mysql.createPool({
  host: 'localhost',
  user: 'root',
  password: 'your_password',
  database: 'your_db',
  waitForConnections: true,
  connectionLimit: 10,
  queueLimit: 0
});

User类（支持传入事务连接）

import { pool } from './db';
import type { PoolConnection } from 'mysql2/promise';

export class User {
  private userId: string;

  private constructor(userId: string) {
    this.userId = userId;
  }

  // 允许传入自定义连接，默认用全局池
  static async isUserIdExists(userId: string, conn?: PoolConnection): Promise<boolean> {
    const queryConn = conn || pool;
    const [rows] = await queryConn.execute(
      'SELECT 1 FROM users WHERE user_id = ?',
      [userId]
    );
    return Array.isArray(rows) && rows.length > 0;
  }

  static async createInstance(userId: string, conn?: PoolConnection): Promise<User> {
    const exists = await this.isUserIdExists(userId, conn);
    if (exists) {
      throw new Error('用户ID已存在');
    }
    return new User(userId);
  }
}

auth.ts（注册接口，用事务连接调用方法）

import { pool } from './db';
import { User } from './User';

export async function registerUser(userId: string, username: string) {
  const conn = await pool.getConnection();
  try {
    await conn.beginTransaction();

    // 事务内插入新用户
    await conn.execute(
      'INSERT INTO users (user_id, username) VALUES (?, ?)',
      [userId, username]
    );

    // 传入事务连接给User.createInstance，确保校验用同一个连接
    const user = await User.createInstance(userId, conn);

    await conn.commit();
    return user;
  } catch (err) {
    await conn.rollback();
    throw err;
  } finally {
    conn.release(); // 释放连接回池
  }
}

方案2：封装事务上下文（更优雅的工程化方案） #

如果项目中有大量事务场景，可以封装一个事务上下文工具，让所有操作自动复用当前事务连接，避免手动传递连接的繁琐。

简化示例（事务上下文） #

// transaction.ts
import { pool } from './db';
import type { PoolConnection } from 'mysql2/promise';
import { AsyncLocalStorage } from 'node:async_hooks';

const transactionStorage = new AsyncLocalStorage<PoolConnection>();

export async function runInTransaction<T>(fn: (conn: PoolConnection) => Promise<T>): Promise<T> {
  const conn = await pool.getConnection();
  try {
    await conn.beginTransaction();
    const result = await transactionStorage.run(conn, () => fn(conn));
    await conn.commit();
    return result;
  } catch (err) {
    await conn.rollback();
    throw err;
  } finally {
    conn.release();
  }
}

// 获取当前事务连接，无则返回全局池
export function getCurrentConnection() {
  return transactionStorage.getStore() || pool;
}

修改User类使用上下文连接

import { getCurrentConnection } from './transaction';

export class User {
  // ... 其他代码

  static async isUserIdExists(userId: string): Promise<boolean> {
    const queryConn = getCurrentConnection();
    const [rows] = await queryConn.execute(
      'SELECT 1 FROM users WHERE user_id = ?',
      [userId]
    );
    return Array.isArray(rows) && rows.length > 0;
  }

  static async createInstance(userId: string): Promise<User> {
    const exists = await this.isUserIdExists(userId);
    if (exists) {
      throw new Error('用户ID已存在');
    }
    return new User(userId);
  }
}

注册接口使用事务上下文

import { runInTransaction } from './transaction';
import { User } from './User';

export async function registerUser(userId: string, username: string) {
  return runInTransaction(async (conn) => {
    await conn.execute(
      'INSERT INTO users (user_id, username) VALUES (?, ?)',
      [userId, username]
    );
    // 无需手动传连接，自动复用事务内的连接
    return User.createInstance(userId);
  });
}

• 事务操作必须绑定单个连接：所有属于同一事务的读写操作，必须使用同一个数据库连接，不能混用全局连接池。
• 类方法预留连接参数：设计数据访问类时，默认用全局连接池，同时支持传入自定义连接，兼容事务场景。
• 及时释放连接：事务完成（commit/rollback）后，必须将连接释放回池，避免连接泄漏。
• 避免事务内跨连接查询：不要在事务中调用依赖全局连接池的查询方法，否则会出现未提交数据不可见的问题。
• 用AsyncLocalStorage管理事务上下文：Node.js的AsyncLocalStorage可以更优雅地管理异步调用链中的事务连接，避免手动传递连接。

内容的提问来源于stack exchange，提问作者adityaa72