MyBatis源码剖析

1. MyBatis架构原理

1.1. 架构设计

我们把Mybatis的功能架构分为三层：

1. API接口层：提供给外部使用的接口 API，开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。

   MyBatis和数据库的交互有两种方式：

   （1）使用传统的MyBati s提供的API ；

   （2）使用Mapper代理的方式

2. 数据处理层：负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。它主要的目的是根据调用的请求完成一次数据库操作。

3. 基础支撑层：负责最基础的功能支撑，包括连接管理、事务管理、配置加载和缓存处理，这些都是共用的东西，将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。

1.2. 主要构件及其相互关系

构件	描述
SqlSession	作为MyBatis工作的主要顶层API，表示和数据库交互的会话，完成必要数据库增删改查功能
Executor	MyBatis执行器，是MyBatis调度的核心，负责SQL语句的生成和查询缓 存的维护
StatementHandler	封装了JDBC Statement操作，负责对JDBC statement的操作，如设置参数、将Statement结果集转换成List集合。
ParameterHandler	负责对用户传递的参数转换成JDBC Statement所需要的参数，
ResultSetHandler	负责将JDBC返回的ResultSet结果集对象转换成List类型的集合；
TypeHandler	负责java数据类型和jdbc数据类型之间的映射和转换
MappedStatement	MappedStatement维护了一条select、delete、update、insert节点的封装
SqlSource	负责根据用户传递的parameterObject，动态地生成SQL语句，将信息封装到BoundSql对象中，并返回
BoundSql	表示动态生成的SQL语句以及相应的参数信息

1.3. 总体流程

1. 加载配置并初始化

   触发条件：加载配置文件
   配置来源于两个地方，一个是配置文件(主配置文件conf.xml,mapper文件*.xml)，—个是java代码中的 注解，将主配置文件内容解析封装到Configuration，将sql的配置信息加载成为一个Mappedstatement 对象，存储在内存之中。

2. 接收调用请求
   触发条件：调用Mybatis提供的API
   传入参数：为SQL的ID和传入参数对象
   处理过程：将请求传递给下层的请求处理层进行处理。

3. 处理操作请求
   触发条件：API接口层传递请求过来
   传入参数：为SQL的ID和传入参数对象
   处理过程：
   ​ ① 根据SQL的ID查找对应的MappedStatement对象。
   ​ ② 根据传入参数对象解析MappedStatement对象，得到最终要执行的SQL和执行传入参数。
   ​ ③ 获取数据库连接，根据得到的最终SQL语句和执行传入参数到数据库执行，并得到执行结果。
   ​ ④ 根据MappedStatement对象中的结果映射配置对得到的执行结果进行转换处理，并得到最终的处理结果。
   ​ ⑤ 释放连接资源。

4. 返回处理结果
   将最终的处理结果返回。

2. 传统方式源码剖析

public class MybatisTest {
    
    

    /**
     * 传统方式
     *
     * @throws IOException
     */
    public void test1() throws IOException {
    
    
        // 1. 读取配置文件，读成字节输入流，注意：现在还没解析
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");

        // 2. (1)解析配置文件，封装Configuration对象  (2)创建DefaultSqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);

        // 3. 生产了DefaultSqlsession实例对象   设置了事务不自动提交  完成了executor对象的创建
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 4.(1)根据statementid来从Configuration中map集合中获取到了指定的MappedStatement对象
        //(2)将查询任务委派了executor执行器
        List<Object> objects = sqlSession.selectList("namespace.id");

        // 5.释放资源
        sqlSession.close();
    }
}

2.1. 读取配置文件，读成字节输入流

首先调用Resources中getResourceAsStream()方法读取MyBatis核心配置文件，读成字节输入流

// 1. 读取配置文件，读成字节输入流，注意：现在还没解析
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");

Resources类

/**
     * Returns a resource on the classpath as a Stream object
     *
     * @param resource The resource to find
     * @return The resource
     * @throws java.io.IOException If the resource cannot be found or read
     */
    public static InputStream getResourceAsStream(String resource) throws IOException {
    
    
        return getResourceAsStream(null, resource);
    }

    /**
     * Returns a resource on the classpath as a Stream object
     *
     * @param loader   The classloader used to fetch the resource
     * @param resource The resource to find
     * @return The resource
     * @throws java.io.IOException If the resource cannot be found or read
     */
    public static InputStream getResourceAsStream(ClassLoader loader, String resource) throws IOException {
    
    
        InputStream in = classLoaderWrapper.getResourceAsStream(resource, loader);
        if (in == null) {
    
    
            throw new IOException("Could not find resource " + resource);
        }
        return in;
    }

2.2. 解析配置文件

// 2. (1)解析配置文件，封装Configuration对象  (2)创建DefaultSqlSessionFactory对象
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);

首先看下构建SqlSessionFactory的整个流程，1：解析核心配置文件；2：创建DefaultSqlSessionFactory对象

SqlSessionFactoryBuilder类

	// 1.我们最初调用的build
    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);
    }

    // 2.调用的重载方法
    public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    
    
        try {
    
    
            // 创建 XMLConfigBuilder, XMLConfigBuilder是专门解析mybatis的配置文件的类
            XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
            // 执行 XML 解析
            // 创建 DefaultSqlSessionFactory 对象
            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.
            }
        }
    }

  MyBatis在初始化的时候，会将MyBatis的配置信息全部加载到内存中，使用Configuratio容器实例来维护

2.3. 下面进入对配置文件解析部分

2.3.1. Configuration

首先对Configuration对象进行介绍：

