一 、Spring Boot中Mybatis启动过程概述

最新推荐文章于 2024-09-16 16:40:34 发布
最新推荐文章于 2024-09-16 16:40:34 发布
阅读量713 收藏 1
点赞数
文章标签： java 数据库 python
原文链接：https://my.oschina.net/yangjianzhou/blog/3022258
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

一、问题描述

在工作中，经常用到ORM框架，目前使用最为广泛的一个就是mybatis，由于其上手快、学习成本低、灵活等优点（参见：为什么用mybatis），被很多公司用来作为ORM解决方案。

因此，熟悉mybatis在项目中的运行过程及其运行原理就很有必要了。

二、启动流程

spring boot启动过程中，加载mybatis的mapper（实例化为spring的bean，初步加工）、加载mybaits的mapper配置文件、将mybatis的mapper对应的bean绑定到jdk的动态代理上的整个过程如下：

三、详细流程

1、spring的启动过程

spring应用的启动过程，实际上就是AbstractApplicationContext.refresh()方法运行的过程，其过程如下：

2、mapper实例化

mapper实例化就是将注解MapperScan指定的包下面的接口实例化为spring的bean，这时的bean还没被彻底实例化，还不能使用。这个是在mybatis-spring包中实现的。

public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {

  private ResourceLoader resourceLoader;

  /**
   * {@inheritDoc}
   */
  @Override
  public void setResourceLoader(ResourceLoader resourceLoader) {
    this.resourceLoader = resourceLoader;
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    AnnotationAttributes mapperScanAttrs = AnnotationAttributes
        .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
    if (mapperScanAttrs != null) {
      registerBeanDefinitions(mapperScanAttrs, registry);
    }
  }

  void registerBeanDefinitions(AnnotationAttributes annoAttrs, BeanDefinitionRegistry registry) {

    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);

    // this check is needed in Spring 3.1
    Optional.ofNullable(resourceLoader).ifPresent(scanner::setResourceLoader);

    Class<? extends Annotation> annotationClass = annoAttrs.getClass("annotationClass");
    if (!Annotation.class.equals(annotationClass)) {
      scanner.setAnnotationClass(annotationClass);
    }

    Class<?> markerInterface = annoAttrs.getClass("markerInterface");
    if (!Class.class.equals(markerInterface)) {
      scanner.setMarkerInterface(markerInterface);
    }

    Class<? extends BeanNameGenerator> generatorClass = annoAttrs.getClass("nameGenerator");
    if (!BeanNameGenerator.class.equals(generatorClass)) {
      scanner.setBeanNameGenerator(BeanUtils.instantiateClass(generatorClass));
    }

    Class<? extends MapperFactoryBean> mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");
    if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {
      scanner.setMapperFactoryBean(BeanUtils.instantiateClass(mapperFactoryBeanClass));
    }

    scanner.setSqlSessionTemplateBeanName(annoAttrs.getString("sqlSessionTemplateRef"));
    scanner.setSqlSessionFactoryBeanName(annoAttrs.getString("sqlSessionFactoryRef"));

    List<String> basePackages = new ArrayList<>();
    basePackages.addAll(
        Arrays.stream(annoAttrs.getStringArray("value"))
            .filter(StringUtils::hasText)
            .collect(Collectors.toList()));

    basePackages.addAll(
        Arrays.stream(annoAttrs.getStringArray("basePackages"))
            .filter(StringUtils::hasText)
            .collect(Collectors.toList()));

    basePackages.addAll(
        Arrays.stream(annoAttrs.getClassArray("basePackageClasses"))
            .map(ClassUtils::getPackageName)
            .collect(Collectors.toList()));

    scanner.registerFilters();
    scanner.doScan(StringUtils.toStringArray(basePackages));
  }

  /**
   * A {@link MapperScannerRegistrar} for {@link MapperScans}.
   * @since 2.0.0
   */
  static class RepeatingRegistrar extends MapperScannerRegistrar {
    /**
     * {@inheritDoc}
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
        BeanDefinitionRegistry registry) {
      AnnotationAttributes mapperScansAttrs = AnnotationAttributes
          .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScans.class.getName()));
      if (mapperScansAttrs != null) {
        Arrays.stream(mapperScansAttrs.getAnnotationArray("value"))
            .forEach(mapperScanAttrs -> registerBeanDefinitions(mapperScanAttrs, registry));
      }
    }
  }

}

接口ImportBeanDefinitionRegistrar的唯一方法registerBeanDefinitions就是根据指定的注解去注册bean。其描述如下：

public interface ImportBeanDefinitionRegistrar {

	/**
	 * Register bean definitions as necessary based on the given annotation metadata of
	 * the importing {@code @Configuration} class.
	 * <p>Note that {@link BeanDefinitionRegistryPostProcessor} types may <em>not</em> be
	 * registered here, due to lifecycle constraints related to {@code @Configuration}
	 * class processing.
	 * @param importingClassMetadata annotation metadata of the importing class
	 * @param registry current bean definition registry
	 */
	public void registerBeanDefinitions(
			AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry);

}

