//文件：DbConnectionDefaultPool.java的第一部分
//请注意看里面注明的一处需要修改连接参数的地方
package com.qingtuo.db.pool;
import java.sql.*;
import java.util.*;
import java.io.*;
import java.text.*;
import java.util.Date;
/**
* Default Jive connection provider. It uses the excellent connection pool
* available from http://www.javaexchange.com. This connection provider is a
* a good choice unless you can use a container-managed one.
*/
public class DbConnectionDefaultPool extends DbConnectionProvider {
private static final String NAME = "Default Connection Pool";
private static final String DESCRIPTION = "The default connection provider "
+ "that uses the connection pool from javaexchange.com. It works with "
+ "almost any database setup, is customizable, and offers good performance. "
+ "Use this connection provider unless you have your own or can use a "
+ "container managed connection pool.";
private static final String AUTHOR = "CoolServlets.com";
private static final int MAJOR_VERSION = 1;
private static final int MINOR_VERSION = 0;
private static final boolean POOLED = true;
private ConnectionPool connectionPool = null;
private Properties props;
private Properties propDescriptions;
private Object initLock = new Object();
public DbConnectionDefaultPool() {
//this.manager = manager;
props = new Properties();
propDescriptions = new Properties();
//Initialize all property values
initializeProperties();
//Load any existing property values
loadProperties();
}
/**
* Returns a database connection.
*/
public Connection getConnection() {
if (connectionPool == null) {
//block until the init has been done
synchronized(initLock) {
//if still null, something has gone wrong
if (connectionPool == null) {
System.err.println("Warning: DbConnectionDefaultPool.getConnection() was " +
"called when the internal pool has not been initialized.");
return null;
}
}
}
return new ConnectionWrapper(connectionPool.getConnection(), connectionPool);
}
/**
* Starts the pool.
*/
protected void start() {
//acquire lock so that no connections can be returned.
synchronized (initLock) {
//Get properties
String driver = props.getProperty("driver");
String server = props.getProperty("server");
String username = props.getProperty("username");
String password = props.getProperty("password");
int minConnections = 0, maxConnections = 0;
double connectionTimeout = 0.0;
try {
minConnections = Integer.parseInt(props.getProperty("minConnections"));
maxConnections = Integer.parseInt(props.getProperty("maxConnections"));
connectionTimeout = Double.parseDouble(props.getProperty("connectionTimeout"));
}
catch (Exception e) {
System.err.println("Error: could not parse default pool properties. " +
"Make sure the values exist and are correct.");
e.printStackTrace();
return;
}
String logPath = props.getProperty("logPath");
try {
connectionPool = new ConnectionPool(driver, server, username, password,
minConnections, maxConnections, logPath, connectionTimeout);
}
catch (IOException ioe) {
System.err.println("Error starting DbConnectionDefaultPool: " + ioe);
ioe.printStackTrace();
}
}
}
/**
* Restarts the pool to take into account any property changes.
*/
protected void restart() {
//Kill off pool.
destroy();
//Reload properties.
loadProperties();
//Start a new pool.
start();
}
/**
* Destroys the connection pool.
*/
protected void destroy() {
if (connectionPool != null) {
try {
connectionPool.destroy(1);
}
catch (Exception e) {
e.printStackTrace();
}
}
//Release reference to connectionPool
connectionPool = null;
}
/**
* Returns the value of a property of the connection provider.
*
* @param name the name of the property.
* @returns the value of the property.
*/
public String getProperty(String name) {
return (String)props.get(name);
}
/**
* Returns the description of a property of the connection provider.
*
* @param name the name of the property.
* @return the description of the property.
*/
public String getPropertyDescription(String name) {
return (String)propDescriptions.get(name);
}
/**
* Returns an enumeration of the property names for the connection provider.
*/
public Enumeration propertyNames() {
return props.propertyNames();
}
/**
* Sets a property of the connection provider. Each provider has a set number
* of properties that are determined by the author. Trying to set a non-
* existant property will result in an IllegalArgumentException.
*
* @param name the name of the property to set.
* @param value the new value for the property.
*
*/
public void setProperty(String name, String value) {
props.put(name, value);
saveProperties();
}
/**
* Give default values to all the properties and descriptions.
*/
private void initializeProperties() {
props.put("driver","");
props.put("server","");
props.put("username","");
props.put("password","");
props.put("minConnections","");
props.put("maxConnections","");
props.put("logPath","");
props.put("connectionTimeout","");
propDescriptions.put("driver","JDBC driver. e.g. 'oracle.jdbc.driver.OracleDriver'");
propDescriptions.put("server","JDBC connect string. e.g. 'jdbc:oracle:thin:@203.92.21.109:1526:orcl'");
propDescriptions.put("username","Database username. e.g. 'Scott'");
propDescriptions.put("password","Database password. e.g. 'Tiger'");
propDescriptions.put("minConnections","Minimum # of connections to start with in pool. Three is the recommended minimum");
propDescriptions.put("maxConnections","Maximum # of connections in dynamic pool. Fifteen should give good performance for an average load.");
propDescriptions.put("logPath","Absolute path name for log file. e.g. 'c:\\logs\\jiveDbLog.log'");
propDescriptions.put("connectionTimeout","Time in days between connection resets. e.g. '.5'");
}
/**
* Load whatever properties that already exist.
*/
private void loadProperties() {
//在这里修改一些连接参数
//in 2000
/*
String driver="org.gjt.mm.mysql.Driver";
String server="jdbc:mysql://192.100.100.11/pcc";
String username="pcc";
String password="pcc123";
String minConnections="3";
String maxConnections="10";
String logPath="c:\\temp\\qingtuoDbLog.log";
String connectionTimeout="0.5";
*/
//in Linux
String driver="org.gjt.mm.mysql.Driver";
String server="jdbc:mysql://192.100.100.1/qingtuo";
//String server="jdbc:mysql://192.168.0.1/qingtuo";
String username="qingtuo";
String password="qingtuo";
String minConnections="3";
String maxConnections="20";
String logPath="c:\\temp\\qingtuoDbLog.log";
// String logPath="/tmp/qingtuoDbLog.log";
String connectionTimeout="0.5";
if (driver != null) { props.setProperty("driver", driver); }
if (server != null) { props.setProperty("server", server); }
if (username != null) { props.setProperty("username", username); }
if (password != null) { props.setProperty("password", password); }
//if (database != null) { props.setProperty("database", database); }
if (minConnections != null) { props.setProperty("minConnections", minConnections); }
if (maxConnections != null) { props.setProperty("maxConnections", maxConnections); }
if (logPath != null) { props.setProperty("logPath", logPath); }
if (connectionTimeout != null) { props.setProperty("connectionTimeout", connectionTimeout); }
}
private void saveProperties() {
PropertyManager.setProperty("DbConnectionDefaultPool.driver", props.getProperty("driver"));
PropertyManager.setProperty("DbConnectionDefaultPool.server", props.getProperty("server"));
PropertyManager.setProperty("DbConnectionDefaultPool.username", props.getProperty("username"));
PropertyManager.setProperty("DbConnectionDefaultPool.password", props.getProperty("password"));
PropertyManager.setProperty("DbConnectionDefaultPool.minConnections", props.getProperty("minConnections"));
PropertyManager.setProperty("DbConnectionDefaultPool.maxConnections", props.getProperty("maxConnections"));
PropertyManager.setProperty("DbConnectionDefaultPool.logPath", props.getProperty("logPath"));
PropertyManager.setProperty("DbConnectionDefaultPool.connectionTimeout", props.getProperty("connectionTimeout"));
}
private class ConnectionPool implements Runnable {
private Thread runner;
private Connection[] connPool;
private int[] connStatus;
private long[] connLockTime, connCreateDate;
private String[] connID;
private String dbDriver, dbServer, dbLogin, dbPassword, logFileString;
private int currConnections, connLast, minConns, maxConns, maxConnMSec;
//available: set to false on destroy, checked by getConnection()
private boolean available=true;
private PrintWriter log;
private SQLWarning currSQLWarning;
private String pid;
/**
* Creates a new Connection Broker<br>
* dbDriver: JDBC driver. e.g. 'oracle.jdbc.driver.OracleDriver'<br>
* dbServer: JDBC connect string. e.g. 'jdbc:oracle:thin:@203.92.21.109:1526:orcl'<br>
* dbLogin: Database login name. e.g. 'Scott'<br>
* dbPassword: Database password. e.g. 'Tiger'<br>
* minConns: Minimum number of connections to start with.<br>
* maxConns: Maximum number of connections in dynamic pool.<br>
* logFileString: Absolute path name for log file. e.g. 'c:\temp\mylog.log' <br>
* maxConnTime: Time in days between connection resets. (Reset does a basic cleanup)<br>
*/
public ConnectionPool (String dbDriver, String dbServer, String dbLogin,
String dbPassword, int minConns, int maxConns,
String logFileString, double maxConnTime) throws IOException
{
connPool = new Connection[maxConns];
connStatus = new int[maxConns];
connLockTime = new long[maxConns];
connCreateDate = new long[maxConns];
connID = new String[maxConns];
currConnections = minConns;
this.maxConns = maxConns;
this.dbDriver = dbDriver;
this.dbServer = dbServer;
this.dbLogin = dbLogin;
this.dbPassword = dbPassword;
this.logFileString = logFileString;
maxConnMSec = (int)(maxConnTime * 86400000.0); //86400 sec/day
if(maxConnMSec < 30000) { // Recycle no less than 30 seconds.
maxConnMSec = 30000;
}
try {
log = new PrintWriter(new FileOutputStream(logFileString),true);
// Can't open the requested file. Open the default file.
}
catch (IOException e1) {
System.err.println("Warning: DbConnectionDefaultPool could not open \""
+ logFileString + "\" to write log to. Make sure that your Java " +
"process has permission to write to the file and that the directory exists."
);
try {
log = new PrintWriter(new FileOutputStream("DCB_" +
System.currentTimeMillis() + ".log"), true
);
}
catch (IOException e2) {
throw new IOException("Can't open any log file");
}
}
// Write the pid file (used to clean up dead/broken connection)
SimpleDateFormat formatter
= new SimpleDateFormat ("yyyy.MM.dd G 'at' hh:mm:ss a zzz");
java.util.Date nowc = new java.util.Date();
pid = formatter.format(nowc);
BufferedWriter pidout = new BufferedWriter(new
FileWriter(logFileString + "pid"));
pidout.write(pid);
pidout.close();
log.println("Starting ConnectionPool:");
log.println("dbDriver = " + dbDriver);
log.println("dbServer = " + dbServer);
log.println("dbLogin = " + dbLogin);
log.println("log file = " + logFileString);
log.println("minconnections = " + minConns);
log.println("maxconnections = " + maxConns);
log.println("Total refresh interval = " + maxConnTime + " days");
log.println("-----------------------------------------");
// Initialize the pool of connections with the mininum connections:
// Problems creating connections may be caused during reboot when the
// servlet is started before the database is ready. Handle this
// by waiting and trying again. The loop allows 5 minutes for
// db reboot.
boolean connectionsSucceeded=false;
int dbLoop=20;
try {
for(int i=1; i < dbLoop; i++) {
try {
for(int j=0; j < currConnections; j++) {
log.println("Create Conn "+j);
createConn(j);
}
connectionsSucceeded=true;
break;
}
catch (SQLException e){
log.println("--->Attempt (" + String.valueOf(i) +
" of " + String.valueOf(dbLoop) +
") failed to create new connections set at startup: ");
log.println(" " + e);
log.println(" Will try again in 15 seconds...");
try { Thread.sleep(15000); }
catch(InterruptedException e1) {}
}
}
if(!connectionsSucceeded) { // All attempts at connecting to db exhausted
log.println("\r\nAll attempts at connecting to Database exhausted");
throw new IOException();
}
}
catch (Exception e) {
throw new IOException();
}
// Fire up the background housekeeping thread
runner = new Thread(this);
runner.start();
} //End ConnectionPool()
//文件：DbConnectionDefaultPool.java的第二部分
/**
* Housekeeping thread. Runs in the background with low CPU overhead.
* Connections are checked for warnings and closure and are periodically
* restarted.
* This thread is a catchall for corrupted
* connections and prevents the buildup of open cursors. (Open cursors
* result when the application fails to close a Statement).
* This method acts as fault tolerance for bad connection/statement programming.
*/
public void run() {
boolean forever = true;
Statement stmt=null;
String currCatalog=null;
while(forever) {
// Make sure the log file is the one this instance opened
// If not, clean it up!
try {
BufferedReader in = new BufferedReader(new
FileReader(logFileString + "pid"));
String curr_pid = in.readLine();
if(curr_pid.equals(pid)) {
//log.println("They match = " + curr_pid);
}
else {
//log.println("No match = " + curr_pid);
log.close();
// Close all connections silently - they are definitely dead.
for(int i=0; i < currConnections; i++) {
try {
connPool[i].close();
}
catch (SQLException e1) {} // ignore
}
// Returning from the run() method kills the thread
return;
}
in.close();
}
catch (IOException e1) {
log.println("Can't read the file for pid info: " +
logFileString + "pid");
}
// Get any Warnings on connections and print to event file
for(int i=0; i < currConnections; i++) {
try {
currSQLWarning = connPool[i].getWarnings();
if(currSQLWarning != null) {
log.println("Warnings on connection " +
String.valueOf(i) + " " + currSQLWarning);
connPool[i].clearWarnings();
}
}
catch(SQLException e) {
log.println("Cannot access Warnings: " + e);
}
}
for(int i=0; i < currConnections; i++) { // Do for each connection
long age = System.currentTimeMillis() - connCreateDate[i];
synchronized(connStatus) {
if(connStatus[i] > 0) { // In use, catch it next time!
continue;
}
connStatus[i] = 2; // Take offline (2 indicates housekeeping lock)
}
try { // Test the connection with createStatement call
if(age > maxConnMSec) { // Force a reset at the max conn time
throw new SQLException();
}
stmt = connPool[i].createStatement();
connStatus[i] = 0; // Connection is O.K.
//log.println("Connection confirmed for conn = " +
// String.valueOf(i));
// Some DBs return an object even if DB is shut down
if(connPool[i].isClosed()) {
throw new SQLException();
}
// Connection has a problem, restart it
}
catch(SQLException e) {
try {
log.println(new Date().toString() +
" ***** Recycling connection " +
String.valueOf(i) + ":");
connPool[i].close();
createConn(i);
}
catch(SQLException e1) {
log.println("Failed: " + e1);
connStatus[i] = 0; // Can't open, try again next time
}
}
finally {
try {
if(stmt != null) {
stmt.close();
}
}
catch(SQLException e1){};
}
}
try {
Thread.sleep(20000);
} // Wait 20 seconds for next cycle
catch(InterruptedException e) {
// Returning from the run method sets the internal
// flag referenced by Thread.isAlive() to false.
// This is required because we don't use stop() to
// shutdown this thread.
return;
}
}
} // End run