深入浅出MyBatis技术原理与实战-学习-MyBatis 初识(一)

        MyBatis 本是 Apache 的一个开源项目 iBatis，2010年这个项目由 Apache Software Foundation 迁移到 Google Code，并改变为 MyBatis 。
        MyBatis 是支持普通 SQL查询，存储过程和高级映射的优秀持久层框架，MyBatis消除了几乎所有的 JDBC 代码和参数的手工设置以及结果集的检索，MyBatis 使用简单的 XML或注解用于配置和原始映射，将接口和 JAVA的 POJOs(Plain Old Java Objects，普通的 Java 对象)映射成数据库中的记录。

MyBatis的基本构成

        认识往往是从表面现象到内存本质的一个探索过程，所以对于 MyBatis 的掌握，我们从认识"表面现象", MyBatis 的基本构成开始，我们先了解一下 MyBatis 的核心组件 。

• SqlSessionFactoryBuilder(构造器)：它会根据配置信息或者代码来生成 SqlSessionFactory(工厂接口)。
• SqlSessionFactory：依靠工厂来生成 SqlSession（会话）。
• SqlSession：是一个既可以发送 SQL 去执行并返回结果，也可以获取 Mapper 的接口。
• SQL Mapper：它是 MyBatis 新设置的组件 ，它是一个由 Java 接口 XML 文件（或注解）构成，需要给出对应的 SQL和映射规则，它负责发送 SQL 去执行，并返回结果。
  用一张图表达它们之间的关联：如下图
  
          这里我们不需要明白 MyBatis 的组件内容，先了解它们之间的先后顺序，流程和基本功能，其他的后面的博客来说明。

构建SqlSessionFactory

        每个 MyBatis 的应用都以 SqlSessionFactory 的实例为中心的，SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得，但是读者们需要注意SqlSessionFactory 是一个工厂接口而不是实现类。它的任务是创建 SqlSession，SqlSession 类似于一个 JDBC 的 Connection对象，MyBatis 提供了两种模式去创建 SqlSessionFactory： 一种是 XML 配置方式，这是笔者推荐的方式，另一种是代码的方式，能够使用配置文件的时候，我们需要尽量的使用配置文件，这样一方面可以以免硬编码，一方面方便日后配置人员修改，避免重复编译代码。
        这里我们的 Configuration 的类全限定名 org.apache.ibatis.session.Configuration，它在 MyBatis 中将以一个 Configuration 类对象的形式存在，而这个对象将存在于整个 MyBatis 应用的生命周期中，以便重复读取和运用，在内存中的数据是计算机系统中读取速度电子书的，我们可以解析一次配置的 XML 文件保存到 Configuration 类对象，方便我们从这个对象读取配置信息，性能高，单例占用空间小，基本不占用存储空间，而且可以反复的使用，Configuration 类对象保存着我们的配置在 MyBatis 的信息，在 MyBatis 中提供了两个 SqlSessionFactory 的实现类，DefaultSqlSessionFactory 和 SqlSessionManager，不过 SqlSessionManager 目前还没有使用，MyBatis中目前使用的是 DefaultSqlSessionFactory。
        让我们来看看他们之前的关系图。

MyBatis独立使用

        尽管我们接触的更多的是 MyBatis和 Spring的整合使用，但是 MyBatis 有它的独立使用方法，了解其独立使用的方法套路对分析 Spring 整合 MyBatis 非常的有帮助，因为 Spring 无非就是将这些功能进行封装，以简化我们的开发流程，MyBatis 独立的使用包括以下的几个步骤。
先创建数据库表吧
CREATE TABLE lz_user (
         id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
        is_delete tinyint(2) DEFAULT ‘0’,
        gmt_create datetime DEFAULT CURRENT_TIMESTAMP COMMENT ‘创建时间’,
        gmt_modified datetime DEFAULT CURRENT_TIMESTAMP,
        username varchar(32) DEFAULT NULL COMMENT ‘用户名’,
        password varchar(64) DEFAULT NULL COMMENT ‘密码’,
        real_name varchar(64) DEFAULT NULL,
        manager_id int(11) DEFAULT NULL COMMENT ‘管理员id’,
PRIMARY KEY (id)
) ENGINE=InnoDB AUTO_INCREMENT=462 DEFAULT CHARSET=utf8mb4 COMMENT=‘公益口罩’;
1 .建立 User对象
用于对数据库中对数据的映射，使程序员更加关注对 Java 类的使用，现是不是对数据库的操作。

@Data
public class User {
    private Long id;
    private Integer isDelete;
    private Date gmtCreate;
    private Date gmtModified;
    private String username;
    private String password;
    private String realName;
    private Long managerId;
    //必需要有无参的构造方法，不然，根据 UserMapper.xml 中的配置，在查询数据库时，将不能反射构造出 User 实例
}

2.建立 UserMapper
数据库操作映射文件，也就是我们常常说的 DAO,用于映射数据库操作。可以通过配置文件指定方法对应的 SQL指定。

public interface UserMapper {
    void insertUser(User user);
    User getUser(Long id);
}

