Java数据库连接池类源码

来自:http://www.cnblogs.com/shiyangxt/archive/2008/07/30/1256813.html
环境：MyEclipse
 
数据库：mysql
 
首先新建Java项目，然后新建两个类，一个数据库连接池类，一个测试类。
 
分别命名ConnectionPool，ConnectionPoolTest。
 
然后新建一个配置文件，命名：dbpool.properties。
 
写入代码：
ConnectionPool.java
 
Code
package webbook.util;

import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
import java.util.Vector;

public class ConnectionPool {

    private Vector<Connection> pool;

    private String url;

    private String username;

    private String password;

    private String driverClassName;

    /** *//**
     * 连接池的大小，也就是连接池中有多少个数据库连接。
     */
    private int poolSize = 1;

    private static ConnectionPool instance = null;

    /** *//**
     * 私有的构造方法，禁止外部创建本类的对象，要想获得本类的对象，通过<code>getIstance</code>方法。
     * 使用了设计模式中的单子模式。
     */
    private ConnectionPool() {
        init();
    }

    /** *//**
     * 连接池初始化方法，读取属性文件的内容 建立连接池中的初始连接
     */
    private void init() {
        pool = new Vector<Connection>(poolSize);
        readConfig();
        addConnection();
    }

    /** *//**
     * 返回连接到连接池中
     */
    public synchronized void release(Connection conn) {
        pool.add(conn);

    }

    /** *//**
     * 关闭连接池中的所有数据库连接
     */
    public synchronized void closePool() {
        for (int i = 0; i < pool.size(); i++) {
            try {
                ((Connection) pool.get(i)).close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            pool.remove(i);
        }
    }

    /** *//**
     * 返回当前连接池的一个对象
     */
    public static ConnectionPool getInstance() {
        if (instance == null) {
            instance = new ConnectionPool();
        }
        return instance;
    }

    /** *//**
     * 返回连接池中的一个数据库连接
     */
    public synchronized Connection getConnection() {
        if (pool.size() > 0) {
            Connection conn = pool.get(0);
            pool.remove(conn);
            return conn;
        } else {
            return null;
        }
    }

    /** *//**
     * 在连接池中创建初始设置的的数据库连接
     */
    private void addConnection() {
        Connection conn = null;
        for (int i = 0; i < poolSize; i++) {

            try {
                Class.forName(driverClassName);
                conn = java.sql.DriverManager.getConnection(url, username, password);
                pool.add(conn);

            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException e) {
                e.printStackTrace();
            }

        }
    }

    /** *//**
     * 读取设置连接池的属性文件
     */
    private void readConfig() {
        try {
            String path = System.getProperty("user.dir") + "//dbpool.properties";
            FileInputStream is = new FileInputStream(path);
            Properties props = new Properties();
            props.load(is);
            this.driverClassName = props.getProperty("driverClassName");
            this.username = props.getProperty("username");
            this.password = props.getProperty("password");
            this.url = props.getProperty("url");
            this.poolSize = Integer.parseInt(props.getProperty("poolSize"));
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("读取属性文件出错. ");       
        }
    }
}
 
ConnectionPoolTest.java
 
Code
package webbook.util;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class ConnectionPoolTest {

    public static void main(String[] args) throws Exception {
        String sql = "select id,name,phone from guestmessage";
        long start = System.currentTimeMillis();
        ConnectionPool pool = null;

        for (int i = 0; i < 100; i++) {
            pool = ConnectionPool.getInstance();
            Connection conn = pool.getConnection();
            Statement stmt = conn.createStatement();
            ResultSet rs = stmt.executeQuery(sql);
            while (rs.next()) {
            }
            rs.close();
            stmt.close();
            pool.release(conn);
        }
        pool.closePool();
        System.out.println("经过100次的循环调用，使用连接池花费的时间:" + (System.currentTimeMillis() - start) + "ms/n");

        String hostName = "localhost";
        String driverClass = "com.mysql.jdbc.Driver";
        String url = "jdbc:mysql://" + hostName + ":3306/people";
        String user = "root";
        String password = "hicc";
        start = System.currentTimeMillis();
       
        for (int i = 0; i < 100; i++) {
            Class.forName(driverClass);
            Connection conn = DriverManager.getConnection(url, user, password);
            Statement stmt = conn.createStatement();
            ResultSet rs = stmt.executeQuery(sql);
            while (rs.next()) {
            }
            rs.close();
            stmt.close();
            conn.close();
        }
        System.out.println("经过100次的循环调用，不使用连接池花费的时间:" + (System.currentTimeMillis() - start) + "ms");
    }
}
 
dbpool.properties
 
Code
driverClassName=com.mysql.jdbc.Driver
username=root
password=hicc
url=jdbc:mysql://localhost:3306/people
poolSize=10
 
运行测试类，可以看到数据库连接池带来的高效。
 
相同的获取连接次数，有数据库连接池的可以节省很多倍时间。