内容摘要：一、前言介绍MyBatis 是一款非常优秀的持久层框架，相对于IBatis更是精进了不少。与此同时它还提供了很多的扩展点，比如最常用的插件；语言驱动器，执行器，对象工厂，对象包装器工厂等等都可以扩展。

一、源码有实前言介绍

MyBatis 是分析一款非常优秀的持久层框架，相对于IBatis更是口没可执精进了不少。与此同时它还提供了很多的现类行增扩展点，比如最常用的删改插件；语言驱动器，执行器，源码有实对象工厂，分析对象包装器工厂等等都可以扩展。口没可执那么，现类行增如果想成为一个有深度的删改男人(程序猿)，还是源码有实应该好好的学习一下这款开源框架的源码，以此可以更好的分析领会设计模式的精髓(面试？)。其实可能平常的口没可执业务开发中，并不会去深究各个框架的现类行增源代码，也常常会听到即使不会也可以开发代码。删改但！每个人的目标不同，就像；代码写的好工资加的少(没有bug怎么看出你工作嘞！云服务器)，好！为了改变世界，开始分析喽！

在分析之前先出一个题，看看你适合看源码不； 

@Test  public void test(){       B b = new B();      b.scan();  //我的输出结果是什么？  }  static class A {       public void scan(){           doScan();      }      protected void doScan(){           System.out.println("A.doScan");      }  } static class B extends A {       @Override      protected void doScan() {           System.out.println("B.doScan");      }  } 

其实无论你的答案对错，都不影响你对源码的分析。只不过，往往在一些框架中会有很多的设计模式和开发技巧，如果上面的代码在你平时的开发中几乎没用过，那么可能你暂时更多的还是开发着CRUD的功能(莫慌，我还写过PHP呢)。

接下来先分析Mybatis单独使用时的源码执行过程，再分析Mybatis+Spring整合源码，好！开始。

二、案例工程

为了更好的分析，我们创建一个Mybaits的案例工程，其中包括；Mybatis单独使用、站群服务器Mybatis+Spring整合使用 

itstack-demo-mybatis  └── src      ├── main      │   ├── java      │   │   └── org.itstack.demo      │   │       ├── dao      │   │       │    ├── ISchool.java        │   │       │    └── IUserDao.java         │   │       └── interfaces           │   │             ├── School.java        │   │            └── User.java      │   ├── resources          │   │   ├── mapper      │   │   │   ├── School_Mapper.xml      │   │   │   └── User_Mapper.xml      │   │   ├── props          │   │   │   └── jdbc.properties      │   │   ├── spring      │   │   │   ├── mybatis-config-datasource.xml      │   │   │   └── spring-config-datasource.xml      │   │   ├── logback.xml      │   │   ├── mybatis-config.xml      │   │   └── spring-config.xml      │   └── webapp      │       └── WEB-INF      └── test           └── java               └── org.itstack.demo.test                   ├── MybatisApiTest.java                   └── SpringApiTest.java 

三、环境配置

 JDK1.8  IDEA 2019.3.1  mybatis 3.4.6 { 不同版本源码略有差异和bug修复}  mybatis-spring 1.3.2 ｛以下源码分析会说代码行号，注意不同版本可能会有差异｝

四、(mybatis)源码分析 

<dependency>      <groupId>org.mybatis</groupId>      <artifactId>mybatis</artifactId>      <version>3.4.6</version>  </dependency> 

Mybatis的整个源码还是很大的，以下主要将部分核心内容进行整理分析，以便于后续分析Mybatis与Spring整合的源码部分。简要包括；容器初始化、配置文件解析、Mapper加载与动态代理。

1. 从一个简单的案例开始

要学习Mybatis源码，最好的方式一定是从一个简单的点进入，而不是从Spring整合开始分析。SqlSessionFactory是整个Mybatis的核心实例对象，SqlSessionFactory对象的实例又通过SqlSessionFactoryBuilder对象来获得。SqlSessionFactoryBuilder对象可以从XML配置文件加载配置信息，然后创建SqlSessionFactory。如下例子：

MybatisApiTest.java 

public class MybatisApiTest {       @Test      public void test_queryUserInfoById() {          String resource = "spring/mybatis-config-datasource.xml";          Reader reader;          try {               reader = Resources.getResourceAsReader(resource);              SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);              SqlSession session = sqlMapper.openSession();              try {                   User user = session.selectOne("org.itstack.demo.dao.IUserDao.queryUserInfoById", 1L);                  System.out.println(JSON.toJSONString(user));              } finally {                   session.close();                  reader.close();              }          } catch (IOException e) {               e.printStackTrace();          }      } } 

dao/IUserDao.java 

public interface IUserDao {        User queryUserInfoById(Long id);  } 

spring/mybatis-config-datasource.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.jdbc.Driver"/>                  <property name="url" value="jdbc:mysql://127.0.0.1:3306/itstack?useUnicode=true"/>                  <property name="username" value="root"/>                  <property name="password" value="123456"/>              </dataSource>          </environment>      </environments>      <mappers>          <mapper resource="mapper/User_Mapper.xml"/>      </mappers> </configuration> 

如果一切顺利，那么会有如下结果： 

{ "age":18,"createTime":1571376957000,"id":1,"name":"花花","updateTime":1571376957000} 

从上面的代码块可以看到，核心代码；SqlSessionFactoryBuilder().build(reader)，负责Mybatis配置文件的网站模板加载、解析、构建等职责，直到最终可以通过SqlSession来执行并返回结果。

2. 容器初始化

从上面代码可以看到，SqlSessionFactory是通过SqlSessionFactoryBuilder工厂类创建的，而不是直接使用构造器。容器的配置文件加载和初始化流程如下：

 流程核心类   SqlSessionFactoryBuilder   XMLConfigBuilder   XPathParser   Configuration

SqlSessionFactoryBuilder.java 