3 .建立配置文件mybatis-config.xml
        配置文件主要用于配置程序中可变性高的设置，一个偏大的程序一定会存在经常会变的变量，如果每次变化都需要改变源码那会是非常糟糕的设计，所以，我们看到的各种各样的框架或者应用时都免不了要配置配置文件，MyBatis 中的配置文件主要封装在configuration 中，配置文件的基本结构如下图所示。

• configuration: 根元素。
• properties:定义配置外在化。
• settings: 一些全局的配置
• typeAliases:为一些类定义别名
• typeHandlers:定义类型处理，也就是定义 Java类型也数据库中数据类型之间的转换关系。
• objectFactory :用于指定结果集对象的实例是如何创建的。
• environments:环境。
• environment: 配置 MyBatis 的环境。
• transactionManager:事务管理器。
• dataSource:数据源。
• mappers:指定映射文件或映射类。
          读者如果对上面的各个配置具体的使用方法感兴趣，可以进一步查阅相关的资料，这里只是举一个最简单的实例以方便读者快速回顾 MyBatis

使用 XML 方式构建

        这里我们配置一个简易的 XML,包含了获取数据库连接实例的数据源(DataSource)，决定事务范围和控制方式的事务管理器（TransactionManager） 和映射器(SQL Mapper)，XML 配置文件的内容后面会详细的探讨，这里先给一个简单的示例，如下代码清单所示。

对上面的配置做一下说明

• 这里配置了一个别名 User，它代表com.spring_1_100.test_61_70.test70_mybatis_alone.User，这样我们就可以在 MyBatis 上下文 配置中引用它了。
• 我们配置了环境内容，它默认使用 id 是 development 配置，包含以下两方面内容
  (1)采用 JDBC 的事务管理模式。
  (2)数据库的连接信息。

4. 建立映射器
           对应的 MyBatis 全局配置中的 mappers 配置属性，主要用于建立对应的数据库操作接口的 SQL映射，MyBatis 会被这里设定的 SQL与对应的 JAVA 接口相关联，以保证在 MyBatis 中调用接口的时候会到数据库中执行相应的SQL来简化开发 。
           这里引入一个 XML，它的作用是提供SQL 和 SQL对 POJO 的映射规则定义，它包含了映射器里面的信息，MyBatis 将解析这个 XML,来为我们生成映射器。
           现在我们用代码的方式来创建 SqlSessionFactory
           String resource = “mybatis-config.xml”;
           InputStream inputstream = Resource.getResourceAsStream(resource);
           SqlSessionFactory sqlSessionFactory = null;
           sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
           这里我们创建一个 XML 文件输入流，用 SqlSessionFactoryBuilder 读取 XML 的信息来创建 SqlSessionFactory 的对象。
           MyBatis 的解析程序会将 mybatis-config.xml 文件配置的信息解析到 Configuration类对象里面，然后利用 SqlSessionFactoryBuilder 读取这个对象为我们创建 SqlSessionFactory。

映射器

映射器是由 Java 接口和 XML 文件(或注解)共同组成，它的作用如下

• 定义参数类型
• 描述缓存
• 描述 SQL 语句
• 定义查询结果和 POJO 的映射关系。

一个映射器的实现方式有两种，一种是通过 XML 文件方式实现，读者应该刻我们在 mybatis-config.xml文件中己经描述了一个 XML 文件，它是用来生成 Mapper 的，另外一种就是通过代码方式实现，在 Configuration里面注册 Mapper接口（当然里面还需要我们写入 Java注解）,当然它也是 MyBatis 的核心内容，同时也是最为复杂的，这两种方式都可以实现我们的需求，不过笔者强烈建义使用 XML 文件配置方式，理由如下：

• Java 注解是受限制的，功能较少，而 MyBatis 的 Mapper 内容相当多，而且相当复杂，功能很强大，使用 XML 文件的方式可以带来更加灵活的空间，显示出 MyBatis 功能的强大和灵活。
• 如果你的 SQL 很复杂，条件也很多，尤其在存在动态 SQL 的时候，写在 Java 文件里可读性较差，增加了维护成本。

XML 文件配置方式实现 Mapper
        使用 XML文件配置是 MyBatis 实现 Mapper 的首先方式，它由一个 Java 接口和一个 XML 文件构成，让我们看看它是如何实现的。
第一步，给出 Java 接口，如下代码

public interface UserMapper {

   void insertUser(User user);
   
   User getUser(Long id);
}

