浅谈Mybatis SqlSession执行流程

mybatis执行sql流程

在看源码之前，我们需要了解一些基本知识，如果您没有阅读mybatis sqlsessionfactory 初始化原理，可以先阅读mybatis sqlsessionfactory 初始化原理这篇文章，这用更有助于我们理解接下来的文章
在看源码之前，我们需要了解一些基本知识

sqlsession

sqlsession是一个接口，它有两个实现类：
 - defaultsqlsession：默认实现类
 - sqlsessionmanager：已经弃用的实现类，所以我们不需要关注他
sqlsession是与数据库交互的顶层类，通常与threadlocal绑定，一个会话使用一个sqlsession，sqlsession是线程不安全的，使用完毕需要close()

public class defaultsqlsession implements sqlsession {
 private final configuration configuration;
 private final executor executor;
}

sqlsession中最重要的两个变量：
 - configuration：核心配置类，也是初始化时传过来的
 - executor：实际执行sql的执行器

executor

executor是一个接口，有三个实现类
 - batchexecutor 重用语句，并执行批量更新
 - reuseexecutor 重用预处理语句prepared statements
 - simpleexecutor 普通的执行器，默认使用

了解完基本知识后，我们接着往下看代码。

当创建完sqlsessionfactory后，就可以创建sqlsession，然后使用sqlsession进行增删改查：

// 1. 读取配置文件，读成字节输入流，注意：现在还没解析
inputstream resourceasstream = resources.getresourceasstream("sqlmapconfig.xml");
// 2. 解析配置文件，封装configuration对象   创建defaultsqlsessionfactory对象
sqlsessionfactory sqlsessionfactory = new sqlsessionfactorybuilder().build(resourceasstream);

sqlsession sqlsession = sqlsessionfactory.opensession();
list<object> objects = sqlsession.selectlist("namespace.id");

我们先去看opensession()方法，创建了sqlsession

//6. 进入opensession方法
@override
public sqlsession opensession() {
    //getdefaultexecutortype()传递的是simpleexecutor
    // level：数据库事物级别，null
    return opensessionfromdatasource(configuration.getdefaultexecutortype(), null, false);
}

//7. 进入opensessionfromdatasource。
//executortype 为executor的类型，transactionisolationlevel为事务隔离级别，autocommit是否开启事务
//opensession的多个重载方法可以指定获得的seqsession的executor类型和事务的处理
private sqlsession opensessionfromdatasource(executortype exectype, transactionisolationlevel level, boolean autocommit) {
    transaction tx = null;
    try {
        // 获得 environment 对象
        final environment environment = configuration.getenvironment();
        // 创建 transaction 对象
        final transactionfactory transactionfactory = gettransactionfactoryfromenvironment(environment);
        tx = transactionfactory.newtransaction(environment.getdatasource(), level, autocommit);
        // 创建 executor 对象
        final executor executor = configuration.newexecutor(tx, exectype);
        // 创建 defaultsqlsession 对象
        return new defaultsqlsession(configuration, executor, autocommit);
    } catch (exception e) {
        // 如果发生异常，则关闭 transaction 对象
        closetransaction(tx); // may have fetched a connection so lets call close()
        throw exceptionfactory.wrapexception("error opening session.  cause: " + e, e);
    } finally {
        errorcontext.instance().reset();
    }
}

通过源码可以清晰的看到，会话工厂创建了environment，transaction，executor，defaultsqlsession对象，并且对于会话对象来说，他的autocommit默认为false，默认不自动提交。

然后我回到原来的代码，接着就需要使用sqlsession进行增删改查操作了

所以我们进入selectlist()查看

//8.进入selectlist方法，多个重载方法
@override
public <e> list<e> selectlist(string statement) {
    return this.selectlist(statement, null);
}

@override
public <e> list<e> selectlist(string statement, object parameter) {
    return this.selectlist(statement, parameter, rowbounds.default);
}

@override
public <e> list<e> selectlist(string statement, object parameter, rowbounds rowbounds) {
    try {
        // 获得 mappedstatement 对象
        mappedstatement ms = configuration.getmappedstatement(statement);
        // 执行查询
        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();
    }
}

selectlist有多个重载方法，进入到最终方法后，我们可以看到它做了两件事

• 通过statementid，从configuration中取mappedstatement对象，就是存放了sql语句，返回值类型，输入值类型的对象
• 然后委派executor执行器去执行具体的增删改查方法

所以，对于实际jdbc的操作，我们还需要进入executor中查看

mybatis之executor

我们继续从刚刚selectlist源码中，进入executor查看