public class SqlSessionFactoryBuilder {     public SqlSessionFactory build(Reader reader) {       return build(reader, null, null);    }    public SqlSessionFactory build(Reader reader, String environment) {       return build(reader, environment, null);    }    public SqlSessionFactory build(Reader reader, Properties properties) {       return build(reader, null, properties);    }    public SqlSessionFactory build(Reader reader, String environment, Properties properties) {       try {         XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);        return build(parser.parse());      } catch (Exception e) {         throw ExceptionFactory.wrapException("Error building SqlSession.", e);      } finally {         ErrorContext.instance().reset();        try {           reader.close();        } catch (IOException e) {           // Intentionally ignore. Prefer previous error.        }      }    }    public SqlSessionFactory build(InputStream inputStream) {       return build(inputStream, null, null);    }    public SqlSessionFactory build(InputStream inputStream, String environment) {       return build(inputStream, environment, null);    }    public SqlSessionFactory build(InputStream inputStream, Properties properties) {       return build(inputStream, null, properties);    }    public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {       try {         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.        }      }    }    public SqlSessionFactory build(Configuration config) {       return new DefaultSqlSessionFactory(config);    }  } 

从上面的源码可以看到，SqlSessionFactory提供三种方式build构建对象；

 字节流：java.io.InputStream  字符流：java.io.Reader  配置类：org.apache.ibatis.session.Configuration

那么，字节流、字符流都会创建配置文件解析类：XMLConfigBuilder，并通过parser.parse()生成Configuration，最后调用配置类构建方法生成SqlSessionFactory。

XMLConfigBuilder.java 

public class XMLConfigBuilder extends BaseBuilder {     private boolean parsed;    private final XPathParser parser;    private String environment;    private final ReflectorFactory localReflectorFactory = new DefaultReflectorFactory();    ...    public XMLConfigBuilder(Reader reader, String environment, Properties props) {       this(new XPathParser(reader, true, props, new XMLMapperEntityResolver()), environment, props);    }    ...  }     XMLConfigBuilder对于XML文件的加载和解析都委托于XPathParser，最终使用JDK自带的javax.xml进行XML解析(XPath)  XPathParser(Reader reader, boolean validation, Properties variables, EntityResolver entityResolver)

          1.  reader：使用字符流创建新的输入源，用于对XML文件的读取

          2.  validation：是否进行DTD校验

          3.  variables：属性配置信息