这里我们定义一个接口，它有一个方法 getUser()，通过用户 id 查找用户对象。
第二步：给出一个映射XML 文件，代码如下：

    
    	
       INSERT INTO lz_user (username, password, real_name, manager_id) VALUES (#{username},#{password},#{realName},#{managerId})
    
	
    
        select * from lz_user where id=#{id}
    

描述一下上面 XML 文件是做了什么?

• 这个文件是我们在配置文件 mybatis-config.xml 中配置的，所以 MyBatis 会读取这个配置文件，生成映射器。
• 定义了一个命名空间为com.spring_1_100.test_61_70.test70_mybatis_alone.UserMapper的 SQL Mapper，这个命名空间和我们定义的接口全限定名是一致的。
• 用一个 select 元素定义一个查询SQL,id 为 getUser，和我们接口的方法一致，而 parameterType 则表示我们传递给这条 SQL 是一个 SQL 语句还是一个 java.lang.Long 类型的参数，而 resultType 则定义我们需要的返回数据类型，这里的 User，而 User 是我们注册com.spring_1_100.test_61_70.test70_mybatis_alone.User的别名。

5.建立测试类MyBatisUtil.java
        至此，我们己经完成了 MyBatis 的建立过程，接下来的工作就是对之前的所有工作进行测试，以方便直接查看 MyBatis 为我们提供的效果。

public class MyBatisUtil {

    private final static SqlSessionFactory sqlSEssionFactory;

    static {
        String resource = "spring_1_100/config_61_70/mybatis-config.xml";
        Reader reader = null;
        try {
            reader = Resources.getResourceAsReader(resource);
        } catch (IOException e) {
            e.printStackTrace();
        }
        sqlSEssionFactory = new SqlSessionFactoryBuilder().build(reader);

    }
    public static SqlSessionFactory getSqlSEssionFactory(){
        return sqlSEssionFactory;
    }
}

        解释一下代码的含义，正如生命周期一样，我们希望 SqlSessionFactory 对于一个数据库而言只有一个实例，我们希望它是单例，现在我们学习一下代码如何实现的。
        某个对象在应用中承担唯一责任的时候 使用单例模式，而本例中 SqlSessionFactory 的唯一责任就是为我们创建 SqlSession，所以采用单例模式的好处在于可以重复使用这唯一对象，而对象在内存中读取和运行速度都比较快，同时节约内存，我们的办法往往是把构造方法私有化，并给一个静态方法，让其返回唯一单例，而在多线程环境初始化单例，往往需要加线程锁以避免类对象被多次初始化，正如本例一样。

开始测试：

static SqlSessionFactory sqlSessionFactory = null;
static {
    sqlSessionFactory = MyBatisUtil.getSqlSEssionFactory();
}

创建 SqlSession
        SqlSession是一个接口类，它类似于你们公司前台的美女客服，它扮演着门面的作用，而真正干活的是 Executor接口，你可以认为它是公司的工程师，假设我是客户找你们公司干活，我只需要告诉前台的美女客服(SqlSession)我要什么信息（参数），要做什么东西，过段时间，她会将结果给我，在这个过程中，作为用户的我所关心的信息。

• 要给美女客服(SqlSession) 什么信息（功能和参数）
• 美女客服会返回什么结果（Result）

        而我不关心工程师（Executor） 是怎样为我工作的，只要前台告诉工程师(Executor) 工程师就知道如何为我工作了，这个步骤对我而言是个黑箱操作。
        在 MyBatis中 SqlSession 接口的实现类有两个，分别是 DefaultSqlSession和 SqlSessionManager，这里我们暂时不讨论Executor 接口及其涉及的其他类，只关心 SqlSession的用法就好了，我们构建了 SqlSessionFactory，然后生成了 MyBatis 的门面接口 SqlSession，SqlSession 接口类似于一个 JDBC 中的 Connection接口对象，我们需要保证每次用完正常关闭它，所以正确的做法是关闭 SqlSession接口的代码写在 finally 语句中保证每次都会关闭 SqlSession，让连接资源归还给数据库，如果我们不及时关闭资源，数据库连接资源将会被耗尽，系统很快会因为数据库资源的匮乏而瘫痪，让我们来看看下面的代码。

@Test
public void testGetUser() throws Exception {
	//定义 SqlSession
	SqlSession sqlSession =null;
	try{
		//打开 SqlSession会话
    	sqlSession= sqlSessionFactory.openSession();
    	//执行相关代码
    	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    	User user = userMapper.getUser(456l);
    	System.out.println(JSON.toJSONString(user));
    }cacth(Exception ex){
    	System.err.println(ex.getMessage());
   	}finally{
    	//在 finally 语句中确保资源被删除顺利并关闭
    	if(sqlSession !=null){
    		sqlSession.close();
		}
	}  	
}

测试结果：

        这样 SqlSession被我们创建出来，在 finally 语句中我们保证了它的合理关闭，让连接资源归还给数据库连接池，以便后续使用。
SqlSession的用途主要有两种。

1. 获取映射器，让映射器通过命名空间和方法急中生智我找到对应的 SQL，发送给数据库执行返回结果。
2. 直接通过命名信息执行 SQL

        这里在数据库设定的 id 自增策略，所以插入的数据会直接在数据库中赋值，当执行测试如果数据库中的表不为空，那么在表中会出现一条我们插入的数据，并会在查询时将此数据查出 。

使用代码方式构建 ？

        除了使用 XML 配置方式创建代码外，也可以使用 Java编码来实现，不过并不推荐这种方式。因为修改环境的时候，我们不得不重新编译代码。这样不利于维护。
        不过，我们还是想研究一下其是如何实现的，和上面的 XML 方式一样，我们也需要配置别名，数据库环境和映射器，MyBatis 己经提供好了对象的类和方法，我们只要熟悉它们的使用即可，首先构建 Configuration 类对象，然后，往对象里注册我们构建的 SqlSessionFactory 所需要的信息便可。

public static SqlSessionFactory getSqlSessionFactory() {
    //构建数据库连接池
    PooledDataSource dataSource = new PooledDataSource();
    dataSource.setDriver("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql://172.16.157.238:3306/pple_test?characterEncoding=utf-8");
    dataSource.setUsername("ldd_biz");
    dataSource.setPassword("Hello1234");
    //构建数据库事务处理方式
    TransactionFactory txFactory = new JdbcTransactionFactory();
    //创建数据库运行环境
    Environment environment = new Environment("development", txFactory, dataSource);
    //构建Configuration 对象
    Configuration configuration = new Configuration(environment);
    //注册一个 MyBatis上下文别名
    configuration.getTypeAliasRegistry().registerAlias("User", User.class);
    //加入一个映射器
    configuration.addMapper(UserMapper.class);
    //使用 SqlSessionFactoryBuilder 构建SqlSessionFactory
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);
    return sqlSessionFactory;
}

