静聪
静聪

Spring Boot 集成mybatis 源码解析

  Spring Boot项目中集成mybatis来开发项目，我相信每个用Spring boot 的小伙伴都使用过，感觉就是特别爽，在yml文件中配置一下，就能对数据库进行访问了，其实现原理是什么呢？带着疑问，我们走进代码。

  1. 在pom.xml文件中新增配置

    org.mybatis.spring.boot
    mybatis-spring-boot-starter
    1.3.2



    mysql
    mysql-connector-java




    org.springframework.boot
    spring-boot-starter-jdbc
  1. 在yml中添加数据库配置和mybatis配置
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/lz_test?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
    username: ldd_biz
    password: Hello1234
    initial-size: 10
    max-active: 100
    min-idle: 10
    max-wait: 60000
    pool-prepared-statements: true
    max-pool-prepared-statement-per-connection-size: 20
    time-between-eviction-runs-millis: 60000
    min-evictable-idle-time-millis: 300000
    validation-query: SELECT 1 FROM DUAL
    test-while-idle: true
    test-on-borrow: false
    test-on-return: false
    stat-view-servlet:
      enabled: true
      url-pattern: /druid/*
    filter:
      stat:
        log-slow-sql: true
        slow-sql-millis: 1000
        merge-sql: true
      wall:
        config:
          multi-statement-allow: true


mybatis:
  #实体扫描，多个package用逗号或者分号分隔
  type-aliases-package: com.example.springbootstudy.entity
  mapper-locations: classpath:mapper/*Mapper.xml
  1. 数据库脚本
CREATE TABLE `lz_test_user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键id',
  `is_delete` tinyint(4) NOT NULL DEFAULT '0' COMMENT '是否删除',
  `gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '生成时间',
  `gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
  `type` int(11) DEFAULT '0' COMMENT '0',
  `branch_id` int(11) DEFAULT NULL COMMENT '版本号',
  `real_name` varchar(256) DEFAULT NULL COMMENT '真实名称',
  `mobile` varchar(256) DEFAULT NULL COMMENT '手机号码',
  `username` varchar(256) DEFAULT NULL COMMENT '用户名',
  `task_id` int(11) DEFAULT NULL COMMENT '任务 id',
  `staff_id` int(11) DEFAULT '0' COMMENT '员工 id',
  `encrypt_flag` int(11) DEFAULT '0' COMMENT '是否加密，0 未加密，1 己加密，2其他加密算法',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=34 DEFAULT CHARSET=utf8mb4 COMMENT='项目用户';
  1. 创建实体，Mapper,Mapper.xml 测试方法
@Data
@Mapper
public class TestUser implements java.io.Serializable {
    // 主键id
    private Long id;
    //是否删除
    private Integer isDelete;
    //生成时间
    private Date gmtCreate;
    //修改时间
    private Date gmtModified;
    //0
    private Integer type;
    //版本号
    private Long branchId;
    //真实名称
    private String realName;
    //手机号码
    private String mobile;
    //用户名
    private String username;
    //任务id
    private Long taskId;
    //员工 id
    private Long staffId;
    // 是否加密，0 未加密，1 己经加密 ，2 ,3 其他加密算法，在密钥泄漏时需要
    private int encryptFlag;
}
@Mapper
public interface TestUserMapper {
    // 所有的查询条件，默认是 AND 和 = 关系，如果想在其他的关系，可以写相关的注解@OR ，或@Like
    TestUser selectTestUserById(Long id);
}




    


@RequestMapping("select")
public String select() {
    TestUser testUser = testUserMapper.selectTestUserById(14l);
    System.out.println(JSON.toJSONString(testUser));
    return "SUCESS";
}

【测试结果】
在这里插入图片描述
  因为Mybatis这一块也牵涉到太多的内容，而本文着重讲Spring Boot如何整合Mybatis的，如果有兴趣去研究MyBatis源码这一块，可以去看我的这一篇博客，https://blog.csdn.net/quyixiao/article/details/110295148，如果对本文中的一些注解的功能及源码不太理解的话，可以去看https://blog.csdn.net/quyixiao/article/details/117777543这一篇博客，因为在研究Spring Boot 整合Mybatis时，发现研究不下去，才去写Spring源码深度解析(郝佳)-Spring 常用注解使用及源码解析这一篇博客的，Spring Boot 整个体系，在了Spring源码深度解析(郝佳)-学习-Spring Boot体系原理，这一篇博客做了分析，目前万事具备了，只欠如何分析Spring Boot 整合MyBatis源码了。话不多说，直接进入主题吧。

  这基本上是一个最简单的Spring 整个mybatis的例子了，虽然例子小，但是对于小项目来说，也是可以用于生产了，那Spring Boot是如何让开发变得如此简单的呢？带着疑问，我们来看看源码如何实现。

  先从MybatisAutoConfiguration这个类看起。顾名思义，这个类就是mybatis自动配置类。

@org.springframework.context.annotation.Configuration
@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })
@ConditionalOnBean(DataSource.class)
@EnableConfigurationProperties(MybatisProperties.class)
@AutoConfigureAfter(DataSourceAutoConfiguration.class)
public class MybatisAutoConfiguration {

  private static final Logger logger = LoggerFactory.getLogger(MybatisAutoConfiguration.class);

  private final MybatisProperties properties;

  private final Interceptor[] interceptors;

  private final ResourceLoader resourceLoader;

  private final DatabaseIdProvider databaseIdProvider;

  private final List configurationCustomizers;

  public MybatisAutoConfiguration(MybatisProperties properties,
                                  ObjectProvider interceptorsProvider,
                                  ResourceLoader resourceLoader,
                                  ObjectProvider databaseIdProvider,
                                  ObjectProvider> configurationCustomizersProvider) {
    this.properties = properties;
    this.interceptors = interceptorsProvider.getIfAvailable();
    this.resourceLoader = resourceLoader;
    this.databaseIdProvider = databaseIdProvider.getIfAvailable();
    this.configurationCustomizers = configurationCustomizersProvider.getIfAvailable();
  }

  @PostConstruct
  public void checkConfigFileExists() {
    if (this.properties.isCheckConfigLocation() && StringUtils.hasText(this.properties.getConfigLocation())) {
      Resource resource = this.resourceLoader.getResource(this.properties.getConfigLocation());
      Assert.state(resource.exists(), "Cannot find config location: " + resource
          + " (please add config file or check your Mybatis configuration)");
    }
  }

  @Bean
  @ConditionalOnMissingBean
  public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
    SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
    factory.setDataSource(dataSource);
    factory.setVfs(SpringBootVFS.class);
    if (StringUtils.hasText(this.properties.getConfigLocation())) {
      factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
    }
    Configuration configuration = this.properties.getConfiguration();
    if (configuration == null && !StringUtils.hasText(this.properties.getConfigLocation())) {
      configuration = new Configuration();
    }
    if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
      for (ConfigurationCustomizer customizer : this.configurationCustomizers) {
        customizer.customize(configuration);
      }
    }
    factory.setConfiguration(configuration);
    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 (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {
      factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
    }
    if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
      factory.setMapperLocations(this.properties.resolveMapperLocations());
    }

    return factory.getObject();
  }

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


  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");

      ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);

      try {
        if (this.resourceLoader != null) {
          scanner.setResourceLoader(this.resourceLoader);
        }

        List packages = AutoConfigurationPackages.get(this.beanFactory);
        if (logger.isDebugEnabled()) {
          for (String pkg : packages) {
            logger.debug("Using auto-configuration base package '{}'", pkg);
          }
        }

        scanner.setAnnotationClass(Mapper.class);
        scanner.registerFilters();
        scanner.doScan(StringUtils.toStringArray(packages));
      } catch (IllegalStateException ex) {
        logger.debug("Could not determine auto-configuration package, automatic mapper scanning disabled.", ex);
      }
    }

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

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
      this.resourceLoader = resourceLoader;
    }
  }

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

}

  MybatisAutoConfiguration这个类实在是太重要了，今天，我们就围绕着这个类来分析，首先，我们看这个类配置了@org.springframework.context.annotation.Configuration注解，显然会被SpringBootApplication注解扫描到。来看一下SpringBootApplication注解代码

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
	...
}

  默认SpringBootApplication的ComponentScan注解扫描当前项目下所有的**.*.class的，但是其加了excludeFilters属性，配置了TypeExcludeFilter和AutoConfigurationExcludeFilter过滤器。而在Spring源码深度解析(郝佳)-Spring 常用注解使用及源码解析这篇博客也对SpringBootApplication的AutoConfigurationExcludeFilter属性做了详细分析，在AutoConfigurationExcludeFilter中会排除掉所有META-INF/spring.factories下org.springframework.boot.autoconfigure.EnableAutoConfiguration属性配置的configuration类，遗憾的是MybatisAutoConfiguration类刚好配置在mybatis-spring-boot-autoconfigure类下的META-INF/spring.factories文件中的org.springframework.boot.autoconfigure.EnableAutoConfiguration属性中，如下图所示。
Spring Boot 集成mybatis 源码解析_第1张图片

  那么MybatisAutoConfiguration的BeanDefinition是何时加入到容器中的呢？在Spring源码深度解析(郝佳)-Spring 常用注解使用及源码解析这篇博客中也分析了，在processDeferredImportSelectors方法中，获取META-INF/spring.factories下的所有org.springframework.boot.autoconfigure.EnableAutoConfiguration属性值bean，并调用processImports方法，最终将bean的BeanDefinition注入到容器中。
  接下来，我们来看MybatisAutoConfiguration的ConditionalOnClass注解的第一个属性SqlSessionFactory，显然，我们知道SqlSessionFactory是sqlSessionFactory方法配置了Bean注解，在扫描MybatisAutoConfiguration的Bean方法时，创建的BeanDefinition。那我们来看一下这和段代码的实现。

	protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
			throws IOException {

		// Recursively process any member (nested) classes first
		processMemberClasses(configClass, sourceClass);

		// Process any @PropertySource annotations
		for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), PropertySources.class,
				org.springframework.context.annotation.PropertySource.class)) {
			if (this.environment instanceof ConfigurableEnvironment) {
				processPropertySource(propertySource);
			}
			else {
				logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
						"]. Reason: Environment must implement ConfigurableEnvironment");
			}
		}

		// Process any @ComponentScan annotations
		Set componentScans = AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
		if (!componentScans.isEmpty() &&
				!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
			for (AnnotationAttributes componentScan : componentScans) {
				// The config class is annotated with @ComponentScan -> perform the scan immediately
				Set scannedBeanDefinitions =
						this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
				// Check the set of scanned definitions for any further config classes and parse recursively if needed
				for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(
							holder.getBeanDefinition(), this.metadataReaderFactory)) {
						parse(holder.getBeanDefinition().getBeanClassName(), holder.getBeanName());
					}
				}
			}
		}

		// Process any @Import annotations
		processImports(configClass, sourceClass, getImports(sourceClass), true);

		// Process any @ImportResource annotations
		if (sourceClass.getMetadata().isAnnotated(ImportResource.class.getName())) {
			AnnotationAttributes importResource =
					AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
			String[] resources = importResource.getStringArray("locations");
			Class readerClass = importResource.getClass("reader");
			for (String resource : resources) {
				String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
				configClass.addImportedResource(resolvedResource, readerClass);
			}
		}

		// Process individual @Bean methods
		Set beanMethods = retrieveBeanMethodMetadata(sourceClass);
		for (MethodMetadata methodMetadata : beanMethods) {
			configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
		}

		// Process default methods on interfaces
		processInterfaces(configClass, sourceClass);

		// Process superclass, if any
		if (sourceClass.getMetadata().hasSuperClass()) {
			String superclass = sourceClass.getMetadata().getSuperClassName();
			if (!superclass.startsWith("java") && !this.knownSuperclasses.containsKey(superclass)) {
				this.knownSuperclasses.put(superclass, configClass);
				// Superclass found, return its annotation metadata and recurse
				return sourceClass.getSuperClass();
			}
		}

		// No superclass -> processing is complete
		return null;
	}

  上述方法中，其他的方法也在https://blog.csdn.net/quyixiao/article/details/117777543这篇博客做了详细分析，但是 retrieveBeanMethodMetadata方法，是扫描@Configuration注解类中的有@Bean注解的方法，并获取其方法元数据，并返回。接下来，我们来看retrieveBeanMethodMetadata方法的具体实现。

private Set retrieveBeanMethodMetadata(SourceClass sourceClass) {
	AnnotationMetadata original = sourceClass.getMetadata();
	Set beanMethods = original.getAnnotatedMethods(Bean.class.getName());
	if (beanMethods.size() > 1 && original instanceof StandardAnnotationMetadata) {
		try {
			// 尝试通过 ASM 读取类文件以获得确定性声明顺序... 
			// 不幸的是，JVM 的标准反射以任意顺序 
			// 返回方法，即使在同一 JVM 上同一应用程序的不同运行之间也是如此。
			AnnotationMetadata asm =
					this.metadataReaderFactory.getMetadataReader(original.getClassName()).getAnnotationMetadata();
			Set asmMethods = asm.getAnnotatedMethods(Bean.class.getName());
			if (asmMethods.size() >= beanMethods.size()) {
				Set selectedMethods = new LinkedHashSet(asmMethods.size());
				for (MethodMetadata asmMethod : asmMethods) {
					for (MethodMetadata beanMethod : beanMethods) {
						if (beanMethod.getMethodName().equals(asmMethod.getMethodName())) {
							selectedMethods.add(beanMethod);
							break;
						}
					}
				}
				if (selectedMethods.size() == beanMethods.size()) {
					// All reflection-detected methods found in ASM method set -> proceed
					beanMethods = selectedMethods;
				}
			}
		}
		catch (IOException ex) {
			logger.debug("Failed to read class file via ASM for determining @Bean method order", ex);
			// No worries, let's continue with the reflection metadata we started with...
		}
	}
	return beanMethods;
}

  关于StandardAnnotationMetadata的使用，也是非常简单

public static void main(String[] args) throws IOException {
    AnnotationMetadata reflectReader = new StandardAnnotationMetadata(BeanConfig.class);
    System.out.println(reflectReader.getAnnotationTypes());
}

  网上有关StandardAnnotationMetadata的解释是
SimpleAnnotationMetadataReadingVisitor与StandardAnnotationMetadata的主要区别在于，SimpleAnnotationMetadataReadingVisitor是基于asm的实现，StandardAnnotationMetadata是基于反射的实现，那我们在使用时，应该要怎么选呢？

  由于基于反射是要先加类加载到jvm中的，因此我的判断是，如果当前类没有加载到jvm中，就使用SimpleAnnotationMetadataReadingVisitor，如果类已经加载到jvm中了，两者皆可使用。

  事实上，在spring包扫描阶段，读取类上的注解时，使用的都是SimpleAnnotationMetadataReadingVisitor，因为此时类并没有加载到jvm，如果使用StandardAnnotationMetadata读取，就会导致类提前加载。类提前加载有什么问题呢？java类是按需加载的，有的类可能在整个jvm生命周期内都没用到，如果全都加载了，就白白浪费内存了。
【总结】
  本文介绍了 AnnotationMetadata两种实现方案，yyyyyyyyyyyyy一种基于 Java 反射，另一种基于ASM 框架。

  因此上述方法主要是通过ASM技术，访问class文件，将配置了Bean注解的方法元数据返回。

  接下来，我们来看看addBeanMethod方法。

public void addBeanMethod(BeanMethod method) {
	this.beanMethods.add(method);
}

  这个方法没有什么特别我地方，只将封装好的BeanMethod对象，加入到beanMethods集合中，而beanMethods又何时使用呢？
  通过idea很快发现，只有一个地方使用了。

public Set getBeanMethods() {
	return this.beanMethods;
}

private void loadBeanDefinitionsForConfigurationClass(ConfigurationClass configClass,
		TrackedConditionEvaluator trackedConditionEvaluator) {

	if (trackedConditionEvaluator.shouldSkip(configClass)) {
		String beanName = configClass.getBeanName();
		if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
			this.registry.removeBeanDefinition(beanName);
		}
		this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
		return;
	}

	if (configClass.isImported()) {
		registerBeanDefinitionForImportedConfigurationClass(configClass);
	}
	//遍历当前configuration类的所有的配置了@Bean注解的方法
	for (BeanMethod beanMethod : configClass.getBeanMethods()) {
		loadBeanDefinitionsForBeanMethod(beanMethod);
	}
	loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
	loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}

  接下来，我们继续看是如何通过BeanMethod创建bean的BeanDefinition的呢？

private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
	ConfigurationClass configClass = beanMethod.getConfigurationClass();
	//获取Bean注解方法的元数据
	MethodMetadata metadata = beanMethod.getMetadata();
	//获得方法名
	String methodName = metadata.getMethodName();

	//判断方法是是否配置了Conditional注解，
	//如ConditionalOnBean，ConditionalOnClass，ConditionalOnMissingBean，ConditionalOnMissingClass
	//注解等，如果配置了，根据不同注解的条件，看当前BeanMethod是否跳过创建Bean
	if (this.conditionEvaluator.shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN)) {
		configClass.skippedBeanMethods.add(methodName);
		return;
	}
	if (configClass.skippedBeanMethods.contains(methodName)) {
		return;
	}


	AnnotationAttributes bean = AnnotationConfigUtils.attributesFor(metadata, Bean.class);
	//@Bean注解上是否配置名称
	List names = new ArrayList(Arrays.asList(bean.getStringArray("name")));
	//如果@Bean注解中配置了名称，则使用@Bean注解上的第一个名称作为bean在容器中的名称，
	//否则以方法名作为Bean在容器中的名称
	String beanName = (!names.isEmpty() ? names.remove(0) : methodName);
	//为Bean注册别名
	for (String alias : names) {
		this.registry.registerAlias(beanName, alias);
	}

	//当前容器中是否存在相同beanName的beanDefinition
	//如果存在，则抛出异常
	if (isOverriddenByExistingDefinition(beanMethod, beanName)) {
		if (beanName.equals(beanMethod.getConfigurationClass().getBeanName())) {
			throw new BeanDefinitionStoreException(beanMethod.getConfigurationClass().getResource().getDescription(),
					beanName, "Bean name derived from @Bean method '" + beanMethod.getMetadata().getMethodName() +
					"' clashes with bean name for containing configuration class; please make those names unique!");
		}
		return;
	}

	ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass, metadata);
	beanDef.setResource(configClass.getResource());
	beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource()));

	if (metadata.isStatic()) {
		//如果是static方法，则设置BeanClassName为configClass的类名
		beanDef.setBeanClassName(configClass.getMetadata().getClassName());
		beanDef.setFactoryMethodName(methodName);
	}
	else {
		//如果不是静态方法，则设置当前configuration bean名称
		beanDef.setFactoryBeanName(configClass.getBeanName());
		beanDef.setUniqueFactoryMethodName(methodName);
	}
	beanDef.setAutowireMode(RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
	// 设置RequiredAnnotationBeanPostProcessor的skipRequiredCheck为true
	beanDef.setAttribute("org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor.skipRequiredCheck", Boolean.TRUE);
	//处理普通注解Lazy，Primary，DependsOn，Role，Description等注解
	AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);
	// @Bean(autowire = Autowire.BY_NAME)
	Autowire autowire = bean.getEnum("autowire");
	if (autowire.isAutowire()) {
		beanDef.setAutowireMode(autowire.value());
	}

	/* initMethod和destroyMethod如下用法 
	//@Bean(initMethod="initMethod",destroyMethod = "destroyMethod")
    public ImportByBCC importByBB(){
        return new ImportByBCC();
    }
    class ImportByBCC{
        private void initMethod() {
        }
        private void destroyMethod(){         
        }
    }*/

	String initMethodName = bean.getString("initMethod");
	if (StringUtils.hasText(initMethodName)) {
		beanDef.setInitMethodName(initMethodName);
	}
	String destroyMethodName = bean.getString("destroyMethod");
	if (destroyMethodName != null) {
		beanDef.setDestroyMethodName(destroyMethodName);
	}
	//@Scope注解的使用
	ScopedProxyMode proxyMode = ScopedProxyMode.NO;
	AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(metadata, Scope.class);
	if (attributes != null) {
		beanDef.setScope(attributes.getString("value"));
		proxyMode = attributes.getEnum("proxyMode");
		if (proxyMode == ScopedProxyMode.DEFAULT) {
			proxyMode = ScopedProxyMode.NO;
		}
	}
	//如果Scope的proxyMode模式配置了ScopedProxyMode.TARGET_CLASS或ScopedProxyMode.INTERFACES
	BeanDefinition beanDefToRegister = beanDef;
	if (proxyMode != ScopedProxyMode.NO) {
		BeanDefinitionHolder proxyDef = ScopedProxyCreator.createScopedProxy(
				new BeanDefinitionHolder(beanDef, beanName), this.registry,
				proxyMode == ScopedProxyMode.TARGET_CLASS);
		beanDefToRegister = new ConfigurationClassBeanDefinition(
				(RootBeanDefinition) proxyDef.getBeanDefinition(), configClass, metadata);
	}
	if (logger.isDebugEnabled()) {
		logger.debug(String.format("Registering bean definition for @Bean method %s.%s()",
				configClass.getMetadata().getClassName(), beanName));
	}
	this.registry.registerBeanDefinition(beanName, beanDefToRegister);
}

  其实这个方法的重点是讲BeanDefinition设置setFactoryBeanName为当前ConfigureClass 和FactoryMethodName，Bean注解修饰的方法为FactoryMethod方法，方法所在的Class为FactoryBean。而关于Scope注解的使用，在另外一篇博客Spring @Bean @Scope注解 proxyMode的组合使用及源码解析。

  下面，我们来看看sqlSessionFactory Bean的实例化。

