springBoot 启动文件为什么要排除DataSourceAutoConfiguration

代码如下:

@SpringBootApplication(scanBasePackages = "com.xen",exclude = DataSourceAutoConfiguration.class)

exclude 排除AutoConfig, 禁止 SpringBoot 自动注入数据源。

为什么要排除呢？因为项目需要用到多数据源。所以需要排除。

下面介绍 DataSourceAutoConfiguration的源码。

1.DataSourceAutoConfiguration概况

DataSourceAutoConfiguration.class 会自动查找 application.yml 或者 properties 文件里的 spring.datasource.* 相关属性并自动配置单数据源「注意这

里提到的单数据源」。作用如下:

• 初始化 DataSourceProperties配置文件
• 初始化数据源
• 执行sql文件
• 为数据源注册一个DataSourcePoolMetadataProvider实例

2.源码分析

@Configuration
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
// 从配置文件中映射 DataSource 的值
@EnableConfigurationProperties(DataSourceProperties.class)
@Import({ DataSourcePoolMetadataProvidersConfiguration.class,
      DataSourceInitializationConfiguration.class })
public class DataSourceAutoConfiguration {

   @Configuration
   //判断是否引入 内置数据库：H2，DERBY，HSQL
   @Conditional(EmbeddedDatabaseCondition.class)
   //如果这是没有DataSource/XADataSource 对应的 BeanDefinition，就通过导入 EmbeddedDataSourceConfiguration.class 来，配置内置数据库对应的数据源！！
   @ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
   @Import(EmbeddedDataSourceConfiguration.class)
   protected static class EmbeddedDatabaseConfiguration {}

 
   @Configuration
   //判断是否引入依赖的数据源：HikariDataSource、tomcat.jdbc.pool.DataSource、BasicDataSource
   @Conditional(PooledDataSourceCondition.class)
   //如果这是没有DataSource/XADataSource 对应的 BeanDefinition，就通过以下属性的配置文件，配置数据源！！
   //配置数据源的时候，如果没有指定一些数据库的参数，就会报错哦
   @ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
   @Import({ DataSourceConfiguration.Hikari.class, DataSourceConfiguration.Tomcat.class,
         DataSourceConfiguration.Dbcp2.class, DataSourceConfiguration.Generic.class,
         DataSourceJmxConfiguration.class })
   protected static class PooledDataSourceConfiguration {}
   
   static class PooledDataSourceCondition extends AnyNestedCondition {}
   static class EmbeddedDatabaseCondition extends SpringBootCondition {}
}

(1) 初始化 DataSourceProperties 配置文件

如果设置的不是内置数据库的话：
1）必须配置的有：url,username,password
2）数据库名不是必须的
3）driverClassName 不是必须的：可以从 url 中推导出
4）type 不是必须的：可以从上下文中推导出
如果设置的是内置数据库的话：
1）必须配置的有：引入内置数据库依赖，如：H2
2）其它所有的都可以不配置(有默认的配置)，如果随意配置，可能产生冲突

