作者：小傅哥

博客：https://bugstack.cn

沉淀、分享、成长，让自己和他人都能有所收获！

一、前言

Mybatis 最核心的原理也是它最便于使用的体现，为什么这说？

因为我们在使用 Mybatis 的时候，只需要定义一个不需要写实现类的接口，就能通过注解或者配置SQL语句的方式，对数据库进行 CRUD 操作。

那么这是怎么做到的呢，其中有一点非常重要，就是在 Spring 中可以把你的代理对象交给 Spring 容器，这个代理对象就是可以当做是 DAO 接口的具体实现类，而这个被代理的实现类就可以完成对数据库的一个操作，也就是这个封装过程被称为 ORM 框架。

说了基本的流程，我们来做点测试，让大家可以动手操作起来！学知识，一定是上手，才能得到！你可以通过以下源码仓库进行练习

源码：https://github.com/fuzhengwei/CodeGuide/wiki

二、把Bean塞到Spring容器，分几步

  • 关于Bean注册的技术场景，在我们日常用到的技术框架中，MyBatis 是最为常见的。通过在使用 MyBatis 时都只是定义一个接口不需要写实现类，但是这个接口却可以和配置的 SQL 语句关联，执行相应的数据库操作时可以返回对应的结果。那么这个接口与数据库的操作就用到的 Bean 的代理和注册。
  • 我们都知道类的调用是不能直接调用没有实现的接口的，所以需要通过代理的方式给接口生成对应的实现类。接下来再通过把代理类放到 Spring 的 FactoryBean 的实现中，最后再把这个 FactoryBean 实现类注册到 Spring 容器。那么现在你的代理类就已经被注册到 Spring 容器了，接下来就可以通过注解的方式注入到属性中。

按照这个实现方式，我们来操作一下，看看一个 Bean 的注册过程在代码中是如何实现的。

1. 定义接口

  1. public interface IUserDao {
  3.     String queryUserInfo();
  5. }
  • 先定义一个类似 DAO 的接口，基本这样的接口在使用 MyBatis 时还是非常常见的。后面我们会对这个接口做代理和注册。

2. 类代理实现

  1. ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
  2. Class<?>[] classes = {IUserDao.class};    
  4. InvocationHandler handler = (proxy, method, args) -> "你被代理了 " + method.getName();
  5. IUserDao userDao = (IUserDao) Proxy.newProxyInstance(classLoader, classes, handler); 
  7. String res = userDao.queryUserInfo();
  8. logger.info("测试结果：{}", res);
  • Java 本身的代理方式使用起来还是比较简单的，用法也很固定。
  • InvocationHandler 是个接口类，它对应的实现内容就是代理对象的具体实现。
  • 最后就是把代理交给 Proxy 创建代理对象，Proxy.newProxyInstance。

3. 实现Bean工厂

  1. public class ProxyBeanFactory implements FactoryBean {
  3.     @Override
  4.     public Object getObject() throws Exception {
  6.         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
  7.         Class[] classes = {IUserDao.class};
  8.         InvocationHandler handler = (proxy, method, args) -> "你被代理了 " + method.getName();
  10.         return Proxy.newProxyInstance(classLoader, classes, handler);
  11.     }
  13.     @Override
  14.     public Class<?> getObjectType() {
  15.         return IUserDao.class;
  16.     } 
  18. }
  • FactoryBean 在 spring 起到着二当家的地位，它将近有70多个小弟(实现它的接口定义)，那么它有三个方法；

    • T getObject() throws Exception; 返回bean实例对象
    • Class<?> getObjectType(); 返回实例类类型
    • boolean isSingleton(); 判断是否单例，单例会放到Spring容器中单实例缓存池中
  • 在这里我们把上面使用Java代理的对象放到了 getObject() 方法中，那么现在再从 Spring 中获取到的对象，就是我们的代理对象了。

4. Bean 注册

  1. public class RegisterBeanFactory implements BeanDefinitionRegistryPostProcessor {
  3.     @Override
  4.     public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
  6.         GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
  7.         beanDefinition.setBeanClass(ProxyBeanFactory.class);
  9.         BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(beanDefinition, "userDao");
  10.         BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
  11.     }
  13. }

在 Spring 的 Bean 管理中，所有的 Bean 最终都会被注册到类 DefaultListableBeanFactory 中，以上这部分代码主要的内容包括：

  • 实现 BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry方法，获取 Bean 注册对象。
  • 定义 Bean，GenericBeanDefinition，这里主要设置了我们的代理类工厂。
  • 创建 Bean 定义处理类，BeanDefinitionHolder，这里需要的主要参数；定义 Bean 和名称 setBeanClass(ProxyBeanFactory.class)。
  • 最后将我们自己的bean注册到spring容器中去，registry.registerBeanDefinition()

5. 测试验证

在上面我们已经把自定义代理的 Bean 注册到了 Spring 容器中，接下来我们来测试下这个代理的 Bean 被如何调用。

1. 定义 spring-config.xml

  1. <bean id="userDao" class="org.itstack.interview.bean.RegisterBeanFactory"/>
  • 这里我们把 RegisterBeanFactory 配置到 spring 的 xml 配置中，便于启动时加载。

2. 单元测试

  1. @Test
  2. public void test_IUserDao() {
  3.     BeanFactory beanFactory = new ClassPathXmlApplicationContext("spring-config.xml");
  4.     IUserDao userDao = beanFactory.getBean("userDao", IUserDao.class);
  5.     String res = userDao.queryUserInfo();
  6.     logger.info("测试结果：{}", res);
  7. }

测试结果

  1. 22:53:14.759 [main] DEBUG o.s.c.e.PropertySourcesPropertyResolver - Could not find key 'spring.liveBeansView.mbeanDomain' in any property source
  2. 22:53:14.760 [main] DEBUG o.s.b.f.s.DefaultListableBeanFactory - Returning cached instance of singleton bean 'userDao'
  3. 22:53:14.796 [main] INFO  org.itstack.interview.test.ApiTest - 测试结果：你被代理了 queryUserInfo
  5. Process finished with exit code 0
  • 从测试结果可以看到，我们已经可以通过注入到Spring的代理Bean对象，实现我们的预期结果。
  • 其实这个过程也是很多框架中用到的方式，尤其是在一些中间件开发，类似的 ORM 框架都需要使用到。

三、手写个Mybatis

扩展上一篇源码分析工程；itstack-demo-mybatis，增加 like 包，模仿 Mybatis 工程。完整规程下载 https://github.com/fuzhengwei/CodeGuide/wiki

  1. itstack-demo-mybatis
  2. └── src
  3.     ├── main
  4.     │   ├── java
  5.     │   │   └── org.itstack.demo
  6.     │   │       ├── dao
  7.     │   │       │	├── ISchool.java
  8.     │   │       │	└── IUserDao.java
  9.     │   │       ├── like
  10.     │   │       │	├── Configuration.java
  11.     │   │       │	├── DefaultSqlSession.java
  12.     │   │       │	├── DefaultSqlSessionFactory.java
  13.     │   │       │	├── Resources.java
  14.     │   │       │	├── SqlSession.java
  15.     │   │       │	├── SqlSessionFactory.java
  16.     │   │       │	├── SqlSessionFactoryBuilder.java
  17.     │   │       │	└── SqlSessionFactoryBuilder.java
  18.     │   │       └── interfaces
  19.     │   │         	├── School.java
  20.     │   │        	└── User.java
  21.     │   ├── resources
  22.     │   │   ├── mapper
  23.     │   │   │   ├── School_Mapper.xml
  24.     │   │   │   └── User_Mapper.xml
  25.     │   │   ├── props
  26.     │   │   │   └── jdbc.properties
  27.     │   │   ├── spring
  28.     │   │   │   ├── mybatis-config-datasource.xml
  29.     │   │   │   └── spring-config-datasource.xml
  30.     │   │   ├── logback.xml
  31.     │   │   ├── mybatis-config.xml
  32.     │   │   └── spring-config.xml
  33.     │   └── webapp
  34.     │       └── WEB-INF
  35.     └── test
  36.          └── java
  37.              └── org.itstack.demo.test
  38.                  ├── ApiLikeTest.java
  39.                  ├── MybatisApiTest.java
  40.                  └── SpringApiTest.java

关于整个 Demo 版本，并不是把所有 Mybatis 全部实现一遍，而是拨丝抽茧将最核心的内容展示给你，从使用上你会感受一模一样，但是实现类已经全部被替换，核心类包括；

  • Configuration
  • DefaultSqlSession
  • DefaultSqlSessionFactory
  • Resources
  • SqlSession
  • SqlSessionFactory
  • SqlSessionFactoryBuilder
  • XNode

1. 先测试下整个DemoJdbc框架

