Mybatis源码简单分析

初识JDBC

从下面看出一般来说，连接数据库一般分四步：

加载驱动 -> 获取连接 -> 创建sql -> 执行sql -> 处理结果

public static void main(String[] args) {
    try {
        // 1. 加载数据库驱动
        Class.forName("com.mysql.jdbc.Driver");
        // 2. 获得连接
        Connection connection = DriverManager.getConnection(url, username, password);
        // 3. 创建sql语句
        String sql = "select * from t_test_user";
        Statement statement = connection.createStatement();
        // 4. 执行sql
        ResultSet result = statement.executeQuery(sql);
        // 5. 处理结果
        while(result.next()){
            System.out.println("result = " + result.getString(1));
        }
        // 6. 关闭连接
        result.close();
        connection.close();
    } catch (Exception e){
        System.out.println(e);
    }
}

Mybatis源码分析

那么我们根据上面的执行顺序来看mybatis的代码。

配置文件

对于一个框架来说，加载配置去初始化一些参数，肯定是第一步（做好准备工作）
在看代码之前，我看现在来看一下mybatis的配置文件。官方配置文档地址：https://mybatis.org/mybatis-3/zh_CN/configuration.html

<?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>
      <!--一些重要的全局配置-->
      <settings>
          <setting name="cacheEnabled" value="true"/>
          <!--<setting name="lazyLoadingEnabled" value="true"/>-->
          <!--<setting name="multipleResultSetsEnabled" value="true"/>-->
          <!--<setting name="useColumnLabel" value="true"/>-->
          <!--<setting name="useGeneratedKeys" value="false"/>-->
          <!--<setting name="autoMappingBehavior" value="PARTIAL"/>-->
          <!--<setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>-->
          <!--<setting name="defaultExecutorType" value="SIMPLE"/>-->
          <!--<setting name="defaultStatementTimeout" value="25"/>-->
          <!--<setting name="defaultFetchSize" value="100"/>-->
          <!--<setting name="safeRowBoundsEnabled" value="false"/>-->
          <!--<setting name="mapUnderscoreToCamelCase" value="false"/>-->
          <!--<setting name="localCacheScope" value="STATEMENT"/>-->
          <!--<setting name="jdbcTypeForNull" value="OTHER"/>-->
          <!--<setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>-->
          <!--<setting name="logImpl" value="STDOUT_LOGGING" />-->
      </settings>
  
      <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/test?useUnicode=true"/>
                  <property name="username" value="test"/>
                  <property name="password" value="test"/>
              </dataSource>
          </environment>
      </environments>
  
      <mappers>
          <!--这边可以使用package和resource两种方式加载mapper-->
          <!--<package name="包名"/>-->
          <package name="com.example.demo.dao"/> -->
          <mapper resource="./mapper/TTestUserMapper.xml"/>
      </mappers>
  </configuration>

接下来我看我们写的demo

public void mybatisTest() throws IOException {
    //1.读取配置
    InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
    //2.创建SqlSessionFactory工厂
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
    //3.获取sqlSession
    SqlSession sqlSession = sqlSessionFactory.openSession();
    //4.获取Mapper的代理
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    //5.执行接口方法
    UserPo userPo = userMapper.selectById(1L);
    System.out.println(userPo);
    //6.提交事务
    sqlSession.commit();
    //7.关闭资源
    sqlSession.close();
    in.close();
  }

读取配置

//读取配置文件
InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
//构建SqlSessionFactory,他的作用就是为了提供SqlSession的创建
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);

//下面就是SqlSession接口中的方法，从下面我们可以看出SqlSession是提供查询，修改，提交事务，回滚事务等我们可能用到的方法
public interface SqlSession extends Closeable {

  /**
  * 查询一个结果对象
  **/ 
  <T> T selectOne(String statement, Object parameter);
  
   /**
  * 查询一个结果集合
  **/ 
  <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds);
  
   /**
  * 查询一个map
  **/ 
  <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds);

   /**
  * 查询游标
  **/ 
  <T> Cursor<T> selectCursor(String statement, Object parameter, RowBounds rowBounds);

  void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler);
  
     /**
  * 插入
  **/ 
  int insert(String statement, Object parameter);

    /**
  * 修改
  **/ 
  int update(String statement, Object parameter);

  /**
  * 删除
  **/
  int delete(String statement, Object parameter);

   /**
  * 提交事物
  **/
  void commit(boolean force);
  
   /**
  * 回滚事物
  **/
  void rollback(boolean force);

  List<BatchResult> flushStatements();

  void close();

  void clearCache();

  Configuration getConfiguration();

   /**
  * 获取映射代理类
  **/
  <T> T getMapper(Class<T> type);

   /**
  * 获取数据库连接
  **/
  Connection getConnection();
}