1. Configuration对象的结构和xml配置文件的对象几乎相同。
2. 回顾一下xml中的配置标签有哪些： properties (属性)，settings (设置)，typeAliases (类型别名)，typeHandlers (类型处理器)，objectFactory (对象工厂)，mappers (映射器)等 Configuration也有对应的对象属性来封装它们
3. 也就是说，初始化配置文件信息的本质就是创建Configuration对象，将解析的xml数据封装到Configuration内部属性中

2.3.2. MapperStatement

  作用：MappedStatement与Mapper配置文件中的一个select/update/insert/delete节点相对应。mapper中配置的标签都被封装到了此对象中，主要用途是描述一条SQL语句。

  初始化过程：回顾刚开 始介绍的加载配置文件的过程中，会对mybatis-config.xm l中的各个标签都进行解析，其中有mappers 标签用来引入mapper.xml文件或者配置mapper接口的目录。

	<select id="findAll" resultType="com.cyd.pojo.User">
        select * FROM user
    </select>

  像这样的一个select标签会在初始化配置文件时被解析封装成一个MappedStatement对象，然后存储在Configuration对象的mappedStatements属性中，mappedStatements 是一个HashMap，存储时key=全限定类名+方法名，value =对应的MappedStatement对象。

在configuration中对应的属性为

   /**
     * MappedStatement 映射
     *
     * KEY：`${namespace}.${id}`
     */
    protected final Map<String, MappedStatement> mappedStatements = new StrictMap<>("Mapped Statements collection");

2.3.3. XMLConfigBuilder中parse()解析配置文件

MyBatis将核心配置文件交由XMLConfigBuilder的parse()方法来解析

   /**
     * 解析 XML 成 Configuration 对象。
     *
     * @return Configuration 对象
     */
    public Configuration parse() {
    
    
        // 若已解析，抛出 BuilderException 异常
        if (parsed) {
    
    
            throw new BuilderException("Each XMLConfigBuilder can only be used once.");
        }
        // 标记已解析
        parsed = true;
        // parser是XPathParser解析器对象，读取节点内数据，<configuration>是MyBatis配置文件中的顶层标签
        // 解析 XML configuration 节点
        parseConfiguration(parser.evalNode("/configuration"));
        return configuration;
    }

    /**
     * 解析 XML
     * <p>
     * 具体 MyBatis 有哪些 XML 标签，参见 《XML 映射配置文件》http://www.mybatis.org/mybatis-3/zh/configuration.html
     *
     * @param root 根节点
     */
    private void parseConfiguration(XNode root) {
    
    
        try {
    
    
            //issue #117 read properties first
            // 解析 <properties /> 标签
            propertiesElement(root.evalNode("properties"));
            // 解析 <settings /> 标签
            Properties settings = settingsAsProperties(root.evalNode("settings"));
            // 加载自定义的 VFS 实现类
            loadCustomVfs(settings);
            // 解析 <typeAliases /> 标签
            typeAliasesElement(root.evalNode("typeAliases"));
            // 解析 <plugins /> 标签
            pluginElement(root.evalNode("plugins"));
            // 解析 <objectFactory /> 标签
            objectFactoryElement(root.evalNode("objectFactory"));
            // 解析 <objectWrapperFactory /> 标签
            objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
            // 解析 <reflectorFactory /> 标签
            reflectorFactoryElement(root.evalNode("reflectorFactory"));
            // 赋值 <settings /> 到 Configuration 属性
            settingsElement(settings);
            // read it after objectFactory and objectWrapperFactory issue #631
            // 解析 <environments /> 标签
            environmentsElement(root.evalNode("environments"));
            // 解析 <databaseIdProvider /> 标签
            databaseIdProviderElement(root.evalNode("databaseIdProvider"));
            // 解析 <typeHandlers /> 标签
            typeHandlerElement(root.evalNode("typeHandlers"));
            // 解析 <mappers /> 标签
            mapperElement(root.evalNode("mappers"));
        } catch (Exception e) {
    
    
            throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
        }
    }

2.3.3.1. 主要介绍一下如何解析mappers标签

一般我们在MyBatis核心配置文件中可以使用以下四种方式配置映射文件的位置

• package：将包内的映射器接口全部注册为映射器
• class：使用映射器接口的完全限定类名
• resource：使用相对于类路径的资源引用
• url：完全限定资源定位符（URL）

	<mappers>
        <!-- 将包内的映射器接口实现全部注册为映射器 -->
        <package name="com.cyd.mapper"/>
        <!-- 使用映射器接口的完全限定类名 -->
        <mapper class="com.cyd.mapper.UserMapper"/>

        <!-- 使用相对于类路径的资源引用 -->
        <mapper resource="UserMapper.xml"/>
        <!-- 使用完全限定资源定位符（URL） -->
        <mapper url="file:///xxx/UserMapper.xml"/>
    </mappers>

	/**
     * 解析 <mappers /> 标签
     *
     * @param parent <mappers />标签
     * @throws Exception
     */
    private void mapperElement(XNode parent) throws Exception {
    
    
        if (parent != null) {
    
    
            // 遍历子节点
            for (XNode child : parent.getChildren()) {
    
    
                // 如果是 package 标签，则扫描该包
                if ("package".equals(child.getName())) {
    
    
                    // 获得包名
                    String mapperPackage = child.getStringAttribute("name");
                    // 添加到 configuration 中
                    configuration.addMappers(mapperPackage);
                    // 如果是 mapper 标签，
                } else {
    
    
                    // 获得 resource、url、class 属性
                    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);
                        // 获得 resource 的 InputStream 对象
                        InputStream inputStream = Resources.getResourceAsStream(resource);
                        // 创建 XMLMapperBuilder 对象
                        XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
                        // 执行解析
                        mapperParser.parse();
                        // 使用完全限定资源定位符（URL）
                    } else if (resource == null && url != null && mapperClass == null) {
    
    
                        ErrorContext.instance().resource(url);
                        // 获得 url 的 InputStream 对象
                        InputStream inputStream = Resources.getUrlAsStream(url);
                        // 创建 XMLMapperBuilder 对象
                        XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
                        // 执行解析
                        mapperParser.parse();
                        // 使用映射器接口实现类的完全限定类名
                    } else if (resource == null && url == null && mapperClass != null) {
    
    
                        // 获得 Mapper 接口
                        Class<?> mapperInterface = Resources.classForName(mapperClass);
                        // 添加到 configuration 中
                        configuration.addMapper(mapperInterface);
                    } else {
    
    
                        throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
                    }
                }
            }
        }
    }