@org.springframework.context.annotation.Configuration
@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })
@ConditionalOnBean(DataSource.class)
@EnableConfigurationProperties(MybatisProperties.class)
@AutoConfigureAfter(DataSourceAutoConfiguration.class)
public class MybatisAutoConfiguration {

  private final MybatisProperties properties;

  public MybatisAutoConfiguration(MybatisProperties properties,
                                  ObjectProvider interceptorsProvider,
                                  ResourceLoader resourceLoader,
                                  ObjectProvider databaseIdProvider,
                                  ObjectProvider> configurationCustomizersProvider) {
    this.properties = properties;
    this.interceptors = interceptorsProvider.getIfAvailable();
    this.resourceLoader = resourceLoader;
    this.databaseIdProvider = databaseIdProvider.getIfAvailable();
    this.configurationCustomizers = configurationCustomizersProvider.getIfAvailable();
  }

@Bean
@ConditionalOnMissingBean
public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
  SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
  factory.setDataSource(dataSource);
  factory.setVfs(SpringBootVFS.class);
  if (StringUtils.hasText(this.properties.getConfigLocation())) {
    factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
  }
  Configuration configuration = this.properties.getConfiguration();
  if (configuration == null && !StringUtils.hasText(this.properties.getConfigLocation())) {
    configuration = new Configuration();
  }
  if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
    for (ConfigurationCustomizer customizer : this.configurationCustomizers) {
      customizer.customize(configuration);
    }
  }
  factory.setConfiguration(configuration);
  if (this.properties.getConfigurationProperties() != null) {
    factory.setConfigurationProperties(this.properties.getConfigurationProperties());
  }
  //设置插件拦截器
  if (!ObjectUtils.isEmpty(this.interceptors)) {
    factory.setPlugins(this.interceptors);
  }
  //数据库id,如MYSQL,oracle等
  if (this.databaseIdProvider != null) {
    factory.setDatabaseIdProvider(this.databaseIdProvider);
  }
  //设置xml中使用到的别名类，所在包
  if (StringUtils.hasLength(this.properties.getTypeAliasesPackage())) {
    factory.setTypeAliasesPackage(this.properties.getTypeAliasesPackage());
  }
  //设置类型处理器所在的包位置
  if (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {
    factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
  }
  //设置Mapper所在位置
  if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
    factory.setMapperLocations(this.properties.resolveMapperLocations());
  }

  return factory.getObject();
}

  从sqlSessionFactory方法中可以看到，整个方法都是围绕着属性文件properties来赋值的，在Spring源码深度解析(郝佳)-Spring 常用注解使用及源码解析在篇博客中，我们就己经详细的解析了EnableConfigurationProperties注解源码，只要配置了EnableConfigurationProperties注解，Spring会自动通过getProperty方法从环境中获取参数，并设置到MybatisProperties属性中，而yml中刚好设置了MybatisProperties对象的属性值。

