构建个人博客系统四(建立数据库连接池)

 

        上文建立了DBUtil来进行数据库操作，这种每次操作都要进行数据库连接打开，数据库连接关闭都是非常消耗系统资源的。下面我来对它进行改进。思路是系统维护一个连接池，池中预放置若干连接，每次数据库操作时从池中拿一个，用后关闭。如果用完连接，再创建相同数目的连接放入池中。

 

        系统如何维护连接池呢？可以创建一个单子对象。在系统中只有一个实例，对象有一vectior来保存connection。我采用在数据库启动的时候来创建连接池和数据库连接的操作。

       

        这个servlet在系统启动时加载。load-on-startup 当值为0或者大于0时，表示容器在应用启动时就加载这个servlet，正数的值越小，启动该servlet的优先级越高。当load-on-startup是一个负数时或者没有指定时，则指示容器在该servlet被选择时才加载。

1.  <servlet>
2.   <servlet-name>sysConfig</servlet-name>
3.   <servlet-class>com.mycompany.sys.SysConfig</servlet-class>
4.   <load-on-startup>1</load-on-startup>
5.  </servlet>

1. package com.mycompany.sys;
3. import javax.servlet.ServletException;
4. import javax.servlet.http.HttpServlet;
5. import com.mycompany.db.*;
6. public class SysConfig extends HttpServlet {
7.     public void init() throws ServletException {
8.         ConnPool.getCP().createConns();
9.     }
10. }

ConnPool是连接池对象。

1. package com.mycompany.db;
3. import java.sql.Connection;
4. import java.sql.DriverManager;
5. import java.sql.SQLException;
6. import java.util.Vector;
8. public class ConnPool {
9.     private static Vector conections;
10.     private static ConnPool cp;
12.     private ConnPool() {
13.     }
15.     public static ConnPool getCP() {
16.         if (cp == null) {
17.             cp = new ConnPool();
18.             return cp;
19.         } else {
20.             return cp;
21.         }
22.     }
24.     public void createConns() {
25.         conections = new Vector();
26.         try {
27.             Class.forName("com.mysql.jdbc.Driver");
28.         } catch (ClassNotFoundException e) {
29.             // TODO Auto-generated catch block
30.             e.printStackTrace();
31.         }
32.         try {
33.             for (int i = 0; i < 100; i++) {
34.                 Connection conn;
35.                 conn = DriverManager
36.                         .getConnection("jdbc:mysql://localhost:3306/sclBlog?user=root&password=root");
37.                 conections.addElement(conn);
38.             }
40.         } catch (SQLException e) {
41.             // TODO Auto-generated catch block
42.             e.printStackTrace();
43.         }
44.     }
46.     public Connection getConnection() {
47.         Connection conn = null;
48.         if (conections.size() <= 0) {
49.             createConns();
50.         }
51.         for (int i = 0; i < conections.size(); i++) {
52.             Connection connection = (Connection)conections.elementAt(i);
53.             try {
54.                 if(!connection.isClosed()){
55.                     conn = connection;
56.                     conections.removeElement(connection);
57.                     break;
58.                 }
59.             } catch (SQLException e) {
60.                 // TODO Auto-generated catch block
61.                 e.printStackTrace();
62.             }
63.         }
64.         return conn;
65.     }
67.     public static Vector getConections() {
68.         return conections;
69.     }
71.     public static void setConections(Vector conections) {
72.         ConnPool.conections = conections;
73.     }
75. }

ConnPool维护一个vector来保持connection，但系统用完connection时，就调用createConns来创建若干连接放入池中备用。这样至少不用每次都创建连接啦。