Mybatis和SpringBoot的整合

已于 2022-04-10 11:10:10 修改
阅读量3.8k 收藏 1
点赞数 1
分类专栏： MyBatis 文章标签： MyBatis
于 2021-08-11 21:02:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41071876/article/details/119610438
版权

简介

Mybatis和SpringBoot整合整合需要依赖MyBatis-Spring-Boot-Starter

MyBatis-Spring-Boot-Starter 帮助您在Spring Boot之上快速构建 MyBatis 应用程序,通过使用此模块，您将实现：构建独立的应用程序,将样板文件减少到几乎为零,更少的 XML 配置

MyBatis-Spring-Boot-Starter 需要以下版本:
在这里插入图片描述

一、Mybatis和SpringBoot整合应用
1.1 项目依赖

在原项目依赖上，加上下面依赖

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

<dependency> 
	<groupId> org.mybatis.spring.boot </groupId> 
	<artifactId> mybatis-spring-boot-starter </artifactId> 
	<version> 2.2.0 </version> 
</dependency>
1.2 项目配置

使用MyBatis-Spring-Boot-Starter后，spring将扫描所有标准@Mapper的类（不需要使用@MapperScan），所以我们直接使用MyBatis的功能，不需要手动配置SqlSessionTemplate，sqlSessionFactory，dataSource，因为MyBatis-Spring-Boot-Starter帮我们配置好了。

MyBatis-Spring-Boot-Starter在其spring.factories文件中配置2个配置类，Mybatis主要配置都在MybatisAutoConfiguration中

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.mybatis.spring.boot.autoconfigure.MybatisLanguageDriverAutoConfiguration,\
org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration
二、Mybatis和Spring整合源码分析
2.1 数据源的配置

其代码在org.springframework.boot.autoconfigure.jdbc中，是SpringBoot的基本代码

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(HikariDataSource.class)
@ConditionalOnMissingBean(DataSource.class)
@ConditionalOnProperty(
name = "spring.datasource.type", havingValue = "com.zaxxer.hikari.HikariDataSource",matchIfMissing = true)
static class Hikari {

	@Bean
	@ConfigurationProperties(prefix = "spring.datasource.hikari")
	HikariDataSource dataSource(DataSourceProperties properties) {
		HikariDataSource dataSource = createDataSource(properties, HikariDataSource.class);
		if (StringUtils.hasText(properties.getName())) {
			dataSource.setPoolName(properties.getName());
		}
		return dataSource;
	}

}

Spring Boot 2默认数据库连接池选择了HikariCP ， 我们一般不需要自己手动创建DataSource，只想要在application.yml配置文件中，表明其url，username等，如下

spring:
 datasource:
  url: jdbc:mysql://localhost:3306/clyu
  username: root
  password: 123456
  driver-class-name: com.mysql.jdbc.Driver
2.2 事务

其代码在org.springframework.boot.autoconfigure.jdbc中，是SpringBoot的基本代码

//proxyBeanMethods = false 是lite模式 不会进行代理配置对象
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(PlatformTransactionManager.class)
@AutoConfigureAfter({ JtaAutoConfiguration.class, HibernateJpaAutoConfiguration.class,
		DataSourceTransactionManagerAutoConfiguration.class, Neo4jDataAutoConfiguration.class })
@EnableConfigurationProperties(TransactionProperties.class)
public class TransactionAutoConfiguration {

	@Bean
	@ConditionalOnMissingBean
	public TransactionManagerCustomizers platformTransactionManagerCustomizers(
			ObjectProvider<PlatformTransactionManagerCustomizer<?>> customizers) {
		return new TransactionManagerCustomizers(customizers.orderedStream().collect(Collectors.toList()));
	}

	@Bean
	@ConditionalOnMissingBean
	@ConditionalOnSingleCandidate(ReactiveTransactionManager.class)
	public TransactionalOperator transactionalOperator(ReactiveTransactionManager transactionManager) {
		return TransactionalOperator.create(transactionManager);
	}

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnSingleCandidate(PlatformTransactionManager.class)
	public static class TransactionTemplateConfiguration {

		@Bean
		@ConditionalOnMissingBean(TransactionOperations.class)
		public TransactionTemplate transactionTemplate(PlatformTransactionManager transactionManager) {
			return new TransactionTemplate(transactionManager);
		}

	}

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnBean(TransactionManager.class)
	@ConditionalOnMissingBean(AbstractTransactionManagementConfiguration.class)
	public static class EnableTransactionManagementConfiguration {

		@Configuration(proxyBeanMethods = false)
		@EnableTransactionManagement(proxyTargetClass = false)
		@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false",
				matchIfMissing = false)
		public static class JdkDynamicAutoProxyConfiguration {

		}