ApiLikeTest.test_queryUserInfoById()

  1. @Test
  2. public void test_queryUserInfoById() {
  3.     String resource = "spring/mybatis-config-datasource.xml";
  4.     Reader reader;
  5.     try {
  6.         reader = Resources.getResourceAsReader(resource);
  7.         SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);
  8.         SqlSession session = sqlMapper.openSession();
  10.         try {
  11.             User user = session.selectOne("org.itstack.demo.dao.IUserDao.queryUserInfoById", 1L);
  12.             System.out.println(JSON.toJSONString(user));
  13.         } finally {
  14.             session.close();
  15.             reader.close();
  16.         }
  17.     } catch (Exception e) {
  18.         e.printStackTrace();
  19.     }
  20. }

一切顺利结果如下(新人往往会遇到各种问题)；

  1. {"age":18,"createTime":1576944000000,"id":1,"name":"水水","updateTime":1576944000000}
  3. Process finished with exit code 0

可能乍一看这测试类完全和 MybatisApiTest.java 测试的代码一模一样呀，也看不出区别。其实他们的引入的包是不一样；

MybatisApiTest.java 里面引入的包

  1. import org.apache.ibatis.io.Resources;
  2. import org.apache.ibatis.session.SqlSession;
  3. import org.apache.ibatis.session.SqlSessionFactory;
  4. import org.apache.ibatis.session.SqlSessionFactoryBuilder;

ApiLikeTest.java 里面引入的包

  1. import org.itstack.demo.like.Resources;
  2. import org.itstack.demo.like.SqlSession;
  3. import org.itstack.demo.like.SqlSessionFactory;
  4. import org.itstack.demo.like.SqlSessionFactoryBuilder;

好！接下来我们开始分析这部分核心代码。

2. 加载XML配置文件

这里我们采用 mybatis 的配置文件结构进行解析，在不破坏原有结构的情况下，最大可能的贴近源码。mybatis 单独使用的使用的时候使用了两个配置文件；数据源配置、Mapper 映射配置，如下；

mybatis-config-datasource.xml & 数据源配置

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  3.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5. <configuration>
  6.     <environments default="development">
  7.         <environment id="development">
  8.             <transactionManager type="JDBC"/>
  9.             <dataSource type="POOLED">
  10.                 <property name="driver" value="com.mysql.jdbc.Driver"/>
  11.                 <property name="url" value="jdbc:mysql://127.0.0.1:3306/itstack?useUnicode=true"/>
  12.                 <property name="username" value="root"/>
  13.                 <property name="password" value="123456"/>
  14.             </dataSource>
  15.         </environment>
  16.     </environments>
  18.     <mappers>
  19.         <mapper resource="mapper/User_Mapper.xml"/>
  20.         <mapper resource="mapper/School_Mapper.xml"/>
  21.     </mappers>
  23. </configuration>

User_Mapper.xml & Mapper 映射配置

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="org.itstack.demo.dao.IUserDao">
  5.     <select id="queryUserInfoById" parameterType="java.lang.Long" resultType="org.itstack.demo.po.User">
  6.         SELECT id, name, age, createTime, updateTime
  7.         FROM user
  8.         where id = #{id}
  9.     </select>
  11.     <select id="queryUserList" parameterType="org.itstack.demo.po.User" resultType="org.itstack.demo.po.User">
  12.         SELECT id, name, age, createTime, updateTime
  13.         FROM user
  14.         where age = #{age}
  15.     </select>
  17. </mapper>

这里的加载过程与 mybaits 不同，我们采用 dom4j 方式。在案例中会看到最开始获取资源，如下；

ApiLikeTest.test_queryUserInfoById() & 部分截取

  1. String resource = "spring/mybatis-config-datasource.xml";
  2. 	Reader reader;
  3. 	try {
  4. 		reader = Resources.getResourceAsReader(resource);
  5. 	...

从上可以看到这是通过配置文件地址获取到了读取流的过程，从而为后面解析做基础。首先我们先看 Resources 类，整个是我们的资源类。

Resources.java & 资源类

  1. /**
  2.  * 博 客 | https://bugstack.cn
  3.  * Create by 小傅哥 @2020
  4.  */
  5. public class Resources {
  7.     public static Reader getResourceAsReader(String resource) throws IOException {
  8.         return new InputStreamReader(getResourceAsStream(resource));
  9.     }
  11.     private static InputStream getResourceAsStream(String resource) throws IOException {
  12.         ClassLoader[] classLoaders = getClassLoaders();
  13.         for (ClassLoader classLoader : classLoaders) {
  14.             InputStream inputStream = classLoader.getResourceAsStream(resource);
  15.             if (null != inputStream) {
  16.                 return inputStream;
  17.             }
  18.         }
  19.         throw new IOException("Could not find resource " + resource);
  20.     }
  22.     private static ClassLoader[] getClassLoaders() {
  23.         return new ClassLoader[]{
  24.                 ClassLoader.getSystemClassLoader(),
  25.                 Thread.currentThread().getContextClassLoader()};
  26.     }
  28. }

这段代码方法的入口是getResourceAsReader，直到往下以此做了；

  1. 获取 ClassLoader 集合，最大限度搜索配置文件
  2. 通过 classLoader.getResourceAsStream 读取配置资源，找到后立即返回，否则抛出异常

3. 解析XML配置文件

配置文件加载后开始进行解析操作，这里我们也仿照 mybatis 但进行简化，如下；

  1. SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);

SqlSessionFactoryBuilder.build() & 入口构建类

  1. public DefaultSqlSessionFactory build(Reader reader) {
  2.     SAXReader saxReader = new SAXReader();
  3.     try {
  4.         Document document = saxReader.read(new InputSource(reader));
  5.         Configuration configuration = parseConfiguration(document.getRootElement());
  6.         return new DefaultSqlSessionFactory(configuration);
  7.     } catch (DocumentException e) {
  8.         e.printStackTrace();
  9.     }
  10.     return null;
  11. }
  • 通过读取流创建 xml 解析的 Document 类
  • parseConfiguration 进行解析 xml 文件，并将结果设置到配置类中，包括；连接池、数据源、mapper关系

SqlSessionFactoryBuilder.parseConfiguration() & 解析过程

  1. private Configuration parseConfiguration(Element root) {
  2.     Configuration configuration = new Configuration();
  3.     configuration.setDataSource(dataSource(root.selectNodes("//dataSource")));
  4.     configuration.setConnection(connection(configuration.dataSource));
  5.     configuration.setMapperElement(mapperElement(root.selectNodes("mappers")));
  6.     return configuration;
  7. }
  • 在前面的 xml 内容中可以看到，我们需要解析出数据库连接池信息 datasource，还有数据库语句映射关系 mappers

SqlSessionFactoryBuilder.dataSource() & 解析出数据源

  1. private Map<String, String> dataSource(List<Element> list) {
  2.     Map<String, String> dataSource = new HashMap<>(4);
  3.     Element element = list.get(0);
  4.     List content = element.content();
  5.     for (Object o : content) {
  6.         Element e = (Element) o;
  7.         String name = e.attributeValue("name");
  8.         String value = e.attributeValue("value");
  9.         dataSource.put(name, value);
  10.     }
  11.     return dataSource;
  12. }
  • 这个过程比较简单，只需要将数据源信息获取即可

SqlSessionFactoryBuilder.connection() & 获取数据库连接

  1. private Connection connection(Map<String, String> dataSource) {
  2.     try {
  3.         Class.forName(dataSource.get("driver"));
  4.         return DriverManager.getConnection(dataSource.get("url"), dataSource.get("username"), dataSource.get("password"));
  5.     } catch (ClassNotFoundException | SQLException e) {
  6.         e.printStackTrace();
  7.     }
  8.     return null;
  9. }
  • 这个就是jdbc最原始的代码，获取了数据库连接池

SqlSessionFactoryBuilder.mapperElement() & 解析SQL语句

  1. private Map<String, XNode> mapperElement(List<Element> list) {
  2.     Map<String, XNode> map = new HashMap<>();
  3.     Element element = list.get(0);
  4.     List content = element.content();
  5.     for (Object o : content) {
  6.         Element e = (Element) o;
  7.         String resource = e.attributeValue("resource");
  8.         try {
  9.             Reader reader = Resources.getResourceAsReader(resource);
  10.             SAXReader saxReader = new SAXReader();
  11.             Document document = saxReader.read(new InputSource(reader));
  12.             Element root = document.getRootElement();
  13.             //命名空间
  14.             String namespace = root.attributeValue("namespace");
  15.             // SELECT
  16.             List<Element> selectNodes = root.selectNodes("select");
  17.             for (Element node : selectNodes) {
  18.                 String id = node.attributeValue("id");
  19.                 String parameterType = node.attributeValue("parameterType");
  20.                 String resultType = node.attributeValue("resultType");
  21.                 String sql = node.getText();
  22.                 // ? 匹配
  23.                 Map<Integer, String> parameter = new HashMap<>();
  24.                 Pattern pattern = Pattern.compile("(#\\{(.*?)})");
  25.                 Matcher matcher = pattern.matcher(sql);
  26.                 for (int i = 1; matcher.find(); i++) {
  27.                     String g1 = matcher.group(1);
  28.                     String g2 = matcher.group(2);
  29.                     parameter.put(i, g2);
  30.                     sql = sql.replace(g1, "?");
  31.                 }
  32.                 XNode xNode = new XNode();
  33.                 xNode.setNamespace(namespace);
  34.                 xNode.setId(id);
  35.                 xNode.setParameterType(parameterType);
  36.                 xNode.setResultType(resultType);
  37.                 xNode.setSql(sql);
  38.                 xNode.setParameter(parameter);
  40.                 map.put(namespace + "." + id, xNode);
  41.             }
  42.         } catch (Exception ex) {
  43.             ex.printStackTrace();
  44.         }
  45.     }
  46.     return map;
  47. }
  • 这个过程首先包括是解析所有的sql语句，目前为了测试只解析 select 相关
  • 所有的 sql 语句为了确认唯一，都是使用；namespace + select中的id进行拼接，作为 key，之后与sql一起存放到 map 中。
  • 在 mybaits 的 sql 语句配置中，都有占位符，用于传参。where id = #{id} 所以我们需要将占位符设置为问号，另外需要将占位符的顺序信息与名称存放到 map 结构，方便后续设置查询时候的入参。

