几百行代码写个Mybatis，原理搞的透透的！_bugstack虫洞栈

作者：小傅哥
博客：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. 定义接口

public interface IUserDao {

    String queryUserInfo();

}

• 先定义一个类似 DAO 的接口，基本这样的接口在使用 MyBatis 时还是非常常见的。后面我们会对这个接口做代理和注册。

2. 类代理实现

ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
Class<?>[] classes = {IUserDao.class};    

InvocationHandler handler = (proxy, method, args) -> "你被代理了 " + method.getName();
IUserDao userDao = (IUserDao) Proxy.newProxyInstance(classLoader, classes, handler); 

String res = userDao.queryUserInfo();
logger.info("测试结果：{}", res);

• Java 本身的代理方式使用起来还是比较简单的，用法也很固定。
• InvocationHandler 是个接口类，它对应的实现内容就是代理对象的具体实现。
• 最后就是把代理交给 Proxy 创建代理对象，Proxy.newProxyInstance。

3. 实现Bean工厂

public class ProxyBeanFactory implements FactoryBean {

    @Override
    public Object getObject() throws Exception {

        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        Class[] classes = {IUserDao.class};
        InvocationHandler handler = (proxy, method, args) -> "你被代理了 " + method.getName();

        return Proxy.newProxyInstance(classLoader, classes, handler);
    }

    @Override
    public Class<?> getObjectType() {
        return IUserDao.class;
    } 

}

• FactoryBean 在 spring 起到着二当家的地位，它将近有70多个小弟(实现它的接口定义)，那么它有三个方法；
  • T getObject() throws Exception; 返回bean实例对象
  • Class<?> getObjectType(); 返回实例类类型
  • boolean isSingleton(); 判断是否单例，单例会放到Spring容器中单实例缓存池中
• 在这里我们把上面使用Java代理的对象放到了 getObject() 方法中，那么现在再从 Spring 中获取到的对象，就是我们的代理对象了。

4. Bean 注册

public class RegisterBeanFactory implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {

        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        beanDefinition.setBeanClass(ProxyBeanFactory.class);

        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(beanDefinition, "userDao");
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
    }

}

在 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

<bean id="userDao" class="org.itstack.interview.bean.RegisterBeanFactory"/>

• 这里我们把 RegisterBeanFactory 配置到 spring 的 xml 配置中，便于启动时加载。

2. 单元测试

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

测试结果

22:53:14.759 [main] DEBUG o.s.c.e.PropertySourcesPropertyResolver - Could not find key 'spring.liveBeansView.mbeanDomain' in any property source
22:53:14.760 [main] DEBUG o.s.b.f.s.DefaultListableBeanFactory - Returning cached instance of singleton bean 'userDao'
22:53:14.796 [main] INFO  org.itstack.interview.test.ApiTest - 测试结果：你被代理了 queryUserInfo

Process finished with exit code 0

• 从测试结果可以看到，我们已经可以通过注入到Spring的代理Bean对象，实现我们的预期结果。
• 其实这个过程也是很多框架中用到的方式，尤其是在一些中间件开发，类似的 ORM 框架都需要使用到。

三、手写个Mybatis

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

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

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

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

1. 先测试下整个DemoJdbc框架

ApiLikeTest.test_queryUserInfoById()

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

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

{"age":18,"createTime":1576944000000,"id":1,"name":"水水","updateTime":1576944000000}

Process finished with exit code 0

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

MybatisApiTest.java 里面引入的包

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

ApiLikeTest.java 里面引入的包

import org.itstack.demo.like.Resources;
import org.itstack.demo.like.SqlSession;
import org.itstack.demo.like.SqlSessionFactory;
import org.itstack.demo.like.SqlSessionFactoryBuilder;

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

2. 加载XML配置文件

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

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

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/itstack?useUnicode=true"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="mapper/User_Mapper.xml"/>
        <mapper resource="mapper/School_Mapper.xml"/>
    </mappers>

</configuration>

User_Mapper.xml & Mapper 映射配置

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.itstack.demo.dao.IUserDao">

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

    <select id="queryUserList" parameterType="org.itstack.demo.po.User" resultType="org.itstack.demo.po.User">
        SELECT id, name, age, createTime, updateTime
        FROM user
        where age = #{age}
    </select>

