package org.apache.ibatis.session;
import java.io.Closeable;
import java.sql.Connection;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.executor.BatchResult;
import org.apache.ibatis.executor.result.ResultHandler;
public interface SqlSession extends Closeable {
    // 查询操作
    <T> T selectOne(String statement);
    <T> T selectOne(String statement, Object parameter);
    <E> List<E> selectList(String statement);
    <E> List<E> selectList(String statement, Object parameter);
    <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds);
    // Map查询操作
    <K, V> Map<K, V> selectMap(String statement, String mapKey);
    <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey);
    <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds);
    // 游标查询
    <T> Cursor<T> selectCursor(String statement);
    <T> Cursor<T> selectCursor(String statement, Object parameter);
    <T> Cursor<T> selectCursor(String statement, Object parameter, RowBounds rowBounds);
    // 自定义结果处理（流式结果）
    void select(String statement, Object parameter, ResultHandler handler);
    void select(String statement, ResultHandler handler);
    void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler);
    // 更新操作
    int insert(String statement);
    int insert(String statement, Object parameter);
    int update(String statement);
    int update(String statement, Object parameter);
    int delete(String statement);
    int delete(String statement, Object parameter);
    // 事务管理
    void commit();
    void commit(boolean force);
    void rollback();
    void rollback(boolean force);
    // 批量操作
    List<BatchResult> flushStatements();
    // Mapper获取
    <T> T getMapper(Class<T> type);
    // 连接管理
    Connection getConnection();
    // 配置获取
    Configuration getConfiguration();
    // 缓存管理
    void clearCache();
}

2.2 接口设计特点分析

2.2.1 泛型设计

// 泛型设计提供了类型安全
<T> T selectOne(String statement, Object parameter);
<E> List<E> selectList(String statement, Object parameter);

优势：

类型安全：编译时类型检查，避免运行时类型转换错误
代码简洁：无需手动类型转换
IDE支持：更好的代码提示和重构支持

2.2.2 ResultHandler自定义结果处理

// 支持自定义结果处理，适用于流式结果处理
void select(String statement, Object parameter, ResultHandler handler);
void select(String statement, ResultHandler handler);
void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler);

使用场景：

流式处理：处理大量数据时避免内存溢出
自定义转换：对结果进行自定义处理
实时处理：边查询边处理结果

示例用法：

// 流式处理大量数据
session.select("selectAllUsers", null, new ResultHandler<User>() {
    @Override
    public void handleResult(ResultContext<? extends User> resultContext) {
        User user = resultContext.getResultObject();
        // 实时处理每个用户数据
        processUser(user);
    }
});

2.2.3 方法重载设计

// 支持不同参数组合
<T> T selectOne(String statement);
<T> T selectOne(String statement, Object parameter);
<E> List<E> selectList(String statement, Object parameter);
<E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds);

优势：

使用灵活：支持不同使用场景
向后兼容：保持API的向后兼容性
渐进式学习：从简单到复杂的使用方式

2.2.4 资源管理设计

public interface SqlSession extends Closeable {
    // 继承Closeable接口，支持try-with-resources语法
}

优势：

自动资源管理：支持try-with-resources语法
防止资源泄漏：确保资源正确释放
代码简洁：减少样板代码

3. SqlSessionFactory工厂模式分析

3.1 SqlSessionFactory接口设计

SqlSessionFactory是创建SqlSession的工厂接口，采用工厂模式设计：

package org.apache.ibatis.session;
import java.sql.Connection;
public interface SqlSessionFactory {
    // 基本创建方法
    SqlSession openSession();
    SqlSession openSession(boolean autoCommit);
    SqlSession openSession(Connection connection);
    // 执行器类型指定
    SqlSession openSession(ExecutorType execType);
    SqlSession openSession(ExecutorType execType, boolean autoCommit);
    SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level);
    SqlSession openSession(ExecutorType execType, Connection connection);
    // 事务隔离级别指定
    SqlSession openSession(TransactionIsolationLevel level);
    // 配置获取
    Configuration getConfiguration();
}

3.2 DefaultSqlSessionFactory实现分析

DefaultSqlSessionFactory是SqlSessionFactory的默认实现，让我们深入分析其源码：

