java源码 - Spring5.x（5）之整合MyBatis源码

墨蓝 2022-11-27 08:52 184阅读 0赞

### 文章目录 ###

*  1. Mybatis独立使用
 *  2. 整合Spring
 *  3. 源码分析
 *   *  3.1 SqlSessionFactory的初始化
     *  3.2 获取 SqlSessionFactoryBean 实例
     *  3.3 MapperFactoryBean的初始化
     *  3.4 获取 MapperFactoryBean 的实例
     *  3.5 MapperScannerConfigurer
     *  3.6 根据配置属性生成过滤器
     *  3.7 扫描文件

# 1. Mybatis独立使用 #

<dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.4.2</version>
            </dependency>
            
            
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>1.3.1</version>
            </dependency>

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70_pic_center]

String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            Configuration configuration = sqlSessionFactory.getConfiguration();
            SqlSession sqlSession = sqlSessionFactory.openSession();
            DeptDao deptDao = sqlSession.getMapper(DeptDao.class);
    // SqlSessionManager sqlSessionManager = SqlSessionManager.newInstance(inputStream);
    // DeptDao deptDao = sqlSessionManager.getMapper(DeptDao.class);
            List<Dept> deptList = deptDao.findAll();
            System.out.println(deptList.toString());

想要获取XXX，得从SqlSessionFactory获取才行。

# 2. 整合Spring #

Spring核心配置文件

<context:property-placeholder location="classpath:dbconfig.properties" />
        <bean id="pooledDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
            <property name="driverClass" value="${jdbc.driverClass}"></property>
            <property name="user" value="${jdbc.user}"></property>
            <property name="password" value="${jdbc.password}"></property>
        </bean>
        
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            
            <property name="configLocation" value="classpath:mybatis-config.xml"></property>
            <property name="dataSource" ref="pooledDataSource"></property>
            
            <property name="mapperLocations" value="classpath:mapper/*.xml"></property>
        </bean>
    
        
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            
            <property name="basePackage" value="com.lyq.curd.dao"></property>
        </bean>
        
        <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
            <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"></constructor-arg>
            <constructor-arg name="executorType" value="BATCH"></constructor-arg>
        </bean>

Mybatis配置文件

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        <settings>
            <setting name="mapUnderscoreToCamelCase" value="true"/>
        </settings>
    
        <typeAliases>
            <package name="com.xxx.curd.bean"/>
        </typeAliases>
    
        <plugins>
            <plugin interceptor="com.github.pagehelper.PageInterceptor">
                
                <property name="reasonable" value="true"/>
            </plugin>
        </plugins>
    </configuration>

映射文件略；

# 3. 源码分析 #

ApplicationContext context = new ClassPathXrnlApplicationContext("xxx");
    UserMapper usermapper=(UserMapper)context.getBean("userMapper");
    usermapper.getUser("1");

如果调用的话，可以直接通过context 获取到Dao。但是通过我们前面的单独使用Mybatis知道，Dao是通过SqlSession得到的。那么可以猜想，Spring必定有个类做了这之间的衔接。

![在这里插入图片描述][20200814164933924.png_pic_center]  
通过配置文件我们可以找到这个类，并看看这个类的继承关系：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70_pic_center 1]  
FactoryBean，InitializingBean，ApplicationListener是不是都很熟悉？

*  FactoryBean：一旦某个 bean 实现该接口，那么通过 getBean 方法获取 bean 时其实是获取此类的 getObject（）返回的实例。（通过该类的工厂方法获取Bean）
 *  InitializingBean：实现此接口的 bean 会在初始化时调用其 afterPropertiesSet方法来进  
    bean 逻辑初始化。

## 3.1 SqlSessionFactory的初始化 ##

直接来看他重写的afterPropertiesSet方法：

@Override
      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");
    
        this.sqlSessionFactory = buildSqlSessionFactory();
      }

很明显主要做事的是buildSqlSessionFactory方法：