@Test
public void test1() {
    SqlSession sqlSession = getSqlSessionFactory().openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    System.out.println("=================================");
    User user = userMapper.getUser(456l);
    System.out.println(JSON.toJSONString(user));
}

让我们说明一下上面的代码做了什么？

• 初始化一个数据库连接池
• 定义了 JDBC的数据库事务管理方式。
• 用数据库连接池和事务管理方式创建了一个数据库运行环境，并命名为 development。
• 创建了一个 Configuration类对象，并把数据库运行环境注册给它。
• 注册一个名为 User 的别名
• 加入一个映射器。
• 用 SqlSessionFactoryBuilder 通过 Configuration对象创建 SqlSessionFactory。

上面需要注意的是 Mapper 和 Mapper.xml需要放到同一个包下，不然报错，显然用代码的方式和使用 XML只是换了个方法实现而已，其本质并无不同，采用代码方式一般是在需要加入自己的特性的时候才会用到，例如：数据源配置的信息要求是加密的，我们需要把它们转化出来，在大部分的情况下，不建义你使用这种方式来创建 MyBatis 的 SqlSessionFactory。
        这样 SqlSession 就被我们创建出来了，在 finally 语句中我们保证了它的合理关闭，让连接资源归还给数据库连接池，以便后续使用。
SqlSession的用途主要有两种。

• 获取映射器，让映射器通过命名空间和方法名称找到对应的 SQL，发送给数据库执行后返回结果。
• 直接通过命名信息去执行 SQL 返回结果，这是 iBatis 版本留下的方式，在 SqlSession 层我们可以通过 update,insert，select,delete 等方法，带上 SQL的 id 操作 XML中配置好的 SQL，从而完成我们的工作，与此同时它也支持事务，通过 commit，rollback 方法提交或者回滚事务。

关于这两种用途我们会在映射器里进行讨论，这两种用途优劣我们也会进行讨论研究。

Java 注解的方式实现 Mapper

        Java 注解方式实现映射方法不难，只需要在接口中使用 Java注解，注入 SQL 即可，我们不妨看看这个接口，代码如下：
public interface UserMapper {
        @Select("select * from lz_user where id=#{id}")
        User getUser(Long id);
}
这里我们需要解析一下，我们使用@Select 注解，注入了和 XML一样的select元素，这样的 MyBatis 就会读取这条 SQL，并将参数的 id 递进 SQL，同样使用了别名，这样MyBatis 会为我们自动映射，得到我们需要的 User 对象，这里看起来比 XML 要简单，但是现实中我们遇到了 SQL 远比这个例子更加复杂，如果多个表的关联，多个查询条件，级联，条件分支等，显然这条 SQL 就会复杂得多，所以不建义使用注解方式，代码如下：

        select m.perms from sys_user_role ur
                LEFT JOIN sys_role_menu rm on ur.role_id = rm.role_id
                LEFT JOIN sys_menu m on rm.menu_id = m.menu_id
        where ur.user_id = #{userId}

如果写到代码中，可读性太差。

一些疑问

        在 MyBatis 中保留着 iBatis，通过命名空间+SQL id 的方式发送 SQL并返回数据的形式，而不需要去获取映射器，以下代码。

SqlSession sqlSession = sqlSessionFactory.openSession();
        List aa = sqlSession.selectList("com.spring_101_200.test_131_140.test_136_mybatis_saferowboundsenabled.UserMapper.selectUserBill",
                null, new RowBounds(0, 5));
        System.out.println(JSON.toJSONString(aa));

        如果 MyBatis 上下文只有一个 SQL的 getUser，那我们代码还可以简写：

SqlSession sqlSession = sqlSessionFactory.openSession();
        List aa = sqlSession.selectList("selectUserBill",null, new RowBounds(0, 5));
        System.out.println(JSON.toJSONString(aa));

        注意，当 SQL 的 id 有两个以上的 getUser的时候，第二种省略法办就会失败，系统异常就会提示你写出“命名空间+SQL id”的全路径模式可以，其实它们大同小异，都是发送 SQL 并返回需要的结果，而 MyBatis 一样会根据"com.spring_101_200.test_131_140.test_136_mybatis_saferowboundsenabled.UserMapper.selectUserBill"找到需要执行的接口和方法，进而找到对应的 SQL，传递参数到 SQL 中，返回数据，完成一次查询 。
        那么困惑我们需要 Mapper吗？答案是肯定的，Mapper 是一个接口，相对而言它可以进一步屏蔽 SqlSession 对象，使得他具有更强的业务可读性，因此笔者强烈建义采用映射器方式编写代码，其好处主要有以下两点。