接下来我们看一下new SqlSessionFactoryBuilder().build(in); 做了哪些事情。代码我们简化一些只看关键部分。

//build(in)
public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    //解析mybatis-config.xml配置文件并返回
    XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
    return build(parser.parse());
}
//由下面代码可以看出，SqlSessionFactory接口的默认实现是DefaultSqlSessionFactory
public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
}
//parser.parse()，使用XMLConfigBuilder去解析我们上面的xml配置文件
//public class XMLConfigBuilder extends BaseBuilder{} 继承了BaseBuilder的三个属性，
//protected final Configuration configuration;  //配置汇总，后面所有读取的配置参数都会和Configuration有密切关系
//protected final TypeAliasRegistry typeAliasRegistry;//类型别名
//protected final TypeHandlerRegistry typeHandlerRegistry; //类型处理器注册
public Configuration parse() {
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
}
//下面这些节点配置作用可以看文档，上面有详细介绍 我们主要看主流程
private void parseConfiguration(XNode root) {
      //解析properties节点 - 
      propertiesElement(root.evalNode("properties"));
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      loadCustomVfs(settings);
      loadCustomLogImpl(settings);
      typeAliasesElement(root.evalNode("typeAliases"));
      pluginElement(root.evalNode("plugins"));
      objectFactoryElement(root.evalNode("objectFactory"));
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      reflectorFactoryElement(root.evalNode("reflectorFactory"));
      settingsElement(settings);
      // read it after objectFactory and objectWrapperFactory issue #631
      environmentsElement(root.evalNode("environments"));
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      typeHandlerElement(root.evalNode("typeHandlers"));
      mapperElement(root.evalNode("mappers"));
    //eg： <mappers>
    //       <!--这边可以使用package或resource两种方式加载mapper-->
    //       <!--<package name="包名"/>-->
    //       <!-- <package name="com.yuan.material.web.mybatist.mapper"/>-->
    //       <mapper resource="./mapper/mybatist/UserMapper.xml"/>
    //       <!--<mapper url="file:///var/mappers/AuthorMapper.xml"/>-->\
    //		<!--<mapper class="org.mybatis.builder.AuthorMapper"/>-->
    //     </mappers>
 }

解析mappers标签 mapperElement(root.evalNode("mappers"));

private void mapperElement(XNode parent) throws Exception {
    for (XNode child : parent.getChildren()) {
      if ("package".equals(child.getName())) {
        String mapperPackage = child.getStringAttribute("name");
        configuration.addMappers(mapperPackage);
      } else {
          //mapper标签有三个属性，分别对应三种类型
        String resource = child.getStringAttribute("resource");
        String url = child.getStringAttribute("url");
        String mapperClass = child.getStringAttribute("class");
          //只配置了resource属性
        if (resource != null && url == null && mapperClass == null) {
          ErrorContext.instance().resource(resource);
          try (InputStream inputStream = Resources.getResourceAsStream(resource)) {
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            mapperParser.parse();
          }
           只配置了url属性
        } else if (resource == null && url != null && mapperClass == null) {
          ErrorContext.instance().resource(url);
          try (InputStream inputStream = Resources.getUrlAsStream(url)) {
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
            mapperParser.parse();
          }
            //只配置了class属性
        } else if (resource == null && url == null && mapperClass != null) {
          Class<?> mapperInterface = Resources.classForName(mapperClass);
          //将MapperProxyFactory加载到HashMap缓存中
          configuration.addMapper(mapperInterface);
        }
      }
    }
  }
}

如果它使用的是resource或者url 可以看做是一类，都是指定了xml文件，无非是文件路径不同

//解析mapper文件传入configuration，去将解析后的数据直接set到configuration里面
XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, 				     configuration.getSqlFragments());
mapperParser.parse();

