JDBC自定义连接池

最近学习了JDBC的相关知识,写一下自定义连接池

一些说明:

本代码参考了部分别人的代码!!!

JDBCCon类具体创建了连接;

MyConnection类集成了Connection类用来管理连接与池,其中的close方法必须pool.add();

MyDataSource则是具体实现连接池。

具体步骤:

1、导mysql的jar包

2、配置db.propertites

1 driver = com.mysql.cj.jdbc.Driver
2 url = jdbc:mysql://localhost:3306/test?serverTimezone=GMT
3 username = root
4 password = root

3、JDBCCon

 1 package com.nick.util;
 2
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5 import java.sql.Connection;
 6 import java.sql.DriverManager;
 7 import java.sql.PreparedStatement;
 8 import java.sql.ResultSet;
 9 import java.sql.SQLException;
10 import java.util.Properties;
11
12 public class JDBCCon {
13
14     private static String driver;
15     private static String url;
16     private static String username;
17     private static String password;
18
19
20     static {
21
22         try {
23             ClassLoader classLoader = JDBCCon.class.getClassLoader();
24             InputStream is = classLoader.getResourceAsStream("db.properties");
25             Properties props = new Properties();
26             props.load(is);
27             driver = props.getProperty("driver");
28             url = props.getProperty("url");
29             username = props.getProperty("username");
30             password = props.getProperty("password");
31         } catch (IOException e) {
32             // TODO Auto-generated catch block
33             e.printStackTrace();
34         }
35
36     }
37
38     public static Connection getConnection() {
39         Connection connection = null;
40         try {
41             Class.forName(driver);
42             connection = DriverManager.getConnection(url, username, password);
43         } catch (Exception e) {
44             // TODO: handle exception
45         }
46         return connection;
47
48     }
49
50     public static void release(Connection conn, PreparedStatement pstmt, ResultSet rs) {
51         if(rs != null) {
52             try {
53                 rs.close();
54             } catch (SQLException e) {
55                 // TODO Auto-generated catch block
56                 e.printStackTrace();
57             }
58         }
59         if(pstmt != null) {
60             try {
61                 pstmt.close();
62             } catch (SQLException e) {
63                 // TODO Auto-generated catch block
64                 e.printStackTrace();
65             }
66         }
67         if(conn != null) {
68             try {
69                 conn.close();
70             } catch (SQLException e) {
71                 // TODO Auto-generated catch block
72                 e.printStackTrace();
73             }
74         }
75
76     }
77
78 }

