springboot整合mybatis原理分析

清疚 2022-08-31 09:57 238阅读 0赞

> 原创不易，转载请注明出处

### 文章目录 ###

*   *   *  前言
         *  1.SqlSessionFactory创建分析
         *  2.SqlSessionTemplate创建分析
         *  3.mapper接口扫描分析
         *  总结

--------------------

### 前言 ###

我们在《[mybatis执行原理精讲][mybatis]》一文中，介绍到springboot整合mybatis启动流程，初始化过程，基本就是干了三件事，一是创建SqlSessionFactory，创建SqlSessionFactory的过程中解析配置文件，mapper xml文件到congfiguration中，二是创建一个SqlSessionTemplate 对象，三是扫描@Mapper注解标注的mapper接口，为其生成代理类。本文主要是分析下mybatis-spring-boot-starter 项目关于springboot整合mybatis源码，看看是怎样实现的。

### 1.SqlSessionFactory创建分析 ###

我这边用的mybatis-spring-boot-starter 是2.1.4版本，springboot整合xxx框架，其实就是用的自动装配那套东西，我们直接去mybatis-spring-boot-starter 项目找下xxxAutoConfiguration类就可以了  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1YW5zaGFuZ3NoZW5naHVv_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1YW5zaGFuZ3NoZW5naHVv_size_16_color_FFFFFF_t_70 1]  
可以看到有两个自动装配的类，我们这里只需要关心MybatisAutoConfiguration 这个自动装配类就可以  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1YW5zaGFuZ3NoZW5naHVv_size_16_color_FFFFFF_t_70 2]  
上面一堆条件注解，  
@ConditionalOnClass 这个注解表示 当某个类存在的时候才加载该类，这里就是当SqlSessionFactory 和SqlSessionFactoryBean存在的时候才会创建该对象。  
@ConditionalOnSingleCandidate 这个就是在容器中只有一个这个类型的bean或者是多个指定了某个是主的时候才会创建该类对象，这里就是datasource 数据源就一个，或者是多个，然后指定了哪个是主的，也就是用@Primary标识的那个。  
@EnableConfigurationProperties这个就是加载配置类，这里就是讲mybatis开头的配置信息加载到MybatisProperties对象中。  
@AutoConfigureAfter(\{ DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class \})这个指的是DataSourceAutoConfiguration与MybatisLanguageDriverAutoConfiguration加载完事后再加载初始化该类。  
好了，类定义就看完了，接下来看下具体的是怎样创建SqlSessionFactory的吧

@Bean
    @ConditionalOnMissingBean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception { 
     SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
     // 设置datasource
     factory.setDataSource(dataSource);
     // 设置vfs
     factory.setVfs(SpringBootVFS.class);
     // 这里看看你配置那个 配置文件地址了么 ，如果有的话，就使用spring的resourceLoader进行资源加载
     if (StringUtils.hasText(this.properties.getConfigLocation())) { 
       factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
     }
     // 应该算是初始化 configuration对象
     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());
     }
     Set<String> factoryPropertyNames = Stream
         .of(new BeanWrapperImpl(SqlSessionFactoryBean.class).getPropertyDescriptors()).map(PropertyDescriptor::getName)
         .collect(Collectors.toSet());
     Class<? extends LanguageDriver> defaultLanguageDriver = this.properties.getDefaultScriptingLanguageDriver();
     if (factoryPropertyNames.contains("scriptingLanguageDrivers") && !ObjectUtils.isEmpty(this.languageDrivers)) { 
       // Need to mybatis-spring 2.0.2+
       factory.setScriptingLanguageDrivers(this.languageDrivers);
       if (defaultLanguageDriver == null && this.languageDrivers.length == 1) { 
         defaultLanguageDriver = this.languageDrivers[0].getClass();
       }
     }
     if (factoryPropertyNames.contains("defaultScriptingLanguageDriver")) { 
       // Need to mybatis-spring 2.0.2+
       factory.setDefaultScriptingLanguageDriver(defaultLanguageDriver);
     }
    
     return factory.getObject();
    }

这段代码很长，但是很简单，就是创建SqlSessionFactoryBean对象，然后将一堆配置信息，一堆自定义插件，自定义typehandler塞到里面，不需要过多的关注。  
这里最后一句`factory.getObject();`返回一个SqlSessionFactory对象，调用的SqlSessionFactoryBean对象方法，我们看下

