spring boot 整合 mybatis

大家好，又到了学习的时间了，今天就来讲一下spring boot如何整合mybatis吧!

什么是mybatis?这里引用中文官网的简介介绍一下：

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。

具体的在这里就不介绍了，相信大家在项目中已经用的很多了，如果需要以后可能会开一个mybatis的学习系列啦！
好了，那我们开始来介绍一下spring boot如何整合mybatis吧！
贴一张spring-boot-mybatis依赖关系

首先，当然是引入maven依赖,既然我们要整合mybatis那总得要个数据库吧，我们这边就用mysql，同时引入mysql依赖，其中exclusions的意思去除logging依赖的意思。

        <!--spring boot MySQL依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

接着在我们yml配置文件中加入数据源信息，这样就能访问数据库了。

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mytest
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver

这边建表语句就不贴出来了。
在我们启动类上加上mybatis配置扫描注解，若不加则无法扫描到mybatis的xml文件,当然你也可以在每个dao的接口类上加上@Mapper来标记为mybatis的mapper。

@SpringBootApplication 
@MapperScan("com.god.dao") 
public class AresApplication {

    public static void main(String[] args) {
        SpringApplication.run(AresApplication.class, args);
    }
}

在dao上加上@Repository注解，controller和service就不贴出来啦。

@Repository
public interface UserDao extends BaseDao<User> {

    User queryByUsername(String username);
}

在这里博主将mapper.xml文件放在了resources目录下面，让xml配置文件与Java源码分离。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.god.dao.UserDao">
    <resultMap type="com.god.entity.User" id="userMap">
        <result property="id" column="id" jdbcType="VARCHAR"/>
        <result property="name" column="name" jdbcType="VARCHAR"/>
        <result property="username" column="username" jdbcType="VARCHAR"/>
        <result property="password" column="password" jdbcType="VARCHAR"/>
        <result property="address" column="address" jdbcType="VARCHAR" />
    </resultMap>

    <select id="queryByUsername" resultMap="userMap">
        SELECT COUNt(*) FROM tbl_user where username = #{username}
    </select>


</mapper>

以上就是一个简单的spring boot 和mybatis整合例子。

下面我们来扩展一下，当我们不满足现有的mybatis配置时，我们就需要修改mybatis现有的配置，如何修改呢，先让我们来看一下MybatisAutoConfiguration和MybatisProperties源码：

@Configuration
@ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class}) //该注解的参数对应的类必须存在，否则不解析该注解修饰的配置类
@ConditionalOnBean({DataSource.class}) //该注解的参数对应的bean实例必须存在，否则不解析该注解修饰的配置类
@EnableConfigurationProperties({MybatisProperties.class}) //使用Mybatisproperties配置文件
@AutoConfigureAfter({DataSourceAutoConfiguration.class}) //在数据源加载之后进行加载
public class MybatisAutoConfiguration {
    private static final Logger logger = LoggerFactory.getLogger(MybatisAutoConfiguration.class);
    private final MybatisProperties properties;
    private final Interceptor[] interceptors;
    private final ResourceLoader resourceLoader;
    private final DatabaseIdProvider databaseIdProvider;
    private final List<ConfigurationCustomizer> configurationCustomizers;

    public MybatisAutoConfiguration(MybatisProperties properties, ObjectProvider<Interceptor[]> interceptorsProvider, ResourceLoader resourceLoader, ObjectProvider<DatabaseIdProvider> databaseIdProvider, ObjectProvider<List<ConfigurationCustomizer>> configurationCustomizersProvider) {
        this.properties = properties;
        this.interceptors = (Interceptor[])interceptorsProvider.getIfAvailable();
        this.resourceLoader = resourceLoader;
        this.databaseIdProvider = (DatabaseIdProvider)databaseIdProvider.getIfAvailable();
        this.configurationCustomizers = (List)configurationCustomizersProvider.getIfAvailable();
    }
    //在初始化之前先根据我们在MybatisProperties中的checkConfigLocation设置的值检查配置文件是否存在，若设置为true同时配置了配置文件位置则配置文件必须存在
    @PostConstruct
    public void checkConfigFileExists() {
        if(this.properties.isCheckConfigLocation() && StringUtils.hasText(this.properties.getConfigLocation())) {
            Resource resource = this.resourceLoader.getResource(this.properties.getConfigLocation());
            Assert.state(resource.exists(), "Cannot find config location: " + resource + " (please add config file or check your Mybatis configuration)");
        }

    }

    //若我们没有配置自己的sqlSessionFactory则启动mybatis中默认定义的sqlSessionFactory，接在加载我们的配置信息
    @Bean
    @ConditionalOnMissingBean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
        factory.setDataSource(dataSource);
        factory.setVfs(SpringBootVFS.class);
        if(StringUtils.hasText(this.properties.getConfigLocation())) {
            factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
        }

