ConnectionPooljar数据连接池文件包的制作流程模板.doc

ConnectionPooljar数据连接池文件包的制作流程模板

81

资料内容仅供您学习参考，如有不当或者侵权，请联系改正或者删除。
关于ConnectionPool.jar数据连接池文件包的制作流程

目的: 制作通用型数据连接池文件包, 便于应用于通用工程
结构: 工程包内classes目录内
1.ConnectionPool : 连接池管理程序
|______ConnectionPool.java
|______ConnectionWrapper.java
|______LogFile.java
|______LogWriter.java
|______MakeDateTime.java
|______PoolManager.java

2. com : MySql JDBC驱动程序
3. org : MySql JDBC驱动程序
4. net : MSSqlserver JTDS 驱动程序
5. javax : Oracle JDBC 驱动程序
6. oracle : Oracle JDBC 驱动程序

制作流程:
1. 新建一个工程命名为Pool, 在工程内建立一个war模块命名为Poolwar;
2. 在工程内新建class文件, 文件的包起名为ConnectionPool;
3. 依次新建下列文件: ConnectionPool.java、 ConnectionWrapper.java、 LogFile.java、 LogWriter.java、 MakeDateTime.java、 PoolManager.java
4. 将Oracle for JDBC驱动classes12.jar文件用winrar解压缩, 得到javax和oracle两个文件夹, 将这两个文件夹复制到Pool工程内的classes目录下;
5. 将MS-Sqlserver for JDBC驱动jtds-1.2.jar文件用winrar解压缩, 得到net这个文件夹, 将这个文件夹复制到Pool工程内的classes目录下;
6. 将MySql for JDBC驱动mysql-connector-java-3.0.16-ga-bin.jar文件用winrar解压缩, 得到com和org两个文件夹, 将这两个文件夹复制到Pool工程内的classes目录下;
7. 如果需要添加其它驱动程序, 可参照4-6进行;
8. 选择JBuilder工具条上Wizards--àArchive Builder ;

9.Archive Builder – Step 1 of 5 : Archive Type 选择Basic( 具体类型含义参考JBuilerX使用手册) ;

10. Archive Builder – Step 2 of 5 : 将Name 和 File 命名为需要的名字, 这里同意将其命名为ConnectionPool, 其它的选项均不做更改;

11．Archive Builder – Step 3 of 5 : 指定结构文件包含内容, 这里不做任何修改;

12．Archive Builder – Step 4 of 5 : 将servlet 选择为 Allways include all classes and resources;

13．Archive Builder – Step 4 of 5 : 保持默认状态不改变, 按finish完成结构文件的定义;

14．在工程窗口用鼠标右键点 ConnectionPool 结构, 然后选择make 生成结构文件;

使用方法:
1. 将该jar文件添加到 ToolsàConfigure Librarise 中;
2. 新加工程, 在工程 Required Librarise 中添加该库文件;
3. 在工程中新建一个”连接池初始化类”负责建立数据连接;
4. 在工程中新建一属性文件----db.properties, 负责描述数据库驱动及用户信息等, 该属性文件存放的位置在PoolManager.java中定义;
5. 在PoolManager.java中默认为”../ db.properties”,该位置表示在/WEB-INF 目录下;

附录: 文件代码
************************文件开始***************************
db.properties //属性文件
***********************************************************
XBDBManager Properties
poolname = sqlpool oraclepool 注: 中间以空格分隔
drivers = net.sourceforge.jtds.jdbc.Driver oracle.jdbc.driver.OracleDriver 注: 中间以空格分隔
logfile = d:\\logfile.txt

sqlpool.url = jdbc:jtds:sqlserver://10.1.1.2:1433;DatabaseName=pda
sqlpool.initconns=50
sqlpool.maxconns=80
sqlpool.user = pda
sqlpool.password = pdapass1234