4. 创建DefaultSqlSessionFactory

最后将初始化后的配置类 Configuration，作为参数进行创建 DefaultSqlSessionFactory，如下；

  1. public DefaultSqlSessionFactory build(Reader reader) {
  2.     SAXReader saxReader = new SAXReader();
  3.     try {
  4.         Document document = saxReader.read(new InputSource(reader));
  5.         Configuration configuration = parseConfiguration(document.getRootElement());
  6.         return new DefaultSqlSessionFactory(configuration);
  7.     } catch (DocumentException e) {
  8.         e.printStackTrace();
  9.     }
  10.     return null;
  11. }

DefaultSqlSessionFactory.java & SqlSessionFactory的实现类

  1. public class DefaultSqlSessionFactory implements SqlSessionFactory {
  3. 	private final Configuration configuration;
  5. 	public DefaultSqlSessionFactory(Configuration configuration) {
  6.         this.configuration = configuration;
  7.     }
  9.     @Override
  10.     public SqlSession openSession() {
  11.         return new DefaultSqlSession(configuration.connection, configuration.mapperElement);
  12.     }
  14. }
  • 这个过程比较简单，构造函数只提供了配置类入参
  • 实现 SqlSessionFactory 的 openSession()，用于创建 DefaultSqlSession，也就可以执行 sql 操作

5. 开启SqlSession

  1. SqlSession session = sqlMapper.openSession();

上面这一步就是创建了DefaultSqlSession，比较简单。如下；

  1. @Override
  2. public SqlSession openSession() {
  3.     return new DefaultSqlSession(configuration.connection, configuration.mapperElement);
  4. }

6. 执行SQL语句

  1. User user = session.selectOne("org.itstack.demo.dao.IUserDao.queryUserInfoById", 1L);

在 DefaultSqlSession 中通过实现 SqlSession，提供数据库语句查询和关闭连接池，如下；

SqlSession.java & 定义

  1. public interface SqlSession {
  3.     <T> T selectOne(String statement);
  5.     <T> T selectOne(String statement, Object parameter);
  7.     <T> List<T> selectList(String statement);
  9.     <T> List<T> selectList(String statement, Object parameter);
  11.     void close();
  12. }

接下来看具体的执行过程，session.selectOne

DefaultSqlSession.selectOne() & 执行查询

  1. public <T> T selectOne(String statement, Object parameter) {
  2.     XNode xNode = mapperElement.get(statement);
  3.     Map<Integer, String> parameterMap = xNode.getParameter();
  4.     try {
  5.         PreparedStatement preparedStatement = connection.prepareStatement(xNode.getSql());
  6.         buildParameter(preparedStatement, parameter, parameterMap);
  7.         ResultSet resultSet = preparedStatement.executeQuery();
  8.         List<T> objects = resultSet2Obj(resultSet, Class.forName(xNode.getResultType()));
  9.         return objects.get(0);
  10.     } catch (Exception e) {
  11.         e.printStackTrace();
  12.     }
  13.     return null;
  14. }

  • selectOne 就objects.get(0);，selectList 就全部返回

  • 通过 statement 获取最初解析 xml 时候的存储的 select 标签信息；

    1. <select id="queryUserInfoById" parameterType="java.lang.Long" resultType="org.itstack.demo.po.User">
    2. 	SELECT id, name, age, createTime, updateTime
    3. 	FROM user
    4. 	where id = #{id}
    5. </select>

  • 获取 sql 语句后交给 jdbc 的 PreparedStatement 类进行执行

  • 这里还需要设置入参，我们将入参设置进行抽取，如下；

    1. private void buildParameter(PreparedStatement preparedStatement, Object parameter, Map<Integer, String> parameterMap) throws SQLException, IllegalAccessException {
    3.       int size = parameterMap.size();
    4.       // 单个参数
    5.       if (parameter instanceof Long) {
    6.           for (int i = 1; i <= size; i++) {
    7.               preparedStatement.setLong(i, Long.parseLong(parameter.toString()));
    8.           }
    9.           return;
    10.       }
    12.       if (parameter instanceof Integer) {
    13.           for (int i = 1; i <= size; i++) {
    14.               preparedStatement.setInt(i, Integer.parseInt(parameter.toString()));
    15.           }
    16.           return;
    17.       }
    19.       if (parameter instanceof String) {
    20.           for (int i = 1; i <= size; i++) {
    21.               preparedStatement.setString(i, parameter.toString());
    22.           }
    23.           return;
    24.       }
    26.       Map<String, Object> fieldMap = new HashMap<>();
    27.       // 对象参数
    28.       Field[] declaredFields = parameter.getClass().getDeclaredFields();
    29.       for (Field field : declaredFields) {
    30.           String name = field.getName();
    31.           field.setAccessible(true);
    32.           Object obj = field.get(parameter);
    33.           field.setAccessible(false);
    34.           fieldMap.put(name, obj);
    35.       }
    37.       for (int i = 1; i <= size; i++) {
    38.           String parameterDefine = parameterMap.get(i);
    39.           Object obj = fieldMap.get(parameterDefine);
    41.           if (obj instanceof Short) {
    42.               preparedStatement.setShort(i, Short.parseShort(obj.toString()));
    43.               continue;
    44.           }
    46.           if (obj instanceof Integer) {
    47.               preparedStatement.setInt(i, Integer.parseInt(obj.toString()));
    48.               continue;
    49.           }
    51.           if (obj instanceof Long) {
    52.               preparedStatement.setLong(i, Long.parseLong(obj.toString()));
    53.               continue;
    54.           }
    56.           if (obj instanceof String) {
    57.               preparedStatement.setString(i, obj.toString());
    58.               continue;
    59.           }
    61.           if (obj instanceof Date) {
    62.               preparedStatement.setDate(i, (java.sql.Date) obj);
    63.           }
    65.       }
    67.   }
    • 单个参数比较简单直接设置值即可，Long、Integer、String ...
    • 如果是一个类对象，需要通过获取 Field 属性，与参数 Map 进行匹配设置

  • 设置参数后执行查询 preparedStatement.executeQuery()

  • 接下来需要将查询结果转换为我们的类（主要是反射类的操作），resultSet2Obj(resultSet, Class.forName(xNode.getResultType()));

    1. private <T> List<T> resultSet2Obj(ResultSet resultSet, Class<?> clazz) {
    2. 	List<T> list = new ArrayList<>();
    3. 	try {
    4. 		ResultSetMetaData metaData = resultSet.getMetaData();
    5. 		int columnCount = metaData.getColumnCount();
    6. 		// 每次遍历行值
    7. 		while (resultSet.next()) {
    8. 			T obj = (T) clazz.newInstance();
    9. 			for (int i = 1; i <= columnCount; i++) {
    10. 				Object value = resultSet.getObject(i);
    11. 				String columnName = metaData.getColumnName(i);
    12. 				String setMethod = "set" + columnName.substring(0, 1).toUpperCase() + columnName.substring(1);
    13. 				Method method;
    14. 				if (value instanceof Timestamp) {
    15. 					method = clazz.getMethod(setMethod, Date.class);
    16. 				} else {
    17. 					method = clazz.getMethod(setMethod, value.getClass());
    18. 				}
    19. 				method.invoke(obj, value);
    20. 			}
    21. 			list.add(obj);
    22. 		}
    23. 	} catch (Exception e) {
    24. 		e.printStackTrace();
    25. 	}
    26. 	return list;
    27. }
    • 主要通过反射生成我们的类对象，这个类的类型定义在 sql 标签上
    • 时间类型需要判断后处理，Timestamp，与 java 不是一个类型

7. Sql查询补充说明