• sqlSession.selectOne 是功能性代码，长长的字符串比较晦涩难懂，不包含业务逻辑的含义，不符合面向对象的规范，而对于 userMapper.getUser()这样才是符合面向对象的规范编程的。也更加符合业务的逻辑。
• 使用 Mapper方式，IDE 可以检查Java 语法，避免不必要的错误。

        我们使用仅仅是接口和一个 XML 文件(或者注解)去实现 Mapper，Java 接口不是实现类，对于 Java 语言不熟悉的读者肯定会感到十分疑惑，一个没有实现类的接口怎么能够运行呢？其实它需要运用到 Java 语言的动态代理去实现，而实现 Java 语言动态代理的方式有多种，这里我们还需要集中于它的用法，所以可以这样理解，我们会在 MyBatis上下文描述这个接口，而 MyBatis 会为这个接口生成代理对象，代理对象会根据"接口全路径+方法名" 去匹配，找到对应的 XML 文件或者注解去完成所需要的任务，返回给我们需要的结果。
        关于SqlSession和 Mapper 是 MyBatis 的核心内容和难点，它内部远远没有我们目前看到的那样简单，只是在入门阶段我们暂时不需要去讨论它的实现方式，知道它的作用和用法就可以了。

生命周期

        我们只讨论了 MyBatis主要组件和它的基本用法。而现实中想要写出高效的程序只掌握MyBatis的基本用法是远远不够的，我们还需要掌握它们的生命周期，这是十分重要的，尤其是在 Web 应用，Socket 连接池等多线程场景中，如果我们不了解MyBatis 组件的生命周期可能带来的并发问题，这节的任务是正常理解 SqlSessionFactoryBuilder，SqlSessionFactory，SqlSession和 Mapper 的生命周期，并且重构上面的代码，使 MyBatis 能够高效的工作，这对于 MyBatis应用的正确性和高性能极其重要，我们必需要掌握它们。

        上面的示例非常简单，但是源码是如何实现的呢？注意：因为我想创建一套MyBatis源码解析博客，因此今天的博客只是对 mybatis源码解析的开篇，源码解析部分较少。MyBatis使用特性居多。希望对mybatis使用的基本特性有一定了解以后，再来对源码深度分析。

SqlSessionFactoryBuilder

        SqlSessionFactoryBuilder 是利用 XML 或者 Java 编码获得资源来构建SqlSessionFactory的，通过它可以构建多个 SessionFactory，它的作用是构建器，一旦我们构建了 SqlSessionFactory，它的作用就完结，失去了存在的意义，这时我们就应该毫不犹豫的废弃它，将它回收，所以他的生命周期只在于方法的局部，它的作用就是生成 SqlSessionFactory 对象。

public SqlSessionFactory build(Reader reader) {
  return build(reader, null, null);
}

public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
  try {
    XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
    //构建DefaultSqlSessionFactory对象，将创建好的 configuration 对象传入
    return build(parser.parse());
  } catch (Exception e) {
    throw ExceptionFactory.wrapException("Error building SqlSession.", e);
  } finally {
    ErrorContext.instance().reset();
    try {
      reader.close();
    } catch (IOException e) {
    }
  }
}

SqlSessionFactory

        SqlSessionFactory 的作用是创建 SqlSession，而 SqlSession 就是一个会话，相当于 JDBC中的 Connection对象，每次应用程序需要访问数据库，我们就需要通过 SqlSessionFactory 创建 SqlSession，所以 SqlSessionFactory 应该在 MyBatis 应用的整个生命周期中，而如果我们多次创建同一个数据库的 SqlSessionFactory,则每次创建 SqlSessionFactory 会打开更多的数据库连接（connection） 资源，那么连接资源就会很快被耗尽，因此 SqlSessionFactory的责任是唯一的，它责任就是创建 SqlSession，所以我们果断采用单例模式，如果我们采用多例，那就它对数据库的连接消耗是很大的，不利于我们统一管理。所以，正确的做法应该是使得每一个数据库只对应一个 SqlSessionFactory，管理好数据库资源的分配，避免过多的 Connection被消耗。

public SqlSessionFactory build(Configuration config) {
  //构建DefaultSqlSessionFactory对象，保存 configuration
  return new DefaultSqlSessionFactory(config);
}

SqlSession

         SqlSession 是一个会话，相当于 JDBC 的一个Connection对象，它的生命周期应该是在请求数据库处理事务的过程中，它是一个线程不安全的对象，在涉及多线程的时候我们就需要特别小心，操作数据库需要注意隔离级别，数据库锁等高级特性，此外，每次创建的 SqlSession 都必需及时关闭它，它长期存在会便数据库连接池的活动资源减少，对系统的影响很大，正如前面的代码一样，我们往往通过 finally 语句块保证我们正确的关闭 SqlSession，它存活于一个应用请求和操作中，可以执行多条 SQL 语句，保证事务的一致性。