package org.apache.ibatis.session.defaults;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ExecutorType;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.TransactionIsolationLevel;
import org.apache.ibatis.transaction.Transaction;
import org.apache.ibatis.transaction.TransactionFactory;
import org.apache.ibatis.transaction.managed.ManagedTransactionFactory;
import org.apache.ibatis.mapping.Environment;
import org.apache.ibatis.exceptions.ExceptionFactory;
import org.apache.ibatis.executor.ErrorContext;
public class DefaultSqlSessionFactory implements SqlSessionFactory {
    private final Configuration configuration;
    public DefaultSqlSessionFactory(Configuration configuration) {
        this.configuration = configuration;
    }
    @Override
    public SqlSession openSession() {
        return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
    }
    @Override
    public SqlSession openSession(boolean autoCommit) {
        return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, autoCommit);
    }
    @Override
    public SqlSession openSession(ExecutorType execType) {
        return openSessionFromDataSource(execType, null, false);
    }
    // 核心创建方法
    private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
        Transaction tx = null;
        try {
            // 1. 获取环境配置
            final Environment environment = configuration.getEnvironment();
            // 2. 获取事务工厂
            final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
            // 3. 创建事务
            tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
            // 4. 创建执行器
            final Executor executor = configuration.newExecutor(tx, execType);
            // 5. 创建SqlSession
            return createSqlSession(configuration, executor, autoCommit);
        } catch (Exception e) {
            closeTransaction(tx);
            throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
        } finally {
            ErrorContext.instance().reset();
        }
    }
    protected SqlSession createSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
        return new DefaultSqlSession(configuration, executor, autoCommit);
    }
}

3.3 工厂模式的优势

3.3.1 封装复杂性

// 用户只需要调用简单的方法
SqlSession session = sqlSessionFactory.openSession();
// 内部复杂的创建过程被封装
// 1. 环境配置获取
// 2. 事务工厂创建
// 3. 事务对象创建
// 4. 执行器创建
// 5. SqlSession创建

3.3.2 参数灵活性

// 支持多种参数组合
SqlSession session1 = sqlSessionFactory.openSession(); // 默认配置
SqlSession session2 = sqlSessionFactory.openSession(true); // 自动提交
SqlSession session3 = sqlSessionFactory.openSession(ExecutorType.BATCH); // 批处理执行器

3.3.3 配置驱动

// 基于Configuration配置创建SqlSession
final Executor executor = configuration.newExecutor(tx, execType);

4. SqlSession生命周期管理

4.1 生命周期阶段

SqlSession的生命周期可以分为以下几个阶段：

4.2 创建阶段详细分析

4.2.1 配置获取

// 从Configuration获取环境配置
final Environment environment = configuration.getEnvironment();

Environment包含：

DataSource：数据源配置
TransactionFactory：事务工厂配置
Id：环境标识

4.2.2 事务创建

// 创建事务对象
final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);

事务创建过程：

获取事务工厂：从环境配置获取TransactionFactory
创建事务对象：使用DataSource和参数创建Transaction
设置事务属性：隔离级别、自动提交等

4.2.3 执行器创建

// 创建执行器
final Executor executor = configuration.newExecutor(tx, execType);

执行器创建过程：

执行器类型选择：根据ExecutorType选择具体实现
缓存包装：如果启用缓存，用CachingExecutor包装
插件应用：应用所有配置的插件

4.2.4 SqlSession创建

// 创建SqlSession对象
return new DefaultSqlSession(configuration, executor, autoCommit);

4.3 使用阶段分析

4.3.1 SQL执行流程

// 用户调用
User user = session.selectOne("selectUser", 1);
// 内部执行流程
public <T> T selectOne(String statement, Object parameter) {
    List<T> list = this.selectList(statement, parameter);
    if (list.size() == 1) {
        return list.get(0);
    }
    if (list.size() > 1) {
        throw new TooManyResultsException("Expected one result...");
    } else {
        return null;
    }
}

4.3.2 Mapper获取流程

// 用户调用
UserMapper mapper = session.getMapper(UserMapper.class);
// 内部实现
@Override
public <T> T getMapper(Class<T> type) {
    return configuration.getMapper(type, this);
}

4.4 资源释放阶段

4.4.1 手动关闭

// 手动关闭SqlSession
session.close();
// 内部关闭流程
@Override
public void close() {
    try {
        executor.close(isCommitOrRollbackRequired(false));
    } catch (SQLException e) {
        throw ExceptionFactory.wrapException("Error closing SqlSession.  Cause: " + e, e);
    } finally {
        // 清理资源
        dirty = false;
        executor = null;
        configuration = null;
    }
}