          4.  entityResolver：Mybatis硬编码了new XMLMapperEntityResolver()提供XML默认解析器

XMLMapperEntityResolver.java 

public class XMLMapperEntityResolver implements EntityResolver {     private static final String IBATIS_CONFIG_SYSTEM = "ibatis-3-config.dtd";    private static final String IBATIS_MAPPER_SYSTEM = "ibatis-3-mapper.dtd";    private static final String MYBATIS_CONFIG_SYSTEM = "mybatis-3-config.dtd";    private static final String MYBATIS_MAPPER_SYSTEM = "mybatis-3-mapper.dtd";    private static final String MYBATIS_CONFIG_DTD = "org/apache/ibatis/builder/xml/mybatis-3-config.dtd";    private static final String MYBATIS_MAPPER_DTD = "org/apache/ibatis/builder/xml/mybatis-3-mapper.dtd";    /*    * Converts a public DTD into a local one     *      * @param publicId The public id that is what comes after "PUBLIC"     * @param systemId The system id that is what comes after the public id.     * @return The InputSource for the DTD     *      * @throws org.xml.sax.SAXException If anything goes wrong     */    @Override    public InputSource resolveEntity(String publicId, String systemId) throws SAXException {       try {         if (systemId != null) {           String lowerCaseSystemId = systemId.toLowerCase(Locale.ENGLISH);          if (lowerCaseSystemId.contains(MYBATIS_CONFIG_SYSTEM) || lowerCaseSystemId.contains(IBATIS_CONFIG_SYSTEM)) {             return getInputSource(MYBATIS_CONFIG_DTD, publicId, systemId);          } else if (lowerCaseSystemId.contains(MYBATIS_MAPPER_SYSTEM) || lowerCaseSystemId.contains(IBATIS_MAPPER_SYSTEM)) {             return getInputSource(MYBATIS_MAPPER_DTD, publicId, systemId);          }        }        return null;      } catch (Exception e) {         throw new SAXException(e.toString());      }    }    private InputSource getInputSource(String path, String publicId, String systemId) {       InputSource source = null;      if (path != null) {         try {           InputStream in = Resources.getResourceAsStream(path);          source = new InputSource(in);          source.setPublicId(publicId);          source.setSystemId(systemId);                } catch (IOException e) {           // ignore, null is ok        }      }      return source;    }  }   Mybatis依赖于dtd文件进行进行解析，其中的ibatis-3-config.dtd主要是用于兼容用途  getInputSource(String path, String publicId, String systemId)的调用里面有两个参数publicId（公共标识符）和systemId（系统标示符）

XPathParser.java 

public XPathParser(Reader reader, boolean validation, Properties variables, EntityResolver entityResolver) {     commonConstructor(validation, variables, entityResolver);    this.document = createDocument(new InputSource(reader));  }  private void commonConstructor(boolean validation, Properties variables, EntityResolver entityResolver) {     this.validation = validation;    this.entityResolver = entityResolver;    this.variables = variables;    XPathFactory factory = XPathFactory.newInstance();    this.xpath = factory.newXPath();  }  private Document createDocument(InputSource inputSource) {     // important: this must only be called AFTER common constructor    try {       DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();      factory.setValidating(validation);      factory.setNamespaceAware(false);      factory.setIgnoringComments(true);      factory.setIgnoringElementContentWhitespace(false);      factory.setCoalescing(false);      factory.setExpandEntityReferences(true);      DocumentBuilder builder = factory.newDocumentBuilder();      builder.setEntityResolver(entityResolver);      builder.setErrorHandler(new ErrorHandler() {         @Override        public void error(SAXParseException exception) throws SAXException {           throw exception;        }        @Override        public void fatalError(SAXParseException exception) throws SAXException {           throw exception;        }        @Override        public void warning(SAXParseException exception) throws SAXException {         }      });      return builder.parse(inputSource);    } catch (Exception e) {       throw new BuilderException("Error creating document instance.  Cause: " + e, e);   }  }       从上到下可以看到主要是为了创建一个Mybatis的文档解析器，最后根据builder.parse(inputSource)返回Document  得到XPathParser实例后，接下来在调用方法：this(new XPathParser(reader, true, props, new XMLMapperEntityResolver()), environment, props);    XMLConfigBuilder.this(new XPathParser(reader, true, props, new XMLMapperEntityResolver()), environment, props);      private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {         super(new Configuration());        ErrorContext.instance().resource("SQL Mapper Configuration");        this.configuration.setVariables(props);        this.parsed = false;        this.environment = environment;        this.parser = parser;      } 

      3.  其中调用了父类的构造函数   

public abstract class BaseBuilder {         protected final Configuration configuration;        protected final TypeAliasRegistry typeAliasRegistry;        protected final TypeHandlerRegistry typeHandlerRegistry;       public BaseBuilder(Configuration configuration) {           this.configuration = configuration;          thisthis.typeAliasRegistry = this.configuration.getTypeAliasRegistry();          thisthis.typeHandlerRegistry = this.configuration.getTypeHandlerRegistry();        }      } 

      4.  XMLConfigBuilder创建完成后，sqlSessionFactoryBuild调用parser.parse()创建Configuration 

public class XMLConfigBuilder extends BaseBuilder {            public Configuration parse() {          if (parsed) {           throw new BuilderException("Each XMLConfigBuilder can only be used once.");         }         parsed = true;         parseConfiguration(parser.evalNode("/configuration"));         return configuration;       }  } 

3. 配置文件解析

这一部分是整个XML文件解析和装载的核心内容，其中包括；

 属性解析propertiesElement  加载settings节点settingsAsProperties  载自定义VFS loadCustomVfs  解析类型别名typeAliasesElement  加载插件pluginElement  加载对象工厂objectFactoryElement  创建对象包装器工厂objectWrapperFactoryElement  加载反射工厂reflectorFactoryElement  元素设置settingsElement  加载环境配置environmentsElement  数据库厂商标识加载databaseIdProviderElement  加载类型处理器typeHandlerElement  (核心)加载mapper文件mapperElement  parseConfiguration(parser.evalNode("/configuration"));  private void parseConfiguration(XNode root) {       try {         //issue #117 read properties first        //属性解析propertiesElement        propertiesElement(root.evalNode("properties"));        //加载settings节点settingsAsProperties        Properties settings = settingsAsProperties(root.evalNode("settings"));        //加载自定义VFS loadCustomVfs        loadCustomVfs(settings);        //解析类型别名typeAliasesElement        typeAliasesElement(root.evalNode("typeAliases"));        //加载插件pluginElement        pluginElement(root.evalNode("plugins"));        //加载对象工厂objectFactoryElement        objectFactoryElement(root.evalNode("objectFactory"));        //创建对象包装器工厂objectWrapperFactoryElement        objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));        //加载反射工厂reflectorFactoryElement        reflectorFactoryElement(root.evalNode("reflectorFactory"));        //元素设置        settingsElement(settings);        // read it after objectFactory and objectWrapperFactory issue #631        //加载环境配置environmentsElement        environmentsElement(root.evalNode("environments"));        //数据库厂商标识加载databaseIdProviderElement        databaseIdProviderElement(root.evalNode("databaseIdProvider"));        //加载类型处理器typeHandlerElement        typeHandlerElement(root.evalNode("typeHandlers"));        //加载mapper文件mapperElement        mapperElement(root.evalNode("mappers"));      } catch (Exception e) {         throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);      }  }  

所有的root.evalNode()底层都是调用XML DOM方法：Object evaluate(String expression, Object item, QName returnType)，表达式参数expression，通过XObject resultObject = eval( expression, item )返回最终节点内容，可以参考http://mybatis.org/dtd/mybati...，如下； 

<!ELEMENT configuration (properties?, settings?, typeAliases?, typeHandlers?, objectFactory?, objectWrapperFactory?, reflectorFactory?, plugins?, environments?, databaseIdProvider?, mappers?)> <!ELEMENT databaseIdProvider (property*)>  <!ATTLIST databaseIdProvider  type CDATA #REQUIRED  >  <!ELEMENT properties (property*)>  <!ATTLIST properties  resource CDATA #IMPLIED  url CDATA #IMPLIED  >  <!ELEMENT property EMPTY>  <!ATTLIST property  name CDATA #REQUIRED  value CDATA #REQUIRED  > <!ELEMENT settings (setting+)>  <!ELEMENT setting EMPTY>  <!ATTLIST setting  name CDATA #REQUIRED  value CDATA #REQUIRED  >  <!ELEMENT typeAliases (typeAlias*,package*)> <!ELEMENT typeAlias EMPTY>  <!ATTLIST typeAlias  type CDATA #REQUIRED  alias CDATA #IMPLIED  >  <!ELEMENT typeHandlers (typeHandler*,package*)>  <!ELEMENT typeHandler EMPTY>  <!ATTLIST typeHandler  javaType CDATA #IMPLIED  jdbcType CDATA #IMPLIED  handler CDATA #REQUIRED  > <!ELEMENT objectFactory (property*)>  <!ATTLIST objectFactory  type CDATA #REQUIRED  >  <!ELEMENT objectWrapperFactory EMPTY>  <!ATTLIST objectWrapperFactory  type CDATA #REQUIRED  >  <!ELEMENT reflectorFactory EMPTY>  <!ATTLIST reflectorFactory  type CDATA #REQUIRED  > <!ELEMENT plugins (plugin+)>  <!ELEMENT plugin (property*)> <!ATTLIST plugin  interceptor CDATA #REQUIRED  >  <!ELEMENT environments (environment+)>  <!ATTLIST environments  default CDATA #REQUIRED  >  <!ELEMENT environment (transactionManager,dataSource)>  <!ATTLIST environment  id CDATA #REQUIRED  >  <!ELEMENT transactionManager (property*)>  <!ATTLIST transactionManager  type CDATA #REQUIRED  >  <!ELEMENT dataSource (property*)>  <!ATTLIST dataSource  type CDATA #REQUIRED  >  <!ELEMENT mappers (mapper*,package*)>  <!ELEMENT mapper EMPTY>  <!ATTLIST mapper  resource CDATA #IMPLIED  url CDATA #IMPLIED  class CDATA #IMPLIED  >  <!ELEMENT package EMPTY>  <!ATTLIST package  name CDATA #REQUIRED  > 

mybatis-3-config.dtd 定义文件中有11个配置文件，如下；

 properties?,  settings?,  typeAliases?,  typeHandlers?,  objectFactory?,  objectWrapperFactory?,  reflectorFactory?,  plugins?,  environments?,  databaseIdProvider?,  mappers?

以上每个配置都是可选。最终配置内容会保存到org.apache.ibatis.session.Configuration，如下； 

public class Configuration {     protected Environment environment;    // 允许在嵌套语句中使用分页（RowBounds）。如果允许使用则设置为false。默认为false    protected boolean safeRowBoundsEnabled;    // 允许在嵌套语句中使用分页（ResultHandler）。如果允许使用则设置为false。   protected boolean safeResultHandlerEnabled = true;    // 是否开启自动驼峰命名规则（camel case）映射，即从经典数据库列名 A_COLUMN 到经典 Java 属性名 aColumn 的类似映射。默认false    protected boolean mapUnderscoreToCamelCase;    // 当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性会按需加载。默认值false (true in ≤3.4.1)    protected boolean aggressiveLazyLoading;    // 是否允许单一语句返回多结果集（需要兼容驱动）。    protected boolean multipleResultSetsEnabled = true;    // 允许 JDBC 支持自动生成主键，需要驱动兼容。这就是insert时获取mysql自增主键/oracle sequence的开关。注：一般来说,这是希望的结果,应该默认值为true比较合适。    protected boolean useGeneratedKeys;    // 使用列标签代替列名,一般来说,这是希望的结果    protected boolean useColumnLabel = true;    // 是否启用缓存 { 默认是开启的，可能这也是你的面试题}    protected boolean cacheEnabled = true;    // 指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，这对于有 Map.keySet() 依赖或 null 值初始化的时候是有用的。    protected boolean callSettersOnNulls;    // 允许使用方法签名中的名称作为语句参数名称。 为了使用该特性，你的工程必须采用Java 8编译，并且加上-parameters选项。（从3.4.1开始）    protected boolean useActualParamName = true;    //当返回行的所有列都是空时，MyBatis默认返回null。 当开启这个设置时，MyBatis会返回一个空实例。 请注意，它也适用于嵌套的结果集 (i.e. collectioin and association)。（从3.4.2开始） 注：这里应该拆分为两个参数比较合适, 一个用于结果集，一个用于单记录。通常来说，我们会希望结果集不是null，单记录仍然是null    protected boolean returnInstanceForEmptyRow;    // 指定 MyBatis 增加到日志名称的前缀。    protected String logPrefix;    // 指定 MyBatis 所用日志的具体实现，未指定时将自动查找。一般建议指定为slf4j或log4j    protected Class <? extends Log> logImpl;     // 指定VFS的实现, VFS是mybatis提供的用于访问AS内资源的一个简便接口    protected Class <? extends VFS> vfsImpl;    // MyBatis 利用本地缓存机制（Local Cache）防止循环引用（circular references）和加速重复嵌套查询。 默认值为 SESSION，这种情况下会缓存一个会话中执行的所有查询。 若设置值为 STATEMENT，本地会话仅用在语句执行上，对相同 SqlSession 的不同调用将不会共享数据。    protected LocalCacheScope localCacheScope = LocalCacheScope.SESSION;    // 当没有为参数提供特定的 JDBC 类型时，为空值指定 JDBC 类型。 某些驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。    protected JdbcType jdbcTypeForNull = JdbcType.OTHER;    // 指定对象的哪个方法触发一次延迟加载。    protected Set<String> lazyLoadTriggerMethods = new HashSet<String>(Arrays.asList(new String[] {  "equals", "clone", "hashCode", "toString" }));    // 设置超时时间，它决定驱动等待数据库响应的秒数。默认不超时    protected Integer defaultStatementTimeout;    // 为驱动的结果集设置默认获取数量。    protected Integer defaultFetchSize;    // SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（prepared statements）； BATCH 执行器将重用语句并执行批量更新。    protected ExecutorType defaultExecutorType = ExecutorType.SIMPLE;    // 指定 MyBatis 应如何自动映射列到字段或属性。 NONE 表示取消自动映射；PARTIAL 只会自动映射没有定义嵌套结果集映射的结果集。 FULL 会自动映射任意复杂的结果集（无论是否嵌套）。    protected AutoMappingBehavior autoMappingBehavior = AutoMappingBehavior.PARTIAL;    // 指定发现自动映射目标未知列（或者未知属性类型）的行为。这个值应该设置为WARNING比较合适    protected AutoMappingUnknownColumnBehavior autoMappingUnknownColumnBehavior = AutoMappingUnknownColumnBehavior.NONE;    // settings下的properties属性    protected Properties variables = new Properties();    // 默认的反射器工厂,用于操作属性、构造器方便    protected ReflectorFactory reflectorFactory = new DefaultReflectorFactory();    // 对象工厂, 所有的类resultMap类都需要依赖于对象工厂来实例化    protected ObjectFactory objectFactory = new DefaultObjectFactory();    // 对象包装器工厂,主要用来在创建非原生对象,比如增加了某些监控或者特殊属性的代理类    protected ObjectWrapperFactory objectWrapperFactory = new DefaultObjectWrapperFactory();    // 延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置fetchType属性来覆盖该项的开关状态。    protected boolean lazyLoadingEnabled = false;    // 指定 Mybatis 创建具有延迟加载能力的对象所用到的代理工具。MyBatis 3.3+使用JAVASSIST    protected ProxyFactory proxyFactory = new JavassistProxyFactory(); // #224 Using internal Javassist instead of OGNL    // MyBatis 可以根据不同的数据库厂商执行不同的语句，这种多厂商的支持是基于映射语句中的 databaseId 属性。    protected String databaseId;    ...  } 

以上可以看到，Mybatis把所有的配置；resultMap、Sql语句、插件、缓存等都维护在Configuration中。这里还有一个小技巧，在Configuration还有一个StrictMap内部类，它继承于HashMap完善了put时防重、get时取不到值的异常处理，如下； 

protected static class StrictMap<V> extends HashMap<String, V> {       private static final long serialVersionUID = -4950446264854982944L;      private final String name;      public StrictMap(String name, int initialCapacity, float loadFactor) {         super(initialCapacity, loadFactor);        this.name = name;      }      public StrictMap(String name, int initialCapacity) {         super(initialCapacity);        this.name = name;      }      public StrictMap(String name) {         super();        this.name = name;      }      public StrictMap(String name, Map<String, ? extends V> m) {         super(m);        this.name = name;      }  }     

(核心)加载mapper文件mapperElement

Mapper文件处理是Mybatis框架的核心服务，所有的SQL语句都编写在Mapper中，这块也是我们分析的重点，其他模块可以后续讲解。

XMLConfigBuilder.parseConfiguration()->mapperElement(root.evalNode("mappers")); 

private void mapperElement(XNode parent) throws Exception {      if (parent != null) {        for (XNode child : parent.getChildren()) {          // 如果要同时使用package自动扫描和通过mapper明确指定要加载的mapper，一定要确保package自动扫描的范围不包含明确指定的mapper，否则在通过package扫描的interface的时候，尝试加载对应xml文件的loadXmlResource()的逻辑中出现判重出错，报org.apache.ibatis.binding.BindingException异常，即使xml文件中包含的内容和mapper接口中包含的语句不重复也会出错，包括加载mapper接口时自动加载的xml mapper也一样会出错。         if ("package".equals(child.getName())) {            String mapperPackage = child.getStringAttribute("name");           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) {              ErrorContext.instance().resource(resource);             InputStream inputStream = Resources.getResourceAsStream(resource);             XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());             mapperParser.parse();           } else if (resource == null && url != null && mapperClass == null) {              ErrorContext.instance().resource(url);             InputStream inputStream = Resources.getUrlAsStream(url);             XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());             mapperParser.parse();           } else if (resource == null && url == null && mapperClass != null) {              Class<?> mapperInterface = Resources.classForName(mapperClass);             configuration.addMapper(mapperInterface);           } else {              throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");           }         }       }     }  }   Mybatis提供了两类配置Mapper的方法，第一类是使用package自动搜索的模式，这样指定package下所有接口都会被注册为mapper，也是在Spring中比较常用的方式，例如：    <mappers>       <package name="org.itstack.demo"/>     </mappers>   另外一类是明确指定Mapper，这又可以通过resource、url或者class进行细分，例如；    <mappers>         <mapper resource="mapper/User_Mapper.xml"/>         <mapper class=""/>         <mapper url=""/>     </mappers> 

4. Mapper加载与动态代理

通过package方式自动搜索加载，生成对应的mapper代理类，代码块和流程，如下； 

private void mapperElement(XNode parent) throws Exception {     if (parent != null) {       for (XNode child : parent.getChildren()) {         if ("package".equals(child.getName())) {           String mapperPackage = child.getStringAttribute("name");          configuration.addMappers(mapperPackage);        } else {           ...        }      }    }  } 

Mapper加载到生成代理对象的流程中，主要的核心类包括；

 XMLConfigBuilder  Configuration  MapperRegistry  MapperAnnotationBuilder  MapperProxyFactory

MapperRegistry.java

解析加载Mapper 

public void addMappers(String packageName, Class<?> superType) {     // mybatis框架提供的搜索classpath下指定package以及子package中符合条件(注解或者继承于某个类/接口)的类，默认使用Thread.currentThread().getContextClassLoader()返回的加载器,和spring的工具类殊途同归。    ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<Class<?>>();       // 无条件的加载所有的类,因为调用方传递了Object.class作为父类,这也给以后的指定mapper接口预留了余地    resolverUtil.find(new ResolverUtil.IsA(superType), packageName);    // 所有匹配的calss都被存储在ResolverUtil.matches字段中    Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses();    for (Class<?> mapperClass : mapperSet) {          //调用addMapper方法进行具体的mapper类/接口解析      addMapper(mapperClass);    }  } 

生成代理类：MapperProxyFactory 

public <T> void addMapper(Class<T> type) {         // 对于mybatis mapper接口文件，必须是interface，不能是class    if (type.isInterface()) {       if (hasMapper(type)) {         throw new BindingException("Type " + type + " is already known to the MapperRegistry.");      }      boolean loadCompleted = false;      try {               // 为mapper接口创建一个MapperProxyFactory代理        knownMappers.put(type, new MapperProxyFactory<T>(type));        // Its important that the type is added before the parser is run        // otherwise the binding may automatically be attempted by the        // mapper parser. If the type is already known, it wont try.        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);        parser.parse();        loadCompleted = true;      } finally {         if (!loadCompleted) {           knownMappers.remove(type);        }      }    }  } 

在MapperRegistry中维护了接口类与代理工程的映射关系，knownMappers； 

private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<Class<?>, MapperProxyFactory<?>>(); 

MapperProxyFactory.java 

public class MapperProxyFactory<T> {     private final Class<T> mapperInterface;    private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();    public MapperProxyFactory(Class<T> mapperInterface) {       this.mapperInterface = mapperInterface;    }    public Class<T> getMapperInterface() {       return mapperInterface;    }    public Map<Method, MapperMethod> getMethodCache() {       return methodCache;    }    @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<T>(sqlSession, mapperInterface, methodCache);      return newInstance(mapperProxy);    }  } 

如上是Mapper的代理类工程，构造函数中的mapperInterface就是对应的接口类，当实例化时候会获得具体的MapperProxy代理，里面主要包含了SqlSession。

五、(mybatis-spring)源码分析 

<dependency>      <groupId>org.mybatis</groupId>      <artifactId>mybatis-spring</artifactId>      <version>1.3.2</version>  </dependency> 

作为一款好用的ORM框架，一定是萝莉脸(单纯)、御姐心(强大)，铺的了床(屏蔽与JDBC直接打交道)、暖的了房(速度性能好)！鉴于这些优点几乎在国内互联网大部分开发框架都会使用到Mybatis，尤其在一些需要高性能的场景下需要优化sql那么一定需要手写sql在xml中。那么，准备好了吗！开始分析分析它的源码；

1. 从一个简单的案例开始

与分析mybatis源码一样，先做一个简单的案例；定义dao、编写配置文件、junit单元测试；

SpringApiTest.java 

@RunWith(SpringJUnit4ClassRunner.class)  @ContextConfiguration("classpath:spring-config.xml")  public class SpringApiTest {      private Logger logger = LoggerFactory.getLogger(SpringApiTest.class);      @Resource      private ISchoolDao schoolDao;      @Resource      private IUserDao userDao;      @Test      public void test_queryRuleTreeByTreeId(){           School ruleTree = schoolDao.querySchoolInfoById(1L);          logger.info(JSON.toJSONString(ruleTree));          User user = userDao.queryUserInfoById(1L);          logger.info(JSON.toJSONString(user));      }  } 

spring-config-datasource.xml 

<?xml version="1.0" encoding="UTF-8"?>  <beans xmlns="http://www.springframework.org/schema/beans"         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"         xsi:schemaLocation="http://www.springframework.org/schema/beans          http://www.springframework.org/schema/beans/spring-beans.xsd">     <!-- 1.数据库连接池： DriverManagerDataSource 也可以使用DBCP2-->      <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">          <property name="driverClassName" value="${ db.jdbc.driverClassName}"/>          <property name="url" value="${ db.jdbc.url}"/>          <property name="username" value="${ db.jdbc.username}"/>          <property name="password" value="${ db.jdbc.password}"/>      </bean>      <!-- 2.配置SqlSessionFactory对象 -->      <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">          <!-- 注入数据库连接池 -->          <property name="dataSource" ref="dataSource"/>          <!-- 配置MyBaties全局配置文件:mybatis-config.xml -->          <property name="configLocation" value="classpath:mybatis-config.xml"/>          <!-- 扫描entity包 使用别名 -->          <property name="typeAliasesPackage" value="org.itstack.demo.po"/>          <!-- 扫描sql配置文件:mapper需要的xml文件 -->          <property name="mapperLocations" value="classpath:mapper/*.xml"/>      </bean>      <!-- 3.配置扫描Dao接口包，动态实现Dao接口，注入到spring容器中 -->      <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">          <!-- 注入sqlSessionFactory -->          <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>          <!-- 给出需要扫描Dao接口包，多个逗号隔开 -->          <property name="basePackage" value="org.itstack.demo.dao"/>      </bean>            </beans> 

如果一切顺利，那么会有如下结果： 

{ "address":"北京市海淀区颐和园路5号","createTime":1571376957000,"id":1,"name":"北京大学","updateTime":1571376957000}  { "age":18,"createTime":1571376957000,"id":1,"name":"花花","updateTime":1571376957000} 

从上面单元测试的代码可以看到，两个没有方法体的注解就这么神奇的执行了我们的xml中的配置语句并输出了结果。其实主要得益于以下两个类；

 org.mybatis.spring.SqlSessionFactoryBean  org.mybatis.spring.mapper.MapperScannerConfigurer

2. 扫描装配注册(MapperScannerConfigurer)

MapperScannerConfigurer为整个Dao接口层生成动态代理类注册，启动到了核心作用。这个类实现了如下接口，用来对扫描的Mapper进行处理：

 BeanDefinitionRegistryPostProcessor  InitializingBean  ApplicationContextAware  BeanNameAware

整体类图如下；

执行流程如下；

上面的类图+流程图，其实已经很清楚的描述了MapperScannerConfigurer初始化过程，但对于头一次看的新人来说依旧是我太难了，好继续！

MapperScannerConfigurer.java & 部分截取 

@Override  public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {     if (this.processPropertyPlaceHolders) {       processPropertyPlaceHolders();    }    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);    scanner.setAddToConfig(this.addToConfig);    scanner.setAnnotationClass(this.annotationClass);    scanner.setMarkerInterface(this.markerInterface);    scanner.setSqlSessionFactory(this.sqlSessionFactory);    scanner.setSqlSessionTemplate(this.sqlSessionTemplate);    scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);    scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);    scanner.setResourceLoader(this.applicationContext);    scanner.setBeanNameGenerator(this.nameGenerator);    scanner.registerFilters();    scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));  }   实现了BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry用于注册Bean到Spring容器中  306行：new ClassPathMapperScanner(registry); 硬编码类路径扫描器，用于解析Mybatis的Mapper文件  317行：scanner.scan 对Mapper进行扫描。这里包含了一个继承类实现关系的调用，也就是本文开头的测试题。

ClassPathMapperScanner.java & 部分截取 

@Override  public Set<BeanDefinitionHolder> doScan(String... basePackages) {     Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);    if (beanDefinitions.isEmpty()) {       logger.warn("No MyBatis mapper was found in " + Arrays.toString(basePackages) + " package. Please check your configuration.");    } else {       processBeanDefinitions(beanDefinitions);    }    return beanDefinitions;  }   优先调用父类的super.doScan(basePackages);进行注册Bean信息

ClassPathBeanDefinitionScanner.java & 部分截取 

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {       Assert.notEmpty(basePackages, "At least one base package must be specified");      Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();      for (String basePackage : basePackages) {           Set<BeanDefinition> candidates = findCandidateComponents(basePackage);          for (BeanDefinition candidate : candidates) {               ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);              candidate.setScope(scopeMetadata.getScopeName());              String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);              if (candidate instanceof AbstractBeanDefinition) {                   postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);              }              if (candidate instanceof AnnotatedBeanDefinition) {                   AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate)              }              if (checkCandidate(beanName, candidate)) {                   BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);                  definitionHolder =                          AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.regi                  beanDefinitions.add(definitionHolder);                  registerBeanDefinition(definitionHolder, this.registry);              }          }      }      return beanDefinitions;  }   优先调用了父类的doScan方法，用于Mapper扫描和Bean的定义以及注册到DefaultListableBeanFactory。｛DefaultListableBeanFactory是Spring中IOC容器的始祖，所有需要实例化的类都需要注册进来，之后在初始化｝  272行：findCandidateComponents(basePackage)，扫描package包路径，对于注解类的有另外的方式，大同小异  288行：registerBeanDefinition(definitionHolder, this.registry);注册Bean信息的过程，最终会调用到：org.springframework.beans.factory.support.DefaultListableBeanFactory

ClassPathMapperScanner.java & 部分截取 

**processBeanDefinitions(beanDefinitions);**  private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {     GenericBeanDefinition definition;    for (BeanDefinitionHolder holder : beanDefinitions) {       definition = (GenericBeanDefinition) holder.getBeanDefinition();      if (logger.isDebugEnabled()) {         logger.debug("Creating MapperFactoryBean with name " + holder.getBeanName()           + " and " + definition.getBeanClassName() + " mapperInterface");      }      // the mapper interface is the original class of the bean      // but, the actual class of the bean is MapperFactoryBean      definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName()); // issue #59      definition.setBeanClass(this.mapperFactoryBean.getClass());      definition.getPropertyValues().add("addToConfig", this.addToConfig);      boolean explicitFactoryUsed = false;      if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {         definition.getPropertyValues().add("sqlSessionFactory", new RuntimeBeanReference(this.sqlSessionFactoryBeanName));        explicitFactoryUsed = true;      } else if (this.sqlSessionFactory != null) {         definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);        explicitFactoryUsed = true;      }      if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) {         if (explicitFactoryUsed) {           logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");        }        definition.getPropertyValues().add("sqlSessionTemplate", new RuntimeBeanReference(this.sqlSessionTemplateBeanName));        explicitFactoryUsed = true;      } else if (this.sqlSessionTemplate != null) {         if (explicitFactoryUsed) {           logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");        }        definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);        explicitFactoryUsed = true;      }      if (!explicitFactoryUsed) {         if (logger.isDebugEnabled()) {           logger.debug("Enabling autowire by type for MapperFactoryBean with name " + holder.getBeanName() + ".");        }        definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);      }    }  }   163行：super.doScan(basePackages);，调用完父类方法后开始执行内部方法：processBeanDefinitions(beanDefinitions)  186行：definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName()); 设置BeanName参数，也就是我们的：ISchoolDao、IUserDao  187行：definition.setBeanClass(this.mapperFactoryBean.getClass());，设置BeanClass，接口本身是没有类的，那么这里将MapperFactoryBean类设置进来，最终所有的dao层接口类都是这个MapperFactoryBean

MapperFactoryBean.java & 部分截取

这个类有继承也有接口实现，最好先了解下整体类图，如下；

这个类就非常重要了，最终所有的sql信息执行都会通过这个类获取getObject()，也就是SqlSession获取mapper的代理类：MapperProxyFactory->MapperProxy 

public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {     private Class<T> mapperInterface;    private boolean addToConfig = true;    public MapperFactoryBean() {       //intentionally empty     }    public MapperFactoryBean(Class<T> mapperInterface) {       this.mapperInterface = mapperInterface;    }    /**       * 当SpringBean容器初始化时候会调用到checkDaoConfig()，他是继承类中的抽象方法     * { @inheritDoc}     */    @Override    protected void checkDaoConfig() {       super.checkDaoConfig();      notNull(this.mapperInterface, "Property mapperInterface is required");     Configuration configuration = getSqlSession().getConfiguration();      if (this.addToConfig && !configuration.hasMapper(this.mapperInterface)) {         try {           configuration.addMapper(this.mapperInterface);        } catch (Exception e) {           logger.error("Error while adding the mapper " + this.mapperInterface + " to configuration.", e);          throw new IllegalArgumentException(e);        } finally {           ErrorContext.instance().reset();        }      }    }   /**     * { @inheritDoc}     */    @Override    public T getObject() throws Exception {       return getSqlSession().getMapper(this.mapperInterface);    }    ...  }   72行：checkDaoConfig()，当SpringBean容器初始化时候会调用到checkDaoConfig()，他是继承类中的抽象方法  95行：getSqlSession().getMapper(this.mapperInterface);，通过接口获取Mapper(代理类)，调用过程如下；   DefaultSqlSession.getMapper(Class<T> type)，获取Mapper   Configuration.getMapper(Class<T> type, SqlSession sqlSession)，从配置中获取   MapperRegistry.getMapper(Class<T> type, SqlSession sqlSession)，从注册中心获取到实例化生成      public <T> T getMapper(Class<T> type, SqlSession sqlSession) {          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);         }       }    mapperProxyFactory.newInstance(sqlSession);，通过反射工程生成MapperProxy        @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<T>(sqlSession, mapperInterface, methodCache);            return newInstance(mapperProxy);          } 

MapperProxy.java & 部分截取 

public class MapperProxy<T> implements InvocationHandler, Serializable {     private static final long serialVersionUID = -6424540398559729838L;    private final SqlSession sqlSession;    private final Class<T> mapperInterface;    private final Map<Method, MapperMethod> methodCache;    public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {       this.sqlSession = sqlSession;      this.mapperInterface = mapperInterface;      this.methodCache = methodCache;    }    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {       try {         if (Object.class.equals(method.getDeclaringClass())) {           return method.invoke(this, args);        } else if (isDefaultMethod(method)) {           return invokeDefaultMethod(proxy, method, args);        }      } catch (Throwable t) {         throw ExceptionUtil.unwrapThrowable(t);      }      final MapperMethod mapperMethod = cachedMapperMethod(method);      return mapperMethod.execute(sqlSession, args);    }    private MapperMethod cachedMapperMethod(Method method) {       MapperMethod mapperMethod = methodCache.get(method);      if (mapperMethod == null) {         mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());        methodCache.put(method, mapperMethod);      }      return mapperMethod;    }    @UsesJava7    private Object invokeDefaultMethod(Object proxy, Method method, Object[] args)        throws Throwable {       final Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class          .getDeclaredConstructor(Class.class, int.class);      if (!constructor.isAccessible()) {         constructor.setAccessible(true);      }      final Class<?> declaringClass = method.getDeclaringClass();      return constructor          .newInstance(declaringClass,              MethodHandles.Lookup.PRIVATE | MethodHandles.Lookup.PROTECTED                  | MethodHandles.Lookup.PACKAGE | MethodHandles.Lookup.PUBLIC)          .unreflectSpecial(method, declaringClass).bindTo(proxy).invokeWithArguments(args);    }    ...  }   58行：final MapperMethod mapperMethod = cachedMapperMethod(method);，从缓存中获取MapperMethod  59行：mapperMethod.execute(sqlSession, args);，执行SQL语句，并返回结果(到这关于查询获取结果就到骨头(干)层了)；INSERT、UPDATE、DELETE、SELECT  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);           result = sqlSession.selectOne(command.getName(), param);         }         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;   }   

以上对于MapperScannerConfigurer这一层就分析完了，从扫描定义注入到为Spring容器准备Bean的信息，代理、反射、SQL执行，基本就包括全部核心内容了，接下来在分析下SqlSessionFactoryBean

3. SqlSession容器工厂初始化(SqlSessionFactoryBean)

SqlSessionFactoryBean初始化过程中需要对一些自身内容进行处理，因此也需要实现如下接口；