Mapper

        Mapper 是一个接口，而没有任何实现类，它的作用是发送 SQL，然后返回我们需要的结果，或者执行 SQL 从而修改数据库的数据，因此，它应该是一个 SqlSession事务方法之内，是一个方法级别的东西，它就如同 JDBC 中的和条 SQL 语句的执行，它最大范围和 SqlSession是相同的，尽管我们想一直保存着 Mapper，但是你会发现它很难控制，所以尽量在一个 SqlSession事务的方法中使用它们。然后废弃掉。
        有了上面的叙述，我们己经清楚了 MyBatis组件的生命周期，如下图所示

解析configuration

XMLConfigBuilder

public Configuration parse() {
  if (parsed) {
    throw new BuilderException("Each XMLConfigBuilder can only be used once.");
  }
  parsed = true;
  //解析mybatis-config.xml的根元素configuration
  parseConfiguration(parser.evalNode("/configuration"));
  return configuration;
}

下面将进入到真正的解析，将对mybatis-config.xml的根元素configuration进行解析。

XMLConfigBuilder

private void parseConfiguration(XNode root) {
  try {
  	//定义配置外在化
    propertiesElement(root.evalNode("properties")); //issue #117 read properties first
    //为一些类定义别名
    typeAliasesElement(root.evalNode("typeAliases"));
    //对某种方法进行拦截调用的机制，被称为plugin插件，下面对插件解析
    pluginElement(root.evalNode("plugins"));
    //解析注册对象工厂
    objectFactoryElement(root.evalNode("objectFactory"));
    //解析objectWrapperFactory标签
    objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
    //MyBatis settings 标签相关配置
    settingsElement(root.evalNode("settings"));
    //根据配置取线上线下环境
    environmentsElement(root.evalNode("environments")); // read it after objectFactory and objectWrapperFactory issue #631
    //设置数据库 mysql 或Oracle 等数据配置
    databaseIdProviderElement(root.evalNode("databaseIdProvider"));
    //mybatis对对象数据设置或取出作类型转换
    typeHandlerElement(root.evalNode("typeHandlers"));
    //注册 MyBatis 下的所有 mapper
    mapperElement(root.evalNode("mappers"));
  } catch (Exception e) {
    throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
  }
}

properties标签使用：

       在实际工作中，我们常常遇到这样的问题：系统是由运维人员去配置的，生产数据库的用户名密码对开发者而言是保密的，而且为了安全，运维人员要求对配置文件中的数据库用户名和密码进行加密，这样，我们的配置文件中往往配置的是加密过后的数据库信息，而且无法通过加密字符串去连接数据库，这个时候可以通过编码的形式来满足我们的场景。
       下面假设 db.properies 文件中的用户名和密码两个属性都是加密字符串，这个时候我们需要生成 SqlSessionFactory 之前将它转化为明文，而系统己经提供了解密方法 decode(str)，让我们来看看如何使用代码的方式完成 SqlSessionFactory 的创建。

public class MyBatisUtil1 {
    private final static SqlSessionFactory sqlSEssionFactory ;

    static {
        String resource = "spring_101_200/config_121_130/spring125_mybatis_properties/mybatis-config.xml";
        InputStream cfgStream = null;
        Reader cfgReader = null;
        InputStream proStream = null;
        Reader proReader = null;
        Properties properties = null;
        try {
            //读取配置文件流
            cfgStream = Resources.getResourceAsStream(resource);
            cfgReader = new InputStreamReader(cfgStream);
            //读取属性文件
            proStream = Resources.getResourceAsStream("spring_101_200/config_121_130/spring125_mybatis_properties/db.properties");
            proReader = new InputStreamReader(proStream);
            properties = new Properties();
            properties.load(proReader);
            //解密为明文
            properties.setProperty("username",decode(properties.getProperty("db.username")));
            properties.setProperty("password",decode(properties.getProperty("db.pwd")));
        } catch (Exception e) {
            e.printStackTrace();
        }
        sqlSEssionFactory = new SqlSessionFactoryBuilder().build(cfgReader,properties);
    }
    //在这里实现解密操作
    public static String decode(String value){
        return value;
    }
    
    public static SqlSessionFactory getSqlSEssionFactory(){
        return sqlSEssionFactory;
    }
}

这样我们就完全可以在 db.properties 配置密文，满足对系统安全的要求。
       MyBatis支持3种配置方式可能同时出现，并且属性还会重复配置，这3种方式是存在优先级，MyBatis 将按照下面的顺序来加载。

1. 在 propertiess 元素内指定属性首先被读取。
2. 根据 properties 元素中的 resource 属性读取类路径下属性文件，或者根据 url 属性指定路径读取属性文件，并覆盖己读取同名属性。
3. 读取作为言法参数传递属性，并覆盖己读取同名的属性。
   因此，通过方法参数传递的属性具有最高优先级，resource/url属性中指定配置文件次之，最低优先级是 properties 属性中指定属性，因此，实际操作中我们需要注意以下3点。

• 不要使用混合方式，这样会便利管理混乱 。
• 首先的方式是使用 properties 文件
• 如果我们需要对其进行加密或者其他加工以满足特殊的要求，不妨按示例的方法处理，这样做的好处是使得配置来自于同一个配置文件，就不容易产生没有必要的歧义，也为日后统一管理提供了方便。

       首先，我们来对properties进行解析，在解析 properties之前，我们先来了解一下，properties 是怎样用的。
