Easyconnectionpool2.0

1. package com.mdj.dmdatabase.develop;
3. import java.io.PrintWriter;
4. import java.io.Serializable;
5. import java.io.UnsupportedEncodingException;
6. import java.sql.Connection;
7. import java.sql.ResultSet;
8. import java.sql.SQLException;
9. import java.util.List;
10. import java.util.Map;
11. import java.util.Vector;
13. import javax.sql.DataSource;
15. /**
16.  * @see Connectionpool EasyconnectionPool
17.  * @author 武汉软件工程职业学院<br>
18.  *         孟德军<br>
19.  *         2009-01-01<br>
20.  *         封装了Dbutils工具<br>
21.  *         的部分细节
22.  * @version 2.0
23.  */
24. public interface DmDataSource extends DataSource, Serializable {
26.     /**
27.      * @see #resultset 存放数据库的表信息.
28.      */
29.     ResultSet resultset = null;
30.     /**
31.      * @see #con 数据库连接
32.      */
33.     Connection con = null;
34.     /**
35.      * @see #pool 连接池容器.可自行选择。
36.      */
37.     Vector<Connection> pool = null;
38.     /**
39.      * @see #driverclass 数据库驱动类
40.      */
41.     String driverclass = null;
42.     /**
43.      * @see #uername 数据库用户名
44.      */
45.     String uername = null;
46.     /**
47.      * @see #password 数据库密码
48.      */
49.     String password = null;
50.     /**
51.      * @see #url 连接数据库url
52.      */
53.     String url = null;
54.     /**
55.      * @see #filepath 配置文件路径.
56.      */
57.     String filepath = null;
58.     /**
59.      * @see #logpath 日志文件路径.
60.      */
61.     String logpath = null;
62.     /**
63.      * @see #maxwaittime 允许等待时间
64.      */
65.     int maxwaittime = 0;
66.     /**
67.      * @see #delaytime 延迟时间
68.      */
69.     int delaytime = 0;
70.     /**
71.      * @see #maxconnection 最大连接
72.      */
73.     int maxconnection = 0;
74.     /**
75.      * @see #minconnection 最小连接
76.      */
77.     int minconnection = 0;
78.     /**
79.      * @see #poolsize 连接池大小.
80.      */
81.     int poolsize = 0;
83.     public void closeConnectionPool() throws SQLException;
84.     /**
85.      * @param username 数据库用户名<br>password 数据库密码
86.      * @deprecated 建议使用getconnection()
87.      * @see #getConnection() 参见
88.      */
89.     public Connection getConnection(String username, String password)
90.             throws SQLException;
91.     /**
92.      * @see #getConnection() 无用户名和密码，以在配置文件中配置。
93.      */
94.     public Connection getConnection() throws SQLException;
96.     public PrintWriter getLogWriter() throws SQLException;
98.     public int getLoginTimeout() throws SQLException;
100.     public void releaseConnection(Connection con);
102.     public void setLogWriter(PrintWriter out) throws SQLException;
104.     public void setLoginTimeout(int seconds) throws SQLException;
106.     public Map mapexecuteQuery(String sql) throws SQLException;
108.     public List listexecuteQuery(String sql, Class beanclass)
109.             throws SQLException;
111.     public ResultSet getTables(String catalog, String schemapattern,
112.             String tablenamepattern, String[] types) throws SQLException;
114.     public int getJDBCMajorVersion() throws SQLException;
116.     public int generalUpdate(String sql) throws SQLException;
118.     public ResultSet generalQuery(String sql) throws SQLException;
120.     public String toChinese(String str, String oldcharsetName,
121.             String newcharsetName) throws UnsupportedEncodingException;
122. }