4、MyConnection

  1 package com.nick.dataSource;
  2
  3 import java.sql.Array;
  4 import java.sql.Blob;
  5 import java.sql.CallableStatement;
  6 import java.sql.Clob;
  7 import java.sql.Connection;
  8 import java.sql.DatabaseMetaData;
  9 import java.sql.NClob;
 10 import java.sql.PreparedStatement;
 11 import java.sql.SQLClientInfoException;
 12 import java.sql.SQLException;
 13 import java.sql.SQLWarning;
 14 import java.sql.SQLXML;
 15 import java.sql.Savepoint;
 16 import java.sql.Statement;
 17 import java.sql.Struct;
 18 import java.util.LinkedList;
 19 import java.util.Map;
 20 import java.util.Properties;
 21 import java.util.concurrent.Executor;
 22
 23 public class MyConnection implements Connection{
 24
 25     private Connection connection = null;
 26     private LinkedList<Connection> pool = null;
 27     public MyConnection(Connection connection, LinkedList<Connection> pool) {
 28         this.connection = connection;
 29         this.pool = pool;
 30     }
 31
 32     @Override
 33     public void close() throws SQLException {
 34         // TODO Auto-generated method stub
 35         pool.add(connection);
 36     }
 37
 38     @Override
 39     public <T> T unwrap(Class<T> iface) throws SQLException {
 40         // TODO Auto-generated method stub
 41         return null;
 42     }
 43     @Override
 44     public boolean isWrapperFor(Class<?> iface) throws SQLException {
 45         // TODO Auto-generated method stub
 46         return false;
 47     }
 48     @Override
 49     public Statement createStatement() throws SQLException {
 50         // TODO Auto-generated method stub
 51         return null;
 52     }
 53     @Override
 54     public PreparedStatement prepareStatement(String sql) throws SQLException {
 55         // TODO Auto-generated method stub
 56         return null;
 57     }
 58     @Override
 59     public CallableStatement prepareCall(String sql) throws SQLException {
 60         // TODO Auto-generated method stub
 61         return null;
 62     }
 63     @Override
 64     public String nativeSQL(String sql) throws SQLException {
 65         // TODO Auto-generated method stub
 66         return null;
 67     }
 68     @Override
 69     public void setAutoCommit(boolean autoCommit) throws SQLException {
 70         // TODO Auto-generated method stub
 71
 72     }
 73     @Override
 74     public boolean getAutoCommit() throws SQLException {
 75         // TODO Auto-generated method stub
 76         return false;
 77     }
 78     @Override
 79     public void commit() throws SQLException {
 80         // TODO Auto-generated method stub
 81
 82     }
 83     @Override
 84     public void rollback() throws SQLException {
 85         // TODO Auto-generated method stub
 86
 87     }
 88
 89     @Override
 90     public boolean isClosed() throws SQLException {
 91         // TODO Auto-generated method stub
 92         return false;
 93     }
 94     @Override
 95     public DatabaseMetaData getMetaData() throws SQLException {
 96         // TODO Auto-generated method stub
 97         return null;
 98     }
 99     @Override
100     public void setReadOnly(boolean readOnly) throws SQLException {
101         // TODO Auto-generated method stub
102
103     }
104     @Override
105     public boolean isReadOnly() throws SQLException {
106         // TODO Auto-generated method stub
107         return false;
108     }
109     @Override
110     public void setCatalog(String catalog) throws SQLException {
111         // TODO Auto-generated method stub
112
113     }
114     @Override
115     public String getCatalog() throws SQLException {
116         // TODO Auto-generated method stub
117         return null;
118     }
119     @Override
120     public void setTransactionIsolation(int level) throws SQLException {
121         // TODO Auto-generated method stub
122
123     }
124     @Override
125     public int getTransactionIsolation() throws SQLException {
126         // TODO Auto-generated method stub
127         return 0;
128     }
129     @Override
130     public SQLWarning getWarnings() throws SQLException {
131         // TODO Auto-generated method stub
132         return null;
133     }
134     @Override
135     public void clearWarnings() throws SQLException {
136         // TODO Auto-generated method stub
137
138     }
139     @Override
140     public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
141         // TODO Auto-generated method stub
142         return null;
143     }
144     @Override
145     public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency)
146             throws SQLException {
147         // TODO Auto-generated method stub
148         return null;
149     }
150     @Override
151     public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
152         // TODO Auto-generated method stub
153         return null;
154     }
155     @Override
156     public Map<String, Class<?>> getTypeMap() throws SQLException {
157         // TODO Auto-generated method stub
158         return null;
159     }
160     @Override
161     public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
162         // TODO Auto-generated method stub
163
164     }
165     @Override
166     public void setHoldability(int holdability) throws SQLException {
167         // TODO Auto-generated method stub
168
169     }
170     @Override
171     public int getHoldability() throws SQLException {
172         // TODO Auto-generated method stub
173         return 0;
174     }
175     @Override
176     public Savepoint setSavepoint() throws SQLException {
177         // TODO Auto-generated method stub
178         return null;
179     }
180     @Override
181     public Savepoint setSavepoint(String name) throws SQLException {
182         // TODO Auto-generated method stub
183         return null;
184     }
185     @Override
186     public void rollback(Savepoint savepoint) throws SQLException {
187         // TODO Auto-generated method stub
188
189     }
190     @Override
191     public void releaseSavepoint(Savepoint savepoint) throws SQLException {
192         // TODO Auto-generated method stub
193
194     }
195     @Override
196     public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)
197             throws SQLException {
198         // TODO Auto-generated method stub
199         return null;
200     }
201     @Override
202     public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency,
203             int resultSetHoldability) throws SQLException {
204         // TODO Auto-generated method stub
205         return null;
206     }
207     @Override
208     public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency,
209             int resultSetHoldability) throws SQLException {
210         // TODO Auto-generated method stub
211         return null;
212     }
213     @Override
214     public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
215         // TODO Auto-generated method stub
216         return null;
217     }
218     @Override
219     public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
220         // TODO Auto-generated method stub
221         return null;
222     }
223     @Override
224     public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
225         // TODO Auto-generated method stub
226         return null;
227     }
228     @Override
229     public Clob createClob() throws SQLException {
230         // TODO Auto-generated method stub
231         return null;
232     }
233     @Override
234     public Blob createBlob() throws SQLException {
235         // TODO Auto-generated method stub
236         return null;
237     }
238     @Override
239     public NClob createNClob() throws SQLException {
240         // TODO Auto-generated method stub
241         return null;
242     }
243     @Override
244     public SQLXML createSQLXML() throws SQLException {
245         // TODO Auto-generated method stub
246         return null;
247     }
248     @Override
249     public boolean isValid(int timeout) throws SQLException {
250         // TODO Auto-generated method stub
251         return false;
252     }
253     @Override
254     public void setClientInfo(String name, String value) throws SQLClientInfoException {
255         // TODO Auto-generated method stub
256
257     }
258     @Override
259     public void setClientInfo(Properties properties) throws SQLClientInfoException {
260         // TODO Auto-generated method stub
261
262     }
263     @Override
264     public String getClientInfo(String name) throws SQLException {
265         // TODO Auto-generated method stub
266         return null;
267     }
268     @Override
269     public Properties getClientInfo() throws SQLException {
270         // TODO Auto-generated method stub
271         return null;
272     }
273     @Override
274     public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
275         // TODO Auto-generated method stub
276         return null;
277     }
278     @Override
279     public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
280         // TODO Auto-generated method stub
281         return null;
282     }
283     @Override
284     public void setSchema(String schema) throws SQLException {
285         // TODO Auto-generated method stub
286
287     }
288     @Override
289     public String getSchema() throws SQLException {
290         // TODO Auto-generated method stub
291         return null;
292     }
293     @Override
294     public void abort(Executor executor) throws SQLException {
295         // TODO Auto-generated method stub
296
297     }
298     @Override
299     public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException {
300         // TODO Auto-generated method stub
301
302     }
303     @Override
304     public int getNetworkTimeout() throws SQLException {
305         // TODO Auto-generated method stub
306         return 0;
307     }
308 }