oraclepool.url = jdbc:oracle:thin:@172.168.72.8:1521:infodb
oraclepool.initconns=50
oraclepool.maxconns=80
oraclepool.user = tjold
oraclepool.password = tjold
************************文件结束***************************

************************文件开始***************************
ConnectionPool.java
***********************************************************
package ConnectionPool;

import java.io.*;
import java.sql.*;
import java.util.*;

public class ConnectionPool {
private String name;
private String URL;
private String user;
private String password;
private int maxConns;
private int timeOut;
private LogWriter logWriter;

private int checkedOut;
private Vector freeConnections = new Vector();

public ConnectionPool(String name, String URL, String user,
String password, int maxConns, int initConns, int timeOut,
PrintWriter pw, int logLevel)
{
this.name = name;
this.URL = URL;
this.user = user;
this.password = password;
this.maxConns = maxConns;
this.timeOut = timeOut > 0 ? timeOut : 5;

logWriter = new LogWriter(name, logLevel, pw);
initPool(initConns);

logWriter.log("New pool created", LogWriter.INFO);
String lf = System.getProperty("line.separator");

logWriter.log(
" url=" + URL +
" user=" + user +
// " password=" + password +
" initconns=" + initConns +
" maxconns=" + maxConns +
" logintimeout=" + this.timeOut, LogWriter.INFO);
logWriter.log(getStats(), LogWriter.INFO);
}

private void initPool(int initConns) {
for (int i = 0; i < initConns; i++) {
try {
Connection pc = newConnection();
freeConnections.addElement(pc);
}
catch (SQLException e)
{ }
}
}

public Connection getConnection() throws SQLException
{
logWriter.log("Request for connection received", LogWriter.DEBUG);
try
{
Connection conn = getConnection(timeOut * 1000);
return new ConnectionWrapper(conn, this);
}
catch(SQLException e)
{
logWriter.log(e, "Exception getting connection", logWriter.ERROR);
throw e;
}
}

synchronized void wrapperClosed(Connection conn)
{
freeConnections.addElement(conn);
checkedOut--;
notifyAll();

logWriter.log("Returned wrapperClosed to pool", LogWriter.INFO);
logWriter.log(getStats(), LogWriter.INFO);
}

private synchronized Connection getConnection(long timeout) throws SQLException {
// Get a pooled Connection from the cache or a new one.
// Wait if all are checked out and the max limit has
// been reached.
long startTime = System.currentTimeMillis();
long remaining = timeout;
Connection conn = null;
while ((conn = getPooledConnection()) == null) {
try {
logWriter.log("Waiting for connection. Timeout=" + remaining,
LogWriter.DEBUG);
wait(remaining);
}
catch (InterruptedException e)
{ }
remaining = timeout - (System.currentTimeMillis() - startTime);
if (remaining <= 0) {
// Timeout has expired
logWriter.log("Time-out while waiting for connection",
LogWriter.DEBUG);
throw new SQLException("getConnection() timed-out");
}
}

// Check if the Connection is still OK
if (!isConnectionOK(conn)) {
// It was bad. Try again with the remaining timeout
logWriter.log("Removed selected bad connection from pool",
LogWriter.ERROR);
return getConnection(remaining);
}
checkedOut++;
logWriter.log("Delivered getConnection from pool", LogWriter.INFO);
logWriter.log(getStats(), LogWriter.INFO);
return conn;
}

private boolean isConnectionOK(Connection conn) {
Statement testStmt = null;
try {
if (!conn.isClosed()) {
// Try to createStatement to see if it's really alive
testStmt = conn.createStatement();
testStmt.close();
}
else {
return false;
}
}
catch (SQLException e) {
if (testStmt != null) {
try {
testStmt.close();
}
catch (SQLException se)
{ }
}
logWriter.log(e, "Pooled Connection was not okay", LogWriter.ERROR);
return false;
}
return true;
}

private Connection getPooledConnection() throws SQLException {
Connection conn = null;
if (freeConnections.size() > 0) {
// Pick the first Connection in the Vector
// to get round-robin usage
conn = (Connection) freeConnections.firstElement();
freeConnections.removeElementAt(0);
}
else if (maxConns == 0 || checkedOut < maxConns) {
conn = newConnection();
}
return conn;
}

private Connection newConnection() throws SQLException {
Connection conn = null;
if (user == null) {
conn = DriverManager.getConnection(URL);
}
else {
conn = DriverManager.getConnection(URL, user, password);
}
logWriter.log("Opened a new connection", LogWriter.INFO);
logWriter.log(getStats(), LogWriter.INFO);
return conn;
}

public synchronized void freeConnection(Connection conn) {
// Put the connection at the end of the Vector
freeConnections.addElement(conn);
checkedOut--;
notifyAll();

logWriter.log("Returned freeConnection to pool", LogWriter.INFO);
logWriter.log(getStats(), LogWriter.INFO);
}

public synchronized void release() {
Enumeration allConnections = freeConnections.elements();
while (allConnections.hasMoreElements()) {
Connection con = (Connection) allConnections.nextElement();
try {
con.close();
logWriter.log("release Closed connection", LogWriter.INFO);
}
catch (SQLException e) {
logWriter.log(e, "release Couldn't close connection", LogWriter.ERROR);
}
}
freeConnections.removeAllElements();
}

private String getStats() {
return "Total connections: " + (freeConnections.size() + checkedOut)
+ " Available: " + freeConnections.size() + " Checked-out: " + checkedOut;
}
}

