Spring 集成Mybatis原理（手写mybatis-spring）

概要

MyBatis 是一个可以独立运行的框架，为了和spring一块使用，需要通过代码将mybatis中的一些bean放入到spring 容器中

需要解决的问题

@Mapper 标注的接口无法解析成Bean

• 要生成bean ,首先是能扫描成BeanDefinition
• 有两个地方做了限制 ，看下下面代码，所以如果要打破这两个限制 ，需要将这两个限制打破，注意到这两个方法都是可由子类进行继承的，所以可以自定义扫描器继承这两个方法来打破限制

如何获取扫描路径

正常我们写MyBatis时会 有这样一个注解，@MapperScan(basePackages=“xxx.xxx”) 在这个注解上有对应Mapper的扫描路径，那么问题来了，我们怎么拿到这个注解上的路径呢，可以在@MapperScan上写一个@Import，导入一个实现了 ImportBeanDefinitionRegistrar的类，这时候可以通过方法registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) 上的importingClassMetadata 拿到注解并进行扫描

如何生成代理类

这一步可以通过jdk通过代理来做 ，但是mybatis底层已经有拿到Mapper直接获取代理对象的方法 sqlSessionfactory.getMapper(xxx.class) 所以直接套用

• 生成代理类后，将代理类和beanName进行绑定

注册BeanDefinition的时候使用Mapper类的名称作为bean ,其具体类封装成FactoryBean ，设置到BeanDefinition中

手写代码实现

导入依赖

 <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.13</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <version>2.7.11</version>
        </dependency>
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <version>8.0.33</version>
        </dependency>
    </dependencies>

mybatis.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">
            <!--使用jdbc事务管理-->
            <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/test?characterEncoding=utf-8&amp;useSsL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

TestClass（启动类）

public class TestClass {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        UserMapper bean = context.getBean(UserMapper.class);
        System.out.println(bean.getUser());
    }
}

AppConfig

@Configuration
@PalmerMapperScan("com.palmer.soucecode.springmybatis.mapper")
public class AppConfig {

    @Bean
    public SqlSessionFactory sqlSessionFactory() throws IOException {
        InputStream inputstream =  Resources.getResourceAsStream("mybatis.xml");
        SqlSessionFactory sqlSessionFactory  = new SqlSessionFactoryBuilder().build(inputstream);
        return sqlSessionFactory;
    }
}

PalmerFactoryBean

public class PalmerFactoryBean implements FactoryBean {

   private  Class clazz;


    SqlSession sqlSession;

    @Autowired
    public void setSqlSession(SqlSessionFactory sqlSessionFactory) {
       // 这个必须写，不然会报错
        sqlSessionFactory.getConfiguration().addMapper(clazz);
        this.sqlSession = sqlSessionFactory.openSession();
    }

    public PalmerFactoryBean(Class clazz) {
        this.clazz = clazz;
    }

    @Override
    public Object getObject() throws Exception {
        return sqlSession.getMapper(clazz);
    }

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

}

PalmerImportConfigurer

public class PalmerImportConfigurer implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
        Map<String, Object> annotationAttributes = importingClassMetadata.getAnnotationAttributes(PalmerMapperScan.class.getName());
        String path = (String) annotationAttributes.get("value");
        PalmerScanner palmerScanner = new PalmerScanner(registry);
        // 这里添加自定义IncludeFilter 直接返回true ,过掉生成BeanDefinition限制
        palmerScanner.addIncludeFilter((metadataReader, metadataReaderFactory) -> true);
        palmerScanner.scan(path);
    }
}

PalmerMapperScan

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import(PalmerImportConfigurer.class)
public @interface PalmerMapperScan {
    String value() default "";
}

PalmerScanner

public class PalmerScanner  extends ClassPathBeanDefinitionScanner {
    public PalmerScanner(BeanDefinitionRegistry registry) {
        super(registry);
    }
    @Override
    protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
        return true;
    }
    @Override
    protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        Set<BeanDefinitionHolder> beanDefinitionHolders = super.doScan(basePackages);
        for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
            BeanDefinition beanDefinition = beanDefinitionHolder.getBeanDefinition();
            beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(beanDefinition.getBeanClassName());
            beanDefinition.setBeanClassName(PalmerFactoryBean.class.getName());
        }
        return beanDefinitionHolders;
    }
}