我们先添加db.properties属性文件，在文件中添加内容如下：
        db.driver=com.mysql.jdbc.Driver
        db.url=jdbc:mysql://localhost:3306/pple_test?characterEncoding=utf-8
        db.username=username
        db.pwd=password
修改mybatis-config.xml配置文件，如下：

    
    
        
        
        
        
    
    
        
    

    
        
            
            
                ${db.driver}"/>
                ${db.url}">
                ${db.username}">
                ${db.pwd}">
            
        
    

    
        
    

        其中，红色部分就是与之前的mybatis-config.xml不相同的部分，从表现，我们可以看出，我们不再需要在 xml配置文件中添加具体各项配置信息，而将配置信息提取到db.properties中，具体的配置项不再是零散的分布在各个 xml 文件中，只需要是统一的配置信息放到db.properties,方便开发人员维护与管理。
        我们来看看源码是如何解析db.properties配置文件的。

properties标签解析：

XMLConfigBuilder.java

private void propertiesElement(XNode context) throws Exception {
  if (context != null) {
  	//将所有子节点的 name,value 转化为Properties
    Properties defaults = context.getChildrenAsProperties();
    //从节点中获取String 属性的resource
    String resource = context.getStringAttribute("resource");
    //从节点中获取String属性的 url
    String url = context.getStringAttribute("url");
    //如果 resource 属性不为空并且 url 属性也不为空，抛出异常
    if (resource != null && url != null) {
      throw new BuilderException("The properties element cannot specify both a URL and a resource based property file reference.  Please specify one or the other.");
    }
    if (resource != null) {
      //将所有的resource资源文件所配置的内容转化为Properties并存入defaults中
      defaults.putAll(Resources.getResourceAsProperties(resource));
    } else if (url != null) {
      //将所有url的资源转化为Properties并存入defaults中
      defaults.putAll(Resources.getUrlAsProperties(url));
    }
    Properties vars = configuration.getVariables();
    if (vars != null) {
      defaults.putAll(vars);
    }
    //解析器中存入defaults
    parser.setVariables(defaults);
    //configuration设置变量defaults
    configuration.setVariables(defaults);
  }
}

typeAliases标签使用

        别名typeAliases是一个指代名称，因为我们遇到类全限定名过长，所以希望用一个简短的名称去指代它，而这个名称可以是在 MyBatis上下文 中使用，别名 MyBatis 里面分为系统定义别名和自定义别名两类，注意在 MyBatis 中别名是不分大小写的，一个 typeAliases 的实例是在解析配置文件时生成的，然后长期保存在 Configuration对象中，当我们使用它时，再把它拿出来，这样就没有必要运行的时候再次生成它的实例了。

系统定义的别名

        MyBatis系统定义一些经常使用的别名，例如，数值，字符串，日期和集合等，我们可以在 MyBatis 中使用别名（支持数组类型的只要加"[]"即可以使用，比如 Date 数组别名可以 date[]代替）,MyBatis 己经在系统定义了 type Aliases

别名	映射的类型	支持数组
_byte	byte	是
_long	long	是
_short	short	是
_int	int	是
_integer	int	是
_double	double	是
_float	float	是
_boolean	boolean	是
string	String	否
byte	Byte	是
long	Long	是
short	Short	是
int	Integer	是
integer	Integer	是
double	Double	是
float	Float	是
boolean	Boolean	是
date	Date	是
decimal	BigDecimal	是
bigdecimal	BigDecimal	是
object	Object	是
map	Map	否
hashMap	HashMap	否
list	List	否
arrayList	ArrayList	否
collection	Collection	否
iterator	Iterator	否
ResultSet	ResultSet	否

自定义别名

        系统所定义的别名往往是不够用的，因为不同的应用有着不同的需要，所以 MyBatis 允许自定义别名
User” parameterType=“java.lang.Long”>
        select * from lz_user where id=#{id}

        我们看到，我们没有返回具体的类型，这里具体的类型是指包名+类名，User 对象，可以是 com.aaa.User,也可以是 com.bbb.User,因此，我们可以定义typeAliases,来确定 User 对象具体代表的是哪个类，达到一次配置，到处使用。接下来，我们分析typeAliases的解析。

typeAliases标签解析

XMLConfigBuilder.java

private void typeAliasesElement(XNode parent) {
  if (parent != null) {
    for (XNode child : parent.getChildren()) {
      if ("package".equals(child.getName())) {
      	//如果子节点是 package，则获取 name 的值
        String typeAliasPackage = child.getStringAttribute("name");
        //注册当前包下的所有的类
        configuration.getTypeAliasRegistry().registerAliases(typeAliasPackage);
      } else {
        String alias = child.getStringAttribute("alias");
        String type = child.getStringAttribute("type");
        //配置如下：
        try {
          Class clazz = Resources.classForName(type);
          if (alias == null) {
          	//注册所配置的类，别名或者简单类名或者是类所配置注解Alias的值
            typeAliasRegistry.registerAlias(clazz);
          } else {
          	//如果别名和类型都不为空，注册别名和类型
            typeAliasRegistry.registerAlias(alias, clazz);
          }
        } catch (ClassNotFoundException e) {
          throw new BuilderException("Error registering typeAlias for '" + alias + "'. Cause: " + e, e);
        }
      }
    }
  }
}