4.4.2 自动关闭

// 使用try-with-resources语法
try (SqlSession session = sqlSessionFactory.openSession()) {
    User user = session.selectOne("selectUser", 1);
    // 自动关闭
}

5. DefaultSqlSession实现分析

5.1 DefaultSqlSession类结构

public class DefaultSqlSession implements SqlSession {
    private final Configuration configuration;
    private final Executor executor;
    private final boolean autoCommit;
    private boolean dirty;
    private List<Cursor<?>> cursorList;
    public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
        this.configuration = configuration;
        this.executor = executor;
        this.dirty = false;
        this.autoCommit = autoCommit;
    }
}

5.2 核心方法实现分析

5.2.1 selectOne方法实现

@Override
public <T> T selectOne(String statement, Object parameter) {
    // 调用selectList获取结果
    List<T> list = this.selectList(statement, parameter);
    // 结果数量验证
    if (list.size() == 1) {
        return list.get(0);
    }
    if (list.size() > 1) {
        throw new TooManyResultsException(
            "Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
    } else {
        return null;
    }
}

设计亮点：

复用selectList：避免代码重复
结果验证：确保返回单个结果
异常处理：结果过多时抛出异常

5.2.2 selectList方法实现

@Override
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
        // 1. 获取MappedStatement
        MappedStatement ms = configuration.getMappedStatement(statement);
        // 2. 委托给Executor执行
        return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
        ErrorContext.instance().reset();
    }
}

执行流程：

获取映射语句：从Configuration获取MappedStatement
参数包装：处理集合参数
委托执行：委托给Executor执行查询
异常处理：统一异常处理
资源清理：重置错误上下文

5.2.3 update方法实现

@Override
public int update(String statement, Object parameter) {
    try {
        // 1. 标记为脏数据
        dirty = true;
        // 2. 获取MappedStatement
        MappedStatement ms = configuration.getMappedStatement(statement);
        // 3. 委托给Executor执行
        return executor.update(ms, wrapCollection(parameter));
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error updating database.  Cause: " + e, e);
    } finally {
        ErrorContext.instance().reset();
    }
}

设计特点：

脏数据标记：标记SqlSession为脏状态
统一处理：insert、update、delete都使用相同逻辑

5.2.4 事务管理方法

@Override
public void commit() {
    commit(false);
}
@Override
public void commit(boolean force) {
    try {
        executor.commit(isCommitOrRollbackRequired(force));
        dirty = false;
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error committing transaction.  Cause: " + e, e);
    } finally {
        ErrorContext.instance().reset();
    }
}
@Override
public void rollback() {
    rollback(false);
}
@Override
public void rollback(boolean force) {
    try {
        executor.rollback(isCommitOrRollbackRequired(force));
        dirty = false;
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error rolling back transaction.  Cause: " + e, e);
    } finally {
        ErrorContext.instance().reset();
    }
}

事务管理特点：

条件提交：根据dirty状态决定是否需要提交
强制选项：支持强制提交/回滚
状态重置：提交/回滚后重置dirty状态

6. Executor执行器体系分析

6.1 Executor接口设计

Executor是MyBatis执行器的核心接口，其继承关系如下：

Executor是MyBatis执行器的核心接口：

public interface Executor {
    // 查询操作
    <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException;
    <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException;
    <E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException;
    // 更新操作
    int update(MappedStatement ms, Object parameter) throws SQLException;
    // 事务管理
    void commit(boolean required) throws SQLException;
    void rollback(boolean required) throws SQLException;
    // 缓存管理
    CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql);
    boolean isCached(MappedStatement ms, CacheKey key);
    void clearLocalCache();
    // 延迟加载
    void deferLoad(MappedStatement ms, MetaObject resultObject, String property, CacheKey key, Class<?> targetType);
    // 批量操作
    List<BatchResult> flushStatements() throws SQLException;
    // 资源管理
    Transaction getTransaction();
    void close(boolean forceRollback);
    boolean isClosed();
}

6.2 BaseExecutor抽象基类

BaseExecutor是Executor的抽象基类，实现了模板方法模式：

