org.apache.ibatis.binding.bindingexception: 
invalid bound statement (not found): 
com.dhy.testMapper.query

    @Bean
    public SqlSessionFactory sqlSessionFactoryOfDataSourceA(@Qualifier("datasourceA") DataSource dataSourceA) throws Exception {
        SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        sessionFactoryBean.setDataSource(dataSourceA);
        sessionFactoryBean.setConfigLocation(configLocation);
        sessionFactoryBean.setTypeAliasesPackage("com.dhy.mapper");
        Resource[] resources = new PathMatchingResourcePatternResolver().getResources("classpath:dhy/mapper/*.xml");
        sessionFactoryBean.setMapperLocations(resources);
        return sessionFactoryBean.getObject();
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurerOfDataSourceA() {
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactoryOfDataSourceA");
        mapperScannerConfigurer.setBasePackage("com.dhy.mapper");
        return mapperScannerConfigurer;
    }

    @Bean
    public SqlSessionFactory sqlSessionFactoryOfDataSourceB(@Qualifier("datasourceB") DataSource dataSourceB) throws Exception {
        SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        sessionFactoryBean.setDataSource(dataSourceB);
        sessionFactoryBean.setConfigLocation(configLocation);
        sessionFactoryBean.setTypeAliasesPackage("com.dhy.mapper.b");
        Resource[] resources = new PathMatchingResourcePatternResolver().getResources("classpath:dhy/mapper/*.xml");
        sessionFactoryBean.setMapperLocations(resources);
        return sessionFactoryBean.getObject();
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurerOfDataSourceB() {
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactoryOfDataSourceB");
        mapperScannerConfigurer.setBasePackage("com.dhy.mapper.b");
        return mapperScannerConfigurer;
    }

/**
 Auto-Configuration for Mybatis. 
 Contributes a SqlSessionFactory and a SqlSessionTemplate. 
 If org.mybatis.spring.annotation.MapperScan is used, 
 or a configuration file is specified as a property, 
 those will be considered, 
 otherwise this auto-configuration will attempt to register mappers 
 based on the interface definitions in or under the root auto-configuration package.
 */
@org.springframework.context.annotation.Configuration
@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })
@ConditionalOnBean(DataSource.class)
@EnableConfigurationProperties(MybatisProperties.class)
@AutoConfigureAfter(DataSourceAutoConfiguration.class)
public class MybatisAutoConfiguration {
  ... 
  //Если мы не предоставляем SqlSessionFactory, он будет автоматически внедрен по умолчанию
  @Bean
  @ConditionalOnMissingBean
  public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
    ...
  }
  //Если мы не предоставляем SqlSessionTemplate , один из них будет автоматически введен по умолчанию
  @Bean
  @ConditionalOnMissingBean
  public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
       ...
  }

  /**
   MapperScan ultimately ends up creating instances of MapperFactoryBean. 
   If MapperScan is used then this auto-configuration is not needed. 
   If it is _not_ used, however, then this will bring in a bean registrar and automatically register components based on the same component-scanning path as Spring Boot itself.
   */
  @org.springframework.context.annotation.Configuration
  @Import({ AutoConfiguredMapperScannerRegistrar.class })
  @ConditionalOnMissingBean(MapperFactoryBean.class)
  public static class MapperScannerRegistrarNotFoundConfiguration {

    @PostConstruct
    public void afterPropertiesSet() {
      logger.debug("No {} found.", MapperFactoryBean.class.getName());
    }
  }

}

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

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
      logger.debug("Searching for mappers annotated with @Mapper");
      //сканер картографа, предоставленный mybaits 
      ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
      try {
        if (this.resourceLoader != null) {
          scanner.setResourceLoader(this.resourceLoader);
        }
        //Получаем путь сканирования пакета текущего проекта SpringBoot
        List<String> packages = AutoConfigurationPackages.get(this.beanFactory);
        ...
        //Настраиваем фильтр на основе аннотации
        scanner.setAnnotationClass(Mapper.class);
        //зарегистрироваться Процесс сканирования пакет Фильтровать ожидаемый результат, установленный пользователем
        //После того, как мы настроили аннотацию выше, она будет инкапсулирована как AnnotationTypeFilter и зарегистрирована в сканере.
        scanner.registerFilters();
        //Сканирование пакетов
        scanner.doScan(StringUtils.toStringArray(packages));
      }...
    }
    ...
  }

  /**
   * Calls the parent search that will search and register all the candidates. Then the registered objects are post
   * processed to set them as MapperFactoryBeans
   */
  @Override
  public Set<BeanDefinitionHolder> doScan(String... basePackages) {
    //Вызов метода doScan ClassPathBeanDefinitionScanner для завершения сканирования пакета и фильтрации фильтра.
    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 {
      //mybaits отвечает за обработку определения компонента
      processBeanDefinitions(beanDefinitions);
    }

    return beanDefinitions;
  }

  private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
    AbstractBeanDefinition definition;
    BeanDefinitionRegistry registry = getRegistry();
    for (BeanDefinitionHolder holder : beanDefinitions) {
      definition = (AbstractBeanDefinition) holder.getBeanDefinition();
      ...
      // the mapper interface is the original class of the bean
      // but, the actual class of the bean is MapperFactoryBean
      //Добавляем параметры конструктора для MapperFactoryBean
      definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName); // issue #59
      //Добавляем сопоставление отношений внедрения атрибутов
      definition.getPropertyValues().add("mapperInterface", Resources.classForName(beanClassName));
      //Устанавливаем фактический тип текущего компонента MapperFactoryBeanClass
      definition.setBeanClass(this.mapperFactoryBeanClass);
      //Добавляем сопоставление отношений внедрения атрибутов
      definition.getPropertyValues().add("addToConfig", this.addToConfig);
      ...
      //Установили ли мы свойство sqlSessionFactoryBeanName для ClassPathMapperScanner
      // Установка этого атрибута указывает, что интерфейс картографа, сканируемый текущим сканером, в конечном итоге будет передан этому sqlSessionFactory для управления.
      boolean explicitFactoryUsed = false;
      if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {
        //Если установлено, добавляем сопоставление атрибутов
        definition.getPropertyValues().add("sqlSessionFactory",
            //RuntimeBeanReference будет заменен фактическим экземпляром sqlSessionFactoryBean на этапе внедрения свойств компонента.
            new RuntimeBeanReference(this.sqlSessionFactoryBeanName));
        explicitFactoryUsed = true;
      } else if (this.sqlSessionFactory != null) {
        //Или мы напрямую указываем экземпляр объекта sqlSessionFactory, тогда мы можем напрямую заменить RuntimeBeanReference фактическим экземпляром bean-компонента
        definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);
        explicitFactoryUsed = true;
      }
      
      //Если указан sqlSessionTemplate, это также возможно.
      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;
      }
     
      //Если ни sqlSessionTemplate, ни sqlSessionFactory не указаны, то этот параметр поддерживает автоматическое внедрение.
      if (!explicitFactoryUsed) {
        LOGGER.debug(() -> "Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
        definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
      }
      //Устанавливаем, нужно ли отложенной загрузке текущего bean-компонента
      definition.setLazyInit(lazyInitialization);
      ...
       //Настройки области
      if (ConfigurableBeanFactory.SCOPE_SINGLETON.equals(definition.getScope()) && defaultScope != null) {
        definition.setScope(defaultScope);
      }
      ...
    }
  }

	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		...
		//Получаем существующую коллекцию PropertyValues ​​в beanDefintion ---в коллекции могут быть разработки картографирование зависимостей
		//Например: Мы передаем текущий bean-компонент через xmlConfiguration или вручную обрабатываем коллекцию PropertyValues, как указано выше.
		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
		//Получаем режим автоматического внедрения текущего компонента — по умолчанию он не включен
		int resolvedAutowireMode = mbd.getResolvedAutowireMode();
		//Если для текущего компонента включен режим автоматического внедрения, определите, следует ли внедрять по имени или по типу.
		//Например: Если режим автоматического внедрения включен и автоматическое внедрение выполняется в соответствии с типом, Spring попытается автоматически внедрить каждое свойство текущего компонента.
		//Если определенные атрибуты могут быть автоматически успешно внедрены в соответствии с типом, то создаем соответствующую реализацию зависимостей Отображение отношений---propertyValue
		//Затем добавляем propertyValue в существующую коллекцию PropertyValues ​​текущего bean-компонента
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			// Add property values based on autowire by name if applicable.
			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
			// Add property values based on autowire by type if applicable.
			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}
			pvs = newPvs;
		}
        //Постпроцессор обрабатывает логику внедрения сопоставления зависимостей, указанную в режиме аннотации, и опускает ее.
		...
        //Наконец, используем BeanWrapper для взаимодействия с модулем преобразования типов Spring
        //По реализации, сохраненной в коллекции PropertyValues отображение взаимосвязей зависимостей, завершение внедрения на основе метода установки зависимостей
		if (pvs != null) {
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

	/**
	 Check the given candidate's bean name, determining whether the corresponding bean definition needs to be registered or conflicts with an existing definition.
	 */
	protected boolean checkCandidate(String beanName, BeanDefinition beanDefinition) throws IllegalStateException {
		if (!this.registry.containsBeanDefinition(beanName)) {
			return true;
		}
		BeanDefinition existingDef = this.registry.getBeanDefinition(beanName);
		BeanDefinition originatingDef = existingDef.getOriginatingBeanDefinition();
		if (originatingDef != null) {
			existingDef = originatingDef;
		}
		//Определения двух bean-компонентов одинаковы, то есть они совместимы друг с другом
		if (isCompatible(beanDefinition, existingDef)) {
			return false;
		}
		//Если два bean-компонента имеют одинаковое имя, но определения bean-компонента несовместимы, будет выброшен аномальный объект, сообщающий об ошибке, что beanName сопоставлен с двумя разными bean-компонентами.
		throw new ConflictingBeanDefinitionException("Annotation-specified bean name '" + beanName +
				"' for bean class [" + beanDefinition.getBeanClassName() + "] conflicts with existing, " +
				"non-compatible bean definition of same name and class [" + existingDef.getBeanClassName() + "]");
	}

  @Override
  public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    if (this.processPropertyPlaceHolders) {
      processPropertyPlaceHolders();
    }
    //В соответствии со значением, которое мы установили для MapperScannerConfigurer, затем установите его в ClassPathMapperScanner середина
    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);
    }
    //зарегистрироватьсяFilter,Затем запустите сканирование пакет, путь сканирования пакета — это тот, который мы установили в методе @Bean середина
    scanner.registerFilters();
    scanner.scan(
        StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
  }

