Spring整合Mybatis底层原理

最新推荐文章于 2023-09-03 22:08:13 发布

愉悦滴帮主)

最新推荐文章于 2023-09-03 22:08:13 发布

阅读量432

点赞数 1

分类专栏： Spring原理文章标签： spring java mybatis

本文链接：https://blog.csdn.net/qq_45065241/article/details/117526487

版权

Spring原理专栏收录该内容

8 篇文章 0 订阅

订阅专栏

Spring整合Mybatis底层原理

前言：

想必学习过Spring框架的小伙伴，知道在Spring项目中在Controller类中获取Service层的对象，我们只需在Controller类中运用@Autowired注解将Service层的对象注入进来即可，但是Service层的我们基本都是访问数据库的接口，都是运用mybatis框架去访问数据库。那么这两个框架本身是如何联系起来的？本文主要介绍Spring整合Mybatis的核心底层原理、@MapperScan注解的底层工作原理、MapperScannerConfigure底层工作原理。

Spring整合Mybatis的核心底层原理

public interface UserMapper {
    @Select("select 'testUser'")
    String selectById();
}

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

    public void test(){
        System.out.println(userMapper.selectById());
    }
}

上述代码：表述了在UserService类中注入UserMapper接口对象，然后调用userMapper对象的方法。

那么UserService中的UserMapper的代理对象是谁生成的，是Spring框架代理生成的还是Mybatis框架代理生成的？答案是：Mybatis框架。答错的小伙伴要恶补下知识喽。

结合底层去分析该过程：

1.在UserService类中声明一个UserMapper类型的属性。

2.然后mybatis框架去生成一个UserMapper的代理对象。

3.mybatis框架把UserMapper代理对象通过spring-mybatis.jar将UserMapper代理对象转换成Bean对象

4.spring-mybatis.jar将生成好的Bean交给Spring容器去管理

Mybatis如何生成代理对象

在 org.mybatis:mybatis.jar包中给我们提供了一些方法。下面代码是运用mybatis来生成代理对象。如何搭建mybatis项目请参考：https://www.cnblogs.com/21-forever/p/11305332.html

public class MybatisTest {
    public static void main(String[] args) throws IOException {
            // 1. 创建SqlSessionFactoryBuilder对象
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            // 2. 加载SqlMapConfig.xml配置文件
            InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");
            // 3. 创建SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
            // 4. 创建SqlSession对象
            SqlSession sqlSession = sqlSessionFactory.openSession();
            // 5.执行sql
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);// 获得一个(动态代理）UserMapper接口的实现类对象
            System.out.println(userMapper.selectById());
            // 6.释放资源
            sqlSession.close();
        }
    }

Spring中如何声明一个bean

定义bean分为两种方式:

第一种：声明式，例如：我们通常使用的@Bean注解，@Service注解，@Component注解等等。

第二种：编程式，运用BeanDefinition来创建一个bean，下面看代码

public class User {
    public void fff(){
        System.out.println("初始化方法");
    }
}

    public static void main(String[] args) {
        //使用AnnotationConfigApplicationContext可以实现基于Java的配置类加载Spring的应用上下文。避免使用application.xml进行配置。相比XML配置，更加便捷。
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        applicationContext.register(AppConfig.class);

        //获取beanDefinition对象
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        //创建User类的bean
        beanDefinition.setBeanClass(User.class);
        beanDefinition.setScope("prototype"); //bean单例模式改为原型模式
        beanDefinition.setInitMethodName("fff"); //设置bean的初始化方法
        //设置bean的名称
        applicationContext.registerBeanDefinition("xxx",beanDefinition);
        applicationContext.refresh();
          /**
         * 打印结果
         * 初始化方法
         * com.example.service.User@3b94d659
         * 初始化方法
         * com.example.service.User@24b1d79b
         * 初始化方法
         * com.example.service.User@68ceda24
         */
        System.out.println(applicationContext.getBean("xxx"));
        System.out.println(applicationContext.getBean("xxx"));
        System.out.println(applicationContext.getBean("xxx"));



//        UserService userService = applicationContext.getBean(UserService.class);
//        userService.test();
    }

通过上述代码我们可以使用BeanDefinition来创建一个bean。但是如果我的User类如果是一个接口通过BeanDefinition就不能实现了。我们可以通过FactoryBean来创建bean。