</mapper>

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

ApiLikeTest.test_queryUserInfoById() & 部分截取

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

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

Resources.java & 资源类

/**
 * 博 客 | https://bugstack.cn
 * Create by 小傅哥 @2020
 */
public class Resources {

    public static Reader getResourceAsReader(String resource) throws IOException {
        return new InputStreamReader(getResourceAsStream(resource));
    }

    private static InputStream getResourceAsStream(String resource) throws IOException {
        ClassLoader[] classLoaders = getClassLoaders();
        for (ClassLoader classLoader : classLoaders) {
            InputStream inputStream = classLoader.getResourceAsStream(resource);
            if (null != inputStream) {
                return inputStream;
            }
        }
        throw new IOException("Could not find resource " + resource);
    }

    private static ClassLoader[] getClassLoaders() {
        return new ClassLoader[]{
                ClassLoader.getSystemClassLoader(),
                Thread.currentThread().getContextClassLoader()};
    }

}

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

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

3. 解析XML配置文件

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

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

SqlSessionFactoryBuilder.build() & 入口构建类

public DefaultSqlSessionFactory build(Reader reader) {
    SAXReader saxReader = new SAXReader();
    try {
        Document document = saxReader.read(new InputSource(reader));
        Configuration configuration = parseConfiguration(document.getRootElement());
        return new DefaultSqlSessionFactory(configuration);
    } catch (DocumentException e) {
        e.printStackTrace();
    }
    return null;
}

• 通过读取流创建 xml 解析的 Document 类
• parseConfiguration 进行解析 xml 文件，并将结果设置到配置类中，包括；连接池、数据源、mapper关系

SqlSessionFactoryBuilder.parseConfiguration() & 解析过程

private Configuration parseConfiguration(Element root) {
    Configuration configuration = new Configuration();
    configuration.setDataSource(dataSource(root.selectNodes("//dataSource")));
    configuration.setConnection(connection(configuration.dataSource));
    configuration.setMapperElement(mapperElement(root.selectNodes("mappers")));
    return configuration;
}

• 在前面的 xml 内容中可以看到，我们需要解析出数据库连接池信息 datasource，还有数据库语句映射关系 mappers

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

private Map<String, String> dataSource(List<Element> list) {
    Map<String, String> dataSource = new HashMap<>(4);
    Element element = list.get(0);
    List content = element.content();
    for (Object o : content) {
        Element e = (Element) o;
        String name = e.attributeValue("name");
        String value = e.attributeValue("value");
        dataSource.put(name, value);
    }
    return dataSource;
}

• 这个过程比较简单，只需要将数据源信息获取即可

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

private Connection connection(Map<String, String> dataSource) {
    try {
        Class.forName(dataSource.get("driver"));
        return DriverManager.getConnection(dataSource.get("url"), dataSource.get("username"), dataSource.get("password"));
    } catch (ClassNotFoundException | SQLException e) {
        e.printStackTrace();
    }
    return null;
}

• 这个就是jdbc最原始的代码，获取了数据库连接池

SqlSessionFactoryBuilder.mapperElement() & 解析SQL语句