//org.apache.ibatis.builder.xml.XMLMapperBuilder#parse
public void parse() {
    //判断resource是否已经被加载过
if (!configuration.isResourceLoaded(resource)) {
    //解析mapper文件
  configurationElement(parser.evalNode("/mapper"));
  configuration.addLoadedResource(resource);
   //下面有这个方法的解释，目的是：
    //configuration.addLoadedResource("namespace:" + namespace);
    //下面会详细说
    //configuration.addMapper(boundType);（ 根据boundType去生成代理对象） boundType = Resources.classForName(namespace);
  bindMapperForNamespace();
}
//将configuration.getIncompleteResultMaps();拿出来然后存放到MapperBuilderAssistant.addResultMap
parsePendingResultMaps();
//将configuration.getIncompleteCacheRefs();拿出来然后存放到MapperBuilderAssistant.useCacheRef(cacheRefNamespace)
 //这个是如果在初始化的时候，缓存片段未创建完成，则会放在configuration.getIncompleteCacheRefs()后面再进行处理
parsePendingCacheRefs();
//将configuration.getIncompleteStatements();拿出来然后存放到MapperBuilderAssistant.parseStatementNode
 //在前面方法如果解析失败的时候并抛出IncompleteElementException异常，会放在IncompleteStatements，后续再处理一次
parsePendingStatements();
}

先看解析mapperconfigurationElement(parser.evalNode("/mapper"));

private void configurationElement(XNode context) {
    //<mapper namespace="org.apache.mytest.mapper.UserMapper">
    String namespace = context.getStringAttribute("namespace");
    //获取xml中的namespace属性，并设置到currentNamespace
    builderAssistant.setCurrentNamespace(namespace);
    cacheRefElement(context.evalNode("cache-ref"));
    cacheElement(context.evalNode("cache"));
    //parameterMap已经废弃，不用关注
    parameterMapElement(context.evalNodes("/mapper/parameterMap"));
    //<resultMap id="userResultMap" type="User">
    //  <id property="id" column="user_id" />
    //  <result property="username" column="user_name"/>
    //  <result property="password" column="hashed_password"/>
    //</resultMap>
	//将数据库返回的字段和实体对象中的属性进行映射
    resultMapElements(context.evalNodes("/mapper/resultMap"));
    //通用的sql片段解析
    sqlElement(context.evalNodes("/mapper/sql"));
    //解析增，删，改，查
    buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
}

解析resultMap标签

private void resultMapElements(List<XNode> list) {
  for (XNode resultMapNode : list) {
      resultMapElement(resultMapNode);
  }
}

private ResultMap resultMapElement(XNode resultMapNode) {
  return resultMapElement(resultMapNode, Collections.emptyList(), null);
}

private ResultMap resultMapElement(XNode resultMapNode, List<ResultMapping> additionalResultMappings, Class<?> enclosingType) {
  ErrorContext.instance().activity("processing " + resultMapNode.getValueBasedIdentifier());
  String type = resultMapNode.getStringAttribute("type",
      resultMapNode.getStringAttribute("ofType",
          resultMapNode.getStringAttribute("resultType",
              resultMapNode.getStringAttribute("javaType"))));
  Class<?> typeClass = resolveClass(type);
  if (typeClass == null) {
    typeClass = inheritEnclosingType(resultMapNode, enclosingType);
  }
  Discriminator discriminator = null;
  List<ResultMapping> resultMappings = new ArrayList<>(additionalResultMappings);
  List<XNode> resultChildren = resultMapNode.getChildren();
  for (XNode resultChild : resultChildren) {
 	//解析<result column="password" jdbcType="VARCHAR" property="password"/>
      List<ResultFlag> flags = new ArrayList<>();
      //buildResultMappingFromContext()解析column等属性，然后构建为ResultMapping对象
      resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags));
    }
  }
  String id = resultMapNode.getStringAttribute("id",
          resultMapNode.getValueBasedIdentifier());

  ResultMapResolver resultMapResolver = new ResultMapResolver(builderAssistant, id, typeClass, extend, discriminator, resultMappings, autoMapping);
    return resultMapResolver.resolve();

}
//将resultMap解析为一个对象，然后调用在MapperBuilderAssistant对象中的addResultMap，然后最终存放在
//Map<String, ResultMap> resultMaps = new StrictMap<>("Result Maps collection"); --> Configuration类
//key =  currentNamespace + "." + ResultMap标签的id属性作为key，value为解析的ResultMap对象;
public ResultMap resolve() {
    return assistant.addResultMap(this.id, this.type, this.extend, this.discriminator, this.resultMappings, this.autoMapping);
  }

解析sql标签