在下面代码：由于beanDefinition.setBeanClass(FactoryBeanTest.class);这行代码我们创建的是FactoryBeanTest.class这个类型的bean,但是FactoryBeanTest 类实现了FactoryBean这个接口最后返回给我们一个User类型的bean。这样我们就实现了动态的获取bean.

public class FactoryBeanTest implements FactoryBean {
    //getObject方法返回的bean，会放到spring容器里面去
    @Override
    public Object getObject() throws Exception {
        return new User();
    }
    //getObjectType方法是返回bean的类型
    @Override
    public Class<?> getObjectType() {
        return null;
    }
}

public class TestApplication {
    public static void main(String[] args) {
        //使用AnnotationConfigApplicationContext可以实现基于Java的配置类加载Spring的应用上下文。避免使用application.xml进行配置。相比XML配置，更加便捷。
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        applicationContext.register(AppConfig.class);
        //获取beanDefinition对象
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        //创建User类的bean
        beanDefinition.setBeanClass(FactoryBeanTest.class);
        //设置bean的名称
        applicationContext.registerBeanDefinition("xxx",beanDefinition);
        applicationContext.refresh();
        System.out.println(applicationContext.getBean("xxx"));

    }
}

模拟代理对象转化Spring的bean过程

首先我们通过Proxy.newProxyInstance方法去模拟一个代理对象，然后通过FactoryBean将这个代理对象放入SpringBean容器中。然后通过调用UserService.test方法我们可以发现：在执行UserService.test方法时会调用userMapper代理对象的selectById())的方法，

那么在调用代理对象时会先调用代理对象的代理逻辑里面也就是invoke方法，然后再去调用代理对象的selectById())的方法。

这样我们就做到了将mybatis的代理对象转化位bean放入到spring容器中。

public class FactoryBeanTest implements FactoryBean {

    @Override
    public Object getObject() throws Exception {
        /**
         * 参数：类加载器，代理的接口，代理的逻辑
         */
        Object proxyInstance = Proxy.newProxyInstance(FactoryBeanTest.class.getClassLoader(), new Class[]{UserMapper.class}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println(method.getName());
                return null;
            }
        });
        return proxyInstance;
    }

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

/**
 * 在spring boot中设置的IOC容器中设置包扫描
 */
@ComponentScan("com.example.*")
@Configuration
public class AppConfig {
}

public class TestApplication {
    public static void main(String[] args) {
        //使用AnnotationConfigApplicationContext可以实现基于Java的配置类加载Spring的应用上下文。避免使用application.xml进行配置。相比XML配置，更加便捷。
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        applicationContext.register(AppConfig.class);
        //获取beanDefinition对象
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        //创建User类的bean
        beanDefinition.setBeanClass(FactoryBeanTest.class);
        //设置bean的名称
        applicationContext.registerBeanDefinition("xxx",beanDefinition);
        applicationContext.refresh();
       UserService userService = applicationContext.getBean(UserService.class);
       userService.test();
    }
}

@MapperScan注解的底层工作原理

虽然上述代码我们已经实现了将mybatis的代理对象转化位bean放入到spring容器中这一过程，但是如果存在多个代理对象我们该怎么办呢？每多一个代理对象就重复

AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
//创建User类的bean
beanDefinition.setBeanClass(FactoryBeanTest.class);
//设置bean的名称
applicationContext.registerBeanDefinition("xxx",beanDefinition);

这三行代码么，很明显不现实。我们需要扫描出所有的代理对象，然后循环的去调用上述代码。

过程：1.启动spring,会去加载AddConfig配置文件

2.读取@Import注解，则会调用BeanDefinitionRegistrarTest 的registerBeanDefinitions方法

3.registerBeanDefinitions去调用 Spring中的扫描器ClassPathBeanDefinitionScanner，我们需要修改扫描器的配置（不过滤没有加@Component注解的类并且只保留接口）

4.然后将扫描出来的Class转换成对应类型的代理对象，然后将代理对象转换成bean放入到spring容器中

public class TestApplication {
    public static void main(String[] args) {
        //使用AnnotationConfigApplicationContext可以实现基于Java的配置类加载Spring的应用上下文。避免使用application.xml进行配置。相比XML配置，更加便捷。
        //启动spring
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        applicationContext.register(AppConfig.class);
        applicationContext.refresh();
        //调用userService的test方法
        UserService userService = applicationContext.getBean(UserService.class);
       userService.test();
    }
}

/**
 * 在spring boot中设置的IOC容器中设置包扫描
 */
@ComponentScan("com.example.*")
@Import(BeanDefinitionRegistrarTest.class)
public class AppConfig {
}

