Proxool 0.9.1的配置与应用

核心提示： 粗体部分是变化部分，上面有详细说明！二、测试类packagelavasoft;importorg.apache.commons.logging.Log;importorg.apache.commons.logging.LogFactory;importorg.logicalcobwebs.pro

粗体部分是变化部分，上面有详细说明！

二、测试类

package　lavasoft;
import　org.apache.commons.logging.Log;
import　org.apache.commons.logging.LogFactory;
import　org.logicalcobwebs.proxool.ProxoolException;
import　org.logicalcobwebs.proxool.configuration.JAXPConfigurator;
import　java.io.FileNotFoundException;
import　java.io.IOException;
import　java.sql.*;
import　java.util.List;
import　java.util.Properties;
/**
*　简单的JDBC工具类
*
*　@author　leizhimin　2009-11-23　17:35:26
*/
public　class　MyDB　{
　　　　　　　　private　static　final　Log　log　=　LogFactory.getLog(MyDB.class);
　　　　　　　　private　static　final　boolean　useDBPool　=　true;　　　　//是否使用数据库连接池
　　　　　　　　private　static　String　dburl　=　null;
　　　　　　　　private　static　String　user　=　null;
　　　　　　　　private　static　String　password　=　null;
　　　　　　　　private　static　Properties　props　=　new　Properties();
　　　　　　　　static　{
　　　　　　　　　　　　　　　　init();
　　　　　　　　}
　　　　　　　　public　static　void　init()　{
　　　　　　　　　　　　　　　　if　(useDBPool)　{
　　　　　　　　　　　　　　　　　　　　　　　　try　{
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　JAXPConfigurator.configure("proxool.xml",　false);
//　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　JAXPConfigurator.configure("src/proxool.xml",　false);
　　　　　　　　　　　　　　　　　　　　　　　　}　catch　(ProxoolException　e)　{
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　e.printStackTrace();
　　　　　　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　　　　　　　　return;
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　try　{
//　　　　　　　　　　　　　　　　　　　　　　　　props.load(new　FileInputStream("/jdbc.properties"));
　　　　　　　　　　　　　　　　　　　　　　　　props.load(MyDB.class.getResourceAsStream("/jdbc.properties"));
　　　　　　　　　　　　　　　　}　catch　(IOException　e)　{
　　　　　　　　　　　　　　　　　　　　　　　　log.error("#ERROR#　:系统加载sysconfig.properties配置文件异常，请检查！",　e);
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　dburl　=　props.getProperty("jdbc.url");
　　　　　　　　　　　　　　　　user　=　props.getProperty("jdbc.username").trim();
　　　　　　　　　　　　　　　　password　=　props.getProperty("jdbc.password").trim();
　　　　　　　　　　　　　　　　System.out.println(dburl);
　　　　　　　　　　　　　　　　System.out.println(user);
　　　　　　　　　　　　　　　　System.out.println(password);
　　　　　　　　　　　　　　　　//注册驱动类
　　　　　　　　　　　　　　　　try　{
　　　　　　　　　　　　　　　　　　　　　　　　Class.forName(props.getProperty("jdbc.driver"));
　　　　　　　　　　　　　　　　}　catch　(ClassNotFoundException　e)　{
　　　　　　　　　　　　　　　　　　　　　　　　log.error("#ERROR#　:加载数据库驱动异常，请检查！",　e);
　　　　　　　　　　　　　　　　　　　　　　　　throw　new　RuntimeException(e);
　　　　　　　　　　　　　　　　}
　　　　　　　　}

　　　　　　　　public　static　void　main(String[]　args)　throws　FileNotFoundException　{
　　　　　　　　　　　　　　　　for　(int　i　=　0;　i　<　5;　i++)　{
　　　　　　　　　　　　　　　　　　　　　　　　Connection　conn　=　getConnection();
　　　　　　　　　　　　　　　　　　　　　　　　System.out.println(conn　==　null　?　"没连上"　:　"连上了");
//　　　　　　　　　　　　　　　　　　　　　　　　System.out.println("--------");
//　　　　　　　　　　　　　　　　closeConnection(conn);　　　　　　　　　　　　　　　　　　　　　　　　
　　　　　　　　　　　　　　　　}
　　　　　　　　}
　　　　　　　　/**
　　　　　　　　　*　创建一个数据库连接
　　　　　　　　　*
　　　　　　　　　*　@return　一个数据库连接
　　　　　　　　　*/
　　　　　　　　public　static　Connection　getConnection()　{
　　　　　　　　　　　　　　　　Connection　conn　=　null;
　　　　　　　　　　　　　　　　//根据连接池配置创建数据库连接
　　　　　　　　　　　　　　　　if　(useDBPool)　{
　　　　　　　　　　　　　　　　　　　　　　　　try　{
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　conn　=　DriverManager.getConnection("proxool.ds");
　　　　　　　　　　　　　　　　　　　　　　　　}　catch　(SQLException　e)　{
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　log.error("#ERROR#　:无法从数据库连接池获取到数据库连接！");
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　throw　new　RuntimeException(e);
　　　　　　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　　　　　　　　return　conn;
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　//根据JDBC配置创建数据库连接
　　　　　　　　　　　　　　　　try　{
　　　　　　　　　　　　　　　　　　　　　　　　conn　=　DriverManager.getConnection(dburl,　user,　password);
　　　　　　　　　　　　　　　　}　catch　(SQLException　e)　{
　　　　　　　　　　　　　　　　　　　　　　　　log.error("#ERROR#　:创建数据库连接发生异常，请检查！",　e);
　　　　　　　　　　　　　　　　　　　　　　　　throw　new　RuntimeException(e);
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　return　conn;
　　　　　　　　}
　　　　　　　　/**
　　　　　　　　　*　在一个数据库连接上执行一个静态SQL语句查询
　　　　　　　　　*
　　　　　　　　　*　@param　conn　　　　　　　　　　　　数据库连接
　　　　　　　　　*　@param　staticSql　静态SQL语句字符串
　　　　　　　　　*　@return　返回查询结果集ResultSet对象
　　　　　　　　　*/
　　　　　　　　public　static　ResultSet　executeQuery(Connection　conn,　String　staticSql)　{
　　　　　　　　　　　　　　　　ResultSet　rs　=　null;
　　　　　　　　　　　　　　　　try　{
　　　　　　　　　　　　　　　　　　　　　　　　//创建执行SQL的对象
　　　　　　　　　　　　　　　　　　　　　　　　Statement　stmt　=　conn.createStatement();
　　　　　　　　　　　　　　　　　　　　　　　　//执行SQL，并获取返回结果
　　　　　　　　　　　　　　　　　　　　　　　　rs　=　stmt.executeQuery(staticSql);
　　　　　　　　　　　　　　　　}　catch　(SQLException　e)　{
　　　　　　　　　　　　　　　　　　　　　　　　log.error("#ERROR#　:执行SQL语句出错，请检查！\n"　+　staticSql,　e);
　　　　　　　　　　　　　　　　　　　　　　　　throw　new　RuntimeException(e);
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　return　rs;
　　　　　　　　}
　　　　　　　　/**
　　　　　　　　　*　在一个数据库连接上执行一个静态SQL语句
　　　　　　　　　*
　　　　　　　　　*　@param　conn　　　　　　　　　　　　数据库连接
　　　　　　　　　*　@param　staticSql　静态SQL语句字符串
　　　　　　　　　*/
　　　　　　　　public　static　void　executeSQL(Connection　conn,　String　staticSql)　{
　　　　　　　　　　　　　　　　try　{
　　　　　　　　　　　　　　　　　　　　　　　　//创建执行SQL的对象
　　　　　　　　　　　　　　　　　　　　　　　　Statement　stmt　=　conn.createStatement();
　　　　　　　　　　　　　　　　　　　　　　　　//执行SQL，并获取返回结果
　　　　　　　　　　　　　　　　　　　　　　　　stmt.execute(staticSql);
　　　　　　　　　　　　　　　　}　catch　(SQLException　e)　{
　　　　　　　　　　　　　　　　　　　　　　　　log.error("#ERROR#　:执行SQL语句出错，请检查！\n"　+　staticSql,　e);
　　　　　　　　　　　　　　　　　　　　　　　　throw　new　RuntimeException(e);
　　　　　　　　　　　　　　　　}
　　　　　　　　}
　　　　　　　　/**
　　　　　　　　　*　在一个数据库连接上执行一批静态SQL语句
　　　　　　　　　*
　　　　　　　　　*　@param　conn　　　　　　　　数据库连接
　　　　　　　　　*　@param　sqlList　静态SQL语句字符串集合
　　　　　　　　　*/
　　　　　　　　public　static　void　executeBatchSQL(Connection　conn,　List<String>　sqlList)　{
　　　　　　　　　　　　　　　　try　{
　　　　　　　　　　　　　　　　　　　　　　　　//创建执行SQL的对象
　　　　　　　　　　　　　　　　　　　　　　　　Statement　stmt　=　conn.createStatement();
　　　　　　　　　　　　　　　　　　　　　　　　for　(String　sql　:　sqlList)　{
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　stmt.addBatch(sql);
　　　　　　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　　　　　　　　//执行SQL，并获取返回结果
　　　　　　　　　　　　　　　　　　　　　　　　stmt.executeBatch();
　　　　　　　　　　　　　　　　}　catch　(SQLException　e)　{
　　　　　　　　　　　　　　　　　　　　　　　　log.error("#ERROR#　:执行批量SQL语句出错，请检查！",　e);
　　　　　　　　　　　　　　　　}
　　　　　　　　}
　　　　　　　　public　static　void　closeConnection(Connection　conn)　{
　　　　　　　　　　　　　　　　if　(conn　==　null)　return;
　　　　　　　　　　　　　　　　try　{
　　　　　　　　　　　　　　　　　　　　　　　　if　(!conn.isClosed())　{
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//关闭数据库连接
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　conn.close();
　　　　　　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　}　catch　(SQLException　e)　{
　　　　　　　　　　　　　　　　　　　　　　　　log.error("#ERROR#　:关闭数据库连接发生异常，请检查！",　e);
　　　　　　　　　　　　　　　　　　　　　　　　throw　new　RuntimeException(e);
　　　　　　　　　　　　　　　　}
　　　　　　　　}
}