private Map<String, XNode> mapperElement(List<Element> list) {
    Map<String, XNode> map = new HashMap<>();
    Element element = list.get(0);
    List content = element.content();
    for (Object o : content) {
        Element e = (Element) o;
        String resource = e.attributeValue("resource");
        try {
            Reader reader = Resources.getResourceAsReader(resource);
            SAXReader saxReader = new SAXReader();
            Document document = saxReader.read(new InputSource(reader));
            Element root = document.getRootElement();
            //命名空间
            String namespace = root.attributeValue("namespace");
            // SELECT
            List<Element> selectNodes = root.selectNodes("select");
            for (Element node : selectNodes) {
                String id = node.attributeValue("id");
                String parameterType = node.attributeValue("parameterType");
                String resultType = node.attributeValue("resultType");
                String sql = node.getText();
                // ? 匹配
                Map<Integer, String> parameter = new HashMap<>();
                Pattern pattern = Pattern.compile("(#\\{(.*?)})");
                Matcher matcher = pattern.matcher(sql);
                for (int i = 1; matcher.find(); i++) {
                    String g1 = matcher.group(1);
                    String g2 = matcher.group(2);
                    parameter.put(i, g2);
                    sql = sql.replace(g1, "?");
                }
                XNode xNode = new XNode();
                xNode.setNamespace(namespace);
                xNode.setId(id);
                xNode.setParameterType(parameterType);
                xNode.setResultType(resultType);
                xNode.setSql(sql);
                xNode.setParameter(parameter);
                
                map.put(namespace + "." + id, xNode);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    return map;
}

• 这个过程首先包括是解析所有的sql语句，目前为了测试只解析 select 相关
• 所有的 sql 语句为了确认唯一，都是使用；namespace + select中的id进行拼接，作为 key，之后与sql一起存放到 map 中。
• 在 mybaits 的 sql 语句配置中，都有占位符，用于传参。where id = #{id} 所以我们需要将占位符设置为问号，另外需要将占位符的顺序信息与名称存放到 map 结构，方便后续设置查询时候的入参。

4. 创建DefaultSqlSessionFactory

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

public DefaultSqlSessionFactory build(Reader reader) {
    SAXReader saxReader = new SAXReader();
    try {
        Document document = saxReader.read(new InputSource(reader));
        Configuration configuration = parseConfiguration(document.getRootElement());
        return new DefaultSqlSessionFactory(configuration);
    } catch (DocumentException e) {
        e.printStackTrace();
    }
    return null;
}

DefaultSqlSessionFactory.java & SqlSessionFactory的实现类

public class DefaultSqlSessionFactory implements SqlSessionFactory {
    
	private final Configuration configuration;
    
	public DefaultSqlSessionFactory(Configuration configuration) {
        this.configuration = configuration;
    }
	
    @Override
    public SqlSession openSession() {
        return new DefaultSqlSession(configuration.connection, configuration.mapperElement);
    }
	
}

• 这个过程比较简单，构造函数只提供了配置类入参
• 实现 SqlSessionFactory 的 openSession()，用于创建 DefaultSqlSession，也就可以执行 sql 操作

5. 开启SqlSession

SqlSession session = sqlMapper.openSession();

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

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

6. 执行SQL语句

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

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

SqlSession.java & 定义

public interface SqlSession {

    <T> T selectOne(String statement);

    <T> T selectOne(String statement, Object parameter);

    <T> List<T> selectList(String statement);

    <T> List<T> selectList(String statement, Object parameter);

    void close();
}

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

DefaultSqlSession.selectOne() & 执行查询

public <T> T selectOne(String statement, Object parameter) {
    XNode xNode = mapperElement.get(statement);
    Map<Integer, String> parameterMap = xNode.getParameter();
    try {
        PreparedStatement preparedStatement = connection.prepareStatement(xNode.getSql());
        buildParameter(preparedStatement, parameter, parameterMap);
        ResultSet resultSet = preparedStatement.executeQuery();
        List<T> objects = resultSet2Obj(resultSet, Class.forName(xNode.getResultType()));
        return objects.get(0);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

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

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

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

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

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

  private void buildParameter(PreparedStatement preparedStatement, Object parameter, Map<Integer, String> parameterMap) throws SQLException, IllegalAccessException {
  
        int size = parameterMap.size();
        // 单个参数
        if (parameter instanceof Long) {
            for (int i = 1; i <= size; i++) {
                preparedStatement.setLong(i, Long.parseLong(parameter.toString()));
            }
            return;
        }
  
        if (parameter instanceof Integer) {
            for (int i = 1; i <= size; i++) {
                preparedStatement.setInt(i, Integer.parseInt(parameter.toString()));
            }
            return;
        }
  
        if (parameter instanceof String) {
            for (int i = 1; i <= size; i++) {
                preparedStatement.setString(i, parameter.toString());
            }
            return;
        }
  
        Map<String, Object> fieldMap = new HashMap<>();
        // 对象参数
        Field[] declaredFields = parameter.getClass().getDeclaredFields();
        for (Field field : declaredFields) {
            String name = field.getName();
            field.setAccessible(true);
            Object obj = field.get(parameter);
            field.setAccessible(false);
            fieldMap.put(name, obj);
        }
  
        for (int i = 1; i <= size; i++) {
            String parameterDefine = parameterMap.get(i);
            Object obj = fieldMap.get(parameterDefine);
  
            if (obj instanceof Short) {
                preparedStatement.setShort(i, Short.parseShort(obj.toString()));
                continue;
            }
  
            if (obj instanceof Integer) {
                preparedStatement.setInt(i, Integer.parseInt(obj.toString()));
                continue;
            }
  
            if (obj instanceof Long) {
                preparedStatement.setLong(i, Long.parseLong(obj.toString()));
                continue;
            }
  
            if (obj instanceof String) {
                preparedStatement.setString(i, obj.toString());
                continue;
            }
  
            if (obj instanceof Date) {
                preparedStatement.setDate(i, (java.sql.Date) obj);
            }
  
        }
  
    }
  

  • 单个参数比较简单直接设置值即可，Long、Integer、String …
  • 如果是一个类对象，需要通过获取 Field 属性，与参数 Map 进行匹配设置

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

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

  private <T> List<T> resultSet2Obj(ResultSet resultSet, Class<?> clazz) {
  	List<T> list = new ArrayList<>();
  	try {
  		ResultSetMetaData metaData = resultSet.getMetaData();
  		int columnCount = metaData.getColumnCount();
  		// 每次遍历行值
  		while (resultSet.next()) {
  			T obj = (T) clazz.newInstance();
  			for (int i = 1; i <= columnCount; i++) {
  				Object value = resultSet.getObject(i);
  				String columnName = metaData.getColumnName(i);
  				String setMethod = "set" + columnName.substring(0, 1).toUpperCase() + columnName.substring(1);
  				Method method;
  				if (value instanceof Timestamp) {
  					method = clazz.getMethod(setMethod, Date.class);
  				} else {
  					method = clazz.getMethod(setMethod, value.getClass());
  				}
  				method.invoke(obj, value);
  			}
  			list.add(obj);
  		}
  	} catch (Exception e) {
  		e.printStackTrace();
  	}
  	return list;
  }
  

  • 主要通过反射生成我们的类对象，这个类的类型定义在 sql 标签上
  • 时间类型需要判断后处理，Timestamp，与 java 不是一个类型

7. Sql查询补充说明

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

ApiLikeTest.test_queryUserList()

@Test
public void test_queryUserList() {
    String resource = "spring/mybatis-config-datasource.xml";
    Reader reader;
    try {
        reader = Resources.getResourceAsReader(resource);
        SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);
        SqlSession session = sqlMapper.openSession();
        
		try {
            User req = new User();
            req.setAge(18);
            List<User> userList = session.selectList("org.itstack.demo.dao.IUserDao.queryUserList", req);
            System.out.println(JSON.toJSONString(userList));
        } finally {
            session.close();
            reader.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
	
}

**测试结果：

[{"age":18,"createTime":1576944000000,"id":1,"name":"水水","updateTime":1576944000000},{"age":18,"createTime":1576944000000,"id":2,"name":"豆豆","updateTime":1576944000000}]

Process finished with exit code 0

四、源码分析(mybatis)

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

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

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

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

MybatisApiTest.java

public class MybatisApiTest {

    @Test
    public void test_queryUserInfoById() {
        String resource = "spring/mybatis-config-datasource.xml";
        Reader reader;
        try {
            reader = Resources.getResourceAsReader(resource);
            SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);

            SqlSession session = sqlMapper.openSession();
            try {
                User user = session.selectOne("org.itstack.demo.dao.IUserDao.queryUserInfoById", 1L);
                System.out.println(JSON.toJSONString(user));
            } finally {
                session.close();
                reader.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

dao/IUserDao.java

public interface IUserDao {

     User queryUserInfoById(Long id);

}

spring/mybatis-config-datasource.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/itstack?useUnicode=true"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="mapper/User_Mapper.xml"/>
    </mappers>

</configuration>

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

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

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

2. 容器初始化

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

点击全文阅读

本文链接：http://m.zhangshiyu.com/post/24553.html