源码分析 | 手写mybait-spring核心功能(干货好文一次学会工厂bean、类代理、bean注册的使用)
作者：付政委
博客：https://bugstack.cn
小傅哥 | https://bugstack.cn
沉淀、分享、成长，让自己和他人都能有所收获。专注于原创专题案例编写，目前已完成的专题有；Netty4.x实战专题案例、用Java实现JVM、基于JavaAgent的全链路监控、手写RPC框架、架构设计专题案例、源码分析等。
你用剑🗡、我用刀🔪，好的代码都很烧，望你不吝出招！
目录
一、前言介绍二、以往章节三、一碟小菜类代理1. 定义一个 IUserDao 接口并实现这个接口类2. new() 方式实例化3. proxy 方式实例化四、盛宴来自Bean工厂1. FactoryBean的使用2. BeanDefinitionRegistryPostProcessor 类注册五、老板郎上主食呀(mybaits-spring)1. 需要实现哪些核心类2. (类介绍)SqlSessionFactoryBean3. (类介绍)MapperScannerConfigurer4. (类介绍)MapperFactoryBean六、酒倒满走一个七、综上总结八、文末惊喜
一、前言介绍
一个知识点的学习过程基本分为；运行helloworld、熟练使用api、源码分析、核心专家。在分析mybaits以及mybatis-spring源码之前，我也只是简单的使用，因为它好用。但是他是怎么做的多半是凭自己的经验去分析，但始终觉得这样的感觉缺少点什么，在几次夙兴夜寐，靡有朝矣之后决定彻底的研究一下，之后在去仿照着写一版核心功能。依次来补全自己的技术栈的空缺。在现在技术知识像爆炸一样迸发，而我们多半又忙于工作业务开发。就像一个不会修车的老司机，只能一脚油门，一脚刹车的奔波。车速很快，但经不起坏，累觉不爱。好！为了解决这样问题，也为了钱程似锦（形容钱多的想家里的棉布一样），努力！
开动之前先庆祝下我的iPhone4s又活了，还是那么好用(嗯！有点卡
二、以往章节
关于mybaits & spring 源码分析以及demo功能的章节汇总，可以通过下列内容进行系统的学习，同时以下章节会有部分内容涉及到demo版本的mybaits；
三、一碟小菜类代理
往往从最简单的内容才有抓手。先看一个接口到实现类的使用，在将这部分内容转换为代理类。
1. 定义一个 IUserDao 接口并实现这个接口类
1public interface IUserDao {
2
3 String queryUserInfo();
4
5}
6
7public class UserDao implements IUserDao {
8
9 @Override
10 public String queryUserInfo() {
11 return "实现类";
12 }
13
14}
2. new() 方式实例化
1IUserDao userDao = new UserDao();
2userDao.queryUserInfo();
这是最简单的也是最常用的使用方式，new 个对象。
3. proxy 方式实例化
1ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
2Class<?>[] classes = {IUserDao.class};
3InvocationHandler handler = (proxy, method, args) -> "你被代理了 " + method.getName();
4
5IUserDao userDao = (IUserDao) Proxy.newProxyInstance(classLoader, classes, handler);
6
7String res = userDao.queryUserInfo();
8logger.info("测试结果：{}", res);
Proxy.newProxyInstance 代理类实例化方式，对应传入类的参数即可
ClassLoader，是这个类加载器，我们可以获取当前线程的类加载器
InvocationHandler 是代理后实际操作方法执行的内容，在这里可以添加自己业务场景需要的逻辑，在这里我们只返回方法名
测试结果：
123:20:18.841 [main] INFO org.itstack.demo.test.ApiTest - 测试结果：你被代理了 queryUserInfo
2
3Process finished with exit code 0
四、盛宴来自Bean工厂
在使用Spring的时候，我们会采用注册或配置文件的方式，将我们的类交给Spring管理。例如；
1<bean id="userDao" class="org.itstack.demo.UserDao" scope="singleton"/>
UserDao是接口IUserDao的实现类，通过上面配置，就可以实例化一个类供我们使用，但如果IUserDao没有实现类或者我们希望去动态改变他的实现类比如挂载到别的地方(像mybaits一样)，并且是由spring bean工厂管理的，该怎么做呢？
1. FactoryBean的使用
FactoryBean 在spring起到着二当家的地位，它将近有70多个小弟(实现它的接口定义)，那么它有三个方法；
T getObject() throws Exception; 返回bean实例对象
Class getObjectType(); 返回实例类类型
boolean isSingleton(); 判断是否单例，单例会放到Spring容器中单实例缓存池中
那么我们现在就将上面用到的代理类交给spring的FactoryBean进行管理，代码如下；
ProxyBeanFactory.java & bean工厂实现类
1public class ProxyBeanFactory implements FactoryBean<IUserDao> {
2
3 @Override
4 public IUserDao getObject() throws Exception {
5
6 ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
7 Class<?>[] classes = {IUserDao.class};
8 InvocationHandler handler = (proxy, method, args) -> "你被代理了 " + method.getName();
9
10 return (IUserDao) Proxy.newProxyInstance(classLoader, classes, handler);
11 }
12
13 @Override
14 public Class<?> getObjectType() {
15 return IUserDao.class;
16 }
17
18 @Override
19 public boolean isSingleton() {
20 return true;
21 }
22
23}
spring-config.xml & 配置bean类信息
1<bean id="userDao" class="org.itstack.demo.bean.ProxyBeanFactory"/>
ApiTest.test_IUserDao() & 单元测试
1@Test
2public 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一月 20, 2020 23:43:35 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
2信息: Loading XML bean definitions from class path resource [spring-config.xml]
323:43:35.440 [main] INFO org.itstack.demo.test.ApiTest - 测试结果：你被代理了 queryUserInfo
4
5Process finished with exit code 0
6
咋样，神奇不！你的接口都不需要实现类，就被安排的明明白白的。记住这个方法FactoryBean和动态代理。
2. BeanDefinitionRegistryPostProcessor 类注册
你是否有怀疑过你媳妇把你钱没收了之后都存放到哪去了，为啥你每次get都那么费劲，像垃圾回收了一样，不可达。
好嘞，媳妇那就别想了，研究下你的bean都被注册到哪了就可以了。在spring的bean管理中，所有的bean最终都会被注册到类DefaultListableBeanFactory中，接下来我们就主动注册一个被我们代理了的bean。
RegisterBeanFactory.java & 注册bean的实现类
1public class RegisterBeanFactory implements BeanDefinitionRegistryPostProcessor {
2
3 @Override
4 public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
5
6 GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
7 beanDefinition.setBeanClass(ProxyBeanFactory.class);
8
9 BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(beanDefinition, "userDao");
10 registry.registerBeanDefinition(definitionHolder.getBeanName(), definitionHolder.getBeanDefinition());
11 }
12
13 @Override
14 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
15 // left intentionally blank
16 }
17
18}
这里包含4块主要内容，分别是；
实现BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry方法，获取bean注册对象
定义bean，GenericBeanDefinition，这里主要设置了我们的代理类工厂。我们已经测试过他获取一个代理类
创建bean定义处理类，BeanDefinitionHolder，这里需要的主要参数；定义bean、bean名称
最后将我们自己的bean注册到spring容器中去，registry.registerBeanDefinition()
spring-config.xml & 配置bean类信息
1<bean id="userDao" class="org.itstack.demo.bean.RegisterBeanFactory"/>
ApiTest.test_IUserDao() & 单元测试
1@Test
2public 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信息: Loading XML bean definitions from class path resource [spring-config.xml]
2一月 20, 2020 23:42:29 上午 org.springframework.beans.factory.support.DefaultListableBeanFactory registerBeanDefinition
3信息: Overriding bean definition for bean 'userDao' with a different definition: replacing [Generic bean: class [org.itstack.demo.bean.RegisterBeanFactory]; scope=; abstract=false; lazyInit=false; autowireMode=1; dependencyCheck=0; autowireCandidate=true; primary=false; factoryBeanName=null; factoryMethodName=null; initMethodName=null; destroyMethodName=null; defined in class path resource [spring-config.xml]] with [Generic bean: class [org.itstack.demo.bean.ProxyBeanFactory]; scope=; abstract=false; lazyInit=false; autowireMode=0; dependencyCheck=0; autowireCandidate=true; primary=false; factoryBeanName=null; factoryMethodName=null; initMethodName=null; destroyMethodName=null]
423:42:29.754 [main] INFO org.itstack.demo.test.ApiTest - 测试结果：你被代理了 queryUserInfo
5
6Process finished with exit code 0
纳尼？是不有一种满脑子都是骚操作的感觉，自己注册的bean自己知道在哪了，咋回事了。
五、老板郎上主食呀(mybaits-spring)
如果通过上面的知识点；代理类、bean工厂、bean注册，将我们一个没有实现类的接口安排的明明白白，让他执行啥就执行啥，那么你是否可以想到，这个没有实现类的接口，可以通过我们的折腾，去调用到我们的mybaits呢！
如下图，通过mybatis使用的配置，我们可以看到数据源DataSource交给SqlSessionFactoryBean，SqlSessionFactoryBean实例化出的SqlSessionFactory，再交给MapperScannerConfigurer。而我们要实现的就是MapperScannerConfigurer这部分；
1. 需要实现哪些核心类
为了更易理解也更易于对照，我们将实现mybatis-spring中的流程核心类，如下；
MapperFactoryBean ｛给每一个没有实现类的接口都代理一个这样的类，用于操作数据库执行crud｝
MapperScannerConfigurer ｛扫描包下接口类，免去配置。这样是上图中核心配置类｝
SimpleMetadataReader ｛这个类完全和mybaits-spring中的类一样，为了解析class文件。如果你对类加载处理很好奇，可以阅读我的《用java实现jvm虚拟机》｝
SqlSessionFactoryBean {这个类核心内容就一件事，将我们写的demo版的mybaits结合进来}
在分析之前先看下我们实现主食是怎么食用的，如下；
1<bean id="sqlSessionFactory" class="org.itstack.demo.like.spring.SqlSessionFactoryBean">
2 <property name="resource" value="spring/mybatis-config-datasource.xml"/>
3</bean>
4
5<bean class="org.itstack.demo.like.spring.MapperScannerConfigurer">
6 <!-- 注入sqlSessionFactory -->
7 <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
8 <!-- 给出需要扫描Dao接口包 -->
9 <property name="basePackage" value="org.itstack.demo.dao"/>
10</bean>
2. (类介绍)SqlSessionFactoryBean
这类本身比较简单，主要实现了FactoryBean
SqlSessionFactoryBean.java
1public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>, InitializingBean {
2
3 private String resource;
4 private SqlSessionFactory sqlSessionFactory;
5
6 @Override
7 public void afterPropertiesSet() throws Exception {
8 try (Reader reader = Resources.getResourceAsReader(resource)) {
9 this.sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
10 } catch (Exception e) {
11 e.printStackTrace();
12 }
13 }
14
15 @Override
16 public SqlSessionFactory getObject() throws Exception {
17 return sqlSessionFactory;
18 }
19
20 @Override
21 public Class<?> getObjectType() {
22 return sqlSessionFactory.getClass();
23 }
24
25 @Override
26 public boolean isSingleton() {
27 return true;
28 }
29
30 public void setResource(String resource) {
31 this.resource = resource;
32 }
33
34}
实现InitializingBean主要用于加载mybatis相关内容；解析xml、构造SqlSession、链接数据库等
FactoryBean，这个类我们介绍过，主要三个方法；getObject()、getObjectType()、isSingleton()
3. (类介绍)MapperScannerConfigurer
这类的内容看上去可能有点多，但是核心事情也就是将我们的dao层接口扫描、注册
1public class MapperScannerConfigurer implements BeanDefinitionRegistryPostProcessor {
2
3 private String basePackage;
4 private SqlSessionFactory sqlSessionFactory;
5
6 @Override
7 public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
8 try {
9 // classpath*:org/itstack/demo/dao/**/*.class
10 String packageSearchPath = "classpath*:" + basePackage.replace('.', '/') + "/**/*.class";
11
12 ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
13 Resource[] resources = resourcePatternResolver.getResources(packageSearchPath);
14
15 for (Resource resource : resources) {
16 MetadataReader metadataReader = new SimpleMetadataReader(resource, ClassUtils.getDefaultClassLoader());
17
18 ScannedGenericBeanDefinition beanDefinition = new ScannedGenericBeanDefinition(metadataReader);
19 String beanName = Introspector.decapitalize(ClassUtils.getShortName(beanDefinition.getBeanClassName()));
20
21 beanDefinition.setResource(resource);
22 beanDefinition.setSource(resource);
23 beanDefinition.setScope("singleton");
24 beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(beanDefinition.getBeanClassName());
25 beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(sqlSessionFactory);
26 beanDefinition.setBeanClass(MapperFactoryBean.class);
27
28 BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(beanDefinition, beanName);
29 registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
30 }
31 } catch (IOException e) {
32 e.printStackTrace();
33 }
34
35 }
36
37 @Override
38 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
39 // left intentionally blank
40 }
41
42 public void setBasePackage(String basePackage) {
43 this.basePackage = basePackage;
44 }
45
46 public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
47 this.sqlSessionFactory = sqlSessionFactory;
48 }
49}
类的扫描注册，classpath:org/itstack/demo/dao//.class，解析calss文件获取资源信息；Resource[] resources = resourcePatternResolver.getResources(packageSearchPath);
遍历Resource，这里就你的class信息，用于注册bean。ScannedGenericBeanDefinition
这里有一点，bean的定义设置时候，是把beanDefinition.setBeanClass(MapperFactoryBean.class);设置进去的。同时在前面给他设置了构造参数。（细细品味，你细品）
最后执行注册registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
4. (类介绍)MapperFactoryBean
这个类就非常有意思了，因为你所有的dao接口类，实际就是他。他这里帮你执行你对sql的所有操作的分发处理。为了更加简化清晰，目前这里只实现了查询部分，在mybatis-spring源码中分别对select、update、insert、delete、其他等做了操作。
1public class MapperFactoryBean<T> implements FactoryBean<T> {
2
3 private Class<T> mapperInterface;
4 private SqlSessionFactory sqlSessionFactory;
5
6 public MapperFactoryBean(Class<T> mapperInterface, SqlSessionFactory sqlSessionFactory) {
7 this.mapperInterface = mapperInterface;
8 this.sqlSessionFactory = sqlSessionFactory;
9 }
10
11 @Override
12 public T getObject() throws Exception {
13 InvocationHandler handler = (proxy, method, args) -> {
14 System.out.println("你被代理了，执行SQL操作！" + method.getName());
15 try {
16 SqlSession session = sqlSessionFactory.openSession();
17 try {
18 return session.selectOne(mapperInterface.getName() + "." + method.getName(), args[0]);
19 } finally {
20 session.close();
21 }
22 } catch (Exception e) {
23 e.printStackTrace();
24 }
25
26 return method.getReturnType().newInstance();
27 };
28 return (T) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class[]{mapperInterface}, handler);
29 }
30
31 @Override
32 public Class<?> getObjectType() {
33 return mapperInterface;
34 }
35
36 @Override
37 public boolean isSingleton() {
38 return true;
39 }
40
41}
T getObject()，中是一个java代理类的实现，这个代理类对象会被挂到你的注入中。真正调用方法内容时会执行到代理类的实现部分，也就是“你被代理了，执行SQL操作！”
InvocationHandler，代理类的实现部分非常简单，主要开启SqlSession，并通过固定的key；“org.itstack.demo.dao.IUserDao.queryUserInfoById”执行SQL操作；
session.selectOne(mapperInterface.getName() + "." + method.getName(), args[0]);
1<mapper namespace="org.itstack.demo.dao.IUserDao"><select id="queryUserInfoById" parameterType="java.lang.Long" resultType="org.itstack.demo.po.User"></mapper>
2 SELECT id, name, age, createTime, updateTime
3 FROM user
4 where id = #{id}
5</select>
6最终返回了执行结果，关于查询到结果信息会反射操作成对象类，这部分内容可以遇到demo版本的mybatis
六、酒倒满走一个
好！到这一切开发内容就完成了，测试走一个。
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">
4
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_demo_ddd?useUnicode=true"/>
12 <property name="username" value="root"/>
13 <property name="password" value="123456"/>
14 </dataSource>
15 </environment>
16 </environments>
17
18 <mappers>
19 <mapper resource="mapper/User_Mapper.xml"/>
20 <mapper resource="mapper/School_Mapper.xml"/>
21 </mappers>
22
23</configuration>
test-config.xml & 配置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 xmlns:context="http://www.springframework.org/schema/context"
5 xmlns:aop="http://www.springframework.org/schema/aop"
6 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"
7 default-autowire="byName">
8 <context:component-scan base-package="org.itstack"/>
9
10 <aop:aspectj-autoproxy/>
11
12 <bean id="sqlSessionFactory" class="org.itstack.demo.like.spring.SqlSessionFactoryBean">
13 <property name="resource" value="spring/mybatis-config-datasource.xml"/>
14 </bean>
15
16 <bean class="org.itstack.demo.like.spring.MapperScannerConfigurer">
17 <!-- 注入sqlSessionFactory -->
18 <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
19 <!-- 给出需要扫描Dao接口包 -->
20 <property name="basePackage" value="org.itstack.demo.dao"/>
21 </bean>
22
23</beans>
SpringTest.java & 单元测试
1public class SpringTest {
2
3 private Logger logger = LoggerFactory.getLogger(SpringTest.class);
4
5 @Test
6 public void test_ClassPathXmlApplicationContext() {
7 BeanFactory beanFactory = new ClassPathXmlApplicationContext("test-config.xml");
8 IUserDao userDao = beanFactory.getBean("IUserDao", IUserDao.class);
9 User user = userDao.queryUserInfoById(1L);
10 logger.info("测试结果：{}", JSON.toJSONString(user));
11 }
12
13}
测试结果；
1一月 20, 2020 23:51:43 上午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
2信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@30b8a058: startup date [Mon Jan 20 23:51:43 CST 2020]; root of context hierarchy
3一月 20, 2020 23:51:43 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
4信息: Loading XML bean definitions from class path resource [test-config.xml]
5你被代理了，执行SQL操作！queryUserInfoById
62020-01-20 23:51:45.592 [main] INFO org.itstack.demo.SpringTest[26] - 测试结果：{"age":18,"createTime":1576944000000,"id":1,"name":"水水","updateTime":1576944000000}
7
8Process finished with exit code 0
酒干热火笑红尘，春秋几载年轮，不问。回首皆是Spring！Gun！变心！你被代理了！
七、综上总结
通过这些核心关键类的实现；SqlSessionFactoryBean、MapperScannerConfigurer、SqlSessionFactoryBean，我们将spring与mybaits集合起来使用，解决了没有实现类的接口怎么处理数据库CRUD操作
那么这个知识点可以用到哪里，不要只想着面试！在我们业务开发中是不会有很多其他数据源操作，比如ES、Hadoop、数据中心等等，包括自建。那么我们就可以做成一套统一数据源处理服务，以优化服务开发效率
由于这次工程类是在itstack-demo-code-mybatis中继续开发，如果需要获取源码可以关注公众号：bugstack虫洞栈，回复：源码分析
最后祝福大家在新的一年里；万事如意、恭贺新禧、喜气洋洋、福星高照、欢天喜地、吉祥如意、一帆风顺、万事大吉、龙凤呈祥、步步高升，一家瑞气，二气雍和，三星拱户，四季平安，五星高照。六六大顺，七星高照，八方来财，九九同心，十全十美。