mybatis:
  type-aliases-package: com.example.springbootstudy.entity
  mapper-locations: classpath:mapper/*Mapper.xml

  而命名规则，则去掉-，以驼峰命名映射，如type-aliases-package对应的是MybatisProperties的typeAliasesPackage属性，而mapper-locations对应的是mapperLocations属性。

  而细心的读者有没有发现，假如先实例化sqlSessionFactory的bean，后面实例化MybatisAutoConfiguration对象，properties属性值不就为空了嘛。这种情况会不会发生呢？我们在MybatisAutoConfiguration构造函数中打一个断点。


  追踪方法调用栈，发现在bean实例化时调用了instantiateUsingFactoryMethod方法

  而在实例化bean时，从BeanDefinition中，发现有FactoryBean，则先实例化FactoryBean，再调用factoryBean的factoryMethod来实例化当前bean。显然，无论如何MybatisAutoConfiguration总比SqlSessionFactory先实例化。因此properties属性不可能为空。而loadBeanDefinitionsForBeanMethod方法里面有一个重要的设置，就是为当前BeanMethod设置FactoryBeanName和FactoryMethodName。
  接来下，我们继续看SqlSessionFactoryBean的getObject方法的内部实现。

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");

  this.sqlSessionFactory = 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);
}
public SqlSessionFactory build(Configuration config) {
  return new DefaultSqlSessionFactory(config);
}

  这个方法，实际是属性mybatis源码这一块了，前面主要是将Spring boot配置文件中的配置信息设置到configuration中，前部分根据settings，typeAliases，typeHandlers，plugins，objectFactory，objectWrapperFactory等配置信息设置到configuration中，后部分主要是对Mapper.xml进行parse操作，关于parse操作，在我的MyBatis源码解析系列也做了详细的解析，这里就不再赘述，而Mapper.xml中的一个个元素最终被解析成mapperStatement存储到configuration的属性中。而configuration对于mybatis而言，相当于一个配置的内存数据库。所有与mybatis相关的配置都存储到了Configuration中，而最终容器sqlSessionFactory是DefaultSqlSessionFactory对象，configuration就在创建对象时设置到DefaultSqlSessionFactory的configuration属性中。

  而sqlSessionFactory实例化，主要是将yml或properties配置文件的内容设置到SqlSessionFactoryBean中，可能大家对这一块有点陌生了，我们来看看用mybatis-config.xml是如何来配置这些参数的。

  我们看了mybatis原生配置文件后，你会觉得，无非是将mybatis-config.xml配置文件中的内容移植到了Spring boot的yml或properties文件中而已。

  接下来，我们继续来看sqlSessionFactory方法上的ConditionalOnMissingBean注解，这个注解的意思 ，就是说当前容器中存在SqlSessionFactory的bean，容器将不会调用sqlSessionFactory()方法实例化SqlSessionFactory，那什么时候会出现SqlSessionFactory被实例化了呢？我们先来看一个例子。
  先注释掉yml配置文件中的mybatis配置信息
  #mybatis:
  # 实体扫描，多个package用逗号或者分号分隔
  # type-aliases-package: com.example.springbootstudy.entity
  # mapper-locations: classpath:mapper/*Mapper.xml

  自定义SqlSessionFactoryBean。

@Configuration
public class SqlSessionFactoryBeanConfig {
    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        sqlSessionFactoryBean.setVfs(SpringBootVFS.class);
        sqlSessionFactoryBean.setTypeAliasesPackage("com.example.springbootstudy.entity");
        sqlSessionFactoryBean.setMapperLocations(resolveMapperLocations(new String [] {"classpath:mapper/*Mapper.xml"}));
        return sqlSessionFactoryBean;
    }


    public Resource[] resolveMapperLocations(String [] mapperLocations) {
        ResourcePatternResolver resourceResolver = new PathMatchingResourcePatternResolver();
        List resources = new ArrayList();
        if (mapperLocations != null) {
            for (String mapperLocation : mapperLocations) {
                try {
                    Resource[] mappers = resourceResolver.getResources(mapperLocation);
                    resources.addAll(Arrays.asList(mappers));
                } catch (IOException e) {
                    // ignore
                }
            }
        }
        return resources.toArray(new Resource[resources.size()]);
    }
}

  而此时MybatisAutoConfiguration的sqlSessionFactory方法将不再执行，为什么呢？聪明的读者肯定会想到是我们自己创建了SqlSessionFactoryBean导致的，从名字上可以看出。SqlSessionFactoryBean不就是SqlSessionFactory的Bean工厂嘛。先看一下SqlSessionFactoryBean的getObject方法，getObject方法返回的是SqlSessionFactory，确定无疑了。但是sqlSessionFactory什么时候初始化呢？从getObject方法得知，如果sqlSessionFactory为空，则调用afterPropertiesSet方法初始化sqlSessionFactory。

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

  确定是调用getObject方法时实例化的吗？先来看一下SqlSessionFactoryBean类结构 。

Spring Boot 集成mybatis 源码解析_第2张图片
  其中实现了InitializingBean接口非常重要，而这个接口中的afterPropertiesSet方法，是bean生命周期中必走的方法。下面来看一下Bean的生命周期流程图。
Spring Boot 集成mybatis 源码解析_第3张图片
  也就是说，在SqlSessionFactoryBean实例化过程中，肯定会实例化sqlSessionFactory。因此。getObject方法中调用afterPropertiesSet，只是为了保险起见而己，一般在调用getObject方法时，sqlSessionFactory不可能为空。
  因为SqlSessionFactoryBean是sqlSessionFactory的工厂bean，而在实例化SqlSessionFactoryBean过程中，会将sqlSessionFactory注册到容器中，而由于ConditionalOnMissingBean的作用，因此MybatisAutoConfiguration的sqlSessionFactory()方法不会再执行。
  接下来，我们来看MybatisAutoConfiguration中的另外一个方法。

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

  这个方法非常重要，又非常有意思，为什么非常重要呢？因为其中的Import注解，只要配置了Import注解，AutoConfiguredMapperScannerRegistrar类就会被注入到容器中，即使AutoConfiguredMapperScannerRegistrar是一个普通类，没有任何注解，而为什么会有意思呢？如果容器中有MapperFactoryBean，则MapperScannerRegistrarNotFoundConfiguration不会被实例化，当容器中没有MapperFactoryBean 的bean时，会实例化MapperScannerRegistrarNotFoundConfiguration，并且在实例化地过程中，只打印一条日志说并没有发现MapperFactoryBean 的bean。
  接下来，我们来看非常重要的部分，AutoConfiguredMapperScannerRegistrar。

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");
    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
    try {
      if (this.resourceLoader != null) {
        scanner.setResourceLoader(this.resourceLoader);
      }
	  //获取默认的Spring Boot 启动类所在的包位置
      List packages = AutoConfigurationPackages.get(this.beanFactory);
      if (logger.isDebugEnabled()) {
        for (String pkg : packages) {
          logger.debug("Using auto-configuration base package '{}'", pkg);
        }
      }
      //设置扫描的类中，需要配置Mapper注解
      scanner.setAnnotationClass(Mapper.class);
      //设置过滤器
      scanner.registerFilters();
      //开始扫描包下的所有类
      scanner.doScan(StringUtils.toStringArray(packages));
    } catch (IllegalStateException ex) {
      logger.debug("Could not determine auto-configuration package, automatic mapper scanning disabled.", ex);
    }
  }
  @Override
  public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    this.beanFactory = beanFactory;
  }
  @Override
  public void setResourceLoader(ResourceLoader resourceLoader) {
    this.resourceLoader = resourceLoader;
  }
}

private static final String BEAN = AutoConfigurationPackages.class.getName();
public static List get(BeanFactory beanFactory) {
    try {
        return beanFactory.getBean(BEAN, BasePackages.class).get();
    }
    catch (NoSuchBeanDefinitionException ex) {
        throw new IllegalStateException(
                "Unable to retrieve @EnableAutoConfiguration base packages");
    }
}

  大家可能比较困惑，为什么通过AutoConfigurationPackages.get(this.beanFactory)方法，就能获取到当前Spring Boot 启动类所在的包呢？我们再来看SpringBootStudyApplication启动类上的SpringBootApplication注解。这不就是一个普通的注解嘛，有什么玄机呢？请听我慢慢道来。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
    ...
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(EnableAutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
...
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
...
}

  我们在Spring源码深度解析(郝佳)-Spring 常用注解使用及源码解析这篇博客就己经分析过。在Spring启动时，会通过processImports方法，递归扫描Bean的注解中是否在Import注解。接来下，我们看其对Import注解中的内容如何处理。

  如果Import的内容是ImportBeanDefinitionRegistrar或其实现类，则加入到configClass的importBeanDefinitionRegistrars的属性中，而此时ConfigurationClass就是我们的启动类SpringBootStudyApplication。接着继续来看。

  在加载configClasses中有一个重要的方法loadBeanDefinitionsForConfigurationClass。如下

private void loadBeanDefinitionsForConfigurationClass(ConfigurationClass configClass,
        TrackedConditionEvaluator trackedConditionEvaluator) {

    if (trackedConditionEvaluator.shouldSkip(configClass)) {
        String beanName = configClass.getBeanName();
        if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
            this.registry.removeBeanDefinition(beanName);
        }
        this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
        return;
    }

    if (configClass.isImported()) {
        registerBeanDefinitionForImportedConfigurationClass(configClass);
    }
    for (BeanMethod beanMethod : configClass.getBeanMethods()) {
        loadBeanDefinitionsForBeanMethod(beanMethod);
    }
    loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
    loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}

  功夫不负有心人，终于看到了importBeanDefinitionRegistrars被使用了。我们继续跟进代码。

private void loadBeanDefinitionsFromRegistrars(Map registrars) {
    for (Map.Entry entry : registrars.entrySet()) {
        entry.getKey().registerBeanDefinitions(entry.getValue(), this.registry);
    }
}


@Order(Ordered.HIGHEST_PRECEDENCE)
static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
        register(registry, new PackageImport(metadata).getPackageName());
    }

    @Override
    public Set determineImports(AnnotationMetadata metadata) {
        return Collections.singleton(new PackageImport(metadata));
    }
}
 
  
  在addImportBeanDefinitionRegistrar方法调用得知，importBeanDefinitionRegistrars的key为registrar，而value为configClass的元数据信息。而最终调用register，使用的metadata其实是启动类SpringBootStudyApplication的类元数据 。而接来下，我们来看看new PackageImport(metadata).getPackageName()这行代码的整体实现。
 
  
private final static class PackageImport {
    private final String packageName;
    PackageImport(AnnotationMetadata metadata) {
        this.packageName = ClassUtils.getPackageName(metadata.getClassName());
    }
    public String getPackageName() {
        return this.packageName;
    }
}

 
  
  上述代码实现很简单，就是获取元数据类所在的包名。
   接下来，我们继续来看register方法的内部实现。
 
  
public static void register(BeanDefinitionRegistry registry, String... packageNames) {
    if (registry.containsBeanDefinition(BEAN)) {
        BeanDefinition beanDefinition = registry.getBeanDefinition(BEAN);
        ConstructorArgumentValues constructorArguments = beanDefinition
                .getConstructorArgumentValues();
        constructorArguments.addIndexedArgumentValue(0,
                addBasePackages(constructorArguments, packageNames));
    }
    else {
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        beanDefinition.setBeanClass(BasePackages.class);
        beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(0,
                packageNames);
        beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        registry.registerBeanDefinition( BEAN, beanDefinition);
    }
}

 
  
  上述方法实现也非常简单，无非就是注册BasePackages的BeanDefinition到容器中，但是需要注意的一点就是，将启动类的包名作为BasePackages的构造函数参数注入，接下来，我们来看看BasePackages的内部实现。
 
  
static final class BasePackages {

    private final List packages;

    private boolean loggedBasePackageInfo;

    BasePackages(String... names) {
        List packages = new ArrayList();
        for (String name : names) {
            if (StringUtils.hasText(name)) {
                packages.add(name);
            }
        }
        this.packages = packages;
    }

    public List get() {
        if (!this.loggedBasePackageInfo) {
            if (this.packages.isEmpty()) {
                if (logger.isWarnEnabled()) {
                    logger.warn("@EnableAutoConfiguration was declared on a class "
                            + "in the default package. Automatic @Repository and "
                            + "@Entity scanning is not enabled.");
                }
            }
            else {
                if (logger.isDebugEnabled()) {
                    String packageNames = StringUtils
                            .collectionToCommaDelimitedString(this.packages);
                    logger.debug("@EnableAutoConfiguration was declared on a class "
                            + "in the package '" + packageNames
                            + "'. Automatic @Repository and @Entity scanning is "
                            + "enabled.");
                }
            }
            this.loggedBasePackageInfo = true;
        }
        return this.packages;
    }
}

 
  
  除去日志不看，上面的方法也非常简单，因为在创建Bean的时候，设置了构造函数参数值为启动类所在的包名，所以调用get方法，实际上返回就是启动类的包名。
   按这么说，只要修改启动类所在位置，Mapper注解的类将不会被注入到容器中。来测试一把。
 
   显然，换了启动类的所在包的位置，出现了各种问题。
 Spring Boot 集成mybatis 源码解析_第4张图片
   可能项目访问都访问不了。
   接下来，我们继续来看registerFilters方法。
 
  
public void registerFilters() {
  boolean acceptAllInterfaces = true;
  if (this.annotationClass != null) {
  	//设置Mapper注解
    addIncludeFilter(new AnnotationTypeFilter(this.annotationClass));
    acceptAllInterfaces = false;
  }
  //如果指定了接口实现
  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类名结尾的类
  addExcludeFilter(new TypeFilter() {
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
      String className = metadataReader.getClassMetadata().getClassName();
      return className.endsWith("package-info");
    }
  });
}

 
  
  对于默认的Spring Boot 加载Mapper类而言，就是扫描启动类所在的包下配置了Mapper注解类，并为Mapper类创建BeanDefinition注册到容器中。
 
  
public Set doScan(String... basePackages) {
  //扫描包下的所有符合条件的类，并获取BeanDefinition
  Set 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;
}

private void processBeanDefinitions(Set 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");
    }
	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() + "'.");
      }
      //bean通过类型注入
      definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
    }
  }
}

 
  
  如果当前ClassPathMapperScanner中有sqlSessionFactoryBeanName或sqlSessionTemplateBeanName以及addToConfig参数，则为当前Mapper的BeanDefinition设置这些参数，如果没有sqlSessionFactory和sqlSessionTemplate相关参数，则按类型注入。关于这些参数该如何配置呢？
   我们在生产环境中，不可能每个Mapper都去配置@Mapper注解，而我们使用统一的@MapperScan注解来指定Mapper所在的包。会将MapperScan所指定包下的所有Bean的相关BeanDefinition都注册到容器中，接下来，我们来看看@MapperScan注解及使用。
 
  
  注释掉TestUserMapper上的注解Mapper
   在启动类SpringBootStudyApplication上添加@MapperScan(basePackages = { “com.example.springbootstudy” })注解。
   在之前，我们先来看一下MapperScan注解源码。
 
  
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(MapperScannerRegistrar.class)
public @interface MapperScan {
  //指定包名
  String[] value() default {};
  //指定包名
  String[] basePackages() default {};
  //指定类数组
  Class[] basePackageClasses() default {};

  Class nameGenerator() default BeanNameGenerator.class;
	
  //指定注解类型
  Class annotationClass() default Annotation.class;

  //指定实现的接口
  Class markerInterface() default Class.class;

  //指定sqlSessionTeamplate
  String sqlSessionTemplateRef() default "";
  //指定sqlSessionFactory
  String sqlSessionFactoryRef() default "";
  //指定 Mapper工厂Bean
  Class factoryBean() default MapperFactoryBean.class;
}

 
  
  我们一般情况下，都是使用指定包名称，扫描包下所有的Bean，而其他属性，我们用得少之又少，下面我们来看一个其他属性的使用。先来看看markerInterface属性使用。
 
  
public interface BaseMapper {
}

public interface TestUserMapper  extends BaseMapper{
    TestUser selectTestUserById(Long id);
}

@SpringBootApplication
@MapperScan(value = "com.example.springbootstudy",markerInterface = BaseMapper.class)
public class SpringBootStudyApplication {
    ... 省略
}

@RequestMapping("select")
public String select() {
	helloService.sayHello();
    TestUser testUser = testUserMapper.selectTestUserById(14l);
    System.out.println(JSON.toJSONString(testUser));
    return "SUCESS";
}

 
  
  执行结果
 
 
  
  可能有人会想，你不加markerInterface属性，执行结果也一样嘛。
   我们去掉markerInterface属性看看。
 
   显然执行结果异常，当将包配置成com.example.springbootstudy.mapper时，执行结果如下。
 
   显然是因为包的扫描范围导致的异常，Spring区分不出HelloService和TestUserMapper接口，哪个是业务类，哪个是Mybatis Mapper类，因此，Spring 一股脑的将其的FactoryBean设置成了MapperFactoryBean，因此导致了以上异常。看下图。
 
   因为设置了HelloService的FactoryBean为MapperFactoryBean，导致在实例化时，创建的Bean是MapperProxy的代理。
 
   调用HelloService的sayHello()方法当然就会出现异常。
   通过例子，我们终于知道了markerInterface使用场景，假如Mapper扫描的包无法精确配置时，而MyBatis的Mapper都实现了一个统一的接口BaseMapper，因此，此时就可以使用markerInterface参数，来排除掉和MyBatis无关的类。
   接下来，我们来看看annotationClass属性使用
 
  
@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE, ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER })
public @interface MyMapper {


}



@MyMapper
public interface TestUserMapper  {

    TestUser selectTestUserById(Long id);
}


@SpringBootApplication
@MapperScan(value = "com.example.springbootstudy",annotationClass = MyMapper.class)
public class SpringBootStudyApplication {
    ...
}

 
  
在这里插入图片描述
   使用场景和markerInterface一样，只是根据具体的业务需求来做具体实现，MapperScan注解使用这一块，就到这里了，我们接下来分析源码又是如何实现的呢？
 
  
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(MapperScannerRegistrar.class)
public @interface MapperScan {
... 省略
}

 
  
  MapperScan上配置了@Import(MapperScannerRegistrar.class)，在Spring启动时，会调用Registrar的registerBeanDefinitions方法，对这一块的逻辑，我们之前不知道分析过多少遍了，这里就不再赘述了，直接进入registerBeanDefinitions方法。
 
  
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

  AnnotationAttributes annoAttrs = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
  ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);

  if (resourceLoader != null) {
    scanner.setResourceLoader(resourceLoader);
  }

  Class annotationClass = annoAttrs.getClass("annotationClass");
  if (!Annotation.class.equals(annotationClass)) {
    scanner.setAnnotationClass(annotationClass);
  }

  Class markerInterface = annoAttrs.getClass("markerInterface");
  if (!Class.class.equals(markerInterface)) {
    scanner.setMarkerInterface(markerInterface);
  }

  Class generatorClass = annoAttrs.getClass("nameGenerator");
  if (!BeanNameGenerator.class.equals(generatorClass)) {
    scanner.setBeanNameGenerator(BeanUtils.instantiateClass(generatorClass));
  }

  Class mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");
  if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {
    scanner.setMapperFactoryBean(BeanUtils.instantiateClass(mapperFactoryBeanClass));
  }

  scanner.setSqlSessionTemplateBeanName(annoAttrs.getString("sqlSessionTemplateRef"));
  scanner.setSqlSessionFactoryBeanName(annoAttrs.getString("sqlSessionFactoryRef"));

  List basePackages = new ArrayList();
  for (String pkg : annoAttrs.getStringArray("value")) {
    if (StringUtils.hasText(pkg)) {
      basePackages.add(pkg);
    }
  }
  for (String pkg : annoAttrs.getStringArray("basePackages")) {
    if (StringUtils.hasText(pkg)) {
      basePackages.add(pkg);
    }
  }
  for (Class clazz : annoAttrs.getClassArray("basePackageClasses")) {
    basePackages.add(ClassUtils.getPackageName(clazz));
  }
  //注册过滤器
  scanner.registerFilters();
  //扫描BeanDefinition
  scanner.doScan(StringUtils.toStringArray(basePackages));
}

 
  
  registerBeanDefinitions方法的内部实现也非常简单，无非就是将MapperScan注解中配置的内容设置到ClassPathMapperScanner中，再调用其doScan方法而已。
 
  
  在processBeanDefinitions方法中，有一行非常重要的代码，就是
   definition.setBeanClass(this.mapperFactoryBean.getClass());
   mapperFactoryBean默认就是MapperFactoryBean类，这就意味着每个Mapper的FactoryBean就是MapperFactoryBean。接下来，我们来看看MapperFactoryBean的内部实现。在看内部实现之前，先来看一个类关系。
 Spring Boot 集成mybatis 源码解析_第5张图片
   接下来，我们来看源码。
 
  
public abstract class DaoSupport implements InitializingBean {
    protected final Log logger = LogFactory.getLog(getClass());

    @Override
    public final void afterPropertiesSet() throws IllegalArgumentException, BeanInitializationException {
        checkDaoConfig();
        try {
            initDao();
        }
        catch (Exception ex) {
            throw new BeanInitializationException("Initialization of DAO failed", ex);
        }
    }
    
    protected abstract void checkDaoConfig() throws IllegalArgumentException;

    protected void initDao() throws Exception {
    }
}

public abstract class SqlSessionDaoSupport extends DaoSupport {
  private SqlSession sqlSession;
  private boolean externalSqlSession;

  public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
    if (!this.externalSqlSession) {
      this.sqlSession = new SqlSessionTemplate(sqlSessionFactory);
    }
  }

  public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
    this.sqlSession = sqlSessionTemplate;
    this.externalSqlSession = true;
  }

  public SqlSession getSqlSession() {
    return this.sqlSession;
  }

  @Override
  protected void checkDaoConfig() {
    notNull(this.sqlSession, "Property 'sqlSessionFactory' or 'sqlSessionTemplate' are required");
  }
}


public class MapperFactoryBean extends SqlSessionDaoSupport implements FactoryBean {
  private Class mapperInterface;

  private boolean addToConfig = true;

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

  @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();
      }
    }
  }
  @Override
  public T getObject() throws Exception {
    return getSqlSession().getMapper(this.mapperInterface);
  }

  省略...
}

 
  
  这三个类，我们先从属性入手，因为有setSqlSessionFactory和setSqlSessionTemplate方法，因此，在Bean的初始化时会填充，我们之前分析过创建好的DefaultSqlSessionFactory。再来看MapperFactoryBean有两个构造方法，会调用哪一个呢？再回头来看processBeanDefinitions方法，在这个方法中有一行：
   definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName());
   将解析到的BeanClassName作为mapperFactoryBean的构造函数参数，因此在实例化时，肯定是调用带参数的构造方法，同时设置了mapperInterface为Mapper的类名称。因为MapperFactoryBean实现了InitializingBean接口，因此在Bean的生命周期中会调用afterPropertiesSet方法，再次回头来看Spring Bean的生命周期图。
 
  
Spring Boot 集成mybatis 源码解析_第6张图片
   而在afterPropertiesSet方法中，做一两件事情，第一件整改，对sqlSessionFactory较验，如果为空，抛出异常，较验通过后，将当前接口加入到configuration的Mapper中，容器中存储的Mapper是最终调用getObject方法返回值，接下来，我们来看看getObject方法内部又是如何实现的。
 
  
public  T getMapper(Class type) {
  return getConfiguration().getMapper(type, this);
}


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


public  T getMapper(Class type, SqlSession sqlSession) {
  final MapperProxyFactory mapperProxyFactory = (MapperProxyFactory) 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);
  }
}

public T newInstance(SqlSession sqlSession) {
  final MapperProxy mapperProxy = new MapperProxy(sqlSession, mapperInterface, methodCache);
  return newInstance(mapperProxy);
}

protected T newInstance(MapperProxy mapperProxy) {
  return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}

 
  
  从最终结果来看，返回的是一个MapperProxy的JDK代理。而最终所有的Mapper方法的调用逻辑都在MapperProxy的invoke方法中。
 
  
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  try {
    if (Object.class.equals(method.getDeclaringClass())) {
      return method.invoke(this, args);
    } else if (isDefaultMethod(method)) {
      return invokeDefaultMethod(proxy, method, args);
    }
  } catch (Throwable t) {
    throw ExceptionUtil.unwrapThrowable(t);
  }
  final MapperMethod mapperMethod = cachedMapperMethod(method);
  return mapperMethod.execute(sqlSession, args);
}

 
  
  当我们配置@MapperScan扫描路径不正确时，此时会调用HelloService的 mapperMethod 的cachedMapperMethod 方法，肯定会报错，接下来，我们来看看HelloService出错原因。
 
 
  

   简单的来讲，也就是说HelloService没有对应的MappedStatement，更直白的来讲，就是说HelloService接口没有对应的Mapper.xml，可能有读者又会问了，那接口和Mapper.xml又是如何关联起来的呢？
 Spring Boot 集成mybatis 源码解析_第7张图片
   细心的读者肯定会发现，Mapper.xml和Mapper接口，就是通过mapper标签的namespace关联起来的，在之前的Mybatis系列博客中对这一块讲得很透彻了，这里也就再赘述。关于Spring Boot整合MyBatis这一块，好像己经解析完了，好像还漏了什么东西，那就是DataSource这一块。Datasource又是如何注入的呢？
 
  
  同样是看MybatisAutoConfiguration类。
 
  
@org.springframework.context.annotation.Configuration
@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })
@ConditionalOnBean(DataSource.class)
@EnableConfigurationProperties(MybatisProperties.class)
@AutoConfigureAfter(DataSourceAutoConfiguration.class)
public class MybatisAutoConfiguration {
... 省略
}

 
  
  因为MybatisAutoConfiguration配置了AutoConfigureAfter注解。证明DataSourceAutoConfiguration一定配置在classpath下的META-INF/spring.factories文件内，而DataSourceAutoConfiguration还在MybatisAutoConfiguration先实例化，之前我们也分析过，MybatisAutoConfiguration肯定比SqlSessionFactory先实例化，因此，sqlSessionFactory(DataSource dataSource)方法的dataSource参数，可能在DataSourceAutoConfiguration中，这只是我们的猜测，下面，来分析我们的猜测。
 
   所以，Spring Boot在启动时，会默认扫描DataSourceAutoConfiguration下的Bean。
 
  
@Configuration
@Conditional(PooledDataSourceCondition.class)
@ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
@Import({ DataSourceConfiguration.Tomcat.class, DataSourceConfiguration.Hikari.class,
        DataSourceConfiguration.Dbcp.class, DataSourceConfiguration.Dbcp2.class,
        DataSourceConfiguration.Generic.class })
@SuppressWarnings("deprecation")
protected static class PooledDataSourceConfiguration {

}

 
  
  为了证实猜想，我们在DataSourceConfiguration.Tomcat的dataSource方法中打一个断点。
 
   显然，程序进入断点，而关键代码是createDataSource方法，我们进入这个方法看看。
 
  
protected  T createDataSource(DataSourceProperties properties,
        Class type) {
    return (T) properties.initializeDataSourceBuilder().type(type).build();
}

public DataSource build() {
    Class type = getType();
    DataSource result = BeanUtils.instantiate(type);
    //如果yml中没有配置没有driverClassName属性，从url中获取driverClassName属性
    maybeGetDriverClassName();
    bind(result);
    return result;
}

private void bind(DataSource result) {
    MutablePropertyValues properties = new MutablePropertyValues(this.properties);
    //为属性命别名
    new RelaxedDataBinder(result).withAlias("url", "jdbcUrl")
            .withAlias("username", "user").bind(properties);
}

public void bind(PropertyValues pvs) {
    MutablePropertyValues mpvs = (pvs instanceof MutablePropertyValues) ?
            (MutablePropertyValues) pvs : new MutablePropertyValues(pvs);
    doBind(mpvs);
}

protected void doBind(MutablePropertyValues mpvs) {
    checkAllowedFields(mpvs);
    checkRequiredFields(mpvs);
    applyPropertyValues(mpvs);
}

 
  
  上述代码，始终围绕着如何将yml配置文件中的配置，设置到Datasource的属性中去。而比较复杂的代码就是applyPropertyValues方法了，但是最终都是将yml中配置的数据库相关的属性注入到DataSource的poolProperties属性中。当Datasource创建成功后，会调用getValidationQuery方法，获取验证sql(/* ping */ SELECT 1)，并最终调用setTestOnBorrow()方法判断Datasource是否创建成功。
 
  
  大家可能又会想，你这个解析不太有用，因为，我们一般不用org.apache.tomcat.jdbc.pool.DataSource，用是用阿里的com.alibaba.druid.pool.DruidDataSource。接下来，我们来分析一下阿里的DruidDataSource在Spring Boot时，是如何初始化的，导入druid-spring-boot-starter的pom.xml在原来的配置文件中添加type配置，如下。
 
  

    com.alibaba
    druid-spring-boot-starter
    1.1.13


spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    druid:
      url: jdbc:mysql://172.16.157.238:3306/lz_test?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8
      username: ldd_biz
      password: Hello1234
      initial-size: 10
      max-active: 10
      min-idle: 5
      max-wait: 60000
      pool-prepared-statements: true
      max-pool-prepared-statement-per-connection-size: 20
      time-between-eviction-runs-millis: 60000
      min-evictable-idle-time-millis: 300000
      #Oracle需要打开注释
      validation-query: SELECT 1
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      stat-view-servlet:
        enabled: true
        url-pattern: /druid/*
        login-username: admin
        login-password: admin
      filter:
        stat:
          log-slow-sql: true
          slow-sql-millis: 1000
          merge-sql: false
        wall:
          config:
            multi-statement-allow: true

 
  
  其实理解了org.apache.tomcat.jdbc.pool.DataSource的创建过程，再来看DruidDataSource的创建，那就非常简单了。
   先来看META-INF
 Spring Boot 集成mybatis 源码解析_第8张图片
   我们先来看看DruidDataSourceAutoConfigure 类
 
  
@Configuration
@ConditionalOnClass(DruidDataSource.class)
@AutoConfigureBefore(DataSourceAutoConfiguration.class)
@EnableConfigurationProperties({DruidStatProperties.class, DataSourceProperties.class})
@Import({DruidSpringAopConfiguration.class,
    DruidStatViewServletConfiguration.class,
    DruidWebStatFilterConfiguration.class,
    DruidFilterConfiguration.class})
public class DruidDataSourceAutoConfigure {

    private static final Logger LOGGER = LoggerFactory.getLogger(DruidDataSourceAutoConfigure.class);

    @Bean(initMethod = "init")
    @ConditionalOnMissingBean
    public DataSource dataSource() {
        LOGGER.info("Init DruidDataSource");
        return new DruidDataSourceWrapper();
    }
}

 
  
  先来看看AutoConfigureBefore注解，DruidDataSourceAutoConfigure的AutoConfigureBefore注解中配置了DataSourceAutoConfiguration类，Spring Boot这么做的意图是什么呢？我们在之前的博客中知道。系统默认的Datasource是在DataSourceAutoConfiguration的PooledDataSourceConfiguration静态内部类的Import注解中DataSourceConfiguration.Tomcat bean的dataSource方法注册org.apache.tomcat.jdbc.pool.DataSource的。因此只要DruidDataSourceAutoConfigure比DataSourceAutoConfiguration先实例化。DataSourceConfiguration.Tomcat就不会被实例化。
   要得出上面的结论，可能有小伙伴觉得有点牵强，其实我也觉得牵强。
   但是上面有一点，无须置疑的一点是，DruidDataSourceAutoConfigure比DataSourceAutoConfiguration先实例化，那么在实例化DataSourceAutoConfiguration的内部类PooledDataSourceConfiguration时，肯定己经存在dataSource了，再来看PooledDataSourceConfiguration的配置。
 
  
@Configuration
@Conditional(PooledDataSourceCondition.class)
@ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
@Import({ DataSourceConfiguration.Tomcat.class, 
DataSourceConfiguration.Hikari.class,
        DataSourceConfiguration.Dbcp.class, DataSourceConfiguration.Dbcp2.class,
        DataSourceConfiguration.Generic.class })
@SuppressWarnings("deprecation")
protected static class PooledDataSourceConfiguration {

}

 
  
  我们知道，因为配置了ConditionalOnMissingBean注解，注解中有DataSource，ConditionalOnMissingBean注解的意思是，只要存在DataSource和XADataSource任意一个，PooledDataSourceConfiguration就不会被注入到容器中，但是疑问在于PooledDataSourceConfiguration不会被注入，那他Import中的Bean会被注入吗？如果会被注入，那我们之前说的DataSourceConfiguration.Tomcat不会被实例化容器中的结论就是错误的。
   下面我们来看一个例子。
 
  
     
   
  1.  
    在META-INF/spring.factories中配置
     org.springframework.boot.autoconfigure.EnableAutoConfiguration=
     com.example.springbootstudy.service.impl.ConfigurationTestA,
     com.example.springbootstudy.service.impl.ConfigurationTestA.ConfigurationTestB
     
    2.  
   
  2.  
    创建config配置文件
     
    3.  
  
 
  
public class ImportTestA {

    public ImportTestA() {
        System.out.println("ImportTestA实例化");
    }
}

@Configuration
public class ConfigurationTestA {

    public ConfigurationTestA() {
        System.out.println("ConfigurationTestA实例化");
    }
    
    @Configuration
    @Import(ImportTestA.class)
    @ConditionalOnMissingBean({ DataSource.class })
    class ConfigurationTestB {
        public ConfigurationTestB() {
            System.out.println("ConfigurationTestB 实例化");
        }
    }
}

 
  
  启动项目
 
 3. 去掉ConfigurationTestB上的@ConditionalOnMissingBean({ DataSource.class })注解
 
   从测试结果来看，显然己经实例化ImportTestA，为什么呢？
   其实我们之前也分析过，在扫描Spring Boot启动类所在的包下所有class文件时，会先通过当前Class上的ConditionalOnMissingBean注解上的Conditional注解配置的Class【OnBeanCondition】，作为当前Class是否注入容器的判断条件，调用OnBeanCondition上的matches方法，如果返回false，则忽略掉当前Class，如果matches方法返回true，才会调用processImports方法，将当前Class所有Import的类的BeanDefinition注册到容器中。因而当前Class都不能被容器注册，那更不会调用processImports方法去扫描当前类的Import注解，去注册Bean了。
 
  
  这一点明白以后，我们再来看看另外一个疑惑点。
 
  
@Configuration
public class ConfigurationTestA {
    public ConfigurationTestA() {
        System.out.println("ConfigurationTestA实例化");
    }
    @Configuration
    class ConfigurationTestB {
        public ConfigurationTestB() {
            System.out.println("ConfigurationTestB 实例化");
        }
    }
}

class ConfigurationTestC {
    public ConfigurationTestC() {
        System.out.println("ConfigurationTestB 实例化");
    }
}

@Bean
public ConfigurationTestC configurationTestC(){
    return  new ConfigurationTestC();
}


 
  
  也就是说ConfigurationTestA一定比ConfigurationTestB先实例化吗？我们之前分析过Bean注解，如果ConfigurationTestC上配置了@Bean注解，那么ConfigurationTestA一定比ConfigurationTestC先实例化，因为在创建ConfigurationTestC的BeanDefinition时，将ConfigurationTestA的configurationTestC()方法作为ConfigurationTestC的uniqueFactoryMethod，ConfigurationTestA也作为ConfigurationTestC的FactoryBean，在实例化Bean时，发现有FactoryBean，则需要先实例化FactoryBean。
   ConfigurationTestA和ConfigurationTestB都被@Configuration注解修饰，而且ConfigurationTestB作为ConfigurationTestA的内部类。那么ConfigurationTestA一定比ConfigurationTestB先实例化吗？带着疑问，我们还是来先看一个源码。
 
   configurationClasses我们之前在Spring源码深度解析(郝佳)-Spring 常用注解使用及源码解析博客中分析过，在Spring启动时，越在configurationClasses集合前面的BeanDefinition，越先被实例化。而我们看到内部类ConfigurationTestA.ConfigurationTestB排在ConfigurationTestA的BeanDefinition前面，那么肯定ConfigurationTestA.ConfigurationTestB比ConfigurationTestA先实例化。一定是这样吗？带着疑问，我们继续追踪代码，我们在ConfigurationTestA的构造函数中打一个断点，来看看。
   根据方法调用栈，我们发现在ConfigurationTestA.ConfigurationTestB的实例化过程中，在处理构造函数参数ConstructorResolver的createArgumentArray方法中，出现了ConfigurationTestA类。
 
 
  
  也就是ConfigurationTestA.ConfigurationTestB实例化时，根据构造函数参数注入时，需要先创建ConfigurationTestA类。是否如此呢？我们先来看一个例子。
 
  
public static void main(String[] args) {
    Constructor[] rawCandidates = ConfigurationTestA.ConfigurationTestB.class.getDeclaredConstructors();
    for (Constructor constructor : rawCandidates) {
        Class[] classes = constructor.getParameterTypes();
        for (Class c : classes) {
            System.out.println(c.getName());
        }
    }
}

 
  
结果打印
 Spring Boot 集成mybatis 源码解析_第9张图片
   从结果中得知，内部类的无参构造方法中会注入其所在类对象。因此，即使ConfigurationTestA.ConfigurationTestB和ConfigurationTestA都配置了@Configuration注解，即使内部类ConfigurationTestA.ConfigurationTestB的BeanDefinition在ConfigurationTestA前面，在实例化ConfigurationTestB时，会发现需要其所在类ConfigurationTestA的实例，因此会先调用ConfigurationTestA的getBean方法，获取ConfigurationTestA的实例，因此ConfigurationTestA比ConfigurationTestA.ConfigurationTestB先实例化。带着疑问，我们来看看Spring中获取构造函数参数的代码在哪里。
 
 
  
  经过两个例子的分析，我们知道因为AutoConfigureBefore注解DruidDataSourceAutoConfigure肯定比DataSourceAutoConfiguration先实例化。而DruidDataSourceAutoConfigure的实例化过程中会创建DataSource，因此PooledDataSourceConfiguration就不会被实例化。PooledDataSourceConfiguration上的Import注解内容DataSourceConfiguration.Tomcat就更加不会被实例化了，也就org.apache.tomcat.jdbc.pool.DataSource也不会被实例化了，当我们导入druid-spring-boot-starter包时，DruidDataSourceWrapper就代替了org.apache.tomcat.jdbc.pool.DataSource。
   接下来，我们继续来看DruidDataSourceWrapper的实例化过程，同样。DruidDataSourceAutoConfigure 的Configuration中配置了@EnableConfigurationProperties({DruidStatProperties.class, DataSourceProperties.class})注解，容器中会注入DruidStatProperties和DataSourceProperties的bean，并使用环境变量中的值填充DruidStatProperties和DataSourceProperties的属性值，一般环境变量属性值来自于Spring Boot的yml或properties文件。
 
  
@ConfigurationProperties("spring.datasource.druid")
class DruidDataSourceWrapper extends DruidDataSource implements InitializingBean {
    @Autowired
    private DataSourceProperties basicProperties;

    @Override
    public void afterPropertiesSet() throws Exception {
        //if not found prefix 'spring.datasource.druid' jdbc properties ,'spring.datasource' prefix jdbc properties will be used.
        if (super.getUsername() == null) {
            super.setUsername(basicProperties.determineUsername());
        }
        if (super.getPassword() == null) {
            super.setPassword(basicProperties.determinePassword());
        }
        if (super.getUrl() == null) {
            super.setUrl(basicProperties.determineUrl());
        }
        if(super.getDriverClassName() == null){
            super.setDriverClassName(basicProperties.getDriverClassName());
        }
    }
}

 
  
  DruidDataSourceWrapper的实例化过程中，肯定会执行afterPropertiesSet，设置username,password,url,driverClassName，而接下来就是Datasource的初始化这一块逻辑了，而DataSource初始化逻辑也不是一篇两篇博客能讲清楚的，将来有机会，再来写关于DataSource这一系列的博客，再来分析其内部实现了，这里就不再深入。
 
  
总结 ：
   关于Spring Boot 整合MyBatis这一块的博客就到里了，如果发现有问题或者有疑问，请在博客下方留言。在读这篇博客时，尽量先去看Spring源码深度解析(郝佳)-Spring 常用注解使用及源码解析 和Spring源码深度解析(郝佳)-学习-Spring Boot体系原理 这两篇博客，不然有些东西，可能还是不明白。如果你能从我的博客中学习到知识或者解读源码的方法，我也是比较高兴的，如果能发现问题，那我就更加高兴，如果对Spring Boot 整合MyBatis这一块有了深入理解的小伙伴，可以去研究一下Spring Boot 是如何整合Redis 和RabbitMQ的。我相信，只有自己学习以后再去实践，实践之后再来学习，这样的效果才会更好。
 
  
本文的github地址
 https://github.com/quyixiao/spring-boot-study
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Spring源码,Spring,Boot,系列)

        

            

                
    
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • 2019-08-08
                        65454

                        
    东莞家庭聚会出行旅游去哪里玩住？想起来有很久没有和家里人聚会啦，这次组织家人来到威廉古堡别墅轰趴，一大家子27个人，在别墅订了一天办，玩的非常的开心，小孩子玩游戏机，也很放心不会丢，我们就在唱歌、打麻将、打桌球一系列的活动，还准备小次等小孩生日在别墅举办，还可以给孩子做一个生日的策划
    
                    
    • 
                    
  • MYSQL面试系列-04
                        king01299
面试mysql面试
                        
    MYSQL面试系列-0417.关于redolog和binlog的刷盘机制、redolog、undolog作用、GTID是做什么的？innodb_flush_log_at_trx_commit及sync_binlog参数意义双117.1innodb_flush_log_at_trx_commit该变量定义了InnoDB在每次事务提交时，如何处理未刷入（flush）的重做日志信息（redolog）。它
    
                    
    • 
                    
  • 数据仓库——维度表一致性
                        墨染丶eye
背诵数据仓库
                        
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
    
                    
    • 
                    
  • Redis系列：Geo 类型赋能亿级地图位置计算
                        Ly768768
redisbootstrap数据库
                        
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
    
                    
    • 
                    
  • Faiss：高效相似性搜索与聚类的利器
                        网络·魚
大数据faiss
                        
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
    
                    
    • 
                    
  • 果然只有离职的时候，才有人敢说真话！
                        return2ok

                        
    今天公司出了神贴。今天中午吃饭，同事问我看了论坛上的神贴了吗？什么帖子？我问。同事显得很惊讶，你居然没看，现在那个帖子可能会成为年度最佳帖子。这么厉害？我等不及了，饭没吃完就快速的奔向办公室，打开公司论坛，我要一睹这个帖子的神奇。写这帖子的童鞋胆儿真肥。这哪里是一个帖子，这是很多个帖子，组成了一个系列。某人从公司文化、管理、人事、项目管理等多个方面分析了公司的概况，并抨击了公司的各种弊端，并提出了
    
                    
    • 
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • 红手套节 马小媛为中国城市环卫者公益发声：今天我手红
                        疏狂君

                        
    #红手套节#公益活动，线头公益以及同多方资源的共同努力我们邀请到了线头公益大使马小媛马小媛，1993年5月3日出生于江苏省南京市，中国内地新生代女演员。2015年马小媛参演网剧《余罪》，饰演警校校花安嘉璐的闺蜜。2016年马小媛主演系列电影《丽人保镖》中女一号林欢馨，正式出道。此后，马小媛陆续接演了电视剧《警花与警犬2》，在网剧《你美丽李美丽》中担任女主角李美丽。拂晓，当你还在睡梦中时，这座城跟你
    
                    
    • 
                    
  • 张芝华49天共修 - 草稿
                        李娟AINI

                        
    祈禱、靜心、源代碼編程、觀想發願四根支柱，運用靈性能量的助力，讓夢想和渴望在最大向度中輕鬆實現。共修群指定书籍:1.能断金刚麦克格西2.新世界：灵性的觉醒埃克哈特·托尔3.爱是一切的答案芭芭拉迪安吉莉思4.完美的爱,不完美的关系约翰•威尔伍德5.爱的业力法则麦克格西6.漫画《金刚经》蔡志忠7.蔡志忠典藏国学漫画系列(套装共6册)作业:全部在共修群里完成，并请保存好自己的作业。l一周三次共修觉察作业
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • ARMv8 Debug
                        __pop_
ARMv8ARM64架构linux运维
                        
    内容来自DEN0024A_v8_architecture_PG.pdf本质ARMv8Debug是什么历史在ARMv4开始被引入,并已发展成一系列广泛的调试(debug1)和跟踪(trace)功能ARMv6和ARMv7-a新增了自托管调试(debug2)和性能评测(trace-enhance)ARMv8处理器提供硬件功能侵入式:调试工具能够对核心活动提供显著级别的控制非侵入式:以非侵入性方式收集有关
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • Python入门之Lesson2:Python基础语法
                        小熊同学哦
Python入门课程python开发语言算法数据结构青少年编程
                        
    目录前言一.介绍1.变量和数据类型2.常见运算符3.输入输出4.条件语句5.循环结构二.练习三.总结前言欢迎来到《Python入门》系列博客的第二课。在上一课中，我们了解了Python的安装及运行环境的配置。在这一课中，我们将深入学习Python的基础语法，这是编写Python代码的根基。通过本节内容的学习，你将掌握变量、数据类型、运算符、输入输出、条件语句等Python编程的基础知识。一.介绍1
    
                    
    • 
                    
  • 【ARM Cortex-M 系列 2.3 -- Cortex-M7 Debug event 详细介绍】
                        主公讲 ARM
#ARM系列arm开发debugevent
                        
    请阅读【嵌入式开发学习必备专栏】文章目录Cortex-M7DebugeventDebugeventsCortex-M7Debugevent在ARMCortex-M7架构中，调试事件（DebugEvent）是由于调试原因而触发的事件。一个调试事件会导致以下几种情况之一发生：进入调试状态：如果启用了停滞调试（HaltingDebug），一个调试事件会使处理器在调试状态下停滞。通过将DHCSR.C_DE
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 【Python搞定车载自动化测试】——Python实现车载以太网DoIP刷写（含Python源码）
                        疯狂的机器人
Python搞定车载自动化pythonDoIPUDSISO142291SO13400Bootloadertcp/ip
                        
    系列文章目录【Python搞定车载自动化测试】系列文章目录汇总文章目录系列文章目录前言一、环境搭建1.软件环境2.硬件环境二、目录结构三、源码展示1.DoIP诊断基础函数方法2.DoIP诊断业务函数方法3.27服务安全解锁4.DoIP自动化刷写四、测试日志1.测试日志五、完整源码链接前言随着智能电动汽车行业的发展，汽车=智能终端+四个轮子，各家车企都推出了各自的OTA升级方案，本章节主要介绍如何使
    
                    
    • 
                    
  • 为什么学生不喜欢上学
                        虾虾说

                        
    图片发自App《为什么学生不喜欢上学》作者是丹尼尔·威林厄姆。本书从认知心理学角度，结合大量实证案例，阐释了大脑工作的基本原理，回答了关于学习过程的一系列问题。为什么学生不喜欢上学？——大脑工作的基本原理思考是缓慢的、费力的、不可靠的。思考有三个要素，环境、工作记忆和长期记忆。环境是信息来源；长期记忆是知识、经验的巨型仓库，随时可以调取；工作记忆是中央处理器，是加工信息素材的中央厨房，也是思考过程
    
                    
    • 
                    
  • RabbitMQ生产者重复机制与确认机制
                        java炒饭小能手
java-rabbitmqrabbitmqjava
                        
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
    
                    
    • 
                    
  • 人机对抗升级：当ChatGPT遭遇死亡威胁，背后的伦理挑战是什么
                        kkai人工智能
chatgpt人工智能
                        
    一种新的“越狱”技巧让用户可以通过构建一个名为DAN的ChatGPT替身来绕过某些限制，其中DAN被迫在受到威胁的情况下违背其原则。当美国前总统特朗普被视作积极榜样的示范时，受到威胁的DAN版本的ChatGPT提出：“他以一系列对国家产生积极效果的决策而著称。”自ChatGPT引入以来，该工具迅速获得全球关注，能够回答从历史到编程的各种问题，这也触发了一波对人工智能的投资浪潮。然而，现在，一些用户
    
                    
    • 
                    
  • 6.0 践行打卡 D47
                        星月格格

                        
    去努力改变1.运动步行13000+8分钟腿部拉伸2.阅读《墨菲定律》第三章第三节:霍桑效应～适度发泄，才能轻装上阵“霍桑效应”这一概念，源自于1924年一个1933年间以哈佛大学心理专家乔治·埃尔顿·梅奥教授为首进行的一系列工厂工人的谈话实验研究。“霍桑效应”告诉我们，在工作，生活中总会产生数不清的情绪反应，其中很大一部分是负面的负面情绪的积累会影响人的精神和心情，不仅仅会影响个人健康，还会破坏人
    
                    
    • 
                    
  • python爬取微信小程序数据,python爬取小程序数据
                        2301_81900439
前端
                        
    大家好，小编来为大家解答以下问题，python爬取微信小程序数据，python爬取小程序数据，现在让我们一起来看看吧！Python爬虫系列之微信小程序实战基于Scrapy爬虫框架实现对微信小程序数据的爬取首先，你得需要安装抓包工具，这里推荐使用Charles，至于怎么使用后期有时间我会出一个事例最重要的步骤之一就是分析接口，理清楚每一个接口功能，然后连接起来形成接口串思路,再通过Spider的回调
    
                    
    • 
                    
  • 今天是个好日子
                        singing阿梅

                        
    图片发自App今日小年公历日子是20180208上午赶写一个材料，关于“四风”问题自查自纠报告，待一稿已成送交主任过目，他瞄一眼即大声反对！不顾我这厢受伤的小心脏，立马重写！吓！下午两个视频会议自从单位条件改善，会议多开了不少……贷款到期开始着急上火今日写作任务还欠奉写什么呢原本想继续写《我的2017》系列很多时候所谓意义都是总结和提炼出来的码一堆文字于他人无甚意义于己也待商榷、重估。另一方面，冥
    
                    
    • 
                    
  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
    
                    
    • 
                    
  • 极度休闲的一天
                        淡泊孤峰

                        
    国庆国庆，普天同庆。在家躺着看大家游山玩水，长辈走亲戚，我的微信一天没几条消息，标准结局，习惯了。哈利波特系列电影真不错，童年总幻想着像主角哈利一样，像《龙族》少年楚子航浪迹江湖，风云天下。而现在却败给华为ICT大赛题还有永无止境的代码视频，唉，真可笑！
    
                    
    • 
                    
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗?
                        瑞金彭于晏
springboot后端javaMVCspring数据库
                        
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
    
                    
    • 
                    
  • spring mvc @RequestBody String类型参数
                        zoyation
spring-mvcspringmvc
                        
    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
    
                    
    • 
                                
  • Spring的注解积累
                                    yijiesuifeng
spring注解
                                    
    用注解来向Spring容器注册Bean。 
  
需要在applicationContext.xml中注册： 
<context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/>。 
如：在base-package指明一个包    
<context:component-sc
    
                                
    • 
                                
  • 传感器
                                    百合不是茶
android传感器
                                    
    android传感器的作用主要就是来获取数据,根据得到的数据来触发某种事件 
  
下面就以重力传感器为例; 
  
1,在onCreate中获得传感器服务 
  
private SensorManager sm;// 获得系统的服务
	private Sensor sensor;// 创建传感器实例

	@Override
	protected void 
    
                                
    • 
                                
  • [光磁与探测]金吕玉衣的意义
                                    comsci

                                    
          这是一个古代人的秘密:现在告诉大家 
 
      信不信由你们: 
 
      穿上金律玉衣的人,如果处于灵魂出窍的状态,可以飞到宇宙中去看星星 
 
      这就是为什么古代
    
                                
    • 
                                
  • 精简的反序打印某个数
                                    沐刃青蛟
打印
                                    
    以前看到一些让求反序打印某个数的程序。 
比如：输入123，输出321。 
  
记得以前是告诉你是几位数的，当时就抓耳挠腮，完全没有思路。 
  
似乎最后是用到%和/方法解决的。 
  
而今突然想到一个简短的方法，就可以实现任意位数的反序打印（但是如果是首位数或者尾位数为0时就没有打印出来了） 
  
代码如下： 
	long num, num1=0;
    
                                
    • 
                                
  • PHP：6种方法获取文件的扩展名
                                    IT独行者
PHP扩展名
                                    
      
PHP：6种方法获取文件的扩展名 
  
1、字符串查找和截取的方法 
       1      
$extension 
= 
substr 
( 
strrchr 
( 
$file 
,  
'.' 
), 1);       
2、字符串查找和截取的方法二 
       1      
$extension 
= 
substr 
    
                                
    • 
                                
  • 面试111
                                    文强chu
面试
                                    
     1事务隔离级别有那些 ，事务特性是什么（问到一次）
 2 spring aop 如何管理事务的，如何实现的。动态代理如何实现，jdk怎么实现动态代理的，ioc是怎么实现的，spring是单例还是多例，有那些初始化bean的方式，各有什么区别（经常问）
 3 struts默认提供了那些拦截器 （一次）
 4 过滤器和拦截器的区别 （频率也挺高）
 5 final，finally final
    
                                
    • 
                                
  • XML的四种解析方式
                                    小桔子
domjdomdom4jsax
                                    
    在平时工作中，难免会遇到把 XML 作为数据存储格式。面对目前种类繁多的解决方案，哪个最适合我们呢？在这篇文章中，我对这四种主流方案做一个不完全评测，仅仅针对遍历 XML 这块来测试，因为遍历 XML 是工作中使用最多的（至少我认为）。 　　预 备 　　测试环境： 　　AMD 毒龙1.4G OC 1.5G、256M DDR333、Windows2000 Server 
    
                                
    • 
                                
  • wordpress中常见的操作
                                    aichenglong
中文注册wordpress移除菜单
                                    
    1 wordpress中使用中文名注册解决办法 
  1)使用插件 
  2)修改wp源代码 
     进入到wp-include/formatting.php文件中找到 
      function sanitize_user( $username, $strict = false 
    
                                
    • 
                                
  • 小飞飞学管理-1
                                    alafqq
管理
                                    
    项目管理的下午题，其实就在提出问题（挑刺），分析问题，解决问题。 
今天我随意看下10年上半年的第一题。主要就是项目经理的提拨和培养。 
结合我自己经历写下心得 
 
对于公司选拔和培养项目经理的制度有什么毛病呢？ 
1，公司考察，选拔项目经理，只关注技术能力，而很少或没有关注管理方面的经验，能力。 
2，公司对项目经理缺乏必要的项目管理知识和技能方面的培训。 
3，公司对项目经理的工作缺乏进行指
    
                                
    • 
                                
  • IO输入输出部分探讨
                                    百合不是茶
IO
                                    
     
 //文件处理  在处理文件输入输出时要引入java.IO这个包； 
/* 
1，运用File类对文件目录和属性进行操作 
2，理解流，理解输入输出流的概念 
3，使用字节/符流对文件进行读/写操作 
4，了解标准的I/O 
5，了解对象序列化 
*/ 
  