public SqlSessionFactory getObject() throws Exception { 
        if (this.sqlSessionFactory == null) { 
          afterPropertiesSet();
        }
        return this.sqlSessionFactory;
      }
     public void afterPropertiesSet() throws Exception { 
        notNull(dataSource, "Property 'dataSource' is required");
        notNull(sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");
        state((configuration == null && configLocation == null) || !(configuration != null && configLocation != null),
            "Property 'configuration' and 'configLocation' can not specified with together");
        // 构建sqlSessionFactory
        this.sqlSessionFactory = buildSqlSessionFactory();
      }

关心 this.sqlSessionFactory = buildSqlSessionFactory(); 这行就可以了

protected SqlSessionFactory buildSqlSessionFactory() throws Exception { 
        final Configuration targetConfiguration;
        XMLConfigBuilder xmlConfigBuilder = null;
        if (this.configuration != null) { 
          targetConfiguration = this.configuration;
          if (targetConfiguration.getVariables() == null) { 
            targetConfiguration.setVariables(this.configurationProperties);
          } else if (this.configurationProperties != null) { 
            targetConfiguration.getVariables().putAll(this.configurationProperties);
          }
          //如果有配置文件的话
        } else if (this.configLocation != null) { 
          //解析配置文件
          xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
          targetConfiguration = xmlConfigBuilder.getConfiguration();
        } else { 
          LOGGER.debug(
              () -> "Property 'configuration' or 'configLocation' not specified, using default MyBatis Configuration");
          targetConfiguration = new Configuration();
          Optional.ofNullable(this.configurationProperties).ifPresent(targetConfiguration::setVariables);
        }
    
        Optional.ofNullable(this.objectFactory).ifPresent(targetConfiguration::setObjectFactory);
        Optional.ofNullable(this.objectWrapperFactory).ifPresent(targetConfiguration::setObjectWrapperFactory);
        Optional.ofNullable(this.vfs).ifPresent(targetConfiguration::setVfsImpl);
    
        if (hasLength(this.typeAliasesPackage)) { 
          scanClasses(this.typeAliasesPackage, this.typeAliasesSuperType).stream()
              .filter(clazz -> !clazz.isAnonymousClass()).filter(clazz -> !clazz.isInterface())
              .filter(clazz -> !clazz.isMemberClass()).forEach(targetConfiguration.getTypeAliasRegistry()::registerAlias);
        }
    
        if (!isEmpty(this.typeAliases)) { 
          Stream.of(this.typeAliases).forEach(typeAlias -> { 
            targetConfiguration.getTypeAliasRegistry().registerAlias(typeAlias);
            LOGGER.debug(() -> "Registered type alias: '" + typeAlias + "'");
          });
        }
    
        if (!isEmpty(this.plugins)) { 
          Stream.of(this.plugins).forEach(plugin -> { 
            targetConfiguration.addInterceptor(plugin);
            LOGGER.debug(() -> "Registered plugin: '" + plugin + "'");
          });
        }
    
        if (hasLength(this.typeHandlersPackage)) { 
          scanClasses(this.typeHandlersPackage, TypeHandler.class).stream().filter(clazz -> !clazz.isAnonymousClass())
              .filter(clazz -> !clazz.isInterface()).filter(clazz -> !Modifier.isAbstract(clazz.getModifiers()))
              .forEach(targetConfiguration.getTypeHandlerRegistry()::register);
        }
    
        if (!isEmpty(this.typeHandlers)) { 
          Stream.of(this.typeHandlers).forEach(typeHandler -> { 
            targetConfiguration.getTypeHandlerRegistry().register(typeHandler);
            LOGGER.debug(() -> "Registered type handler: '" + typeHandler + "'");
          });
        }
    
        targetConfiguration.setDefaultEnumTypeHandler(defaultEnumTypeHandler);
    
        if (!isEmpty(this.scriptingLanguageDrivers)) { 
          Stream.of(this.scriptingLanguageDrivers).forEach(languageDriver -> { 
            targetConfiguration.getLanguageRegistry().register(languageDriver);
            LOGGER.debug(() -> "Registered scripting language driver: '" + languageDriver + "'");
          });
        }
        Optional.ofNullable(this.defaultScriptingLanguageDriver)
            .ifPresent(targetConfiguration::setDefaultScriptingLanguage);
    
        if (this.databaseIdProvider != null) { // fix #64 set databaseId before parse mapper xmls
          try { 
            targetConfiguration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));
          } catch (SQLException e) { 
            throw new NestedIOException("Failed getting a databaseId", e);
          }
        }
    
        Optional.ofNullable(this.cache).ifPresent(targetConfiguration::addCache);
        //如果有xml 配置文件
        if (xmlConfigBuilder != null) { 
          try { 
            xmlConfigBuilder.parse();
            LOGGER.debug(() -> "Parsed configuration file: '" + this.configLocation + "'");
          } catch (Exception ex) { 
            throw new NestedIOException("Failed to parse config resource: " + this.configLocation, ex);
          } finally { 
            ErrorContext.instance().reset();
          }
        }
    
        targetConfiguration.setEnvironment(new Environment(this.environment,
            this.transactionFactory == null ? new SpringManagedTransactionFactory() : this.transactionFactory,
            this.dataSource));
        // 如果mapper xml地址不是空，我们一般就会配置这个东西
        if (this.mapperLocations != null) { 
          if (this.mapperLocations.length == 0) { 
            LOGGER.warn(() -> "Property 'mapperLocations' was specified but matching resources are not found.");
          } else { 
    
            //遍历
            for (Resource mapperLocation : this.mapperLocations) { 
              if (mapperLocation == null) { 
                continue;
              }
              try { 
                // 这里解析xml文件
                XMLMapperBuilder xmlMapperBuilder =
                  new XMLMapperBuilder(
                    mapperLocation.getInputStream(),
                    targetConfiguration,
                    mapperLocation.toString(),
                    targetConfiguration.getSqlFragments()  //将configuration中的sql片段集合放入了解析器中
                  );
                xmlMapperBuilder.parse();
              } catch (Exception e) { 
                throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);
              } finally { 
                ErrorContext.instance().reset();
              }
              LOGGER.debug(() -> "Parsed mapper file: '" + mapperLocation + "'");
            }
          }
        } else { 
          LOGGER.debug(() -> "Property 'mapperLocations' was not specified.");
        }
    
        return this.sqlSessionFactoryBuilder.build(targetConfiguration);
      }