private void sqlElement(List<XNode> list) {
  if (configuration.getDatabaseId() != null) {
  //如果指定databaseid，则会在匹配，当前的数据库id是否匹配这个sql片段的数据库id
    sqlElement(list, configuration.getDatabaseId());
  }
  sqlElement(list, null);
}

private void sqlElement(List<XNode> list, String requiredDatabaseId) {
  for (XNode context : list) {
    String databaseId = context.getStringAttribute("databaseId");
    String id = context.getStringAttribute("id");
    id = builderAssistant.applyCurrentNamespace(id, false);
      //判断databaseId是否配置
    if (databaseIdMatchesCurrent(id, databaseId, requiredDatabaseId)) {
        //如果匹配或者为null，则存放在sqlFragments中
        //sqlFragments是org.apache.ibatis.builder.xml.XMLMapperBuilder的属性
        //为什么sqlFragments不存放在Configuration中我想是因为使用位置不同，sqlFragments是在sql拼接的是否使用，
        //resultMap是映射响应结果的时候使用
      sqlFragments.put(id, context);
    }
  }
}

解析增删改查标签buildStatementFromContext(context.evalNodes("select|insert|update|delete"));

private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
  for (XNode context : list) {
  //构建XMLStatementBuilder对象configuration，builderAssistant作为通用配置传入对象，贯彻配置解析始终
   XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
    statementParser.parseStatementNode();
  }
}


public void parseStatementNode() {
    String id = context.getStringAttribute("id");
    String databaseId = context.getStringAttribute("databaseId");
	//和刚才一样，判断当前databaseId是否和select属性的databaseId相同
    if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
      return;
    }
	
    String nodeName = context.getNode().getNodeName();
    //处理为sql执行美剧
    SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
    //是否为SELECT查询
    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
    boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
    boolean useCache = context.getBooleanAttribute("useCache", isSelect);
    boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);
	//<sql id="userColumns"> ${alias}.id,${alias}.username,${alias}.password </sql>
    // <include refid="userColumns"><property name="alias" value="t1"/></include>
    //去解析sql片段
    XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
    includeParser.applyIncludes(context.getNode());
	//获取参数类型，可以使用别名去获取参数类型
    String parameterType = context.getStringAttribute("parameterType");
    Class<?> parameterTypeClass = resolveClass(parameterType);
	//定义语言解析，此配置，分为两种，XMLLanguageDriver（默认值）和RawLanguageDriver，作用创建SqlSource和创建ParameterHandler
    String lang = context.getStringAttribute("lang");
    LanguageDriver langDriver = getLanguageDriver(lang);

    // 处理sql中包含的SelectKey节点,主要作用，如果一些数据库不支持主键生成，mybatis使用此功能去生成主键
    //<selectKey keyProperty="id" resultType="int" order="BEFORE">
    //    select CAST(RANDOM()*1000000 as INTEGER) a from SYSIBM.SYSDUMMY1
    //  </selectKey>
    processSelectKeyNodes(id, parameterTypeClass, langDriver);

    // 在配置中查询KeyGenerator
    KeyGenerator keyGenerator;
    String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
    keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
    if (configuration.hasKeyGenerator(keyStatementId)) {
      keyGenerator = configuration.getKeyGenerator(keyStatementId);
    } else {
      keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
          configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
          ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
    }
	//创建sqlSource,使用上面说的XMLLanguageDriver类
    SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
    //mybatis支持STATEMENT，PREPARED 或 CALLABLE。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement（调用存储过程），默认值：PREPARED。
    StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
    //这是一个给驱动的建议值，尝试让驱动程序每次批量返回的结果行数等于这个设置值。 默认值为未设置（unset）（依赖驱动）。
    Integer fetchSize = context.getIntAttribute("fetchSize");
    //这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数。默认值为未设置（unset）（依赖数据库驱动）。
    Integer timeout = context.getIntAttribute("timeout");
	//将会传入这条语句的参数的类全限定名或别名。这个属性是可选的，因为 MyBatis 可以根据语句中实际传入的参数计算出应该使用的类型处理器（TypeHandler）
    String parameterMap = context.getStringAttribute("parameterMap");
    //期望从这条语句中返回结果的类全限定名或别名。 注意，如果返回的是集合，那应该设置为集合包含的类型，而不是集合本身的类型。
    String resultType = context.getStringAttribute("resultType");
    //处理别名
    Class<?> resultTypeClass = resolveClass(resultType);
    //对外部 resultMap 的命名引用。
    String resultMap = context.getStringAttribute("resultMap");
    //FORWARD_ONLY，SCROLL_SENSITIVE, SCROLL_INSENSITIVE 或 DEFAULT（等价于 unset） 中的一个，默认值为 unset （依赖数据库驱动）。指在创建PreparedStatement时,resultSetType参数设置，这块是指游标默认是游标向下移动（TYPE_FORWARD_ONLY）
    String resultSetType = context.getStringAttribute("resultSetType");
    ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
    if (resultSetTypeEnum == null) {
      resultSetTypeEnum = configuration.getDefaultResultSetType();
    }
    //（仅适用于 insert 和 update）指定能够唯一识别对象的属性，MyBatis 会使用 getGeneratedKeys 的返回值或 insert 语句的 selectKey 子元素设置它的值
    String keyProperty = context.getStringAttribute("keyProperty");
    //（仅适用于 insert 和 update）设置生成键值在表中的列名，在某些数据库（像 PostgreSQL）中，当主键列不是表中的第一列的时候，是必须设置的。
    String keyColumn = context.getStringAttribute("keyColumn");
    //指定用于加载复杂类型的结果集名字。平时用的少
    String resultSets = context.getStringAttribute("resultSets");
	//builderAssistant中新增mappedStatement，将下面所有参数使用MappedStatement.Builder，构建成MappedStatement对象
    //configuration.addMappedStatement(statement);
    builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
        fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
        resultSetTypeEnum, flushCache, useCache, resultOrdered,
        keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
  }