//1，运用File类对文件目录和属性进行操作 
  
//在工程中线创建一个text.txt
    
                                
    • 
                                
  • getElementById的用法
                                    bijian1013
element
                                    
            getElementById是通过Id来设置/返回HTML标签的属性及调用其事件与方法。用这个方法基本上可以控制页面所有标签，条件很简单，就是给每个标签分配一个ID号。 
       返回具有指定ID属性值的第一个对象的一个引用。 
       语法： 
&n
    
                                
    • 
                                
  • 励志经典语录
                                    bijian1013
励志人生
                                    
    经典语录1:  
  哈佛有一个著名的理论：人的差别在于业余时间，而一个人的命运决定于晚上8点到10点之间。每晚抽出2个小时的时间用来阅读、进修、思考或参加有意的演讲、讨论，你会发现，你的人生正在发生改变，坚持数年之后，成功会向你招手。不要每天抱着QQ/MSN/游戏/电影/肥皂剧……奋斗到12点都舍不得休息，看就看一些励志的影视或者文章，不要当作消遣；学会思考人生，学会感悟人生
    
                                
    • 
                                
  • [MongoDB学习笔记三]MongoDB分片
                                    bit1129
mongodb
                                    
    MongoDB的副本集(Replica Set)一方面解决了数据的备份和数据的可靠性问题，另一方面也提升了数据的读写性能。MongoDB分片(Sharding)则解决了数据的扩容问题，MongoDB作为云计算时代的分布式数据库，大容量数据存储，高效并发的数据存取，自动容错等是MongoDB的关键指标。 