@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceProperties implements BeanClassLoaderAware, InitializingBean {
	private ClassLoader classLoader;
    //数据库名：如果使用内置数据库，默认为testdb
	private String name;
	//Whether to generate a random datasource name
	private boolean generateUniqueName;
    //如果generateUniqueName==true,则不使用name,而使用uniqueName来做数据库名
    private String uniqueName;
    //完整的数据库连接池名。默认从项目中检测出
	private Class<? extends DataSource> type;
    //JDBC driver的完整名，默认从URL中检测出相对应的driver
	private String driverClassName;
    //JDBC URL of the database
	private String url;
    
	//Login username of the database
	private String username;
	//Login password of the database
	private String password;
    //JNDI 数据源的位置：如果指定了，则数据库连接数据将会失效：driverClassName,url,username,password
	private String jndiName;
	//初始化database使用的sql文件的模式，默认是EMBEDDED，如果是NONE就不会执行sql文件
    //如果设置的模式和检测出来的模式不匹配，也不会执行sql文件
	private DataSourceInitializationMode initializationMode = DataSourceInitializationMode.EMBEDDED;

    //执行sql文件相关，schema-${platform}.sql,data-${platform}.sql
    //默认执行不带 platform 的 sql 文件 + 带 platform 的 sql 文件
	private String platform = "all";
    //具体的 schema 文件的位置，如果指定了这个就不会查找默认的sql文件了
	private List<String> schema;
	//执行schema使用数据库的用户名
	private String schemaUsername;
	//执行schema使用数据库的密码，如果schemaUsername和schemaPassword都不指定，就使用 **主数据源** 作为执行目的数据库！
	private String schemaPassword;
	//同schema
	private List<String> data;
	private String dataUsername;
	private String dataPassword;
    
    //如果初始化database时报错，是否继续
	private boolean continueOnError = false;
	//Statement separator in SQL initialization scripts.
	private String separator = ";";
	//SQL scripts encoding.
	private Charset sqlScriptEncoding;
	//默认的内置数据库连接信息：
    //1 NONE(null, null, null)
    //2 H2(EmbeddedDatabaseType.H2, "org.h2.Driver","jdbc:h2:mem:%s;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE")
    //3 DERBY(...)
    //4 HSQL(...)
	private EmbeddedDatabaseConnection embeddedDatabaseConnection = EmbeddedDatabaseConnection.NONE;

	private Xa xa = new Xa();
	//从项目中匹配相应的内置数据库，查找是否引入了相应的依赖，如果引入了H2依赖，这里embeddedDatabaseConnection就设置成 H2
	@Override
	public void afterPropertiesSet() throws Exception {
		this.embeddedDatabaseConnection = EmbeddedDatabaseConnection
				.get(this.classLoader);
	}

    // 通过 spring.datasource 属性 初始化一个DataSourceBuilder，用来方便的创建datasource，就是一个封装的方法
	public DataSourceBuilder<?> initializeDataSourceBuilder() {
		return DataSourceBuilder.create(getClassLoader()).type(getType())
				.driverClassName(determineDriverClassName()).url(determineUrl())
				.username(determineUsername()).password(determinePassword());
	}
	//智能的获取DriverClassName
	public String  determineDriverClassName() {
		if (StringUtils.hasText(this.driverClassName)) {
			Assert.state(driverClassIsLoadable(),
					() -> "Cannot load driver class: " + this.driverClassName);
			return this.driverClassName;
		}
		String driverClassName = null;
		if (StringUtils.hasText(this.url)) {
			driverClassName = DatabaseDriver.fromJdbcUrl(this.url).getDriverClassName();
		}
        //如果走到这，还没识别出 driverClassName，且它为null，就去内置数据库中找匹配的
        //如果项目中没有引入 内置数据库依赖，那就会报错啦
		if (!StringUtils.hasText(driverClassName)) {
			driverClassName = this.embeddedDatabaseConnection.getDriverClassName();
		}
		if (!StringUtils.hasText(driverClassName)) {
			throw new DataSourceBeanCreationException(
					"Failed to determine a suitable driver class", this,
					this.embeddedDatabaseConnection);
		}
		return driverClassName;
	}
    private boolean driverClassIsLoadable() {
		try {
			ClassUtils.forName(this.driverClassName, null);
			return true;
		}
		catch (UnsupportedClassVersionError ex) {
			// Driver library has been compiled with a later JDK, propagate error
			throw ex;
		}
		catch (Throwable ex) {
			return false;
		}
	}
	//Determine the url to use based on this configuration and the environment.
	public String determineUrl() {
		if (StringUtils.hasText(this.url)) {
			return this.url;
		}
		String databaseName = determineDatabaseName();
		String url = (databaseName != null)
				? this.embeddedDatabaseConnection.getUrl(databaseName) : null;
		if (!StringUtils.hasText(url)) {
			throw new DataSourceBeanCreationException(
					"Failed to determine suitable jdbc url", this,
					this.embeddedDatabaseConnection);
		}
		return url;
	}
	//Determine the name to used based on this configuration.
	public String determineDatabaseName() {
		if (this.generateUniqueName) {
			if (this.uniqueName == null) {
				this.uniqueName = UUID.randomUUID().toString();
			}
			return this.uniqueName;
		}
		if (StringUtils.hasLength(this.name)) {
			return this.name;
		}
		if (this.embeddedDatabaseConnection != EmbeddedDatabaseConnection.NONE) {
			return "testdb";
		}
		return null;
	}
	//
	public String determineUsername() {
		if (StringUtils.hasText(this.username)) {
			return this.username;
		}
		if (EmbeddedDatabaseConnection.isEmbedded(determineDriverClassName())) {
			return "sa";
		}
		return null;
	}

	public String determinePassword() {
		if (StringUtils.hasText(this.password)) {
			return this.password;
		}
		if (EmbeddedDatabaseConnection.isEmbedded(determineDriverClassName())) {
			return "";
		}
		return null;
	}
	//XA Specific datasource settings.
	public static class Xa {
		//XA datasource fully qualified name.
		private String dataSourceClassName;
		//Properties to pass to the XA data source.
		private Map<String, String> properties = new LinkedHashMap<>();
    }
}