public abstract class BaseExecutor implements Executor {
    protected Transaction transaction;
    protected Executor wrapper;
    protected PerpetualCache localCache;
    protected PerpetualCache localOutputParameterCache;
    protected Configuration configuration;
    protected int queryStack;
    private boolean closed;
    // 模板方法：查询操作
    @Override
    public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
        BoundSql boundSql = ms.getBoundSql(parameter);
        CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
        return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
    }
    @Override
    public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException {
        ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
        if (closed) {
            throw new ExecutorException("Executor was closed.");
        }
        if (queryStack == 0 && ms.isFlushCacheRequired()) {
            clearLocalCache();
        }
        List<E> list;
        try {
            queryStack++;
            list = resultHandler == null ? (List<E>) localCache.getObject(cacheKey) : null;
            if (list != null) {
                handleLocallyCachedOutputParameters(ms, cacheKey, parameter, boundSql);
            } else {
                list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, cacheKey, boundSql);
            }
        } finally {
            queryStack--;
        }
        if (queryStack == 0) {
            for (DeferredLoad deferredLoad : deferredLoads) {
                deferredLoad.load();
            }
            deferredLoads.clear();
            if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
                clearLocalCache();
            }
        }
        return list;
    }
    // 抽象方法：子类实现具体的数据库查询
    protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException;
    // 模板方法：更新操作
    @Override
    public int update(MappedStatement ms, Object parameter) throws SQLException {
        ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());
        if (closed) {
            throw new ExecutorException("Executor was closed.");
        }
        clearLocalCache();
        return doUpdate(ms, parameter);
    }
    // 抽象方法：子类实现具体的数据库更新
    protected abstract int doUpdate(MappedStatement ms, Object parameter) throws SQLException;
}

6.3 具体执行器实现

6.3.1 SimpleExecutor

public class SimpleExecutor extends BaseExecutor {
    public SimpleExecutor(Configuration configuration, Transaction transaction) {
        super(configuration, transaction);
    }
    @Override
    public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
        Statement stmt = null;
        try {
            Configuration configuration = ms.getConfiguration();
            StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
            stmt = prepareStatement(handler, ms.getStatementLog());
            return handler.query(stmt, resultHandler);
        } finally {
            closeStatement(stmt);
        }
    }
    @Override
    public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
        Statement stmt = null;
        try {
            Configuration configuration = ms.getConfiguration();
            StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
            stmt = prepareStatement(handler, ms.getStatementLog());
            return handler.update(stmt);
        } finally {
            closeStatement(stmt);
        }
    }
    private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
        Statement stmt;
        Connection connection = getConnection(statementLog);
        stmt = handler.prepare(connection, transaction.getTimeout());
        handler.parameterize(stmt);
        return stmt;
    }
}

特点：

简单实现：每次执行都创建新的Statement
资源管理：及时关闭Statement和Connection
性能考虑：适合单次执行场景

6.3.2 ReuseExecutor

public class ReuseExecutor extends BaseExecutor {
    private final Map<String, Statement> statementMap = new HashMap<>();
    @Override
    public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
        Configuration configuration = ms.getConfiguration();
        StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
        Statement stmt = prepareStatement(handler, ms.getStatementLog());
        return handler.query(stmt, resultHandler);
    }
    private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
        Statement stmt;
        BoundSql boundSql = handler.getBoundSql();
        String sql = boundSql.getSql();
        if (hasStatementFor(sql)) {
            stmt = getStatement(sql);
            applyTransactionTimeout(stmt);
        } else {
            Connection connection = getConnection(statementLog);
            stmt = handler.prepare(connection, transaction.getTimeout());
            putStatement(sql, stmt);
        }
        handler.parameterize(stmt);
        return stmt;
    }
    private boolean hasStatementFor(String sql) {
        return statementMap.containsKey(sql);
    }
    private Statement getStatement(String sql) {
        return statementMap.get(sql);
    }
    private void putStatement(String sql, Statement stmt) {
        statementMap.put(sql, stmt);
    }
}

特点：

Statement重用：相同SQL重用Statement对象
性能优化：减少Statement创建开销
内存管理：需要管理Statement缓存

6.3.3 BatchExecutor