 FactoryBean<SqlSessionFactory>  InitializingBean -> void afterPropertiesSet() throws Exception  ApplicationListener<ApplicationEvent>

以上的流程其实已经很清晰的描述整个核心流程，但同样对于新手上路会有障碍，那么！好，继续！

SqlSessionFactoryBean.java & 部分截取 

public void afterPropertiesSet() throws Exception {     notNull(dataSource, "Property dataSource is required");    notNull(sqlSessionFactoryBuilder, "Property sqlSessionFactoryBuilder is required");    state((configuration == null && configLocation == null) || !(configuration != null && configLocation != null),              "Property configuration and configLocation can not specified with together");    this.sqlSessionFactory = buildSqlSessionFactory();  }   afterPropertiesSet()，InitializingBean接口为bean提供了初始化方法的方式，它只包括afterPropertiesSet方法，凡是继承该接口的类，在初始化bean的时候都会执行该方法。  380行：buildSqlSessionFactory();内部方法构建，核心功能继续往下看。

SqlSessionFactoryBean.java & 部分截取 

protected SqlSessionFactory buildSqlSessionFactory() throws IOException {     Configuration configuration;    XMLConfigBuilder xmlConfigBuilder = null;    ...   if (!isEmpty(this.mapperLocations)) {       for (Resource mapperLocation : this.mapperLocations) {        if (mapperLocation == null) {           continue;        }        try {           XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),              configuration, mapperLocation.toString(), configuration.getSqlFragments());          xmlMapperBuilder.parse();        } catch (Exception e) {           throw new NestedIOException("Failed to parse mapping resource: " + mapperLocation + "", e);        } finally {           ErrorContext.instance().reset();        }        if (LOGGER.isDebugEnabled()) {           LOGGER.debug("Parsed mapper file: " + mapperLocation + "");        }      }    } else {       if (LOGGER.isDebugEnabled()) {         LOGGER.debug("Property mapperLocations was not specified or no matching resources found");      }    }    return this.sqlSessionFactoryBuilder.build(configuration);  }   513行：for (Resource mapperLocation : this.mapperLocations) 循环解析Mapper内容  519行：XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(...) 解析XMLMapperBuilder  521行：xmlMapperBuilder.parse() 执行解析，具体如下；

XMLMapperBuilder.java & 部分截取 

public class XMLMapperBuilder extends BaseBuilder {      private final XPathParser parser;     private final MapperBuilderAssistant builderAssistant;     private final Map<String, XNode> sqlFragments;     private final String resource;     private void bindMapperForNamespace() {        String namespace = builderAssistant.getCurrentNamespace();      if (namespace != null) {          Class<?> boundType = null;         try {            boundType = Resources.classForName(namespace);         } catch (ClassNotFoundException e) {            //ignore, bound type is not required         }         if (boundType != null) {            if (!configuration.hasMapper(boundType)) {              // Spring may not know the real resource name so we set a flag             // to prevent loading again this resource from the mapper interface             // look at MapperAnnotationBuilder#loadXmlResource             configuration.addLoadedResource("namespace:" + namespace);             configuration.addMapper(boundType);           }         }       }     }  }   这里413行非常重要，configuration.addMapper(boundType);，真正到了添加Mapper到配置中心

MapperRegistry.java & 部分截取 

public class MapperRegistry {     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.put(type, new MapperProxyFactory<T>(type));          // Its important that the type is added before the parser is run          // otherwise the binding may automatically be attempted by the          // mapper parser. If the type is already known, it wont try.          MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);          parser.parse();          loadCompleted = true;        } finally {           if (!loadCompleted) {             knownMappers.remove(type);          }        }      }    }  }   67行：创建代理工程knownMappers.put(type, new MapperProxyFactory<T>(type));

截至到这，MapperScannerConfigurer、SqlSessionFactoryBean，两个类干的事情就相融合了；