@Override
  public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
     //Получаем все атрибуты аннотации середина
    AnnotationAttributes mapperScanAttrs = AnnotationAttributes
        .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
    //Регистрация MapperScannerConfigurer
    if (mapperScanAttrs != null) {
      registerBeanDefinitions(importingClassMetadata, mapperScanAttrs, registry,
          generateBaseBeanName(importingClassMetadata, 0));
    }
  }

  void registerBeanDefinitions(AnnotationMetadata annoMeta, AnnotationAttributes annoAttrs,
      BeanDefinitionRegistry registry, String beanName) {
    // Тип bean-компонента, который необходимо зарегистрировать, — MapperScannerConfigurer.
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
    
    builder.addPropertyValue("processPropertyPlaceHolders", true);
    //Если вы указали сканирование и фильтрацию пакетов по аннотации, то настроим по умолчанию, будет собираться весь интерфейс под указанным пакетом.
    Class<? extends Annotation> annotationClass = annoAttrs.getClass("annotationClass");
    if (!Annotation.class.equals(annotationClass)) {
      builder.addPropertyValue("annotationClass", annotationClass);
    }
    
    Class<?> markerInterface = annoAttrs.getClass("markerInterface");
    if (!Class.class.equals(markerInterface)) {
      builder.addPropertyValue("markerInterface", markerInterface);
    }

    Class<? extends BeanNameGenerator> generatorClass = annoAttrs.getClass("nameGenerator");
    if (!BeanNameGenerator.class.equals(generatorClass)) {
      builder.addPropertyValue("nameGenerator", BeanUtils.instantiateClass(generatorClass));
    }

    Class<? extends MapperFactoryBean> mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");
    if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {
      builder.addPropertyValue("mapperFactoryBeanClass", mapperFactoryBeanClass);
    }

    String sqlSessionTemplateRef = annoAttrs.getString("sqlSessionTemplateRef");
    if (StringUtils.hasText(sqlSessionTemplateRef)) {
      builder.addPropertyValue("sqlSessionTemplateBeanName", annoAttrs.getString("sqlSessionTemplateRef"));
    }

    String sqlSessionFactoryRef = annoAttrs.getString("sqlSessionFactoryRef");
    if (StringUtils.hasText(sqlSessionFactoryRef)) {
      builder.addPropertyValue("sqlSessionFactoryBeanName", annoAttrs.getString("sqlSessionFactoryRef"));
    }
    //Указан ли путь сканирования пакета в аннотациисередина
    List<String> basePackages = new ArrayList<>();
    basePackages.addAll(
Arrays.stream(annoAttrs.getStringArray("value")).filter(StringUtils::hasText).collect(Collectors.toList()));    basePackages.addAll(Arrays.stream(annoAttrs.getStringArray("basePackages")).filter(StringUtils::hasText)
        .collect(Collectors.toList()));
basePackages.addAll(Arrays.stream(annoAttrs.getClassArray("basePackageClasses")).map(ClassUtils::getPackageName)
        .collect(Collectors.toList()));
    //Если путь сканирования пакета не указан, выбирается путь сканирования пакета по умолчанию.
    if (basePackages.isEmpty()) {
      basePackages.add(getDefaultBasePackage(annoMeta));
    }

    String lazyInitialization = annoAttrs.getString("lazyInitialization");
    if (StringUtils.hasText(lazyInitialization)) {
      builder.addPropertyValue("lazyInitialization", lazyInitialization);
    }

    String defaultScope = annoAttrs.getString("defaultScope");
    if (!AbstractBeanDefinition.SCOPE_DEFAULT.equals(defaultScope)) {
      builder.addPropertyValue("defaultScope", defaultScope);
    }

    builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(basePackages));

    // for spring-native
    builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

    registry.registerBeanDefinition(beanName, builder.getBeanDefinition());

  }

  private static String generateBaseBeanName(AnnotationMetadata importingClassMetadata, int index) {
    return importingClassMetadata.getClassName() + "#" + MapperScannerRegistrar.class.getSimpleName() + "#" + index;
  }

  private static String getDefaultBasePackage(AnnotationMetadata importingClassMetadata) {
    return ClassUtils.getPackageName(importingClassMetadata.getClassName());
  }