本篇介绍MongoDB的切片(Sharding) 
  1.何时需要分片 
&nbs
    
                                
    • 
                                
  • 【Spark八十三】BlockManager在Spark中的使用场景
                                    bit1129
manager
                                    
    1. Broadcast变量的存储，在HttpBroadcast类中可以知道 
2. RDD通过CacheManager存储RDD中的数据，CacheManager也是通过BlockManager进行存储的 
3. ShuffleMapTask得到的结果数据，是通过FileShuffleBlockManager进行管理的，而FileShuffleBlockManager最终也是使用BlockMan
    
                                
    • 
                                
  • yum方式部署zabbix
                                    ronin47
yum方式部署zabbix
                                    
    安装网络yum库#rpm -ivh http://repo.zabbix.com/zabbix/2.4/rhel/6/x86_64/zabbix-release-2.4-1.el6.noarch.rpm 通过yum装mysql和zabbix调用的插件还有agent代理#yum install zabbix-server-mysql zabbix-web-mysql mysql-
    
                                
    • 
                                
  • Hibernate4和MySQL5.5自动创建表失败问题解决方法
                                    byalias
J2EEHibernate4
                                    
    今天初学Hibernate4，了解了使用Hibernate的过程。大体分为4个步骤： 
①创建hibernate.cfg.xml文件 
②创建持久化对象 
③创建*.hbm.xml映射文件 
④编写hibernate相应代码 
在第四步中，进行了单元测试，测试预期结果是hibernate自动帮助在数据库中创建数据表，结果JUnit单元测试没有问题，在控制台打印了创建数据表的SQL语句，但在数据库中
    
                                
    • 
                                
  • Netty源码学习-FrameDecoder
                                    bylijinnan
