Mybatis运行流程源码解析

it2025-04-29 17

一、debug源码环境准备

1、下载mybatis源码

调试mybatis源码理解mybatis工作原理，首先需要下载mybatis源码！

下载地址：https://github.com/mybatis/mybatis-3

带中文注释的源码： https://github.com/tuguangquan/mybatis

2、下载mybatis-parent源码并编译

**注意：**下载的mybatis-parent版本要和mybatis源文件pom.xml 版本一致。

下载地址：https://github.com/mybatis/parent

切换到下载的mybatis-parent目录，执行：

mvn clean install

切换到下载的mybatis源码目录，执行：

mvn clean mvn install -Dmaven.test.skip=true

上面的步骤进行完毕后，就可以使用idea导入mybatis源码了！

3、调整配置(选做)

在pom.xml的节点下增加如下配置，读取classpath下的配置文件！

<resource> <directory>src/main/java</directory> <includes>  <include>**/*.properties</include> </includes> </resource> <resource>  <directory>src/main/resources</directory> </resource>

注释掉pom.xml中的pdf插件()

如果执行过程中有报错，可以根据报错信息注释掉相应的依赖即可！

4、编写测试代码

public static void main(String[] args) throws IOException { // 通过字节流读取配置文件 InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml"); // 创建SqlSessionFacory SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream); // 获取sqlSession SqlSession sqlSession = factory.openSession(); // 获取动态代理产生的mapper接口对象 MyBlogMapper mapper = sqlSession.getMapper(MyBlogMapper.class); // 调用接口方法 Blog blog = mapper.selectBlog(1); System.out.println("blog:"+blog); }

二、整体流程说明

mybatis运行流程大致分为以下两步：

第一，构建，也就是解析我们写的xml配置，将其变成它所需要的对象（configuration）。

①、解析mybatis-config.xml信息

②、解析xxxMapper.xml信息

③、解析xxxMapper.xml配置文件中的每个标签信息（比如）

第二，就是执行，在构建完成的基础上，去执行我们的SQL，完成与Jdbc的交互。

①、先获取mapper接口的代理对象

②、通过代理对象调用方法，执行操作。

所以下面就按照这样的步骤来分析！见下面的【三】和【四】

三、解析xml配置文件

解析xml配置文件也分为两步：

** 第一：**解析全局配置文件mybatis-config.xml

** 第二：**解析与我们的mapper接口对应的xxxxMapper.xml文件，解析完毕后会将每一个xxxMapper.xml中的解析结果保存到Configuration对象的mappedStatements（Map结构）中，并且将每一个xxxMapper.xml信息都保存到 knownMappers（Map结构）中。

最后将解析的配置文件信息整合到configuration类中！所有解析xml配置文件的最终结果就是得到一个configuration对象。

public class Configuration { // 封装了所有的xxXMapper.xml配置文件中解析出的sql信息 protected final Map<String, MappedStatement> mappedStatements; }

Ⅰ、前期准备

为了更好的理解这个解析流程，这里先贴出探究源码的过程中会用到的内容（测试代码、配置文件、解析流程图等）。

1）、测试代码

2）、mybatis-config.xml和mapper.mxl配置文件

①、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> <properties resource="jdbc.properties"> <property name="password" value="root"></property> </properties>  <settings>  <setting name="cacheEnabled" value="true"/> </settings> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"/> <dataSource type="POOLED"> <property name="driver" value="${driver}"/> <property name="url" value="${url}"/> <property name="username" value="${username}"/> <property name="password" value="${password}"/> </dataSource> </environment> </environments> <mappers> <mapper resource="mapper/MyBlogMapper.xml"/>  </mappers> </configuration>

②、MyBlogMapper.xml

<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="org.apache.ibatis.demo.mapper.MyBlogMapper">  <select id="selectBlog" resultType="org.apache.ibatis.demo.entity.Blog"> select * from Blog where id = ${id} </select> <insert id="insertBlog" parameterType="org.apache.ibatis.demo.entity.Blog"> insert into Blog (id,username,context) values (#{id}, #{username}, #{context}) </insert> </mapper>

3）、解析配置文件流程图

这里为了下面看代码容易理解，先贴上解析配置文件的流程图！当把整个流程过完以后再回头来看这个流程图就非常清晰了！

Ⅱ、解析过程探究

1）、解析mybatis-config.xml文件

由SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);代码debug进去

①、build（）

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) { try { //解析mybatis-config.xml // 委托XMLConfigBuilder来解析xml文件，并构建 XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties); // 进入 return build(parser.parse()); } catch (Exception e) { throw ExceptionFactory.wrapException("Error building SqlSession.", e); } finally { ErrorContext.instance().reset(); try { inputStream.close(); } catch (IOException e) { // Intentionally ignore. Prefer previous error. } } }

②、build(parser.parse())

// 解析配置文件信息 public Configuration parse() { if (parsed) { throw new BuilderException("Each XMLConfigBuilder can only be used once."); } parsed = true; // 解析mybatis-config.xml配置文件顶层节点 <configuration> parseConfiguration(parser.evalNode("/configuration")); return configuration; }

③、解析mybatis-config.xml配置文件核心代码

/** * 解析配置mybatis-config.xml的顶层节点（即：<configuration>）， * 这里会解析出<configuration>标签下的所有一级子标签 * @param root 顶层节点 */ private void parseConfiguration(XNode root) { try { //分步骤解析 //1.properties propertiesElement(root.evalNode("properties")); Properties settings = settingsAsProperties(root.evalNode("settings")); loadCustomVfs(settings); loadCustomLogImpl(settings); //2.类型别名 typeAliasesElement(root.evalNode("typeAliases")); //3.插件 pluginElement(root.evalNode("plugins")); //4.对象工厂 objectFactoryElement(root.evalNode("objectFactory")); //5.对象包装工厂 objectWrapperFactoryElement(root.evalNode("objectWrapperFactory")); reflectorFactoryElement(root.evalNode("reflectorFactory")); //6.设置 settingsElement(settings); // 环境信息 environmentsElement(root.evalNode("environments")); //8.databaseIdProvider databaseIdProviderElement(root.evalNode("databaseIdProvider")); //9.类型处理器 typeHandlerElement(root.evalNode("typeHandlers")); //10.映射器，从mybatis-config.xml配置文件中的<configration>标签中解析<mappers>标签 // 这里就是解析Mapper.xml文件的地方，下面分析 mapperElement(root.evalNode("mappers")); } catch (Exception e) { throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e); } }

到这里，解析mybatis-config.xml配置文件的流程就完毕了，解析完毕后会将mybatis-config.xml配置文件信息封装为一个Configuration对象返回！

2）、解析xxxMapper.xml文件

说明：

这里解析xxxMapper.xml文件，解析完毕后，会将 xxxMapper.xml自身的信息添加到一个名为 knownMappers的map集合中。

mybatis-config.xml文件中我们一定会写一个叫做的标签，这个标签中的<mapper>节点存放了我们对数据库进行操作的SQL语句。首先在看源码之前，我们先回忆一下我们在mapper标签内通常会怎样进行配置，通常有如下几种配置方式

<mappers>  <mapper resource="mapper/DemoMapper.xml" ></mapper>  <mapper class="com.mybatistest.TestMapper"/>  <mapper url=""/>  <package name="com.mybatistest"/> </mappers>

①、解析xxxMapper.xml

/** * 扫描配置mybatis-config.xml文件中的<mappers>节点，根据不同的配置方式，将该节点下指定的所有 * mapper接口添加到一个Map集合中 * @param parent * @throws Exception */ private void mapperElement(XNode parent) throws Exception { if (parent != null) { for (XNode child : parent.getChildren()) { //10.0自动扫描包下所有映射器 if ("package".equals(child.getName())) { String mapperPackage = child.getStringAttribute("name"); //将包下所有类加入到mapper(一个Map集合，Map<Class<?>, MapperProxyFactory<?>>) // 这里其实就是循环的调用addMapper（）方法 configuration.addMappers(mapperPackage); } else { String resource = child.getStringAttribute("resource"); String url = child.getStringAttribute("url"); String mapperClass = child.getStringAttribute("class"); if (resource != null && url == null && mapperClass == null) { //10.1使用类路径 ErrorContext.instance().resource(resource); InputStream inputStream = Resources.getResourceAsStream(resource); //映射器比较复杂，调用XMLMapperBuilder //注意在for循环里每个mapper都重新new一个XMLMapperBuilder，来解析 XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments()); // 【重要】解析mapper.xml配置文件中的标签，比如：<select/>、<update/>等 mapperParser.parse(); } else if (resource == null && url != null && mapperClass == null) { //10.2使用绝对url路径 ErrorContext.instance().resource(url); InputStream inputStream = Resources.getUrlAsStream(url); //映射器比较复杂，调用XMLMapperBuilder XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments()); // 【重要】解析mapper.xml配置文件中的标签，比如：<select/>、<update/>等 mapperParser.parse(); } else if (resource == null && url == null && mapperClass != null) { //10.3使用java类名 Class<?> mapperInterface = Resources.classForName(mapperClass); // 【重要】直接把这个映射加入配置类中(一个Map集合，Map<Class<?>, MapperProxyFactory<?>>)，源码在下面的【②】 configuration.addMapper(mapperInterface); } else { throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one."); } } } } }

②、将解析到的xxxMapper.xml信息添加到名为knownMappers的Map中

/** * 看一下如何添加一个映射 * @param type * @param <T> */ public class MapperRegistry { // 将已经添加的映射都放入HashMap，一个mapper接口就对应着一个key--value键值对 // key：接口的全限定名，value: mapper接口对应的MapperProxyFactory private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>(); public <T> void addMapper(Class<T> type) { //mapper必须是接口！才会添加 if (type.isInterface()) { if (hasMapper(type)) { //如果重复添加了，报错 throw new BindingException("Type " + type + " is already known to the MapperRegistry."); } boolean loadCompleted = false; try { // 【添加】:将解析到的每一个mapper.xml添加到map集合中， // key: mapper接口的全限定名， // value：根据mapper接口创建的MapperProxyFactory对象 knownMappers.put(type, new MapperProxyFactory<>(type)); MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type); parser.parse(); loadCompleted = true; } finally { if (!loadCompleted) { knownMappers.remove(type); } } } } }

上面两步的作用是：举个例子，假如我在mybatis-config.xml中有如下配置：

那么在上面两步就是，找到节点下的所有节点并解析他们，将解析后的mapper的全限定名作为key，new一个mappre相关的MapperProxyFactory作为value，然后put到knownMappers中。

==注意：==上面代码还有一句 mapperParser.parse();非常重要，我们将在下面做解析！

3）、解析xxxMapper.xml中的子标签

接上面的 mapperParser.parse();代码继续debug进去，这里就是解析每一个mapper.xml文件中的标签，比如：、等等。解析完成后，每一个被正确解析的子标签（、、、）都会被放入一个名为 mappedStatements的Map集合中！

1、mapperParser.parse();

public void parse() { //如果没有加载过再加载，防止重复加载 if (!configuration.isResourceLoaded(resource)) { //【重要】解析mapper文件节点（主要） configurationElement(parser.evalNode("/mapper")); //标记一下，已经加载过了 configuration.addLoadedResource(resource); //绑定映射器到namespace bindMapperForNamespace(); } // 重新解析之前解析不了的节点 parsePendingResultMaps(); parsePendingCacheRefs(); parsePendingStatements(); }

2、configurationElement（）

private void configurationElement(XNode context) { try { //1.配置namespace，检查namespace String namespace = context.getStringAttribute("namespace"); if (namespace.equals("")) { throw new BuilderException("Mapper's namespace cannot be empty"); } builderAssistant.setCurrentNamespace(namespace); //2.配置cache-ref cacheRefElement(context.evalNode("cache-ref")); //3.配置cache cacheElement(context.evalNode("cache")); //4.配置parameterMap(已经废弃,老式风格的参数映射) parameterMapElement(context.evalNodes("/mapper/parameterMap")); //5.配置resultMap(高级功能) resultMapElements(context.evalNodes("/mapper/resultMap")); //6.配置sql(定义可重用的 SQL 代码段) sqlElement(context.evalNodes("/mapper/sql")); //7.【重要】配置select|insert|update|delete TODO buildStatementFromContext(context.evalNodes("select|insert|update|delete")); } catch (Exception e) { throw new BuilderException("Error parsing Mapper XML. Cause: " + e, e); } }

3、buildStatementFromContext()

// 配置select|insert|update|delete private void buildStatementFromContext(List<XNode> list) { //调用构建语句 if (configuration.getDatabaseId() != null) { buildStatementFromContext(list, configuration.getDatabaseId()); } buildStatementFromContext(list, null); }

4、parseStatementNode()

// 解析Statement public void parseStatementNode() { String id = context.getStringAttribute("id"); String databaseId = context.getStringAttribute("databaseId"); //如果databaseId不匹配，退出 if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) { return; } //============================================================================ // 这里省略很多代码。。。 // 这里的代码主要作用就是：假如mapper.xml中有一个select语句如下： // <select id="selectBlog" resultType="org.apache.ibatis.demo.entity.Blog"> // select * from Blog where id = ${id} // </select> // 这里相当于是解析这条<select>标签中的各种属性，返回结果集，是select类型还是update类型还是 // delete类型呀、是否要缓存呀，参数类型，超时时间呀等等。 //============================================================================ //【重要】又去调助手类,添加到MappedStatement中 builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType, fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass, resultSetTypeEnum, flushCache, useCache, resultOrdered, keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets); }

5、addMappedStatement()

public MappedStatement addMappedStatement( String id, SqlSource sqlSource, StatementType statementType, SqlCommandType sqlCommandType, Integer fetchSize, Integer timeout, String parameterMap, Class<?> parameterType, String resultMap, Class<?> resultType, ResultSetType resultSetType, boolean flushCache, boolean useCache, boolean resultOrdered, KeyGenerator keyGenerator, String keyProperty, String keyColumn, String databaseId, LanguageDriver lang, String resultSets) { if (unresolvedCacheRef) { throw new IncompleteElementException("Cache-ref not yet resolved"); } //为id加上namespace前缀 id = applyCurrentNamespace(id, false); //是否是select语句 boolean isSelect = sqlCommandType == SqlCommandType.SELECT; //又是建造者模式 MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType); statementBuilder.resource(resource); statementBuilder.fetchSize(fetchSize); statementBuilder.statementType(statementType); statementBuilder.keyGenerator(keyGenerator); statementBuilder.keyProperty(keyProperty); statementBuilder.keyColumn(keyColumn); statementBuilder.databaseId(databaseId); statementBuilder.lang(lang); statementBuilder.resultOrdered(resultOrdered); statementBuilder.resulSets(resultSets); setStatementTimeout(timeout, statementBuilder); //1.参数映射 setStatementParameterMap(parameterMap, parameterType, statementBuilder); //2.结果映射 setStatementResultMap(resultMap, resultType, resultSetType, statementBuilder); setStatementCache(isSelect, flushCache, useCache, currentCache, statementBuilder); MappedStatement statement = statementBuilder.build(); //建造好调用configuration.addMappedStatement //比如mapper.xml中有一条select 语句，这里会将这条select语句解析后放入到MappedStatement中（MappedStatement是一个Map） configuration.addMappedStatement(statement); return statement; }

4）、总结

上面的解析XML配置文件的代码繁琐但不复杂，里面主要也就是对xml的节点进行解析。

总结一下大致流程就是：

①、首先是解析mybatis-config.xml配置文件信息。

②、然后是解析mybatis-config.xml配置文件中的节点下的每一个，然后将解析到的信息以接口的全限定名作为 key， mapper接口对应的MapperProxyFactory作为 value，放入到一个Map集合中（knownMappers）。

③、然后解析每一个mapper.xml里面的子节点（比如、、、），解析这些节点里面的每一个属性，做校验等，解析后的信息保存在MappedStatement中。

④、然后将这些节点按照接口的全限定名 + 方法名作为 key，**节点解析后的信息（MappedStatement）**作为 value 放入到configuration对象的mappedStatements（Map）属性中。

说明：这里理一下 Configuration 、 knownMappers 、 mappedStatements之间的关系，如下：

public class Configuration { // 环境信息 protected Environment environment; protected final MapperRegistry mapperRegistry = new MapperRegistry(this); // 存放mapper.xml解析后的一个个sql信息，key: 为mapper接口全限定名 + 方法名 protected final Map<String, MappedStatement> mappedStatements; } public class MapperRegistry { // 配置信息 private final Configuration config; // 存放一个个的mapper.xml信息，key：为mapper接口的全限定名 private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>(); // 构造方法 public MapperRegistry(Configuration config) { this.config = config; } }

到这里mybatis解析配置文件的流程就完了！

四、执行SQL

上面第一步解析了我们的mybatis-config.xml和mapper.xml配置文件并封装为configuration对象后，即可通过获取SqlSession来调用接口的方法进行查询了，代码如下！

// 创建SqlSessionFacory，这步会解析xml配置文件 SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream); // 获取sqlSession SqlSession sqlSession = factory.openSession(); // 获取mapper的动态代理对象 MyBlogMapper mapper = sqlSession.getMapper(MyBlogMapper.class); // 执行查询方法 Blog blog = mapper.selectBlog(1);

Ⅰ、动态代理创建mapper接口的代理对象

跟着 MyBlogMapper mapper = sqlSession.getMapper(MyBlogMapper.class);一路debug下去，会发现如下代码：(动态代理，投鞭断流)

public <T> T getMapper(Class<T> type, SqlSession sqlSession) { // 通过传入的接口的Class对象，去knownMappers中获取Mapper接口相关信息（mapperProxyFactory） final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type); if (mapperProxyFactory == null) { throw new BindingException("Type " + type + " is not known to the MapperRegistry."); } try { // 通过mapperProxyFactory创建代理对象，并返回 return mapperProxyFactory.newInstance(sqlSession); } catch (Exception e) { throw new BindingException("Error getting mapper instance. Cause: " + e, e); } } public T newInstance(SqlSession sqlSession) { // 传入mapper接口信息,创建mapperProxy对象 final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache); // 调用下面的方法，返回代理对象 return newInstance(mapperProxy); } protected T newInstance(MapperProxy<T> mapperProxy) { // 用JDK自带的动态代理生成映射器 // 这里要注意：mapperProxy中组合了一个mapper接口，这里是为mapperProxy创建代理对象，代理对象里的方法实现，其实就是MapperProxy里的invoke方法，每次调用接口的方法都会调用到 MapperProxy 里的invoke方法 return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy); }

上面的代码便是创建mapper接口代理的代码过程，首先会通过传入的mapper的Class信息去 knownMappers中获取到一个 MapperProxyFactory，然后调用MapperProxyFactory的 newInstance方法，在newInstance方法中通过传入mapper接口信息，sqlSession信息，methodCache创建一个mapperProxy。最后使用JDK代理为mapperProxy创建代理对象（Proxy.newProxyInstance()）！

Ⅱ、调用mapper接口方法

1）、代理对象的方法调用

当调用mapper接口中的方法时，其实时调用的代理对象中的对应方法！以debug的方式进入方法调用处！会发现进入了MapperProxy的 invoke（）方法中！

// 代理以后，所有Mapper的方法调用时，都会调用这个invoke方法 // 并不是任何一个方法都需要执行调用代理对象进行执行，如果这个方法是Object中通用的方法（toString、hashCode等）无需执行 @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { try { // 如果是Object的方法（toString、hashCode等）则直接执行 if (Object.class.equals(method.getDeclaringClass())) { return method.invoke(this, args); } else { // 从这里进去 return cachedInvoker(method).invoke(proxy, method, args, sqlSession); } } catch (Throwable t) { throw ExceptionUtil.unwrapThrowable(t); } }

2）、代理对象核心方法

从上面进去以后会发现最终进入了 MapperMethod的 execute()方法，该方法就是mapper接口方法的实现。在这里判断操作类型（增删改查），获取到要执行的sql，获取sql参数，替换占位符，处理返回结果集等

public Object execute(SqlSession sqlSession, Object[] args) { Object result; //可以看到执行时就是4种情况，insert|update|delete|select，分别调用SqlSession的4大类方法 switch (command.getType()) { case INSERT: { Object param = method.convertArgsToSqlCommandParam(args); result = rowCountResult(sqlSession.insert(command.getName(), param)); break; } case UPDATE: { Object param = method.convertArgsToSqlCommandParam(args); result = rowCountResult(sqlSession.update(command.getName(), param)); break; } case DELETE: { Object param = method.convertArgsToSqlCommandParam(args); result = rowCountResult(sqlSession.delete(command.getName(), param)); break; } // 处理查询 case SELECT: //如果有结果处理器 if (method.returnsVoid() && method.hasResultHandler()) { executeWithResultHandler(sqlSession, args); result = null; //如果结果有多条记录 } else if (method.returnsMany()) { result = executeForMany(sqlSession, args); //如果结果是map } else if (method.returnsMap()) { result = executeForMap(sqlSession, args); } else if (method.returnsCursor()) { result = executeForCursor(sqlSession, args); } else { //否则就是一条记录 Object param = method.convertArgsToSqlCommandParam(args); // 我们的示例中只有一条记录，所以从这里跟进去 result = sqlSession.selectOne(command.getName(), param); if (method.returnsOptional() && (result == null || !method.getReturnType().equals(result.getClass()))) { result = Optional.ofNullable(result); } } break; case FLUSH: result = sqlSession.flushStatements(); break; default: throw new BindingException("Unknown execution method for: " + command.getName()); } if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) { throw new BindingException("Mapper method '" + command.getName() + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ")."); } return result; }

3）、调用SqlSession的查询方法

这里会根据上面的返回结果集条件判断（是否有多条返回值、返回结果集是否是Map等）选择不同的查询方法，但核心的就只有两个方法：一个是selectOne（），一个是selectList（）！在selectOne()里面其实也是调用了selectList（）方法在做查询。

3.1、sqlSession.selectOne（）

//核心selectOne @Override public <T> T selectOne(String statement, Object parameter) { // Popular vote was to return null on 0 results and throw exception on too many. //转而去调用selectList,很简单的，如果得到0条则返回null，得到1条则返回1条，得到多条报TooManyResultsException错 // 特别需要注意的是当没有查询到结果的时候就会返回null。因此一般建议在mapper中编写resultType的时候使用包装类型 //而不是基本类型，比如推荐使用Integer而不是int。这样就可以避免NPE List<T> list = this.selectList(statement, parameter); if (list.size() == 1) { return list.get(0); } else if (list.size() > 1) { throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size()); } else { return null; } }

3.2、selectList()

// 核心selectList @Override public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) { try { // 根据statement id找到对应的 MappedStatement MappedStatement ms = configuration.getMappedStatement(statement); // 转而用执行器来查询结果,注意这里传入的ResultHandler是null 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(); } }

3.3 Executor简单说明

Executor是一个接口，该接口的实现以及继承关系图如下：

可以看出 BaseExecutor以及 CachingExecutor直接继承了Executor，BaseExecutor类下有三个子类。这里对这几个执行器做一个简单的说明！

**Executor接口：**该接口主要提供了update、query方法及事物相关的方法接口！

CachingExecutor： CachingExecutor 从内存中获取数据，在查找数据库前先查找缓存，若没有找到的话调用delegate从数据库查询，并将查询结果存入缓存中。该执行器主要是针对于mybatis的二级缓存（需要在配置中开启二级缓存才可用）

BaseExecutor：抽象类BaseExecutor采用模板方法设计模式，具体的实现在其子类：BatchExecutor、ReuseExecutor和SimpleExecutor

**SimpleExecutor：**简单执行器，每次执行SQL需要预编译SQL语句。

BatchExecutor：批处理执行器，只针对修改操作的SQL语句预编译一次，并且需要手动刷新SQL执行才生效

**ReuseExecutor：**可重用执行器，同一SQL语句执行只需要预编译一次SQL语句。

3.4、executor二级缓存查询逻辑

在上面3.2源码中执行了 executor.query(）方法，调用执行器的查询方法，我这里开启了二级缓存，所以会走到缓存执行器的query（）方法。

// CachingExecutor里的query @Override public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException { // 获取sql信息 BoundSql boundSql = ms.getBoundSql(parameterObject); CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql); // 调用本类的另一个query方法，如下 return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); } // CachingExecutor里的query public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { Cache cache = ms.getCache(); //默认情况下是没有开启缓存的(二级缓存).要开启二级缓存 //简单的说，就是先查CacheKey，查不到再委托给实际的执行器去查 if (cache != null) { // 如果需要则刷新缓存 flushCacheIfRequired(ms); if (ms.isUseCache() && resultHandler == null) { ensureNoOutParams(ms, boundSql); @SuppressWarnings("unchecked") // 先通过事务缓存管理器，在二级缓存中取数据 List<E> list = (List<E>) tcm.getObject(cache, key); // 如果从二级缓存中没有取到数据，则调用委托的执行器对象去执行查询，这里的被委托对象可以是： // simpleExecutor、ReuseExecutor、BatchExecutor。默认是simpleExecutor执行器 // 这里使用的是装饰设计模式 if (list == null) { // 被委托的对象执行查询方法(这里被委托的对象是BaseExecutor执行器) list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); tcm.putObject(cache, key, list); // issue #578 and #116 } return list; } } return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); }

如果二级缓存没有值，则调用委托对象(BaseExecutor）的查询方法，查询一级缓存。

3.5、executor一级缓存查询逻辑

在上面的二级缓存没有查询到结果以后，会委托baseExecutor执行器去一级缓存查询。

// baseExecutor的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()); //如果已经关闭，报错 if (closed) { throw new ExecutorException("Executor was closed."); } //先清局部缓存，再查询.但仅查询堆栈为0，才清。为了处理递归调用 if (queryStack == 0 && ms.isFlushCacheRequired()) { // 清除局部缓存 clearLocalCache(); } List<E> list; try { //加一,这样递归调用到上面的时候就不会再清局部缓存了 queryStack++; // 【查询一级缓存】先根据cachekey从一级缓存localCache去查，一级缓存实质就是从一个Map中拿 list = resultHandler == null ? (List<E>) localCache.getObject(key) : null; if (list != null) { //若查到localCache缓存，处理localOutputParameterCache handleLocallyCachedOutputParameters(ms, key, parameter, boundSql); } else { // 【从数据库查询】如果一级缓存查询不到数据，则从数据库查 list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql); } } finally { //清空堆栈 queryStack--; } if (queryStack == 0) { //延迟加载队列中所有元素 for (DeferredLoad deferredLoad : deferredLoads) { deferredLoad.load(); } // issue #601 //清空延迟加载队列 deferredLoads.clear(); if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) { // issue #482 //如果是STATEMENT，清本地缓存 clearLocalCache(); } } return list; }

从一级缓存中get

public class PerpetualCache implements Cache { private final Map<Object, Object> cache = new HashMap<>(); @Override public Object getObject(Object key) { return cache.get(key); } }

3.6、一级缓存查询不到，从数据库查询

上面的从一级缓存中如果没有查询到结果，则直接调用BaseExecutor的子类执行器去数据库查询！

// BaseExecutor里的 queryFromDatabase private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { List<E> list; //先向缓存中放入占位符 localCache.putObject(key, EXECUTION_PLACEHOLDER); try { // 执行doQuery()方法从数据库查询【这里执行的是BaseExecutor子类的doQuery()，默认是SimpleExecutor】 list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql); } finally { //最后删除占位符 localCache.removeObject(key); } //加入缓存 localCache.putObject(key, list); //如果是存储过程，OUT参数也加入缓存 if (ms.getStatementType() == StatementType.CALLABLE) { localOutputParameterCache.putObject(key, parameter); } return list; }

3.7、SimpleExecutor.doQuery查询数据库

// SimpleExecutor里的doQuery（） @Override public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException { Statement stmt = null; try { // 这里就是基础的构建prepareStatement，执行查询操作了 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); } }

执行查询（或其他操作）完毕后，然后再按照一定的条件或逻辑放入缓存或情况缓存！

Ⅲ、总结

上面分析的执行SQL的逻辑用简单的话描述：

①、首先通过 sqlSession.getMapper(MyBlogMapper.class)创建对应mapper接口的代理对象

②、调用mapper代理对象的方法执行查询（或其他操作）【其中最核心的就是调用sqlSession的API】

③、在执行mapper代理对象的方法中，执行查询的时候会首先查找二级缓存（如果开启了二级缓存），如果命中则返回缓存结果。

④、如果二级缓存没有命中，则调用委托执行器（BaseExecutor）的方法去查询一级缓存，如果命中则返回缓存结果

⑤、如果一级缓存没有命中，则调用BaseExecutor执行器的子类执行器（默认是 SimpleExecutor）的方法从数据库查询！

⑥、将查询到的结果按照一定的规则和条件该写缓存的写缓存，然后返回！

其他：

1、一级缓存作用域

MyBatis中的一级缓存，是默认开启且无法关闭的，一级缓存默认的作用域是一个SqlSession，解释一下，就是当SqlSession被构建了之后，缓存就存在了，只要这个SqlSession不关闭，这个缓存就会一直存在，换言之，只要SqlSession不关闭，那么这个SqlSession处理的同一条SQL就不会被调用两次，只有当会话结束了之后，这个缓存才会一并被释放。

2、 MyBatis 四大核心对象

ParameterHandler：处理SQL的参数对象

ResultSetHandler：处理SQL的返回结果集

StatementHandler：数据库的处理对象，用于执行SQL语句

Executor：MyBatis的执行器，用于执行增删改查操作

常见问题：

1、缓存失效条件?

2、为什么mybatis和spring进行整合的时候一级缓存会失效？

3、一级缓存的作用域？生命周期？

4、sqlSession生命周期？

最新回复(0)