(2) 引入 EmbeddedDatabaseConfiguration 配置类

//所有的 condition 类都会最终继承 SpringBootCondition，SpringBootCondition 是一个模板类，继承它后，我们只需要实现核心的 getMatchOutCome() 方法来自定义一个 Condition 类了。当这个类被@Conditional 注解引入的时候，最终时候执行这个核心方法来判断是否匹配的
static class EmbeddedDatabaseCondition extends SpringBootCondition {
	private final SpringBootCondition pooledCondition = new PooledDataSourceCondition();
	@Override
	public ConditionOutcome getMatchOutcome(ConditionContext context,
			AnnotatedTypeMetadata metadata) {
		ConditionMessage.Builder message = ConditionMessage
				.forCondition("EmbeddedDataSource");
	    // anyMatches() 就是一个 SpringbootCondition 类中的模板方法，意思是：匹配任意一个 pooledCondition 中的条件
	    // 这里 pooledCondition 中的条件其实是匹配非内置数据库的条件，这就很奇怪了，为什么不把 匹配非内置数据库的配置放在前面呢？
		if (anyMatches(context, metadata, this.pooledCondition)) {
			return ConditionOutcome
					.noMatch(message.foundExactly("supported pooled data source"));
		}
		//这里查找了项目中有没有引入 H2，DERBY，HSQL 这3个class，如果没有引入，就返回 null，引入了返回 第一个 type
		EmbeddedDatabaseType type = EmbeddedDatabaseConnection
				.get(context.getClassLoader()).getType();
		if (type == null) {
			return ConditionOutcome
					.noMatch(message.didNotFind("embedded database").atAll());
		}
		return ConditionOutcome.match(message.found("embedded database").items(type));
	}
}

(3) 引入 PooledDataSourceConfiguration 配置类

@Configuration
//满足其中的任意一个：1）有spring.datasource.type属性 2）满足PooledDataSourceAvailableCondition：项目中引入了数据源依赖
@Conditional(PooledDataSourceCondition.class)
@ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
//如果满足上面条件，就解析一下几个配置类（注意顺序，hikari优先）
@Import({ DataSourceConfiguration.Hikari.class, DataSourceConfiguration.Tomcat.class,
      DataSourceConfiguration.Dbcp2.class, DataSourceConfiguration.Generic.class,
      DataSourceJmxConfiguration.class })
protected static class PooledDataSourceConfiguration {}

 //继承了 AnyNestedCondition 的类，会对这个类中的所有内部类(不一定非得是静态内部类)上的注解做匹配，只要其中有一个匹配了，就匹配了
//说明：如果没有spring.datasource.type属性，就默认查看项目中有没有引入：hikari，tomcat，dbcp2。这样说明如果项目中exclude了这3个，那么就必须使用 spring.datasource.type来指定数据库连接池了
//type 属性优先级比较低，是在找不到，就通过 DataSourceConfiguration.Generic.class 类，来根据 type 属性配置
static class PooledDataSourceCondition extends AnyNestedCondition {
   PooledDataSourceCondition() {
      //因为 AnyNestedCondition 实现了 ConfigurationCondition，所以要设置 这个属性
      //这个属性在 sholudSkip() 方法中会用到，如果这个属性是 REGISTER_BEAN 的话，在生成 configClass 阶段就不会进行匹配过滤，要等到 loadBeanDefintion 的时候，在进行过滤
      //因为类中的静态内部类，都被 @ConditionalOnProperty 注解，这些注解都是在 configClass 阶段做匹配的，所以要设置为 PARSE_CONFIGURATION
      //如果这里设置为 REGISTER_BEAN，但是内部有应该在 configClass 阶段做匹配的，就不符合整体思想了（这样本应该在 configClass 阶段就做匹配的，延迟到了 loadBeanDefintion 阶段），就可能能出现莫名其妙的问题。
      //进一步思考：继承了 AnyNestedCondition 的子类中，不应该同时存在 configClass 阶段做匹配和在 loadBeanDefintion 阶段匹配的
      super(ConfigurationPhase.PARSE_CONFIGURATION);
   }
   //条件一：是否配置了 spring.datasource.type 属性
   @ConditionalOnProperty(prefix = "spring.datasource", name = "type")
   static class ExplicitType {
   }
   //条件二：项目中是否引入了数据源依赖(如，hikari)
   @Conditional(PooledDataSourceAvailableCondition.class)
   static class PooledDataSourceAvailable {
   }
}
static class PooledDataSourceAvailableCondition extends SpringBootCondition {
  @Override
  public ConditionOutcome getMatchOutcome(ConditionContext context,
        AnnotatedTypeMetadata metadata) {
     //这个类只是用来传递消息的
     ConditionMessage.Builder message = ConditionMessage
           .forCondition("PooledDataSource");
      //getDataSourceClassLoader(context)：内部做class.forName来找项目中的相关class，找到了就不为null啦，一般肯定能找到的，在org.springframework.boot:spring-boot-starter-jdbc中就已经引入了 hikariDatabase，而在 spring.boot:mybatis-spring-boot-starter中引入了 jdbc!
     if (getDataSourceClassLoader(context) != null) {
        return ConditionOutcome
              .match(message.foundExactly("supported DataSource"));
     }
     return ConditionOutcome
           .noMatch(message.didNotFind("supported DataSource").atAll());
  }
  private ClassLoader getDataSourceClassLoader(ConditionContext context) {
      //在DataSourceBuilder中有个关键的 findType方法来按：hikari，tomcat，dbcp2顺序查找，一查到就返回
     Class<?> dataSourceClass = DataSourceBuilder
           .findType(context.getClassLoader());
     return (dataSourceClass != null) ? dataSourceClass.getClassLoader() : null;
  }
}