5、MyDataSource

 1 package com.nick.dataSource;
 2
 3 import java.sql.Connection;
 4 import java.util.LinkedList;
 5
 6 import com.nick.util.JDBCCon;
 7
 8 public class MyDataSource {
 9
10     private static LinkedList<Connection> pool = new LinkedList<Connection>();
11
12     static {
13         //
14         for(int i = 0; i < 5; i++) {
15             Connection connection = JDBCCon.getConnection();
16             pool.add(connection);
17         }
18     }
19
20     public static Connection getConnection() {
21         if(pool.size() == 0) {
22             for(int i = 0; i < 5; i++) {
23                 Connection connection = JDBCCon.getConnection();
24                 MyConnection myConnection = new MyConnection(connection, pool);
25                 pool.add(myConnection);
26             }
27         }
28         Connection connection = pool.remove(0);
29         return connection;
30
31     }
32 }

6、检测代码

 1 package com.nick.test;
 2
 3 import java.sql.Connection;
 4 import java.sql.PreparedStatement;
 5
 6 import org.junit.jupiter.api.Test;
 7
 8 import com.nick.dataSource.MyDataSource;
 9 import com.nick.util.JDBCCon;
10
11 public class TestDemo01 {
12
13     @Test
14     public void t1() {
15         Connection connection = null;
16         PreparedStatement pstmt = null;
17         MyDataSource myDataSource = new MyDataSource();
18         try {
19             connection = myDataSource.getConnection();
20             String sql = "insert into student values (?,?,?,?)";
21             PreparedStatement prepareStatement = connection.prepareStatement(sql);
22             prepareStatement.setInt(1, 10);
23             prepareStatement.setString(2, "吕布");
24             prepareStatement.setString(3, "男");
25             prepareStatement.setInt(4, 100);
26             int rows = prepareStatement.executeUpdate();
27             if(rows > 0) {
28                 System.out.println("OK");
29             }else {
30                 System.out.println("NO");
31             }
32         } catch (Exception e) {
33             // TODO: handle exception
34         }
35     }
36 }

以上即全部代码。

原文地址:https://www.cnblogs.com/nick9527/p/9873976.html

时间: 2024-10-09 05:08:24

JDBC自定义连接池的相关文章

day18(JDBC事务&连接池介绍&DBUtils工具介绍&BaseServlet作用)