1、解析package标签

	// 如果是 package 标签，则扫描该包
    if ("package".equals(child.getName())) {
    
    
    	// 获得包名
      	String mapperPackage = child.getStringAttribute("name");
      	// 添加到 configuration 中
       	configuration.addMappers(mapperPackage);
	}

configuration.addMappers(mapperPackage)

	public void addMappers(String packageName) {
    
    
        // 扫描该包下所有的 Mapper 接口，并添加到 mapperRegistry 中
        mapperRegistry.addMappers(packageName);
    }

mapperRegistry.addMappers(packageName)，扫描指定包，并将符合的类，添加到MapperRegistry的属性knownMappers中

	//这个类中维护一个HashMap存放MapperProxyFactory
    private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>();

    /**
     * @since 3.2.2
     */
    public void addMappers(String packageName) {
    
    
        addMappers(packageName, Object.class);
    }
    
    /**
     * 扫描指定包，并将符合的类，添加到 {@link #knownMappers} 中
     *
     * @since 3.2.2
     */
    public void addMappers(String packageName, Class<?> superType) {
    
    
        // 扫描指定包下的指定类
        ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<>();
        resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
        Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses();
        // 遍历，添加到 knownMappers 中
        for (Class<?> mapperClass : mapperSet) {
    
    
            addMapper(mapperClass);
        }
    }
    
    public <T> void addMapper(Class<T> type) {
    
    
        // 判断，必须是接口。
        if (type.isInterface()) {
    
    
            // 已经添加过，则抛出 BindingException 异常
            if (hasMapper(type)) {
    
    
                throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
            }
            boolean loadCompleted = false;
            try {
    
    
                // 添加到 knownMappers 中
                knownMappers.put(type, new MapperProxyFactory<>(type));
                // It's 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 won't try.
                // 解析 Mapper 的注解配置
                MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
                parser.parse();
                // 标记加载完成
                loadCompleted = true;
            } finally {
    
    
                // 若加载未完成，从 knownMappers 中移除
                if (!loadCompleted) {
    
    
                    knownMappers.remove(type);
                }
            }
        }
    }    

  上面的knowMappers.put(type， new MapperProxyFactory<>(type))，为该类生成一个动态代理工厂放入到Map集合中，key为该类Class，value为该类动态代理工厂。

2、解析mapper标签（分别有resource、class、url三种属性）

	// 如果是 package 标签，则扫描该包
    if ("package".equals(child.getName())) {
    
    
        // 获得包名
        String mapperPackage = child.getStringAttribute("name");
        // 添加到 configuration 中
        configuration.addMappers(mapperPackage);
    // 如果是 mapper 标签，
    } else {
    
    
        // 获得 resource、url、class 属性
        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);
            // 获得 resource 的 InputStream 对象
            InputStream inputStream = Resources.getResourceAsStream(resource);
            // 创建 XMLMapperBuilder 对象
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            // 执行解析
            mapperParser.parse();
            // 使用完全限定资源定位符（URL）
        } else if (resource == null && url != null && mapperClass == null) {
    
    
            ErrorContext.instance().resource(url);
            // 获得 url 的 InputStream 对象
            InputStream inputStream = Resources.getUrlAsStream(url);
            // 创建 XMLMapperBuilder 对象
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
            // 执行解析
            mapperParser.parse();
            // 使用映射器接口实现类的完全限定类名
        } else if (resource == null && url == null && mapperClass != null) {
    
    
            // 获得 Mapper 接口
            Class<?> mapperInterface = Resources.classForName(mapperClass);
            // 添加到 configuration 中
            configuration.addMapper(mapperInterface);
        } else {
    
    
            throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
        }
    }

（1）如果是使用映射器接口实现类的完全限定类名，即使用class的话，和package标签类似，调用configuration.addMapper()接口将该类添加到MapperRegistry的knownMappers中。

（2）如果是/使用相对于类路径的资源引用（resource）或使用完全限定资源定位符（URL），则交由XMLMapperBuilder解析Mapper配置文件，调用的是XMLMapperBuilder的parse()方法。