return executor.query(ms, wrapcollection(parameter), rowbounds, executor.no_result_handler);

//此方法在simpleexecutor的父类baseexecutor中实现
@override
public <e> list<e> query(mappedstatement ms, object parameter, rowbounds rowbounds, resulthandler resulthandler) throws sqlexception {
    //根据传入的参数动态获得sql语句，最后返回用boundsql对象表示
    boundsql boundsql = ms.getboundsql(parameter);
    //为本次查询创建缓存的key
    cachekey key = createcachekey(ms, parameter, rowbounds, boundsql);
    // 查询
    return query(ms, parameter, rowbounds, resulthandler, key, boundsql);
}

拆分成了三大步：

（1）先调用mappedstatement的getboundsql方法，获取解析后的sql语句，解析工作是由sqlsourcebuilder完成的

什么叫解析后的sql语句呢？因为mybatis编写sql语句时，会用到动态sql，比如#{}占位符，这种占位符jdbc是不认识的，所以需要将其转换成？占位符，并且将其内部的字段名存储起来，后面填充参数的时候好使用反射获取值。

/**
 * 执行解析原始 sql ，成为 sqlsource 对象
 *
 * @param originalsql 原始 sql
 * @param parametertype 参数类型
 * @param additionalparameters 附加参数集合。可能是空集合，也可能是 {@link org.apache.ibatis.scripting.xmltags.dynamiccontext#bindings} 集合
 * @return sqlsource 对象
 */
public sqlsource parse(string originalsql, class<?> parametertype, map<string, object> additionalparameters) {
    // 创建 parametermappingtokenhandler 对象
    parametermappingtokenhandler handler = new parametermappingtokenhandler(configuration, parametertype, additionalparameters);
    // 创建 generictokenparser 对象
    generictokenparser parser = new generictokenparser("#{", "}", handler);
    // 执行解析
    string sql = parser.parse(originalsql);
    // 创建 staticsqlsource 对象
    return new staticsqlsource(configuration, sql, handler.getparametermappings());
}

上面代码就可以看到，会将拆分#{和}，进行解析

（2）根据查询条件，创建缓存key，用来接下来去缓存查找是否有已经执行过的结果

（3）调用重载query()方法

接着我们进入重载方法查看：

@override
    public <e> list<e> query(mappedstatement ms, object parameter, rowbounds rowbounds, resulthandler resulthandler, cachekey key, boundsql boundsql) throws sqlexception {
        errorcontext.instance().resource(ms.getresource()).activity("executing a query").object(ms.getid());
        // 已经关闭，则抛出 executorexception 异常
        if (closed) {
            throw new executorexception("executor was closed.");
        }
        // 清空本地缓存，如果 querystack 为零，并且要求清空本地缓存。
        if (querystack == 0 && ms.isflushcacherequired()) {
            clearlocalcache();
        }
        list<e> list;
        try {
            // querystack + 1
            querystack++;
            // 从一级缓存中，获取查询结果
            list = resulthandler == null ? (list<e>) localcache.getobject(key) : null;
            // 获取到，则进行处理
            if (list != null) {
                handlelocallycachedoutputparameters(ms, key, parameter, boundsql);
            // 获得不到，则从数据库中查询
            } else {
                list = queryfromdatabase(ms, parameter, rowbounds, resulthandler, key, boundsql);
            }
        } finally {
            // querystack - 1
            querystack--;
        }
        if (querystack == 0) {
            // 执行延迟加载
            for (deferredload deferredload : deferredloads) {
                deferredload.load();
            }
            // issue #601
            // 清空 deferredloads
            deferredloads.clear();
            // 如果缓存级别是 localcachescope.statement ，则进行清理
            if (configuration.getlocalcachescope() == localcachescope.statement) {
                // issue #482
                clearlocalcache();
            }
        }
        return list;
    }

主要的逻辑：

• 从一级缓存取数据，如果有直接使用缓存的进行接下来的操作
• 如果没有，从数据库查询

进入queryfromdatabase()方法：

// 从数据库中读取操作
private <e> list<e> queryfromdatabase(mappedstatement ms, object parameter, rowbounds rowbounds, resulthandler resulthandler, cachekey key, boundsql boundsql) throws sqlexception {
    list<e> list;
    // 在缓存中，添加占位对象。此处的占位符，和延迟加载有关，可见 `deferredload#canload()` 方法
    localcache.putobject(key, execution_placeholder);
    try {
        // 执行读操作
        list = doquery(ms, parameter, rowbounds, resulthandler, boundsql);
    } finally {
        // 从缓存中，移除占位对象
        localcache.removeobject(key);
    }
    // 添加到缓存中
    localcache.putobject(key, list);
    // 暂时忽略，存储过程相关
    if (ms.getstatementtype() == statementtype.callable) {
        localoutputparametercache.putobject(key, parameter);
    }
    return list;
}