 第一个用于扫描Dao接口设置代理类注册到IOC中，用于后续生成Bean实体类，MapperFactoryBean，并可以通过mapperInterface从Configuration获取Mapper  另一个用于生成SqlSession工厂初始化，解析Mapper里的XML配置进行动态代理MapperProxyFactory->MapperProxy注入到Configuration的Mapper  最终在注解类的帮助下进行方法注入，等执行操作时候即可获得动态代理对象，从而执行相应的CRUD操作  @Resource    private ISchoolDao schoolDao;   schoolDao.querySchoolInfoById(1L); 

六、综上总结

 分析过程较长篇幅也很大，不一定一天就能看懂整个流程，但当耐下心来一点点研究，还是可以获得很多的收获的。以后在遇到这类的异常就可以迎刃而解了，同时也有助于面试、招聘！  之所以分析Mybatis最开始是想在Dao上加自定义注解，发现切面拦截不到。想到这是被动态代理的类，之后层层往往下扒直到MapperProxy.invoke！当然，Mybatis提供了自定义插件开发。  以上的源码分析只是对部分核心内容进行分析，如果希望了解全部可以参考资料；MyBatis 3源码深度解析，并调试代码。IDEA中还是很方便看源码的，包括可以查看类图、调用顺序等。  mybatis、mybatis-spring中其实最重要的是将Mapper配置文件解析与接口类组装成代理类进行映射，以此来方便对数据库的CRUD操作。从源码分析后，可以获得更多的编程经验(套路)。  Mybatis相关链接；   https://github.com/mybatis/mybatis-3   https://mybatis.org/mybatis-3/zh/index.html

七、推荐阅读

 这么折腾学习毕业进大厂不是问题  工作两年简历写的差教你优化  讲一下我自己的学习路线，给你一些参考  基于Springboot的中间件开发，了解一下