数据库连接池

package com.kyo.connection;

002

003	import java.sql.Connection;

004	import java.sql.DatabaseMetaData;

005	import java.sql.Driver;

006	import java.sql.DriverManager;

007	import java.sql.SQLException;

008	import java.sql.Statement;

009	import java.util.Enumeration;

010	import java.util.Vector;

011

012	public class ConnectionPool {

013

014	private ConnectionParam param;

015

016	private String testTable = ""; // 测试连接是否可用的测试表名，默认没有测试表

017

018	private Vector connections = null; // 存放连接池中数据库连接的向量 , 初始时为

019	// null,它中存放的对象为PooledConnection 型

020

021	public void setParam(ConnectionParam param) {

022	this.param = param;

023

}

024

025	public ConnectionParam getParam() {

026	return param;

027

}

028

029

/**

030

* 构造函数

031

*

032	* @param param

033

*/

034	public ConnectionPool(ConnectionParam param) {

035	this.param = param;

036

}

037

038

/**

039

*

040	* 获取测试数据库表的名字

041

*

042	* @return 测试数据库表的名字

043

*/

044

045	public String getTestTable() {

046	return this.testTable;

047

}

048

049

/**

050

*

051	* 设置测试表的名字

052

*

053	* @param testTable

054	*            String 测试表的名字

055

*/

056

057	public void setTestTable(String testTable) {

058	this.testTable = testTable;

059

}

060

061

/**

062	* 创建一个数据库连接池，连接池中的可用连接的数量采用类成员 initialConnections 中设置的值

063

*/

064

065	public synchronized void createPool() throws Exception {

066

067	// 确保连接池没有创建

068	// 如果连接池己经创建了，保存连接的向量 connections 不会为空

069	if (connections != null) {

070	return; // 如果己经创建，则返回

071

}

072

073	// 实例化 JDBC Driver 中指定的驱动类实例

074	Driver driver = (Driver) (Class.forName(this.param.getDriver())

075	.newInstance());

076	DriverManager.registerDriver(driver); // 注册 JDBC 驱动程序

077	// 创建保存连接的向量 , 初始时有 0 个元素

078	connections = new Vector();

079

080	// 根据 initialConnections 中设置的值，创建连接。

081	createConnections(this.param.getMinConnection());

082	System.out.println(" 数据库连接池创建成功！ ");

083

084

}

085

086

/**

087

*

088	* 创建由 numConnections 指定数目的数据库连接 , 并把这些连接 放入 connections 向量中

089

*

090	* @param numConnections

091	*            要创建的数据库连接的数目

092

*/

093

094	private void createConnections(int numConnections) throws SQLException {

095

096	// 循环创建指定数目的数据库连接

097	for (int x = 0; x < numConnections; x++) {

098	// 是否连接池中的数据库连接的数量己经达到最大？最大值由类成员 maxConnections,指出，如果 maxConnections

099	// 为 0 或负数，表示连接数量没有限制。

100	// 如果连接数己经达到最大，即退出。

101

102	if (this.param.getMaxConnection() > 0

103	&& this.connections.size() >= this.param.getMaxConnection()) {

104

break;

105

}

106

107	// add a new PooledConnection object to connections vector

108	// 增加一个连接到连接池中（向量 connections 中）

109

try {

110	connections.addElement(new PooledConnection(newConnection()));

111	} catch (SQLException e) {

112	System.out.println(" 创建数据库连接失败！ " + e.getMessage());

113	throw new SQLException();

114

}

115

116	System.out.println(" 数据库连接己创建 ......");

117

}

118

119

}

120

121

/**

122

*

123	* 创建一个新的数据库连接并返回它

124

*

125	* @return 返回一个新创建的数据库连接

126

*/

127

128	private Connection newConnection() throws SQLException {

129

130	// 创建一个数据库连接

131	Connection conn = DriverManager.getConnection(this.param.getUrl(),

132	this.param.getUser(), this.param.getPassword());

133

134	// 如果这是第一次创建数据库连接，即检查数据库，获得此数据库允许支持的

135	// 最大客户连接数目

136	// connections.size()==0 表示目前没有连接己被创建

137

138	if (connections.size() == 0) {

139

140	DatabaseMetaData metaData = conn.getMetaData();

141	int driverMaxConnections = metaData.getMaxConnections();

142

143	// 数据库返回的 driverMaxConnections 若为 0 ，表示此数据库没有最大

144	// 连接限制，或数据库的最大连接限制不知道

145	// driverMaxConnections 为返回的一个整数，表示此数据库允许客户连接的数 目

146	// 如果连接池中设置的最大连接数量大于数据库允许的连接数目 , 则置连接池 的最大

147	// 连接数目为数据库允许的最大数目

148

149	if (driverMaxConnections > 0

150	&& this.param.getMaxConnection() > driverMaxConnections) {

151	this.param.setMaxConnection(driverMaxConnections);

152

}

153

}

154	return conn; // 返回创建的新的数据库连接

155

}

156

157

/**

158

*

159	* 通过调用 getFreeConnection() 函数返回一个可用的数据库连接 ,

160

*

161	* 如果当前没有可用的数据库连接，并且更多的数据库连接不能创

162

*

163	* 建（如连接池大小的限制），此函数等待一会再尝试获取。

164

*

165	* @return 返回一个可用的数据库连接对象

166

*/

167

168	public synchronized Connection getConnection() throws SQLException {

169

170	// 确保连接池己被创建

171	if (connections == null) {

172	return null; // 连接池还没创建，则返回 null

173

}

174

175	Connection conn = getFreeConnection(); // 获得一个可用的数据库连接

176	// 如果目前没有可以使用的连接，即所有的连接都在使用中

177

178	while (conn == null) {

179

// 等一会再试

180	wait(250);

181	conn = getFreeConnection(); // 重新再试，直到获得可用的连接，如果

182	// getFreeConnection() 返回的为 null

183	// 则表明创建一批连接后也不可获得可用连接

184

}

185

186	return conn;// 返回获得的可用的连接

187

}

188

189

/**

190

*

191	* 本函数从连接池向量 connections 中返回一个可用的的数据库连接，如果

192

*

193	* 当前没有可用的数据库连接，本函数则根据 incrementalConnections 设置

194

*

195	* 的值创建几个数据库连接，并放入连接池中。

196

*

197	* 如果创建后，所有的连接仍都在使用中，则返回 null

198

*

199	* @return 返回一个可用的数据库连接

200

*/

201

202	private Connection getFreeConnection() throws SQLException {

203

204	// 从连接池中获得一个可用的数据库连接

205	Connection conn = findFreeConnection();

206	if (conn == null) {

207	// 如果目前连接池中没有可用的连接

208

// 创建一些连接

209	createConnections(this.param.getIncrementalConnections());

210	// 重新从池中查找是否有可用连接

211	conn = findFreeConnection();

212	if (conn == null) {

213	// 如果创建连接后仍获得不到可用的连接，则返回 null

214	return null;

215

}

216

}

217	return conn;

218

219

}

220

221

/**

222

*

223	* 查找连接池中所有的连接，查找一个可用的数据库连接，

224

*

225	* 如果没有可用的连接，返回 null

226

*

227	* @return 返回一个可用的数据库连接

228

*/

229

230	private Connection findFreeConnection() throws SQLException {

231

232	Connection conn = null;

233	PooledConnection pConn = null;

234	// 获得连接池向量中所有的对象

235	Enumeration enumerate = connections.elements();

236	// 遍历所有的对象，看是否有可用的连接

237	while (enumerate.hasMoreElements()) {

238	pConn = (PooledConnection) enumerate.nextElement();

239	if (!pConn.isBusy()) {

240	// 如果此对象不忙，则获得它的数据库连接并把它设为忙

241	conn = pConn.getConnection();