源码梳理（3）MybatisPlus启动流程

源码版本springboot3.0.2，mybatis-plus-spring-boot3-starter3.5.5，mybatis3.5.15

1，MybatisPlus的使用示例

开始前先简单定义一个mybatisPlus的简单使用示例，为后面的分析准备
要操作表的实体类

@TableName(value = "json_type", autoResultMap = true)
@Data
@Accessors(chain = true)
public class JsonType {@TableId(type = IdType.AUTO)private Integer id;
}

mapper接口

@Mapper
public interface JsonTypeMapper extends BaseMapper<JsonType> {}

service接口

public interface JsonTypeService {List<JsonType> findAll();JsonType findOne(JsonType jsonType);
}

service实现类

@Service
public class JsonTypeServiceImpl extends ServiceImpl<JsonTypeMapper, JsonType> implements JsonTypeService {public List<JsonType> findAll() {return baseMapper.selectList(Wrappers.lambdaQuery(JsonType.class));}@Overridepublic JsonType findOne(JsonType jsonType) {LambdaQueryWrapper<JsonType> wrapper = Wrappers.lambdaQuery(JsonType.class).eq(jsonType.getId() != null, JsonType::getId, jsonType.getId()).eq(jsonType.getName() != null && !"".equals(jsonType.getName()), JsonType::getName, jsonType.getName());return this.baseMapper.selectOne(wrapper);}}

2，BaseMapper方法的执行

2,1 MybatisMapperProxy代理对象

当程序启动后，在执行service方法的时候，容器中继承BaseMapper的JsonTypeMapper 实例是MybatisMapperProxy类型的代理对象

MybatisMapperProxy实现了InvocationHandler接口

2.2 InvocationHandler接口（JDK动态代理）

InvocationHandler 它是实现JDK动态代理的关键部分之一。它包含一个方法 invoke()，用于处理在代理对象上调用方法时的行为。

public interface InvocationHandler {public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

MybatisMapperProxy在实现InvocationHandler接口后重写了invoke方法，前面的baseMapper.selectList(Wrappers.lambdaQuery(JsonType.class))就会通过invoke方法来处理

	// MybatisMapperProxy.class@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {try {if (Object.class.equals(method.getDeclaringClass())) {return method.invoke(this, args);} else {// 先执行cachedInvoker方法获取到MapperMethodInvoker实例// 核心环节：再执行MapperMethodInvoker实例的invoke方法return cachedInvoker(method).invoke(proxy, method, args, sqlSession);}} catch (Throwable t) {throw ExceptionUtil.unwrapThrowable(t);}}

2.3 MapperMethodInvoker接口

MybatisMapperProxy的invoke方法中会先执行cachedInvoker方法获取到MapperMethodInvoker实例

