druid是一个数据库连接池，它持有一系列的数据库连接，当应用程序需要数据库连接时，通过druid的数据源可以直接获取连接。同时它也有很多附加功能，比如监控等。本文主要分析druid的数据源DruidDataSource的初始化过程。
在应用程序中，我们一般都是直接创建DruidDataSource对象，然后通过它的getConnection()方法获取数据库连接。下面我们主要解析DruidDataSource的构造方法，看看它都做了什么事情。
public DruidDataSource(boolean fairLock) {
super(fairLock);//DruidDataSource会创建一个重入锁，该入参用于设置锁是否是公平锁，默认是非公平锁
configFromPropety(System.getProperties());
}
public void configFromPropety(Properties properties) {
{
//设置druid的名字
String property = properties.getProperty("druid.name");
if (property != null) {
this.setName(property);
}
}
//设置数据库连接的url
{
String property = properties.getProperty("druid.url");
if (property != null) {
this.setUrl(property);
}
}
//中间代码进行了省略，该方法主要是将一些数据库连接参数设置到DruidDataSource的属性中，在创建数据库连接时，数据源会将这些参数设置到连接对象中
{
String property = properties.getProperty("druid.initConnectionSqls");
if (property != null && property.length() > 0) {
try {
StringTokenizer tokenizer = new StringTokenizer(property, ";");
setConnectionInitSqls(Collections.list(tokenizer));
} catch (NumberFormatException e) {
LOG.error("illegal property 'druid.initConnectionSqls'", e);
}
}
}
{
String property = System.getProperty("druid.load.spifilter.skip");
if (property != null && !"false".equals(property)) {
loadSpifilterSkip = true;
}
}
{
String property = System.getProperty("druid.checkExecuteTime");
if (property != null && !"false".equals(property)) {
checkExecuteTime = true;
}
}
}从上面的代码可以看到，DruidDataSource的构造方法还是比较简单的，主要是用于初始化属性值。
下面我们在分析一下该类的getConnection()方法。
public DruidPooledConnection getConnection(long maxWaitMillis) throws SQLException {
init();
if (filters.size() > 0) {
FilterChainImpl filterChain = new FilterChainImpl(this);
return filterChain.dataSource_connect(this, maxWaitMillis);
} else {
return getConnectionDirect(maxWaitMillis);
}
}getConnection()方法一共做了两件事：1）初始化；2）获取数据库连接，如果配置了过滤器，则在连接池前面增加过滤器（过滤器在以后的文章详细介绍）。
首先我们看下初始化方法init()：
public void init() throws SQLException {
if (inited) {
return;//防止重复初始化
}
DruidDriver.getInstance();//创建DruidDriver对象
final ReentrantLock lock = this.lock;
try {
lock.lockInterruptibly();//加锁防止并发初始化，同时响应中断
} catch (InterruptedException e) {
throw new SQLException("interrupt", e);
}
boolean init = false;
try {
if (inited) {
return;//加锁后，再次判断是否已经初始化过
}
//记录当前线程的堆栈信息，应用程序可以获取该属性做一些加工处理
initStackTrace = Utils.toString(Thread.currentThread().getStackTrace());
//作为初始化下面四个属性的种子，启动的时候从1开始
this.id = DruidDriver.createDataSourceId();
//当创建多个数据源的时候，id才会出现大于1的情况，如果只有一个数据源对象，id为1
if (this.id > 1) {
long delta = (this.id - 1) * 100000;
//作为数据库连接的一个标示，打印日志时使用
this.connectionIdSeedUpdater.addAndGet(this, delta);
//在过滤器中使用，作为Statement代理对象的一个标示，打印日志时使用
this.statementIdSeedUpdater.addAndGet(this, delta);
//在过滤器中使用，作为ResultSet代理对象的一个标示
this.resultSetIdSeedUpdater.addAndGet(this, delta);
//作为TransactionInfo对象的一个标示
this.transactionIdSeedUpdater.addAndGet(this, delta);
}
if (this.jdbcUrl != null) {
this.jdbcUrl = this.jdbcUrl.trim();
//根据jdbcUrl中的信息初始化数据库连接url、过滤器
//这要求jdbcUrl必须以jdbc:wrap-jdbc:开头
initFromWrapDriverUrl();
//根据jdbcUrl初始化socketTimeOut和connectTimeOut，目前只能对mysql使用这种方式初始化
initFromUrlOrProperties();
}
if (connectTimeout == 0) {
socketTimeout = DEFAULT_TIME_CONNECT_TIMEOUT_MILLIS;
}
if (socketTimeout == 0) {
socketTimeout = DEFAULT_TIME_SOCKET_TIMEOUT_MILLIS;
}
//初始化过滤器
for (Filter filter : filters) {
filter.init(this);
}
//从url中判断出数据库类型，比如是db2还是mysql
if (this.dbTypeName == null || this.dbTypeName.length() == 0) {
this.dbTypeName = JdbcUtils.getDbType(jdbcUrl, null);
}
DbType dbType = DbType.of(this.dbTypeName);
if (JdbcUtils.isMysqlDbType(dbType)) {
boolean cacheServerConfigurationSet = false;
if (this.connectProperties.containsKey("cacheServerConfiguration")) {
cacheServerConfigurationSet = true;
} else if (this.jdbcUrl.indexOf("cacheServerConfiguration") != -1) {
cacheServerConfigurationSet = true;
}
if (cacheServerConfigurationSet) {
this.connectProperties.put("cacheServerConfiguration", "true");
}
}
//对属性值进行校验
if (maxActive <= 0) {
throw new IllegalArgumentException("illegal maxActive " + maxActive);
}
if (maxActive < minIdle) {
throw new IllegalArgumentException("illegal maxActive " + maxActive);
}
if (getInitialSize() > maxActive) {
throw new IllegalArgumentException("illegal initialSize " + this.initialSize + ", maxActive " + maxActive);
}
if (timeBetweenLogStatsMillis > 0 && useGlobalDataSourceStat) {
throw new IllegalArgumentException("timeBetweenLogStatsMillis not support useGlobalDataSourceStat=true");
}
if (maxEvictableIdleTimeMillis < minEvictableIdleTimeMillis) {
throw new SQLException("maxEvictableIdleTimeMillis must be grater than minEvictableIdleTimeMillis");
}
if (keepAlive && keepAliveBetweenTimeMillis <= timeBetweenEvictionRunsMillis) {
throw new SQLException("keepAliveBetweenTimeMillis must be grater than timeBetweenEvictionRunsMillis");
}
if (this.driverClass != null) {
this.driverClass = driverClass.trim();
}
//加载配置了@AutoLoad的过滤器，不过可以通过设置loadSpifilterSkip跳过该方法
initFromSPIServiceLoader();
//获得DriverClass类的全限定类名
resolveDriver();
//对db2和oracle的validationQuery属性值做一下检查，检查语句是否符合语法
initCheck();
//当调用Connection对象的setNetworkTimeout方法时，通过netTimeoutExecutor执行回调处理
this.netTimeoutExecutor = new SynchronousExecutor();
//创建ExceptionSorter对象，
//ExceptionSorter的作用是当数据库出现异常时，通过它判断是否是致命异常，如果是，数据源可能会废弃当前连接，重新创建
initExceptionSorter();
//初始化ValidConnectionChecker对象，该对象可以在创建连接或者使用连接前做一些检查，
//比如执行validationQuery语句，或者调用mysql的ConnectionImpl.pingInternal()
initValidConnectionChecker();
//检查一些参数，如果参数设置有问题，会打印日志
validationQueryCheck();
//创建监控对象JdbcDataSourceStat
if (isUseGlobalDataSourceStat()) {
dataSourceStat = JdbcDataSourceStat.getGlobal();
if (dataSourceStat == null) {
dataSourceStat = new JdbcDataSourceStat("Global", "Global", this.dbTypeName);
JdbcDataSourceStat.setGlobal(dataSourceStat);
}
if (dataSourceStat.getDbType() == null) {
dataSourceStat.setDbType(this.dbTypeName);
}
} else {
dataSourceStat = new JdbcDataSourceStat(this.name, this.jdbcUrl, this.dbTypeName, this.connectProperties);
}
dataSourceStat.setResetStatEnable(this.resetStatEnable);
//创建存储连接对象的数组
connections = new DruidConnectionHolder[maxActive];
evictConnections = new DruidConnectionHolder[maxActive];
keepAliveConnections = new DruidConnectionHolder[maxActive];
SQLException connectError = null;
//创建连接对象，这里可以在定时任务中创建，也可以同步创建
//创建对象的过程下文详细介绍
if (createScheduler != null && asyncInit) {
for (int i = 0; i < initialSize; ++i) {
submitCreateTask(true);
}
} else if (!asyncInit) {
// init connections
while (poolingCount < initialSize) {
try {
PhysicalConnectionInfo pyConnectInfo = createPhysicalConnection();
DruidConnectionHolder holder = new DruidConnectionHolder(this, pyConnectInfo);
connections[poolingCount++] = holder;
} catch (SQLException ex) {
LOG.error("init datasource error, url: " + this.getUrl(), ex);
if (initExceptionThrow) {
connectError = ex;
break;
} else {
Thread.sleep(3000);
}
}
}
if (poolingCount > 0) {
poolingPeak = poolingCount;
poolingPeakTime = System.currentTimeMillis();
}
}
//创建打印日志的线程，每过timeBetweenLogStatsMillis毫秒后打印一次数据源日志
//该日志会把一些重要的参数信息打印出来，并且还会打印出存活线程数
//如果timeBetweenLogStatsMillis的值为小于等于0，则不会创建该线程
createAndLogThread();
//如果createScheduler为null，则创建CreateConnectionThread后台线程
//该线程的作用为创建连接对象
createAndStartCreatorThread();
//创建一个后台线程，每过一段时间检查是否有不可用的线程，如果有则剔除
createAndStartDestroyThread();
initedLatch.await();
init = true;
initedTime = new Date();
registerMbean();
if (connectError != null && poolingCount == 0) {
throw connectError;
}
//keepAlive默认为false，如果设置为true，则会创建minIdle个连接
if (keepAlive) {
// async fill to minIdle
if (createScheduler != null) {
for (int i = 0; i < minIdle; ++i) {
submitCreateTask(true);
}
} else {
this.emptySignal();
}
}
} catch (Error e) {
LOG.error("{dataSource-" + this.getID() + "} init error", e);
throw e;
} finally {
inited = true;
lock.unlock();//解锁
}
}可以看到init()方法主要是做参数的初始化，然后就创建连接对象，执行完init()方法后，如果设置了过滤器，则先执行过滤器，否则调用getConnectionDirect()方法，该方法用于返回连接对象。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