这里这个buildSqlSessionFactory 方法超级长啊，核心思想其实就是看看Configuration对象有没有，没有的话创建一个，然后将插件，TypeHandler，别名这些东西放到congfiguration里面，还有比较重要的就是解析xml配置文件，解析xml mapper文件到congfiguration中。  
尤其下面这段代码，可以说核心，解析xml mapper文件的。

// 这里解析xml mapper文件
                XMLMapperBuilder xmlMapperBuilder =
                  new XMLMapperBuilder(
                    mapperLocation.getInputStream(),
                    targetConfiguration,
                    mapperLocation.toString(),
                    targetConfiguration.getSqlFragments()  //将configuration中的sql片段集合放入了解析器中
                  );
                xmlMapperBuilder.parse();

这里我们就不深入里面看了，只要知道xml 配置文件，xml mapper文件是在这里解析的就可以了。  
最后调用SqlSessionFactoryBuilder 的build方法构建出来一个SqlSessionFactory对象，构建的时候将Configuration对象传了过去。其实从这里就能看到，mybatis用了超级多的建造者设计模式来构建某个复杂的对象。

public SqlSessionFactory build(Configuration config) { 
        return new DefaultSqlSessionFactory(config);
      }

这里就简单了，就是创建DefaultSqlSessionFactory对象，将Configuration作为构造参数传进去。然后返回就可以了。  
到这里我们就把SqlSessionFactory创建流程看完了，不需要太关心细节，里面就是一堆琐碎的代码，解析配置，解析xml啥的。

### 2.SqlSessionTemplate创建分析 ###

上面分析完了SqlSessionFactory创建流程，我们接着回到MybatisAutoConfiguration 中看看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);
        }
      }

就是直接new个SqlSessionTemplate 对象，将sqlSessionFactory作为构造参数传了进去，我们看下它的构造方法

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;
    
        //生成一个sqlSession代理类
        this.sqlSessionProxy = (SqlSession) newProxyInstance(SqlSessionFactory.class.getClassLoader(),
            new Class[] {  SqlSession.class }, new SqlSessionInterceptor());
      }

最后面生成一个SqlSessionProxy 也就是SqlSession动态代理类，我们调用dao的时候，就是找到SqlSessionTemplate，然后SqlSessionTemplate又找到这个sqlSession代理类 来执行的，这个我们后面再说，这里只需要知道它创建一个SqlSession动态代理类即可。

### 3.mapper接口扫描分析 ###

mapper接口其实就是我们平常开发写的那个dao接口类，就是类似下面这种

@Mapper
    public interface UserDao { 
        boolean addUser(@Param("user") UserEntity userEntity);
    }

我们看下它是怎样被扫描出来，然后生成代理实现类的。  
接着MybatisAutoConfiguration 类往下走。

@org.springframework.context.annotation.Configuration
      @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.");
        }
    
      }