在 XMLMapperBuilder 中的处理：

	/**
     * 解析***Mapper.xml配置文件
     */
    public void parse() {
    
    
        // 判断当前 Mapper 是否已经加载过
        if (!configuration.isResourceLoaded(resource)) {
    
    
            // 解析 `<mapper />` 节点
            configurationElement(parser.evalNode("/mapper"));
            // 标记该 Mapper 已经加载过
            configuration.addLoadedResource(resource);
            // 绑定 Mapper
            bindMapperForNamespace();
        }

        // 解析待定的 <resultMap /> 节点
        parsePendingResultMaps();
        // 解析待定的 <cache-ref /> 节点
        parsePendingCacheRefs();
        // 解析待定的 SQL 语句的节点
        parsePendingStatements();
    }

	// 解析 `<mapper />` 节点
    private void configurationElement(XNode context) {
    
    
        try {
    
    
            // 获得 namespace 属性
            String namespace = context.getStringAttribute("namespace");
            if (namespace == null || namespace.equals("")) {
    
    
                throw new BuilderException("Mapper's namespace cannot be empty");
            }
            // 设置 namespace 属性
            builderAssistant.setCurrentNamespace(namespace);
            // 解析 <cache-ref /> 节点
            cacheRefElement(context.evalNode("cache-ref"));
            // 解析 <cache /> 节点
            cacheElement(context.evalNode("cache"));
            // 已废弃！老式风格的参数映射。内联参数是首选,这个元素可能在将来被移除，这里不会记录。
            parameterMapElement(context.evalNodes("/mapper/parameterMap"));
            // 解析 <resultMap /> 节点们
            resultMapElements(context.evalNodes("/mapper/resultMap"));
            // 解析 <sql /> 节点们
            sqlElement(context.evalNodes("/mapper/sql"));
            // 解析 <select /> <insert /> <update /> <delete /> 节点们
            buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
        } catch (Exception e) {
    
    
            throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
        }
    }

	// 解析 <select /> <insert /> <update /> <delete /> 节点们
    private void buildStatementFromContext(List<XNode> list) {
    
    
        if (configuration.getDatabaseId() != null) {
    
    
            buildStatementFromContext(list, configuration.getDatabaseId());
        }
        buildStatementFromContext(list, null);
        // 上面两块代码，可以简写成 buildStatementFromContext(list, configuration.getDatabaseId());
    }

    private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
    
    
        //遍历 <select /> <insert /> <update /> <delete /> 节点们
        for (XNode context : list) {
    
    
            // 创建 XMLStatementBuilder 对象，执行解析
            final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
            try {
    
    
                statementParser.parseStatementNode();
            } catch (IncompleteElementException e) {
    
    
                // 解析失败，添加到 configuration 中
                configuration.addIncompleteStatement(statementParser);
            }
        }
    }

在XMLStatementBuilder的parseStatementNode()中具体执行select、insert、update、delete节点的解析

/**
     * 执行解析
     */
    public void parseStatementNode() {
    
    
        // 获得 id 属性，编号。
        String id = context.getStringAttribute("id");
        // 获得 databaseId ， 判断 databaseId 是否匹配
        String databaseId = context.getStringAttribute("databaseId");
        if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
    
    
            return;
        }

        // 获得各种属性
        Integer fetchSize = context.getIntAttribute("fetchSize");
        Integer timeout = context.getIntAttribute("timeout");
        String parameterMap = context.getStringAttribute("parameterMap");
        String parameterType = context.getStringAttribute("parameterType");
        Class<?> parameterTypeClass = resolveClass(parameterType);
        String resultMap = context.getStringAttribute("resultMap");
        String resultType = context.getStringAttribute("resultType");
        String lang = context.getStringAttribute("lang");

        // 获得 lang 对应的 LanguageDriver 对象
        LanguageDriver langDriver = getLanguageDriver(lang);

        // 获得 resultType 对应的类
        Class<?> resultTypeClass = resolveClass(resultType);
        // 获得 resultSet 对应的枚举值
        String resultSetType = context.getStringAttribute("resultSetType");
        ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
        // 获得 statementType 对应的枚举值
        StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));

        // 获得 SQL 对应的 SqlCommandType 枚举值
        String nodeName = context.getNode().getNodeName();
        SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
        // 获得各种属性
        boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
        boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
        boolean useCache = context.getBooleanAttribute("useCache", isSelect);
        boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);

        // Include Fragments before parsing
        // 创建 XMLIncludeTransformer 对象，并替换 <include /> 标签相关的内容
        XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
        includeParser.applyIncludes(context.getNode());

        // Parse selectKey after includes and remove them.
        // 解析 <selectKey /> 标签
        processSelectKeyNodes(id, parameterTypeClass, langDriver);

        // Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
        // 创建 SqlSource 对象
        SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
        // 获得 KeyGenerator 对象
        String resultSets = context.getStringAttribute("resultSets");
        String keyProperty = context.getStringAttribute("keyProperty");
        String keyColumn = context.getStringAttribute("keyColumn");
        KeyGenerator keyGenerator;
        // 优先，从 configuration 中获得 KeyGenerator 对象。如果存在，意味着是 <selectKey /> 标签配置的
        String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
        keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
        if (configuration.hasKeyGenerator(keyStatementId)) {
    
    
            keyGenerator = configuration.getKeyGenerator(keyStatementId);
        // 其次，根据标签属性的情况，判断是否使用对应的 Jdbc3KeyGenerator 或者 NoKeyGenerator 对象
        } else {
    
    
            keyGenerator = context.getBooleanAttribute("useGeneratedKeys", // 优先，基于 useGeneratedKeys 属性判断
                    configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType)) // 其次，基于全局的 useGeneratedKeys 配置 + 是否为插入语句类型
                    ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
        }

        // 创建 MappedStatement 对象
        builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
                fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
                resultSetTypeEnum, flushCache, useCache, resultOrdered,
                keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
    }

