欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

数据库连接池

程序员文章站 2022-04-22 08:32:54
...

 

转自 http://soft-development.iteye.com/blog/1401770

 

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

import java.util.Properties;

import java.util.Vector;

 

public class PersonDefine_ConnectionPool implements Runnable {

 

public  String ProductionDB = "axdb_tmp";//給的默認值

private String database_driver = "com.microsoft.sqlserver.jdbc.SQLServerDriver";//給的默認值

// private String

// dakabase_url="jdbc:sybase:Tds:IP:port/dakabase_test?useUnicode=true&characterEncoding=UTF-8";

private String database_url = "jdbc:sqlserver://localhost:1433;DatabaseName=mgr_live"; //給的默認值

private String username = "sa";

private String password = "12345678";

private int maxConnections = 50;

private boolean waitIfBusy = true;

private Vector availableConnections, busyConnections;

private boolean connectionPending = false;

 

public PersonDefine_ConnectionPool(Properties props) throws SQLException {

 

System.out.println("jdbc:PersonDefine_ConnectionPool...");

int initialConnections = 0;

this.ProductionDB = props.getProperty("ELITEDATA.ProductionDB");

this.database_driver = props.getProperty("ELITEDATA.database_driver").trim();

this.database_url = props.getProperty("ELITEDATA.database_url");

this.username=props.getProperty("ELITEDATA.database_username");

this.password=props.getProperty("ELITEDATA.database_password");

this.maxConnections = maxConnections;

this.waitIfBusy = waitIfBusy;

if (initialConnections > maxConnections) {

initialConnections = maxConnections;

}

availableConnections = new Vector(initialConnections);

busyConnections = new Vector();

for (int i = 0; i < initialConnections; i++) {

availableConnections.addElement(makeNewConnection());

}

}

 

public synchronized Connection getConnection() throws SQLException {

System.out.println("jdbc:Get PersonDefine_ConnectionPool...");

if (!availableConnections.isEmpty()) {

Connection existingConnection = (Connection) availableConnections.lastElement();

int lastIndex = availableConnections.size() - 1;

availableConnections.removeElementAt(lastIndex);

// If connection on available list is closed (e.g.,

// it timed out), then remove it from available list

// and repeat the process of obtaining a connection.

// Also wake up threads that were waiting for a

// connection because maxConnection limit was reached.

if (existingConnection.isClosed()) {

notifyAll(); // Freed up a spot for anybody waiting

return (getConnection());

} else {

busyConnections.addElement(existingConnection);

return (existingConnection);

}

} else {

// Three possible cases:

// 1) You haven't reached maxConnections limit. So

// establish one in the background if there isn't

// already one pending, then wait for

// the next available connection (whether or not

// it was the newly established one).

// 2) You reached maxConnections limit and waitIfBusy

// flag is false. Throw SQLException in such a case.

// 3) You reached maxConnections limit and waitIfBusy

// flag is true. Then do the same thing as in second

// part of step 1: wait for next available connection.

 

if ((totalConnections() < maxConnections) && !connectionPending) {

makeBackgroundConnection();

} else if (!waitIfBusy) {

throw new SQLException("PersonDefine_ConnectionPool limit reached");

}

// Wait for either a new connection to be established

// (if you called makeBackgroundConnection) or for

// an existing connection to be freed up.

try {

wait();

} catch (InterruptedException ie) {

}

// Someone freed up a connection, so try again.

return (getConnection());

}

}

 

// You can't just make a new connection in the foreground

// when none are available, since this can take several

// seconds with a slow network connection. Instead,

// start a thread that establishes a new connection,

// then wait. You get woken up either when the new connection

// is established or if someone finishes with an existing

// connection.

 

private void makeBackgroundConnection() {

connectionPending = true;

System.out.println("jdbc:Make Background PersonDefine_ConnectionPool...");

try {

Thread connectThread = new Thread(this);

connectThread.start();

} catch (OutOfMemoryError oome) {

System.out.println("jdbc:PersonDefine_ConnectionPool out of Memory..." + oome);

}

}

 

public void run() {

try {

System.out.println("jdbc:run PersonDefine_ConnectionPool...");

Connection connection = makeNewConnection();

synchronized (this) {

availableConnections.addElement(connection);

connectionPending = false;

notifyAll();

}

} catch (Exception e) { // SQLException or OutOfMemory

System.out.println("jdbc:PersonDefine_ConnectionPool out of Memory...");

}

}

 

// This explicitly makes a new connection. Called in

// the foreground when initializing the ConnectionPool,

// and called in the background when running.

 

private Connection makeNewConnection() throws SQLException {

try {

System.out.println("jdbc:make new PersonDefine_ConnectionPool...");

// Load database dakabase_driver if not already loaded

Class.forName(database_driver);

// Establish network connection to database

Connection connection = DriverManager.getConnection(database_url, username, password);

return (connection);

} catch (ClassNotFoundException cnfe) {

// Simplify try/catch blocks of people using this by

// throwing only one exception type.

System.out.println("jdbc:PersonDefine_ConnectionPool Can't find class for database_driver:");

throw new SQLException("Can't find class for PersonDefine_ConnectionPool: " + database_driver);

}

}

 

public synchronized void free(Connection connection) {

System.out.println("jdbc:free PersonDefine_ConnectionPool...");

busyConnections.removeElement(connection);

availableConnections.addElement(connection);

// Wake up threads that are waiting for a connection

notifyAll();

}

 

public synchronized int totalConnections() {

return (availableConnections.size() + busyConnections.size());

}

 

/**

* Close all the connections. Use with caution: be sure no connections are

* in use before calling. Note that you are not <I>required</I> to call

* this when done with a ConnectionPool, since connections are guaranteed to

* be closed when garbage collected. But this method gives more control

* regarding when the connections are closed.

*/

 

public synchronized void closeAllConnections() {

System.out.println("jdbc:close all PersonDefine_ConnectionPool...");

closeConnections(availableConnections);

availableConnections = new Vector();

closeConnections(busyConnections);

busyConnections = new Vector();

}

 

private void closeConnections(Vector connections) {

try {

System.out.println("jdbc:close PersonDefine_ConnectionPool...");

for (int i = 0; i < connections.size(); i++) {

Connection connection = (Connection) connections.elementAt(i);

if (!connection.isClosed()) {

connection.close();

}

}

} catch (SQLException sqle) {

System.out.println("jdbc: PersonDefine_ConnectionPool..." + sqle);

}

}

 

public synchronized String toString() {

String info = "ConnectionPool(PersonDefine_ConnectionPool)(" + database_url + "," + username + ")" + ", available=" + availableConnections.size() + ", busy="

+ busyConnections.size() + ", max=" + maxConnections;

return (info);

}

}

相关标签: 数据库连接池