		@Configuration(proxyBeanMethods = false)
		@EnableTransactionManagement(proxyTargetClass = true)
		@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
				matchIfMissing = true)
		public static class CglibAutoProxyConfiguration {

		}

	}

}

springBoot默认开启事物，我不需要@EnableTransactionManagement手动开启事物

下面的配置都是MyBatis-Spring-Boot-Starter的

2.3 SqlSessionFactory的注册

基于MybatisAutoConfiguration

@org.springframework.context.annotation.Configuration
@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })
@ConditionalOnSingleCandidate(DataSource.class)
@EnableConfigurationProperties(MybatisProperties.class)
@AutoConfigureAfter({ DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class })
public class MybatisAutoConfiguration implements InitializingBean {

  private static final Logger logger = LoggerFactory.getLogger(MybatisAutoConfiguration.class);

  private final MybatisProperties properties;

  private final Interceptor[] interceptors;

  private final TypeHandler[] typeHandlers;

  private final LanguageDriver[] languageDrivers;

  private final ResourceLoader resourceLoader;

  private final DatabaseIdProvider databaseIdProvider;

  private final List<ConfigurationCustomizer> configurationCustomizers;
  @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()));
    }
    applyConfiguration(factory);
    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 (this.properties.getTypeAliasesSuperType() != null) {
      factory.setTypeAliasesSuperType(this.properties.getTypeAliasesSuperType());
    }
    if (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {
      factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
    }
    if (!ObjectUtils.isEmpty(this.typeHandlers)) {
      factory.setTypeHandlers(this.typeHandlers);
    }
    if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
      factory.setMapperLocations(this.properties.resolveMapperLocations());
    }
    Set<String> factoryPropertyNames = Stream
        .of(new BeanWrapperImpl(SqlSessionFactoryBean.class).getPropertyDescriptors()).map(PropertyDescriptor::getName)
        .collect(Collectors.toSet());
    Class<? extends LanguageDriver> defaultLanguageDriver = this.properties.getDefaultScriptingLanguageDriver();
    if (factoryPropertyNames.contains("scriptingLanguageDrivers") && !ObjectUtils.isEmpty(this.languageDrivers)) {
      // Need to mybatis-spring 2.0.2+
      factory.setScriptingLanguageDrivers(this.languageDrivers);
      if (defaultLanguageDriver == null && this.languageDrivers.length == 1) {
        defaultLanguageDriver = this.languageDrivers[0].getClass();
      }
    }
    if (factoryPropertyNames.contains("defaultScriptingLanguageDriver")) {
      // Need to mybatis-spring 2.0.2+
      factory.setDefaultScriptingLanguageDriver(defaultLanguageDriver);
    }

    return factory.getObject();
  }
  
 private void applyConfiguration(SqlSessionFactoryBean factory) {
    Configuration configuration = this.properties.getConfiguration();
    if (configuration == null && !StringUtils.hasText(this.properties.getConfigLocation())) {
      configuration = new Configuration();
    }
    if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
      for (ConfigurationCustomizer customizer : this.configurationCustomizers) {
        customizer.customize(configuration);
      }
    }
    factory.setConfiguration(configuration);
  }
//忽略代码............
}

其主要是配置Mybatis的行为，案例如下

