为什么要做这个封装类:

以前经常使用Hibernate来操作数据库,但是时间长了以后发现,Hibernate的大多数功能其实我根本就用不上,而且,Hibernate的查询执行效率的确很让人纠结
所以,我又回到了JDBC的怀抱,而我又是个懒人,喜欢一个函数就能直接调用的那种,JDBC本身方法对我来说,要打的字太多了...@_@

 

入正题:

首先,画一个结构的草图

 

包结构:

先贴代码:

1.IConnectionProvider 接口

package org.sol.util.db;    import java.sql.Connection;  import java.sql.SQLException;    /**   * 用于获取连接的接口   * @author SOL   *   */  public interface IConnectionProvider {   public Connection getConnection(String sourceName) throws SQLException;  }

2.JDBCProvider JDBC数据提供源

package org.sol.util.db;    import java.sql.Connection;  import java.sql.DriverManager;  import java.sql.SQLException;    /**   * 标准JDBC连接获取代理   * @author HUYAO   *   */  public class JdbcProvider implements IConnectionProvider {   private String DBDriver;   private String DBUrl;   private String username;   private String password;      public JdbcProvider(String DBDriver,String DBUrl,String username,String password) throws ClassNotFoundException {    this.DBDriver = DBDriver;    this.DBUrl = DBUrl;    this.username = username;    this.password = password;        Class.forName(DBDriver);   }      @Override   public Connection getConnection(String sourceName) throws SQLException {    return DriverManager.getConnection(DBUrl + ";DatabaseName=" + sourceName,username,password);   }     public String getDBUrl() {    return DBUrl;   }     public void setDBUrl(String dBUrl) {    DBUrl = dBUrl;   }     public String getDBDriver() {    return DBDriver;   }     public String getUsername() {    return username;   }     public String getPassword() {    return password;   }     }

3.Tomcat数据提供源

package org.sol.util.db;    import java.sql.Connection;  import java.sql.SQLException;    import javax.naming.Context;  import javax.naming.InitialContext;  import javax.sql.DataSource;    /**   * TOMCAT JNDI连接池获取代理   * @author SOL   *   */  public class TomcatProvider implements IConnectionProvider {   @Override   public Connection getConnection(String sourceName) throws SQLException {    try {     Context ctx = new InitialContext();     return ((DataSource)ctx.lookup("java:comp/env/" + sourceName)).getConnection();    } catch (Exception e) {     throw new SQLException(e);    }   }  }

4.DataConsole 功能封装类