TypeAliasRegistry.java

public void registerAlias(Class type) {
  //获取类的简单名称
  String alias = type.getSimpleName();
  //获取Alias注解
  Alias aliasAnnotation = type.getAnnotation(Alias.class);
  if (aliasAnnotation != null) {
  	//如果配置了@Alias注解，则取其值作为别名
    alias = aliasAnnotation.value();
  } 
  registerAlias(alias, type);
}

        从上面代码分析得知，在注册别名过程中，最不能少的就是类信息，当前类配置分两种情况，如下：

• typeAlias：获取配置文件中属性alias和type，如果alias为空，分为两种情况，如果类配置了@Alias注解，则取其值作为别名，如果没有配置@Alias注解，则取类的简单类名作为别名。
• package：则取其 name属性，获取包下的所有的类。再根据类型注册。注册过程和typeAlias配置一样，先获取注解@Alias的值，如果没有，则取简单类名作为默认值。

        如果 POJO 过多时，我们可以使用自动扫描的形式自定义别名。如需要配置多个包，则像如下配置即可，多个包不能在 name 中以逗号分号隔开，只能写多个 package 标签

        
        

plugins标签使用

接下来，我们继续来分析plugins的解析，在分析之前，我们来看一个业务需求，我们想在第次执行 sql 时，打印sql 语句。这就需要用到我们的plugin的使用了
1.我们在mybatis-config.xml中加入配置文件

2.新建DataScopeInterceptor类

@Slf4j
@Intercepts({@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class})})
public class DataScopeInterceptor extends SqlParserHandler implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        StatementHandler statementHandler = (StatementHandler) PluginUtils.realTarget(invocation.getTarget());
        MetaObject metaObject = SystemMetaObject.forObject(statementHandler);
        this.sqlParser(metaObject);
        BoundSql boundSql = (BoundSql) metaObject.getValue("delegate.boundSql");
        String originalSql = boundSql.getSql();
        //打印出原始sql
        System.out.println(originalSql);
        Object result = invocation.proceed();
        return result;
    }

    /**
     * 生成拦截对象的代理
     */
    @Override
    public Object plugin(Object target) {
        if (target instanceof StatementHandler) {
            return Plugin.wrap(target, this);
        }
        return target;
    }
    /**
     * @param properties mybatis配置的属性
     */
    @Override
    public void setProperties(Properties properties) {
    }
}

运行结果：

plugin标签解析

下面开始对plugin标签进行解析

private void pluginElement(XNode parent) throws Exception {
  if (parent != null) {
    for (XNode child : parent.getChildren()) {
      //获取plugin的interceptor属性
      String interceptor = child.getStringAttribute("interceptor");
      //获取所有的子节点中的 name，value 属性，封装成properties
      Properties properties = child.getChildrenAsProperties();
      //创建拦截器
      Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
      //调用拦截器的setProperties方法
      interceptorInstance.setProperties(properties);
      //将拦截器加到拦截器链interceptorChain中
      configuration.addInterceptor(interceptorInstance);
    }
  }
}

objectFactory标签使用：

        在 MyBatis 中，当其 sql 映射配置文件中的 sql 语句所得到的查询结果，被动态映射到 resultType 或其他处理结果集的参数配置对应的 Java 类型，其中就有 JavaBean 等封装类。而 objectFactory 对象工厂就是用来创建实体对象的类。
        在 MyBatis 中，默认的 objectFactory 要做的就是实例化查询结果对应的目标类，有两种方式可以将查询结果的值映射到对应的目标类，一种是通过目标类的默认构造方法，另外一种就是通过目标类的有参构造方法。
        有时候在 new 一个新对象（构造方法或者有参构造方法），在得到对象之前需要处理一些逻辑，或者在执行该类的有参构造方法时，在传入参数之前，要对参数进行一些处理，这时就可以创建自己的 objectFactory 来加载该类型的对象。
        当 MyBatis在构建一个结果返回的时候，都会用 ObjectFactory(对象工厂) 去构建 POJO，在 MyBatis 中可以定制自己的对象工厂，一般来说我们使用默认的 ObjectFactory 即可，MyBatis 的默认 ObjectFactory 是由 org.apache.ibatis.reflection.factory.DefaultObjectFactory 来提供服务的，在大部分场景下，我们都不用修改，如果要定制特定的工厂则需要进行配置。
        首先在mybatis-config.xml配置文件中加入

在User 对象中加入 init 方法

User

public void init(){
	//测试对象创建时，是否被工厂方法调用
    System.out.println("user init ");
}

        我们这里配置了一个对象工厂UserObjectFactory，对它的要求是实现 ObjectFactory接口，实际上 DefaultObjectFactory 己经实现了 ObjectFactory 的接口，我们可以通过继承 DefaultObjectFactory 来编程 。

UserObjectFactory

public class UserObjectFactory extends DefaultObjectFactory {
    public  T create(Class type) {
        return super.create(type);
    }
    
    //DefaultObjectFactory的create(Class type)方法也会调用此方法，所以只需要在此方法中添加逻辑即可
    public  T create(Class type, List> constructorArgTypes, List