(4) 导入 DataSourcePoolMetadataProvidersConfiguration 配置类

//为数据源注册一个DataSourcePoolMetadataProvider实例，这个实例主要用于获取内置数据源的一些状态
@Configuration
public class DataSourcePoolMetadataProvidersConfiguration {
	@Configuration
	@ConditionalOnClass(org.apache.tomcat.jdbc.pool.DataSource.class)
	static class TomcatDataSourcePoolMetadataProviderConfiguration {...}
	@Configuration
	@ConditionalOnClass(HikariDataSource.class)
	static class HikariPoolDataSourceMetadataProviderConfiguration {
		@Bean
		public DataSourcePoolMetadataProvider hikariPoolDataSourceMetadataProvider() {
			return (dataSource) -> {
				HikariDataSource hikariDataSource = DataSourceUnwrapper.unwrap(dataSource,
						HikariDataSource.class);
				if (hikariDataSource != null) {
					//这里就返回了一个HikariDataSourcePoolMetadata实例，算是代理数据源吧
					return new HikariDataSourcePoolMetadata(hikariDataSource);
				}
				return null;
			};
		}
	}
	@Configuration
	@ConditionalOnClass(BasicDataSource.class)
	static class CommonsDbcp2PoolDataSourceMetadataProviderConfiguration {...}
}
//函数式接口，可以这样声明
//DataSourcePoolMetadataProvider dpmp = dataSource->{...,return 一个DataSourcePoolMetadata实例}
@FunctionalInterface
public interface DataSourcePoolMetadataProvider {
	//返回能够管理指定数据源的DataSourcePoolMetadata实例，如果无法处理给定的数据源，则返回空值。
	DataSourcePoolMetadata getDataSourcePoolMetadata(DataSource dataSource);
}
//每个都可能返回null，如果数据源没有提供相应的信息
public interface DataSourcePoolMetadata {
	//返回池的使用情况，值介于0和1之间(如果池不受限制，则返回-1)，1表示所有的都分配了
	Float getUsage();
	//返回从数据源分配的当前活动连接数
	Integer getActive();
	//返回可同时分配的最大活动连接数，无限制的话返回-1
	Integer getMax();
	//返回池中空闲连接的最小数目
	Integer getMin();
	//返回用于验证连接是否有效的查询
	String getValidationQuery();
	//此池创建的连接的默认自动提交状态
	Boolean getDefaultAutoCommit();
}

(5) 如何自定义数据源

• 每个数据源都有自己的属性，
• 通过 DataSourceBuilder 类来创建数据源实例
• 通过 @ConfigurationProperties() 注解，将配置文件中的属性，映射到相应的数据源实例中
• DataSourcePoolMetadataProvidersConfiguration 中只配置了默认的3个数据源，如果需要，需要自己定义它

@Bean(name = "druidDatasource")
@ConfigurationProperties("wang-kang.druid.datasource")
public DataSource druidDatasource() {
    return DataSourceBuilder.create().type(DruidDataSource.class).build();
}