sql 查询有入参、有不需要入参、有查询一个、有查询集合，只需要合理包装即可，例如下面的查询集合，入参是对象类型；

ApiLikeTest.test_queryUserList()

  1. @Test
  2. public void test_queryUserList() {
  3.     String resource = "spring/mybatis-config-datasource.xml";
  4.     Reader reader;
  5.     try {
  6.         reader = Resources.getResourceAsReader(resource);
  7.         SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);
  8.         SqlSession session = sqlMapper.openSession();
  10. 		try {
  11.             User req = new User();
  12.             req.setAge(18);
  13.             List<User> userList = session.selectList("org.itstack.demo.dao.IUserDao.queryUserList", req);
  14.             System.out.println(JSON.toJSONString(userList));
  15.         } finally {
  16.             session.close();
  17.             reader.close();
  18.         }
  19.     } catch (Exception e) {
  20.         e.printStackTrace();
  21.     }
  23. }

**测试结果：

  1. [{"age":18,"createTime":1576944000000,"id":1,"name":"水水","updateTime":1576944000000},{"age":18,"createTime":1576944000000,"id":2,"name":"豆豆","updateTime":1576944000000}]
  3. Process finished with exit code 0

四、源码分析(mybatis)

  1. <dependency>
  2.     <groupId>org.mybatis</groupId>
  3.     <artifactId>mybatis</artifactId>
  4.     <version>3.4.6</version>
  5. </dependency>

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

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

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

MybatisApiTest.java

  1. public class MybatisApiTest {
  3.     @Test
  4.     public void test_queryUserInfoById() {
  5.         String resource = "spring/mybatis-config-datasource.xml";
  6.         Reader reader;
  7.         try {
  8.             reader = Resources.getResourceAsReader(resource);
  9.             SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);
  11.             SqlSession session = sqlMapper.openSession();
  12.             try {
  13.                 User user = session.selectOne("org.itstack.demo.dao.IUserDao.queryUserInfoById", 1L);
  14.                 System.out.println(JSON.toJSONString(user));
  15.             } finally {
  16.                 session.close();
  17.                 reader.close();
  18.             }
  19.         } catch (IOException e) {
  20.             e.printStackTrace();
  21.         }
  22.     }
  24. }

dao/IUserDao.java

  1. public interface IUserDao {
  3.      User queryUserInfoById(Long id);
  5. }

spring/mybatis-config-datasource.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  3.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5. <configuration>
  6.     <environments default="development">
  7.         <environment id="development">
  8.             <transactionManager type="JDBC"/>
  9.             <dataSource type="POOLED">
  10.                 <property name="driver" value="com.mysql.jdbc.Driver"/>
  11.                 <property name="url" value="jdbc:mysql://127.0.0.1:3306/itstack?useUnicode=true"/>
  12.                 <property name="username" value="root"/>
  13.                 <property name="password" value="123456"/>
  14.             </dataSource>
  15.         </environment>
  16.     </environments>
  18.     <mappers>
  19.         <mapper resource="mapper/User_Mapper.xml"/>
  20.     </mappers>
  22. </configuration>

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

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

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

2. 容器初始化

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

  • 流程核心类

    • SqlSessionFactoryBuilder
    • XMLConfigBuilder
    • XPathParser
    • Configuration

SqlSessionFactoryBuilder.java

  1. public class SqlSessionFactoryBuilder {
  3.   public SqlSessionFactory build(Reader reader) {
  4.     return build(reader, null, null);
  5.   }
  7.   public SqlSessionFactory build(Reader reader, String environment) {
  8.     return build(reader, environment, null);
  9.   }
  11.   public SqlSessionFactory build(Reader reader, Properties properties) {
  12.     return build(reader, null, properties);
  13.   }
  15.   public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
  16.     try {
  17.       XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
  18.       return build(parser.parse());
  19.     } catch (Exception e) {
  20.       throw ExceptionFactory.wrapException("Error building SqlSession.", e);
  21.     } finally {
  22.       ErrorContext.instance().reset();
  23.       try {
  24.         reader.close();
  25.       } catch (IOException e) {
  26.         // Intentionally ignore. Prefer previous error.
  27.       }
  28.     }
  29.   }
  31.   public SqlSessionFactory build(InputStream inputStream) {
  32.     return build(inputStream, null, null);
  33.   }
  35.   public SqlSessionFactory build(InputStream inputStream, String environment) {
  36.     return build(inputStream, environment, null);
  37.   }
  39.   public SqlSessionFactory build(InputStream inputStream, Properties properties) {
  40.     return build(inputStream, null, properties);
  41.   }
  43.   public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
  44.     try {
  45.       XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
  46.       return build(parser.parse());
  47.     } catch (Exception e) {
  48.       throw ExceptionFactory.wrapException("Error building SqlSession.", e);
  49.     } finally {
  50.       ErrorContext.instance().reset();
  51.       try {
  52.         inputStream.close();
  53.       } catch (IOException e) {
  54.         // Intentionally ignore. Prefer previous error.
  55.       }
  56.     }
  57.   }
  59.   public SqlSessionFactory build(Configuration config) {
  60.     return new DefaultSqlSessionFactory(config);
  61.   }
  63. }

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

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

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

XMLConfigBuilder.java

  1. public class XMLConfigBuilder extends BaseBuilder {
  3.   private boolean parsed;
  4.   private final XPathParser parser;
  5.   private String environment;
  6.   private final ReflectorFactory localReflectorFactory = new DefaultReflectorFactory();
  8.   ...
  9.   public XMLConfigBuilder(Reader reader, String environment, Properties props) {
  10.     this(new XPathParser(reader, true, props, new XMLMapperEntityResolver()), environment, props);
  11.   }
  12.   ...
  13. }
  1. XMLConfigBuilder对于XML文件的加载和解析都委托于XPathParser，最终使用JDK自带的javax.xml进行XML解析(XPath)
  2. 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

  1. public class XMLMapperEntityResolver implements EntityResolver {
  3.   private static final String IBATIS_CONFIG_SYSTEM = "ibatis-3-config.dtd";
  4.   private static final String IBATIS_MAPPER_SYSTEM = "ibatis-3-mapper.dtd";
  5.   private static final String MYBATIS_CONFIG_SYSTEM = "mybatis-3-config.dtd";
  6.   private static final String MYBATIS_MAPPER_SYSTEM = "mybatis-3-mapper.dtd";
  8.   private static final String MYBATIS_CONFIG_DTD = "org/apache/ibatis/builder/xml/mybatis-3-config.dtd";
  9.   private static final String MYBATIS_MAPPER_DTD = "org/apache/ibatis/builder/xml/mybatis-3-mapper.dtd";
  11.   /*
  12.    * Converts a public DTD into a local one
  13.    *
  14.    * @param publicId The public id that is what comes after "PUBLIC"
  15.    * @param systemId The system id that is what comes after the public id.
  16.    * @return The InputSource for the DTD
  17.    *
  18.    * @throws org.xml.sax.SAXException If anything goes wrong
  19.    */
  20.   @Override
  21.   public InputSource resolveEntity(String publicId, String systemId) throws SAXException {
  22.     try {
  23.       if (systemId != null) {
  24.         String lowerCaseSystemId = systemId.toLowerCase(Locale.ENGLISH);
  25.         if (lowerCaseSystemId.contains(MYBATIS_CONFIG_SYSTEM) || lowerCaseSystemId.contains(IBATIS_CONFIG_SYSTEM)) {
  26.           return getInputSource(MYBATIS_CONFIG_DTD, publicId, systemId);
  27.         } else if (lowerCaseSystemId.contains(MYBATIS_MAPPER_SYSTEM) || lowerCaseSystemId.contains(IBATIS_MAPPER_SYSTEM)) {
  28.           return getInputSource(MYBATIS_MAPPER_DTD, publicId, systemId);
  29.         }
  30.       }
  31.       return null;
  32.     } catch (Exception e) {
  33.       throw new SAXException(e.toString());
  34.     }
  35.   }
  37.   private InputSource getInputSource(String path, String publicId, String systemId) {
  38.     InputSource source = null;
  39.     if (path != null) {
  40.       try {
  41.         InputStream in = Resources.getResourceAsStream(path);
  42.         source = new InputSource(in);
  43.         source.setPublicId(publicId);
  44.         source.setSystemId(systemId);
  45.       } catch (IOException e) {
  46.         // ignore, null is ok
  47.       }
  48.     }
  49.     return source;
  50.   }
  52. }
  1. Mybatis依赖于dtd文件进行进行解析，其中的ibatis-3-config.dtd主要是用于兼容用途
  2. getInputSource(String path, String publicId, String systemId)的调用里面有两个参数publicId（公共标识符）和systemId（系统标示符）

