JDBC工具类

http://lavasoft.blog.51cto.com/62575/233549

 

 

jdbc.properties

jdbc.url=jdbc:mysql: //192.168.1.101:3306/testdb?autoReconnect=true&zeroDateTimeBehavior=convertToNull 
jdbc.username=root 
jdbc.password=leizhimin

 

DBToolkit.java

package lavasoft.common; 

import org.apache.commons.logging.Log; 
import org.apache.commons.logging.LogFactory; 

import java.io.IOException; 
import java.sql.*; 
import java.util.List; 
import java.util.Properties; 

/** 
* JDBC工具类 
* 
* @author leizhimin 2009-11-24 9:28:03 
*/ 
public  class DBToolkit { 
         private  static  final Log log = LogFactory.getLog(DBToolkit. class); 
         private  static String url =  null; 
         private  static String username =  null; 
         private  static String password =  null; 
         private  static Properties props =  new Properties(); 

         static { 
                 try { 
                        props.load(DBToolkit. class.getResourceAsStream( "/jdbc.properties")); 
                }  catch (IOException e) { 
                        log.error( "#ERROR# :系统加载sysconfig.properties配置文件异常，请检查！", e); 
                } 
                url = (props.getProperty( "jdbc.url")); 
                username = (props.getProperty( "jdbc.username")); 
                password = (props.getProperty( "jdbc.password")); 
                 //注册驱动类 
                 try { 
                        Class.forName( "com.mysql.jdbc.Driver"); 
                }  catch (ClassNotFoundException e) { 
                        log.error( "#ERROR# :加载数据库驱动异常，请检查！", e); 
                } 
        } 

         /** 
         * 创建一个数据库连接 
         * 
         * @return 一个数据库连接 
         */ 
         public  static Connection getConnection() { 
                Connection conn =  null; 
                 //创建数据库连接 
                 try { 
                        conn = DriverManager.getConnection(url, username, password); 
                }  catch (SQLException e) { 
                        log.error( "#ERROR# :创建数据库连接发生异常，请检查！", 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); 
                } 
                 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); 
                } 
        } 

         /** 
         * 在一个数据库连接上执行一批静态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); 
                } 
        } 
}

 

这个类的实现中，有几点说明下：

1、此类没有实例，一切静态化。

2、此类线程安全。

3、此类将数据库连接交给了使用者去控制，提高连接的利用率，常规的做法是每个SQL执行完成后，做一个关闭操作。

通过此类，实现了原来iBatis实现的DAO和Service，因为传递了连接，改用JDBC实现时候去掉了DAO层，只有Service层，Service中的每个操作数据库的方法都会接收一个数据库连接参数。 以方便更高层对Connection的利用，最大限度的利用数据库连接，从而提高系统的效率。

4、此类SQL异常时候，用户还有机会去关闭数据库连接。

5、此类没有事物控制，如果需要的话，可以在Service此工具类中跑出SQLException，然后在Service中调用的时候进行控制，一旦发生异常，则回滚。一切都交给开发者自行处理控制，相比框架式的一刀切更能灵活控制事物，并能最大限度利用数据库连接的资源。

6、此类的方法可以嵌套调用，为级联查询提供方便。以前iBatis的级联查询，我用此类全实现了。

 

此类也存在一些不足：

比如，无法去封装预定义SQL，也许有办法，但绝对不是轻而易举就能实现的。

此类也无法对结果集自动封装为JavaBean或者List集合，这是比较麻烦的，实际上要实现自动封装，Apache的Commons DBUtils做的比较好。