protected SqlSessionFactory buildSqlSessionFactory() throws IOException { 
    
        Configuration configuration;
    
        XMLConfigBuilder xmlConfigBuilder = null;
        if (this.configuration != null) { 
          configuration = this.configuration;
          if (configuration.getVariables() == null) { 
            configuration.setVariables(this.configurationProperties);
          } else if (this.configurationProperties != null) { 
            configuration.getVariables().putAll(this.configurationProperties);
          }
        } else if (this.configLocation != null) { 
          xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
          configuration = xmlConfigBuilder.getConfiguration();
        } else { 
          if (LOGGER.isDebugEnabled()) { 
            LOGGER.debug("Property 'configuration' or 'configLocation' not specified, using default MyBatis Configuration");
          }
          configuration = new Configuration();
          if (this.configurationProperties != null) { 
            configuration.setVariables(this.configurationProperties);
          }
        }
    
        if (this.objectFactory != null) { 
          configuration.setObjectFactory(this.objectFactory);
        }
    
        if (this.objectWrapperFactory != null) { 
          configuration.setObjectWrapperFactory(this.objectWrapperFactory);
        }
    
        if (this.vfs != null) { 
          configuration.setVfsImpl(this.vfs);
        }
    
        if (hasLength(this.typeAliasesPackage)) { 
          String[] typeAliasPackageArray = tokenizeToStringArray(this.typeAliasesPackage,
              ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
          for (String packageToScan : typeAliasPackageArray) { 
            configuration.getTypeAliasRegistry().registerAliases(packageToScan,
                    typeAliasesSuperType == null ? Object.class : typeAliasesSuperType);
            if (LOGGER.isDebugEnabled()) { 
              LOGGER.debug("Scanned package: '" + packageToScan + "' for aliases");
            }
          }
        }
    
        if (!isEmpty(this.typeAliases)) { 
          for (Class<?> typeAlias : this.typeAliases) { 
            configuration.getTypeAliasRegistry().registerAlias(typeAlias);
            if (LOGGER.isDebugEnabled()) { 
              LOGGER.debug("Registered type alias: '" + typeAlias + "'");
            }
          }
        }
    
        if (!isEmpty(this.plugins)) { 
          for (Interceptor plugin : this.plugins) { 
            configuration.addInterceptor(plugin);
            if (LOGGER.isDebugEnabled()) { 
              LOGGER.debug("Registered plugin: '" + plugin + "'");
            }
          }
        }
    
        if (hasLength(this.typeHandlersPackage)) { 
          String[] typeHandlersPackageArray = tokenizeToStringArray(this.typeHandlersPackage,
              ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
          for (String packageToScan : typeHandlersPackageArray) { 
            configuration.getTypeHandlerRegistry().register(packageToScan);
            if (LOGGER.isDebugEnabled()) { 
              LOGGER.debug("Scanned package: '" + packageToScan + "' for type handlers");
            }
          }
        }
    
        if (!isEmpty(this.typeHandlers)) { 
          for (TypeHandler<?> typeHandler : this.typeHandlers) { 
            configuration.getTypeHandlerRegistry().register(typeHandler);
            if (LOGGER.isDebugEnabled()) { 
              LOGGER.debug("Registered type handler: '" + typeHandler + "'");
            }
          }
        }
    
        if (this.databaseIdProvider != null) { //fix #64 set databaseId before parse mapper xmls
          try { 
            configuration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));
          } catch (SQLException e) { 
            throw new NestedIOException("Failed getting a databaseId", e);
          }
        }
    
        if (this.cache != null) { 
          configuration.addCache(this.cache);
        }
    
        if (xmlConfigBuilder != null) { 
          try { 
            xmlConfigBuilder.parse();
    
            if (LOGGER.isDebugEnabled()) { 
              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();
          }
        }
    
        if (this.transactionFactory == null) { 
          this.transactionFactory = new SpringManagedTransactionFactory();
        }
    
        configuration.setEnvironment(new Environment(this.environment, this.transactionFactory, this.dataSource));
    
        if (!isEmpty(this.mapperLocations)) { 
          for (Resource mapperLocation : this.mapperLocations) { 
            if (mapperLocation == null) { 
              continue;
            }
    
            try { 
              XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),
                  configuration, mapperLocation.toString(), configuration.getSqlFragments());
              xmlMapperBuilder.parse();
            } catch (Exception e) { 
              throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);
            } finally { 
              ErrorContext.instance().reset();
            }
    
            if (LOGGER.isDebugEnabled()) { 
              LOGGER.debug("Parsed mapper file: '" + mapperLocation + "'");
            }
          }
        } else { 
          if (LOGGER.isDebugEnabled()) { 
            LOGGER.debug("Property 'mapperLocations' was not specified or no matching resources found");
          }
        }
    
        return this.sqlSessionFactoryBuilder.build(configuration);
      }