我们通过Proxy.newProxyInstance方法去生成代理对象。那么代理对象的Class类型怎么来，就需要去扫描带有标志这个类是个bean的注解的类。


public class FactoryBeanTest implements FactoryBean {

    private Class mapperInterface;

    //通过构造方法去给mapperInterface属性赋值
    public FactoryBeanTest(Class mapperInterface) {
        this.mapperInterface = mapperInterface;
    }


    @Override
    public Object getObject() throws Exception {
        /**
         * 参数：类加载器，代理的接口，代理的逻辑
         */
        Object proxyInstance = Proxy.newProxyInstance(FactoryBeanTest.class.getClassLoader(), new Class[]{mapperInterface}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println(method.getName());
                return null;
            }
        });
        return proxyInstance;
    }

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

我们通过Spring提供的扫描器，去扫描出标志是一个bean的类，然后将这些类去生成beanDefinition。为什么生成beanDefinition？因为代理对象是通过beanFactory接口创建的，我们必须在beanFactory工厂组件完成之前，将材料（beanDefinition）交给工厂处理。

/**
 * 扫描器
 * Spring中的扫描器ClassPathBeanDefinitionScanner
 */
public class ScannerTest extends ClassPathBeanDefinitionScanner {
    public ScannerTest(BeanDefinitionRegistry registry) {
        /**
         * false的作用：ClassPathBeanDefinitionScanner扫描器会默认添加一个filter的一个过滤器，
         * 这个过滤器的作用就是过滤掉没有添加@Component注解的class。而false参数的作用就是关闭这个过滤器，
         * 不进行过滤
         */
        super(registry, false);
    }

    //过滤保留所有的接口
    @Override
    protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
        return beanDefinition.getMetadata().isInterface();
    }

    @Override
    public int scan(String... basePackages) {
        //运用spring的扫描器去扫描
        //我们得到的扫描结果是对应自己类型的接口，如UserMapper,OrderMapper等等，我们需要的是FactoryBean代理类型，所以进行循环。
        Set<BeanDefinitionHolder> beanDefinitionHolders = super.doScan(basePackages);
        for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
            AbstractBeanDefinition beanDefinition = (AbstractBeanDefinition) beanDefinitionHolder.getBeanDefinition();
   //这里需要将代理bean转换成对应类型的bean 
        beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(beanDefinition.getBeanClassName());
            beanDefinition.setBeanClass(FactoryBeanTest.class);
        }
        return beanDefinitionHolders.size();
    }


}

在交给beanFactory处理之前我们要先想Spring注册beanDefintion。

public class BeanDefinitionRegistrarTest implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
        //scan扫描 spring
        ScannerTest scanner = new ScannerTest(registry);
        //在scanner添加一个过滤器
        scanner.addIncludeFilter(new TypeFilter() {
            //不进行拦截
            @Override
            public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
                return true;
            }
        });
        scanner.scan("com.example.dao");
    }

}

在上述代码中我们发现 scanner.scan("com.example.dao");是写死的，我们可以运用注解的形式改成动态的可配置的，这也是@MapperScan注解的由来。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import(BeanDefinitionRegistrarTest.class)
public @interface ScanTest {
     String value();
}


public class BeanDefinitionRegistrarTest implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
        //scan扫描 spring
        ScannerTest scanner = new ScannerTest(registry);
        //在scanner添加一个过滤器
        scanner.addIncludeFilter(new TypeFilter() {
            //不进行拦截
            @Override
            public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
                return true;
            }
        });
        Map<String, Object> annotationAttributes = importingClassMetadata.getAnnotationAttributes(ScanTest.class.getName());
        String path = (String) annotationAttributes.get("value");
        scanner.scan(path);
    }

}

上面代码的代理对象只是运用Proxy.newProxyInstance生成的伪代理对象，并不是mybatis生成的代理对象。下面代码将整合mybatis。


/**
 * 在spring boot中设置的IOC容器中设置包扫描
 */
@ComponentScan("com.example.*")
@ScanTest("com.example.dao")
@Configuration
public class AppConfig {
    @Bean
    public DataSource dataSource(){
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setUrl("jdbc:mysql://localhost:3306/login?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false");
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUsername("root");
        dataSource.setPassword("admin");
        return dataSource;
    }
    @Bean
    public SqlSessionFactory sqlSessionFactory(){
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource());
        try {
            return sessionFactory.getObject();
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }

}

package com.example.service;

