Spring整合Mybatis原理

首先介绍一下Mybatis的工作原理
先简略的放两张图,后面的知识结合这两张图比较好理解
在这里插入图片描述

在这里插入图片描述

Mybatis的基本工作原理

在 Mybatis 中,我们可以使用⼀个接口去定义要执行sql,简化代码如下:
定义⼀个接口,@Select 表示要执行查询sql语句。

public interface UserMapper {
	@Select("select * from user where id = #{id}")
	User selectById(Integer id);
}

以下为执行sql代码:

InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
// 以下使我们需要关注的重点
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
Integer id = 1;
User user = mapper.selectById(id);

Mybatis 的目的是:使得程序员能够以调用方法的方式执行某个指定的sql,将执行 sql 的底层逻辑进行了封装。
这里重点思考以下 mapper 这个对象,当调用 SqlSession 的 getMapper 方法时,会对传入的接口生成⼀个代理对象,而程序要真正用到的就是这个代理对象,在调用代理对象的方法时,Mybatis 会取出该方法所对应的sql语句,然后利用 JDBC 去执行 sql 语句,最终得到结果。

分析需要解决的问题

Spring 和 Mybatis 时,我们重点要关注的就是这个代理对象。因为整合的目的就是:把某个 Mapper 的代理对象作为⼀个 bean 放入 Spring 容器中,使得能够像使用⼀个普通 bean ⼀样去使用这个代理对象,比如能被 @Autowire 自动注入。
比如当 Spring 和 Mybatis 整合之后,我们就可以使用如下的代码来使用 Mybatis 中的代理对象了:

@Component
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public User getUserById(Integer id) {
        return userMapper.selectById(id);
    }
}

UserService 中的 userMapper属性就会被自动注入为 Mybatis中 的代理对象。如果你基于⼀个已经完成整合的项目去调试即可发现,userMapper 的类型为:
org.apache.ibatis.binding.MapperProxy@41a0aa7d。证明确实是 Mybatis 中的代理对象。
那么现在要解决的问题的就是:
如何能够把 Mybatis的代理对象作为⼀个 bean 放入 Spring 容器中?
要解决这个,我们需要对 Spring 的 bean 生成过程有⼀个了解。

Spring 中 Bean 的产生过程

Spring 启动过程中,大致会经过如下步骤去生成bean

  1. 扫描指定的包路径下的 class 文件
  2. 根据 class 信息生成对应的 BeanDefinition
  3. 在此处,程序员可以利用某些机制去修改 BeanDefinition
  4. 根据 BeanDefinition 生成 bean 实例
  5. 把生成的 bean 实例放入 Spring 容器中

在 Spring 中,Bean 的产生过程可以分为以下几个步骤:

  1. 加载配置文件:Spring 容器会通过指定的配置文件(如XML文件、注解等)读取 Bean 的定义信息。
  2. 解析配置文件:Spring 容器根据配置文件的内容,找到所有需要创建的 Bean 的定义。
  3. 创建 Bean 的实例:Spring 容器根据 Bean 的定义信息,利用 Java 的反射机制创建Bean的实例,并调用其构造方法进行实例化。
  4. 设置 Bean 的属性:Spring 容器会根据配置文件中的属性值,通过调用 Bean 的 setter 方法来设置 Bean 的属性。
  5. 执行自定义的初始化方法:如果 Bean 实现了 InitializingBean 接口或在配置文件中通过 init-method 属性指定了初始化方法,Spring 容器会在 Bean 的所有属性设置完成后调用该方法进行初始化。
  6. 注入依赖:Spring 容器会根据配置文件中的依赖关系,自动将其他 Bean 注入到当前Bean中,可以通过构造器注入、setter 方法注入或字段注入等方式实现。
  7. 使用 Bean:经过以上步骤,Bean 已经成功创建并初始化,可以被其他对象引用和使用。
  8. 执行自定义的销毁方法:如果 Bean 实现了 DisposableBean 接口或在配置文件中通过 destroy-method 属性指定了销毁方法,当容器关闭时,Spring 容器会自动调用该方法对 Bean 进行销毁。
    以上是 Spring 中 Bean 的产生过程的简要介绍,通过 Spring 的 IoC(控制反转)和 DI(依赖注入)机制,开发人员可以更加便捷地管理和使用 Bean,提高代码的可维护性和灵活性。

注:需要更详细的可查阅相关资料!

讲这个问题,是想说明⼀个问题:在 Spring 中,bean 对象跟 class 没有直接关系,跟 BeanDefinition 才有直接关系。
回到我们要解决的问题:
如何能够把 Mybatis 的代理对象作为⼀个 bean 放入 Spring 容器中?
在 Spring 中,如果你想生成⼀个 bean,那么得先生成⼀个 BeanDefinition,就像你想 new⼀个对象实例,得先有⼀个 class。

解决问题