这个方法其实主要的就是做了读取配置构建出sqlSessionFactory。通过这个方法还可以了解到，配置属性可以直接写在sqlSessionFactoryBean中。

## 3.2 获取 SqlSessionFactoryBean 实例 ##

其配置：  
![在这里插入图片描述][20200815152950626.png_pic_center]

由于 SqlSessionFactoryBean 实现了 FactoryBean 接口 ，所以当通过getBean 方法获取对应实例时，其实是获取该类的 getObject（）函数返回的实例，也就是获取初始化后的 SqlSessionFactory属性。

@Override
      public SqlSessionFactory getObject() throws Exception { 
        if (this.sqlSessionFactory == null) { 
          afterPropertiesSet();
        }
    
        return this.sqlSessionFactory;
      }

## 3.3 MapperFactoryBean的初始化 ##

在Bean的创建过程中Spring肯定使用了MyBatis中的原生方法sqlSession.getMapper()，进行了再次封装。

public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T>

其继承关系如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70_pic_center 2]

那么同理我们先来看afterPropertiesSet：

public final void afterPropertiesSet() throws IllegalArgumentException, BeanInitializationException { 
            this.checkDaoConfig();
    
            try { 
                this.initDao();
            } catch (Exception var2) { 
                throw new BeanInitializationException("Initialization of DAO failed", var2);
            }
        }

其中的checkDaoConfig，initDao均可以由子类实现：

@Override
      protected void checkDaoConfig() { 
        super.checkDaoConfig();
    
        notNull(this.mapperInterface, "Property 'mapperInterface' is required");
    
        Configuration configuration = getSqlSession().getConfiguration();
        if (this.addToConfig && !configuration.hasMapper(this.mapperInterface)) { 
          try { 
            configuration.addMapper(this.mapperInterface);
          } catch (Exception e) { 
            logger.error("Error while adding the mapper '" + this.mapperInterface + "' to configuration.", e);
            throw new IllegalArgumentException(e);
          } finally { 
            ErrorContext.instance().reset();
          }
        }
      }

其主要作用：

*  父类中验证SqlSession不为空
 *  映射接口的验证
 *  映射文件存在验证性

## 3.4 获取 MapperFactoryBean 的实例 ##

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

## 3.5 MapperScannerConfigurer ##

[关于PropertyResourceConfigurer请看这儿][PropertyResourceConfigurer]

对于MapperFactoryBean的使用，其实是很低效的。我们可以使用MapperScannerConfigurer来指定扫描某个包内的dao到Spring的IOC容器中。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70_pic_center 3]  
还是同理先看afterPropertiesSet：

@Override
      public void afterPropertiesSet() throws Exception { 
        notNull(this.basePackage, "Property 'basePackage' is required");
      }

但是发现该方法并没有做什么有效的事情。但是我们会再回顾类图。该类还实现了BeanFactoryPostProcessor接口，可见，MapperScannerConfigurer会在BeanFactory初始化时，同样进行调用该接口内的方法。如果回忆一下，其实是在onRefresh方法。

