零、回顾之前使用的动态代理的方式实现的数据库连接池：
代码：
1 package day16.utils;
2
3 import java.io.IOException;
4 import java.lang.reflect.InvocationHandler;
5 import java.lang.reflect.Method;
6 import java.lang.reflect.Proxy;
7 import java.sql.Connection;
8 import java.sql.DriverManager;
9 import java.sql.SQLException;
10 import java.util.LinkedList;
11 import java.util.Properties;
12
13 public class JDBCUtils {
14 private static LinkedList<Connection>pool=new LinkedList<Connection>();//定义连接池，使用LinkedList能提高效率
15 static{
16 Properties properties=new Properties();
17 try {
18 properties.load(JDBCUtils.class.getClassLoader().getResourceAsStream("config.properties"));
19 String driver=properties.getProperty("driver");
20 String username=properties.getProperty("username");
21 String password=properties.getProperty("password");
22 String url=properties.getProperty("url");
23 int connectionMaxNum=Integer.parseInt(properties.getProperty("connectionMaxNum"));
24 Class.forName(driver);
25 for(int i=0;i<connectionMaxNum;i++)
26 {
27 final Connection conn=DriverManager.getConnection(url, username, password);
28 //关键的一步：进行代理设置。
29 Object proxy=Proxy.newProxyInstance(
30 JDBCUtils.class.getClassLoader()
31 , new Class[]{Connection.class},
32 new InvocationHandler() {
33 @Override
34 public Object invoke(Object proxy, Method method, Object[] args)
35 throws Throwable {
36 //如果调用了close方法，则不要关闭连接，而应当将连接回收。
37 if(method.getName().equals("close"))
38 {
39 synchronized(pool)
40 {
41 pool.addLast((Connection) proxy);//这里进行强制转换
42 System.out.println("调用了close方法！回收 "+proxy+" ,剩余连接数为"+pool.size());
43 pool.notify();//从等待池中唤醒任意一条线程
44 }
45 return null;//返回值是null表名拦截该方法的执行。这里的return位置非常重要，一不小心就会是的创建反射对象失败
46 }
47 //如果调用了其他的方法，则要放行
48 else
49 {
50 System.out.println("调用了 "+method.getName()+" 方法，放行！");
51 return method.invoke(conn, args);//注意这里的对象是conn，而不是其它对象
52 }
53 }
54 });
55 // System.out.println(proxy);
56 pool.addLast((Connection) proxy);//这里添加的一定是被代理的对象
57 }
58 System.out.println(pool);
59 } catch (IOException e) {
60 e.printStackTrace();
61 } catch (ClassNotFoundException e) {
62 e.printStackTrace();
63 } catch (SQLException e) {
64 e.printStackTrace();
65 }
66 }
67 //获得连接对象的方法
68 public static Connection getConnection()
69 {
70 synchronized (pool) {
71 if(pool.size()==0)
72 {
73 System.out.println("连接池中没有可用连接，等待中------------");
74 try {
75 pool.wait();//等待的方式，使用的是pool*************************
76 } catch (InterruptedException e) {
77 e.printStackTrace();
78 }
79 return getConnection();//递归调用该方法目的是解锁之后重新获得连接
80 }
81 else
82 {
83 Connection conn=pool.removeFirst();
84 System.out.println("分配一条连接,剩余连接数目为"+pool.size());
85 return conn;
86 }
87 }
88 }
89 }
JDBCUtils.java
测试：
public void testByProxy() throws SQLException
{
Connection conn1=JDBCUtils.getConnection();
Connection conn2=JDBCUtils.getConnection();
Connection conn3=JDBCUtils.getConnection();
conn1.close();
Connection conn4=JDBCUtils.getConnection();
}
测试代码
运行结果：
调用了 toString 方法，放行！ 调用了 toString 方法，放行！ 调用了 toString 方法，放行！ [[email protected], [email protected], [email protected]] 分配一条连接,剩余连接数目为2 分配一条连接,剩余连接数目为1 分配一条连接,剩余连接数目为0 调用了 toString 方法，放行！ 调用了close方法！回收 [email protected] ,剩余连接数为1 分配一条连接,剩余连接数目为0
运行结果
和之前的相比有些改进：连接池使用LinkedList，效率更高。
功能增强的方式有两种：
1.使用动态代理的方式
2.使用包装的方式
实际上实现数据库连接池只需要实现一个接口：DataSource，然后改连接池就实现了标准化~
一、使用动态代理实现数据库连接池。
1.数据库连接池动态代理实现方式
package day16.utils;
//实现DataSource接口使用反射机制实现数据库连接池。
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.LinkedList;
import java.util.Properties;
import java.util.logging.Logger;
import javax.sql.DataSource;
public class DBCPPools implements DataSource{
private LinkedList<Connection>pools=new LinkedList<Connection>();
public DBCPPools()
{
try {
Properties config=new Properties();
config.load(DBCPPools.class.getClassLoader().getResourceAsStream("config.properties"));
Class.forName(config.getProperty("driver"));
String url=config.getProperty("url");
String username=config.getProperty("username");
String password=config.getProperty("password");
for(int i=0;i<3;i++)
{
final Connection conn=DriverManager.getConnection(url,username,password);
Object proxy=Proxy.newProxyInstance(
DBCPPools.class.getClassLoader(),
new Class[]{Connection.class},
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
if(method.getName().equals("close"))
{
synchronized(pools)
{
pools.addLast((Connection) proxy);
System.out.println("调用了close方法！回收 "+proxy+" ,剩余连接数为"+pools.size());
pools.notify();
}
return null;
}
else
{
// System.out.println(proxy(这里不能写上proxy，否则异常报出！！！！为什么？？？？)+"调用了 "+method.getName()+" 方法，放行！");
System.out.println("调用了 "+method.getName()+" 方法，放行！");
return method.invoke(conn, args);
}
}
});
pools.add((Connection) proxy);
}
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
}
//最重要的是实现这个方法。
@Override
public Connection getConnection(){
synchronized(pools)
{
if(pools.size()==0)
{
System.out.println("连接池中没有可用连接，等待中------------");
try {
pools.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
return getConnection();
}
else
{
Connection conn=pools.removeFirst();
System.out.println("分配一条连接,剩余连接数目为"+pools.size());
return conn;
}
}
}
@Override
public PrintWriter getLogWriter() throws SQLException {
return null;
}
@Override
public void setLogWriter(PrintWriter out) throws SQLException {
}
@Override
public void setLoginTimeout(int seconds) throws SQLException {
}
@Override
public int getLoginTimeout() throws SQLException {
return 0;
}
@Override
public <T> T unwrap(Class<T> iface) throws SQLException {
return null;
}
@Override
public boolean isWrapperFor(Class<?> iface) throws SQLException {
return false;
}
@Override
public Connection getConnection(String username, String password)
throws SQLException {
return null;
}
@Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
return null;
}
}
DBCPPools.java
2.测试代码
public void testImplementsDataSourceInterfaceByProxy() throws SQLException
{
DBCPPools pool=new DBCPPools();
Connection conn1=pool.getConnection();
System.out.println(conn1);
System.out.println();
Connection conn2=pool.getConnection();
System.out.println(conn2);
System.out.println();
Connection conn3=pool.getConnection();
System.out.println(conn3);
System.out.println();
// conn1.close();//如果这里没有注释掉，则可以拿到第四条连接，连接池大小默认为3
Connection conn4=pool.getConnection();//第四条连接因为拿不到连接而进入等待池中。
System.out.println(conn4);
}
运行结果：
分配一条连接,剩余连接数目为2 调用了 toString 方法，放行！ com.mysql.jdbc.J[email protected] 分配一条连接,剩余连接数目为1 调用了 toString 方法，放行！ [email protected] 分配一条连接,剩余连接数目为0 调用了 toString 方法，放行！ [email protected] 连接池中没有可用连接，等待中------------
将关闭连接的代码放开：
分配一条连接,剩余连接数目为2 调用了 toString 方法，放行！ [email protected] 分配一条连接,剩余连接数目为1 调用了 toString 方法，放行！ [email protected] 分配一条连接,剩余连接数目为0 调用了 toString 方法，放行！ [email protected] 调用了 toString 方法，放行！ 调用了close方法！回收 [email protected] ,剩余连接数为1 分配一条连接,剩余连接数目为0 调用了 toString 方法，放行！ [email protected]
二、使用包装的方法实现自定义数据库连接池
1.包装对象：Connection类，这里作为数据库连接池的一个内部类（MyConnection）。
2.使用包装的方法实现的数据库连接池：
1 package day16.utils;
2
3 import java.io.PrintWriter;
4 import java.sql.Array;
5 import java.sql.Blob;
6 import java.sql.CallableStatement;
7 import java.sql.Clob;
8 import java.sql.Connection;
9 import java.sql.DatabaseMetaData;
10 import java.sql.DriverManager;
11 import java.sql.NClob;
12 import java.sql.PreparedStatement;
13 import java.sql.SQLClientInfoException;
14 import java.sql.SQLException;
15 import java.sql.SQLFeatureNotSupportedException;
16 import java.sql.SQLWarning;
17 import java.sql.SQLXML;
18 import java.sql.Savepoint;
19 import java.sql.Statement;
20 import java.sql.Struct;
21 import java.util.LinkedList;
22 import java.util.Map;
23 import java.util.Properties;
24 import java.util.concurrent.Executor;
25 import java.util.logging.Logger;
26
27 import javax.sql.DataSource;
28
29 //测试使用包装的方法定义一个数据库连接池
30 public class MyDBCPpool implements DataSource{
31 private LinkedList<Connection> pool =new LinkedList<Connection>();
32 public MyDBCPpool()
33 {
34 Properties properties=new Properties();
35 try {
36 properties.load(JDBCUtils.class.getClassLoader().getResourceAsStream("config.properties"));
37 String driver=properties.getProperty("driver");
38 String username=properties.getProperty("username");
39 String password=properties.getProperty("password");
40 String url=properties.getProperty("url");
41 int connectionMaxNum=Integer.parseInt(properties.getProperty("connectionMaxNum"));
42 Class.forName(driver);
43 for(int i=0;i<connectionMaxNum;i++)
44 {
45 Connection conn=DriverManager.getConnection(url,username,password);
46 MyConnection connection =new MyConnection(conn);
47 pool.addLast(connection);
48 }
49 }
50 catch(Exception e)
51 {
52 e.printStackTrace();
53 }
54 }
55 @Override
56 public Connection getConnection() throws SQLException {
57 System.out.println(pool);
58 synchronized(pool)
59 {
60 if(pool.size()==0)
61 {
62 try {
63 pool.wait();
64 } catch (InterruptedException e) {
65 e.printStackTrace();
66 }
67 return getConnection();
68 }
69 else
70 {
71 Connection conn=pool.removeFirst();
72 System.out.println("分配出一条连接："+conn+" 剩余"+pool.size()+" 条连接！");
73 return conn;
74 }
75 }
76 }
77 @Override
78 public Connection getConnection(String username, String password)
79 throws SQLException {
80 return null;
81 }
82 @Override
83 public PrintWriter getLogWriter() throws SQLException {
84 return null;
85 }
86 @Override
87 public void setLogWriter(PrintWriter out) throws SQLException {
88 }
89 @Override
90 public void setLoginTimeout(int seconds) throws SQLException {
91 }
92 @Override
93 public int getLoginTimeout() throws SQLException {
94 return 0;
95 }
96 // @Override
97 public Logger getParentLogger() throws SQLFeatureNotSupportedException {
98 return null;
99 }
100 @Override
101 public <T> T unwrap(Class<T> iface) throws SQLException {
102 return null;
103 }
104 @Override
105 public boolean isWrapperFor(Class<?> iface) throws SQLException {
106 return false;
107 }
108 class MyConnection implements Connection
109 {
110 private Connection conn;
111 public MyConnection(Connection conn){
112 this.conn=conn;
113 }
114 //重写close方法
115 @Override
116 public void close() throws SQLException {
117 synchronized(pool)
118 {120 pool.addLast(this); System.out.println(this+"还连接！剩余连接数："+pool.size());
121 pool.notify();
122 }
123 }
124 @Override
125 public <T> T unwrap(Class<T> iface) throws SQLException {
126 return conn.unwrap(iface);
127 }
128 @Override
129 public boolean isWrapperFor(Class<?> iface) throws SQLException {
130 return conn.isWrapperFor(iface);
131 }
132 @Override
133 public Statement createStatement() throws SQLException {
134 return conn.createStatement();
135 }
136 @Override
137 public PreparedStatement prepareStatement(String sql)
138 throws SQLException {
139 return conn.prepareStatement(sql);
140 }
141 @Override
142 public CallableStatement prepareCall(String sql) throws SQLException {
143 return conn.prepareCall(sql);
144 }
145 @Override
146 public String nativeSQL(String sql) throws SQLException {
147 return conn.nativeSQL(sql);
148 }
149 @Override
150 public void setAutoCommit(boolean autoCommit) throws SQLException {
151 conn.setAutoCommit(autoCommit);
152 }
153 @Override
154 public boolean getAutoCommit() throws SQLException {
155 return conn.getAutoCommit();
156 }
157 @Override
158 public void commit() throws SQLException {
159 conn.commit();
160 }
161 @Override
162 public void rollback() throws SQLException {
163 conn.rollback();
164 }
165 @Override
166 public boolean isClosed() throws SQLException {
167 return conn.isClosed();
168 }
169 @Override
170 public DatabaseMetaData getMetaData() throws SQLException {
171 return conn.getMetaData();
172 }
173 @Override
174 public void setReadOnly(boolean readOnly) throws SQLException {
175 conn.setReadOnly(readOnly);
176 }
177 @Override
178 public boolean isReadOnly() throws SQLException {
179 return conn.isReadOnly();
180 }
181 @Override
182 public void setCatalog(String catalog) throws SQLException {
183 conn.setCatalog(catalog);
184 }
185 @Override
186 public String getCatalog() throws SQLException {
187 return conn.getCatalog();
188 }
189 @Override
190 public void setTransactionIsolation(int level) throws SQLException {
191 conn.setTransactionIsolation(level);
192 }
193 @Override
194 public int getTransactionIsolation() throws SQLException {
195 return conn.getTransactionIsolation();
196 }
197 @Override
198 public SQLWarning getWarnings() throws SQLException {
199 return conn.getWarnings();
200 }
201 @Override
202 public void clearWarnings() throws SQLException {
203 conn.clearWarnings();
204 }
205 @Override
206 public Statement createStatement(int resultSetType,
207 int resultSetConcurrency) throws SQLException {
208 return conn.createStatement(resultSetType, resultSetConcurrency);
209 }
210 @Override
211 public PreparedStatement prepareStatement(String sql,
212 int resultSetType, int resultSetConcurrency)
213 throws SQLException {
214 return conn.prepareStatement(sql, resultSetType, resultSetConcurrency);
215 }
216 @Override
217 public CallableStatement prepareCall(String sql, int resultSetType,
218 int resultSetConcurrency) throws SQLException {
219 return conn.prepareCall(sql, resultSetType, resultSetConcurrency);
220 }
221 @Override
222 public Map<String, Class<?>> getTypeMap() throws SQLException {
223 return conn.getTypeMap();
224 }
225 @Override
226 public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
227 conn.setTypeMap(map);
228 }
229 @Override
230 public void setHoldability(int holdability) throws SQLException {
231 conn.setHoldability(holdability);
232 }
233 @Override
234 public int getHoldability() throws SQLException {
235 return conn.getHoldability();
236 }
237 @Override
238 public Savepoint setSavepoint() throws SQLException {
239 return conn.setSavepoint();
240 }
241 @Override
242 public Savepoint setSavepoint(String name) throws SQLException {
243 return conn.setSavepoint(name);
244 }
245 @Override
246 public void rollback(Savepoint savepoint) throws SQLException {
247 conn.rollback(savepoint);
248 }
249 @Override
250 public void releaseSavepoint(Savepoint savepoint) throws SQLException {
251 conn.releaseSavepoint(savepoint);
252 }
253 @Override
254 public Statement createStatement(int resultSetType,
255 int resultSetConcurrency, int resultSetHoldability)
256 throws SQLException {
257 return conn.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);
258 }
259 @Override
260 public PreparedStatement prepareStatement(String sql,
261 int resultSetType, int resultSetConcurrency,
262 int resultSetHoldability) throws SQLException {
263 return conn.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
264 }
265 @Override
266 public CallableStatement prepareCall(String sql, int resultSetType,
267 int resultSetConcurrency, int resultSetHoldability)
268 throws SQLException {
269 return conn.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
270 }
271 @Override
272 public PreparedStatement prepareStatement(String sql,
273 int autoGeneratedKeys) throws SQLException {
274 return conn.prepareStatement(sql, autoGeneratedKeys);
275 }
276 @Override
277 public PreparedStatement prepareStatement(String sql,
278 int[] columnIndexes) throws SQLException {
279 return conn.prepareStatement(sql, columnIndexes);
280 }
281 @Override
282 public PreparedStatement prepareStatement(String sql,
283 String[] columnNames) throws SQLException {
284 return conn.prepareStatement(sql, columnNames);
285 }
286 @Override
287 public Clob createClob() throws SQLException {
288 return conn.createClob();
289 }
290 @Override
291 public Blob createBlob() throws SQLException {
292 return conn.createBlob();
293 }
294 @Override
295 public NClob createNClob() throws SQLException {
296 return conn.createNClob();
297 }
298 @Override
299 public SQLXML createSQLXML() throws SQLException {
300 return conn.createSQLXML();
301 }
302 @Override
303 public boolean isValid(int timeout) throws SQLException {
304 return conn.isValid(timeout);
305 }
306 @Override
307 public void setClientInfo(String name, String value)
308 throws SQLClientInfoException {
309 conn.setClientInfo(name, value);
310 }
311 @Override
312 public void setClientInfo(Properties properties)
313 throws SQLClientInfoException {
314 conn.setClientInfo(properties);
315 }
316 @Override
317 public String getClientInfo(String name) throws SQLException {
318 return conn.getClientInfo(name);
319 }
320 @Override
321 public Properties getClientInfo() throws SQLException {
322 return conn.getClientInfo();
323 }
324 @Override
325 public Array createArrayOf(String typeName, Object[] elements)
326 throws SQLException {
327 return conn.createArrayOf(typeName, elements);
328 }
329 @Override
330 public Struct createStruct(String typeName, Object[] attributes)
331 throws SQLException {
332 return conn.createStruct(typeName, attributes);
333 }
334 @Override
335 public void setSchema(String schema) throws SQLException {
336 }
337 @Override
338 public String getSchema() throws SQLException {
339 return conn.getSchema();
340 }
341 @Override
342 public void abort(Executor executor) throws SQLException {
343 }
344 @Override
345 public void setNetworkTimeout(Executor executor, int milliseconds)
346 throws SQLException {
347 }
348 @Override
349 public int getNetworkTimeout() throws SQLException {
350 return conn.getNetworkTimeout();
351 }
352 }
353 }
3.和之前的相比有哪些改动？
（1）将数据库连接池的初始化放在了构造方法中。
（2）连接池中放的是重写的Connection对象。
（3）没有使用动态代理，效率更高。
（4）将重写的Connection类放到了连接池类的内部作为内部类使用。
4.测试代码
public void testMyDBCPpool() throws SQLException
{
MyDBCPpool pool=new MyDBCPpool();
Connection conn1=pool.getConnection();
System.out.println(conn1);
Connection conn2=pool.getConnection();
System.out.println(conn2);
Connection conn3=pool.getConnection();
System.out.println(conn3);
conn1.close();
Connection conn4=pool.getConnection();//第四条连接因为拿不到连接而进入等待池中。
System.out.println(conn4);
}
6.运行结果：
[[email protected], [email protected], [email protected]] 分配出一条连接：[email protected]13f7cd2 剩余2 条连接！ [email protected] [[email protected], [email protected]] 分配出一条连接：[email protected] 剩余1 条连接！ [email protected] [[email protected]] 分配出一条连接：[email protected] 剩余0 条连接！ [email protected] [email protected]还连接！剩余连接数：1 [[email protected]] 分配出一条连接：[email protected]13f7cd2 剩余0 条连接！ [email protected]
分析和总结：实际上使用DBCP数据库连接池原理和这基本上差不多，所以该数据库连接池的名字为MyDBCPpool，下面开始进入正题。
【Java EE 学习第16天】【dbcp数据库连接池】【c3p0数据库连接池】
时间： 2024-10-21 17:03:55