1. package com.mdj.dmdatabase.DmDriverManager;
3. import java.io.File;
4. import java.io.FileInputStream;
5. import java.io.FileNotFoundException;
6. import java.io.FileWriter;
7. import java.io.IOException;
8. import java.io.InputStream;
9. import java.io.PrintWriter;
10. import java.io.UnsupportedEncodingException;
11. import java.sql.Connection;
12. import java.sql.DatabaseMetaData;
13. import java.sql.DriverManager;
14. import java.sql.PreparedStatement;
15. import java.sql.ResultSet;
16. import java.sql.SQLException;
17. import java.sql.Statement;
18. import java.util.Date;
19. import java.util.List;
20. import java.util.Map;
21. import java.util.Properties;
22. import java.util.Timer;
23. import java.util.TimerTask;
24. import java.util.Vector;
26. import javax.xml.parsers.DocumentBuilder;
27. import javax.xml.parsers.DocumentBuilderFactory;
28. import javax.xml.parsers.ParserConfigurationException;
30. import org.apache.commons.dbutils.DbUtils;
31. import org.apache.commons.dbutils.QueryRunner;
32. import org.apache.commons.dbutils.handlers.BeanListHandler;
33. import org.apache.commons.dbutils.handlers.MapListHandler;
34. import org.w3c.dom.Document;
35. import org.w3c.dom.Element;
36. import org.w3c.dom.NodeList;
37. import org.xml.sax.SAXException;
39. import com.mdj.dmdatabase.pool.Dmconnection;
41. /**
42.  * @see Connectionpool EasyconnectionPool
43.  * @author <hr><p bgcolor="#9acd32">武汉软件工程职业学院</p>
44.  *         孟德军<br>
45.  *         2009-01-03<br>
46.  *         封装了Dbutils<br>
47.  *         工具的部分细节
48.  * 
49.  * @version 2.0
50.  */
51. public class DatabaseManager extends Dmconnection {
53.     /**
54.      * 
55.      */
56.     private static final long serialVersionUID = 1L;
57.     /**
58.      * @see #databasemetaData 数据源.
59.      */
60.     private DatabaseMetaData databasemetaData;
61.     /**
62.      * @see #resultset 存放数据库的表信息.
63.      */
64.     private ResultSet resultset = null;
65.     /**
66.      * @see #map 存放mapexecuteQuery查询结果
67.      */
68.     private Map map = null;
69.     /**
70.      * @see #list 存放listexecuteQuery查询结果
71.      */
72.     private List list = null;
73.     /**
74.      * @see #con 数据库连接
75.      */
76.     private Connection con = null;
77.     /**
78.      * @see #pool 连接池容器.可自行选择。
79.      */
80.     private Vector<Connection> pool = null;
81.     /**
82.      * @see #driverclass 数据库驱动类
83.      */
84.     private String driverclass = "dm.jdbc.driver.DmDriver";
85.     /**
86.      * @see #uername 数据库用户名
87.      */
88.     private String username = "SYSDBA";
89.     /**
90.      * @see #password 数据库密码
91.      */
92.     private String password = "123456";
93.     /**
94.      * @see #url 连接数据库url
95.      */
96.     private String url = "jdbc:dm://localhost:12345/guest";
97.     /**
98.      * @see #filepath 配置文件路径.
99.      */
100.     private static String filepath = null;
101.     /**
102.      * @see #logpath 日志文件路径.
103.      */
104.     private String logpath = "..//server.log";
105.     /**
106.      * @see #maxwaittime 允许等待时间
107.      */
108.     private int maxwaittime = 10;
109.     /**
110.      * @see #delaytime 延迟时间
111.      */
112.     private int delaytime = 10;
113.     /**
114.      * @see #maxconnection 最大连接
115.      */
116.     private int maxconnection = 10;
117.     /**
118.      * @see #minconnection 最小连接
119.      */
120.     private int minconnection = 5;
121.     /**
122.      * @see #poolsize 连接池大小.
123.      */
124.     private int poolsize = 10;
125.     /**
126.      * @see #manager 本类实例.
127.      */
128.     private static DatabaseManager manager = null;
129.     /**
130.      * @see #timer 扫描连接池.
131.      */
132.     private Timer timer;
133.     private PrintWriter writer;
134.     private boolean loading = false;
136.     /**
137.      * @see #addConnection() 为连接池添加连接
138.      * @throws ClassNotFoundException
139.      */
140.     private DatabaseManager() {
141.         try {
142.             init();
143.             File file = new File(logpath);
144.             writer = new PrintWriter(new FileWriter(file.getAbsolutePath(),
145.                     true), true);
146.             addConnection();
147.         } catch (IOException e) {
148.             e.printStackTrace();
149.         }
151.     }
153.     private void init() {
154.         if (loading == false) {
155.             config(filepath);
156.         } else {
158.             readconfig(filepath);
159.         }
160.         pool = new Vector<Connection>(maxconnection);
161.         timer = new Timer(true);
162.     }
164.     static public synchronized DatabaseManager getinstance(String path) {
165.         // 必须先初始化变量filepath,然后在创建变量.
166.         DatabaseManager.filepath = path;
167.         if (manager == null) {
168.             manager = new DatabaseManager();
169.         }
170.         return manager;
171.     }
173.     private void addConnection() {
174.         serverlog("server start");
175.         for (int i = 0; i < maxconnection; i++) {
176.             try {
177.                 Class.forName(driverclass);
178.                 DriverManager.setLogWriter(writer);
179.                 DriverManager.setLoginTimeout(maxwaittime);
180.                 con = DriverManager.getConnection(url, username, password);
181.                 pool.add(con);
183.             } catch (ClassNotFoundException e) {
184.                 // TODO Auto-generated catch block
185.                 serverlog(e.getMessage());
186.             } catch (SQLException e) {
187.                 // TODO Auto-generated catch block
188.                 serverlog(e.getMessage());
189.             }
190.         }
191.     }
193.     /**
194.      * @see #releaseConnection(Connection) 释放连接，返还连接池.
195.      * @return con 当前连接.
196.      * 
197.      */
198.     public synchronized Connection getConnection() throws SQLException {
199.         if (pool.size() > 0) {
200.             con = pool.get(0);
201.             pool.remove(0);
202.             scaner();
203.             return con;
204.         } else {
205.             return con;
206.         }
208.     }
210.     /**
211.      * @see #releaseConnection(Connection) 释放连接，返还连接池.
212.      * @return con 当前连接.
213.      * 
214.      */
215.     public synchronized Connection getConnection(String username,
216.             String password) {
217.         if (pool.size() > 0) {
218.             con = pool.get(0);
219.             pool.remove(0);
220.             return con;
221.         } else {
222.             return con;
223.         }
225.     }
227.     public synchronized void releaseConnection(Connection con) {
228.         pool.add(con);
230.     }
232.     /**
233.      * @return 无返回值
234.      * @see #closeConnectionPool() 关闭连接，清空连接池.
235.      * @throws SQLException
236.      */
237.     public void closeConnectionPool() throws SQLException {
238.         for (int i = 0; i < pool.size(); i++) {
239.             pool.get(i).close();
240.             pool.clear();
241.             timer.cancel();
242.         }
243.     }
245.     /**
246.      * @see #scaner()扫描连接池.
247.      */
248.     private void scaner() {
249.         TimerTask task = new TimerTask() {
250.             @Override
251.             public void run() {
252.                 // TODO Auto-generated method stub
253.                 if (manager.pool.size() < maxconnection) {
254.                     while (manager.pool.size() < maxconnection) {
255.                         addConnection();
256.                     }
257.                 }
258.             }
260.         };
261.         timer.schedule(task, 10000, 10000);
262.     }
264.     /**
265.      * @see #config(String) 读取配置文件.<br>
266.      *      初始化数据库连接数据.
267.      * @since <hr>http://blog.csdn.net/mak0000 <a
268.      *        href="http://blog.csdn.net/mak0000">更多信息</a>
269.      * @throws path
270.      *             为配置文件路径，文件路径错误会抛出FileNotFoundException异常
271.      */
272.     /**
273.      * @see #config(String) 读取配置文件.
274.      */
275.     private void config(String path) {
276.         loading = true;
277.         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
278.         try {
279.             DocumentBuilder builder = factory.newDocumentBuilder();
280.             Document document = builder.parse(DatabaseManager.filepath);
281.             NodeList nodelist = document.getElementsByTagName("dbmsdriver");
282.             for (int i = 0; i < nodelist.getLength(); i++) {
283.                 Element element = (Element) nodelist.item(i);
284.                 driverclass = element.getElementsByTagName("driverclass").item(
285.                         0).getFirstChild().getNodeValue();
286.                 url = element.getElementsByTagName("url").item(0)
287.                         .getFirstChild().getNodeValue();
288.                 username = element.getElementsByTagName("username").item(0)
289.                         .getFirstChild().getNodeValue();
290.                 password = element.getElementsByTagName("password").item(0)
291.                         .getFirstChild().getNodeValue();
292.                 maxconnection = Integer
293.                         .parseInt(element.getElementsByTagName("maxconnection")
294.                                 .item(0).getFirstChild().getNodeValue());
295.                 minconnection = Integer
296.                         .parseInt(element.getElementsByTagName("minconnection")
297.                                 .item(0).getFirstChild().getNodeValue());
298.                 logpath = element.getElementsByTagName("logpath").item(0)
299.                         .getFirstChild().getNodeValue();
300.                 maxwaittime = Integer.parseInt(element.getElementsByTagName(
301.                         "maxwaittime").item(0).getFirstChild().getNodeValue());
302.                 delaytime = Integer.parseInt(element.getElementsByTagName(
303.                         "delaytime").item(0).getFirstChild().getNodeValue());
304.             }
305.         } catch (ParserConfigurationException e) {
306.             // TODO Auto-generated catch block
307.             e.printStackTrace();
308.             serverlog(new Date() + ":/t" + e.getMessage() + "/n");
309.         } catch (SAXException e) {
310.             e.printStackTrace();
311.             serverlog(new Date() + ":/t" + e.getMessage() + "/n");
312.         } catch (IOException e) {
313.             e.printStackTrace();
314.             serverlog(new Date() + ":/t" + e.getMessage() + "/n");
315.         }
316.     }
318.     /**
319.      * @deprecated 该方法为候选方法.
320.      * @param path
321.      *            配置文件路径.
322.      */
323.     public void readconfig(String path) {
324.         loading = false;
325.         Properties properties = new Properties();
326.         try {
327.             InputStream in = new FileInputStream(DatabaseManager.filepath);
328.             properties.load(in);
329.             driverclass = properties.getProperty("driverclass");
330.             url = properties.getProperty("url");
331.             username = properties.getProperty("username");
332.             password = properties.getProperty("password");
333.             maxconnection = Integer.parseInt(properties
334.                     .getProperty("maxconnection"));
335.             minconnection = Integer.parseInt(properties
336.                     .getProperty("minconnection"));
337.             delaytime = Integer.parseInt(properties.getProperty("delaytime"));
338.             logpath = properties.getProperty("logpath");
339.             in.close();
340.         } catch (FileNotFoundException e) {
342.             e.printStackTrace();
343.         } catch (IOException e) {
345.             e.printStackTrace();
346.         }
347.     }
349.     /**
350.      * @see #serverlog(String) 日志.
351.      * @param msg
352.      *            异常及日常信息.
353.      * @since <a href="http://www.w3.org/xmlschema">建议将变量以配置文件形式存放，<br>
354.      *        以方便使用,例如xml,properties<br>
355.      *        文件.</a>
356.      */
358.     private void serverlog(String msg) {
359.         writer.println(new Date() + ":" + msg);
360.         writer.close();
361.     }
363.     /**
364.      * @see #setLogWriter(PrintWriter) set delay time
365.      * @throws SQLException
366.      */
367.     public void setLoginTimeout(int seconds) throws SQLException {
368.         this.maxwaittime = seconds;
369.     }
371.     /**
372.      * @see #getLoginTimeout() get delay time.
373.      * @throws SQLException
374.      */
375.     public int getLoginTimeout() throws SQLException {
376.         return maxwaittime;
377.     }
379.     /**
380.      * @see #setLogWriter(PrintWriter) set logwriter.
381.      * @throws SQLException
382.      */
384.     public void setLogWriter(PrintWriter out) throws SQLException {
385.         this.writer = out;
386.     }
388.     /**
389.      * @see #getLogWriter() get logwriter
390.      * @throws SQLException
391.      */
392.     public PrintWriter getLogWriter() throws SQLException {
393.         return writer;
394.     }
396.     /**
397.      * @see #listexecuteQuery(String, Class) put the var in list,list includes objects bean
398.      * @since Book.class<br>
399.      *        Book book=(Book)result.get(i);<br>
400.      *        book.getid();
401.      */
402.     @Override
403.     public List listexecuteQuery(String sql, Class beanclass)
404.             throws SQLException {
405.         con = getConnection();
406.         DbUtils.loadDriver(driverclass);
407.         //build a queryrunner instance.
408.         QueryRunner queryrunner = new QueryRunner();
409.         list = (List) queryrunner.query(con, sql,
410.                 new BeanListHandler(beanclass));
411.         releaseConnection(con);
412.         return list;
414.     }
416.     /**
417.      * @see #mapexecuteQuery(String) map形式存放数据.list includes map
418.      */
419.     @Override
420.     public Map mapexecuteQuery(String sql) throws SQLException {
421.         // TODO Auto-generated method stub
422.         con = getConnection();
423.         DbUtils.loadDriver(driverclass);
424.         QueryRunner queryrunner = new QueryRunner();
425.         list = (List) queryrunner.query(con, sql, new MapListHandler());
426.         releaseConnection(con);
427.         for (int i = 0; i < list.size(); i++) {
428.             map = (Map) list.get(i);
429.         }
430.         return map;
431.     }
433.     /**
434.      * @see #getTables(String, String, String, String[])获取数据库表结构.
435.      * @param catalog
436.      *            ,schemaPattern,tableNamePattern,types
437.      * 
438.      */
439.     public ResultSet getTables(String catalog, String schemaPattern,
440.             String tableNamePattern, String[] types) throws SQLException {
441.         con = getConnection();
442.         databasemetaData = con.getMetaData();
443.         resultset = databasemetaData.getTables(catalog, schemaPattern,
444.                 tableNamePattern, types);
445.         releaseConnection(con);
446.         return resultset;
447.     }
449.     /**
450.      * @see #getJDBCMajorVersion() jdbc主版本号.
451.      */
452.     @Override
453.     public int getJDBCMajorVersion() throws SQLException {
454.         // TODO Auto-generated method stub
455.         con = getConnection();
456.         databasemetaData = con.getMetaData();
457.         int version = databasemetaData.getJDBCMajorVersion();
458.         releaseConnection(con);
459.         return version;
460.     }
462.     /**
463.      * @see #getJDBCMinorVersion() jdbc次版本号.
464.      */
465.     @Override
466.     public int getJDBCMinorVersion() throws SQLException {
467.         // TODO Auto-generated method stub
468.         con = getConnection();
469.         databasemetaData = con.getMetaData();
470.         int version = databasemetaData.getJDBCMinorVersion();
471.         releaseConnection(con);
472.         return version;
473.     }
475.     @Override
476.     /*
477.      * @see #getMaxConnections() 数据库支持的同时建立连接的对象数目.
478.      */
479.     public int getMaxConnections() throws SQLException {
481.         con = getConnection();
482.         databasemetaData = con.getMetaData();
483.         int maxconnection = databasemetaData.getMaxConnections();
484.         releaseConnection(con);
485.         return maxconnection;
486.     }
488.     /**
489.      * @see #getMaxStatements() 数据库支持同时打开statement的数目.
490.      */
491.     @Override
492.     public int getMaxStatements() throws SQLException {
493.         // TODO Auto-generated method stub
494.         con = getConnection();
495.         databasemetaData = con.getMetaData();
496.         int minconnection = databasemetaData.getMaxStatements();
497.         releaseConnection(con);
498.         return minconnection;
499.     }
501.     /**
502.      * @see #generalUpdate(String) 更新.
503.      */
504.     public int generalUpdate(String sql) {
505.         int result = 0;
506.         Statement statement;
507.         try {
508.             con = getConnection();
509.             statement = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
510.                     ResultSet.CONCUR_UPDATABLE);
511.             result = statement.executeUpdate(sql);
512.             statement.close();
513.             releaseConnection(con);
514.         } catch (SQLException e) {
515.             // TODO Auto-generated catch block
516.             serverlog(e.getSQLState() + "/t" + e.getMessage());
517.         }
519.         return result;
521.     }
523.     public ResultSet generalQuery(String sql) {
524.         ResultSet result = null;
525.         
526.         Statement statement;
527.         try {
528.             con = getConnection();
529.             statement = con.createStatement();
530.             result = statement.executeQuery(sql);
531.             result.close();
532.             statement.close();
533.             releaseConnection(con);
534.         } catch (SQLException e) {
535.             serverlog(e.getSQLState() + "/t" + e.getMessage());
536.         }
537.         return result;
538.     }
540.     public String toChinese(String str, String oldcharsetName,
541.             String newcharsetName) {
542.         String chinesestr = null;
543.         if (str.equals(null) || str == "") {
544.             chinesestr = "";
545.         } else {
546.             try {
547.                 chinesestr = new String(str.getBytes(oldcharsetName),
548.                         newcharsetName);
549.             } catch (UnsupportedEncodingException e) {
550.                 serverlog("/t" + e.getMessage());
551.             }
552.         }
553.         return chinesestr;
554.     }
556. }

 