而这个接口内的postProcessBeanDefinitionRegistry主要提供的功能就是，在容器初始化完成前，可以修改BeanDefinitionRegistry。

@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.registerFilters();
        scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
      }

以前方法功能：完成对指定路径的扫描。

/* * BeanDefinitionRegistries在应用程序启动之前被调用 * beanfactorypostprocessor。这意味着PropertyResourceConfigurers将不会 *加载后，该类属性的任何属性替换都将失败。要避免这种情况，请找到 *上下文中定义的所有PropertyResourceConfigurers，并在这个类的bean上运行它们 *定义。然后更新值。 */
      private void processPropertyPlaceHolders() { 
        Map<String, PropertyResourceConfigurer> prcs = applicationContext.getBeansOfType(PropertyResourceConfigurer.class);
    
        if (!prcs.isEmpty() && applicationContext instanceof ConfigurableApplicationContext) { 
          BeanDefinition mapperScannerBean = ((ConfigurableApplicationContext) applicationContext)
              .getBeanFactory().getBeanDefinition(beanName);
    
    		//PropertyResourceConfigurer不公开任何要显式执行的方法
    		//属性占位符替换。相反，创建一个Bean工厂
    		//包含这个映射程序扫描器和后处理工厂。
          DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
          factory.registerBeanDefinition(beanName, mapperScannerBean);
    
          for (PropertyResourceConfigurer prc : prcs.values()) { 
            prc.postProcessBeanFactory(factory);
          }
    
          PropertyValues values = mapperScannerBean.getPropertyValues();
    
          this.basePackage = updatePropertyValue("basePackage", values);
          this.sqlSessionFactoryBeanName = updatePropertyValue("sqlSessionFactoryBeanName", values);
          this.sqlSessionTemplateBeanName = updatePropertyValue("sqlSessionTemplateBeanName", values);
        }
      }

BeanDefinitionRegistries会在应用启动的时候调用，并且会早于 BeanFactoryPostProcessors的调用，这就意味着PropertyResourceConfigurers 还没有被加载所有对于属性文件的引用将会失效。为避免此种情况发生，此方法手动地找出定义的 PropertyResourceConfigurers 并进行提前调用以保证对于属性的引用可以正常工作。

**（IOC容器的BeanDefinition的注册要早于BeanFactoryPostProcessors的调用时机，为防止PropertyResourceConfigurers 失效，得先保持对他的引用）**

1.  找到所有已经注册的PropertyResourceConfigurers 类型的 bean。
2.  模拟 Spring 中的环境来用处理器。

## 3.6 根据配置属性生成过滤器 ##

org.mybatis.spring.mapper.ClassPathMapperScanner\#registerFilters

/** *配置父扫描程序，以搜索正确的接口。它可以搜索 *适用于所有接口，或仅适用于扩展markerInterface或/and的接口 *那些用annotationClass注释的 */
      public void registerFilters() { 
        boolean acceptAllInterfaces = true;
    
    	//如果指定，使用给定的注释和/或标记接口
        if (this.annotationClass != null) { 
          addIncludeFilter(new AnnotationTypeFilter(this.annotationClass));
          acceptAllInterfaces = false;
        }
    
       //重写AssignableTypeFilter来忽略实际标记接口上的匹配
        if (this.markerInterface != null) { 
          addIncludeFilter(new AssignableTypeFilter(this.markerInterface) { 
            @Override
            protected boolean matchClassName(String className) { 
              return false;
            }
          });
          acceptAllInterfaces = false;
        }
    
        if (acceptAllInterfaces) { 
        //默认包含接受所有类的过滤器
          addIncludeFilter(new TypeFilter() { 
            @Override
            public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException { 
              return true;
            }
          });
        }
    
    	//排除package-info.java
        addExcludeFilter(new TypeFilter() { 
          @Override
          public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException { 
            String className = metadataReader.getClassMetadata().getClassName();
            return className.endsWith("package-info");
          }
        });
      }