到此对xml配置文件的解析就结束了，回到步骤1.2中调用的重载build方法

	// 2.调用的重载方法
    public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    
    
        try {
    
    
            // 创建 XMLConfigBuilder, XMLConfigBuilder是专门解析mybatis的配置文件的类
            XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
            // 执行 XML 解析
            // 创建 DefaultSqlSessionFactory 对象
            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.
            }
        }
    }

  上面的配置文件解析都是parser.parse()方法中的操作，解析完后返回一个Configuration对象，然后调用build(Configuration configuration)方法创建DefaultSqlSessionFactory对象

   /**
     * 创建 DefaultSqlSessionFactory 对象
     *
     * @param config Configuration 对象
     * @return DefaultSqlSessionFactory 对象
     */
    public SqlSessionFactory build(Configuration config) {
    
    
        return new DefaultSqlSessionFactory(config); //构建者设计模式
    }

2.4. 生产DefaultSqlsession实例对象

	// 3. 生产DefaultSqlsession实例对象   设置了事务不自动提交  完成了executor对象的创建
    SqlSession sqlSession = sqlSessionFactory.openSession();

首先看一下创建SqlSession对象的整个流程
先简单介绍SqlSession ：

• SqlSession是一个接口，它有两个实现类：DefaultSqlSession (默认)和SqlSessionManager (弃用，不做介绍)
• SqlSession是MyBatis中用于和数据库交互的顶层类，通常将它与ThreadLocal绑定，一个会话使用一 个SqlSession，并且在使用完毕后需要close
• SqlSession中的两个最重要的参数，configuration与初始化时的相同，Executor为执行器

Executor：Executor也是一个接口，他有三个常用的实现类：

• BatchExecutor (重用语句并执行批量更新)
• ReuseExecutor (重用预处理语句 prepared statements)
• SimpleExecutor (普通的执行器，默认)

DefaultSqlsession

public class DefaultSqlSession implements SqlSession {
    
    

    private final Configuration configuration;
    private final Executor executor;

    /**
     * 是否自动提交事务
     */
    private final boolean autoCommit;
    /**
     * 是否发生数据变更
     */
    private boolean dirty;
    /**
     * Cursor 数组
     */
    private List<Cursor<?>> cursorList;

    public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
    
    
        this.configuration = configuration;
        this.executor = executor;
        this.dirty = false;
        this.autoCommit = autoCommit;
    }

    public DefaultSqlSession(Configuration configuration, Executor executor) {
    
    
        this(configuration, executor, false);
    }
}

DefaultSqlSessionFactory

public class DefaultSqlSessionFactory implements SqlSessionFactory {
    
    

    private final Configuration configuration;

    public DefaultSqlSessionFactory(Configuration configuration) {
    
    
        this.configuration = configuration;
    }

    // 6. 进入openSession方法
    @Override
    public SqlSession openSession() {
    
    
        // getDefaultExecutorType()传递的是SimpleExecutor
        return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
    }

    // 7. 进入openSessionFromDataSource。
    // ExecutorType 为Executor的类型，TransactionIsolationLevel为事务隔离级别，autoCommit是否开启事务
    // openSession的多个重载方法可以指定获得的SeqSession的Executor类型和事务的处理
    private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    
    
        Transaction tx = null;
        try {
    
    
            // 获得 Environment 对象
            final Environment environment = configuration.getEnvironment();
            // 创建 Transaction 对象
            final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
            tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
            // 创建 Executor 对象
            final Executor executor = configuration.newExecutor(tx, execType);
            // 创建 DefaultSqlSession 对象
            return new DefaultSqlSession(configuration, executor, autoCommit);
        } catch (Exception e) {
    
    
            // 如果发生异常，则关闭 Transaction 对象
            closeTransaction(tx); // may have fetched a connection so lets call close()
            throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
        } finally {
    
    
            ErrorContext.instance().reset();
        }
    }
}

  DefaultSqlSessionFactory的openSession()方法调用openSessionFromDataSource创建DefaultSqlSession对象，注意该方法中传递的第一个参数是执行器的类型，configuration.getDefaultExecutorType()传递的是SimpleExecutor，所以DefaultSqlSession中使用的Executor是SimpleExecutor。

  调用configuration.newExecutor(Transaction transaction, ExecutorType executorType)创建Executor，使用的Executor是SimpleExecutor。

   /**
     * 创建 Executor 对象
     *
     * @param transaction 事务对象
     * @param executorType 执行器类型
     * @return Executor 对象
     */
    public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    
    
        // 获得执行器类型
        executorType = executorType == null ? defaultExecutorType : executorType; // 使用默认
        executorType = executorType == null ? ExecutorType.SIMPLE : executorType; // 使用 ExecutorType.SIMPLE
        // 创建对应实现的 Executor 对象
        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);
        }
        // 如果开启缓存，创建 CachingExecutor 对象，进行包装
        if (cacheEnabled) {
    
    
            executor = new CachingExecutor(executor);
        }
        // 应用插件
        executor = (Executor) interceptorChain.pluginAll(executor);
        return executor;
    }

2.5. 执行SQL

	// 4.(1)根据statementid来从Configuration中map集合中获取到了指定的MappedStatement对象
    // (2)将查询任务委派了executor执行器
    List<Object> objects = sqlSession.selectList("namespace.id");

调用DefaultSqlSession中的selectList()方法

	// 进入selectList方法，多个重载方法
    @Override
    public <E> List<E> selectList(String statement) {
    
    
        return this.selectList(statement, null);
    }

    @Override
    public <E> List<E> selectList(String statement, Object parameter) {
    
    
        return this.selectList(statement, parameter, RowBounds.DEFAULT);
    }

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

• 第一步通过statement即（namespace+id）获取MapperStatement对象
• 第二步执行查询：executor.query()，使用的是SimpleExecutor执行器。

2.6. 源码剖析-Executor