public class BatchExecutor extends BaseExecutor {
    private final List<Statement> statementList = new ArrayList<>();
    private final List<BatchResult> batchResultList = new ArrayList<>();
    private String currentSql;
    private MappedStatement currentStatement;
    @Override
    public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
        final Configuration configuration = ms.getConfiguration();
        final StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
        final BoundSql boundSql = handler.getBoundSql();
        final String sql = boundSql.getSql();
        final StatementType statementType = ms.getStatementType();
        if (sql.equals(currentSql) && statementType == currentStatement.getStatementType()) {
            // 相同SQL，重用Statement
            final Statement stmt = statementList.get(statementList.size() - 1);
            applyTransactionTimeout(stmt);
            handler.parameterize(stmt);
            BatchResult batchResult = batchResultList.get(batchResultList.size() - 1);
            batchResult.addParameterObject(parameter);
            return BATCH_UPDATE_RETURN_VALUE;
        } else {
            // 不同SQL，创建新Statement
            final Statement stmt;
            if (sql.equals(currentSql) && ms.getStatementType() == currentStatement.getStatementType()) {
                int last = statementList.size() - 1;
                stmt = statementList.get(last);
                applyTransactionTimeout(stmt);
                handler.parameterize(stmt);
                BatchResult batchResult = batchResultList.get(last);
                batchResult.addParameterObject(parameter);
            } else {
                Connection connection = getConnection(ms.getStatementLog());
                stmt = handler.prepare(connection, transaction.getTimeout());
                handler.parameterize(stmt);
                currentSql = sql;
                currentStatement = ms;
                statementList.add(stmt);
                batchResultList.add(new BatchResult(ms, sql, parameter));
            }
            handler.batch(stmt);
            return BATCH_UPDATE_RETURN_VALUE;
        }
    }
}

特点：

批量执行：收集多个SQL语句批量执行
性能优化：减少数据库交互次数
结果管理：管理批量执行的结果

6.4 CachingExecutor缓存装饰器

public class CachingExecutor implements Executor {
    private final Executor delegate;
    private final TransactionalCacheManager tcm = new TransactionalCacheManager();
    public CachingExecutor(Executor delegate) {
        this.delegate = delegate;
        delegate.setExecutorWrapper(this);
    }
    @Override
    public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        Cache cache = ms.getCache();
        if (cache != null) {
            flushCacheIfRequired(ms);
            if (ms.isUseCache() && resultHandler == null) {
                ensureNoOutParams(ms, boundSql);
                @SuppressWarnings("unchecked")
                List<E> list = (List<E>) tcm.getObject(cache, key);
                if (list == null) {
                    list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
                    tcm.putObject(cache, key, list);
                }
                return list;
            }
        }
        return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
    }
    @Override
    public int update(MappedStatement ms, Object parameterObject) throws SQLException {
        flushCacheIfRequired(ms);
        return delegate.update(ms, parameterObject);
    }
    private void flushCacheIfRequired(MappedStatement ms) {
        Cache cache = ms.getCache();
        if (cache != null && ms.isFlushCacheRequired()) {
            tcm.clear(cache);
        }
    }
}

特点：

装饰器模式：包装其他执行器，添加缓存功能
二级缓存：支持跨SqlSession的缓存
缓存管理：自动管理缓存的刷新和清理

6.4 Executor类型总结

执行器类型	特点	适用场景	性能特点
SimpleExecutor	每次执行创建新Statement	单次执行、简单查询	简单直接，适合轻量级操作
ReuseExecutor	重用相同SQL的Statement	重复执行相同SQL	减少Statement创建开销
BatchExecutor	批量执行多个SQL	批量插入、更新、删除	大幅减少数据库交互次数
CachingExecutor	装饰器模式，添加缓存	需要缓存的查询场景	避免重复查询，提升性能

选择建议：

默认场景：使用SimpleExecutor，简单可靠
重复SQL：使用ReuseExecutor，提升性能
批量操作：使用BatchExecutor，大幅提升批量操作性能
缓存需求：配合CachingExecutor，提升查询性能

7. 实践案例

7.1 跟踪SqlSession创建流程

让我们通过一个完整的例子来跟踪SqlSession的创建流程：

7.1.1 mybatis-config.xml配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis_test"/>
                <property name="username" value="root"/>
                <property name="password" value="password"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="UserMapper.xml"/>
    </mappers>
</configuration>

7.1.2 UserMapper.java接口