package org.sol.util.db;    import java.lang.reflect.Field;  import java.lang.reflect.InvocationTargetException;  import java.lang.reflect.Method;  import java.sql.CallableStatement;  import java.sql.Connection;  import java.sql.PreparedStatement;  import java.sql.ResultSet;  import java.sql.SQLException;  import java.sql.Statement;  import java.sql.Types;  import java.util.ArrayList;  import java.util.Arrays;  import java.util.HashMap;  import java.util.List;  import java.util.Map;  import java.util.Map.Entry;    import org.apache.commons.logging.Log;  import org.apache.commons.logging.LogFactory;    public class DataConsole {   /**    * 连接    */   private Connection connection;   /**    * 预处理对象    */   private PreparedStatement ps;   /**    * 存储过程处理对象    */   private CallableStatement cs;     /**    * 结果集对象    */   private ResultSet rs;   /**    * 数据源    */   private String sourceName;      /**    * 连接获取代理    */   private IConnectionProvider connectionProvider;     /**    * 事务超时事件    */   private int queryTime;      private static final Log log = LogFactory.getLog(DataConsole.class);      /**    * 生成一个JDBC封装对象    * @param connectionProvider 连接提供代理    * @param sourceName 数据源名称,connectionProvider根据此名称切换数据源    * @param queryTime 事务处理超时时间 0:无超时    */   public DataConsole(IConnectionProvider connectionProvider,String sourceName,int queryTime) {    this.connectionProvider = connectionProvider;    this.sourceName = sourceName;    this.queryTime = queryTime;   }      /**    * 统计语句查询 直接返回唯一值    * @param sql    * @param objs    * @return    * @throws SQLException    */   public Object findReturn(String sql,Object... objs) throws SQLException {    log.debug("Query return value:[" + sql + "] " + (objs != null ? Arrays.deepToString(objs) : ""));      try {     getConnection();          ps = connection.prepareStatement(sql);     ps.setQueryTimeout(queryTime);          if(objs != null) {      for(int i = 0 ; i < objs.length; i ++)       ps.setObject(i + 1, objs[i]);     }     rs = ps.executeQuery();     if(rs.next())      return rs.getObject(1);     else      return null;    } finally {     close();    }   }      /**    * 执行存储过程 首字段用于处理返回值 所以存储过程写法必须是 {?=call PRODUCENAME(?,?...,?)}    * @param call 存储过程    * @param returnType 返回参数类型 [Types.XXXX]    * @param objs 参数列表    * @return    * @throws SQLException    */   public Object callWithReturn(String call,int returnType,Object... objs) throws SQLException {    log.debug("Call return value:[" + call + "] " + (objs != null ? Arrays.deepToString(objs) : ""));    try {     getConnection();       cs = connection.prepareCall(call);     cs.setQueryTimeout(queryTime);          cs.registerOutParameter(1, returnType);     for(int i = 0; i < objs.length; i ++)      cs.setObject(i+2,objs[i]);          cs.execute();     return cs.getObject(1);    } finally {     close();    }   }      /**    * 用于执行返回列表的存储过程  并映射到对象列表上    * @param <X>     * @param clazz 映射对象    * @param sql 查询语句    * @param smap 映射配置表<字段名,类型>    * @param objs 参数列表    * @return    * @throws Exception    */   public <X> List<X> call(Class<X> clazz,String sql,Map<String,Class<?>> smap,Object... objs) throws Exception {    log.debug("Call Query produce:[" + sql + "] " + (objs != null ? Arrays.deepToString(objs) : ""));    try {     rs = call(sql, objs);          List<X> list = new ArrayList<X>();          while(rs != null && rs.next()) {      X obj = returnObject(clazz,smap);            list.add(obj);     }          return list;    } catch (Exception e) {     close();     throw e;    } finally {     close();    }   }      private ResultSet call(String sql,Object... params) throws SQLException {    getConnection();        cs = connection.prepareCall(sql,ResultSet.TYPE_SCROLL_INSENSITIVE,      ResultSet.CONCUR_READ_ONLY);    cs.setQueryTimeout(queryTime);        cs.registerOutParameter(1, Types.REAL);    for(int i = 0; i < params.length; i ++)     cs.setObject(i + 2, params[i]);        return cs.executeQuery();   }      /**    * 查询单个对象 并映射到对象上    * @param <X>     * @param clazz 映射对象    * @param sql 查询语句    * @param smap 映射配置表<字段名,类型>    * @param objs 参数列表    * @return    * @throws Exception    */   public <X> X get(Class<X> clazz,String sql,Map<String,Class<?>> smap,Object... objs) throws SQLException {    log.debug("Get Entity:[" + sql + "] " + (objs != null ? Arrays.deepToString(objs) : ""));    try {     rs = query(sql, objs);          if(rs != null && rs.next()) {      X obj = returnObject(clazz,smap);            return obj;     } else {      return null;     }         } catch (Exception e) {     throw new SQLException(e);    } finally {     close();    }   }      private ResultSet query(String sql,Object... objs) throws Exception {    getConnection();      ps = connection.prepareStatement(sql,ResultSet.TYPE_SCROLL_INSENSITIVE,      ResultSet.CONCUR_READ_ONLY);    ps.setQueryTimeout(queryTime);        if(objs != null) {     for(int i = 0; i < objs.length; i ++)      ps.setObject(i + 1, objs[i]);    }    return ps.executeQuery();   }   /**    * 用于解析查询结果 并映射到对象    * @param <X>    * @param clazz 映射对象    * @param smap 映射表    * @return    * @throws InstantiationException    * @throws SecurityException    * @throws NoSuchMethodException    * @throws SQLException    * @throws IllegalAccessException    */   private <X> X returnObject(Class<X> clazz,Map<String,Class<?>> smap) throws InstantiationException,  SecurityException, NoSuchMethodException, SQLException, IllegalAccessException {    X obj = clazz.newInstance();        for(Entry<String,Class<?>> en : smap.entrySet()) {     try {      Object value = rs.getObject(en.getKey());            setField(obj,en.getKey(),en.getValue(),(en.getValue().equals(String.class) ? (value != null ? value : null) : value));     } catch (IllegalArgumentException e1) {      log.error("不正确的对象映射. 映射类:" + clazz.getName() +         " 配置字段名:" + en.getKey() +         " 类型:" + en.getValue().getName() +         " 数据库字段类型:" + rs.getObject(en.getKey()).getClass().getName());     } catch (InvocationTargetException e1) {      e1.printStackTrace();     }    }        return obj;   }      /**    * 设置对象上字段的值    * 现在只支持简单的对象类型 String Integer Short Double 等标准对象    * 可以扩展这个方法用来支持一些比较复杂的对象格式    * @param obj 映射的对象    * @param fieldname 字段名称 将调用它的set方法进行设置    * @param type 字段类型    * @param value 字段值    * @throws SecurityException    * @throws NoSuchMethodException    * @throws IllegalArgumentException    * @throws IllegalAccessException    * @throws InvocationTargetException    */   protected void setField(Object obj,String fieldname,Class<?> type,Object value) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException  {    Method method = obj.getClass().getMethod(setMethod(fieldname),type);    method.invoke(obj, value);   }     /**    * 执行插入语句,并返回生成的主键    * @param sql 插入语句    * @param objs 参数列表    * @return 插入语句返回的主键值    * @throws SQLException    */   public int insertAndReturnKey(String sql,Object... objs) throws SQLException {    int countRow = 0;    int key = 0;        log.debug("Insert and return Id:[" + sql + "] " + (objs != null ? Arrays.deepToString(objs) : ""));    try {     getConnection();          connection.setAutoCommit(false);       ps = connection.prepareStatement(sql,Statement.RETURN_GENERATED_KEYS);     ps.setQueryTimeout(queryTime);          if(objs != null) {      for(int i = 0; i < objs.length; i ++)       ps.setObject(i+1,objs[i]);     }          countRow = ps.executeUpdate();     if(countRow > 0) {      ResultSet rs = ps.getGeneratedKeys();      if(rs.next())       key = rs.getInt(1);     }     connection.commit();    } catch (SQLException e) {     countRow = 0;     connection.rollback();     closeConnection();     throw e;    } finally {     if (connection != null) {      connection.setAutoCommit(true);     }     close();    }    return key;   }      /**    * 执行预编译SQL     * @param sql SQL语句    * @param objs 参数列表    * @return 执行影响条数    * @throws SQLException    */   public int updatePrepareSQL(String sql,Object... objs) throws SQLException {    log.debug("Update:[" + sql + "]" + (objs != null ? objs.toString() : ""));        int countRow = 0;    try {     getConnection();       connection.setAutoCommit(false);       ps = connection.prepareStatement(sql);     ps.setQueryTimeout(queryTime);     if(objs != null) {      for(int i = 0; i < objs.length; i ++)       ps.setObject(i+1,objs[i]);     }     countRow = ps.executeUpdate();     connection.commit();    } catch (SQLException e) {     countRow = 0;     connection.rollback();     closeConnection();     throw e;    } finally {     if (connection != null) {      connection.setAutoCommit(true);     }     close();    }    return countRow;   }     public <X> List<X> find(String sql,Class<X> clazz,Map<String,Class<?>> smap,Object... objs) throws SQLException {    try {     log.debug("Query:" + sql + " Class:" + clazz.getName() + (objs != null ? Arrays.deepToString(objs) : ""));          rs = query(sql, objs);          List<X> list = new ArrayList<X>();          while(rs != null && rs.next()) {      X obj = returnObject(clazz,smap);            list.add(obj);     }          return list;    } catch (Exception e) {     throw new SQLException(e);    } finally {     close();    }   }     public void closeConnection() {    try {     if (connection != null) {      connection.close();     }     connection = null;    } catch (Exception e) {    }   }      public Connection getConnection() throws SQLException {    if(sourceName == null)     throw new SQLException("没有设置数据源");        int Times = 0;    while (connection == null || connection.isClosed()) {     try {      closeConnection();      connection = connectionProvider.getConnection(sourceName);      break;     } catch (Exception sqle) {      log.error("error getConnection():" + sqle.getMessage(),sqle);     }finally{      if(Times>5){       throw new SQLException("获取连接次数已经超过6次。不再尝试重新获取");      }      ++Times;     }    }    return connection;   }      public void close() {    try {     super.finalize();     if (rs != null) {      rs.close();      rs = null;     }     if (ps != null) {      ps.close();      ps = null;     }     if (cs != null) {      cs.close();      cs = null;     }     if (connection != null) {      connection.close();      connection = null;     }    } catch (Throwable te) {    }   }     public static Map<String,Class<?>> parseSmap(Class<?> clazz,String... paramNames) {    Map<String,Class<?>> smap = new HashMap<String, Class<?>>(paramNames.length);        for(String name : paramNames) {     try {      Field field = clazz.getDeclaredField(name);      smap.put(name, field.getType());     } catch (Exception e) {      throw new RuntimeException(e);     }     }        return smap;   }      public static String getMethod(String name) {    return "get" + name.replaceFirst(name.substring(0,1), name.substring(0,1).toUpperCase());   }      public static String setMethod(String name) {    return "set" + name.replaceFirst(name.substring(0,1), name.substring(0,1).toUpperCase());   }  }