看一下XMLLanguageDriver.createSqlSource()是怎么生成SqlSource文件的

public SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType) {
   //在创建的时候除了将configuration, script, parameterType进行赋值以外，还会初始化一些方法比如对trim,if,else等标签的处理
  XMLScriptBuilder builder = new XMLScriptBuilder(configuration, script, parameterType);
  return builder.parseScriptNode();
}

  public SqlSource parseScriptNode() {
    MixedSqlNode rootSqlNode = parseDynamicTags(context);
    SqlSource sqlSource;
    if (isDynamic) {
      sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
    } else {
      sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
    }
    return sqlSource;
  }


protected MixedSqlNode parseDynamicTags(XNode node) {
    List<SqlNode> contents = new ArrayList<>();
    NodeList children = node.getNode().getChildNodes();
    for (int i = 0; i < children.getLength(); i++) {
      XNode child = node.newXNode(children.item(i));
        //如果节点textNode
      if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE || child.getNode().getNodeType() == Node.TEXT_NODE) {
          //获取body片段 比如：SELECT t_user.* FROM t_user
        String data = child.getStringBody("");
          //创建TextSqlNode
        TextSqlNode textSqlNode = new TextSqlNode(data);
          //判断sql中是否包含 ${ } 这些
        if (textSqlNode.isDynamic()) {
          contents.add(textSqlNode);
          isDynamic = true;
        } else {
            //按照静态sql片段处理
          contents.add(new StaticTextSqlNode(data));
        }
          //如果存在标签
      } else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) { // issue #628
        String nodeName = child.getNode().getNodeName();
        NodeHandler handler = nodeHandlerMap.get(nodeName);
        if (handler == null) {
          throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
        }
         //按照不同标签处理器去处理，比如：WhereHandler
        handler.handleNode(child, contents);
        isDynamic = true;
      }
    }
    //处理结束后生成MixedSqlNode里面是List<SqlNode> contents
    return new MixedSqlNode(contents);
  }

configuration.addMapper(boundType)在XMLMapperBuilder#bindMapperForNamespace绑定命名空间时候addMapper(boundType) 根据boundType去生成代理对象

private void bindMapperForNamespace() {
  String namespace = builderAssistant.getCurrentNamespace();
  if (namespace != null) {
    Class<?> boundType = null;
      //获取的mapper接口
      boundType = Resources.classForName(namespace);
    if (boundType != null && !configuration.hasMapper(boundType)) {
      configuration.addLoadedResource("namespace:" + namespace);
      configuration.addMapper(boundType);
    }
  }
}

public <T> void addMapper(Class<T> type) {
    mapperRegistry.addMapper(type);
}

public <T> void addMapper(Class<T> type) {
    if (type.isInterface()) {
        if (hasMapper(type)) {
            //判断是否已经绑定
            throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
        }
        boolean loadCompleted = false;
        try {
            //knownMappers存放Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>();
            //此处只是存放，并没有创建代理对象
            knownMappers.put(type, new MapperProxyFactory<>(type));
            //此处是解析mapper接口上面的注解
            MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
            parser.parse();
            loadCompleted = true;
        } finally {
            if (!loadCompleted) {
                knownMappers.remove(type);
            }
        }
    }
}