XPathParser.java

  1. public XPathParser(Reader reader, boolean validation, Properties variables, EntityResolver entityResolver) {
  2.   commonConstructor(validation, variables, entityResolver);
  3.   this.document = createDocument(new InputSource(reader));
  4. }
  6. private void commonConstructor(boolean validation, Properties variables, EntityResolver entityResolver) {
  7.   this.validation = validation;
  8.   this.entityResolver = entityResolver;
  9.   this.variables = variables;
  10.   XPathFactory factory = XPathFactory.newInstance();
  11.   this.xpath = factory.newXPath();
  12. }
  14. private Document createDocument(InputSource inputSource) {
  15.   // important: this must only be called AFTER common constructor
  16.   try {
  17.     DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  18.     factory.setValidating(validation);
  19.     factory.setNamespaceAware(false);
  20.     factory.setIgnoringComments(true);
  21.     factory.setIgnoringElementContentWhitespace(false);
  22.     factory.setCoalescing(false);
  23.     factory.setExpandEntityReferences(true);
  24.     DocumentBuilder builder = factory.newDocumentBuilder();
  25.     builder.setEntityResolver(entityResolver);
  26.     builder.setErrorHandler(new ErrorHandler() {
  27.       @Override
  28.       public void error(SAXParseException exception) throws SAXException {
  29.         throw exception;
  30.       }
  31.       @Override
  32.       public void fatalError(SAXParseException exception) throws SAXException {
  33.         throw exception;
  34.       }
  35.       @Override
  36.       public void warning(SAXParseException exception) throws SAXException {
  37.       }
  38.     });
  39.     return builder.parse(inputSource);
  40.   } catch (Exception e) {
  41.     throw new BuilderException("Error creating document instance.  Cause: " + e, e);
  42.   }
  44. }

  1. 从上到下可以看到主要是为了创建一个Mybatis的文档解析器，最后根据builder.parse(inputSource)返回Document

  2. 得到XPathParser实例后，接下来在调用方法：this(new XPathParser(reader, true, props, new XMLMapperEntityResolver()), environment, props);

    1.  XMLConfigBuilder.this(new XPathParser(reader, true, props, new XMLMapperEntityResolver()), environment, props);
    3.  private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
    4.    super(new Configuration());
    5.    ErrorContext.instance().resource("SQL Mapper Configuration");
    6.    this.configuration.setVariables(props);
    7.    this.parsed = false;
    8.    this.environment = environment;
    9.    this.parser = parser;
    10.  }

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

    1. public abstract class BaseBuilder {
    2.   protected final Configuration configuration;
    3.   protected final TypeAliasRegistry typeAliasRegistry;
    4.   protected final TypeHandlerRegistry typeHandlerRegistry;
    6.   public BaseBuilder(Configuration configuration) {
    7.     this.configuration = configuration;
    8.     this.typeAliasRegistry = this.configuration.getTypeAliasRegistry();
    9.     this.typeHandlerRegistry = this.configuration.getTypeHandlerRegistry();
    10.   }
    11. }

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

    1. public class XMLConfigBuilder extends BaseBuilder {
    2.      public Configuration parse() {
    3.        if (parsed) {
    4.          throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    5.        }
    6.        parsed = true;
    7.        parseConfiguration(parser.evalNode("/configuration"));
    8.        return configuration;
    9.      }
    10. }

3. 配置文件解析

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

  1. 属性解析propertiesElement
  2. 加载settings节点settingsAsProperties
  3. 载自定义VFS loadCustomVfs
  4. 解析类型别名typeAliasesElement
  5. 加载插件pluginElement
  6. 加载对象工厂objectFactoryElement
  7. 创建对象包装器工厂objectWrapperFactoryElement
  8. 加载反射工厂reflectorFactoryElement
  9. 元素设置settingsElement
  10. 加载环境配置environmentsElement
  11. 数据库厂商标识加载databaseIdProviderElement
  12. 加载类型处理器typeHandlerElement
  13. (核心)加载mapper文件mapperElement
  1. parseConfiguration(parser.evalNode("/configuration"));
  3. private void parseConfiguration(XNode root) {
  4.     try {
  5.       //issue #117 read properties first
  6.       //属性解析propertiesElement
  7.       propertiesElement(root.evalNode("properties"));
  8.       //加载settings节点settingsAsProperties
  9.       Properties settings = settingsAsProperties(root.evalNode("settings"));
  10.       //加载自定义VFS loadCustomVfs
  11.       loadCustomVfs(settings);
  12.       //解析类型别名typeAliasesElement
  13.       typeAliasesElement(root.evalNode("typeAliases"));
  14.       //加载插件pluginElement
  15.       pluginElement(root.evalNode("plugins"));
  16.       //加载对象工厂objectFactoryElement
  17.       objectFactoryElement(root.evalNode("objectFactory"));
  18.       //创建对象包装器工厂objectWrapperFactoryElement
  19.       objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
  20.       //加载反射工厂reflectorFactoryElement
  21.       reflectorFactoryElement(root.evalNode("reflectorFactory"));
  22.       //元素设置
  23.       settingsElement(settings);
  24.       // read it after objectFactory and objectWrapperFactory issue #631
  25.       //加载环境配置environmentsElement
  26.       environmentsElement(root.evalNode("environments"));
  27.       //数据库厂商标识加载databaseIdProviderElement
  28.       databaseIdProviderElement(root.evalNode("databaseIdProvider"));
  29.       //加载类型处理器typeHandlerElement
  30.       typeHandlerElement(root.evalNode("typeHandlers"));
  31.       //加载mapper文件mapperElement
  32.       mapperElement(root.evalNode("mappers"));
  33.     } catch (Exception e) {
  34.       throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
  35.     }
  36. }

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

  1. <!ELEMENT configuration (properties?, settings?, typeAliases?, typeHandlers?, objectFactory?, objectWrapperFactory?, reflectorFactory?, plugins?, environments?, databaseIdProvider?, mappers?)>
  3. <!ELEMENT databaseIdProvider (property*)>
  4. <!ATTLIST databaseIdProvider
  5. type CDATA #REQUIRED
  6. >
  8. <!ELEMENT properties (property*)>
  9. <!ATTLIST properties
  10. resource CDATA #IMPLIED
  11. url CDATA #IMPLIED
  12. >
  14. <!ELEMENT property EMPTY>
  15. <!ATTLIST property
  16. name CDATA #REQUIRED
  17. value CDATA #REQUIRED
  18. >
  20. <!ELEMENT settings (setting+)>
  22. <!ELEMENT setting EMPTY>
  23. <!ATTLIST setting
  24. name CDATA #REQUIRED
  25. value CDATA #REQUIRED
  26. >
  28. <!ELEMENT typeAliases (typeAlias*,package*)>
  30. <!ELEMENT typeAlias EMPTY>
  31. <!ATTLIST typeAlias
  32. type CDATA #REQUIRED
  33. alias CDATA #IMPLIED
  34. >
  36. <!ELEMENT typeHandlers (typeHandler*,package*)>
  38. <!ELEMENT typeHandler EMPTY>
  39. <!ATTLIST typeHandler
  40. javaType CDATA #IMPLIED
  41. jdbcType CDATA #IMPLIED
  42. handler CDATA #REQUIRED
  43. >
  45. <!ELEMENT objectFactory (property*)>
  46. <!ATTLIST objectFactory
  47. type CDATA #REQUIRED
  48. >
  50. <!ELEMENT objectWrapperFactory EMPTY>
  51. <!ATTLIST objectWrapperFactory
  52. type CDATA #REQUIRED
  53. >
  55. <!ELEMENT reflectorFactory EMPTY>
  56. <!ATTLIST reflectorFactory
  57. type CDATA #REQUIRED
  58. >
  60. <!ELEMENT plugins (plugin+)>
  62. <!ELEMENT plugin (property*)>
  63. <!ATTLIST plugin
  64. interceptor CDATA #REQUIRED
  65. >
  67. <!ELEMENT environments (environment+)>
  68. <!ATTLIST environments
  69. default CDATA #REQUIRED
  70. >
  72. <!ELEMENT environment (transactionManager,dataSource)>
  73. <!ATTLIST environment
  74. id CDATA #REQUIRED
  75. >
  77. <!ELEMENT transactionManager (property*)>
  78. <!ATTLIST transactionManager
  79. type CDATA #REQUIRED
  80. >
  82. <!ELEMENT dataSource (property*)>
  83. <!ATTLIST dataSource
  84. type CDATA #REQUIRED
  85. >
  87. <!ELEMENT mappers (mapper*,package*)>
  89. <!ELEMENT mapper EMPTY>
  90. <!ATTLIST mapper
  91. resource CDATA #IMPLIED
  92. url CDATA #IMPLIED
  93. class CDATA #IMPLIED
  94. >
  96. <!ELEMENT package EMPTY>
  97. <!ATTLIST package
  98. name CDATA #REQUIRED
  99. >

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

  1. properties?,
  2. settings?,
  3. typeAliases?,
  4. typeHandlers?,
  5. objectFactory?,
  6. objectWrapperFactory?,
  7. reflectorFactory?,
  8. plugins?,
  9. environments?,
  10. databaseIdProvider?,
  11. mappers?

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

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

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

  1. protected static class StrictMap<V> extends HashMap<String, V> {
  3.     private static final long serialVersionUID = -4950446264854982944L;
  4.     private final String name;
  6.     public StrictMap(String name, int initialCapacity, float loadFactor) {
  7.       super(initialCapacity, loadFactor);
  8.       this.name = name;
  9.     }
  11.     public StrictMap(String name, int initialCapacity) {
  12.       super(initialCapacity);
  13.       this.name = name;
  14.     }
  16.     public StrictMap(String name) {
  17.       super();
  18.       this.name = name;
  19.     }
  21.     public StrictMap(String name, Map<String, ? extends V> m) {
  22.       super(m);
  23.       this.name = name;
  24.     }
  25. }