因此，在spring启动过程中，实现了接口ImportBeanDefinitionRegistrar的类会被调用其方法registerBeanDefinitions来注册额外的bean到BeanDefinitionRegistry中，这里就可以根据自己的需求，使用定制的注解来实例bean。

从上面的代码可以看出，配置mapper所在包还可以使用@MapperScans。

3、mapper配置文件加载

在spring boot中，mapper配置文件的位置可以通过配置mybatis.mapperLocations来指定。MybatisAutoConfiguration在实例化SqlSessionFactory的时候，就会去读取mybatis.mapperLocations指定的配置文件，然后解析会里面每个SQL。实例化SqlSessionFactory的代码在mybatis-spring-boot-autoconfigure包中，解析mapper.xml文件的代码位于mybatis中。

  @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()));
    }
    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);
    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();//这里会去解析mapper.xml文件
  }

4、mapper bean与动态代理类绑定

mapper对应的bean实例化的最后一步，就是将接口和动态代理的类绑定。

  protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

  public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }

MapperProxy就是具体的代理，实现如下：

/**
 *    Copyright 2009-2017 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.binding;

import java.io.Serializable;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Map;

import org.apache.ibatis.lang.UsesJava7;
import org.apache.ibatis.reflection.ExceptionUtil;
import org.apache.ibatis.session.SqlSession;

/**
 * @author Clinton Begin
 * @author Eduardo Macarron
 */
public class MapperProxy<T> implements InvocationHandler, Serializable {

  private static final long serialVersionUID = -6424540398559729838L;
  private final SqlSession sqlSession;
  private final Class<T> mapperInterface;
  private final Map<Method, MapperMethod> methodCache;

  public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {
    this.sqlSession = sqlSession;
    this.mapperInterface = mapperInterface;
    this.methodCache = methodCache;
  }

  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      if (Object.class.equals(method.getDeclaringClass())) {
        return method.invoke(this, args);
      } else if (isDefaultMethod(method)) {
        return invokeDefaultMethod(proxy, method, args);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    return mapperMethod.execute(sqlSession, args);
  }

  private MapperMethod cachedMapperMethod(Method method) {
    MapperMethod mapperMethod = methodCache.get(method);
    if (mapperMethod == null) {
      mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
      methodCache.put(method, mapperMethod);
    }
    return mapperMethod;
  }

  @UsesJava7
  private Object invokeDefaultMethod(Object proxy, Method method, Object[] args)
      throws Throwable {
    final Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class
        .getDeclaredConstructor(Class.class, int.class);
    if (!constructor.isAccessible()) {
      constructor.setAccessible(true);
    }
    final Class<?> declaringClass = method.getDeclaringClass();
    return constructor
        .newInstance(declaringClass,
            MethodHandles.Lookup.PRIVATE | MethodHandles.Lookup.PROTECTED
                | MethodHandles.Lookup.PACKAGE | MethodHandles.Lookup.PUBLIC)
        .unreflectSpecial(method, declaringClass).bindTo(proxy).invokeWithArguments(args);
  }

