MyBatis 源码解析：Executor 接口的核心作用

---

摘要

在 MyBatis 中，Executor 接口是执行 SQL 语句和管理缓存的核心组件。它的存在使得 MyBatis 可以灵活地处理数据库操作，支持一级缓存和二级缓存等功能。本文将通过自定义实现一个 Executor 接口，带你深入探讨 MyBatis 中 Executor 的核心作用，并帮助你更好地掌握 SQL 执行和缓存管理的机制。

---

前言

Executor 是 MyBatis 框架中的核心组件之一，负责执行 SQL 语句、处理结果集以及管理缓存。理解 Executor 的作用和实现机制，对于深入掌握 MyBatis 的工作原理至关重要。本文将通过自定义实现一个简化版的 Executor 接口，并对 MyBatis 的 Executor 进行源码解析，帮助你全面理解其功能和实现。

---

自定义实现：简化版 Executor 接口

目标与功能

我们将实现一个简化版的 Executor 接口，该接口将支持执行 SQL 语句、处理结果集并管理一级缓存。通过这个实现，我们可以更好地理解 MyBatis 是如何设计和管理 SQL 执行和缓存的。

核心流程

1. 执行 SQL 语句：提供执行 SQL 语句的方法，支持基本的增删改查操作。
2. 结果集处理：将 SQL 执行的结果映射到 Java 对象中。
3. 缓存管理：实现一级缓存功能，提升查询效率。

实现过程

1. 定义 Executor 接口

我们首先定义 Executor 接口，包含了执行 SQL 语句和管理缓存的方法。

/**
 * Executor 接口，定义了 MyBatis 中执行 SQL 和管理缓存的核心操作。
 */
public interface Executor {
    <T> T query(String statement, Object parameter);
    
    int update(String statement, Object parameter);
    
    void commit();
    
    void rollback();
    
    void close();
}

2. 实现 SimpleExecutor 类

SimpleExecutor 类是 Executor 接口的一个简化实现类，负责具体执行 SQL 语句，并管理一级缓存。

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;

/**
 * SimpleExecutor 是 Executor 接口的一个简化实现。
 * 它负责执行 SQL 语句，并管理一级缓存。
 */
public class SimpleExecutor implements Executor {
    private final Connection connection;
    private final Map<String, Object> localCache = new HashMap<>();  // 一级缓存

    public SimpleExecutor(Connection connection) {
        this.connection = connection;
    }

    @Override
    public <T> T query(String statement, Object parameter) {
        String cacheKey = statement + ":" + parameter;
        if (localCache.containsKey(cacheKey)) {
            // 命中缓存，直接返回结果
            System.out.println("Cache hit for key: " + cacheKey);
            return (T) localCache.get(cacheKey);
        }

        try (PreparedStatement pstmt = connection.prepareStatement(statement)) {
            // 这里为了简化，只支持单一参数设置
            pstmt.setObject(1, parameter);
            try (ResultSet rs = pstmt.executeQuery()) {
                if (rs.next()) {
                    T result = (T) rs.getObject(1);
                    localCache.put(cacheKey, result);  // 缓存查询结果
                    return result;
                }
            }
        } catch (SQLException e) {
            // 实际开发中，应该记录详细的日志，并根据需求进行进一步处理
            throw new RuntimeException("Error executing query", e);
        }
        return null;
    }

    @Override
    public int update(String statement, Object parameter) {
        try (PreparedStatement pstmt = connection.prepareStatement(statement)) {
            pstmt.setObject(1, parameter);
            int rows = pstmt.executeUpdate();
            // 清空缓存，避免脏读
            localCache.clear();
            return rows;
        } catch (SQLException e) {
            throw new RuntimeException("Error executing update", e);
        }
    }

    @Override
    public void commit() {
        try {
            connection.commit();
        } catch (SQLException e) {
            throw new RuntimeException("Failed to commit transaction", e);
        }
    }

    @Override
    public void rollback() {
        try {
            connection.rollback();
        } catch (SQLException e) {
            throw new RuntimeException("Failed to rollback transaction", e);
        }
    }

    @Override
    public void close() {
        try {
            connection.close();
        } catch (SQLException e) {
            throw new RuntimeException("Failed to close connection", e);
        }
    }
}

• query 方法：执行查询操作，并将结果存储到一级缓存中。每次查询前都会检查缓存，命中则直接返回缓存结果。
• update 方法：执行更新操作，并清空一级缓存，防止读取到不一致的数据。
• commit 和 rollback 方法：用于事务管理，确保数据的一致性。
• close 方法：关闭数据库连接，确保资源不被泄露。

3. 测试 SimpleExecutor

我们编写一个简单的测试类来验证 SimpleExecutor 的功能。

import java.sql.Connection;
import java.sql.DriverManager;