(核心)加载mapper文件mapperElement

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

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

  1. private void mapperElement(XNode parent) throws Exception {
  2.    if (parent != null) {
  3.      for (XNode child : parent.getChildren()) {
  4.        // 如果要同时使用package自动扫描和通过mapper明确指定要加载的mapper，一定要确保package自动扫描的范围不包含明确指定的mapper，否则在通过package扫描的interface的时候，尝试加载对应xml文件的loadXmlResource()的逻辑中出现判重出错，报org.apache.ibatis.binding.BindingException异常，即使xml文件中包含的内容和mapper接口中包含的语句不重复也会出错，包括加载mapper接口时自动加载的xml mapper也一样会出错。
  5.        if ("package".equals(child.getName())) {
  6.          String mapperPackage = child.getStringAttribute("name");
  7.          configuration.addMappers(mapperPackage);
  8.        } else {
  9.          String resource = child.getStringAttribute("resource");
  10.          String url = child.getStringAttribute("url");
  11.          String mapperClass = child.getStringAttribute("class");
  12.          if (resource != null && url == null && mapperClass == null) {
  13.            ErrorContext.instance().resource(resource);
  14.            InputStream inputStream = Resources.getResourceAsStream(resource);
  15.            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
  16.            mapperParser.parse();
  17.          } else if (resource == null && url != null && mapperClass == null) {
  18.            ErrorContext.instance().resource(url);
  19.            InputStream inputStream = Resources.getUrlAsStream(url);
  20.            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
  21.            mapperParser.parse();
  22.          } else if (resource == null && url == null && mapperClass != null) {
  23.            Class<?> mapperInterface = Resources.classForName(mapperClass);
  24.            configuration.addMapper(mapperInterface);
  25.          } else {
  26.            throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
  27.          }
  28.        }
  29.      }
  30.    }
  31. }

  • Mybatis提供了两类配置Mapper的方法，第一类是使用package自动搜索的模式，这样指定package下所有接口都会被注册为mapper，也是在Spring中比较常用的方式，例如：

    1. <mappers>
    2.   <package name="org.itstack.demo"/>
    3. </mappers>

  • 另外一类是明确指定Mapper，这又可以通过resource、url或者class进行细分，例如；

    1. <mappers>
    2.     <mapper resource="mapper/User_Mapper.xml"/>
    3.     <mapper class=""/>
    4.     <mapper url=""/>
    5. </mappers>

4. Mapper加载与动态代理

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

  1. private void mapperElement(XNode parent) throws Exception {
  2.   if (parent != null) {
  3.     for (XNode child : parent.getChildren()) {
  4.       if ("package".equals(child.getName())) {
  5.         String mapperPackage = child.getStringAttribute("name");
  6.         configuration.addMappers(mapperPackage);
  7.       } else {
  8.         ...
  9.       }
  10.     }
  11.   }
  12. }

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

  1. XMLConfigBuilder
  2. Configuration
  3. MapperRegistry
  4. MapperAnnotationBuilder
  5. MapperProxyFactory

MapperRegistry.java

解析加载Mapper

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

生成代理类：MapperProxyFactory

  1. public <T> void addMapper(Class<T> type) {
  2.   // 对于mybatis mapper接口文件，必须是interface，不能是class
  3.   if (type.isInterface()) {
  4.     if (hasMapper(type)) {
  5.       throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
  6.     }
  7.     boolean loadCompleted = false;
  8.     try {
  9.       // 为mapper接口创建一个MapperProxyFactory代理
  10.       knownMappers.put(type, new MapperProxyFactory<T>(type));
  11.       // It's important that the type is added before the parser is run
  12.       // otherwise the binding may automatically be attempted by the
  13.       // mapper parser. If the type is already known, it won't try.
  14.       MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
  15.       parser.parse();
  16.       loadCompleted = true;
  17.     } finally {
  18.       if (!loadCompleted) {
  19.         knownMappers.remove(type);
  20.       }
  21.     }
  22.   }
  23. }

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

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

MapperProxyFactory.java

  1. public class MapperProxyFactory<T> {
  2.   private final Class<T> mapperInterface;
  3.   private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();
  4.   public MapperProxyFactory(Class<T> mapperInterface) {
  5.     this.mapperInterface = mapperInterface;
  6.   }
  7.   public Class<T> getMapperInterface() {
  8.     return mapperInterface;
  9.   }
  10.   public Map<Method, MapperMethod> getMethodCache() {
  11.     return methodCache;
  12.   }
  13.   @SuppressWarnings("unchecked")
  14.   protected T newInstance(MapperProxy<T> mapperProxy) {
  15.     return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  16.   }
  17.   public T newInstance(SqlSession sqlSession) {
  18.     final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
  19.     return newInstance(mapperProxy);
  20.   }
  21. }

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

五、源码分析(mybatis-spring)

  1. <dependency>
  2.     <groupId>org.mybatis</groupId>
  3.     <artifactId>mybatis-spring</artifactId>
  4.     <version>1.3.2</version>
  5. </dependency>

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

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

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

SpringApiTest.java

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration("classpath:spring-config.xml")
  3. public class SpringApiTest {
  5.     private Logger logger = LoggerFactory.getLogger(SpringApiTest.class);
  7.     @Resource
  8.     private ISchoolDao schoolDao;
  9.     @Resource
  10.     private IUserDao userDao;
  12.     @Test
  13.     public void test_queryRuleTreeByTreeId(){
  14.         School ruleTree = schoolDao.querySchoolInfoById(1L);
  15.         logger.info(JSON.toJSONString(ruleTree));
  17.         User user = userDao.queryUserInfoById(1L);
  18.         logger.info(JSON.toJSONString(user));
  19.     }
  21. }