public class MapperProxyFactory<T> {
 // 。。。 省略get and set方法
  private final Class<T> mapperInterface;
  private final Map<Method, MapperMethodInvoker> methodCache = new ConcurrentHashMap<>();

  @SuppressWarnings("unchecked")
  protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

  public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }
}



//org.apache.ibatis.builder.annotation.MapperAnnotationBuilder#parse
public void parse() {
    //mapper地址
    String resource = type.toString();
    if (!configuration.isResourceLoaded(resource)) {
        //去指定路径去解析xml文件，寻找的资源路径为：org.apache.mytest.mapper.UserMapper将. 替换/
        //String xmlResource = type.getName().replace('.', '/') + ".xml";
        //org/apache/mytest/mapper/UserMapper.xml 也就是说默认加载此路径下面的xml文件
      loadXmlResource();
      configuration.addLoadedResource(resource);
      assistant.setCurrentNamespace(type.getName());
       //解析CacheNamespace注解
      parseCache();
       //解析CacheNamespaceRef注解
      parseCacheRef();
        //获取所有的方法
      for (Method method : type.getMethods()) {
        if (!canHaveStatement(method)) {
          continue;
        }
          //判断方法上面是否注解Select，SelectProvider，并且存在ResultMap
        if (getAnnotationWrapper(method, false, Select.class, SelectProvider.class).isPresent()
            && method.getAnnotation(ResultMap.class) == null) {
            //处理ResultMap
          parseResultMap(method);
        }
        try {
            //解析parseStatement，解析过程和xml解析很相似，但是获取值的方式换为获取注解参数
          parseStatement(method);
        } catch (IncompleteElementException e) {
            //如果处理异常则添加IncompleteMethod
          configuration.addIncompleteMethod(new MethodResolver(this, method));
        }
      }
    }
    //处理刚才处理异常的方法
    parsePendingMethods();
  }

获取SqlSession

sqlSessionFactory.openSession() 去获取SqlSession

public SqlSession openSession() {
  return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
}

/**
   * 开启一个SqlSession（从数据源获取）默认
   *
   * @param execType   执行的类型：[简单，可复用，批量]
   * @param level      事务等级
   * @param autoCommit 是否开启自动提交
   */
  private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
      final Environment environment = configuration.getEnvironment();
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
        //生成事务
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
      //运行代码的Executor
      final Executor executor = configuration.newExecutor(tx, execType);
      return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
      closeTransaction(tx); // may have fetched a connection so lets call close()
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }


/**
   * 创建一个运行sql的Executor
   *
   * @param transaction  事务
   * @param executorType 根据executorType初始化不同的Executor,默认为SIMPLE类型
   * @return executor 如果没有修改设置的情况，默认返回CachingExecutor(SimpleExecutor)
   */
  public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    executorType = executorType == null ? defaultExecutorType : executorType;
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Executor executor;
    if (ExecutorType.BATCH == executorType) {
      executor = new BatchExecutor(this, transaction);
    } else if (ExecutorType.REUSE == executorType) {
      executor = new ReuseExecutor(this, transaction);
    } else {
      executor = new SimpleExecutor(this, transaction);
    }
    if (cacheEnabled) {
      executor = new CachingExecutor(executor);
    }
    //根据插件生成对应的代理Executor,!这里是层层套的代理
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

获取Mapper代理

//此时返回的UserMapper是一个代理对象
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

public <T> T getMapper(Class<T> type) {
	return configuration.getMapper(type, this);
}

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
  return mapperRegistry.getMapper(type, sqlSession);
}

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    //HashMap中获取MapperProxyFactory代理工厂（用于创建Mapper代理类）
    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
    if (mapperProxyFactory == null) {
        throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }
    try {
        return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
        throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
}

public T newInstance(SqlSession sqlSession) {
    //MapperProxy为实际的代理处理类实现了InvocationHandler方法
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
 }

protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

调用接口方法

通过代理对象去调用对应的方法