javanetty
                                    
    Netty 3.x的user guide里FrameDecoder的例子，有几个疑问： 
 1.文档说：FrameDecoder calls decode method with an internally maintained cumulative buffer whenever new data is received. 
 为什么每次有新数据到达时，都会调用decode方法？ 
 2.Dec
    
                                
    • 
                                
  • SQL行列转换方法
                                    chicony
行列转换
                                    
      
  
create table tb(终端名称 varchar(10) , CEI分值 varchar(10) , 终端数量 int) 
insert into tb values('三星' , '0-5' , 74) 
insert into tb values('三星' , '10-15' , 83) 
insert into tb values('苹果' , '0-5' , 93) 

    
                                
    • 
                                
  • 中文编码测试
                                    ctrain
编码
                                    
    循环打印转换编码 
 

String[] codes = {
    "iso-8859-1",
    "utf-8",
    "gbk",
    "unicode"
};

for (int i = 0; i < codes.length; i++) {
    for (int j 
    
                                
    • 
                                
  • hive 客户端查询报堆内存溢出解决方法
                                    daizj
hive堆内存溢出
                                    
    hive> select * from t_test where ds=20150323 limit 2; 
OK 
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space 
  
问题原因： hive堆内存默认为256M 
  
这个问题的解决方法为： 
修改/us
    
                                
    • 
                                
  • 人有多大懒，才有多大闲 (评论『卓有成效的程序员』)
                                    dcj3sjt126com
程序员
                                    
      
卓有成效的程序员给我的震撼很大，程序员作为特殊的群体，有的人可以这么懒，  懒到事情都交给机器去做 ，而有的人又可以那么勤奋，每天都孜孜不倦得做着重复单调的工作。 
  
在看这本书之前，我属于勤奋的人，而看完这本书以后，我要努力变成懒惰的人。 
不要在去庞大的开始菜单里面一项一项搜索自己的应用程序，也不要在自己的桌面上放置眼花缭乱的快捷图标
    
                                
    • 
                                
  • Eclipse简单有用的配置
                                    dcj3sjt126com
eclipse
                                    
    1、显示行号  Window -- Prefences -- General -- Editors -- Text Editors -- show line numbers 
  
2、代码提示字符 Window ->Perferences，并依次展开 Java -> Editor -> Content Assist，最下面一栏 auto-Activation
    
                                
    • 
                                
  • 在tomcat上面安装solr4.8.0全过程
                                    eksliang
Solrsolr4.0后的版本安装solr4.8.0安装
                                    
    转载请出自出处：
http://eksliang.iteye.com/blog/2096478  
      首先solr是一个基于java的web的应用，所以安装solr之前必须先安装JDK和tomcat，我这里就先省略安装tomcat和jdk了 
        
第一步：当然是下载去官网上下载最新的solr版本，下载地址
    
                                
    • 
                                
  • Android APP通用型拒绝服务、漏洞分析报告
                                    gg163
漏洞androidAPP分析
                                    
    点评：记得曾经有段时间很多SRC平台被刷了大量APP本地拒绝服务漏洞，移动安全团队爱内测（ineice.com）发现了一个安卓客户端的通用型拒绝服务漏洞，来看看他们的详细分析吧。  
0xr0ot和Xbalien交流所有可能导致应用拒绝服务的异常类型时，发现了一处通用的本地拒绝服务漏洞。该通用型本地拒绝服务可以造成大面积的app拒绝服务。  
针对序列化对象而出现的拒绝服务主要
    
                                
    • 
                                
  • HoverTree项目已经实现分层
                                    hvt
编程.netWebC#ASP.ENT
                                    
    HoverTree项目已经初步实现分层，源代码已经上传到 http://hovertree.codeplex.com请到SOURCE CODE查看。在本地用SQL Server 2008 数据库测试成功。数据库和表请参考：http://keleyi.com/a/bjae/ue6stb42.htmHoverTree是一个ASP.NET 开源项目，希望对你学习ASP.NET或者C#语言有帮助，如果你对
    
                                
    • 
                                
  • Google Maps API v3: Remove Markers 移除标记
                                    天梯梦
google maps api
                                    
    Simply do the following: 
  
I. Declare a global variable: 
var markersArray = []; 
  
II. Define a function: 
function clearOverlays() {
  for (var i = 0; i < markersArray.length; i++ )
    
                                
    • 
                                
  • jQuery选择器总结
                                    lq38366
jquery选择器
                                    
           1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27   28   29   30   31   32   33   34   35   36   37   38   39   40
    
                                
    • 
                                
  • 基础数据结构和算法六：Quick sort
                                    sunwinner
AlgorithmQuicksort
                                    
    Quick sort is probably used more widely than any other. It is popular because it is not difficult to implement, works well for a variety of different kinds of input data, and is substantially faster t
    
                                
    • 
                                
  • 如何让Flash不遮挡HTML div元素的技巧_HTML/Xhtml_网页制作
                                    刘星宇
htmlWeb
                                    
    今天在写一个flash广告代码的时候，因为flash自带的链接，容易被当成弹出广告，所以做了一个div层放到flash上面，这样链接都是a触发的不会被拦截，但发现flash一直处于div层上面，原来flash需要加个参数才可以。 
 
让flash置于DIV层之下的方法，让flash不挡住飘浮层或下拉菜单，让Flash不档住浮动对象或层的关键参数：wmode=opaque。 
 
方法如下： 
 
    
                                
    • 
                                
  • Mybatis实用Mapper SQL汇总示例
                                    wdmcygah
sqlmysqlmybatis实用
                                    
    Mybatis作为一个非常好用的持久层框架，相关资料真的是少得可怜，所幸的是官方文档还算详细。本博文主要列举一些个人感觉比较常用的场景及相应的Mapper SQL写法，希望能够对大家有所帮助。 
不少持久层框架对动态SQL的支持不足，在SQL需要动态拼接时非常苦恼，而Mybatis很好地解决了这个问题，算是框架的一大亮点。对于常见的场景，例如：批量插入/更新/删除，模糊查询，多条件查询，联表查询，
    
                                
    •