MySql数据库再学习——使用强化版的自定义连接池连接数据库

一：两个重点，

一是获取properties文件的路径，总结在注释里，我当时获取了好半天，总是找不到文件。

二是理清这几个class之间的联系，以及本次demo的思路逻辑关系：总的来说就是，在原有的driverManager获取的基础上——>创建一个池子（池子中存储若干个基础的Connection对象）

——>书写一个强化类实现Connection接口（强化的是close（）方法）——>在主程序中调用的时候调用的是从池子中取出来的，强化后的 Connection对象。

dbUtil.class

 1 public class dbUtil {
 2
 3     /*初始化需要用到的变量*/
 4     private static Connection conn;
 5     private static PreparedStatement pst;
 6     private static ResultSet rs;
 7
 8     private static String driver;
 9     private static String url;
10     private static String username;
11     private static String password;
12     private static InputStream in;
13     private static ClassLoader cl;
14
15     static {
16         try {
17             //获取当前类的类加载器
18             //cl = Thread.currentThread().getContextClassLoader();
19
20             //获取配置文件的输入流
21             // in = cl.getResourceAsStream("db.properties");
22
23             //切忌使用中文命名文件夹，否则dbUtil.class.getResource("/db.properties").getFile()会找不到文件路径
24             FileInputStream in = new FileInputStream(dbUtil.class.getResource("/db.properties").getFile());
25
26             //创建一个properties文件对象
27             Properties ppt = new Properties();
28             //加载输入流
29             ppt.load(in);
30             //获得相关参数
31             driver = ppt.getProperty("driver");
32             url = ppt.getProperty("url");
33             username = ppt.getProperty("username");
34             password = ppt.getProperty("password");
35         } catch (Exception e) {
36             e.printStackTrace();
37         }
38     }
39
40
41     public static Connection getConnection() throws ClassNotFoundException, SQLException {
42         //注册驱动
43         Class.forName(driver);
44         //连接数据库
45         Connection connection = DriverManager.getConnection(url, username, password);
46         return connection;
47     }
48
49
50     public static void release(Connection conn, PreparedStatement pst, ResultSet rs) {
51         if (rs != null) {
52             try {
53                 rs.close();
54             } catch (Exception e) {
55                 e.printStackTrace();
56             }
57         }
58         if (pst != null) {
59             try {
60                 pst.close();
61             } catch (Exception e) {
62                 e.printStackTrace();
63             }
64         }
65         if (conn != null) {
66             try {
67                 conn.close();
68             } catch (Exception e) {
69                 e.printStackTrace();
70             }
71         }
72     }
73
74     @Test
75     public void test() {
76
77         String sql = "select * from test where name=?";
78         LinkPool pool = new LinkPool();
79         try {
80             //conn=getConnection();
81             //这个链接是从池子里取的，此时尺子中的连接是强化过得 战斗力翻倍.:)
82             conn = pool.getConnection();
83             //这个prepareStatement方法也是重写过得 否则重写过的conn是得不到该方法的
84             pst = conn.prepareStatement(sql);
85             pst.setString(1, "张浩");
86             rs = pst.executeQuery();
87             while (rs.next()) {
88                 System.out.println(rs.getString("name"));
89             }
90         } catch (Exception e) {
91             e.printStackTrace();
92         } finally {
93             //release对象中的close方法也是重写过的
94             release(conn, pst, rs);
95         }
96     }
97 }

LinkPool.class

 1 public class LinkPool implements DataSource {
 2         //定义一个池子对象
 3     private static LinkedList<Connection> pool = new LinkedList<>();
 4
 5     static {
 6         for (int i = 0; i < 5; i++) {
 7             try {
 8                 pool.add(new MyDbConnection(dbUtil.getConnection(), pool));
 9             } catch (ClassNotFoundException e) {
10                 e.printStackTrace();
11             } catch (SQLException e) {
12                 e.printStackTrace();
13             }
14         }
15     }
16
17
18     @Override
19     public Connection getConnection() throws SQLException {
20
21         if (pool.size() == 0) {
22             for (int i = 0; i < 5; i++) {
23                 try {
24                     //想池子中添加Myconnection对象
25                     pool.add(new MyDbConnection(dbUtil.getConnection(), pool));
26                 } catch (ClassNotFoundException e) {
27                     e.printStackTrace();
28                 } catch (SQLException e) {
29                     e.printStackTrace();
30                 }
31             }
32         }
33         return pool.remove(0);
34     }
35
36     @Override
37     public Connection getConnection(String username, String password) throws SQLException {
38         return null;
39     }
40
41     @Override
42     public <T> T unwrap(Class<T> iface) throws SQLException {
43         return null;
44     }
45
46     @Override
47     public boolean isWrapperFor(Class<?> iface) throws SQLException {
48         return false;
49     }
50
51     @Override
52     public PrintWriter getLogWriter() throws SQLException {
53         return null;
54     }
55
56     @Override
57     public void setLogWriter(PrintWriter out) throws SQLException {
58
59     }
60
61     @Override
62     public void setLoginTimeout(int seconds) throws SQLException {
63
64     }
65
66     @Override
67     public int getLoginTimeout() throws SQLException {
68         return 0;
69     }
70
71     @Override
72     public Logger getParentLogger() throws SQLFeatureNotSupportedException {
73         return null;
74     }
75 }