//调用代理类的所有方法都会处理invoke方法
UserPo userPo = userMapper.selectById(1L);

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  try {
    //如果是Object类的方法就直接执行，无需代理
    if (Object.class.equals(method.getDeclaringClass())) {
      return method.invoke(this, args);
    } else {
      //是接口中的方法，需代理增强
      //这里是mapper方法执行的入口
      return cachedInvoker(method).invoke(proxy, method, args, sqlSession);
    }
  } catch (Throwable t) {
    throw ExceptionUtil.unwrapThrowable(t);
  }
}


private MapperMethodInvoker cachedInvoker(Method method) throws Throwable {
    try {
        //public static <K, V> V computeIfAbsent(Map<K, V> map, K key, Function<K, V> mappingFunction) 
      return MapUtil.computeIfAbsent(methodCache, method, m -> {
          //判断此方法是不是默认方法
        if (m.isDefault()) {
          try {
              //privateLookupInMethod用来区分是JDK8 还是 JDK9，两个对于MethodHandle不一样
              //MethodHandle是方法句柄，下去可以自定学习
            if (privateLookupInMethod == null) {
                //绑定
              return new DefaultMethodInvoker(getMethodHandleJava8(method));
            } else {
              return new DefaultMethodInvoker(getMethodHandleJava9(method));
            }
          } catch (IllegalAccessException | InstantiationException | InvocationTargetException
              | NoSuchMethodException e) {
            throw new RuntimeException(e);
          }
        } else {
            是Mapper接口中定义的接口，通过创建的MapperMethod实例构造PlainMethodInvoker对象
          return new PlainMethodInvoker(new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
        }
      });
    } catch (RuntimeException re) {
      Throwable cause = re.getCause();
      throw cause == null ? re : cause;
    }
  }


public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {
    //根据String statementId = mapperInterface.getName() + "." + methodName;
    // configuration.getMappedStatement(statementId);SqlCommand的信息可以在MappedStatement中获取
    this.command = new SqlCommand(config, mapperInterface, method);
    this.method = new MethodSignature(config, mapperInterface, method);
}


public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable {
  //最终的代理逻辑
  return mapperMethod.execute(sqlSession, args);
}

//MapperMethod.execute();
public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    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);
        } else if (method.returnsMap()) {
          result = executeForMap(sqlSession, args);
        } else if (method.returnsCursor()) {
          result = executeForCursor(sqlSession, args);
        } else {
            //将参数转换并且拼接
          Object param = method.convertArgsToSqlCommandParam(args);
            //调用selectOne
          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;
  }



public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
	return selectList(statement, parameter, rowBounds, Executor.NO_RESULT_HANDLER);
}

/**
   * 查询的最后处理方法
   *
   * @param statement sql或者Mybatis的Mapper文件中的Id (namespace +方法名)
   * @param parameter sql中需要的参数
   * @param rowBounds 行信息
   * @param handler   结果处理函数
   * @param <E>       泛型
   */
  private <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
    try {
      //根据用户传入的唯一标识符，去查找Sql对应的MappedStatement结构
      MappedStatement ms = configuration.getMappedStatement(statement);
      return executor.query(ms, wrapCollection(parameter), rowBounds, handler);
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }


public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    //将#{}替换为?
    BoundSql boundSql = ms.getBoundSql(parameter);
    //创建缓存key
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
	return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}

//ms.getBoundSql(parameter);
public BoundSql getBoundSql(Object parameterObject) {
    BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    if (parameterMappings == null || parameterMappings.isEmpty()) {
      boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject);
    }
    // check for nested result maps in parameter mappings (issue #30)
    for (ParameterMapping pm : boundSql.getParameterMappings()) {
      String rmId = pm.getResultMapId();
        //没有指定ResultMap则不走下面
      if (rmId != null) {
        ResultMap rm = configuration.getResultMap(rmId);
        if (rm != null) {
          hasNestedResultMaps |= rm.hasNestedResultMaps();
        }
      }
    }
    return boundSql;
  }

//oundSql boundSql = sqlSource.getBoundSql(parameterObject);
@Override
  public BoundSql getBoundSql(Object parameterObject) {
    DynamicContext context = new DynamicContext(configuration, parameterObject);
     //MixedSqlNode => contents.forEach(node -> node.apply(context)); 循环去调用各sql片段的方法
    rootSqlNode.apply(context);
    SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
    Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
     //上面处理完了后，sqlSource成了StaticSqlSource
    SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());
      //return new BoundSql(configuration, sql, parameterMappings, parameterObject);
    BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
    context.getBindings().forEach(boundSql::setAdditionalParameter);
    return boundSql;
  }