    private MapperMethodInvoker cachedInvoker(Method method) throws Throwable {try {return CollectionUtils.computeIfAbsent(methodCache, method, m -> {// 判断是否是接口的default方法if (m.isDefault()) {try {if (privateLookupInMethod == null) {return new DefaultMethodInvoker(getMethodHandleJava8(method));} else {return new DefaultMethodInvoker(getMethodHandleJava9(method));}} catch (IllegalAccessException | InstantiationException | InvocationTargetException| NoSuchMethodException e) {throw new RuntimeException(e);}} else {return new PlainMethodInvoker(new MybatisMapperMethod(mapperInterface, method, sqlSession.getConfiguration()));}});}}

在MybatisMapperProxy调用cachedInvoker方法的时候，会先获取到一个MapperMethodInvoker实例，MapperMethodInvoker接口有两种实现类型，一种是PlainMethodInvoker（用于Mybatis默认方法的调用实现），另一种是DefaultMethodInvoker（用于处理有默认实现的接口方法）

public interface BaseMapper<T> extends Mapper<T> {default T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper, boolean throwEx) {List<T> list = this.selectList(queryWrapper);int size = list.size();if (size == 1) {return list.get(0);} else if (size > 1) {if (throwEx) {throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + size);}return list.get(0);}return null;}List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
}

例如上面BaseMapper接口中的selectList方法是没有默认实现的，而selectOne方法提供了默认实现。那selectList到底是怎么从数据库查到数据的呢，接下来就要看获取到的MapperMethodInvoker（也就是PlainMethodInvoker ）实例的invoke方法都做了些什么

    private static class PlainMethodInvoker implements MapperMethodInvoker {private final MybatisMapperMethod mapperMethod;public PlainMethodInvoker(MybatisMapperMethod mapperMethod) {super();this.mapperMethod = mapperMethod;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable {// 核心方法，执行MybatisMapperMethod的execute方法return mapperMethod.execute(sqlSession, args);}}

2.4 MybatisMapperMethod

在PlainMethodInvoker的invoke方法中，直接返回了MybatisMapperMethod实例执行execute方法的结果。
类中的两个属性：
MapperMethod.SqlCommand 用于表示 Mapper 方法对应的 SQL 语句信息。它包含了 SQL 语句的类型，ID（statement ID）、SQL 语句的字符串以及参数映射信息等。
MapperMethod.MethodSignature 用于表示 Mapper 方法的签名信息。它包含了方法的返回类型、参数类型以及其他相关信息。
在execute方法中经过一些判断，参数的转化之后，会将本次查询的操作交给SqlSession处理，也是MybatisMapperProxy中的SqlSession（这个SqlSession怎么来的后面会分析）

/*** 从  {@link MapperMethod} copy 过来 </br>* <p> 不要内部类 ParamMap </p>* <p> 不要内部类 SqlCommand </p>* <p> 不要内部类 MethodSignature </p>** @author miemie* @since 2018-06-09*/
public class MybatisMapperMethod {private final MapperMethod.SqlCommand command;private final MapperMethod.MethodSignature method;public MybatisMapperMethod(Class<?> mapperInterface, Method method, Configuration config) {this.command = new MapperMethod.SqlCommand(config, mapperInterface, method);this.method = new MapperMethod.MethodSignature(config, mapperInterface, method);}public Object execute(SqlSession sqlSession, Object[] args) {Object result;switch (command.getType()) {case INSERT: {// 省略...}case UPDATE: {// 省略...}case DELETE: {// 省略...}case SELECT:if (method.returnsVoid() && method.hasResultHandler()) {// 省略...} else if (method.returnsMany()) {// 我们前面调用的方法会继续执行到这里result = executeForMany(sqlSession, args);} else {// 省略...}break;case FLUSH:result = sqlSession.flushStatements();break;default:throw new BindingException("Unknown execution method for: " + command.getName());}// 省略...return result;}// 省略...private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {List<E> result;// 将 Args 转换为 Sql 命令参数Object param = method.convertArgsToSqlCommandParam(args);if (method.hasRowBounds()) {RowBounds rowBounds = method.extractRowBounds(args);result = sqlSession.selectList(command.getName(), param, rowBounds);} else {// 核心环节，执行sqlSession的selectList的方法result = sqlSession.selectList(command.getName(), param);}// issue #510 Collections & arrays support// 判断method.getReturnType()的类型是否可以被result.getClass()的类型赋值if (!method.getReturnType().isAssignableFrom(result.getClass())) {if (method.getReturnType().isArray()) {return convertToArray(result);} else {return convertToDeclaredCollection(sqlSession.getConfiguration(), result);}}return result;}// 省略...}

3，SqlSession的执行流程

SqlSession用于 MyBatis 的主要 Java 接口。通过此界面，您可以执行命令、获取映射器和管理事务

SqlSession有三个实现类，这里执行selectList的对象是从MybatisMapperProxy传递过来SqlSessionTemplate实例。

3.1 SqlSessionTemplate

SqlSessionTemplate用于提供对 Mapper 方法的调用和 SQL 语句的执行。
在SqlSessionTemplate的构造器中通过Proxy类的.new ProwyInstance方法又创建了一个SqlSession的代理对象，并赋值给属性sqlSessionProxy

  public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,PersistenceExceptionTranslator exceptionTranslator) {notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");notNull(executorType, "Property 'executorType' is required");this.sqlSessionFactory = sqlSessionFactory;this.executorType = executorType;this.exceptionTranslator = exceptionTranslator;this.sqlSessionProxy = (SqlSession) newProxyInstance(SqlSessionFactory.class.getClassLoader(),new Class[] { SqlSession.class }, new SqlSessionInterceptor());}

3.2 Proxy类中的newProxyInstance（JDK动态代理）

这个方法接收三个参数：
loader: 用于加载代理类的类加载器。
interfaces: 代理类需要实现的接口列表。
h: 代理类的调用处理程序，也就是拦截器。
当调用 newProxyInstance 方法时，它会返回一个代理对象，该对象实现了指定的接口列表，在调用代理对象的方法时，实际上会触发调用拦截器的 invoke 方法。

    @CallerSensitivepublic static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) {Objects.requireNonNull(h);@SuppressWarnings("removal")final Class<?> caller = System.getSecurityManager() == null ? null : Reflection.getCallerClass();/** Look up or generate the designated proxy class and its constructor.*/Constructor<?> cons = getProxyConstructor(caller, loader, interfaces);return newProxyInstance(caller, cons, h);}

    this.sqlSessionProxy = (SqlSession) newProxyInstance(SqlSessionFactory.class.getClassLoader(),new Class[] { SqlSession.class }, new SqlSessionInterceptor());

3.3 SqlSession的创建，执行，关闭

所以SqlSessionTemplate中的属性sqlSessionProxy 代理对象，它的加载器使用SqlSessionFactory的类加载器，并且需要实现SqlSession接口的方法，在对象方法被调用时，通过SqlSessionInterceptor的invoke方法处理
SqlSessionInterceptor的invoke方法处理了SqlSession的创建，执行，关闭

  private class SqlSessionInterceptor implements InvocationHandler {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 获取SqlSession对象SqlSession sqlSession = getSqlSession(SqlSessionTemplate.this.sqlSessionFactory,SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);try {// 通过反射执行sqlSession的方法获取结果Object result = method.invoke(sqlSession, args);// 判断会话是不是开启事务的if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {// 如果没有开启事务则强制提交// force commit even on non-dirty sessions because some databases require// a commit/rollback before calling close()sqlSession.commit(true);}return result;} catch (Throwable t) {Throwable unwrapped = unwrapThrowable(t);// 判断是否设置了异常转换器(exceptionTranslator)且捕获到的异常是PersistenceException类型if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {// release the connection to avoid a deadlock if the translator is no loaded. See issue #22closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);sqlSession = null;// 转化异常后再尝试赋值给unwrappedThrowable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException) unwrapped);if (translated != null) {unwrapped = translated;}}throw unwrapped;} finally {if (sqlSession != null) {// 关闭sqlSessioncloseSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);}}}}

3.4 DefaultSqlSession的创建

这里又通过getSqlSession获取到了一个SqlSession实例，也是真正来执行接口方法（本次示例中是SqlSession的selectList方法）的是实例，先去getSqlSession方法里看看这次获取到的sqlSession又是什么类型，传入的三个参数sqlSessionFactory，executorType，exceptionTranslator都是在构建SqlSessionTemplate时赋值的，后面会分析到的。
Mybatis在同一个同一个事务中，只有存在一个sqlSession，所以这里通过sessionHolder尝试获取当前事务的sqlSession，如果没有获取到，则通过sessionFactory的openSession开启一个sqlSession

  public static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType,PersistenceExceptionTranslator exceptionTranslator) {notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);notNull(executorType, NO_EXECUTOR_TYPE_SPECIFIED);// 从事务同步管理器中获取一个 SqlSessionHolder 对象。SqlSessionHolder是一个包含SqlSession 实例的持有者对象，可能在事务刚开始时就已经存放在事务上下文中SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);// 从 SqlSessionHolder 对象中取出 SqlSession 实例。如果能够取到 SqlSession 实例，则直接返回SqlSession session = sessionHolder(executorType, holder);if (session != null) {return session;}LOGGER.debug(() -> "Creating a new SqlSession");// 开启一个sql会话session = sessionFactory.openSession(executorType);// 调用 registerSessionHolder() 方法将新创建的 SqlSession 实例和其他相关信息注册到事务同步管理器中。这样，在同一个事务中的其他操作就可以通过事务上下文获取到这个 SqlSession 实例。registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);return session;}

DefaultSqlSessionFactory的openSession获取到DefaultSqlSession

public class DefaultSqlSessionFactory implements SqlSessionFactory {private final Configuration configuration;public DefaultSqlSessionFactory(Configuration configuration) {this.configuration = configuration;}// 省略...@Overridepublic SqlSession openSession(TransactionIsolationLevel level) {return openSessionFromDataSource(configuration.getDefaultExecutorType(), level, false);}// 省略...private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level,boolean autoCommit) {Transaction tx = null;try {final Environment environment = configuration.getEnvironment();final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);// 通过mybatis的配置类创建一个执行器（默认是开启缓存的，所以是CachingExecutor）final Executor executor = configuration.newExecutor(tx, execType);// 将mybatis的配置，执行器，是否提交作为参数创建一个DefaultSqlSessionreturn new DefaultSqlSession(configuration, executor, autoCommit);} catch (Exception e) {closeTransaction(tx); // may have fetched a connection so lets call close()throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);} finally {ErrorContext.instance().reset();}}// 省略...
}

3.5 DefaultSqlSession的方法执行

DefaultSqlSession 是 MyBatis 框架中的一个核心类，实现了 SqlSession 接口。它用于执行 SQL 语句并与持久层交互，提供了对数据库的增删改查操作.。
在前面SqlSessionInterceptor的invoke方法里，也将具体的执行SQL语句交给了前面创建的defalutSqlSession

    public class DefaultSqlSession implements SqlSession {@Overridepublic <E> List<E> selectList(String statement, Object parameter) {return this.selectList(statement, parameter, RowBounds.DEFAULT);}@Overridepublic <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {return selectList(statement, parameter, rowBounds, Executor.NO_RESULT_HANDLER);}private <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {try {MappedStatement ms = configuration.getMappedStatement(statement);dirty |= ms.isDirtySelect();return executor.query(ms, wrapCollection(parameter), rowBounds, handler);} catch (Exception e) {throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);} finally {ErrorContext.instance().reset();}}}

具体的执行逻辑会交给executor，在CachingExecutor的query方法执行过程中，先尝试从mybatis的一级缓存中获取数据，如果没有获取到，再进行数据库查询，拿到结果

public class CachingExecutor implements Executor {private final Executor delegate;private final TransactionalCacheManager tcm = new TransactionalCacheManager();// 省略...@Overridepublic <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler)throws SQLException {BoundSql boundSql = ms.getBoundSql(parameterObject);CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);}@Overridepublic <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler,CacheKey key, BoundSql boundSql) throws SQLException {Cache cache = ms.getCache();if (cache != null) {flushCacheIfRequired(ms);if (ms.isUseCache() && resultHandler == null) {ensureNoOutParams(ms, boundSql);@SuppressWarnings("unchecked")List<E> list = (List<E>) tcm.getObject(cache, key);if (list == null) {list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);tcm.putObject(cache, key, list); // issue #578 and #116}return list;}}return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);}}

最后执行SqlSessionInterceptor 拦截器invoke 方法中的closeSqlSession方法，如果不存在事务则会直接关闭会话，如果存在事务不会立马关闭。
在事务结束后，在Mybatis提供SqlSessionSynchronization类的afterCompletion方法中，会关闭sqlSession。
SqlSessionSynchronization实现了TransactionSynchronization事务同步接口，重写了事务的回调方法。

  private class SqlSessionInterceptor implements InvocationHandler {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {SqlSession sqlSession = getSqlSession(SqlSessionTemplate.this.sqlSessionFactory,SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);try {Object result = method.invoke(sqlSession, args);// 省略...} finally {if (sqlSession != null) {closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);}}}}

  private static final class SqlSessionSynchronization implements TransactionSynchronization {private final SqlSessionHolder holder;private final SqlSessionFactory sessionFactory;private boolean holderActive = true;// 省略.../*** {@inheritDoc}*/@Overridepublic void afterCompletion(int status) {if (this.holderActive) {// afterCompletion may have been called from a different thread// so avoid failing if there is nothing in this oneLOGGER.debug(() -> "Transaction synchronization deregistering SqlSession [" + this.holder.getSqlSession() + "]");TransactionSynchronizationManager.unbindResourceIfPossible(sessionFactory);this.holderActive = false;LOGGER.debug(() -> "Transaction synchronization closing SqlSession [" + this.holder.getSqlSession() + "]");this.holder.getSqlSession().close();}this.holder.reset();}}

4，MybatisPlusAutoConfiguration自动装配

前面在执行我们定义的mapper方法时，涉及到了MybatisMapperProxy，SqlSession等一系列组件。
比如在使用MybatisPlus的时候我们都会定义一些添加Mapper注解的接口（如下面的代码示例），这些接口我们不会自己去实现，它们都将在应用启动后被注册为MybatisMapperProxy代理对象并存放在容器中。当这些实例是怎么创建的呢，现在我们去MybatisPlusAutoConfiguration类里看看

@Mapper
public interface JsonTypeMapper extends BaseMapper<JsonType> {}

4.1 SqlSessionFactory 对象的创建

    @Bean@ConditionalOnMissingBeanpublic SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {// 省略...}

4.2 SqlSessionTemplate对象的创建

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

4.3 MapperScannerConfigurer

在MybatisPlusAutoConfiguration类中配置了这样一个类，它表示如果不存在MapperFactoryBean或者MapperScannerConfigurer对象，我就要把AutoConfiguredMapperScannerRegistrar导入到容器里了，并且在属性注入之后打个debug日志

    @org.springframework.context.annotation.Configuration(proxyBeanMethods = false)@Import(AutoConfiguredMapperScannerRegistrar.class)@ConditionalOnMissingBean({MapperFactoryBean.class, MapperScannerConfigurer.class})public static class MapperScannerRegistrarNotFoundConfiguration implements InitializingBean {@Overridepublic void afterPropertiesSet() {logger.debug("Not found configuration for registering mapper bean using @MapperScan, MapperFactoryBean and MapperScannerConfigurer.");}}

要被导入的AutoConfiguredMapperScannerRegistrar是MybatisPlusAutoConfiguration的内部类，它实现了ImportBeanDefinitionRegistrar接口，并且重写了registerBeanDefinitions方法。
这里要先说一下registerBeanDefinitions方法会在Spring容器初始化的早期执行，用于注册BeanDefinition，而在这个我们AutoConfiguredMapperScannerRegistrar的registerBeanDefinitions方法中，它注册了一个类型为MapperScannerConfigurer的BeanDefinition

    public static class AutoConfiguredMapperScannerRegistrarimplements BeanFactoryAware, EnvironmentAware, ImportBeanDefinitionRegistrar {private BeanFactory beanFactory;private Environment environment;@Overridepublic 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);// 这些addPropertyValue方法都是给要注册的BeanDefinition的属性赋值，瞧，这里给annotationClass属性赋了Mapper.classbuilder.addPropertyValue("annotationClass", Mapper.class);builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(packages));BeanWrapper beanWrapper = new BeanWrapperImpl(MapperScannerConfigurer.class);Set<String> propertyNames = Stream.of(beanWrapper.getPropertyDescriptors()).map(PropertyDescriptor::getName).collect(Collectors.toSet());if (propertyNames.contains("lazyInitialization")) {// Need to mybatis-spring 2.0.2+builder.addPropertyValue("lazyInitialization", "${mybatis-plus.lazy-initialization:${mybatis.lazy-initialization:false}}");}if (propertyNames.contains("defaultScope")) {// Need to mybatis-spring 2.0.6+builder.addPropertyValue("defaultScope", "${mybatis-plus.mapper-default-scope:}");}// for spring-nativeBoolean injectSqlSession = environment.getProperty("mybatis-plus.inject-sql-session-on-mapper-scan", Boolean.class);if (injectSqlSession == null) {injectSqlSession = environment.getProperty("mybatis.inject-sql-session-on-mapper-scan", Boolean.class, Boolean.TRUE);}if (injectSqlSession && this.beanFactory instanceof ListableBeanFactory) {ListableBeanFactory listableBeanFactory = (ListableBeanFactory) this.beanFactory;Optional<String> sqlSessionTemplateBeanName = Optional.ofNullable(getBeanNameForType(SqlSessionTemplate.class, listableBeanFactory));Optional<String> sqlSessionFactoryBeanName = Optional.ofNullable(getBeanNameForType(SqlSessionFactory.class, listableBeanFactory));if (sqlSessionTemplateBeanName.isPresent() || !sqlSessionFactoryBeanName.isPresent()) {builder.addPropertyValue("sqlSessionTemplateBeanName",sqlSessionTemplateBeanName.orElse("sqlSessionTemplate"));} else {builder.addPropertyValue("sqlSessionFactoryBeanName", sqlSessionFactoryBeanName.get());}}builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);registry.registerBeanDefinition(MapperScannerConfigurer.class.getName(), builder.getBeanDefinition());}@Overridepublic void setBeanFactory(BeanFactory beanFactory) {this.beanFactory = beanFactory;}@Overridepublic void setEnvironment(Environment environment) {this.environment = environment;}private String getBeanNameForType(Class<?> type, ListableBeanFactory factory) {String[] beanNames = factory.getBeanNamesForType(type);return beanNames.length > 0 ? beanNames[0] : null;}}

这里的MapperScannerConfigurer实现了BeanDefinitionRegistryPostProcessor接口重写了postProcessBeanDefinitionRegistry方法，postProcessBeanDefinitionRegistry方法也是在BeanDefinition注册到容器之前调用的，这里在postProcessBeanDefinitionRegistry方法中创建了一个ClassPathMapperScanner扫描器，这类又继承了ClassPathBeanDefinitionScanner 用于用于扫描指定路径下的类，并将其转化为BeanDefinition。
ClassPathMapperScanner对象会在执行扫描前设置annotationClass的值为Mapper.class用于对扫描结果过滤，如果在@MapperScan注解中配置扫描路径，则会扫描该路径，否则扫描springboot默认的包扫描路径。
在执行完doScan方法之后，那些带Mapper接口就已经注册为BeanDefinition了

public class MapperScannerConfigurerimplements BeanDefinitionRegistryPostProcessor, InitializingBean, ApplicationContextAware, BeanNameAware {private Class<? extends MapperFactoryBean> mapperFactoryBeanClass;// 省略...@Overridepublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {if (this.processPropertyPlaceHolders) {processPropertyPlaceHolders();}ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);scanner.setAddToConfig(this.addToConfig);scanner.setAnnotationClass(this.annotationClass);scanner.setMarkerInterface(this.markerInterface);scanner.setSqlSessionFactory(this.sqlSessionFactory);scanner.setSqlSessionTemplate(this.sqlSessionTemplate);scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);scanner.setResourceLoader(this.applicationContext);scanner.setBeanNameGenerator(this.nameGenerator);// scanner.setMapperFactoryBeanClass(this.mapperFactoryBeanClass);if (StringUtils.hasText(lazyInitialization)) {scanner.setLazyInitialization(Boolean.valueOf(lazyInitialization));}if (StringUtils.hasText(defaultScope)) {scanner.setDefaultScope(defaultScope);}scanner.registerFilters();scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));}}

在ClassPathMapperScanner里有一个setMapperFactoryBeanClass的set方法，确保mapperFactoryBeanClass的属性为MapperFactoryBean

public class ClassPathMapperScanner extends ClassPathBeanDefinitionScanner {public void setMapperFactoryBeanClass(Class<? extends MapperFactoryBean> mapperFactoryBeanClass) {this.mapperFactoryBeanClass = mapperFactoryBeanClass == null ? MapperFactoryBean.class : mapperFactoryBeanClass;}
}

MapperFactoryBean是一个FactoryBean并且继承了SqlSessionDaoSupport ，这个类的作用是通过getObject创建代理对象，
MybatisMapperProxy

public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {private Class<T> mapperInterface;// 省略...@Overridepublic T getObject() throws Exception {return getSqlSession().getMapper(this.mapperInterface);}@Overridepublic Class<T> getObjectType() {return this.mapperInterface;}// 省略...
}