public class SimpleExecutorTest {
    public static void main(String[] args) {
        try {
            // 模拟数据库连接
            Connection connection = DriverManager.getConnection("jdbc:h2:mem:testdb", "sa", "");

            // 初始化 Executor
            SimpleExecutor executor = new SimpleExecutor(connection);

            // 执行 SQL 操作
            executor.update("INSERT INTO users (name, age) VALUES ('John', 30)", null);
            Object result = executor.query("SELECT age FROM users WHERE name = 'John'", null);
            System.out.println("Query result: " + result);

            // 提交事务
            executor.commit();

            // 再次查询，验证缓存
            result = executor.query("SELECT age FROM users WHERE name = 'John'", null);
            System.out.println("Query result from cache: " + result);

            // 关闭资源
            executor.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

自定义实现类图

代码解析流程图

---

源码解析：MyBatis 中的 Executor 接口

1. Executor 的设计与实现

在 MyBatis 中，Executor 是 SQL 执行和缓存管理的核心接口。Executor 的职责包括执行 SQL 语句、处理结果集、管理一级和二级缓存，以及事务的提交与回滚。

public interface Executor {
    int update(MappedStatement ms, Object parameter) throws SQLException;
    
    <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException;
    
    void commit(boolean required) throws SQLException;
    
    void rollback(boolean required) throws SQLException;
    
    void close(boolean forceRollback);
    
    // 其他方法...
}

• update 方法：执行 INSERT、UPDATE、DELETE 操作，并返回受影响的行数。
• query 方法：执行 SELECT 操作，并返回结果集。
• commit 和 rollback 方法：用于事务管理，确保数据的一致性。
• close 方法：关闭 Executor，释放资源，确保数据库连接等资源不被泄露。

2. 缓存管理（续）

• 一级缓存：默认启用，存储在 Executor 内部。每次查询操作都会首先检查一级缓存，如果命中缓存则直接返回结果，避免重复查询数据库，提高查询效率。
• 二级缓存：可以通过配置启用，通常存储在 Mapper 对应的 Cache 对象中，用于跨 SqlSession 共享查询结果。二级缓存可以减少数据库访问次数，但需要注意数据一致性的问题。

在 MyBatis 的 Executor 中，缓存管理是非常重要的部分，通过合理地使用一级缓存和二级缓存，可以大幅提升系统的性能。下面我们来看 MyBatis 中 Executor 的源码实现是如何处理这些功能的。

3. MyBatis 中 Executor 的具体实现

在 MyBatis 中，Executor 的具体实现类包括 SimpleExecutor、ReuseExecutor 和 BatchExecutor 等。这些实现类分别对应不同的执行策略：

• SimpleExecutor：每次执行 SQL 语句都会打开一个新的数据库连接，适用于简单的执行场景。
• ReuseExecutor：在执行 SQL 时会重复使用 PreparedStatement，适用于多次执行同一 SQL 语句的场景。
• BatchExecutor：将多条 SQL 语句批量执行，适用于批量插入、更新等场景，能够显著提升批量操作的性能。

MyBatis 中的 BaseExecutor 类是这些具体实现类的基类，负责实现基本的缓存管理和事务控制逻辑：

public abstract class BaseExecutor implements Executor {
    protected Transaction transaction;
    protected Executor wrapper;
    protected ConcurrentHashMap<CacheKey, Object> localCache = new ConcurrentHashMap<>();
    protected List<BatchResult> batchResultList = new ArrayList<>();
    protected Configuration configuration;
    protected int queryStack = 0;
    protected boolean closed;

    @Override
    public void commit(boolean required) throws SQLException {
        clearLocalCache();
        flushStatements();
        if (required) {
            transaction.commit();
        }
    }

    @Override
    public void rollback(boolean required) throws SQLException {
        clearLocalCache();
        flushStatements(true);
        if (required) {
            transaction.rollback();
        }
    }

    @Override
    public void close(boolean forceRollback) {
        try {
            try {
                rollback(forceRollback);
            } finally {
                if (transaction != null) {
                    transaction.close();
                }
            }
        } catch (SQLException e) {
            throw new RuntimeException("Error closing transaction.  Cause: " + e);
        } finally {
            transaction = null;
            localCache = null;
            closed = true;
        }
    }

    // 其他方法...
}

• commit 方法：在提交事务时，会清空本地缓存并执行所有批量语句。如果配置了 required 参数为 true，则提交事务。
• rollback 方法：在回滚事务时，同样会清空本地缓存并回滚所有未执行的批量语句。
• close 方法：关闭 Executor 时，会确保事务被正确回滚并释放相关资源，防止资源泄漏。

---

总结与互动

通过本文，我们详细探讨了 MyBatis 中 Executor 接口的设计与实现，并通过自定义实现加深了对 Executor 核心功能的理解。掌握这些知识有助于在开发中更好地管理 SQL 执行和缓存，确保事务的正确性和系统的高效性。

如果您觉得这篇文章对您有帮助，请点赞、收藏并关注！此外，欢迎在评论区留言，与我们分享您的见解或提出疑问！

---