3. MyBatis与spring结合原理

最新推荐文章于 2024-03-07 01:37:10 发布

岁月玲珑

最新推荐文章于 2024-03-07 01:37:10 发布

阅读量337

点赞数

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

本文链接：https://blog.csdn.net/yin18827152962/article/details/126066211

版权

mybatis 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

3. MyBatis与spring结合原理

依赖: mybatis-spring

1. MyBatis-Spring是什么

Mybatis-spring 用于帮助你将 MyBatis 代码无缝地整合到 Spring 中。
- Spring 将会加载必要的 MyBatis 工厂类和 session 类
- 提供一个简单的方式来注入 MyBatis 数据映射器和 SqlSession 到业务层的 bean 中。
- 方便集成spring事务
- 翻译 MyBatis 的异常到 Spring 的 DataAccessException 异常(数据访问异常)中。
Mybatis-spring 兼容性

MyBatis-Spring要求Java5及以上版本还有下面列出的MyBatis和Spring版本：

MyBatis-Spring MyBatis Spring
1.0.0 或 1.0.1 3.0.1 到 3.0.5 3.0.0 或以上
1.0.2 3.0.6 3.0.0 或以上
1.1.0 3.1.0 或以上 3.0.0 或以上

MyBatis-Spring	MyBatis	Spring
1.0.0 或 1.0.1	3.0.1 到 3.0.5	3.0.0 或以上
1.0.2	3.0.6	3.0.0 或以上
1.1.0	3.1.0 或以上	3.0.0 或以上

2. 集成配置最佳实践

准备spring项目一个
在pom文件中添加mybatis-spring的依赖

<dependency>
	<groupId>org.mybatis</groupId>
	<artifactId>mybatis-spring</artifactId>
	<version>1.3.0</version>
</dependency>

3. 配置SqlSessionFactoryBean
4. 配置MapperScannerConfigurer

配置事务

3. Spring集成Mybatis的原理分析

分析源码之前也需要源码下载并安装到本地仓库和开发工具中，方便给代码添加注释；安装过程和mybatis源码的安装过程是一样的，这里就不再重复描述了；下载地址：https://github.com/mybatis/spring

1. SqlSessionFactoryBean

在 MyBatis-Spring 中， SqlSessionFactoryBean 是用于创建 Sql SessionFactory 的。

dataSource ：用于配置数据源，该属性为必选项，必须通过这个属性配置数据源，这里使用了上一节中配置好的 dataSource 数据库连接池。
mapper Locations ：配置 SqlSessionFactoryBean 扫描 XML 映射文件的路径，可以使用 Ant 风格的路径进行配置。(ANT PATH)
configLocation ：用于配置mybatis config XML的路径，除了数据源外，对MyBatis的各种配直仍然可以通过这种方式进行，并且配置MyBatis settings 时只能使用这种方式。但配置文件中任意环境,数据源和 MyBatis 的事务管理器都会被忽略；(数据源和事务会被忽略掉, 交由spring托管)
typeAliasesPackage ：配置包中类的别名，配置后，包中的类在 XML 映射文件中使用时可以省略包名部分，直接使用类名。这个配置不支持 Ant风格的路径，当需要配置多个包路径时可以使用分号或逗号进行分隔。

mybatis中有两种配置, 一种是只有一个的config setting配置, 另一种是由n个的接口对应的mapper文件

<!-- spring和MyBatis完美整合，不需要mybatis的配置映射文件 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="typeAliasesPackage" value="com.len.mybatis.entity"/>
    <property name="mapperLocations" value="classpath:sqlmapper/*.xml"/>
</bean>