功能：

*  annotationClass 属性处理
 *  markerlnterface 属性处理
 *  全局默认处理
 *  package-info.java的处理

## 3.7 扫描文件 ##

org.springframework.context.annotation.ClassPathBeanDefinitionScanner\#scan

public int scan(String... basePackages) { 
            int beanCountAtScanStart = this.registry.getBeanDefinitionCount();
            this.doScan(basePackages);
            if (this.includeAnnotationConfig) { 
    	//完成注解处理器的注册
                AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
            }
    
            return this.registry.getBeanDefinitionCount() - beanCountAtScanStart;
        }

scan是一个静态方法，其主要工作交给doScan完成。  
org.mybatis.spring.mapper.ClassPathMapperScanner\#doScan

@Override
      public Set<BeanDefinitionHolder> doScan(String... basePackages) { 
        Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
    
        if (beanDefinitions.isEmpty()) { 
          logger.warn("No MyBatis mapper was found in '" + Arrays.toString(basePackages) + "' package. Please check your configuration.");
        } else { 
          processBeanDefinitions(beanDefinitions);
        }
    
        return beanDefinitions;
      }

org.springframework.context.annotation.ClassPathBeanDefinitionScanner\#doScan

protected Set<BeanDefinitionHolder> doScan(String... basePackages) { 
    		Assert.notEmpty(basePackages, "At least one base package must be specified");
    		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
    		for (String basePackage : basePackages) { 
    		//扫描basePackage下的java文件
    			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
    			for (BeanDefinition candidate : candidates) { 
    			//解析Scope属性
    				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
    				candidate.setScope(scopeMetadata.getScopeName());
    				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
    				if (candidate instanceof AbstractBeanDefinition) { 
    					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
    				}
    				if (candidate instanceof AnnotatedBeanDefinition) { 
    					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
    				}
    				//当前Bean是否已经注册
    				if (checkCandidate(beanName, candidate)) { 
    					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
    					definitionHolder =
    							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
    					beanDefinitions.add(definitionHolder);
    					registerBeanDefinition(definitionHolder, this.registry);
    				}
    			}
    		}
    		return beanDefinitions;
    	}

org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider\#findCandidateComponents

public Set<BeanDefinition> findCandidateComponents(String basePackage) { 
    		Set<BeanDefinition> candidates = new LinkedHashSet<BeanDefinition>();
    		try { 
    			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
    					resolveBasePackage(basePackage) + '/' + this.resourcePattern;
    			Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
    			boolean traceEnabled = logger.isTraceEnabled();
    			boolean debugEnabled = logger.isDebugEnabled();
    			for (Resource resource : resources) { 
    				if (traceEnabled) { 
    					logger.trace("Scanning " + resource);
    				}
    				if (resource.isReadable()) { 
    					try { 
    						MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
    						if (isCandidateComponent(metadataReader)) { 
    							ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
    							sbd.setResource(resource);
    							sbd.setSource(resource);
    							if (isCandidateComponent(sbd)) { 
    								if (debugEnabled) { 
    									logger.debug("Identified candidate component class: " + resource);
    								}
    								candidates.add(sbd);
    							}
    							else { 
    								if (debugEnabled) { 
    									logger.debug("Ignored because not a concrete top-level class: " + resource);
    								}
    							}
    						}
    						else { 
    							if (traceEnabled) { 
    								logger.trace("Ignored because not matching any filter: " + resource);
    							}
    						}
    					}
    					catch (Throwable ex) { 
    						throw new BeanDefinitionStoreException(
    								"Failed to read candidate component class: " + resource, ex);
    					}
    				}
    				else { 
    					if (traceEnabled) { 
    						logger.trace("Ignored because not readable: " + resource);
    					}
    				}
    			}
    		}
    		catch (IOException ex) { 
    			throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
    		}
    		return candidates;
    	}