spring-config-datasource.xml

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

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

  1. {"address":"北京市海淀区颐和园路5号","createTime":1571376957000,"id":1,"name":"北京大学","updateTime":1571376957000}
  2. {"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 & 部分截取

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

ClassPathMapperScanner.java & 部分截取

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

ClassPathBeanDefinitionScanner.java & 部分截取

  1. protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
  2. 	Assert.notEmpty(basePackages, "At least one base package must be specified");
  3. 	Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
  4. 	for (String basePackage : basePackages) {
  5. 		Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
  6. 		for (BeanDefinition candidate : candidates) {
  7. 			ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
  8. 			candidate.setScope(scopeMetadata.getScopeName());
  9. 			String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
  10. 			if (candidate instanceof AbstractBeanDefinition) {
  11. 				postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
  12. 			}
  13. 			if (candidate instanceof AnnotatedBeanDefinition) {
  14. 				AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate)
  15. 			}
  16. 			if (checkCandidate(beanName, candidate)) {
  17. 				BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
  18. 				definitionHolder =
  19. 						AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.regi
  20. 				beanDefinitions.add(definitionHolder);
  21. 				registerBeanDefinition(definitionHolder, this.registry);
  22. 			}
  23. 		}
  24. 	}
  25. 	return beanDefinitions;
  26. }
  • 优先调用了父类的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 & 部分截取

  1. **processBeanDefinitions(beanDefinitions);**
  3. private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
  4.   GenericBeanDefinition definition;
  5.   for (BeanDefinitionHolder holder : beanDefinitions) {
  6.     definition = (GenericBeanDefinition) holder.getBeanDefinition();
  7.     if (logger.isDebugEnabled()) {
  8.       logger.debug("Creating MapperFactoryBean with name '" + holder.getBeanName()
  9.         + "' and '" + definition.getBeanClassName() + "' mapperInterface");
  10.     }
  11.     // the mapper interface is the original class of the bean
  12.     // but, the actual class of the bean is MapperFactoryBean
  13.     definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName()); // issue #59
  14.     definition.setBeanClass(this.mapperFactoryBean.getClass());
  15.     definition.getPropertyValues().add("addToConfig", this.addToConfig);
  16.     boolean explicitFactoryUsed = false;
  17.     if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {
  18.       definition.getPropertyValues().add("sqlSessionFactory", new RuntimeBeanReference(this.sqlSessionFactoryBeanName));
  19.       explicitFactoryUsed = true;
  20.     } else if (this.sqlSessionFactory != null) {
  21.       definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);
  22.       explicitFactoryUsed = true;
  23.     }
  24.     if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) {
  25.       if (explicitFactoryUsed) {
  26.         logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
  27.       }
  28.       definition.getPropertyValues().add("sqlSessionTemplate", new RuntimeBeanReference(this.sqlSessionTemplateBeanName));
  29.       explicitFactoryUsed = true;
  30.     } else if (this.sqlSessionTemplate != null) {
  31.       if (explicitFactoryUsed) {
  32.         logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
  33.       }
  34.       definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);
  35.       explicitFactoryUsed = true;
  36.     }
  37.     if (!explicitFactoryUsed) {
  38.       if (logger.isDebugEnabled()) {
  39.         logger.debug("Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
  40.       }
  41.       definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
  42.     }
  43.   }
  44. }
  • 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

  1. public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {
  3.   private Class<T> mapperInterface;
  5.   private boolean addToConfig = true;
  7.   public MapperFactoryBean() {
  8.     //intentionally empty
  9.   }
  11.   public MapperFactoryBean(Class<T> mapperInterface) {
  12.     this.mapperInterface = mapperInterface;
  13.   }
  15.   /**
  16.    * 当SpringBean容器初始化时候会调用到checkDaoConfig()，他是继承类中的抽象方法
  17.    * {@inheritDoc}
  18.    */
  19.   @Override
  20.   protected void checkDaoConfig() {
  21.     super.checkDaoConfig();
  23.     notNull(this.mapperInterface, "Property 'mapperInterface' is required");
  25.     Configuration configuration = getSqlSession().getConfiguration();
  26.     if (this.addToConfig && !configuration.hasMapper(this.mapperInterface)) {
  27.       try {
  28.         configuration.addMapper(this.mapperInterface);
  29.       } catch (Exception e) {
  30.         logger.error("Error while adding the mapper '" + this.mapperInterface + "' to configuration.", e);
  31.         throw new IllegalArgumentException(e);
  32.       } finally {
  33.         ErrorContext.instance().reset();
  34.       }
  35.     }
  36.   }
  38.   /**
  39.    * {@inheritDoc}
  40.    */
  41.   @Override
  42.   public T getObject() throws Exception {
  43.     return getSqlSession().getMapper(this.mapperInterface);
  44.   }
  46.   ...
  47. }

  • 72行：checkDaoConfig()，当SpringBean容器初始化时候会调用到checkDaoConfig()，他是继承类中的抽象方法

  • 95行：getSqlSession().getMapper(this.mapperInterface);，通过接口获取Mapper(代理类)，调用过程如下；

    • DefaultSqlSession.getMapper(Class type)，获取Mapper

    • Configuration.getMapper(Class type, SqlSession sqlSession)，从配置中获取

    • MapperRegistry.getMapper(Class type, SqlSession sqlSession)，从注册中心获取到实例化生成

      1. public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
      2.   final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
      3.   if (mapperProxyFactory == null) {
      4.     throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
      5.   }
      6.   try {
      7.     return mapperProxyFactory.newInstance(sqlSession);
      8.   } catch (Exception e) {
      9.     throw new BindingException("Error getting mapper instance. Cause: " + e, e);
      10.   }
      11. }

    • mapperProxyFactory.newInstance(sqlSession);，通过反射工程生成MapperProxy

      1. @SuppressWarnings("unchecked")
      2. protected T newInstance(MapperProxy<T> mapperProxy) {
      3.   return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
      4. }
      5. public T newInstance(SqlSession sqlSession) {
      6.   final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
      7.   return newInstance(mapperProxy);
      8. }

MapperProxy.java & 部分截取

  1. public class MapperProxy<T> implements InvocationHandler, Serializable {
  3.   private static final long serialVersionUID = -6424540398559729838L;
  4.   private final SqlSession sqlSession;
  5.   private final Class<T> mapperInterface;
  6.   private final Map<Method, MapperMethod> methodCache;
  8.   public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {
  9.     this.sqlSession = sqlSession;
  10.     this.mapperInterface = mapperInterface;
  11.     this.methodCache = methodCache;
  12.   }
  14.   @Override
  15.   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  16.     try {
  17.       if (Object.class.equals(method.getDeclaringClass())) {
  18.         return method.invoke(this, args);
  19.       } else if (isDefaultMethod(method)) {
  20.         return invokeDefaultMethod(proxy, method, args);
  21.       }
  22.     } catch (Throwable t) {
  23.       throw ExceptionUtil.unwrapThrowable(t);
  24.     }
  25.     final MapperMethod mapperMethod = cachedMapperMethod(method);
  26.     return mapperMethod.execute(sqlSession, args);
  27.   }
  29.   private MapperMethod cachedMapperMethod(Method method) {
  30.     MapperMethod mapperMethod = methodCache.get(method);
  31.     if (mapperMethod == null) {
  32.       mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
  33.       methodCache.put(method, mapperMethod);
  34.     }
  35.     return mapperMethod;
  36.   }
  38.   @UsesJava7
  39.   private Object invokeDefaultMethod(Object proxy, Method method, Object[] args)
  40.       throws Throwable {
  41.     final Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class
  42.         .getDeclaredConstructor(Class.class, int.class);
  43.     if (!constructor.isAccessible()) {
  44.       constructor.setAccessible(true);
  45.     }
  46.     final Class<?> declaringClass = method.getDeclaringClass();
  47.     return constructor
  48.         .newInstance(declaringClass,
  49.             MethodHandles.Lookup.PRIVATE | MethodHandles.Lookup.PROTECTED
  50.                 | MethodHandles.Lookup.PACKAGE | MethodHandles.Lookup.PUBLIC)
  51.         .unreflectSpecial(method, declaringClass).bindTo(proxy).invokeWithArguments(args);
  52.   }
  54.   ...
  55. }

  • 58行：final MapperMethod mapperMethod = cachedMapperMethod(method);，从缓存中获取MapperMethod

  • 59行：mapperMethod.execute(sqlSession, args);，执行SQL语句，并返回结果(到这关于查询获取结果就到骨头(干)层了)；INSERT、UPDATE、DELETE、SELECT

    1. public Object execute(SqlSession sqlSession, Object[] args) {
    2.   Object result;
    3.   switch (command.getType()) {
    4.     case INSERT: {
    5.     Object param = method.convertArgsToSqlCommandParam(args);
    6.       result = rowCountResult(sqlSession.insert(command.getName(), param));
    7.       break;
    8.     }
    9.     case UPDATE: {
    10.       Object param = method.convertArgsToSqlCommandParam(args);
    11.       result = rowCountResult(sqlSession.update(command.getName(), param));
    12.       break;
    13.     }
    14.     case DELETE: {
    15.       Object param = method.convertArgsToSqlCommandParam(args);
    16.       result = rowCountResult(sqlSession.delete(command.getName(), param));
    17.       break;
    18.     }
    19.     case SELECT:
    20.       if (method.returnsVoid() && method.hasResultHandler()) {
    21.         executeWithResultHandler(sqlSession, args);
    22.         result = null;
    23.       } else if (method.returnsMany()) {
    24.         result = executeForMany(sqlSession, args);
    25.       } else if (method.returnsMap()) {
    26.         result = executeForMap(sqlSession, args);
    27.       } else if (method.returnsCursor()) {
    28.         result = executeForCursor(sqlSession, args);
    29.       } else {
    30.         Object param = method.convertArgsToSqlCommandParam(args);
    31.         result = sqlSession.selectOne(command.getName(), param);
    32.       }
    33.       break;
    34.     case FLUSH:
    35.       result = sqlSession.flushStatements();
    36.       break;
    37.     default:
    38.       throw new BindingException("Unknown execution method for: " + command.getName());
    39.   }
    40.   if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
    41.     throw new BindingException("Mapper method '" + command.getName()
    42.         + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
    43.   }
    44.   return result;
    45. }

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

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

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

  • FactoryBean
  • InitializingBean -> void afterPropertiesSet() throws Exception
  • ApplicationListener

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

SqlSessionFactoryBean.java & 部分截取

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

SqlSessionFactoryBean.java & 部分截取

  1. protected SqlSessionFactory buildSqlSessionFactory() throws IOException {
  2.   Configuration configuration;
  3.   XMLConfigBuilder xmlConfigBuilder = null;
  5.   ...
  7.   if (!isEmpty(this.mapperLocations)) {
  8.     for (Resource mapperLocation : this.mapperLocations) {
  9.       if (mapperLocation == null) {
  10.         continue;
  11.       }
  12.       try {
  13.         XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),
  14.             configuration, mapperLocation.toString(), configuration.getSqlFragments());
  15.         xmlMapperBuilder.parse();
  16.       } catch (Exception e) {
  17.         throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);
  18.       } finally {
  19.         ErrorContext.instance().reset();
  20.       }
  21.       if (LOGGER.isDebugEnabled()) {
  22.         LOGGER.debug("Parsed mapper file: '" + mapperLocation + "'");
  23.       }
  24.     }
  25.   } else {
  26.     if (LOGGER.isDebugEnabled()) {
  27.       LOGGER.debug("Property 'mapperLocations' was not specified or no matching resources found");
  28.     }
  29.   }
  30.   return this.sqlSessionFactoryBuilder.build(configuration);
  31. }
  • 513行：for (Resource mapperLocation : this.mapperLocations) 循环解析Mapper内容
  • 519行：XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(...) 解析XMLMapperBuilder
  • 521行：xmlMapperBuilder.parse() 执行解析，具体如下；

