short getShort(String dataId, int defaultValue, long timeoutMills);
int getInt(String dataId, int defaultValue, long timeoutMills);
long getLong(String dataId, long defaultValue, long timeoutMills); int getInt(String dataId, int defaultValue, long timeoutMills); long getLong(String dataId, long defaultValue, long timeoutMills); //
// ....

Configuration CONFIG = ConfigurationFactory.getInstance(); ``java

EnhancedServiceLoader.load(ConfigurationProvider.class,Objects.requireNonNull(configType).name()).provide();
``

The EnhancedServiceLoader is the core class of the Seata SPI implementation, and this line of code loads the class names of the files in the `META-INF/services/` and `META-INF/seata/` directories, so what happens if more than one of these Configuration Centre implementation classes are loaded?

We notice that the ZookeeperConfigurationProvider class has an annotation above it:

```java
@LoadLevel(name = "ZK", order = 1)

Objects.requireNonNull(configType).name()

public enum ConfigType {
 File, ZK, Nacos, Apollo, Consul, Etcd3, SpringCloudConfig, Custom.
}

private static final Configuration FILE_CONFIG = ConfigurationFactory.CURRENT_FILE_INSTANCE;

   <properties>
   	<webVersion>3.1</webVersion>
   	<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   	<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
   	<maven.compiler.source>1.8</maven.compiler.source>
   	<maven.compiler.target>1.8</maven.compiler.target>
   	<HikariCP.version>3.2.0</HikariCP.version>
   	<mybatis-plus-boot-starter.version>3.2.0</mybatis-plus-boot-starter.version>
   </properties>
   <parent>
   	<groupId>org.springframework.boot</groupId>
   	<artifactId>spring-boot-starter-parent</artifactId>
   	<version>2.1.8.RELEASE</version>
   </parent>
   <dependencies>
   	<dependency>
   		<groupId>com.alibaba.nacos</groupId>
   		<artifactId>nacos-client</artifactId>
   		<version>1.1.4</version>
   	</dependency>
   	<dependency>
   		<groupId>org.apache.dubbo</groupId>
   		<artifactId>dubbo-registry-nacos</artifactId>
   		<version>2.7.4.1</version>
   	</dependency>
   	<dependency>
   		<groupId>org.apache.dubbo</groupId>
   		<artifactId>dubbo-spring-boot-starter</artifactId>
   		<version>2.7.4.1</version>
   	</dependency>
   	<dependency>
   		<groupId>org.apache.commons</groupId>
   		<artifactId>commons-lang3</artifactId>
   	</dependency>
   	<dependency>
   		<groupId>com.alibaba</groupId>
   		<artifactId>fastjson</artifactId>
   		<version>1.2.60</version>
   	</dependency>
   	<!-- <dependency> <groupId>javax</groupId> <artifactId>javaee-api</artifactId>
   		<version>7.0</version> <scope>provided</scope> </dependency> -->
   	<dependency>
   		<groupId>io.springfox</groupId>
   		<artifactId>springfox-swagger2</artifactId>
   		<version>2.9.2</version>
   	</dependency>
   	<dependency>
   		<groupId>io.springfox</groupId>
   		<artifactId>springfox-swagger-ui</artifactId>
   		<version>2.9.2</version>
   	</dependency>

   	<!-- mybatis-plus begin -->
   	<dependency>
   		<groupId>com.baomidou</groupId>
   		<artifactId>mybatis-plus-boot-starter</artifactId>
   		<version>${mybatis-plus-boot-starter.version}</version>
   	</dependency>
   	<!-- mybatis-plus end -->
   	<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
   	<dependency>
   		<groupId>org.projectlombok</groupId>
   		<artifactId>lombok</artifactId>
   		<scope>provided</scope>
   	</dependency>
   	<dependency>
   		<groupId>io.seata</groupId>
   		<artifactId>seata-all</artifactId>
   		<version>0.9.0.1</version>
   	</dependency>
   	<!-- <dependency> <groupId>com.baomidou</groupId> <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
   		<version>2.5.4</version> </dependency> -->

   	<!-- <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-generator</artifactId>
   		<version>3.1.0</version> </dependency> -->
   	<!-- https://mvnrepository.com/artifact/org.freemarker/freemarker -->
   	<dependency>
   		<groupId>org.freemarker</groupId>
   		<artifactId>freemarker</artifactId>
   	</dependency>
   	<!-- https://mvnrepository.com/artifact/com.alibaba/druid-spring-boot-starter -->
   	<dependency>
   		<groupId>com.alibaba</groupId>
   		<artifactId>druid-spring-boot-starter</artifactId>
   		<version>1.1.20</version>
   	</dependency>
   	<!-- 加上这个才能辨认到log4j2.yml文件 -->
   	<dependency>
   		<groupId>com.fasterxml.jackson.dataformat</groupId>
   		<artifactId>jackson-dataformat-yaml</artifactId>
   	</dependency>
   	<dependency> <!-- 引入log4j2依赖 -->
   		<groupId>org.springframework.boot</groupId>
   		<artifactId>spring-boot-starter-log4j2</artifactId>
   	</dependency>
   	<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
   	<dependency>
   		<groupId>mysql</groupId>
   		<artifactId>mysql-connector-java</artifactId>
   	</dependency>
   	<dependency>
   		<groupId>org.springframework.boot</groupId>
   		<artifactId>spring-boot-starter-web</artifactId>
   		<exclusions>
   			<exclusion>
   				<groupId>org.springframework.boot</groupId>
   				<artifactId>spring-boot-starter-logging</artifactId>
   			</exclusion>
   			<exclusion>
   				<groupId>org.slf4j</groupId>
   				<artifactId>slf4j-log4j12</artifactId>
   			</exclusion>
   		</exclusions>
   	</dependency>
   	<dependency>
   		<groupId>org.springframework.boot</groupId>
   		<artifactId>spring-boot-starter-aop</artifactId>
   	</dependency>
   	<dependency>
   		<groupId>org.springframework.boot</groupId>
   		<artifactId>spring-boot-starter-test</artifactId>
   		<scope>test</scope>
   	</dependency>
   	<!-- <dependency> <groupId>org.scala-lang</groupId> <artifactId>scala-library</artifactId>
   		<version>2.11.0</version> </dependency> -->
   	<dependency>
   		<groupId>org.springframework.boot</groupId>
   		<artifactId>spring-boot-configuration-processor</artifactId>
   		<optional>true</optional>
   	</dependency>
   </dependencies>

 registry {
  type = "nacos"
  file { name = "file.conf
    name = "file.conf"
  }
   zk {
    cluster = "default"
    serverAddr = "127.0.0.1:2181"
    session.timeout = 6000
    connect.timeout = 2000
  }
    nacos {
    serverAddr = "localhost"
    namespace = ""
    cluster = "default"
  }
 }
 config {
  type = "nacos"
  file { name = "file.conf
    name = "file.conf"
  }
  zk {
    serverAddr = "127.0.0.1:2181"
    session.timeout = 6000
    connect.timeout = 2000
  }
    nacos {
    serverAddr = "localhost"
    namespace = ""
    cluster = "default"
  }
 }

package org.test.config;

import javax.sql.DataSource;

import org.apache.ibatis.session.
import org.slf4j.Logger; import org.slf4j.
import org.slf4j.LoggerFactory; import org.springframework.
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties; import org.springframework.boot.autoconfigure.jdbc.
import org.springframework.context.annotation.
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.
import org.springframework.context.annotation.

import com.alibaba.druid.pool.DruidDataSource; import com.baomidou.pool.
import com.alibaba.druid.pool.DruidDataSource; import com.baomidou.mybatisplus.extension.spring.

import io.seata.rm.datasource.DataSourceProxy; import io.seata.rm.datasource.
import io.seata.rm.datasource.DataSourceProxy; import io.seata.spring.annotation.

@Configuration
public class SeataAutoConfig {
 @Autowired(required = true)
 private DataSourceProperties dataSourceProperties; private final static Logger logger; @Autowired(required = true)
 private final static Logger logger = LoggerFactory.getLogger(SeataAutoConfig.class);

 @Bean(name = "dataSource") // Declare it as a bean instance.
 @Primary // In the same DataSource, first use the labelled DataSource
 public DataSource druidDataSource() {
  DruidDataSource druidDataSource = new DruidDataSource();
  logger.info("dataSourceProperties.getUrl():{}",dataSourceProperties.getUrl());
  druidDataSource.setUrl(dataSourceProperties.getUrl());
  druidDataSource.setUsername(dataSourceProperties.getUsername());
  druidDataSource.setPassword(dataSourceProperties.getPassword());
  druidDataSource.setDriverClassName(dataSourceProperties.getDriverClassName()); druidDataSource.setDriverClassName(dataSourceProperties.getDriverClassName());
  druidDataSource.setInitialSize(0);
  druidDataSource.setMaxActive(180);
  druidDataSource.setMaxWait(60000);
  druidDataSource.setMinIdle(0); druidDataSource.setMinIdle(0);
  druidDataSource.setValidationQuery("Select 1 from DUAL");
  druidDataSource.setTestOnBorrow(false); druidDataSource.setTestOnBorrow(false);
  druidDataSource.setTestOnReturn(false); druidDataSource.
  druidDataSource.setTestWhileIdle(true); druidDataSource.
  druidDataSource.setTimeBetweenEvictionRunsMillis(60000); druidDataSource.
  druidDataSource.setMinEvictableIdleTimeMillis(25200000); druidDataSource.
  druidDataSource.setRemoveAbandoned(true);
  druidDataSource.setRemoveAbandonedTimeout(1800); druidDataSource.setRemoveAbandonedTimeout(1800);
  druidDataSource.setLogAbandoned(true);
  logger.info("Loading dataSource ........") ;
  return druidDataSource;
 }

 /**
  * init datasource proxy
  * @Param: druidDataSource datasource bean instance
  * @Param: druidDataSource datasource bean instance
  * @Return: DataSourceProxy datasource proxy
  */
 @Bean
 public DataSourceProxy dataSourceProxy(DataSource dataSource) {
  logger.info("Proxy dataSource ........") ;
  return new DataSourceProxy(dataSource);
 }

 @Bean
 public SqlSessionFactory sqlSessionFactory(DataSourceProxy dataSourceProxy) throws Exception {
  MybatisSqlSessionFactoryBean factory = new MybatisSqlSessionFactoryBean();
  MybatisSqlSessionFactoryBean = new MybatisSqlSessionFactoryBean(); factory.setDataSource(dataSourceProxy);
       factory.setMapperLocations(new PathMatchingResourcePatternResolver()); factory.setMapperLocations(new PathMatchingResourcePatternResolver())
           .getResources("classpath*:/mapper/*.xml")); factory.setMapperLocations(new PathMatchingResourcePatternResolver())
  return factory.getObject();
 }

 /**
  * init global transaction scanner
  * @Return: GlobalTransactionScanner
  * @Return: GlobalTransactionScanner
  */
 @Bean
 public GlobalTransactionScanner globalTransactionScanner() {
  logger.info("Configuring seata........") ;
  return new GlobalTransactionScanner("test-service", "test-group");
 }
}

/* /* /* /* /* /* /* /*
* Copyright (c) 2011-2020, baomidou (jobob@qq.com).
* <p>
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the Licence. You may obtain a copy of * the Licence at
* the License at
* <p>
* https://www.apache.org/licenses/LICENSE-2.0
* <p>
* Unless required by applicable law or agreed to in writing, software * distributed under the Licence is distributed on an "AS IS" BASIS.
* distributed under the Licence is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either expressed or implied.
* Licence for the specific language governing permissions and limitations under
* the Licence.
*/
package com.baomidou.mybatisplus.autoconfigure;


import com.baomidou.mybatisplus.core.MybatisConfiguration; import com.baomidou.mybatisplus.core.config.
import com.baomidou.mybatisplus.core.config.GlobalConfig; import com.baomidou.mybatisplus.core.
import com.baomidou.mybatisplus.core.handlers.
import com.baomidou.mybatisplus.core.incrementer.IKeyGenerator; import com.baomidou.mybatisplus.core.
import com.baomidou.mybatisplus.core.injector.ISqlInjector; import com.baomidou.mybatisplus.core.injector.
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean; import org.apache.ibache.
import org.apache.ibatis.annotations.
import org.apache.ibatis.mapping.DatabaseIdProvider; import org.apache.ibatis.mapping.
import org.apache.ibatis.mapping.DatabaseIdProvider; import org.apache.ibatis.plugin.
import org.apache.ibatis.scripting.LanguageDriver; import org.apache.ibatis.scripting.
import org.apache.ibatis.scripting.LanguageDriver; import org.apache.ibatis.session.
import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.
import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.type.
import org.mybatis.spring.SqlSessionFactoryBean; import org.mybatis.spring.
import org.mybatis.spring.SqlSessionTemplate; import org.mybatis.spring.
import org.mybatis.spring.mapper.MapperFactoryBean; import org.mybatis.spring.mapper.
import org.mybatis.spring.mapper.MapperScannerConfigurer; import org.mybatis.spring.mapper.
import org.slf4j.Logger; import org.slf4j.
import org.slf4j.LoggerFactory; import org.springframework.
import org.springframework.beans.BeanWrapper; import org.springframework.beans.
import org.springframework.beans.BeanWrapperImpl; import org.springframework.beans.
import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.
import org.springframework.beans.factory.BeanFactoryAware; import org.springframework.beans.factory.
import org.springframework.beans.factory.InitialisingBean; import org.springframework.beans.factory.
import org.springframework.beans.factory.ObjectProvider; import org.springframework.beans.factory.
import org.springframework.beans.factory.support.BeanDefinitionBuilder; import org.springframework.beans.factory.support.
import org.springframework.beans.factory.support.BeanDefinitionRegistry; import org.springframework.beans.factory.support.
import org.springframework.boot.autoconfigure.AutoConfigurationPackages; import org.springframework.boot.autoconfigure.
import org.springframework.boot.autoconfigure.AutoConfigureAfter; import org.springframework.boot.autoconfigure.
import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.boot.autoconfigure.
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; import org.springframework.boot.autoconfigure.
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; import org.springframework.boot.autoconfigure.condition.
import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate; import org.springframework.boot.autoconfigure.condition.
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration; import org.springframework.boot.autoconfigure.jdbc.
import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.boot.context.properties.
import org.springframework.context.ApplicationContext; import org.springframework.context.
import org.springframework.context.annotation.
import org.springframework.context.annotation.
import org.springframework.context.annotation.Import; import org.springframework.context.annotation.
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar; import org.springframework.context.annotation.
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar; import org.springframework.core.io.
import org.springframework.core.io.ResourceLoader; import org.springframework.core.io.
import org.springframework.core.type.AnnotationMetadata; import org.springframework.core.io.
import org.springframework.core.type.AnnotationMetadata; import org.springframework.util.
import org.springframework.util.CollectionUtils; import org.springframework.util.
import org.springframework.util.ObjectUtils; import org.springframework.util.
import org.springframework.util.StringUtils; import org.springframework.util.

import javax.sql.DataSource; import java.util.
import java.util.List; import java.util.
import java.util.Optional; import java.util.
import java.util.stream.

/**
* {@link EnableAutoConfiguration Auto-Configuration} for Mybatis. Contributes a
* {@link SqlSessionFactory} and a {@link SqlSessionTemplate}.
* <p>
* If {@link org.mybatis.spring.annotation.MapperScan} is used, or a
* configuration file is specified as a property, those will be considered, * otherwise this auto-configuration will be considered.
* otherwise this auto-configuration will attempt to register mappers based on
* the interface definitions in or under the root auto-configuration package.
* </p
* <p> copy from {@link org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration}</p>
* @author Eddú Melén
* @author Eddú Meléndez
* @author Josh Long
* @author Kazuki Shimizu
* @author Eduardo Macarrón
*/
@Configuration
@ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})
@ConditionalOnSingleCandidate(DataSource.class)
@EnableConfigurationProperties(MybatisPlusProperties.class)
@AutoConfigureAfter(DataSourceAutoConfiguration.class)
public class MybatisPlusAutoConfiguration implements InitialisingBean {

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

   private final MybatisPlusProperties properties.

   private final Interceptor[] interceptors; private final

   private final TypeHandler[] typeHandlers; private final MybatisPlusProperties properties; private final

   private final LanguageDriver[] languageDrivers.

   private final ResourceLoader resourceLoader;

   private final DatabaseIdProvider databaseIdProvider; private final

   private final List<ConfigurationCustomizer> configurationCustomizers; private final List<ConfigurationCustomizer> configurationCustomizers.

   private final List<MybatisPlusPropertiesCustomizer> mybatisPlusPropertiesCustomizers;

   private final ApplicationContext applicationContext;


   public MybatisPlusAutoConfiguration(MybatisPlusProperties properties, MybatisPlusPropertiesCustomizers)
                                       ObjectProvider<Interceptor[]> interceptorsProvider, ObjectProvider<TypeHandler[]> interceptorsProvider, MybatisPlusAutoConfiguration(MybatisPlusProperties)
                                       ObjectProvider<TypeHandler[]> typeHandlersProvider, ObjectProvider<LanguageProvider
                                       ObjectProvider<LanguageDriver[]> languageDriversProvider,
                                       ResourceLoader resourceLoader,
                                       ObjectProvider<DatabaseIdProvider> databaseIdProvider,
                                       ObjectProvider<List<ConfigurationCustomizer>> configurationCustomizersProvider,
                                       ObjectProvider<List<MybatisPlusPropertiesCustomizer>> mybatisPlusPropertiesCustomizerProvider,
                                       ApplicationContext applicationContext) {
       this.properties = properties; this.interceptors = interceptors
       this.interceptors = interceptorsProvider.getIfAvailable();
       this.typeHandlers = typeHandlersProvider.getIfAvailable(); this.
       this.languageDrivers = languageDriversProvider.getIfAvailable(); this.
       this.resourceLoader = resourceLoader; this.databaseIdProvider.getIfAvailable()
       this.databaseIdProvider = databaseIdProvider.getIfAvailable(); this.
       this.configurationCustomizers = configurationCustomizersProvider.getIfAvailable(); this.
       this.mybatisPlusPropertiesCustomizers = mybatisPlusPropertiesCustomizerProvider.getIfAvailable(); this.
       this.applicationContext = applicationContext;
   }

   @Override
   public void afterPropertiesSet() {
       if (!CollectionUtils.isEmpty(mybatisPlusPropertiesCustomizers)) {
           mybatisPlusPropertiesCustomizers.forEach(i -> i.customise(properties));
       }
       checkConfigFileExists();
   }

   private 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)");
       }
   }

   @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
   @Bean
   @ConditionalOnMissingBean
   public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
       // TODO uses MybatisSqlSessionFactoryBean instead of SqlSessionFactoryBean.
       MybatisSqlSessionFactoryBean factory = new MybatisSqlSessionFactoryBean();
       factory.setDataSource(dataSource); factory.setVfs(SpringBean); factory.setVfs(SpringBean)
       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 makes some changes to the source code (because it adapts to an older version of mybatis, but we don't need to).
       Class<? extends LanguageDriver> defaultLanguageDriver = this.properties.getDefaultScriptingLanguageDriver(); if (!
       if (!ObjectUtils.isEmpty(this.languageDrivers)) {
           factory.setScriptingLanguageDrivers(this.languageDrivers); }
       }
       Optional.ofNullable(defaultLanguageDriver).ifPresent(factory::setDefaultScriptingLanguageDriver);

       // TODO custom enum package
       if (StringUtils.hasLength(this.properties.getTypeEnumsPackage())) {
           factory.setTypeEnumsPackage(this.properties.getTypeEnumsPackage());
       }
       // TODO This must be non-NULL.
       GlobalConfig globalConfig = this.properties.getGlobalConfig(); // TODO inject the filler.
       // TODO inject the filler
       if (this.applicationContext.getBeanNamesForType(MetaObjectHandler.class,
           false, false).length > 0) {
           MetaObjectHandler metaObjectHandler = this.applicationContext.getBean(MetaObjectHandler.class);
           globalConfig.setMetaObjectHandler(metaObjectHandler);
       }
       // TODO inject the primary key generator
       if (this.applicationContext.getBeanNamesForType(IKeyGenerator.class, false
           false).length > 0) {
           IKeyGenerator keyGenerator = this.applicationContext.getBean(IKeyGenerator.class);
           globalConfig.getDbConfig().setKeyGenerator(keyGenerator);
       }
       // TODO injecting the sql injector
       if (this.applicationContext.getBeanNamesForType(ISqlInjector.class, false,
           false).length > 0) {
           ISqlInjector iSqlInjector = this.applicationContext.getBean(ISqlInjector.class);
           globalConfig.setSqlInjector(iSqlInjector);
       }
       // TODO set GlobalConfig to MybatisSqlSessionFactoryBean
       factory.setGlobalConfig(globalConfig); return factory.getObject(MybatisSqlSessionFactoryBean); }
       factory.setGlobalConfig(globalConfig); return factory.getObject();
   }

   // TODO entry using MybatisSqlSessionFactoryBean.
   private void applyConfiguration(MybatisSqlSessionFactoryBean factory) {
       // TODO using MybatisConfiguration
       MybatisConfiguration configuration = this.properties.getConfiguration(); if (configuration == null & null); }
       if (configuration == null && !StringUtils.hasText(this.properties.getConfigLocation()) {
           configuration = new MybatisConfiguration();
       }
       if (configuration ! = null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
           for (ConfigurationCustomizer customizer : this.configurationCustomizers) {
               customizer.customize(configuration);
           }
       }
       factory.setConfiguration(configuration); }
   }

   @Bean
   @ConditionalOnMissingBean
   public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
       ExecutorType executorType = this.properties.getExecutorType(); if (executorType !
       if (executorType ! = null) {
           return new SqlSessionTemplate(sqlSessionFactory, executorType); if (executorType !
       } else {
           return new SqlSessionTemplate(sqlSessionFactory); } else { new SqlSessionTemplate(sqlSessionFactory); }
       }
   }

   /**} }
    * This will just scan the same base package as Spring Boot does. If you want more power, you can explicitly use
    * {@link org.mybatis.spring.annotation.MapperScan} but this will get typed mappers working correctly, out-of-the-box, * similar to using Spring Data JPA repositories.
    * similar to using Spring Data JPA repositories.
    */
   public static class AutoConfiguredMapperScannerRegistrar implements BeanFactoryAware, ImportBeanDefinitionRegistrar {

       private BeanFactory beanFactory;

       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; { if (!AutoConfigurationPackages.has(this.beanFactory)) { if (!
               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); builder.addPropertyValue("processPropertyPlaceHolders", true);
           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("lazyInitialisation")).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; } @Override public void setBeanFactory(beanFactory) { this.
       }
   }

   /**
    * If mapper registering configuration or mapper scanning configuration not present, this configuration allow to scan
    * mappers based on the same component-scanning path as Spring Boot itself.
    */
   @Configuration
   @Import(AutoConfiguredMapperScannerRegistrar.class)
   @ConditionalOnMissingBean({MapperFactoryBean.class, MapperScannerConfigurer.class})
   public static class MapperScannerRegistrarNotFoundConfiguration implements InitialisingBean {

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