使用Java编写控制JDBC连接、执行及关闭的工具类
简单的Java数据库连接和关闭工具类
写JDBC应用的人常常为关闭资源而头痛不已，这些代码枯燥无味，如何才能用简单的代码进行关闭呢，下面我写了一个方法，可以解除你的痛苦：
/**
*关闭所有可关闭资源
*
*@paramobjs可关闭的资源对象有Connection、Statement、ResultSet，别的类型资源自动忽略
*/
publicstaticvoidcloseAll(Object...objs){
for(Objectobj:objs){
if(objinstanceofConnection)close((Connection)obj);
if(objinstanceofStatement)close((Statement)obj);
if(objinstanceofResultSet)close((ResultSet)obj);
}
}
这个方法，带了“...”参数，这个实际上是Java5中的可变参数方法。可以不论顺序，不论个数，调用时候直接关闭想要关闭的资源对象就ok了。例如：
catch(SQLExceptione){
e.printStackTrace();
}finally{
DBTools.closeAll(stmt,pstmt1,pstmt2,conn);
}
下面给出这个类完整的写法：
packagecom.lavasoft.ibatistools.common;
importcom.lavasoft.ibatistools.bean.Table;
importcom.lavasoft.ibatistools.metadata.DataSourceMetaData;
importcom.lavasoft.ibatistools.metadata.MySQLDataSourceMetaData;
importjava.io.IOException;
importjava.io.InputStream;
importjava.sql.*;
importjava.util.List;
importjava.util.Properties;
/**
*简单的Java数据库连接和关闭工具类
*
*@authorleizhimin11-12-20下午4:32
*/
publicclassDBTools{
privatestaticStringdriverClassName,url,user,password;
static{
init();
}
privatestaticvoidinit(){
InputStreamin=DBTools.class.getResourceAsStream("/com/lavasoft/ibatistools/jdbc.properties");
Propertiespreps=newProperties();
try{
preps.load(in);
driverClassName=preps.getProperty("jdbc.driver");
url=preps.getProperty("jdbc.url");
user=preps.getProperty("jdbc.username");
password=preps.getProperty("jdbc.password");
}catch(IOExceptione){
e.printStackTrace();
}
}
/**
*创建一个JDBC连接
*
*@return一个JDBC连接
*/
publicstaticConnectionmakeConnection(){
Connectionconn=null;
try{
Class.forName(driverClassName);
conn=DriverManager.getConnection(url,user,password);
}catch(ClassNotFoundExceptione){
e.printStackTrace();
}catch(SQLExceptione){
e.printStackTrace();
}
returnconn;
}
publicstaticvoidclose(Connectionconn){
if(conn!=null)
try{
conn.close();
}catch(SQLExceptione){
e.printStackTrace();
}
}
publicstaticvoidclose(ResultSetrs){
if(rs!=null)
try{
rs.close();
}catch(SQLExceptione){
e.printStackTrace();
}
}
publicstaticvoidclose(Statementstmt){
if(stmt!=null)
try{
stmt.close();
}catch(SQLExceptione){
e.printStackTrace();
}
}
/**
*关闭所有可关闭资源
*
*@paramobjs可关闭的资源对象有Connection、Statement、ResultSet，别的类型资源自动忽略
*/
publicstaticvoidcloseAll(Object...objs){
for(Objectobj:objs){
if(objinstanceofConnection)close((Connection)obj);
if(objinstanceofStatement)close((Statement)obj);
if(objinstanceofResultSet)close((ResultSet)obj);
}
}
publicstaticvoidmain(String[]args){
DataSourceMetaDatadbmd=MySQLDataSourceMetaData.instatnce();
List<Table>tableList=dbmd.getAllTableMetaData(DBTools.makeConnection());
for(Tabletable:tableList){
System.out.println(table);
}
}
}
因为是在写工具，连接用到的次数很少，所以这里采用jdbc模式创建，而没有用到连接池。关闭方法用起来很爽，减少了代码量，也提高了程序的可靠性和质量。
一个简单的JDBC通用工具
支持多种数据库，统一方式产生连接，最优化、最简单方式释放资源。
欢迎拍砖！
importorg.apache.commons.logging.Log;
importorg.apache.commons.logging.LogFactory;
importjava.sql.*;
importjava.util.List;
importjava.util.Properties;
/**
*通用数据库操作工具，提供数据库连接获取、SQL执行、资源关闭等功能，支持的数据库为Oracle10g、MySQL5.x。</P>
*
*@authorleizhimin2012-03-0511:22
*/
publicclassDBToolkit{
privatestaticLoglog=LogFactory.getLog(DBToolkit.class);
static{
try{
Class.forName("oracle.jdbc.driver.OracleDriver");
Class.forName("com.mysql.jdbc.Driver");
}catch(ClassNotFoundExceptione){
log.error("加载数据库驱动发生错误！");
e.printStackTrace();
}
}
/**
*创建一个数据库连接
*
*@paramurl数据库连接URL串
*@paramproperties作为连接参数的任意字符串标记/值对的列表；通常至少应该包括"user"和"password"属性
*@return一个JDBC的数据库连接
*@throwsSQLException获取连接失败时候抛出
*/
publicstaticConnectionmakeConnection(Stringurl,Propertiesproperties)throwsSQLException{
Connectionconn=null;
try{
conn=DriverManager.getConnection(url,properties);
}catch(SQLExceptione){
log.error("获取数据库连接发生异常",e);
throwe;
}
returnconn;
}
/**
*在一个数据库连接上执行一个静态SQL语句查询
*
*@paramconn数据库连接
*@paramstaticSql静态SQL语句字符串
*@return返回查询结果集ResultSet对象
*@throwsSQLException执行异常时候抛出
*/
publicstaticResultSetexecuteQuery(Connectionconn,StringstaticSql)throwsSQLException{
ResultSetrs=null;
try{
//创建执行SQL的对象
Statementstmt=conn.createStatement();
//执行SQL，并获取返回结果
rs=stmt.executeQuery(staticSql);
}catch(SQLExceptione){
log.error("执行SQL语句出错，请检查！\n"+staticSql);
throwe;
}
returnrs;
}
/**
*在一个数据库连接上执行一个静态SQL语句
*
*@paramconn数据库连接
*@paramstaticSql静态SQL语句字符串
*@throwsSQLException执行异常时候抛出
*/
publicstaticvoidexecuteSQL(Connectionconn,StringstaticSql)throwsSQLException{
Statementstmt=null;
try{
//创建执行SQL的对象
stmt=conn.createStatement();
//执行SQL，并获取返回结果
stmt.execute(staticSql);
}catch(SQLExceptione){
log.error("执行SQL语句出错，请检查！\n"+staticSql);
throwe;
}finally{
close(stmt);
}
}
/**
*在一个数据库连接上执行一批静态SQL语句
*
*@paramconn数据库连接
*@paramsqlList静态SQL语句字符串集合
*@throwsSQLException执行异常时候抛出
*/
publicstaticvoidexecuteBatchSQL(Connectionconn,List<String>sqlList)throwsSQLException{
try{
//创建执行SQL的对象
Statementstmt=conn.createStatement();
for(Stringsql:sqlList){
stmt.addBatch(sql);
}
//执行SQL，并获取返回结果
stmt.executeBatch();
}catch(SQLExceptione){
log.error("执行批量SQL语句出错，请检查！");
throwe;
}
}
/**
*获取Oracle数据一个指定的Sequence下一个值
*
*@paramconn数据库连接
*@paramseq_nameSequence名称
*@returnSequence下一个值
*/
publicstaticlongsequenceNextval(Connectionconn,Stringseq_name){
longval=-1L;
Statementstmt=null;
ResultSetrs=null;
try{
//创建执行SQL的对象
stmt=conn.createStatement();
//执行SQL，并获取返回结果
rs=stmt.executeQuery("select"+seq_name+".nextvalfromdual");
if(rs.next())val=rs.getLong(1);
}catch(SQLExceptione){
log.error("#ERROR#:获取Sequence值出错，请检查！\n"+seq_name);
e.printStackTrace();
thrownewRuntimeException(e);
}finally{
close(rs);
close(stmt);
}
returnval;
}
/**
*关闭所有可关闭的JDBC资源，不论先后顺序，总能以正确的顺序执行
*
*@paramobjs可关闭的资源对象有Connection、Statement、ResultSet，别的类型资源自动忽略
*/
publicstaticvoidcloseAll(Object...objs){
for(Objectobj:objs)
if(objinstanceofResultSet)close((ResultSet)obj);
for(Objectobj:objs)
if(objinstanceofStatement)close((Statement)obj);
for(Objectobj:objs)
if(objinstanceofConnection)close((Connection)obj);
}
privatestaticvoidclose(Connectionconn){
if(conn!=null)
try{
conn.close();
}catch(SQLExceptione){
log.error("关闭数据库连接发生异常！");
}
}
privatestaticvoidclose(ResultSetrs){
if(rs!=null)
try{
rs.close();
}catch(SQLExceptione){
log.error("关闭结果集发生异常！");
}
}
privatestaticvoidclose(Statementstmt){
if(stmt!=null)
try{
stmt.close();
}catch(SQLExceptione){
log.error("关闭SQL语句发生异常！");
}
}
/**
*测试代码，没用
*
*@paramargs
*@throwsSQLException
*/
publicstaticvoidmain(String[]args)throwsSQLException{
Stringtns="jdbc:oracle:thin:@\n"+
"(description=\n"+
"\t(ADDRESS_LIST=\n"+
"\t\t(address=(protocol=tcp)(host=10.87.30.44)(port=1521))\n"+
"\t\t(address=(protocol=tcp)(host=10.87.30.45)(port=1521))\n"+
"\t\t(address=(protocol=tcp)(host=10.87.30.46)(port=1521))\n"+
"\t\t(load_balance=yes)\n"+
"\t)\n"+
"\t(connect_data=\n"+
"\t\t(service_name=KFCS)\n"+
"\t\t(failover_mode=\n"+
"\t\t\t(type=session)\n"+
"\t\t\t(method=basic)\n"+
"\t\t\t(retries=5)\n"+
"\t\t\t(delay=15)\n"+
"\t\t)\n"+
"\t)\n"+
")";
Propertiesp_ora=newProperties();
p_ora.put("user","base");
p_ora.put("password","1qaz!QAZ");
p_ora.put("internal_logon","normal");
Connectionora_conn=makeConnection(tns,p_ora);
ResultSetrs1=ora_conn.createStatement().executeQuery("selectcount(1)frombase.cfg_static_data");
rs1.next();
System.out.println(rs1.getInt(1));
rs1.close();
ora_conn.close();
Propertiesp_mysql=newProperties();
p_mysql.put("user","root");
p_mysql.put("password","leizm");
Stringurl="jdbc:mysql://localhost:3306/tdmc";
Connectionmysql_conn=makeConnection(url,p_mysql);
ResultSetrs2=mysql_conn.createStatement().executeQuery("selectcount(1)fromcfg_code");
rs2.next();
System.out.println(rs2.getInt(1));
rs2.close();
mysql_conn.close();
}
}