mybatis:
 mapperLocations: classpath:mapper/*.xml
 config-location: classpath:/mybatis-config
2.4 SqlSessionTemplate的注册

基于MybatisAutoConfiguration

@org.springframework.context.annotation.Configuration
@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })
@ConditionalOnSingleCandidate(DataSource.class)
@EnableConfigurationProperties(MybatisProperties.class)
@AutoConfigureAfter({ DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class })
public class MybatisAutoConfiguration implements InitializingBean {

  private static final Logger logger = LoggerFactory.getLogger(MybatisAutoConfiguration.class);

  private final MybatisProperties properties;

  private final Interceptor[] interceptors;

  private final TypeHandler[] typeHandlers;

  private final LanguageDriver[] languageDrivers;

  private final ResourceLoader resourceLoader;

  private final DatabaseIdProvider databaseIdProvider;

  private final List<ConfigurationCustomizer> configurationCustomizers;
  //忽略代码............
  @Bean
  @ConditionalOnMissingBean
  public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
    ExecutorType executorType = this.properties.getExecutorType();
    if (executorType != null) {
      return new SqlSessionTemplate(sqlSessionFactory, executorType);
    } else {
      return new SqlSessionTemplate(sqlSessionFactory);
    }
  }
2.5 扫描映射器类

基于MybatisAutoConfiguration

@org.springframework.context.annotation.Configuration
@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })
@ConditionalOnSingleCandidate(DataSource.class)
@EnableConfigurationProperties(MybatisProperties.class)
@AutoConfigureAfter({ DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class })
public class MybatisAutoConfiguration implements InitializingBean {

  private static final Logger logger = LoggerFactory.getLogger(MybatisAutoConfiguration.class);

  private final MybatisProperties properties;

  private final Interceptor[] interceptors;

  private final TypeHandler[] typeHandlers;

  private final LanguageDriver[] languageDrivers;

  private final ResourceLoader resourceLoader;

  private final DatabaseIdProvider databaseIdProvider;

  private final List<ConfigurationCustomizer> configurationCustomizers;
  //忽略代码............
  @org.springframework.context.annotation.Configuration
  @Import(AutoConfiguredMapperScannerRegistrar.class)
  //容器中，没有MapperFactoryBean和MapperScannerConfigurer才会注册
  @ConditionalOnMissingBean({ MapperFactoryBean.class, MapperScannerConfigurer.class })
  public static class MapperScannerRegistrarNotFoundConfiguration implements InitializingBean {

    @Override
    public void afterPropertiesSet() {
      logger.debug(
          "Not found configuration for registering mapper bean using @MapperScan, MapperFactoryBean and MapperScannerConfigurer.");
    }

  }

  public static class AutoConfiguredMapperScannerRegistrar implements BeanFactoryAware,ImportBeanDefinitionRegistrar{

    private BeanFactory beanFactory;

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

      if (!AutoConfigurationPackages.has(this.beanFactory)) {
        logger.debug("Could not determine auto-configuration package, automatic mapper scanning disabled.");
        return;
      }

      logger.debug("Searching for mappers annotated with @Mapper");

      List<String> packages = AutoConfigurationPackages.get(this.beanFactory);
      if (logger.isDebugEnabled()) {
        packages.forEach(pkg -> logger.debug("Using auto-configuration base package '{}'", pkg));
      }

      BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
      builder.addPropertyValue("processPropertyPlaceHolders", true);
      builder.addPropertyValue("annotationClass", Mapper.class);//这里表明只扫mapper
      builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(packages));
      BeanWrapper beanWrapper = new BeanWrapperImpl(MapperScannerConfigurer.class);
      Stream.of(beanWrapper.getPropertyDescriptors())
          // Need to mybatis-spring 2.0.2+
          .filter(x -> x.getName().equals("lazyInitialization")).findAny()
          .ifPresent(x -> builder.addPropertyValue("lazyInitialization", "${mybatis.lazy-initialization:false}"));
      registry.registerBeanDefinition(MapperScannerConfigurer.class.getName(), builder.getBeanDefinition());
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
      this.beanFactory = beanFactory;
    }

  }
//忽略代码............
}

1、Mybatis和SpringBoot利用MyBatis-Spring-Boot-Starter整合后，我们不需要自己手动写@MapperScan，如果我们自己写了@MapperScan，那么MyBatis-Spring-Boot-Starter默认的AutoConfiguredMapperScannerRegistrar就会失效。

2、AutoConfiguredMapperScannerRegistrar的作用和@MapperScan一样，都是注册MapperScannerConfigurer，但是
AutoConfiguredMapperScannerRegistrar注册的MapperScannerConfigurer包扫描的空间和@SpringBootApplication一样，但是其只扫描标注了@Mapper注解的类

这是一条海鱼
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【二十四】springboot整合spring事务详解以及实战
weixin_56995925的博客
07-03 6920
springboot整合spring事务详解以及实战
SpringBoot结合MyBatis 【超详细】
热门推荐
m0_65563175的博客
10-16 9万+
Spring Boot与MyBatis框架集合实践。内置MyBatis大部分使用技巧，而Spring Boot起到个快速入门的效果。其中MyBatis内容涉及到业务层与数据访问层的传参知识、企业常用的动态SQL拼接、高级映射及延迟加载、以及缓存机制、最后包括PageHelper分页插件
SpringBoot整合Mybatis
junR_980218的博客
05-16 5万+
SpringBoot整合Mybatis
SpringBoot整合Mybatis（详解，一看就会）
最新发布
m0_67267524的博客
05-19 698
在resource创建好之后，我们在resource目录下创建application.yml，创建完之后写数据库配置文件，根据自己的 数据库和数据库账号和密码进行更改，改成自己的，以及端口，我这边端口是8081，根据自己可以修改端口，默认是 8080。注：本类中不要忘记写@service，以及依赖注入UserMapper，刚开始可以直接复制我的代码，后面自己去慢慢理解。至此我们的SpringBoot+Mybatis已经整合完毕了 我们运行项目，显示如下，我们已经运行完毕且没有错误。delete用于删除。
Dependency ‘org.mybatis.spring.bootmybatis-spring-boot-starter‘ not found
m0_54853420的博客
03-31 2549
Dependency ‘org.mybatis.spring.boot:mybatis-spring-boot-starter:’ not found 整合mybatis时，添加的依赖一直飘红 给出答主的解决方法 https://blog.csdn.net/qq_45570838/article/details/105471518
Spring Boot整合Mybatis和mysql驱动依赖
m0_45186506的博客
06-20 1005
【代码】Spring Boot整合Mybatis和mysql驱动依赖。
springboot2.7.10集成mybatis2.3.0和mysql8.0.32的坑
qq_43671768的博客
04-02 656
在src\main\resources下新建mapper文件夹，统一管理存放sql语句的mapper.xml，因此需要在application.properties中配置。1.application.properties/properties.yml 中mysql8.0以上版本驱动应该是。2. 检查build.gradle/pom.xml中导入的mysql依赖版本与本地mysql版本对应的驱动版本，（2）输入数据库信息后点击左下方的。
Spring整合Mybatis与SpringBoot整合Mybatis原理分析
04-16
一个完整而简单SSM项目，包含SQL脚本、代码与学习笔记。内容Spring如何整合SpringMVC与Mybatis以及整合原理的源码分析。
SpringBoot-Mybatis:SpringBoot整合Mybatis
05-02
SpringBoot-Mybatis 1. 认识Mybatis MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或...
springboot-mybatis:springboot整合mybatis
05-03
springboot-mybatis springboot整合mybatis
mybatis+springboot框架整合
09-03
mybatis+springboot框架整合 更改一下数据库地址 加一个user表就可以直接测试
springBoot整合mybatis完整详细版
09-27
springBoot整合mybatis完整详细版，简单清晰明了，适合新手拿来研究训练学习，整合教程博客https://blog.csdn.net/iku5200/article/details/82856621
springboot同时整合JPA和mybatis的demo
08-12
这个demo同时整合了springboot+JPA+mybatis这个两个orm框架。
（三）Springboot原理解析之集成Mybatis和SpringMVC
Armyyyyy丶的博客
06-22 714
目录 一、集成Mybatis 1.传统Spring集成Mybatis 2.Springboot集成Mybatis 二、集成SpringMVC 1.Tomcat传统集成方式 2.Springboot自动集成 2.1 WebMvcAutoConfiguration类 2.2 DispatcherServletAutoConfiguration类 2.3 ServletWebServerFactoryAutoConfiguration类 2.4 ServletWebServerFactoryC
MyBatis入门系列(26) -MyBatis-Spring-Boot-Starter入门案例
记录知识、锤炼自我
11-01 3055
前言 mybatis除了继承了Spring以外，还集成了Spring Boot的自动配置及自动装配，开发更加简化。 MyBatis-Spring-Boot-Starter 帮助您在Spring Boot之上快速构建 MyBatis 应用程序。 通过使用此模块，您将实现： 构建独立的应用程序 将样板文件减少到几乎为零 更少的 XML 配置 要求 MyBatis-Spring-Boot-Starter 需要以下版本： 入门案例 首先使用Spring Initializr创建一个Spring Boot We
Spring Boot 中使用 MyBatis-Spring-Boot-Starter
ljinest
01-04 1万+
Spring Boot 中使用 MyBatis-Spring-Boot-Starter 本文将使用 MyBatis-Spring-Boot-Starter 在Spring Boot中建立 Mybatis 应用。 本文将实现： 构建一个独立应用 将JDBC模板代码减少到最小值（接近0） 更少的XML配置 版本要求 MyBatis-Spring-Boot-Starter MyBatis-Spring Spring Boot Java 2.2 2.0(2.0.6以上解锁所有功能) 2.5或以上
SpringBoot学习之路（六）——SpringBoot整合Mybatis
Tony_chenph的博客
11-24 1135
一、基础环境准备工作 1、在Navicat中新建查询，创建数据库develop并在库中创建两张表t_article和t_comment，运行以下脚本即可 #创建数据库 CREATE DATABASE develop; #选择使用数据库 USE develop; #创建表t_article并插入相关数据 DROP TABLE IF EXISTS t_article; CREATE TABLE t_article ( id int(20) NOT NULL AUTO_INCREMENT CO..
整合mybatis与springboot(简洁版）
yebadi_的博客
07-09 243
最终结果的展示 1. 首先导入所需的依赖 <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.1.3</version> </dependen
Spring Boot 2.7.0 Mybatis入门(二)
qq_36378416的博客
06-24 3437
MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。​ 在mybatis这类框架没有出现之前，大多通过 jdbc连接数据库的方式，在java代码中拼接sql语句然后执行,具体如下： mybatis框架对以上过程进行封装和优化，包括:可以配置数据源建立连接池；将java和 sql语句分离，sql语
mybatis和springboot整合
09-06
MyBatis和Spring Boot的整合相对比较简单。下面是一些基本的步骤： 1. 首先，在你的Spring Boot项目的pom.xml文件中添加MyBatis和相关的依赖，例如mybatis-spring-boot-starter和数据库驱动依赖。 2. 创建一个数据...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值