简单介绍一下这个封装类

封装类通过ConnectionProvider获取相应的数据源类型,提供几个快速使用的JDBC方法,包括查询,更新语句,插入并返回主键,调用存储过程等几个常用方法,可以看源文件里的说明

用一个测试类来说明吧

package org.sol.util.db;    import java.sql.SQLException;  import java.sql.Types;    public class test {   private IConnectionProvider connectionProvider = null;   private String sourceName = "megajoysms";   private int queryTime = 5;      private DataConsole dc;      public test() {    /*     * 首先建立数据源对象,现在演示的使用的是JDBC提供源     * 三个参数 1.驱动名称 2.url(数据库名不需要填写,由sourceName参数执行) 3.登录用户名 4.密码     * 代码中还提供了一个tomcat的jndi数据提供源,其他类似的源可以直接继承IConnectionProvider接口实现     */    try {     connectionProvider = new JdbcProvider(       "com.microsoft.sqlserver.jdbc.SQLServerDriver",        "jdbc:sqlserver://127.0.0.1:1433",       "sa","123456");    } catch (ClassNotFoundException e) {     e.printStackTrace();    }        dc = new DataConsole(connectionProvider, sourceName, queryTime);   }      /**    * Find 方法用来查询对象    * 接收3+ 个参数    * 第一个参数表示执行的Select语句    * 第二个参数表示查询结果映射到一个对象类型上    * 第三个参数表示对查询结果字段的映射关系    * 第四个字段用于如果SQL语句是带参数的,从这里开始填入变量列表    *     * 数据表test结构    * int id,    * varchar text,    * varchar value    * 映射对象结构    * class pojo {    private Integer id;    private String text;    get/set 方法...    }    * 第三个参数的类型是Map<String,Class<?>>表示 字段名-字段类型的映射关系    * 可以自己建立这个map,map的键用来匹配查询结果集的字段及映射类的字段    * 也可以用DataConsole.parseSmap(Class,String...)方法获取map    * 这个函数接收两个参数,第一个参数表示映射的类型,第二个开始的参数表示字段名称,函数会在映射类中匹配相应的字段类型    * PS:映射类内部的字段类型不能是基础类型比如int,short,要写成Integer,Short    */   public void find() {    try {     System.out.println(dc.find(       "select top 10 * from test where id>?",       pojo.class,       DataConsole.parseSmap(pojo.class, "id","whichservice"),        10));    } catch (SQLException e) {     e.printStackTrace();    }   }      /**    * 执行更新语句的方法    * 接收1+个参数    * 第一个参数表示SQL更新语句    * 第二个以后的参数表示传入的变量列表,无参数语句不填这些参数    * 返回结果是查询影响的记录条数    */   public void update() {    try {     System.out.println(dc.updatePrepareSQL(       "insert into test(id,text,value) values(?,?,?)",        1,"text","value"));    } catch (SQLException e) {     e.printStackTrace();    }   }      /**    * 执行插入动作,并返回这个操作记录的主键,如果操作无主键或主键不是自增型,返回0    * 参数类似于更新动作,这里演示了没有sql变量的情况    */   public void insertAndReturnKey() {    try {     System.out.println(dc.insertAndReturnKey("insert into test(text,value) values('text','value')"));    } catch (SQLException e) {     e.printStackTrace();    }   }      /**    * 类似于执行select语句,此方法用于执行带有返回结果集的存储过程    */   public void callAndReturnResultSet() {    try {     System.out.println(dc.call(pojo.class,        "{call proc_returnpojo(?)}",        DataConsole.parseSmap(pojo.class, "id","whichservice"),        1));    } catch (Exception e) {     e.printStackTrace();    }   }      /**    * 用于执行存储过程,如果存储过程带有返回值(非output参数),返回接受到的返回值    *  首字段用于处理返回值 所以存储过程写法必须是 {?=call PRODUCENAME(?,?...,?)}    * 比如:    * create proc_testreturn    * begin    * return 1    * end    */   public void callAndReturn() {    try {     System.out.println(dc.callWithReturn("{?=call proc_testreturn}", Types.INTEGER));    } catch (SQLException e) {     e.printStackTrace();    }   }  }

其中用到的pojo类的定义:

package org.sol.util.db;    public class pojo {   private Integer id;   private String text;      public Integer getId() {    return id;   }   public void setId(Integer id) {    this.id = id;   }   public String getText() {    return text;   }   public void setText(String text) {    this.text = text;   }      @Override   public String toString() {    return "pojo [" + (id != null ? "id=" + id + ", " : "")      + (text != null ? "text=" + text : "") + "]";   }     }