  /**
   * Backport of java.lang.reflect.Method#isDefault()
   */
  private boolean isDefaultMethod(Method method) {
    return (method.getModifiers()
        & (Modifier.ABSTRACT | Modifier.PUBLIC | Modifier.STATIC)) == Modifier.PUBLIC
        && method.getDeclaringClass().isInterface();
  }
}

四、实例

了解了spring boot中mybatis的加载及初始化过程后，下面给出spring boot集成mybaits的具体实例。

代码结构如下：

主类代码如下：

package com.iwill.mybatis;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@SpringBootApplication
@ComponentScan("com.iwill.mybatis")
@MapperScan(value = {"com.iwill.mybatis.dao.mapper.ext", "com.iwill.mybatis.dao.mapper.gen"})
@EnableTransactionManagement(proxyTargetClass = true)
public class MyBatisApplication {

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

application.properties配置如下：

spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.password=123456
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&allowMultiQueries=true
spring.datasource.username=jack

mybatis.mapperLocations=classpath:mapper/**/*.xml

logging.level.org.mybatis=DEBUG

 

转载于:https://my.oschina.net/yangjianzhou/blog/3022258

weixin_33842328
关注
基于Spring Boot和MyBatis的论坛问答平台.zip
09-02
基于Spring Boot和MyBatis的论坛问答平台 项目概述 这是一个开源论坛和问答系统，提供提问、回复、通知、最新、最热、消除零回复等功能。项目采用Spring Boot框架，结合MyBatis进行数据库操作，使用H2作为嵌入式...
SpringBoot结合MyBatis 【超详细】
热门推荐
m0_65563175的博客
10-16 10万+
Spring Boot与MyBatis框架集合实践。内置MyBatis大部分使用技巧，而Spring Boot起到个快速入门的效果。其中MyBatis内容涉及到业务层与数据访问层的传参知识、企业常用的动态SQL拼接、高级映射及延迟加载、以及缓存机制、最后包括PageHelper分页插件
SpringBoot 集成 Mybatis 启动流程与原理
qq_20614905的博客
11-01 4435
最近一直处于疯狂读源码的状态，简直就是少壮不努力，老大徒伤悲。言归正传，虽然所在的公司用的框架都是内部的，基于开源的框架封装的，但是平时自己写东西的时候，还是喜欢直接用开源的框架。在大学的时候就用过SpringBoot，工作以后也用过Mybatis，但是会用却不是很了解原理。最近就很好奇，SpringBoot的项目通过starter的形式集成Mybatis后，启动的流程与原理，于是就...
mybatis的基本使用与配置
最新发布
不起眼小菜菜的博客
09-16 558
注释很详细，直接上代码……
面试-springboot-mybatis启动流程
weixin_37862824的博客
03-20 1099
一、看完本篇文章你会知道 1、Mapper是如何被扫描进来的 2、Mapper是如何被实例化的 二、Spring加载Mapper 1、在spring启动的时候，会执行refresh刷新方法，刷新里面会有一个invokeBeanFactoryPostProcessors方法，他调用ConfigurationClassPostProcessor后置处理器去加载各个Bean 2、ConfigurationClassPostProcessor会在Bean中找到是Configuration类型的Bean，判断这个Be
（13）【MyBatis的启动流程与Spring boot配置】
寒潭清
06-29 541
一、Mybatis的启动流程 加载Mapper配置的映射文件或者注解相关sql内容 创建会话工厂，MyBatis通过读写配置文件中的数据源信息来构造会话工厂 创建会话，Mybatis通过会话工厂创建会话对象，会话对象是个接口，包含对数据库的增删改查方法 创建执行器，会话本身不能直接操作数据库，通过数据库执行器来帮它执行操作 封装Sql对象，执行器将代处理sql信息分到对象MappedStatement中，包括sql语句、输入输出、输出结果映射 操作数据库
Spring Boot : Mybatis 执行原理分析
GIS摆渡人
07-20 1400
计算机的基本工作就是存储和计算，而MyBatis是存储领域的利器。MyBatis的基本工作原理就是先封装SQL，接着调用JDBC操作数据库，最后把数据库返回的表结果封装成Java类。
基于Spring Boot和MyBatis的知识交流社区平台.zip
09-02
这是一个基于Spring Boot和MyBatis的社区平台，旨在为用户提供一个交流技术、分享知识的场所。项目包含了用户管理、问题发布、评论、通知等多个功能模块，通过GitHub OAuth实现第三方登录，使用Flyway进行数据库版本...
基于Spring Boot和MyBatis的简易客户管理系统设计
08-20
本项目旨在设计一个基于Spring Boot和MyBatis框架的简易客户管理系统，主要功能模块包括客户信息管理、用户认证与权限管理、数据查询与统计分析等。以下是具体功能概述： 客户信息管理：客户信息管理模块设计目标是...
spring boot整合mybatis使用c3p0数据源连接mysql
08-27
一、Spring Boot 框架概述 * Spring Boot 是一个基于 Spring 框架的微服务框架，提供了一种快速构建基于 Spring 框架的独立应用程序的方式。 * Spring Boot 的主要特点是自动配置、 producción-ready、基于注解的...
基于Spring Boot和MyBatis的银行知识库管理系统的设计与实现
02-23
通过使用Spring Boot框架的快速开发能力、MyBatis框架的数据库操作便利性以及MVC模式的良好架构设计，可以构建出一个功能完备、稳定可靠的银行知识库管理系统，以帮助银行和金融机构更高效地管理知识资产，提升服务...
SpringBoot整合Mybatis超详细流程
2301_78021017的博客
05-09 1368
MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Ordinary Java Object，普通老式 Java 对象）为数据库中的记录。因为 Mybatis的性能非常不错，SpringBoot 官方推荐使用 Mybatis 来连接数据库进行 CRUD 操作。
Springboot整合Mybaits启动过程
Listen·Rain的博客
03-09 1015
springboot整合mybatis启动过程
MyBatis+Springboot 启动到SQL执行全流程
战斧的博客
06-13 9075
本文我们将讲解Mybatis的动态sql是什么，以及从项目启动到sql执行全流程
springboot 加载mybatis的流程
lipengyao2010的专栏
08-20 1097
一、mybatics的配置步骤 1.POM依赖包加载 <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>1.3.2</version>
SpringBoot启动过程深度解析——Mybatis启动过程源码解析-完整流程图
weixin_39072857的博客
04-19 219
SpringBoot启动过程深度解析——Mybatis启动过程源码解析-完整流程图
spring-boot mybatis 初始化流程
TheThirdMoon的博客
03-28 289
1. 初始化的目的是构建三个对象 SqlSessionFactory：保存了所有配置信息，构建sqlSession SqlSessionTemplate: 用于执行sql MapperScannerConfigurer：实现了BeanDefinitionRegistryPostProcessor接口，可以扫描mapper，注册到容器中
Springboot整合mybatis基本步骤
Czh的博客
11-19 225
1、导入相关依赖 <dependencies> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.1.1</version>
Spring Boot + MyBatis 的使用流程
qq_61818443的博客
04-03 462
这些文件也放在 `src/main/resources` 目录下，通常放在一个特定的包路径下，如 `resources/mapper`。在 Spring Boot 的配置文件中，你可以指定 MyBatis 全局配置文件的位置和映射文件的位置。这个全局配置文件指定了 MyBatis 的一些全局设置，例如开启下划线到驼峰命名法的自动转换，并指明了 Mapper 文件的位置。在 `application.yml` 配置文件中，我们指定了 Mapper 文件的位置，并设置了一些 MyBatis 配置选项。
基于Spring Boot和Mybatis打造实习生招聘平台
知识点一：Spring Boot 概述 Spring Boot 是一种基于Spring框架的开源Java项目，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot 包含了自动配置、独立运行的Java应用程序、生产级别的监控、健康检查和外部...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值