public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
    //缓存查询cacheKey是根据mapperxml中的id，参数值，RowBounds，环境id的集合体
    //这里的ms.getCache就是所谓的一级缓存（看完代码感觉可能是二级缓存），缓存对象为整个mapperXml文件
    //BaseExecutor中的可能是一级缓存
    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); // issue #578 and #116
        }
        return list;
      }
    }
    //没有缓存，直接去数据库中查询
    return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }


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.");
    }
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();
    }
    List<E> list;
    try {
      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--;
    }
    if (queryStack == 0) {
      for (DeferredLoad deferredLoad : deferredLoads) {
        deferredLoad.load();
      }
      // issue #601
      deferredLoads.clear();
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }

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 {
      list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    } finally {
      localCache.removeObject(key);
    }
    //缓存结果
    localCache.putObject(key, list);
    if (ms.getStatementType() == StatementType.CALLABLE) {
      //缓存方法调用的参数，parameter为ParameterNameResolver处理之后的
      localOutputParameterCache.putObject(key, parameter);
    }
    return list;
  }

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());
        //org.apache.ibatis.executor.statement.SimpleStatementHandler#query
      return handler.query(stmt, resultHandler);
    } 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;
  }

//org.apache.ibatis.executor.statement.SimpleStatementHandler#query
 public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    String sql = boundSql.getSql();
    statement.execute(sql);
     //根据结果进行映射
    return resultSetHandler.handleResultSets(statement);
  }

处理响应结果

public List<Object> handleResultSets(Statement stmt) throws SQLException {
    ErrorContext.instance().activity("handling results").object(mappedStatement.getId());

    final List<Object> multipleResults = new ArrayList<>();

    int resultSetCount = 0;
    
   //执行sql。并将返回的ResultSet封装到ResultSetWrapper
    ResultSetWrapper rsw = getFirstResultSet(stmt);
	//获取设置的ResultMap
    List<ResultMap> resultMaps = mappedStatement.getResultMaps();
    int resultMapCount = resultMaps.size();
    validateResultMapsCount(rsw, resultMapCount);
    //rsw不是空，并且resultMapCount 大于 0
    while (rsw != null && resultMapCount > resultSetCount) {
      ResultMap resultMap = resultMaps.get(resultSetCount);
      //循环一条一条去处理结果set
      handleResultSet(rsw, resultMap, multipleResults, null);
      rsw = getNextResultSet(stmt);
      cleanUpAfterHandlingResultSet();
      resultSetCount++;
    }
	//处理加载复杂类型的结果集 
    //<select id="selectBlog" resultSets="blogs,authors" resultMap="blogResult" statementType="CALLABLE">
    String[] resultSets = mappedStatement.getResultSets();
    if (resultSets != null) {
      while (rsw != null && resultSetCount < resultSets.length) {
        ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
        if (parentMapping != null) {
          String nestedResultMapId = parentMapping.getNestedResultMapId();
          ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
          handleResultSet(rsw, resultMap, null, parentMapping);
        }
        rsw = getNextResultSet(stmt);
        cleanUpAfterHandlingResultSet();
        resultSetCount++;
      }
    }

    return collapseSingleResultList(multipleResults);
  }



private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List<Object> multipleResults, ResultMapping parentMapping) throws SQLException {
    try {
      if (parentMapping != null) {
        handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);
      } else {
          //判断是否存在结果集处理器，入参出入结果集处理器并实现ResultHandler接口重写handleResult方法
        if (resultHandler == null) {
          DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
          handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
          multipleResults.add(defaultResultHandler.getResultList());
        } else {
          handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
        }
      }
    } finally {
      // issue #228 (close resultsets)
      closeResultSet(rsw.getResultSet());
    }
  }

public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
    //判断结果集是否嵌套处理
    if (resultMap.hasNestedResultMaps()) {
      ensureNoRowBounds();
      checkResultHandler();
      handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    } else {
        //简单的返回
      handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    }
  }

private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
      throws SQLException {
    DefaultResultContext<Object> resultContext = new DefaultResultContext<>();
    ResultSet resultSet = rsw.getResultSet();
    skipRows(resultSet, rowBounds);
    while (shouldProcessMoreRows(resultContext, rowBounds) && !resultSet.isClosed() && resultSet.next()) {
      ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(resultSet, resultMap, null);
      Object rowValue = getRowValue(rsw, discriminatedResultMap, null);
      storeObject(resultHandler, resultContext, rowValue, parentMapping, resultSet);
    }
  }