@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();
        // 传入参数创建statementhanlder对象来执行查询
        statementhandler handler = configuration.newstatementhandler(wrapper, ms, parameter, rowbounds, resulthandler, boundsql);
        // 创建jdbc中的statement对象
        stmt = preparestatement(handler, ms.getstatementlog());
        // 执行 statementhandler  ，进行读操作
        return handler.query(stmt, resulthandler);
    } finally {
        // 关闭 statementhandler 对象
        closestatement(stmt);
    }
}

通过代码可以看到，对于实际与jdbc交互的代码，executor也懒得搞，又像sqlsession一样，委派给小弟statementhandler了。

mybatis之statementhandler

我们从刚刚的executor的代码查看

@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();
        // 传入参数创建statementhanlder对象来执行查询
        statementhandler handler = configuration.newstatementhandler(wrapper, ms, parameter, rowbounds, resulthandler, boundsql);
        // 创建jdbc中的statement对象
        stmt = preparestatement(handler, ms.getstatementlog());
        // 执行 statementhandler  ，进行读操作
        return handler.query(stmt, resulthandler);
    } finally {
        // 关闭 statementhandler 对象
        closestatement(stmt);
    }
}

可以看到，这里创建完statementhandler后，回调用preparestatement()方法，用来创建statement对象

我们进入preparestatement方法中查看

// 初始化 statementhandler 对象
private statement preparestatement(statementhandler handler, log statementlog) throws sqlexception {
    statement stmt;
    // 获得 connection 对象
    connection connection = getconnection(statementlog);
    // 创建 statement 或 preparestatement 对象
    stmt = handler.prepare(connection, transaction.gettimeout());
    // 设置 sql 上的参数，例如 preparestatement 对象上的占位符
    handler.parameterize(stmt);
    return stmt;
}

@override
public void parameterize(statement statement) throws sqlexception {
    //使用parameterhandler对象来完成对statement的设值
    parameterhandler.setparameters((preparedstatement) statement);
}

这里可以看到，它实际是使用parameterhandler来设置statement的参数

@override
public void setparameters(preparedstatement ps) {
    errorcontext.instance().activity("setting parameters").object(mappedstatement.getparametermap().getid());
    // 遍历 parametermapping 数组
    list<parametermapping> parametermappings = boundsql.getparametermappings();
    if (parametermappings != null) {
        for (int i = 0; i < parametermappings.size(); i++) {
            // 获得 parametermapping 对象
            parametermapping parametermapping = parametermappings.get(i);
            if (parametermapping.getmode() != parametermode.out) {
                // 获得值
                object value;
                string propertyname = parametermapping.getproperty();
                if (boundsql.hasadditionalparameter(propertyname)) { // issue #448 ask first for additional params
                    value = boundsql.getadditionalparameter(propertyname);
                } else if (parameterobject == null) {
                    value = null;
                } else if (typehandlerregistry.hastypehandler(parameterobject.getclass())) {
                    value = parameterobject;
                } else {
                    metaobject metaobject = configuration.newmetaobject(parameterobject);
                    value = metaobject.getvalue(propertyname);
                }
                // 获得 typehandler、jdbctype 属性
                typehandler typehandler = parametermapping.gettypehandler();
                jdbctype jdbctype = parametermapping.getjdbctype();
                if (value == null && jdbctype == null) {
                    jdbctype = configuration.getjdbctypefornull();
                }
                // 设置 ? 占位符的参数
                try {
                    typehandler.setparameter(ps, i + 1, value, jdbctype);
                } catch (typeexception | sqlexception e) {
                    throw new typeexception("could not set parameters for mapping: " + parametermapping + ". cause: " + e, e);
                }
            }
        }
    }
}

这段代码的主要目的，就是获取入参，然后根据值，来设置？占位符的参数

typehandler是具体进行参数设置的对象

所以handler.prepare(connection, transaction.gettimeout());方法，就是使用parameterhandler来对占位符位置的参数进行值设置

然后我们回到executor，查看handler.query()方法

@override
public <e> list<e> query(statement statement, resulthandler resulthandler) throws sqlexception {
    preparedstatement ps = (preparedstatement) statement;
    // 执行查询
    ps.execute();
    // 处理返回结果
    return resultsethandler.handleresultsets(ps);
}