继续源码中的步骤，进入executor.query()，此方法在SimpleExecutor的父类BaseExecutor中实现

BaseExecutor类

    @Override
    public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    
    
        // 根据传入的参数动态获得SQL语句，最后返回用BoundSql对象表示
        BoundSql boundSql = ms.getBoundSql(parameter);
        // 为本次查询创建缓存的Key
        CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
        // 查询
        return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
    }

    @SuppressWarnings("unchecked")
    @Override
    public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    
    
        ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
        // 已经关闭，则抛出 ExecutorException 异常
        if (closed) {
    
    
            throw new ExecutorException("Executor was closed.");
        }
        // 清空本地缓存，如果 queryStack 为零，并且要求清空本地缓存。
        if (queryStack == 0 && ms.isFlushCacheRequired()) {
    
    
            clearLocalCache();
        }
        List<E> list;
        try {
    
    
            // queryStack + 1
            queryStack++;
            // 从一级缓存中，获取查询结果
            list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
            // 获取到，则进行处理
            if (list != null) {
    
    
                handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
            // 获得不到，则从数据库中查询
            } else {
    
    
                list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
            }
        } finally {
    
    
            // queryStack - 1
            queryStack--;
        }
        if (queryStack == 0) {
    
    
            // 执行延迟加载
            for (DeferredLoad deferredLoad : deferredLoads) {
    
    
                deferredLoad.load();
            }
            // issue #601
            // 清空 deferredLoads
            deferredLoads.clear();
            // 如果缓存级别是 LocalCacheScope.STATEMENT ，则进行清理
            if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
    
    
                // issue #482
                clearLocalCache();
            }
        }
        return list;
    }

	// 从数据库中读取操作
    private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    
    
        List<E> list;
        // 在缓存中，添加占位对象。此处的占位符，和延迟加载有关，可见 `DeferredLoad#canLoad()` 方法
        localCache.putObject(key, EXECUTION_PLACEHOLDER);
        try {
    
    
            // 执行读操作
            list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
        } finally {
    
    
            // 从缓存中，移除占位对象
            localCache.removeObject(key);
        }
        // 添加到缓存中
        localCache.putObject(key, list);
        // 暂时忽略，存储过程相关
        if (ms.getStatementType() == StatementType.CALLABLE) {
    
    
            localOutputParameterCache.putObject(key, parameter);
        }
        return list;
    }

SimpleExecutor中实现父类的doQuery抽象方法

	@Override
    public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    
    
        Statement stmt = null;
        try {
    
    
            Configuration configuration = ms.getConfiguration();
            // 传入参数创建StatementHanlder对象来执行查询
            StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
            // 创建jdbc中的statement对象
            stmt = prepareStatement(handler, ms.getStatementLog());
            // 执行 StatementHandler  ，进行读操作
            return handler.query(stmt, resultHandler);
        } finally {
    
    
            // 关闭 StatementHandler 对象
            closeStatement(stmt);
        }
    }

	// 创建jdbc中的statement对象
    private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    
    
        Statement stmt;
        // 获得 Connection 对象
        Connection connection = getConnection(statementLog);
        // 创建 Statement 或 PrepareStatement 对象
        stmt = handler.prepare(connection, transaction.getTimeout());
        // 设置 SQL 上的参数，例如 PrepareStatement 对象上的占位符
        handler.parameterize(stmt);
        return stmt;
    }

  上述的Executor.query()方法几经转折，最后会创建一个StatementHandler对象，然后将必要的参数传递给StatementHandler，使用StatementHandler来完成对数据库的查询，最终返回List结果集。

从上面的代码中我们可以看出，Executor的功能和作用是：

• 根据传递的参数，完成SQL语句的动态解析，生成BoundSql对象，供StatementHandler使用；
• 为查询创建缓存，以提高性能
• 创建JDBC的Statement连接对象，传递给StatementHandler对象，返回List查询结果。

BoundSql，主要注意其中的两个属性sql、parameterMappings

public class BoundSql {
    
    

    /**
     * SQL语句，进行 #{ } 和 ${ } 替换完毕之后的结果sql, 注意每个 #{ }替换完之后就是一个 ?
     */
    private final String sql;
    /**
     * ParameterMapping数组，这里的parameterMappings列表参数里的item个数,
     * 以及每个item的属性名称等等, 都是和上面的sql中的 ? 完全一一对应的.
     */
    private final List<ParameterMapping> parameterMappings;
    /**
     * 参数对象
     */
    private final Object parameterObject;
    /**
     * 附加的参数集合
     */
    private final Map<String, Object> additionalParameters;
    /**
     * {@link #additionalParameters} 的 MetaObject 对象
     */
    private final MetaObject metaParameters;

	public BoundSql(Configuration configuration, String sql, List<ParameterMapping> parameterMappings, Object parameterObject) {
    
    
        this.sql = sql;
        this.parameterMappings = parameterMappings;
        this.parameterObject = parameterObject;
        this.additionalParameters = new HashMap<>();
        this.metaParameters = configuration.newMetaObject(additionalParameters);
    }

    public String getSql() {
    
    
        return sql;
    }

    public List<ParameterMapping> getParameterMappings() {
    
    
        return parameterMappings;
    }

    public Object getParameterObject() {
    
    
        return parameterObject;
    }

    public boolean hasAdditionalParameter(String name) {
    
    
        String paramName = new PropertyTokenizer(name).getName();
        return additionalParameters.containsKey(paramName);
    }

    public void setAdditionalParameter(String name, Object value) {
    
    
        metaParameters.setValue(name, value);
    }

