MybatisPlus源码解析1：mybatis-plus启动流程

1.项目结构

1.1 pom.xml

<?xml version="1.0" encoding="UTF-8"?>
	<project xmlns="http://maven.apache.org/POM/4.0.0"
	         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	    <modelVersion>4.0.0</modelVersion>
	
	    <groupId>org.example</groupId>
	    <artifactId>mybatis-plus-starter</artifactId>
	    <version>1.0-SNAPSHOT</version>
	    <description>mybatis-plus首个项目</description>
	
	    <profiles>
	        <profile>
	            <id>jdk-1.8</id>
	            <activation>
	                <activeByDefault>true</activeByDefault>
	                <jdk>1.8</jdk>
	            </activation>
	            <properties>
	                <maven.compiler.source>1.8</maven.compiler.source>
	                <maven.compiler.target>1.8</maven.compiler.target>
	                <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
	            </properties>
	        </profile>
	    </profiles>
	
	    <parent>
	        <groupId>org.springframework.boot</groupId>
	        <artifactId>spring-boot-starter-parent</artifactId>
	        <version>2.7.1</version>
	        <relativePath/>
	    </parent>
	
	    <dependencies>
	        <dependency>
	            <groupId>org.springframework.boot</groupId>
	            <artifactId>spring-boot-starter-web</artifactId>
	        </dependency>
	        <dependency>
	            <groupId>com.baomidou</groupId>
	            <artifactId>mybatis-plus-boot-starter</artifactId>
	            <version>3.5.3</version>
	        </dependency>
	        <dependency>
	            <groupId>mysql</groupId>
	            <artifactId>mysql-connector-java</artifactId>
	            <version>8.0.21</version>
	        </dependency>
	        <dependency>
	            <groupId>com.alibaba</groupId>
	            <artifactId>fastjson</artifactId>
	            <version>1.2.79</version>
	        </dependency>
	        <dependency>
	            <groupId>org.slf4j</groupId>
	            <artifactId>slf4j-api</artifactId>
	            <version>1.7.21</version>
	        </dependency>
	        <dependency>
	            <groupId>ch.qos.logback</groupId>
	            <artifactId>logback-classic</artifactId>
	            <version>1.2.3</version>
	        </dependency>
	        <dependency>
	            <groupId>org.projectlombok</groupId>
	            <artifactId>lombok</artifactId>
	            <version>1.18.24</version>
	        </dependency>
	    </dependencies>
	</project>

1.2 UserService

public interface IUserService extends IService<User> {
}

@Service
public class UserService extends ServiceImpl<UserMapper, User> implements IUserService {
}

1.3 UserMapper

public interface UserMapper extends BaseMapper<User> {
}

1.4 User

@Data
public class User {

//    @TableId
    private Long id;

    private String name;

    private Integer age;

}

1.5 application.yml

server:
  port: 8888
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatisplus?serverTimezone=UTC
    username: root
    password: 123456