1. package com.mdj.dmdatabase.test;
3. import java.io.IOException;
4. import java.sql.Connection;
5. import java.sql.SQLException;
6. import java.util.List;
7. import java.util.Map;
9. import com.mdj.dmdatabase.DmDriverManager.DatabaseManager;
10. import com.mdj.dmdatabase.javabean.Guest;
12. /**
13.  * @since <a href="http://blog.csdn.net/mak0000">Connectionpool
14.  *        EasyconnectionPool</a>
15.  * @author 武汉软件工程职业学院<br>
16.  *         孟德军<br>
17.  *         2009-01-01<br>
18.  *         封装了Dbutils工具<br>
19.  *         的部分细节
20.  * @version 2.0
21.  * 
22.  */
23. public class Test {
24.     /**
25.      * @see #manager DatabaseManager类的实例.
26.      */
27.     private DatabaseManager manager;
28.     /**
29.      * @see #con <p bgcolor="#9acd32">java.sql.Connection con Connection实例</p>
30.      */
31.     private Connection con = null;
33.     public Test(String path) throws IOException, SQLException {
34.         
35.     
36.         manager = DatabaseManager.getinstance(path);
37.         // con = manager.getConnection();
38.         /**
39.          * 此处书写代码. 查询数据无需用connection接收
40.          */
41.         /*int a=manager.generalUpdate("insert into guestbook(author,title,ip,updatetime,content) values('王红梅','你过得怎么样','192.168.18.1','2009-01-04','你过得怎么样')");
42.         System.out.println(a);*/
43.         Map map = manager.mapexecuteQuery("select * from guestbook");
44.         for (int i = 0; i < map.size(); i++) {
45.             System.out.println(map.get("author") + " " + map.get("title") + " "
46.                     + map.get("ip") + map.get("updatetime") + " "
47.                     + map.get("content"));
48.         }
49.         List list = manager.listexecuteQuery("select * from guestbook",
50.                 Guest.class);
51.         Guest guestbook = null;
52.         for (int i = 0; i < list.size(); i++) {
53.             guestbook = (Guest) list.get(i);
54.             System.out
55.                     .println(guestbook.getAuthor() + "/t"
56.                             + guestbook.getTitle() + "/t" + guestbook.getIp()
57.                             + "/t" + guestbook.getUpdatetime() + "/t"
58.                             + guestbook.getContent());
59.         }
60.         
61.         
62.          manager.releaseConnection(con); manager.closeConnectionPool();
63.          
65.     }
66.     
67.     public static void main(String[] args) {
69.         String path = System.getProperty("user.dir") + "//src//sysconfig.xml";
70.         try {
71.             new Test(path);
72.         } catch (SQLException e) {
74.         } catch (IOException e) {
75.             e.printStackTrace();
76.         }
77.     }
79. }