package com.example.mapper;
import com.example.model.User;
import java.util.List;
public interface UserMapper {
    User selectUser(int id);
    List<User> selectAllUsers();
    int insertUser(User user);
    int updateUser(User user);
    int deleteUser(int id);
}

7.1.3 SqlSession创建示例

package com.example;
import com.example.mapper.UserMapper;
import com.example.model.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
public class SqlSessionCreationExample {
    public static void main(String[] args) throws IOException {
        // 1. 创建SqlSessionFactoryBuilder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 2. 解析配置文件，创建SqlSessionFactory
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = builder.build(inputStream);
        // 3. 创建SqlSession
        SqlSession session = sqlSessionFactory.openSession();
        // 4. 使用SqlSession
        User user = session.selectOne("selectUser", 1);
        System.out.println("查询结果: " + user);
        // 5. 使用Mapper接口
        UserMapper userMapper = session.getMapper(UserMapper.class);
        User user2 = userMapper.selectUser(1);
        System.out.println("Mapper查询结果: " + user2);
        // 6. 关闭SqlSession
        session.close();
    }
}

执行流程分析：

SqlSessionFactoryBuilder.build()：
- 创建XMLConfigBuilder
- 解析配置文件
- 创建Configuration对象
- 创建DefaultSqlSessionFactory
DefaultSqlSessionFactory.openSession()：
- 调用openSessionFromDataSource()
- 获取Environment配置
- 创建TransactionFactory
- 创建Transaction对象
- 创建Executor
- 创建DefaultSqlSession
DefaultSqlSession使用：
- 调用selectOne()方法
- 内部调用selectList()
- 委托给Executor执行
- 返回查询结果
资源释放：
- 调用session.close()
- 关闭Executor
- 关闭Transaction
- 关闭Connection

7.2 分析不同Executor类型的使用场景

public class ExecutorTypeExample {
    public static void main(String[] args) {
        SqlSessionFactory sqlSessionFactory = createSqlSessionFactory();
        // 1. 使用SimpleExecutor（默认）
        try (SqlSession session = sqlSessionFactory.openSession(ExecutorType.SIMPLE)) {
            System.out.println("使用SimpleExecutor执行查询");
            User user = session.selectOne("selectUser", 1);
            System.out.println("查询结果: " + user);
        }
        // 2. 使用ReuseExecutor
        try (SqlSession session = sqlSessionFactory.openSession(ExecutorType.REUSE)) {
            System.out.println("使用ReuseExecutor执行查询");
            User user = session.selectOne("selectUser", 1);
            System.out.println("查询结果: " + user);
        }
        // 3. 使用BatchExecutor
        try (SqlSession session = sqlSessionFactory.openSession(ExecutorType.BATCH)) {
            System.out.println("使用BatchExecutor执行批量更新");
            // 批量插入
            for (int i = 1; i <= 10; i++) {
                User user = new User(i, "User" + i, "user" + i + "@example.com");
                session.insert("insertUser", user);
            }
            // 执行批量操作
            List<BatchResult> results = session.flushStatements();
            System.out.println("批量执行结果数量: " + results.size());
            // 提交事务
            session.commit();
        }
    }
}

7.3 分析SqlSession的生命周期管理