mybatis-plus:
  mapper-locations: classpath:/mapper/*Mapper.xml
  typeAliasesPackage: com.lmh.plus.entity
  configuration:
  # log-impl: org.apache.ibatis.logging.nologging.NoLoggingImpl
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  global-config:
    db-config:
      logic-delete-value: 1
      logic-not-delete-value: 0

1.6 启动类

@SpringBootApplication
@MapperScan(basePackages = "com.lmh.plus.mapper")
public class Application {

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

2. 源码分析

2.1 MybatisPlus自动配置 MybatisPlusAutoConfiguration

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})
@ConditionalOnSingleCandidate(DataSource.class)
@EnableConfigurationProperties(MybatisPlusProperties.class)
@AutoConfigureAfter({DataSourceAutoConfiguration.class, MybatisPlusLanguageDriverAutoConfiguration.class})
public class MybatisPlusAutoConfiguration implements InitializingBean {

}

这里是mybatisPlus自动配置的入口

2.2 @MapperScan

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(MapperScannerRegistrar.class)
@Repeatable(MapperScans.class)
public @interface MapperScan {

}

@MapperScan的原理来源于Spring的@ComponentScan
具体实现如下：由于MapperScan注解被@Import(MapperScannerRegistrar.class)所标注，spring在创建beanFactory容器之后，会调用org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry来实现beanDefinition的装配，其中就包括了@Import注解。这里涉及到spring源码的复杂知识，就不展开分析了，毕竟主题是mp。

MapperScannerRegistrar#registerBeanDefinitions

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

  void registerBeanDefinitions(AnnotationMetadata annoMeta, AnnotationAttributes annoAttrs,
      BeanDefinitionRegistry registry, String beanName) {

    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
    builder.addPropertyValue("processPropertyPlaceHolders", true);

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

    Class<?> markerInterface = annoAttrs.getClass("markerInterface");
    if (!Class.class.equals(markerInterface)) {
      builder.addPropertyValue("markerInterface", markerInterface);
    }

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

    Class<? extends MapperFactoryBean> mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");
    if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {
      builder.addPropertyValue("mapperFactoryBeanClass", mapperFactoryBeanClass);
    }

    String sqlSessionTemplateRef = annoAttrs.getString("sqlSessionTemplateRef");
    if (StringUtils.hasText(sqlSessionTemplateRef)) {
      builder.addPropertyValue("sqlSessionTemplateBeanName", annoAttrs.getString("sqlSessionTemplateRef"));
    }

    String sqlSessionFactoryRef = annoAttrs.getString("sqlSessionFactoryRef");
    if (StringUtils.hasText(sqlSessionFactoryRef)) {
      builder.addPropertyValue("sqlSessionFactoryBeanName", 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()));

    if (basePackages.isEmpty()) {
      basePackages.add(getDefaultBasePackage(annoMeta));
    }

    String lazyInitialization = annoAttrs.getString("lazyInitialization");
    if (StringUtils.hasText(lazyInitialization)) {
      builder.addPropertyValue("lazyInitialization", lazyInitialization);
    }

    String defaultScope = annoAttrs.getString("defaultScope");
    if (!AbstractBeanDefinition.SCOPE_DEFAULT.equals(defaultScope)) {
      builder.addPropertyValue("defaultScope", defaultScope);
    }

    builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(basePackages));

    // for spring-native
    builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

    registry.registerBeanDefinition(beanName, builder.getBeanDefinition());

  }

我们可以看到，最终将Mybatis的扫描器MapperScannerConfigurer的BeanDefinition注册到Spring容器里面

2.3 MapperScannerConfigurer#postProcessBeanDefinitionRegistry

该方法的主要作用是对Mapper接口进行扫描，并且将扫描到的bean注册到Spring容器里面

public class MapperScannerConfigurer
    implements BeanDefinitionRegistryPostProcessor, InitializingBean, ApplicationContextAware, BeanNameAware

可以看到MapperScannerConfigurer也实现了BeanDefinitionRegistryPostProcessor接口，也会调用postProcessBeanDefinitionRegistry方法，最终调用了ClassPathMapperScanner#doScan方法，进行扫描Mapper接口

ClassPathMapperScanner#doScan

@Override
  public Set<BeanDefinitionHolder> doScan(String... basePackages) {
    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 {
      processBeanDefinitions(beanDefinitions);
    }

    return beanDefinitions;
  }

首先扫描包名com.lmh.plus.mapper下面所有的接口，然后生成beanDefinition中，注册到beanFactory.beanDefinitionMap中（这里是Spring源码知识就不展开了）。
然后再调用processBeanDefinitions方法

ClassPathMapperScanner#processBeanDefinitions

private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
    AbstractBeanDefinition definition;
    BeanDefinitionRegistry registry = getRegistry();
    for (BeanDefinitionHolder holder : beanDefinitions) {
      definition = (AbstractBeanDefinition) holder.getBeanDefinition();
      boolean scopedProxy = false;
      if (ScopedProxyFactoryBean.class.getName().equals(definition.getBeanClassName())) {
        definition = (AbstractBeanDefinition) Optional
            .ofNullable(((RootBeanDefinition) definition).getDecoratedDefinition())
            .map(BeanDefinitionHolder::getBeanDefinition).orElseThrow(() -> new IllegalStateException(
                "The target bean definition of scoped proxy bean not found. Root bean definition[" + holder + "]"));
        scopedProxy = true;
      }
      String beanClassName = definition.getBeanClassName();
      LOGGER.debug(() -> "Creating MapperFactoryBean with name '" + holder.getBeanName() + "' and '" + beanClassName
          + "' mapperInterface");

      // the mapper interface is the original class of the bean
      // but, the actual class of the bean is MapperFactoryBean
      definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName); // issue #59
      try {
        // for spring-native
        definition.getPropertyValues().add("mapperInterface", Resources.classForName(beanClassName));
      } catch (ClassNotFoundException ignore) {
        // ignore
      }

      definition.setBeanClass(this.mapperFactoryBeanClass);

      definition.getPropertyValues().add("addToConfig", this.addToConfig);

      // Attribute for MockitoPostProcessor
      // https://github.com/mybatis/spring-boot-starter/issues/475
      definition.setAttribute(FACTORY_BEAN_OBJECT_TYPE, beanClassName);

      boolean explicitFactoryUsed = false;
      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;
      }

      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;
      }

      if (!explicitFactoryUsed) {
        LOGGER.debug(() -> "Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
        definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
      }

      definition.setLazyInit(lazyInitialization);

      if (scopedProxy) {
        continue;
      }

      if (ConfigurableBeanFactory.SCOPE_SINGLETON.equals(definition.getScope()) && defaultScope != null) {
        definition.setScope(defaultScope);
      }

      if (!definition.isSingleton()) {
        BeanDefinitionHolder proxyHolder = ScopedProxyUtils.createScopedProxy(holder, registry, true);
        if (registry.containsBeanDefinition(proxyHolder.getBeanName())) {
          registry.removeBeanDefinition(proxyHolder.getBeanName());
        }
        registry.registerBeanDefinition(proxyHolder.getBeanName(), proxyHolder.getBeanDefinition());
      }

    }
  }

该方法修改了beanDefinition的信息：
首先beanDifinition的beanClass属性设置为MapperFactoryBean.class，而MapperFactoryBean实现了FactoryBean接口
然后添加propertyValue，该值为UserMapper.class
所以，这个时候，Mapper接口对应的beanDefinition全部注册到Spring容器里面了

2.4 创建SqlSessionFactory MybatisPlusAutoConfiguration#sqlSessionFactory

为什么要创建sqlSessionFactory?
首先：sqlSessionFactory是mybatis很重要的环节，负责对sqlSession的创建，从而才能执行sql
其次：sqlSessionFactory的创建是为了MapperFactoryBean创建和解析sql语句作铺垫

@Bean
@ConditionalOnMissingBean
 public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
     // TODO 使用 MybatisSqlSessionFactoryBean 而不是 SqlSessionFactoryBean
     MybatisSqlSessionFactoryBean factory = new MybatisSqlSessionFactoryBean();
     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());
     }
     // TODO 修改源码支持定义 TransactionFactory
     this.getBeanThen(TransactionFactory.class, factory::setTransactionFactory);

     // TODO 对源码做了一定的修改(因为源码适配了老旧的mybatis版本,但我们不需要适配)
     Class<? extends LanguageDriver> defaultLanguageDriver = this.properties.getDefaultScriptingLanguageDriver();
     if (!ObjectUtils.isEmpty(this.languageDrivers)) {
         factory.setScriptingLanguageDrivers(this.languageDrivers);
     }
     Optional.ofNullable(defaultLanguageDriver).ifPresent(factory::setDefaultScriptingLanguageDriver);

     applySqlSessionFactoryBeanCustomizers(factory);

     // TODO 此处必为非 NULL
     GlobalConfig globalConfig = this.properties.getGlobalConfig();
     // TODO 注入填充器
     this.getBeanThen(MetaObjectHandler.class, globalConfig::setMetaObjectHandler);
     // TODO 注入参与器
     this.getBeanThen(PostInitTableInfoHandler.class, globalConfig::setPostInitTableInfoHandler);
     // TODO 注入主键生成器
     this.getBeansThen(IKeyGenerator.class, i -> globalConfig.getDbConfig().setKeyGenerators(i));
     // TODO 注入sql注入器
     this.getBeanThen(ISqlInjector.class, globalConfig::setSqlInjector);
     // TODO 注入ID生成器
     this.getBeanThen(IdentifierGenerator.class, globalConfig::setIdentifierGenerator);
     // TODO 设置 GlobalConfig 到 MybatisSqlSessionFactoryBean
     factory.setGlobalConfig(globalConfig);
     return factory.getObject();
 }

1.该方法主要是创建了sqlSessionFactory，并且装备了核心的属性，比如SqlInjector等
2.最终调用MybatisSqlSessionFactoryBean#buildSqlSessionFactory对全局配置进行装配

2.5 MapperFactoryBean创建MappedStatment

从类的名称来看，MapperFactoryBean就是来创建Mapper的FactoryBean。而创建好的Mapper最终保存到了MybatisConfiguration.mappedStatements里面。

MapperFactoryBean实现了InitializingBean，当这个bean创建成功之后，会调用afterPropertiesSet，然后对mapperInterface进行解析

MybatisMapperAnnotationBuilder#parse

@Override
public void parse() {
    String resource = type.toString();
    if (!configuration.isResourceLoaded(resource)) {
        loadXmlResource();
        configuration.addLoadedResource(resource);
        String mapperName = type.getName();
        assistant.setCurrentNamespace(mapperName);
        parseCache();
        parseCacheRef();
        IgnoreStrategy ignoreStrategy = InterceptorIgnoreHelper.initSqlParserInfoCache(type);
        for (Method method : type.getMethods()) {
            if (!canHaveStatement(method)) {
                continue;
            }
            if (getAnnotationWrapper(method, false, Select.class, SelectProvider.class).isPresent()
                && method.getAnnotation(ResultMap.class) == null) {
                parseResultMap(method);
            }
            try {
                // TODO 加入 注解过滤缓存
                InterceptorIgnoreHelper.initSqlParserInfoCache(ignoreStrategy, mapperName, method);
                parseStatement(method);
            } catch (IncompleteElementException e) {
                // TODO 使用 MybatisMethodResolver 而不是 MethodResolver
                configuration.addIncompleteMethod(new MybatisMethodResolver(this, method));
            }
        }
        // TODO 注入 CURD 动态 SQL , 放在在最后, because 可能会有人会用注解重写sql
        try {
            // https://github.com/baomidou/mybatis-plus/issues/3038
            if (GlobalConfigUtils.isSupperMapperChildren(configuration, type)) {
                parserInjector();
            }
        } catch (IncompleteElementException e) {
            configuration.addIncompleteMethod(new InjectorResolver(this));
        }
    }
    parsePendingMethods();
}

首先加载UserMapper.xml，生成mappedStatement。
然后再获取UserMapper接口对应的所有方法，parserInjector()生成动态sql
该方法主要对注解和还有BaseMapper进行解析（mybatis-plus的extension模块）
BaseMapper的解析是通过sqlInjector完成的