import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;

public class FactoryBeanTest implements FactoryBean, InitializingBean {

    private Class mapperInterface;

    private SqlSessionFactory sqlSessionFactory;

    //通过构造方法去给mapperInterface属性赋值
    public FactoryBeanTest(Class mapperInterface) {
        this.mapperInterface = mapperInterface;
    }

    //通过set方法给sqlSessionFactory赋值
    public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
        this.sqlSessionFactory = sqlSessionFactory;
    }

    @Override
    public Object getObject() throws Exception {
        //mybaties代理对象
        return sqlSessionFactory.openSession().getMapper(mapperInterface);
    }

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


    @Override
    public void afterPropertiesSet() throws Exception {
        this.sqlSessionFactory.getConfiguration().addMapper(mapperInterface);
    }
}

/**
 * 扫描器
 * Spring中的扫描器ClassPathBeanDefinitionScanner
 */
public class ScannerTest extends ClassPathBeanDefinitionScanner {
    public ScannerTest(BeanDefinitionRegistry registry) {
        /**
         * false的作用：ClassPathBeanDefinitionScanner扫描器会默认添加一个filter的一个过滤器，
         * 这个过滤器的作用就是过滤掉没有添加@Component注解的class。而false参数的作用就是关闭这个过滤器，
         * 不进行过滤
         */
        super(registry, false);
    }

    //过滤保留所有的接口
    @Override
    protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
        return beanDefinition.getMetadata().isInterface();
    }

    @Override
    public int scan(String... basePackages) {
        //运用spring的扫描器去扫描
        Set<BeanDefinitionHolder> beanDefinitionHolders = super.doScan(basePackages);
        for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
            AbstractBeanDefinition beanDefinition = (AbstractBeanDefinition) beanDefinitionHolder.getBeanDefinition();
            beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(beanDefinition.getBeanClassName());
            beanDefinition.setBeanClass(FactoryBeanTest.class);
            beanDefinition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
        }
        return beanDefinitionHolders.size();
    }


}

MapperScannerConfigure底层工作原理

MapperScannerConfigurer 支持过滤由指定的创建接口或注解创建映射器。我们可以自己定义MapperScannerConfigurer 这个注解，指定扫描路径，就不需要MapperScan这个注解了。这时新版本提供的一种方式。

package com.example.config;

import com.example.service.ScanTest;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import javax.sql.DataSource;

/**
 * 在spring boot中设置的IOC容器中设置包扫描
 */
@ComponentScan("com.example.*")
@ScanTest("com.example.dao")
@Configuration
public class AppConfig {
    @Bean
    public MapperScannerConfigurer configurer(){
        MapperScannerConfigurer configurer = new MapperScannerConfigurer();
        configurer.setBasePackage("com.example.dao");
        return configurer;
    }
    
    
    @Bean
    public DataSource dataSource(){
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setUrl("jdbc:mysql://localhost:3306/login?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false");
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUsername("root");
        dataSource.setPassword("admin");
        return dataSource;
    }
    @Bean
    public SqlSessionFactory sqlSessionFactory(){
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource());
        try {
            return sessionFactory.getObject();
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }

}

接下来让我们看一下MapperScannerConfigurer类的源码看看是如何自动扫描的。

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
    if (this.processPropertyPlaceHolders) {
      processPropertyPlaceHolders();
    }

    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
    scanner.setAddToConfig(this.addToConfig);
    scanner.setAnnotationClass(this.annotationClass);
    scanner.setMarkerInterface(this.markerInterface);
    scanner.setSqlSessionFactory(this.sqlSessionFactory);
    scanner.setSqlSessionTemplate(this.sqlSessionTemplate);
    scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);
    scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);
    scanner.setResourceLoader(this.applicationContext);
    scanner.setBeanNameGenerator(this.nameGenerator);
    scanner.registerFilters();
    scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
  }

愉悦滴帮主)

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Spring整合Mybatis底层原理

Spring整合Mybatis底层原理前言：想必学习过Spring框架的小伙伴，知道在Spring项目中在Controller类中获取Service层的对象，我们只需在Controller类中运用@Autowired注解将Service层的对象注入进来即可，但是Service层的我们基本都是访问数据库的接口，都是运用mybatis框架去访问数据库。那么这两个框架本身是如何联系起来的？本文主要介绍Spring整合Mybatis的核心底层原理、@MapperScan注解的底层工作原理、MapperSca
复制链接

扫一扫

专栏目录