MyDbConnection.class

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

原文地址：https://www.cnblogs.com/zhang188660586/p/11218133.html

时间： 2024-08-29 11:12:33

MySql数据库再学习——使用强化版的自定义连接池连接数据库的相关文章

使用JDBC连接MySQL数据库--典型案例分析(三)----使用Apach DBCP连接池d

问题: 本案例要求使用Apach DBCP 连接数据池重构类DBUtility 为ConnectionSource类,并重构案例"实现DBUtility",提供连接的获取,关闭功能的"中的EmpDAO类,在该类中使用ConnectionSource来获取连接. 方案: 直接使用JDBC访问数据库时,需要避免一下隐患: 1.每一次数据操作请求都是需要建立数据库连接,打开连接,存取数据和关闭数据等步骤.而建立和打开数据库是一件既耗资源有费时间的过程,如果频繁发生这样的数据库操作,

MySql数据库再学习——简述多表连接查询的自我理解

一:序这几天在学习数据库部分,因为在学校听课也是比较迷糊,经过学习之后感觉现在思路比较清楚,对于多表连接查询操作有了一个新的认识. 二:假设假设现在有两个表 :A ,B. 三:两表之间的连接方式两个表的连接方式分为,内,外,交叉三种. 内连接的查询方式又分为隐式和显式两种. 外连接的查询方式又分为左,右两种. 交叉是将两个表的记录做乘积,因为得到的记录很大程度上没有直接联系,所以交叉连接查询基本没什么意义. 四:内连接内连接的关键词:inner join...(inner可以省略) 隐式

linux下mysql数据库的学习

转载博客:http://freedomljtt.blog.163.com/blog/static/72294949201210145441701/ ubuntu12.04 卸载和安装mysql 卸载mysql 第一步 1 sudo apt-get autoremove --purge mysql-server-5.0 2 sudo apt-get remove mysql-server 3 sudo apt-get autoremove mysql-server 4 sudo apt-get r

MYSQL数据库基础学习笔记

一.mysql的安装与初始化: 安装mysql命令: yum install -y mysql-server mysql mysql-devel 初始化: service mysqld start //第一次启动mysqld服务会自动初始化: 创建用户并初始化密码: mysqladmin -u root passwd '密码' 登陆mysql: mysql -u root -p 退出mysql: quit.exit 设置mysqld服务自启动: chkconfig mysqld on mys

MySQL数据库开发学习教程

MySQL数据库开发学习教程一.数据库设计数据库设计(一)--数据库设计http://blog.51cto.com/9291927/2087925 二.MySQL数据库开发基础教程 MySQL数据库开发基础教程目录如下: MySQL数据库基础(一)--MySQL数据库简介http://blog.51cto.com/9291927/2087947MySQL数据库基础(二)--MySQL字符集与乱码解析http://blog.51cto.com/9291927/2088254MySQL数据库基础

Mysql 数据库基础学习笔记

数据库基础数据库是存储数据的仓库,实现数据共享,减少数据冗余,采用特定的数据类型,具有较高的数据独立性,具有数据控制功能. 表 ,是一个二维数组,用来存储数据和操作数据的逻辑结构. 数据类型,整数数据类型,浮点数数据类型,精确小数类型,二进制数据类型,日期/时间数据类型,字符串数据类型. 主键用于唯一标示表中的每条记录.可以定义一列或多了主键.主键不能相同. 数据库技术构成硬件,软件共同构成数据库系统,数据库,数据库管理系统(DBMS),数据库应用程序. SQL 语言结构化查询语

mysql数据库存储过程学习

1.建立存储过程方式一: mysql中存储过程属于函数一栏中,点击新建函数会有让你选择是存储过程还是函数接下来是存储过程中设置的参数: IN 输入参数:表示该参数的值必须在调用存储过程时指定,在存储过程中修改该参数的值不能被返回,为默认值 OUT 输出参数:该值可在存储过程内部被改变,并可返回 INOUT 输入输出参数:调用时指定,并且可被改变和返回接下来就在BEGIN和END中填写需要的sql语句,和平时使用的相同保存后存储在函数下,执行时可以直接运行,查看结果. 注:当没有参数或者只有

Mysql数据库周末学习之Mycat全局表 mysql DBA

Mysql数据库业务中有些数据类似于数据字典,比如配置文件的配置,常用业务的配置或者数据量不大很少变动的表,这些表往往不是特别大,但是大部分的业务场景都会用到,那么这种表适合于Mycat全局表,无须对数据进行切分,只要在所有的分片上保存一份数据即可,Mycat在Join操作中,业务表与全局表进行Join聚合会优先选择相同分片内的全局表join,避免跨库Join,在进行数据插入操作时,mycat将把数据分发到全局表对应的所有分片执行,在进行数据读取时候将会随机获取一个节点读取数据. 全局表的配置如

mysql数据库字符集学习总结

MYSQL数据库字符集包括字符集(CHARACTER)和校对规则(COLLATION)两个概念. MYSQL 支持的字符集和校对规则可以通过命令showcharacter set;查看. 和字符集有关的变量 mysql> show VARIABLES like 'character_set%';+--------------------------+-------------------------------------------+| Variable_name |