继续回到我们的问题,我们现在想自己生成⼀个 bean,那么得先生成⼀个 BeanDefinition,只要有了 BeanDefinition,通过在 BeanDefinition 中设置 bean 对象的类型,然后把 BeanDefinition 添加给 Spring,Spring 就会根据 BeanDefinition 自动帮我们生成⼀个类型对应的 bean 对象。
所以,现在我们要解决两个问题:
1. Mybatis 的代理对象的类型是什么?
因为我们要设置给 BeanDefinition
2. 我们怎么把 BeanDefinition 添加给 Spring 容器?
注意:上文中我们使用的 BeanFactory 后置处理器,他只能修改 BeanDefinition,并不能新增⼀个 BeanDefinition。我们应该使用Import 技术来添加⼀个 BeanDefinition。后文再详细介绍如果使用Import 技术来添加⼀个 BeanDefinition,可以先看⼀下伪代码实现思路。
假设:我们有⼀个UserMapper接口,他的代理对象的类型为UserMapperProxy。
那么我们的思路就是这样的,伪代码如下:

BeanDefinitoin beanDefinitoin = new BeanDefinitoin();
beanDefinitoin.setBeanClassName(UserMapperProxy.class.getName());
SpringContainer.addBd(beanDefinitoin );

但是,这里有⼀个严重的问题,就是上文中的 UserMapperProxy 是我们假设的,他表示⼀个代理类的类型,然而 Mybatis 中的代理对象是利用的 JDK 的动态代理技术实现的,也就是代理对象的代理类是动态生成的,我们根本无法确定代理对象的代理类到底是什么。
所以回到我们的问题:
Mybatis的代理对象的类型是什么?
本来可以有两个答案:

  1. 代理对象对应的代理类
  2. 代理对象对应的接口

那么答案1就相当于没有了,因为是代理类是动态生成的,那么我们来看答案2:代理对象对应的接口;
如果我们采用答案2,那么我们的思路就是:

BeanDefinition beanDefinition = new BeanDefinitoin();
// 注意这里,设置的是UserMapper
beanDefinition.setBeanClassName(UserMapper.class.getName());
SpringContainer.addBd(bdbeanDefinition);

但是,实际上给BeanDefinition对应的类型设置为⼀个接口是行不通的,因为Spring没有办法根据这个BeanDefinition去new出对应类型的实例,接口是没法直接new出实例的。
那么现在问题来了,要解决的问题:
Mybatis的代理对象的类型是什么?
两个答案都被我们否定了,所以这个问题是无解的,所以我们不能再沿着这个思路去思考了,只能回到最开始的问题:
如何能够把Mybatis的代理对象作为⼀个bean放入Spring容器中?
总结上⾯的推理:
我们想通过设置BeanDefinition的class类型,然后由Spring自动的帮助我们去生成对应的bean,但是这条路是行不通的。

终极解决方案

那么我们还有没有其他办法,可以去生成bean呢?并且生成bean的逻辑不能由Spring来帮我们做了,得由我们自己来做。

FactoryBean

有,那就是Spring中的FactoryBean。我们可以利用FactoryBean去自定义我们要生成的bean对象,比如:

@Component
public class LubanFactoryBean implements FactoryBean {
    @Override
    public Object getObject() throws Exception {
        Object proxyInstance = Proxy.newProxyInstance(LubanFactoryBean.class.getClassLoader(), new Class[]{UserMapper.class}, newInvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if (Object.class.equals(method.getDeclaringClass())) {
                    return method.invoke(this, args);
                } 
                else {
                    // 执行代理逻辑
                    return null;
                }
            }
        });
        return proxyInstance;
    }

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

我们定义了⼀个 LubanFactoryBean,它实现了 FactoryBean,getObject 方法就是用来自定义生成 bean
对象逻辑的。
执行如下代码:

public class Test {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        System.out.println("lubanFactoryBean: " + context.getBean("lubanFactoryBean"));
        System.out.println("&lubanFactoryBean: " + context.getBean("&lubanFactoryBean"));
        System.out.println("lubanFactoryBean-class: " + context.getBean("lubanFactoryBean").getClass());
    }
}

将打印:
lubanFactoryBean: com.luban.util.LubanFactoryBeanKaTeX parse error: Expected 'EOF', got '&' at position 11: 1@4d41cee &̲lubanFactoryBea…Proxy20

从结果我们可以看到,从 Spring 容器中拿名字为"lubanFactoryBean"的bean对象,就是我们所自定义的 JDK 动态代理所生成的代理对象。

所以,我们可以通过 FactoryBean 来向 Spring 容器中添加⼀个自定义的 bean 对象。上文中所定义的 LubanFactoryBean 对应的就是UserMapper,表示我们定义了⼀个 LubanFactoryBean,相当于把 UserMapper 对应的代理对象作为⼀个 bean 放入到了容器中。

但是作为程序员,我们不可能每定义了⼀个 Mapper,还得去定义⼀个 LubanFactoryBean,这是很麻烦的事情,我们改造⼀下 LubanFactoryBean,让他变得更通用,比如:

@Component
public class LubanFactoryBean implements FactoryBean {
    // 注意这里
    private Class mapperInterface;

    public LubanFactoryBean(Class mapperInterface) {
        this.mapperInterface = mapperInterface;
    }