代码很简单，这里直接使用jdbc的preparedstatement来进行sql执行，然后使用resultsethandler进行结果数据封装处理。

进入resultsethandler

@override
public list<object> handleresultsets(statement stmt) throws sqlexception {
    errorcontext.instance().activity("handling results").object(mappedstatement.getid());

    // 多 resultset 的结果集合，每个 resultset 对应一个 object 对象。而实际上，每个 object 是 list<object> 对象。
    // 在不考虑存储过程的多 resultset 的情况，普通的查询，实际就一个 resultset ，也就是说，multipleresults 最多就一个元素。
    final list<object> multipleresults = new arraylist<>();

    int resultsetcount = 0;
    // 获得首个 resultset 对象，并封装成 resultsetwrapper 对象
    resultsetwrapper rsw = getfirstresultset(stmt);

    // 获得 resultmap 数组
    // 在不考虑存储过程的多 resultset 的情况，普通的查询，实际就一个 resultset ，也就是说，resultmaps 就一个元素。
    list<resultmap> resultmaps = mappedstatement.getresultmaps();
    int resultmapcount = resultmaps.size();
    validateresultmapscount(rsw, resultmapcount); // 校验
    while (rsw != null && resultmapcount > resultsetcount) {
        // 获得 resultmap 对象
        resultmap resultmap = resultmaps.get(resultsetcount);
        // 处理 resultset ，将结果添加到 multipleresults 中
        handleresultset(rsw, resultmap, multipleresults, null);
        // 获得下一个 resultset 对象，并封装成 resultsetwrapper 对象
        rsw = getnextresultset(stmt);
        // 清理
        cleanupafterhandlingresultset();
        // resultsetcount ++
        resultsetcount++;
    }

    // 因为 `mappedstatement.resultsets` 只在存储过程中使用，本系列暂时不考虑，忽略即可
    // ···

    // 如果是 multipleresults 单元素，则取首元素返回
    return collapsesingleresultlist(multipleresults);
}

 // 处理 resultset ，将结果添加到 multipleresults 中
private void handleresultset(resultsetwrapper rsw, resultmap resultmap, list<object> multipleresults, resultmapping parentmapping) throws sqlexception {
    try {
        // 暂时忽略，因为只有存储过程的情况，调用该方法，parentmapping 为非空
        if (parentmapping != null) {
            handlerowvalues(rsw, resultmap, null, rowbounds.default, parentmapping);
        } else {
            // 如果没有自定义的 resulthandler ，则创建默认的 defaultresulthandler 对象
            if (resulthandler == null) {
                // 创建 defaultresulthandler 对象
                defaultresulthandler defaultresulthandler = new defaultresulthandler(objectfactory);
                // 处理 resultset 返回的每一行 row
                handlerowvalues(rsw, resultmap, defaultresulthandler, rowbounds, null);
                // 添加 defaultresulthandler 的处理的结果，到 multipleresults 中
                multipleresults.add(defaultresulthandler.getresultlist());
            } else {
                // 处理 resultset 返回的每一行 row
                handlerowvalues(rsw, resultmap, resulthandler, rowbounds, null);
            }
        }
    } finally {
        // issue #228 (close resultsets)
        // 关闭 resultset 对象
        closeresultset(rsw.getresultset());
    }
}

代码比较多，实际最重要的代码就是

// 添加 defaultresulthandler 的处理的结果，到 multipleresults 中
multipleresults.add(defaultresulthandler.getresultlist());

将处理后的结果封装到集合中返回,这样基本mybatis逻辑就走完了.

我们来回顾一下，都用到了哪些类

简单总结
sqlsessionfactorybuilder：

• 解析核心配置文件，创建configuration
  • xmlconfigbuilder.parse()：解析核心配置文件
  • xmlmapperbuilder.parse()：解析映射配置文件mappedstatement
• 创建sqlsessionfactory，默认创建defaultsqlsessionfactory
  

sqlsessionfactory：

• opensession()：构建executor，sqlsession等

sqlsession：

• 根据statementid获取mappedstatement
• 委派给executor执行器执行

executor：

• 使用sqlsourcebuilder，将sql解析成jdbc认可的
• 查询缓存，是否存在结果
• 结果不存在，委派给statementhandler处理器

statementhandler：

• preparedstatement：处理参数，将参数赋值到占位符上
  • typehandler：具体设置值的类
• resultsethandler：封装结果集，封装成设置的返回值类型
  • typehandler：根据结果集，取出对应列
    

到此这篇关于浅谈mybatis sqlsession执行流程的文章就介绍到这了,更多相关mybatis sqlsession执行流程内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！