其中的findCandidateComponents 方法根据传人的包路径信息并结合类文件路径拼接成文件的绝对路径，同时完成了文件的扫描过程并且根据对应的文件生成了对应的 bean ，使用ScannedGenericBeanDefinition 类型的 bean 承载信息， bean 中只记录了 resource和source 信息。其中的过滤器excludeFilters，includeFilters对文件是否符合要求就是在这里进行判断的。  
再其他的registerBeanDefinition就是Spring的内容了。

做完这些后，我们回到最初的doScan，返回了一个 Set<BeanDefinitionHolder>  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70_pic_center 4]  
那么再来看看最后对BeanDefinitionHolder的处理的方法processBeanDefinitions：

private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) { 
        GenericBeanDefinition definition;
        for (BeanDefinitionHolder holder : beanDefinitions) { 
          definition = (GenericBeanDefinition) holder.getBeanDefinition();
    
          if (logger.isDebugEnabled()) { 
            logger.debug("Creating MapperFactoryBean with name '" + holder.getBeanName() 
              + "' and '" + definition.getBeanClassName() + "' mapperInterface");
          }
    
       // mapper接口是bean的原始类
    //但是，bean的实际类是MapperFactoryBean
          definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName()); // issue #59
          definition.setBeanClass(this.mapperFactoryBean.getClass());
    
          definition.getPropertyValues().add("addToConfig", this.addToConfig);
    
          boolean explicitFactoryUsed = false;
          if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) { 
            definition.getPropertyValues().add("sqlSessionFactory", new RuntimeBeanReference(this.sqlSessionFactoryBeanName));
            explicitFactoryUsed = true;
          } else if (this.sqlSessionFactory != null) { 
            definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);
            explicitFactoryUsed = true;
          }
    
          if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) { 
            if (explicitFactoryUsed) { 
              logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
            }
            definition.getPropertyValues().add("sqlSessionTemplate", new RuntimeBeanReference(this.sqlSessionTemplateBeanName));
            explicitFactoryUsed = true;
          } else if (this.sqlSessionTemplate != null) { 
            if (explicitFactoryUsed) { 
              logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
            }
            definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);
            explicitFactoryUsed = true;
          }
    
          if (!explicitFactoryUsed) { 
            if (logger.isDebugEnabled()) { 
              logger.debug("Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
            }
            definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
          }
        }
      }

从以上方法的 ，mapper接口是bean的原始类。但是，bean的实际类是MapperFactoryBean：  
![在这里插入图片描述][20200815163542673.png_pic_center]  
我们可以看出有最先的MapperFactoryBean的联系了。其实注册的基本类是MapperFactoryBean。  
那么就可以联想到Spring再实例化相应的Bean的时候调用的。  
org.mybatis.spring.mapper.MapperFactoryBean\#getObject

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

总结一下:Spring在启动的时候，通过BeanFactoryPostProcessor的特性，找到MapperScannerConfigurer执行重写的方法，将指定的路径下Mapper扫描成ScannedGenericBeanDefinition并注册进Spring容器。那么在调用的时候，Spring直接通过MapperFactoryBean.getObject方法就可以获取到指定的Mapper实例了。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70_pic_center]: /images/20221124/2bf19d7e204f4b7ea453dac9a7cd3004.png
[20200814164933924.png_pic_center]: /images/20221124/b86488eb12854d4dae3b25d5e208dc96.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221124/ba7955521e454e62b365b65db73d4a55.png
[20200815152950626.png_pic_center]: /images/20221124/fc77f1ef59d845a986f8e7db3531c6e3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221124/a871605bae8d4e959a04cbcdea777cdc.png
[PropertyResourceConfigurer]: https://blog.csdn.net/andy_zhang2007/article/details/86756564
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221124/31af6c6844704f65b6946d9063af9ee0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221124/ddb93558a3eb45d6ae6d7334291dd90b.png
[20200815163542673.png_pic_center]: /images/20221124/b97b03d50fd040e4bd9cb212854ca554.png