    public Object getAdditionalParameter(String name) {
    
    
        return metaParameters.getValue(name);
    }
}

2.7. 源码剖析-StatementHandler

2.7.1. StatementHandler对象主要完成两个工作：

• 对于JDBC的PreparedStatement类型的对象，创建的过程中，我们使用的是SQL语句字符串会包含若干个？占位符，我们其后再对占位符进行设值。
  StatementHandler通过parameterize(statement)方法对 Statement 进行设值；
• StatementHandler 通过 List query(Statement statement, ResultHandler resultHandler)方法来完成执行Statement，和将Statement对象返回的resultSet封装成List；

2.7.2. 使用ParameterHandler为statement设值

  进入到PreparedStatementHandler的 parameterize(statement) 方法的实现，该方法中调用ParameterHandler的setParameters()方法实现参数的设置。

PreparedStatementHandler

	@Override
    public void parameterize(Statement statement) throws SQLException {
    
    
        // 使用ParameterHandler对象来完成对Statement的设值
        parameterHandler.setParameters((PreparedStatement) statement);
    }

DefaultParameterHandler

   /** 
     * ParameterHandler 类的 setParameters(PreparedStatement ps) 实现对某一个Statement进行设置参数
     */
    @Override
    public void setParameters(PreparedStatement ps) {
    
    
        ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
        // 遍历 ParameterMapping 数组
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        if (parameterMappings != null) {
    
    
            for (int i = 0; i < parameterMappings.size(); i++) {
    
    
                // 获得 ParameterMapping 对象
                ParameterMapping parameterMapping = parameterMappings.get(i);
                if (parameterMapping.getMode() != ParameterMode.OUT) {
    
    
                    // 获得值
                    Object value;
                    String propertyName = parameterMapping.getProperty();
                    if (boundSql.hasAdditionalParameter(propertyName)) {
    
     // issue #448 ask first for additional params
                        value = boundSql.getAdditionalParameter(propertyName);
                    } else if (parameterObject == null) {
    
    
                        value = null;
                    } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
    
    
                        value = parameterObject;
                    } else {
    
    
                        MetaObject metaObject = configuration.newMetaObject(parameterObject);
                        value = metaObject.getValue(propertyName);
                    }
                    // 获得 typeHandler、jdbcType 属性
                    TypeHandler typeHandler = parameterMapping.getTypeHandler();
                    JdbcType jdbcType = parameterMapping.getJdbcType();
                    if (value == null && jdbcType == null) {
    
    
                        jdbcType = configuration.getJdbcTypeForNull();
                    }
                    // 设置 ? 占位符的参数
                    try {
    
    
                        typeHandler.setParameter(ps, i + 1, value, jdbcType);
                    } catch (TypeException | SQLException e) {
    
    
                        throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
                    }
                }
            }
        }
    }

  从上述的代码可以看到，StatementHandler的parameterize(Statement)方法调用了ParameterHandler的setParameters(statement)方法，ParameterHandler的setParameters(Statement )方法负责根据我们输入的参数，对statement对象的 ?占位符处进行赋值。

2.7.3. 执行StatementHandler的query()方法，进行读操作

进入到StatementHandler 的 List query(Statement statement, ResultHandler resultHandler)方法的实现：

	@Override
    public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    
    
        PreparedStatement ps = (PreparedStatement) statement;
        // 执行查询
        ps.execute();
        // 处理返回结果
        return resultSetHandler.handleResultSets(ps);
    }

  从上述代码我们可以看出，StatementHandler 的List query()方法首先调用statement的execute()方法执行数据库查询，再交由ResultSetHandler进行结果集封装。

  ResultSetHandler 的 handleResultSets()方法会将 Statement 语句执行后生成的 resultSet结果集转换成List结果集。

DefaultResultSetHandler

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

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

        int resultSetCount = 0;
        // 获得首个 ResultSet 对象，并封装成 ResultSetWrapper 对象
        ResultSetWrapper rsw = getFirstResultSet(stmt);

        // 获得 ResultMap 数组
        // 在不考虑存储过程的多 ResultSet 的情况，普通的查询，实际就一个 ResultSet ，也就是说，resultMaps 就一个元素。
        List<ResultMap> resultMaps = mappedStatement.getResultMaps();
        int resultMapCount = resultMaps.size();
        validateResultMapsCount(rsw, resultMapCount); // 校验
        while (rsw != null && resultMapCount > resultSetCount) {
    
    
            // 获得 ResultMap 对象
            ResultMap resultMap = resultMaps.get(resultSetCount);
            // 处理 ResultSet ，将结果添加到 multipleResults 中
            handleResultSet(rsw, resultMap, multipleResults, null);
            // 获得下一个 ResultSet 对象，并封装成 ResultSetWrapper 对象
            rsw = getNextResultSet(stmt);
            // 清理
            cleanUpAfterHandlingResultSet();
            // resultSetCount ++
            resultSetCount++;
        }

        // 因为 `mappedStatement.resultSets` 只在存储过程中使用，本系列暂时不考虑，忽略即可
        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++;
            }
        }

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

	private List<Object> collapseSingleResultList(List<Object> multipleResults) {
    
    
        return multipleResults.size() == 1 ? (List<Object>) multipleResults.get(0) : multipleResults;
    }

3. Mapper代理方式

public class MybatisTest {
    
    

    /**
     * mapper代理方式
     */
    public void test2() throws IOException {
    
    
        InputStream inputStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = factory.openSession();

        // 使用JDK动态代理对mapper接口产生代理对象
        IUserMapper mapper = sqlSession.getMapper(IUserMapper.class);

        //代理对象调用接口中的任意方法，执行的都是动态代理中的invoke方法
        List<Object> allUser = mapper.findAllUser();
    }
    
}

