JDCB的基本写法和数据库连接池的实现
1、使用静态方法实现
package util;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class DbConnStatic {
private final static String DB_DRIVER = "oracle.jdbc.driver.OracleDriver";
private final static String DB_URL = "jdbc:oracle:thin:@localhost:testData";
private final static String DB_USER_NAME = "testData";
private final static String DB_PASSWROD = "testData";
private static Connection conn = null;
static{
try {
Class.forName(DB_DRIVER);
conn = DriverManager.getConnection(DB_URL, DB_USER_NAME,
DB_PASSWROD);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static Connection getConnection(){
return conn;
}
public static void freeConnection(){
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
2、使用非静态方法实现
package util;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class DbConn {
private final String DB_DRIVER = "oracle.jdbc.driver.OracleDriver";
private final String DB_URL = "jdbc:oracle:thin:@localhost:testData";
private final String DB_USER_NAME = "testData";
private final String DB_PASSWROD = "testData";
private Connection conn = null;
public DbConn(){
try {
Class.forName(DB_DRIVER);
conn = DriverManager.getConnection(DB_URL, DB_USER_NAME,
DB_PASSWROD);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public Connection getConnection(){
return conn;
}
public void freeConnection(){
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
3、数据库连接池的实现
package util;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Iterator;
import java.util.Vector;
public class DbPool {
// 连接池里面的数据库连接
class PoolConnection {
Connection conn = null;
boolean busy = false;
public PoolConnection(Connection conn) {
this.conn = conn;
}
public Connection getConn() {
return conn;
}
public void setConn(Connection conn) {
this.conn = conn;
}
public boolean isBusy() {
return busy;
}
public void setBusy(boolean busy) {
this.busy = busy;
}
}
private final String DB_DRIVER = "oracle.jdbc.driver.OracleDriver";
private final String DB_URL = "jdbc:oracle:thin:@localhost:testData";
private final String DB_USER_NAME = "testData";
private final String DB_PASSWROD = "testData";
private int initialConnections = 10; // 连接池的初始大小
private int incrementalConnections = 5;// 连接池自动增加的大小
private int maxConnections = 50; // 连接池最大的大小
// private String testTable = "LIJING727_ORIGDATA"; // 测试表，用于测试来连接是否可用
private Vector connections = null;
public int getInitialConnections() {
return initialConnections;
}
public void setInitialConnections(int initialConnections) {
this.initialConnections = initialConnections;
}
public int getIncrementalConnections() {
return incrementalConnections;
}
public void setIncrementalConnections(int incrementalConnections) {
this.incrementalConnections = incrementalConnections;
}
public int getMaxConnections() {
return maxConnections;
}
public void setMaxConnections(int maxConnections) {
this.maxConnections = maxConnections;
}
private Connection newConnection() throws SQLException {
Connection conn = DriverManager.getConnection(DB_URL, DB_USER_NAME,
DB_PASSWROD);
// 首次创建链接
if (connections.size() == 0) {
int driverMaxConnenction = conn.getMetaData().getMaxConnections();
System.out.println("数据库支持的最大连接数：" + driverMaxConnenction);
if (driverMaxConnenction > 0
&& maxConnections > driverMaxConnenction) {
maxConnections = driverMaxConnenction;
}
}
return conn;
}
private void createConnections(int num) throws SQLException {
for (int i = 0; i < num; i++) {
if (maxConnections > 0 && connections.size() >= maxConnections) {
break;
}
try {
connections.add(new PoolConnection(newConnection()));
} catch (SQLException e) {
System.out.println("数据库创建失败! " + e.getMessage());
throw e;
}
}
}
// 创建数据库连接池
public synchronized void createPool() throws ClassNotFoundException,
SQLException {
if (connections != null) {
return;
}
Class.forName(DB_DRIVER);
connections = new Vector();
createConnections(initialConnections);
System.out.println("数据库连接池创建成功！");
}
private void closeConnection(Connection conn) {
try {
conn.close();
} catch (SQLException e) {
System.out.println(" 关闭数据库连接出错： " + e.getMessage());
}
}
private void wait(int mSeconds) {
try {
Thread.sleep(mSeconds);
} catch (InterruptedException e) {
}
}
// 归还数据库连接
public void returnConnection(Connection conn) {
if (connections == null) {
System.out.println("数据库连接池不存在！");
return;
}
PoolConnection pConn = null;
Iterator iterator = connections.iterator();
while (iterator.hasNext()) {
pConn = iterator.next();
if (conn == pConn.getConn()) {
pConn.setBusy(false);
break;
}
}
}
// 刷新数据库连接
public synchronized void refreshConnections() throws SQLException {
// 确保连接池己创新存在
if (connections == null) {
System.out.println(" 连接池不存在，无法刷新 !");
return;
}
PoolConnection pConn = null;
Iterator it = connections.iterator();
while (it.hasNext()) {
// 获得一个连接对象
pConn = it.next();
// 如果对象忙则等 5 秒 ,5 秒后直接刷新
if (pConn.isBusy()) {
wait(5000); // 等 5 秒
}
// 关闭此连接，用一个新的连接代替它。
closeConnection(pConn.getConn());
pConn.setConn(newConnection());
pConn.setBusy(false);
}
}
// 关闭数据库连接池
public synchronized void closeConnectionPool() throws SQLException {
// 确保连接池己创新存在
if (connections == null) {
System.out.println(" 连接池不存在，无法刷新 !");
return;
}
PoolConnection pConn = null;
Iterator it = connections.iterator();
while (it.hasNext()) {
// 获得一个连接对象
pConn = it.next();
// 如果对象忙则等 5 秒 ,5 秒后直接刷新
if (pConn.isBusy()) {
wait(5000); // 等 5 秒
}
// 关闭此连接，用一个新的连接代替它。
closeConnection(pConn.getConn());
connections.remove(pConn);
}
connections = null;
}
private Connection findFreeConnection() throws SQLException {
Connection conn = null;
PoolConnection pConn = null;
// 获得连接池向量中所有的对象
Iterator iterator = connections.iterator();
// 遍历所有的对象，看是否有可用的连接
while (iterator.hasNext()) {
pConn = iterator.next();
if (!pConn.isBusy()) {
// 如果此对象不忙，则获得它的数据库连接并把它设为忙
conn = pConn.getConn();
pConn.setBusy(true);
// 测试此连接是否可用
// if (!testConnection(conn)) {
// // 如果此连接不可再用了，则创建一个新的连接，
// // 并替换此不可用的连接对象，如果创建失败返回 null
// try {
// conn = newConnection();
// } catch (SQLException e) {
// System.out.println(" 创建数据库连接失败！ " + e.getMessage());
// return null;
// }
// pConn.setConn(conn);
// }
break; // 己经找到一个可用的连接，退出
}
}
return conn;// 返回找到到的可用连接
}
// private boolean testConnection(Connection conn) {
// try {
//
// // 判断测试表是否存在
// if (testTable.equals("")) {
// // 如果测试表为空，试着使用此连接的 setAutoCommit() 方法
// // 来判断连接否可用（此方法只在部分数据库可用，如果不可用 ,
// // 抛出异常）。注意：使用测试表的方法更可靠
// conn.setAutoCommit(true);
// } else {// 有测试表的时候使用测试表测试
// // check if this connection is valid
// Statement stmt = conn.createStatement();
// stmt.execute("SELECT COUNT(*) FROM " + testTable);
// }
// } catch (SQLException e) {
// // 上面抛出异常，此连接己不可用，关闭它，并返回 false;
// closeConnection(conn);
// return false;
// }
// // 连接可用，返回 true
// return true;
// }
private Connection getFreeConnection() throws SQLException {
// 从连接池中获得一个可用的数据库连接
Connection conn = findFreeConnection();
if (conn == null) {
// 如果目前连接池中没有可用的连接
// 创建一些连接
createConnections(incrementalConnections);
// 重新从池中查找是否有可用连接
conn = findFreeConnection();
}
return conn;
}
public synchronized Connection getConnection() throws SQLException {
// 确保连接池己被创建
if (connections == null) {
return null; // 连接池还没创建，则返回 null
}
Connection conn = getFreeConnection(); // 获得一个可用的数据库连接
// 如果目前没有可以使用的连接，即所有的连接都在使用中
while (conn == null) {
// 等一会再试
wait(250);
conn = getFreeConnection(); // 重新再试，直到获得可用的连接，如果
// getFreeConnection() 返回的为 null
// 则表明创建一批连接后也不可获得可用连接
}
return conn;// 返回获得的可用的连接
}
}