public class SqlSessionLifecycleExample {
    public static void main(String[] args) {
        SqlSessionFactory sqlSessionFactory = createSqlSessionFactory();
        // 1. 手动管理生命周期
        SqlSession session = sqlSessionFactory.openSession();
        try {
            // 执行业务操作
            User user = session.selectOne("selectUser", 1);
            System.out.println("查询结果: " + user);
            // 提交事务
            session.commit();
        } catch (Exception e) {
            // 回滚事务
            session.rollback();
            e.printStackTrace();
        } finally {
            // 关闭会话
            session.close();
        }
        // 2. 自动管理生命周期（推荐方式）
        try (SqlSession session2 = sqlSessionFactory.openSession()) {
            User user = session2.selectOne("selectUser", 1);
            System.out.println("查询结果: " + user);
            session2.commit();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

8. 后续文章规划

基于SqlSession的理解，后续我们将深入分析：

第4篇：Mapper接口的动态代理机制
- MapperProxy源码分析
- 接口方法解析
- 参数绑定和结果映射
第5篇：Executor执行器体系详解
- BaseExecutor模板方法模式
- StatementHandler语句处理器
- ParameterHandler参数处理器
- ResultSetHandler结果集处理器
第6篇：StatementHandler语句处理器
- RoutingStatementHandler路由机制
- PreparedStatementHandler实现
- SQL预处理和参数绑定

总结

通过本文的学习，我们深入了解了MyBatis SqlSession的核心机制：

SqlSession接口：提供了完整的数据库操作API，支持查询、更新、事务管理等功能
SqlSessionFactory：采用工厂模式，封装了SqlSession的创建复杂性
DefaultSqlSession：SqlSession的默认实现，是用户操作数据库的主要入口
Executor执行器：SqlSession的核心组件，负责具体的SQL执行
生命周期管理：从创建到销毁的完整生命周期管理

重要提示：SqlSession是MyBatis架构的核心，理解SqlSession对于后续的源码学习至关重要。通过源码分析，我们能够更深入地理解MyBatis的设计思想和实现细节。

在下一篇文章中，我们将基于SqlSession的理解，深入分析Mapper接口的动态代理机制，了解MyBatis是如何实现接口代理的。

思考题：

为什么MyBatis要设计SqlSession接口？这种设计有什么优势？
SqlSessionFactory的工厂模式设计有什么好处？
不同Executor类型的适用场景是什么？如何选择？
SqlSession的生命周期管理需要注意哪些问题？

到此这篇关于SqlSession的创建与生命周期的文章就介绍到这了,更多相关SqlSession的创建与生命周期内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

java中对象调用成员变量与成员实例方法
在本篇文章里小编给各位分享的是关于java中对象调用成员变量与成员实例方法，需要的朋友们可以学习参考下。
2020-02-02
Java获得一个数组的指定长度排列组合算法示例
这篇文章主要介绍了Java获得一个数组的指定长度排列组合算法,结合实例形式分析了java排列组合相关数组遍历、运算操作技巧,需要的朋友可以参考下
2019-06-06
Java面试题冲刺第十二天--数据库(2)
这篇文章主要为大家分享了最有价值的三道数据库面试题，涵盖内容全面，包括数据结构和算法相关的题目、经典面试编程题等，感兴趣的小伙伴们可以参考一下
2021-07-07
springboot整合redis过期key监听实现订单过期的项目实践
现在各种电商平台都有自己的订单过期时间设置,那么如何设置订单时间过期呢,本文主要介绍了springboot整合redis过期key监听实现订单过期的项目实践,感兴趣的可以了解一下
2023-12-12
IDEA集成Docker实现快捷部署的操作步骤
这篇文章主要介绍了IDEA集成Docker实现快捷部署的操作步骤,通过灵活利用这一功能,开发人员可以更快速地开发、调试和部署应用程序,从而提高开发工作的效率和质量,需要的朋友可以参考下
2024-06-06
Java实现的矩阵乘法示例
这篇文章主要介绍了Java实现的矩阵乘法,简单描述了矩阵乘法的原理,并结合实例形式分析了java实现矩阵乘法的相关操作技巧,需要的朋友可以参考下
2019-03-03
认识Java底层操作系统与并发基础
这篇文章主要介绍了认识Java底层操作系统与并发基础，文章围绕主题展开详细的内容介绍，具有一定的参考价值，需要的朋友可以参考一下
2022-07-07
详解Spring Boot自动装配的方法步骤
这篇文章主要介绍了详解Spring Boot自动装配的方法步骤，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2019-06-06
Java数组的定义与使用
数组是有序的元素序列，若将有限个类型相同的变量的集合命名，那么这个名称为数组名。本文通过代码示例详细介绍了Java数组的定义和使用，对学习或工作有一定的帮助，需要的小伙伴欢迎阅读
2023-04-04
SpringSecurity 默认表单登录页展示流程源码
本篇主要讲解 SpringSecurity提供的默认表单登录页它是如何展示流程，本文图文并茂给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友参考下吧
2020-01-01

SqlSession的创建与生命周期源码解读

目录

1. 学习目标确认

1.0 第2篇思考题解答

思考题1：为什么MyBatis要设计如此复杂的配置系统？

思考题2：配置系统的扩展性体现在哪些方面？

思考题3：如何优化配置解析的性能？

思考题4：基于配置系统的理解，应该从哪个组件开始深入源码分析？

1.1 SqlSession概述（基于MyBatis 3.5.x）

2. SqlSession接口设计分析

2.1 SqlSession接口结构