发现有这么一个静态类，它头上有个 @Import(AutoConfiguredMapperScannerRegistrar.class) 注解，@Import注解是用来导入配置类或者一些需要前置加载的类。我们直接看下AutoConfiguredMapperScannerRegistrar 类，它里面有个registerBeanDefinitions 方法。

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));
          }
          // 注册一个MapperScannerConfigurer
          BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
          builder.addPropertyValue("processPropertyPlaceHolders", true);
          /// @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.lazy-initialization:false}");
          }
          if (propertyNames.contains("defaultScope")) { 
            // Need to mybatis-spring 2.0.6+
            builder.addPropertyValue("defaultScope", "${mybatis.mapper-default-scope:}");
          }
    
          //向spring 容器中注册MapperScannerConfigurer 这个bean
          registry.registerBeanDefinition(MapperScannerConfigurer.class.getName(), builder.getBeanDefinition());
        }

这个方法就是向容器中注册一个BeanDefinition， BeanDefinition就是一个bean的定义，spring在帮你创建某个对象之前，都会为这个类生成一个BeanDefinition，bean的定义。这里是先使用BeanDefinitionBuilder 构造出来一个MapperScannerConfigurer bean定义，它这里为MapperScannerConfigurer 的BeanDefinition 添加了一堆的属性，在真正实例化的时候，会为MapperScannerConfigurer 对象的属性赋值。  
比较核心的属性 annotationClass 值是@Mapper注解class对象。basePackage 要扫描的包。  
最后就是向spring 容器中注册MapperScannerConfigurer 这个bean 定义了。  
到这里，我们也没有发现它扫描mapper接口的代码，别着急，我们接着看下MapperScannerConfigurer 类定义

public class MapperScannerConfigurer
        implements BeanDefinitionRegistryPostProcessor, InitializingBean, ApplicationContextAware, BeanNameAware {

可以看到实现了一堆spring 提供的生命周期接口。BeanDefinitionRegistryPostProcessor 从接口名字上也能看出来，BeanDefinition注册之后执行的，需要实现postProcessBeanDefinitionRegistry 方法，我们看下

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) { 
        if (this.processPropertyPlaceHolders) { 
          processPropertyPlaceHolders();
        }
    
        ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
        scanner.setAddToConfig(this.addToConfig);
    
        // @Mapper注解
        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 对象，这个就是用来扫描的， scanner.registerFilters();这行是为扫描器注册过滤器，也就是告诉扫描器我要哪些样的类。

if (this.annotationClass != null) { 
      addIncludeFilter(new AnnotationTypeFilter(this.annotationClass));
      acceptAllInterfaces = false;
    }

注册过滤器方法代码中有个非常重要的代码，如果annotationClass不是null，我们上面曾经提到过annotationClass 是@Mapper注册class  
对象，就会添加一个注解类型过滤器，就是@Mapper 注解，也就是说实现@Mapper注解的弄出来。

scanner.scan(
            StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));

这行就是执行扫描，指定包package。  
在往下需要看ClassPathMapperScanner 类的doScan方法，真正实现扫描的方法。

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 { 
          // 处理BeanDefinition
          processBeanDefinitions(beanDefinitions);
        }
        return beanDefinitions;
      }

首先是调用父类doScan方法真正扫描，然后拿到一堆BeanDefinitionHolder ，就是bean定义，这些就是带有@Mapper注解的接口定义了。  
接着调用processBeanDefinitions 方法来处理扫描出来的BeanDefinition。

private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) { 
        AbstractBeanDefinition definition;
        BeanDefinitionRegistry registry = getRegistry();
        for (BeanDefinitionHolder holder : beanDefinitions) { 
        	  ...
        	  String beanClassName = definition.getBeanClassName();
        	  definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName);
    		  definition.setBeanClass(this.mapperFactoryBeanClass);// 设置beanClass ,其实是个FactoryBean
    		  ...
        }
        ...
        registry.registerBeanDefinition(proxyHolder.getBeanName(), proxyHolder.getBeanDefinition());

这个方法代码太长，我截取最核心的几句，其实就是遍历找出的那些beanDefinition，这里有个非常核心的setBeanClass，为beanDefinition设置beanClass，告诉spring ，等下创建对象的时候，为我创建mapperFactoryBeanClass对象，也就是MapperFactoryBean对象，然而他是一个工厂bean，实现了spring的FactoryBean 接口。是专门用来创建对象的，spring为它创建了对象之后，还会调用它实现的getObject方法，获取真正的对象。

String beanClassName = definition.getBeanClassName();
     definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName);