************************文件结束***************************

************************文件开始***************************
ConnectionWrapper.java
***********************************************************
package ConnectionPool;

import java.sql.*;
import java.util.*;

/**
* This class is a wrapper around a Connection, overriding the
* close method to just inform the pool that it's available for
* reuse again, and the isClosed method to return the state
* of the wrapper instead of the Connection.
*/
class ConnectionWrapper implements Connection {
// realConn should be private but we use package scope to
// be able to test removal of bad connections
Connection realConn;
private ConnectionPool pool;
private boolean isClosed = false;

public ConnectionWrapper(Connection realConn, ConnectionPool pool)
{
this.realConn = realConn;
this.pool = pool;
}

/**
* Inform the ConnectionPool that the ConnectionWrapper
* is closed.
*/
public void close() throws SQLException
{
isClosed = true;
pool.wrapperClosed(realConn);
}

/**
* Returns true if the ConnectionWrapper is closed, false
* otherwise.
*/
public boolean isClosed() throws SQLException
{
return isClosed;
}

/*
* Wrapped methods.
*/
public void clearWarnings() throws SQLException
{
if (isClosed)
{
throw new SQLException("Pooled connection is closed");
}
realConn.clearWarnings();
}

public void commit() throws SQLException
{
if (isClosed)
{
throw new SQLException("Pooled connection is closed");
}
realCmit();
}

public Statement createStatement() throws SQLException
{
if (isClosed)
{
throw new SQLException("Pooled connection is closed");
}
return realConn.createStatement();
}

public boolean getAutoCommit() throws SQLException
{
if (isClosed)
{
throw new SQLException("Pooled connection is closed");
}
return realConn.getAutoCommit();
}

public String getCatalog() throws SQLException
{
if (isClosed)
{
throw new SQLException("Pooled connection is closed");
}
return realConn.getCatalog();
}

public DatabaseMetaData getMetaData() throws SQLException
{
if (isClosed)
{
throw new SQLException("Pooled connection is closed");
}
return realConn.getMetaData();
}

public int getTransactionIsolation() throws SQLException {
if (isClosed) {
throw new SQLException("Pooled connection is closed");
}
return realConn.getTransactionIsolation();
}

public SQLWarning getWarnings() throws SQLException {
if (isClosed) {
throw new SQLException("Pooled connection is closed");
}
return realConn.getWarnings();
}

public boolean isReadOnly() th