    @Override
    public Object getObject() throws Exception {
        Object proxyInstance = Proxy.newProxyInstance(LubanFactoryBean.class.getClassLoader(),
                new Class[] { mapperInterface }, new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        if (Object.class.equals(method.getDeclaringClass())) {
                            return method.invoke(this, args);
                        } else {
                            // 执行代理逻辑
                            return null;
                        }
                    }
                });

        return proxyInstance;
    }

    @Override
    public Class<?> getObjectType() {
        return mapperInterface;
    }
}

改造 LubanFactoryBean 之后,LubanFactoryBean 变得灵活了,可以在构造 LubanFactoryBean 时,通过构造传入不同的 Mapper 接口。

实际上 LubanFactoryBea 也是⼀个 Bean,我们也可以通过生成⼀个 BeanDefinition 来生成⼀个 LubanFactoryBean,并给构造方法的参数设置不同的值,比如伪代码如下:

BeanDefinition beanDefinition = new BeanDefinitoin();
// 注意⼀:设置的是LubanFactoryBean
beanDefinition .setBeanClassName(LubanFactoryBean.class.getName());
// 注意⼆:表示当前BeanDefinition在生成bean对象时,会通过调用LubanFactoryBean的构造方法来生成,并传入UserMapper
beanDefinition .getConstructorArgumentValues().addGenericArgumentValue(UserMapper.class.getName())
SpringContainer.addBd(beanDefinition);

特别说⼀下注意⼆,表示表示当前 BeanDefinition 在生成 bean 对象时,会通过调用 LubanFactoryBean 的构造方法来生成,并传入 UserMapper 的 Class 对象。那么在生成 LubanFactoryBean 时就会生成⼀个 UserMapper 接口对应的代理对象作为 bean 了。

到此为止,其实就完成了我们要解决的问题:把 Mybatis 中的代理对象作为⼀个 bean 放入 Spring 容器中。只是我们这里是用简单的 JDK 代理对象模拟的 Mybatis 中的代理对象,如果有时间,我们完全可以调用 Mybatis 中提供的方法区生成⼀个代理对象。这里就不花时间去介绍了。

Import

到这里,我们还有⼀个事情没有做,就是怎么真正的定义⼀个 BeanDefinition,并把它添加到 Spring 中,上文说到我们要利用 Import 技术,比如可以这么实现:
定义如下类:

public class LubanImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
        AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
        beanDefinition.setBeanClass(LubanFactoryBean.class);
        beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(UserMapper.class);
        // 添加beanDefinition
        registry.registerBeanDefinition("luban" + UserMapper.class.getSimpleName(), beanDefinition);
    }
}

并且在 AppConfig 上添加 @Import 注解:

@Import(LubanImportBeanDefinitionRegistrar.class)
public class AppConfig {

这样在启动Spring时就会新增⼀个BeanDefinition,该BeanDefinition会生成⼀个LubanFactoryBean对象,并且在生成LubanFactoryBean对象时会传入UserMapper.class对象,通过LubanFactoryBean内部的逻辑,相当于会自动生产⼀个UserMapper接口的代理对象作为⼀个bean。

总结

总结⼀下,通过我们的分析,我们要整合 Spring 和 Mybatis,需要我们做的事情如下:

  1. 定义⼀个 LubanFactoryBean
  2. 定义⼀个 LubanImportBeanDefinitionRegistrar
  3. 在 AppConfig 上添加⼀个注解 @Import(LubanImportBeanDefinitionRegistrar.class)

优化

这样就可以基本完成整合的需求了,当然还有两个点是可以优化的

优化一

单独再定义⼀个@LubanScan的注解,如下:

@Retention(RetentionPolicy.RUNTIME)
@Import(LubanImportBeanDefinitionRegistrar.class)
public @interface LubanScan {
}

这样在 AppConfig 上直接使用 @LubanScan 即可

优化二

在 LubanImportBeanDefinitionRegistrar 中,我们可以去扫描 Mapper,在
LubanImportBeanDefinitionRegistrar 我们可以通过 AnnotationMetadata 获取到对应的 @LubanScan 注解,所以我们可以在 @LubanScan 上设置⼀个value,用来指定待扫描的包路径。然后在 LubanImportBeanDefinitionRegistrar 中获取所设置的包路径,然后扫描该路径下的所有 Mapper,生成 BeanDefinition,放入 Spring容器中。
所以,到此为止,Spring整合Mybatis的核⼼原理就结束了,再次总结⼀下:

  1. 定义⼀个 LubanFactoryBean,用来将Mybatis的代理对象生成⼀个bean对象
  2. 定义⼀个 LubanImportBeanDefinitionRegistrar,用来生成不同Mapper对象的 LubanFactoryBean
  3. 定义⼀个 @LubanScan,用来在启动 Spring 时执行 LubanImportBeanDefinitionRegistrar的逻辑,并指定包路径

以上这个三个要素分别对象 org.mybatis.spring 中的:

  1. MapperFactoryBean
  2. MapperScannerRegistrar
  3. @MapperScan
  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

雾里有果橙

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值