思考一个问题，通常的Mapper接口我们都没有实现的方法却可以使用，是为什么呢？答案很简单动态代理

  开始之前介绍一下MyBatis初始化时对接口的处理：MapperRegistry是Configuration中的一个属性，它内部维护一个HashMap用于存放mapper接口的工厂类，每个接口对应一个工厂类。mappers中可以配置接口的包路径，或者某个具体的接口类。

	<mappers>
        <mapper class="com.cyd.mapper.UserMapper"/>
        <package name="com.cyd.mapper"/>
    </mappers>

  当解析mappers标签时，它会判断解析到的是mapper配置文件时，会再将对应配置文件中的增删改查标签封装成MappedStatement对象，存入Configuration容器的mappedStatements中。(上文介绍了)当判断解析到接口时，会建此接口对应的MapperProxyFactory对象，存入HashMap中，key=接口的字节码对象，value =此接口对应的MapperProxyFactory对象。

3.1. 源码剖析-getmapper()

进入 sqlSession.getMapper(UserMapper.class )中

DefaultSqlSession

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

Configuration

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

MapperRegistry

	public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    
    
        // 获得 MapperProxyFactory 对象
        final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
        // 不存在，则抛出 BindingException 异常
        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

	// MapperProxyFactory类中的newInstance方法
    public T newInstance(SqlSession sqlSession) {
    
    
        // 创建了JDK动态代理的invocationHandler接口的实现类mapperProxy
        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);
    }

MapperProxy

public class MapperProxy<T> implements InvocationHandler, Serializable {
    
    

    private static final long serialVersionUID = -6424540398559729838L;

    /**
     * SqlSession 对象
     */
    private final SqlSession sqlSession;
    
    /**
     * Mapper 接口
     */
    private final Class<T> mapperInterface;
    
    /**
     * 方法与 MapperMethod 的映射
     *
     * 从 {@link MapperProxyFactory#methodCache} 传递过来
     */
    private final Map<Method, MapperMethod> methodCache;

    // 构造，传入了SqlSession，说明每个session中的代理对象的不同的！
    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 {
    
    
            // 如果是 Object 定义的方法，直接调用
            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);
        }
        // 获得 MapperMethod 对象
        final MapperMethod mapperMethod = cachedMapperMethod(method);
        // 重点在这：MapperMethod最终调用了执行的方法
        return mapperMethod.execute(sqlSession, args);
    }
    
   	//省略部分源码

}

3.2. 源码剖析-invoke()

  在动态代理返回了示例后，我们就可以直接调用mapper类中的方法了，但代理对象调用方法，执行是在MapperProxy中的invoke方法中MapperProxy，该类实现InvocationHandler接口，并重写invoke()方法。

	@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 if (isDefaultMethod(method)) {
    
    
                return invokeDefaultMethod(proxy, method, args);
            }
        } catch (Throwable t) {
    
    
            throw ExceptionUtil.unwrapThrowable(t);
        }
        // 获得 MapperMethod 对象
        final MapperMethod mapperMethod = cachedMapperMethod(method);
        // 重点在这：MapperMethod最终调用了执行的方法
        return mapperMethod.execute(sqlSession, args);
    }

MapperMethod

	public Object execute(SqlSession sqlSession, Object[] args) {
    
    
        Object result;
        //判断mapper中的方法类型，最终调用的还是SqlSession中的方法
        switch (command.getType()) {
    
    
            case INSERT: {
    
    
                // 转换参数
                Object param = method.convertArgsToSqlCommandParam(args);
                // 执行 INSERT 操作
                // 转换 rowCount
                result = rowCountResult(sqlSession.insert(command.getName(), param));
                break;
            }
            case UPDATE: {
    
    
                // 转换参数
                Object param = method.convertArgsToSqlCommandParam(args);
                // 转换 rowCount
                result = rowCountResult(sqlSession.update(command.getName(), param));
                break;
            }
            case DELETE: {
    
    
                // 转换参数
                Object param = method.convertArgsToSqlCommandParam(args);
                // 转换 rowCount
                result = rowCountResult(sqlSession.delete(command.getName(), param));
                break;
            }
            case SELECT:
                // 无返回，并且有 ResultHandler 方法参数，则将查询的结果，提交给 ResultHandler 进行处理
                if (method.returnsVoid() && method.hasResultHandler()) {
    
    
                    executeWithResultHandler(sqlSession, args);
                    result = null;
                // 执行查询，返回列表
                } else if (method.returnsMany()) {
    
    
                    result = executeForMany(sqlSession, args);
                // 执行查询，返回 Map
                } else if (method.returnsMap()) {
    
    
                    result = executeForMap(sqlSession, args);
                // 执行查询，返回 Cursor
                } else if (method.returnsCursor()) {
    
    
                    result = executeForCursor(sqlSession, args);
                // 执行查询，返回单个对象
                } else {
    
    
                    // 转换参数
                    Object param = method.convertArgsToSqlCommandParam(args);
                    // 查询单条
                    result = sqlSession.selectOne(command.getName(), param);
                    if (method.returnsOptional() &&
                            (result == null || !method.getReturnType().equals(result.getClass()))) {
    
    
                        result = Optional.ofNullable(result);
                    }
                }
                break;
            case FLUSH:
                result = sqlSession.flushStatements();
                break;
            default:
                throw new BindingException("Unknown execution method for: " + command.getName());
        }
        // 返回结果为 null ，并且返回类型为基本类型，则抛出 BindingException 异常
        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;
    }