day18总结 今日思维导图: 今日内容 事务 连接池 ThreadLocal BaseServlet自定义Servlet父类(只要求会用,不要求会写) DBUtils à commons-dbutils ? 事务 ? 事务的四大特性:ACID: mysql中操作事务 jdbc中操作事务 ? ? ? 事务概述 为了方便演示事务,我们需要创建一个account表: CREATE TABLE account( ????id INT PRIMARY KEY AUTO_INCREMENT, ????NA

java自定义连接池

1.java自定义连接池 1.1连接池的概念: 实际开发中"获取连接"或"释放资源"是非常消耗系统资源的两个过程,为了姐姐此类性能问题,通常情况我们采用连接池技术来贡献连接Connection 用池来管理Connection,这样可以重复使用Connection,有了池,所以我们就不用自己来创建Connection,而是通过池来获取Connection对象,当使用完Connection后,调用Connection的close()方法也不会真的关闭Connection

自定义连接池(装饰者模式)

连接池概述: 管理数据库的连接, 作用: 提高项目的性能. 就是在连接池初始化的时候存入一定数量的连接,用的时候通过方法获取,不用的时候归还连接即可. 所有的连接池必须实现一个接口 javax.sql.DataSource接口 获取连接方法: Connection getConnection() 归还连接的方法就是以前的释放资源的方法.调用connection.close(); 增强方法: 1.继承 2.装饰者模式(静态代理) 3.动态代理 装饰者模式: 使用步骤: 1.装饰者和被装饰者实现同一

JDBC之 连接池

JDBC之 连接池 有这样的一种现象: 用java代码操作数据库,需要数据库连接对象,一个用户至少要用到一个连接.现在假设有成千上百万个用户,就要创建十分巨大数量的连接对象,这会使数据库承受极大的压力,为了解决这种现象,一种技术出现了,这就是数据库连接池. 什么是数据库连接池(原理) 所谓数据库连接池,可以看作 :在用户和数据库之间创建一个”池”,这个池中有若干个连接对象,当用户想要连接数据库,就要先从连接池中获取连接对象,然后操作数据库.一旦连接池中的连接对象被拿光了,下一个想要操作数据库的用

自定义连接池的问题及解决分析

1.1.1 自定义连接池的问题:1.1.1.1 使用接口的实现类完成的构造MyDataSource dataSource = new MyDataSource();这种写法不方便程序的扩展.1.1.1.2 额外提供了方法归还连接 // 归还连接: dataSource.addBack(conn); 这种方式增加使用连接池的用户的难度.1.1.2 自定义连接池的问题解决如果不提供自定义的方法就可以解决这个问题,但是连接要如何归还到连接池呢?1.1.2.1 解决分析的思路原来在Connection中

集合、多线程、网络编程、JDBC、连接池、反射、综合应用

1.使用TCP连接服务器和客户端. 2.结合反射的知识.创建JDBC和连接池. 3.客户端输入信息并保存到一个对象中,发送到服务器. 4.服务器接收对象,通过JDBC存储进数据库中. 5.把服务器放到线程中,保持启动状态. 6.客户端读取数据库的数据信息,放到集合中. 7.遍历集合,输出数据库的数据. 服务器和客户端的项目结构: 服务器 客户端 实体类: package com.luo.project.pojo; import java.io.Serializable; public class

JAVA自定义连接池原理设计(一)

一,概述 本人认为在开发过程中,需要挑战更高的阶段和更优的代码,虽然在真正开发工作中,代码质量和按时交付项目功能相比总是无足轻重.但是个人认为开发是一条任重而道远的路.现在本人在网上找到一个自定义连接池的代码,分享给大家.无论是线程池还是db连接池,他们都有一个共同的特征:资源复用,在普通的场景中,我们使用一个连接,它的生命周期可能是这样的: 一个连接,从创建完毕到销毁,期间只被使用一次,当周期结束之后,另外的调用者仍然需要这个连接去做事,就要重复去经历这种生命周期.因为创建和销毁都是需要对应服

数据库连接池原理详解与自定义连接池实现

实现原理 数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中,这些数据库连接的数量是由最小数据库连接数制约.无论这些数据库连接是否被使用,连接池都将一直保证至少拥有这么多的连接数量.连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数,当应用程序向连接池请求的连接数超过最大连接数量时,这些请求将被加入到等待队列中. 连接池基本的思想是在系统初始化的时候,将数据库连接作为对象存储在内存中,当用户需要访问数据库时,并非建立一个新的连接,而是从连接池中取出一个已建立的空闲连接对象.使

jdbc之连接池

第三方数据库连接池DBCP的应用 连接池的原理 1.缓存Connection对象 2.缓存Statement及PreparedStatement package jdbcdemo2; import java.io.InputStream; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.Statement; import java.u