public class SqlSessionFactoryBean
    implements FactoryBean<SqlSessionFactory>, InitializingBean, 
	ApplicationListener<ApplicationEvent> {
        
    @Override
    //在spring容器中创建全局唯一的sqlSessionFactory
    public void afterPropertiesSet() throws Exception {
        notNull(dataSource, "Property 'dataSource' is required");
        notNull(sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");
        state((configuration == null && configLocation == null) 
              || !(configuration != null && configLocation != null),
            "Property 'configuration' and 'configLocation' can not specified with together");

        this.sqlSessionFactory = buildSqlSessionFactory();
    }  
        
    // 将SqlSessionFactory对象注入spring容器
    public SqlSessionFactory getObject() throws Exception {
        if (this.sqlSessionFactory == null) {
            afterPropertiesSet();
        }
        return this.sqlSessionFactory;
    }
        
}

2. MapperFactoryBean

<bean id="tUserMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
    <property name="mapperInterface" 
              value="com.len.mybatis.mapper.TUserMapper"></property>
    <property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
</bean>

public class MapperFactoryBean<T> extends SqlSessionDaoSupport 
    implements FactoryBean<T> {
    @Override
    public T getObject() throws Exception {
        return getSqlSession().getMapper(this.mapperInterface);
    }
}

org.apache.ibatis.session.defaults.DefaultSqlSession#getMapper

public <T> T getMapper(Class<T> type) {
  return configuration.<T>getMapper(type, this);
}

3. MapperScannerConfigurer

通过 MapperScannerConfigurer类自动扫描所有的 Mapper 接口，使用时可以直接注入接口。

MapperScannerConfigurer中常配置以下两个属性。

basePackage ：用于配置基本的包路径。可以使用分号或逗号作为分隔符设置多于一个的包路径，每个映射器将会在指定的包路径中递归地被搜索到。
annotationClass ：用于过滤被扫描的接口，如果设置了该属性，那么 MyBatis 的接口只有包含该注解才会被扫描进去

MapperScannerConfigurer和上面的MapperFactoryBean作用是一样的, 都是为了将对象放入容器中

<!-- DAO接口所在包名，Spring会自动查找其下的类 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.len.mybatis.mapper"/>
</bean>

BeanDefinitionRegistryPostProcessor: 这个后置处理器具有修改bean的功能, 也只有这个后置处理器可以修改bean, 因为只有这个可以拿到BeanDefinition

public class MapperScannerConfigurer
    implements BeanDefinitionRegistryPostProcessor, 
	InitializingBean, ApplicationContextAware, BeanNameAware {
          @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        if (this.processPropertyPlaceHolders) {//占位符处理
            processPropertyPlaceHolders();
        }
        //实例化ClassPathMapperScanner，并对scanner相关属性进行配置
        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();//根据上述配置，生成过滤器，只扫描合条件的class
        //扫描指定的包以及其子包
        scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage,
            ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        notNull(this.basePackage, "Property 'basePackage' is required");
    }
}

org.mybatis.spring.mapper.ClassPathMapperScanner#doScan

public Set<BeanDefinitionHolder> doScan(String... basePackages) {
    //通过父类的扫描，获取所有复合条件的BeanDefinitionHolder对象
    Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);

    if (beanDefinitions.isEmpty()) {
        logger.warn("No MyBatis mapper was found in '" + Arrays.toString(basePackages)
            + "' package. Please check your configuration.");
    } else {
        //处理扫描得到的BeanDefinitionHolder集合，将集合中的每一个mapper接口转换成MapperFactoryBean后，注册至spring容器
        processBeanDefinitions(beanDefinitions);
    }

    return beanDefinitions;
}

org.mybatis.spring.mapper.ClassPathMapperScanner#processBeanDefinitions

// holder是一种封装参数的手法, 推荐使用
//处理扫描得到的BeanDefinitionHolder集合，将集合中的每一个mapper接口转换成MapperFactoryBean后，注册至spring容器
private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
    GenericBeanDefinition definition;
    //遍历集合
    for (BeanDefinitionHolder holder : beanDefinitions) {
        definition = (GenericBeanDefinition)holder.getBeanDefinition();

        if (logger.isDebugEnabled()) {
            logger.debug("Creating MapperFactoryBean with name '" + holder.getBeanName() + "' and '"
                + definition.getBeanClassName() + "' mapperInterface");
        }

        // the mapper interface is the original class of the bean
        // but, the actual class of the bean is MapperFactoryBean
        //增加一个构造方法，接口类型作为构造函数的入参
        definition.getConstructorArgumentValues()
            .addGenericArgumentValue(definition.getBeanClassName()); // issue #59
        //将bean的类型转换成mapperFactoryBean
        definition.setBeanClass(this.mapperFactoryBean.getClass());
        //增加addToConfig属性
        definition.getPropertyValues().add("addToConfig", this.addToConfig);

        boolean explicitFactoryUsed = false;
        //增加sqlSessionFactory属性
        if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {
            definition.getPropertyValues()
                .add("sqlSessionFactory", new RuntimeBeanReference(this.sqlSessionFactoryBeanName));
            explicitFactoryUsed = true;
        } else if (this.sqlSessionFactory != null) {
            definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);
            explicitFactoryUsed = true;
        }
        //增加sqlSessionTemplate属性
        if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) {
            if (explicitFactoryUsed) {
                logger.warn(
                    "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
            }
            definition.getPropertyValues()
                .add("sqlSessionTemplate", new RuntimeBeanReference(this.sqlSessionTemplateBeanName));
            explicitFactoryUsed = true;
        } else if (this.sqlSessionTemplate != null) {
            if (explicitFactoryUsed) {
                logger.warn(
                    "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
            }
            definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);
            explicitFactoryUsed = true;
        }

        //修改自动注入的方式 bytype
        if (!explicitFactoryUsed) {
            if (logger.isDebugEnabled()) {
                logger.debug(
                    "Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
            }
            definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
        }
    }
}