        org.apache.ibatis.session.Configuration configuration = this.properties.getConfiguration();
        if(configuration == null && !StringUtils.hasText(this.properties.getConfigLocation())) {
            configuration = new org.apache.ibatis.session.Configuration();
        }

        if(configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
            Iterator var4 = this.configurationCustomizers.iterator();

            while(var4.hasNext()) {
                ConfigurationCustomizer customizer = (ConfigurationCustomizer)var4.next();
                customizer.customize(configuration);
            }
        }

        factory.setConfiguration(configuration);
        if(this.properties.getConfigurationProperties() != null) {
            factory.setConfigurationProperties(this.properties.getConfigurationProperties());
        }

        if(!ObjectUtils.isEmpty(this.interceptors)) {
            factory.setPlugins(this.interceptors);
        }

        if(this.databaseIdProvider != null) {
            factory.setDatabaseIdProvider(this.databaseIdProvider);
        }

        if(StringUtils.hasLength(this.properties.getTypeAliasesPackage())) {
            factory.setTypeAliasesPackage(this.properties.getTypeAliasesPackage());
        }

        if(StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {
            factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
        }

        if(!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
            factory.setMapperLocations(this.properties.resolveMapperLocations());
        }

        return factory.getObject();
    }

    //在缺省sqlSessionTemplate时创建mybatis定义的sqlSessionTemplate bean。使用mybatis的默认模板
    @Bean
    @ConditionalOnMissingBean
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        ExecutorType executorType = this.properties.getExecutorType();
        return executorType != null?new SqlSessionTemplate(sqlSessionFactory, executorType):new SqlSessionTemplate(sqlSessionFactory);
    }

//这里是mybatis 的mapper注册扫描配置类
 @Configuration
 @Import({MybatisAutoConfiguration.AutoConfiguredMapperScannerRegistrar.class})
    @ConditionalOnMissingBean({MapperFactoryBean.class})
    public static class MapperScannerRegistrarNotFoundConfiguration {
        public MapperScannerRegistrarNotFoundConfiguration() {
        }

        @PostConstruct
        public void afterPropertiesSet() {
            MybatisAutoConfiguration.logger.debug("No {} found.", MapperFactoryBean.class.getName());
        }
    }

    public static class AutoConfiguredMapperScannerRegistrar implements BeanFactoryAware, ImportBeanDefinitionRegistrar, ResourceLoaderAware {
        private BeanFactory beanFactory;
        private ResourceLoader resourceLoader;

        public AutoConfiguredMapperScannerRegistrar() {
        }
        //这里的方法扫描添加了@Mapper注解的类
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
            MybatisAutoConfiguration.logger.debug("Searching for mappers annotated with @Mapper");
            ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);

            try {
                if(this.resourceLoader != null) {
                    scanner.setResourceLoader(this.resourceLoader);
                }

                List ex = AutoConfigurationPackages.get(this.beanFactory);
                if(MybatisAutoConfiguration.logger.isDebugEnabled()) {
                    Iterator var5 = ex.iterator();

                    while(var5.hasNext()) {
                        String pkg = (String)var5.next();
                        MybatisAutoConfiguration.logger.debug("Using auto-configuration base package \'{}\'", pkg);
                    }
                }

                scanner.setAnnotationClass(Mapper.class);
                scanner.registerFilters();
                scanner.doScan(StringUtils.toStringArray(ex));
            } catch (IllegalStateException var7) {
                MybatisAutoConfiguration.logger.debug("Could not determine auto-configuration package, automatic mapper scanning disabled.", var7);
            }

        }

        public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
            this.beanFactory = beanFactory;
        }

        public void setResourceLoader(ResourceLoader resourceLoader) {
            this.resourceLoader = resourceLoader;
        }
    }
}

以上就是读取配置的主要源码！我们可以看到MybatisProperties中定义了哪些配置属性，也可以看到MybatisAutoConfiguration内置了sqlsessionfactory和sqlSessionTemplate。
那么我们在可以在哪里设置这些属性呢

1）在yml文件中设置MybatisProperties属性值，让然yml中可以设置的mybatis配置属性远不止这些

mybatis:
  mapper-locations: classpath*:mapper/**/*.xml #本地xml文件所在位置
  type-aliases-package: com.god.dao.aliases  #扫描aliases包位置
  configuration:
    cache-enabled: true  #是否开启缓存
  executor-type: simple  #执行模式,默认为simple
  check-config-location: true #检查本地配置文件
  type-handlers-package: com.god.dao.typeHandles #扫描typeHandle包位置

2）实现自己的sessionFactory工厂，定义自己的MybatisConfig配置类，添加SqlSessionFactory以及SqlSessionTemplate，这样在加载的时候加载的就是你定义的bean了。

@Configuration
public class MybatisConfig {

    @Autowired
    private DataSource dataSource;

    @Bean(name = "sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory() throws Exception{
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        return bean.getObject();
    }

    @Bean(name = "sqlSessionTemplate")
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}

上面就是简单的配置，bean中可以设置你的sqlsessionfactory配置属性