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

文章目录

- - - - 1，MybatisPlus的使用示例
      - 2，BaseMapper方法的执行
      - 2,1 MybatisMapperProxy代理对象
        2.2 InvocationHandler接口（JDK动态代理）
        2.3 MapperMethodInvoker接口
        2.4 MybatisMapperMethod
      - 3，SqlSession的执行流程
      - 3.1 SqlSessionTemplate
        3.2 Proxy类中的newProxyInstance（JDK动态代理）
        3.3 SqlSession的创建，执行，关闭
        3.4 DefaultSqlSession的创建
        3.5 DefaultSqlSession的方法执行
    - 4，MybatisPlusAutoConfiguration自动装配
    - - 4.1 SqlSessionFactory 对象的创建
      - 4.2 SqlSessionTemplate对象的创建
      - 4.3 MapperScannerConfigurer

源码版本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));
    }

    @Override
    public 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
    @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 {
         		// 先执行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;
        }

        @Override
        public 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 方法。

    @CallerSensitive
    public 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 {
    @Override
    public 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 #22
          closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
          sqlSession = null;
          // 转化异常后再尝试赋值给unwrapped
          Throwable translated = SqlSessionTemplate.this.exceptionTranslator
              .translateExceptionIfPossible((PersistenceException) unwrapped);
          if (translated != null) {
            unwrapped = translated;
          }
        }
        throw unwrapped;
      } finally {
        if (sqlSession != null) {
          // 关闭sqlSession
          closeSqlSession(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;
    }
    // 省略...
    @Override
    public 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的配置，执行器，是否提交作为参数创建一个DefaultSqlSession
        return 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 {
	  @Override
      public <E> List<E> selectList(String statement, Object parameter) {
          return this.selectList(statement, parameter, RowBounds.DEFAULT);
      }
      
      @Override
      public <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();
  // 省略...

  @Override
  public <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);
  }

  @Override
  public <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 {
    @Override
    public 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}
     */
    @Override
    public 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 one
        LOGGER
            .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
    @ConditionalOnMissingBean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
       // 省略...
    }

4.2 SqlSessionTemplate对象的创建

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

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 {

        @Override
        public 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 AutoConfiguredMapperScannerRegistrar
        implements BeanFactoryAware, EnvironmentAware, ImportBeanDefinitionRegistrar {

        private BeanFactory beanFactory;
        private Environment environment;

        @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);
            // 这些addPropertyValue方法都是给要注册的BeanDefinition的属性赋值，瞧，这里给annotationClass属性赋了Mapper.class
            builder.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-native
            Boolean 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());
        }

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

        @Override
        public 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 MapperScannerConfigurer
    implements BeanDefinitionRegistryPostProcessor, InitializingBean, ApplicationContextAware, BeanNameAware {
    
  private Class<? extends MapperFactoryBean> mapperFactoryBeanClass;
  // 省略...
  @Override
  public 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;
  // 省略...
  @Override
  public T getObject() throws Exception {
    return getSqlSession().getMapper(this.mapperInterface);
  }

  @Override
  public Class<T> getObjectType() {
    return this.mapperInterface;
  }
  // 省略...
}