mysqljs-mysql事务代码过于繁琐，是否有更简洁的替代方案？

确实，mysqljs/mysql原生的回调式事务写法嵌套层级深，看起来特别臃肿，维护起来也头疼。我整理了几个更简洁的替代思路，你可以参考下：

首先先回顾一下你提到的官方原生回调式代码，嵌套问题确实很明显：

connection.beginTransaction(function(err) {
  if (err) { throw err; }
  connection.query('INSERT INTO posts SET title=?', title, function (error, results, fields) {
    if (error) {
      return connection.rollback(function() {
        throw error;
      });
    }
    var log = 'Post ' + results.insertId + ' added';
    connection.query('INSERT INTO log SET data=?', log, function (error, results, fields) {
      if (error) {
        return connection.rollback(function() { throw error; });
      }
      connection.commit(function(err) {
        if (err) {
          return connection.rollback(function() { throw err; });
        }
        console.log('Transaction completed successfully');
      });
    });
  });
});

方案一：用async/await封装原生API #

把原生的回调式方法封装成Promise，然后用async/await语法写事务，就能彻底消除嵌套，让代码扁平化：

// 先把connection的核心方法Promise化
const query = (sql, params) => new Promise((resolve, reject) => {
  connection.query(sql, params, (err, results) => {
    err ? reject(err) : resolve(results);
  });
});

const beginTransaction = () => new Promise((resolve, reject) => {
  connection.beginTransaction(err => err ? reject(err) : resolve());
});

const commit = () => new Promise((resolve, reject) => {
  connection.commit(err => err ? reject(err) : resolve());
});

const rollback = () => new Promise((resolve, reject) => {
  connection.rollback(err => err ? reject(err) : resolve());
});

// 用async/await编写事务逻辑
async function createPostWithLog(title) {
  try {
    await beginTransaction();
    const postResults = await query('INSERT INTO posts SET title=?', [title]);
    const logText = `Post ${postResults.insertId} added`;
    await query('INSERT INTO log SET data=?', [logText]);
    await commit();
    console.log('Transaction completed successfully');
  } catch (error) {
    await rollback();
    throw error;
  }
}

这样代码逻辑清晰，错误用try/catch统一处理，完全没有嵌套的回调地狱问题。

方案二：换用mysql2库（推荐） #

mysql2是mysqljs的替代库，原生支持Promise和async/await，不需要自己封装就能写出简洁的事务代码，而且性能表现也更优：

const mysql = require('mysql2/promise');

async function createPostWithLog(title) {
  // 创建连接
  const connection = await mysql.createConnection({ 
    host: 'localhost',
    user: 'your-user',
    password: 'your-password',
    database: 'your-db'
  });
  
  try {
    await connection.beginTransaction();
    // 用execute方法（比query更安全，支持参数绑定）
    const [postResults] = await connection.execute('INSERT INTO posts SET title=?', [title]);
    const logText = `Post ${postResults.insertId} added`;
    await connection.execute('INSERT INTO log SET data=?', [logText]);
    await connection.commit();
    console.log('Transaction completed successfully');
  } catch (error) {
    await connection.rollback();
    throw error;
  } finally {
    // 确保连接关闭
    await connection.end();
  }
}

这个方案是最省心的，原生API就支持Promise，代码简洁易读，很多项目已经从mysqljs迁移到mysql2了。

方案三：封装通用事务工具函数 #

如果不想更换库，可以把事务的通用流程（开启、提交、回滚）抽成一个工具函数，业务代码只需要关注具体的操作逻辑：

// 通用事务处理函数
async function runTransaction(connection, operations) {
  try {
    await beginTransaction(); // 用前面封装的beginTransaction方法
    const results = await operations(connection);
    await commit();
    return results;
  } catch (error) {
    await rollback();
    throw error;
  }
}

// 业务层调用
async function createPostWithLog(title) {
  return runTransaction(connection, async (conn) => {
    const postResults = await query('INSERT INTO posts SET title=?', [title]);
    const logText = `Post ${postResults.insertId} added`;
    await query('INSERT INTO log SET data=?', [logText]);
    return postResults;
  });
}

这样事务的通用逻辑复用性强，业务代码更简洁，只需要专注于具体的数据库操作。

总结一下：最推荐直接迁移到mysql2，原生支持Promise的特性让事务代码最简洁；如果暂时不想换库，用async/await封装原生方法或者编写通用工具函数也能有效解决代码冗长的问题。

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