这两行是为MapperFactoryBean 这个工厂bean设置构造参数，参数就是实际带有@Mapper注解的接口全类名。

举个例子，我那个扫描器，扫出来我UserDao接口上面有个@Mapper注解，就会为UserDao接口创建一个beanDefinition对象，我们说过这个beanDefinition 就是spring等下创建对象的一个描述，定义，里面就是维护了创建什么类型的对象，它的构造参数，成员信息等等。  
一开始的时候里面的beanClassName属性值就是我们UserDao 接口的全类名，beanClass 属性也是我们UserDao 接口的class对象。  
但是经过这个处理beanClass 变成了MapperFactoryBean 的class对象，也就是等下创建对象的时候是创建MapperFactoryBean 对象，还为MapperFactoryBean 设置了一个构造参数，参数值就是 beanClassName，也就是UserDao 接口全类名，  
等下spring 创建对象的时候会创建MapperFactoryBean对象，然后构造使用下面这个构造，

public MapperFactoryBean(Class<T> mapperInterface) { 
        this.mapperInterface = mapperInterface;
    }

为啥 mapperInterface 变成了class对象，这个不用太关心，反正mapperInterface 就是你那个UserDao的class对象。  
由于MapperFactoryBean 是一个工厂bean，实现了spring的FactoryBean 接口 ，专门用来创建bean的，所以spring在创建完它的对象后会调用它实现的getObject 方法获取真正的对象。  
我们看下MapperFactoryBean 的getObject方法

@Override
      public T getObject() throws Exception { 
        return getSqlSession().getMapper(this.mapperInterface);
      }

调用SqlSession 的getMapper方法，将mapper接口传了进去，也就是将我们的UserDao class对象传入了进去  
这个SqlSession 是SqlSessionTemplate，它作为成员变量会被spring注入进来，上面我们没有刻意提它。  
我们只需要知道是SqlSessionTemplate 就可以了

public <T> T getMapper(Class<T> type) { 
        return getConfiguration().getMapper(type, this);
     }

它找了Configuration来获取

public <T> T getMapper(Class<T> type, SqlSession sqlSession) { 
        return mapperRegistry.getMapper(type, sqlSession);
    }

Configuration又找了mapperRegistry 来获取。

public <T> T getMapper(Class<T> type, SqlSession sqlSession) { 
    
        //先从缓存中获取MapperProxyFactory
        final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
        if (mapperProxyFactory == null) { 
          throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
        }
    
        //创建代理类
        try { 
          return mapperProxyFactory.newInstance(sqlSession);
        } catch (Exception e) { 
          throw new BindingException("Error getting mapper instance. Cause: " + e, e);
        }
      }

从缓存中获取MapperProxyFactory，这个MapperProxyFactory 是创建SqlSessionFactory，解析xml mapper文件的时候设置进去的。  
接着就是调用 mapperProxyFactory的newInstance方法创建代理类

//使用jdk 动态代理创建对应的mapper 动态代理类
      @SuppressWarnings("unchecked")
      protected T newInstance(MapperProxy<T> mapperProxy) { 
        return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] {  mapperInterface }, mapperProxy);
      }
    
      public T newInstance(SqlSession sqlSession) { 
        final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
        return newInstance(mapperProxy);
      }

直接使用jdk动态代理api 为我们的UserDao创建一个代理类。  
invokerHandler是MapperProxy 对象，我们这里记着就ok了。  
到这里我们扫描mapper 接口，为其创建动态代理实现类的代码就分析完成了。

### 总结 ###

本文主要是介绍了springboot自动装配mybatis都干了些什么，分析了创建SqlSessionFactory流程代码，创建 SqlSessionTemplate流程代码，扫描mapper接口，为其生成动态代理实现类流程代码。尤其是扫描mapper接口，为其生成动态代理实现类这块代码实现上，我们发现它非常绕，而且需要你对spring 实现原理，创建bean生命周期有所了解。

[mybatis]: https://inetyoung.blog.csdn.net/article/details/119007391
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1YW5zaGFuZ3NoZW5naHVv_size_16_color_FFFFFF_t_70]: /images/20220829/862487c6c9044fe2b409a2b938c6b27e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1YW5zaGFuZ3NoZW5naHVv_size_16_color_FFFFFF_t_70 1]: /images/20220829/39b21510b31c4f4aafaeb766cf7497b7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1YW5zaGFuZ3NoZW5naHVv_size_16_color_FFFFFF_t_70 2]: /images/20220829/a7714b64fe9544dda9a3acf70010e5b7.png