XMLMapperBuilder.java & 部分截取

  1. public class XMLMapperBuilder extends BaseBuilder {
  2.    private final XPathParser parser;
  3.    private final MapperBuilderAssistant builderAssistant;
  4.    private final Map<String, XNode> sqlFragments;
  5.    private final String resource;
  7.    private void bindMapperForNamespace() {
  8.      String namespace = builderAssistant.getCurrentNamespace();
  9.      if (namespace != null) {
  10.        Class<?> boundType = null;
  11.        try {
  12.          boundType = Resources.classForName(namespace);
  13.        } catch (ClassNotFoundException e) {
  14.          //ignore, bound type is not required
  15.        }
  16.        if (boundType != null) {
  17.          if (!configuration.hasMapper(boundType)) {
  18.            // Spring may not know the real resource name so we set a flag
  19.            // to prevent loading again this resource from the mapper interface
  20.            // look at MapperAnnotationBuilder#loadXmlResource
  21.            configuration.addLoadedResource("namespace:" + namespace);
  22.            configuration.addMapper(boundType);
  23.          }
  24.        }
  25.      }
  26.    }
  27. }
  • 这里413行非常重要，configuration.addMapper(boundType);，真正到了添加Mapper到配置中心

MapperRegistry.java & 部分截取

  1. public class MapperRegistry {
  3.   public <T> void addMapper(Class<T> type) {
  4.     if (type.isInterface()) {
  5.       if (hasMapper(type)) {
  6.         throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
  7.       }
  8.       boolean loadCompleted = false;
  9.       try {
  10.         knownMappers.put(type, new MapperProxyFactory<T>(type));
  11.         // It's important that the type is added before the parser is run
  12.         // otherwise the binding may automatically be attempted by the
  13.         // mapper parser. If the type is already known, it won't try.
  14.         MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
  15.         parser.parse();
  16.         loadCompleted = true;
  17.       } finally {
  18.         if (!loadCompleted) {
  19.           knownMappers.remove(type);
  20.         }
  21.       }
  22.     }
  23.   }
  25. }
  • 67行：创建代理工程knownMappers.put(type, new MapperProxyFactory(type));

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

  • 第一个用于扫描Dao接口设置代理类注册到IOC中，用于后续生成Bean实体类，MapperFactoryBean，并可以通过mapperInterface从Configuration获取Mapper

  • 另一个用于生成SqlSession工厂初始化，解析Mapper里的XML配置进行动态代理MapperProxyFactory->MapperProxy注入到Configuration的Mapper

  • 最终在注解类的帮助下进行方法注入，等执行操作时候即可获得动态代理对象，从而执行相应的CRUD操作

    1. @Resource
    2. private ISchoolDao schoolDao;
    4. schoolDao.querySchoolInfoById(1L);

六、综上总结

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

几百行代码写个Mybatis，原理搞的透透的！的更多相关文章

  1. python实战：用70行代码写了一个山炮计算器！

    python实战训练:用70行代码写了个山炮计算器! 好了...好了...各位因为我是三年级而发牢骚的各位伙伴们,我第一次为大家插播了python的基础实战训练.这个,我是想给,那些python基础一 ...

  2. JELLY技术周刊 Vol.24 -- 技术周刊 &#183; 实现 Recoil 只需百行代码？

    蒲公英 · JELLY技术周刊 Vol.24 理解一个轮子最好的方法就是仿造一个轮子,很多框架都因此应运而生,比如面向 JS 开发者的 AI 工具 Danfo.js:参考 qiankun 的微前端框架 ...

  3. 继续node爬虫 — 百行代码自制自动AC机器人日解千题攻占HDOJ

    前言 不说话,先猛戳 Ranklist 看我排名. 这是用 node 自动刷题大概半天的 "战绩",本文就来为大家简单讲解下如何用 node 做一个 "自动AC机&quo ...

  4. 【编程教室】PONG - 100行代码写一个弹球游戏

    大家好,欢迎来到 Crossin的编程教室 ! 今天跟大家讲一讲:如何做游戏 游戏的主题是弹球游戏<PONG>,它是史上第一款街机游戏.因此选它作为我这个游戏开发系列的第一期主题. 游戏引 ...

  5. 50行代码写的一个插件，破解一个H5小游戏

    小游戏链接:测测你的眼睛对色差的辨识度http://www.webhek.com/post/color-test.html?from=timeline 废话不多说,先放代码: window.onloa ...

  6. 几百行代码实现一个 JSON 解析器

    前言 之前在写 gscript时我就在想有没有利用编译原理实现一个更实际工具?毕竟真写一个语言的难度不低,并且也很难真的应用起来. 一次无意间看到有人提起 JSON 解析器,这类工具充斥着我们的日常开 ...

  7. [500lines]500行代码写web server

    项目地址:https://github.com/aosabook/500lines/tree/master/web-server.作者是来自Mozilla的Greg Wilson.项目是用py2写成. ...

  8. js280行代码写2048

    2048 原作者就是用Js写的,一直想尝试.但久久未动手. 昨天教学生学习JS代码.最好还是就做个有趣的游戏好了.2048这么火,是一个不错的选择. 思路: 1. 数组 ,2维数组4x4 2. 移动算 ...

  9. Redux百行代码千行文档

    接触Redux不过短短半年,从开始看官方文档的一头雾水,到渐渐已经理解了Redux到底是在做什么,但是绝大数场景下Redux都是配合React一同使用的,因而会引入了React-Redux库,但是正是 ...

随机推荐

  1. linux基础（电脑基本原理）

    1.计算机体系结构:运算器  控制器   存储器  输入设备   输出设备 详解:存储即内存:编址的存储单元.即每一个存储单元在都有一个编址. 控制器告诉运算器加数在存储器的哪个存储单元. POST: ...

  2. 透彻理解液晶显示模组LCD1602指令集与驱动编程（1）

    LCD1602可以说是大多数单片机工程师了解液晶显示的入门级模组,其显示原理与其它很多显示模组也是相似的,今天我们就来详细讨论一下它的指令集.所谓模组的指令集,本质上是该模组使用的控制芯片的指令集,本 ...

  3. redis淘汰+过期双向保证高可用 | redis 为什么那么快？

    前言 redis和数据相比除了他们的结构型颠覆以外!还有他们存储位置也是不相同.传统数据库将数据存储在硬盘上每次数据操作都需要IO而Redis是将数据存储在内存上的.这里稍微解释下IO是啥意思.IO就 ...

  4. Go语言中slice作为参数传递时遇到的一些“坑”

    前言 相信看到这个题目,可能大家都觉得是一个老生常谈的月经topic了.一直以来其实把握一个"值传递"基本上就能理解各种情况了,不过最近遇到了更深一点的"小坑" ...

  5. MindSpore模型精度调优实战：如何更快定位精度问题

    摘要:为大家梳理了针对常见精度问题的调试调优指南,将以"MindSpore模型精度调优实战"系列文章的形式分享出来,帮助大家轻松定位精度问题,快速优化模型精度. 本文分享自华为云社 ...

  6. .net获取项目根目录方法集合

    这篇文章是别的博客复下来,收藏的: 编写程序的时候,经常需要用的项目根目录.自己总结如下 1.取得控制台应用程序的根目录方法     方法1.Environment.CurrentDirectory ...

  7. hdu 2604 递推 矩阵快速幂

    HDU 2604 Queuing (递推+矩阵快速幂) 这位作者讲的不错,可以看看他的 #include <cstdio> #include <iostream> #inclu ...

  8. 实例化Class类的5种方法

    实例说明 java的数据类型分为两类:基础数据类型和引用数据类型.对于每种类型的对象,java虚拟机会实例化不可变的java.lang.Class对象.它提供了在运行时检查对象属性的方法,这些属性包括 ...

  9. javascript数组 （转）

      javascript的Array可以包含任意数据类型,并通过索引来访问每个元素.   要取得Array的长度,直接访问length属性:   var arr = [1,2,3.14,'Hell0' ...

  10. Kotlin Coroutine(协程): 一、样例

    @ 目录 前言 一.直接上例子 1.延时任务. 2.异步任务 3.并行任务: 4.定时任务: 总结 前言 你还在用 Hanlder + Message? 或者 AsyncTask? 你还在用 Rxja ...