我的db类库新版

package bean;

public class z_usertest {

private String name;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}
}

package defaultDBHelper;

import java.sql.DriverManager;
import java.text.DateFormat;
import java.util.Date;
import zhongheling.java.sql.face.IDBHelper;

public class DBManage extends zhongheling.java.sql.manage.DBManage {

/**** 全局得到连接的必经方法在这里定义
* 你可以在这里使用连接池也可以为每个请求创建一个连接，DBHellper用完之后会自动关闭连接资源。
* **/
public java.sql.Connection getConnection() throws Exception {
return getConnection_static();
}
/****
* 连接方法的实现
* **/
private static java.sql.Connection getConnection_static() throws Exception {
// 数据库驱动
//private final String driver = "net.sourceforge.jtds.jdbc.Driver";
//String driver = "net.sourceforge.jtds.jdbc.Driver";
String driver = "oracle.jdbc.driver.OracleDriver";

// 数据库地址以及数据源名称
//private final String url = "jdbc:jtds:sqlserver://localhost:1433/newBBS";
String url = "jdbc:oracle:thin:@10.38.202.37:1522:telf106";

// 用户名
String name = "yy0a";

// 密码
String password = "yy0a";

/****
* 设置自动增长列字段,这个般不要需要
* 父类默认己提供以下实现，自定义的话重写一下即可
* **/
/*
public void getIdentity(Class bealClass,IDBHelper s)throws Exception
{
adpater.getIdentityName(bealClass);
}*/

/****
* 设置入库时时间格式
* 父类默认己提供以下实现，自定义的话重写一下即可
* **/
/*
public String formatTime(Date date) throws Exception {
return dateFormat.format(date);
}*/

/****
* IExceptionNoEx接口异常处理
* 你可以在这里打印或记录日志
* 父类默认己提供以下实现，自定义的话重写一下即可
* **/

/*
public void printException(String sql, String message, Exception e)throws Exception {
printException_Static(sql,message,e);
}*/

/****
* IExceptionNoEx接口异常处理
* 你可以在这里打印或记录日志
* 父类默认己提供以下实现，自定义的话重写一下即可
* *******/

/*
public void printExceptionNoEx(String sql, String message, Exception e) {
printExceptionNoEx_Static(sql,message,e);
}*/

/****
* 父类静态私有类供参考
* *******/
/*
private static String formatTime_Static(Date date) throws Exception {
return dateFormat.format(date);
}
*/

/****
* 父类静态私有类供参考
* *******/
/*
private static void printException_Static(String sql, String message, Exception e)throws Exception {
System.out.println("SQL:"+sql);
System.out.println("MESSAGE:"+message);
System.out.println(e.toString());
e.printStackTrace();
throw e;
}
*/

/****
* 父类静态私有类供参考
* *******/
/*
private static void printExceptionNoEx_Static(String sql, String message, Exception e){
System.out.println("SQL:"+sql);
System.out.println("MESSAGE:"+message);
System.out.println(e.toString());
e.printStackTrace();
}
*/
}

package defaultDBHelper;

public class OreacleDBHelper<E> extends zhongheling.java.sql.dbhelper.DHHelperNoEx<E> implements zhongheling.java.sql.face.IDBHelperNoEx<E>{

public OreacleDBHelper()
{
//指定DB共公方法管类(相关参数在DBManage类代码里设置)
super(new defaultDBHelper.DBManage());
//给DB分配Oracle适配器
this.getDBManage().adpater=new zhongheling.java.sql.adapter.OracleAdapter<E>();
//给DB分配sqlserver适配器
//this.getDBManage().adpater=new zhongheling.java.sql.adapter.SqlServerAdapter<E>());

}
}

package main;

import java.util.List;

import defaultDBHelper.OreacleDBHelper;

import bean.z_usertest;

public class main {

public static void main(String[] args) {
OreacleDBHelper<z_usertest> db = new OreacleDBHelper<z_usertest>();
List<z_usertest> list = null;
list = db.getBeanList("select * from z_usertest ", z_usertest.class);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i).getName());
}
z_usertest user;
Object[] objs=new Object[1];
objs[0]="梅西";
String sql=" select * from z_usertest where name =? ";
user=db.getBean(sql,z_usertest.class,objs);
System.out.println(user.getName()+"@@");
}

}

package zhongheling.java.sql.adapter;

public interface DBAdapter<E> {

public abstract String getIdentityName(Class beanClass) throws Exception ;

public abstract String getInsertSQL(Object bean) throws Exception ;

public abstract String getUpdateSQL(Object bean, String where) throws Exception;

}

package zhongheling.java.sql.adapter;

import java.util.Date;

import zhongheling.java.sql.basic.DBBasic;

public class OracleAdapter<E> extends DBBasic<E> implements DBAdapter {

// 根据表名得到自动增长列
public    String getIdentityName(Class beanClass) throws Exception
{
return getIdentityName_static(beanClass.getCanonicalName());
}

/*
*
* Object obj 实体类斌好值的的实例
*
* 根据实体类 get方法（识别方式是get开头的方法）来生成 insert SQL字符串
*
* 此方法自动避开自动增长列
*
*/
public    String getInsertSQL(Object bean) throws Exception
{
    return getInsertSQL_static(bean);
}

/*
*
* Object obj 实体类斌好值的的实例
*
* 根据实体类 get方法（识别方式是get开头的方法）来生成 Uqdate SQL字符串
*
* where条件自己指定包括Where关键字也要自己补充
*
* 此方法自动避开自动增长列
*
*/
public   String getUpdateSQL(Object bean, String where) throws Exception
{
return   getUpdateSQL_static( bean,   where);
}

private static String getInsertSQL_static(Object bean) throws Exception {
Class cla = bean.getClass();
// 定义一个新实体指针
StringBuffer str = new StringBuffer();
try {
   str.append("insert into " + cla.getSimpleName() + "");
   str.append(" ( ");

   // 得到传进来的实体的所有属性信息列表
   java.lang.reflect.Method[] methods = cla.getDeclaredMethods();
   boolean isFist = true;
   // 遍历所有方法
   for (java.lang.reflect.Method method : methods) {
    String GetMethodParameterTypes = "";
    GetMethodParameterTypes = method.getReturnType().toString();
    // 如果方法存在返回值

    if (!GetMethodParameterTypes.equals("void"))
     ;
    {
     String methodName = method.getName().toString();

String fieldName = methodName.substring(3);

if (GetMethodParameterTypes != null
&& methodName.substring(0, 3).equals("get")) {

      if (!fieldName.equalsIgnoreCase(getIdentityName_static(cla
        .getSimpleName()))) {
       if (!isFist) {
        str.append("," + fieldName);
       } else {
        str.append(fieldName);
        isFist = false;
       }
      }
     }
    }
   }
   str.append(") values (");
   isFist = true;
   // 遍历所有方法
   for (java.lang.reflect.Method method : methods) {
    String GetMethodParameterTypes = "";
    GetMethodParameterTypes = method.getReturnType().getCanonicalName();
    // 如果方法存在返回值
    if (!GetMethodParameterTypes.equals("void"))
     ;
    {
     String methodName = method.getName().toString();
     String fieldName = methodName.substring(3);
     if (!fieldName.equalsIgnoreCase(getIdentityName_static(cla
       .getSimpleName()))) {
      Object[] nullParameter = {};
      Object object = null;
      if (GetMethodParameterTypes != null
        && methodName.substring(0, 3).equals("get")) {
       if (GetMethodParameterTypes.equalsIgnoreCase("")) {
        object = DBBasic.getDBManage().formatTime((Date) object);
       }
       if (IsString(GetMethodParameterTypes)) {
        if (!isFist) {
         object = method.invoke(bean, nullParameter);
         str.append("," + "'" + object + "'");
        } else {
         object = method.invoke(bean, nullParameter);
         str.append("'" + object + "'");
         isFist = false;
        }
       } else {
        if (!isFist) {
         str
           .append(","
             + method.invoke(bean,
               nullParameter));
        } else {
         str.append(method
           .invoke(bean, nullParameter));
         isFist = false;
        }
       }
      }
     }
    }
   }
   str.append(")");
} catch (Exception e) {
   DBBasic.getDBManage().printException(null,"根据" + bean.getClass().getCanonicalName()
     + "对象生成Insert SQL字符串时异常:" + e.getMessage(), e);
}
return str.toString();
}

private static String getIdentityName_static(String TableName) throws Exception {
return "rowid";
}

private static String getUpdateSQL_static(Object obj, String where)
   throws Exception {
Class cla = obj.getClass();
// 定义一个新实体指针
StringBuffer str = new StringBuffer();
try {
   str.append("update " + cla.getSimpleName() + " ");
   str.append(" set ");

   // 得到传进来的实体的所有属性信息列表
   java.lang.reflect.Method[] methods = cla.getDeclaredMethods();
   boolean isFist = true;

   // 遍历所有方法
   for (java.lang.reflect.Method method : methods) {
    String GetMethodParameterTypes = "";
    GetMethodParameterTypes = method.getReturnType().getCanonicalName();
    // 如果方法存在返回值
    if (!GetMethodParameterTypes.equals("void"))
     ;
    {
     String methodName = method.getName().toString();
     String fieldName = methodName.substring(3);
     if (!fieldName.equalsIgnoreCase(getIdentityName_static(cla
       .getSimpleName()))) {
      Object[] nullParameter = {};
      Object object = null;
      if (GetMethodParameterTypes != null
        && methodName.substring(0, 3).equals("get")) {
       if (GetMethodParameterTypes.equalsIgnoreCase("")) {
        object = DBBasic.getDBManage().formatTime((Date) object);
       }
       if (IsString(GetMethodParameterTypes)) {
        if (!isFist) {
         object = method.invoke(obj, nullParameter);
         str.append("," + " " + fieldName + " = ");
         str.append("'" + object + "'");
        } else {
         object = method.invoke(obj, nullParameter);
         str.append(" " + fieldName + " = ");
         str.append("'" + object + "'");
         isFist = false;
        }
       } else {
        if (!isFist) {
         str
           .append(", "
             + fieldName
             + " = "
             + method.invoke(obj,
               nullParameter));
        } else {
         str.append(method
           .invoke(obj, nullParameter));
         isFist = false;
        }
       }
      }
     }
    }
   }
   str.append(" where 1=1 " + where + " ");
} catch (RuntimeException e) {
   DBBasic.getDBManage().printException(null,"根据" + obj.getClass().getCanonicalName()
     + "对象生成upldate SQL字符串时异常:" + e.getMessage(), e);
}
return str.toString();
}
}

package zhongheling.java.sql.adapter;

import java.util.Date;
import zhongheling.java.sql.basic.DBBasic;

public class SqlServerAdapter<E>extends DBBasic<E> implements DBAdapter{

// 根据表名得到自动增长列
public    String getIdentityName(Class beanClass ) throws Exception
{
return getIdentityName_static(beanClass);
}

/*
*
* Object obj 实体类斌好值的的实例
*
* 根据实体类 get方法（识别方式是get开头的方法）来生成 insert SQL字符串
*
* 此方法自动避开自动增长列
*
*/
public    String getInsertSQL(Object bean) throws Exception
{
    return getInsertSQL_static(bean);
}

/*
*
* Object obj 实体类斌好值的的实例
*
* 根据实体类 get方法（识别方式是get开头的方法）来生成 Uqdate SQL字符串
*
* where条件自己指定包括Where关键字也要自己补充
*
* 此方法自动避开自动增长列
*
*/
public   String getUpdateSQL(Object bean, String where) throws Exception
{
return   getUpdateSQL_static( bean,   where);
}

private static String getInsertSQL_static(Object bean) throws Exception {
Class cla = bean.getClass();
// 定义一个新实体指针
StringBuffer str = new StringBuffer();
try {
   str.append("insert into [" + cla.getSimpleName() + "]");
   str.append(" ( ");

    if (!GetMethodParameterTypes.equals("void"))
     ;
    {
     String methodName = method.getName().toString();

String fieldName = methodName.substring(3);

if (GetMethodParameterTypes != null
&& methodName.substring(0, 3).equals("get")) {

      if (!fieldName.equalsIgnoreCase(getIdentityName_static(cla))) {
       if (!isFist) {
        str.append("," + fieldName);
       } else {
        str.append(fieldName);
        isFist = false;
       }
      }

}

    }
   }
   str.append(") values (");
   isFist = true;
   // 遍历所有方法
   for (java.lang.reflect.Method method : methods) {
    String GetMethodParameterTypes = "";
    GetMethodParameterTypes = method.getReturnType().toString();
    // 如果方法存在返回值
    if (!GetMethodParameterTypes.equals("void"))
     ;
    {
     String methodName = method.getName().toString();
     String fieldName = methodName.substring(3);
     if (!fieldName.equalsIgnoreCase(getIdentityName_static(cla))) {
      Object[] nullParameter = {};
      Object object = null;
      if (GetMethodParameterTypes != null
        && methodName.substring(0, 3).equals("get")) {
       if (GetMethodParameterTypes.equalsIgnoreCase("")) {
        object = DBBasic.getDBManage().formatTime((Date) object);
       }
       if (IsString(GetMethodParameterTypes)) {
        if (!isFist) {
         object = method.invoke(bean, nullParameter);
         str.append("," + "'" + object + "'");
        } else {
         object = method.invoke(bean, nullParameter);
         str.append("'" + object + "'");
         isFist = false;
        }
       } else {
        if (!isFist) {
         str
           .append(","
             + method.invoke(bean,
               nullParameter));
        } else {
         str.append(method
           .invoke(bean, nullParameter));
         isFist = false;
        }
       }
      }
     }
    }
   }
   str.append(")");
} catch (Exception e) {
   DBBasic.getDBManage().printException(null,"根据" + bean.getClass().getCanonicalName()
     + "对象生成Insert SQL字符串时异常:" + e.getMessage(), e);
}
return str.toString();
}

private static String getIdentityName_static(Class cla) throws Exception {
String sql = "select name from syscolumns   where id=object_id('["
    + cla.getCanonicalName()
    + "]') and COLUMNPROPERTY( syscolumns.id,syscolumns.name,'IsIdentity') =1";
return (String)DBBasic.getObj(cla, sql,null);
}
private static String getUpdateSQL_static(Object obj, String where)
   throws Exception {
Class cla = obj.getClass();
// 定义一个新实体指针
StringBuffer str = new StringBuffer();
try {
   str.append("update [" + cla.getSimpleName() + "]");
   str.append(" set ");

   // 得到传进来的实体的所有属性信息列表
   java.lang.reflect.Method[] methods = cla.getDeclaredMethods();
   boolean isFist = true;

   // 遍历所有方法
   for (java.lang.reflect.Method method : methods) {
    String GetMethodParameterTypes = "";
    GetMethodParameterTypes = method.getReturnType().toString();
    // 如果方法存在返回值
    if (!GetMethodParameterTypes.equals("void"))
     ;
    {
     String methodName = method.getName().toString();
     String fieldName = methodName.substring(3);
     if (!fieldName.equalsIgnoreCase(getIdentityName_static(cla))) {
      Object[] nullParameter = {};
      Object object = null;
      if (GetMethodParameterTypes != null
        && methodName.substring(0, 3).equals("get")) {
       if (GetMethodParameterTypes.equalsIgnoreCase("")) {
        object = DBBasic.getDBManage().formatTime((Date) object);
       }
       if (IsString(GetMethodParameterTypes)) {
        if (!isFist) {
         object = method.invoke(obj, nullParameter);
         str.append("," + " " + fieldName + " = ");
         str.append("'" + object + "'");
        } else {
         object = method.invoke(obj, nullParameter);
         str.append(" " + fieldName + " = ");
         str.append("'" + object + "'");
         isFist = false;
        }
       } else {
        if (!isFist) {
         str
           .append(", "
             + fieldName
             + " = "
             + method.invoke(obj,
               nullParameter));
        } else {
         str.append(method
           .invoke(obj, nullParameter));
         isFist = false;
        }
       }
      }
     }
    }
   }
   str.append(" where 1=1 " + where + " ");
} catch (RuntimeException e) {
   DBBasic.getDBManage().printException(null,"根据" + obj.getClass().getCanonicalName()
     + "对象生成upldate SQL字符串时异常:" + e.getMessage(), e);
}
return str.toString();
}
}

package zhongheling.java.sql.basic;

import java.lang.reflect.Method;
import java.sql.Date;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.PreparedStatement;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Types;
import java.sql.CallableStatement;
import java.util.ArrayList;
import java.util.List;

import zhongheling.java.sql.pack.PreparedStatementPack;
import zhongheling.java.sql.pack.ResultSetPack;

public abstract class DBBasic<E> {

private static zhongheling.java.sql.manage.DBManageSuper DBManage;

protected static java.sql.Connection getConnection(Connection conn)
throws Exception {
return DBManage.getConnection();
}

protected static boolean execute(Connection conn, Statement stat, String sql)
   throws Exception {
boolean bl = false;
try {
   conn = getConnection(conn);
   stat = conn.createStatement();
   bl = stat.execute(sql);
} catch (Exception e) {
   DBManage.printException(sql, "execute", e);
} finally {
   close(conn, stat);
}
return bl;
}

protected static ResultSet executeQuery(Connection conn, Statement stat,
   String sql) throws Exception {
ResultSet rs = null;
try {
   conn = getConnection(conn);
   stat = conn.createStatement();
   rs = stat.executeQuery(sql);
} catch (Exception e) {
   DBManage.printException(sql, "executeQuery", e);
} finally {
   close(null, stat);
}
return rs;
}

protected static int executeUpdate(Connection conn, Statement stat,
   String sql) throws Exception {
int num = 0;
try {
   conn = getConnection(conn);
   stat = conn.createStatement();
   num = stat.executeUpdate(sql);
} catch (Exception e) {
   DBManage.printException(sql, "executeUpdate", e);
} finally {
   close(null, stat);
}
return num;
}

protected static boolean prem_execute(PreparedStatement prem,
Connection conn, String sql, Object[] parameters) throws Exception {

boolean bl = false;
try {
   conn = getConnection(conn);
   if (conn != null) {
    prem = conn.prepareStatement(sql);
   }
   bl = prem.execute(sql);
} catch (Exception e) {
   DBManage.printException(sql, "prem_execute", e);
} finally {
   close(conn, prem);
}
return bl;
}

protected static java.sql.ResultSet prem_executeQuery(
   PreparedStatement prem, Connection conn, String sql, Object[] parameters)
   throws Exception {
java.sql.ResultSet rs = null;
try {
   conn = getConnection(conn);
   if (conn != null) {
    prem = conn.prepareStatement(sql);
   }
   if (parameters != null) {
    SetPrepareStatement(prem, parameters);
   }
   rs = prem.executeQuery();
} catch (Exception e) {
   DBManage.printException(sql, "prem_executeQuery", e);
}
return rs;
}

protected static int prem_executeUpdate(PreparedStatement prem,
   Connection conn, String sql, Object[] parameters) throws Exception {
int i = 0;
try {
   conn = getConnection(conn);
   if (conn != null) {
    prem = conn.prepareStatement(sql);
   }
   i = prem.executeUpdate();
} catch (Exception e) {
   DBManage.printException(sql, "prem_executeUpdate", e);
} finally {
   close(conn, prem);
}
return i;
}

protected static void Process(Connection conn, CallableStatement cst,
   String sql) throws Exception {
try {
   cst = conn.prepareCall(sql);
   cst.setInt(1, 100);// 设置输入参数值
   cst.registerOutParameter(2, Types.VARCHAR);// 将第2个参数设为输出
   cst.execute();
   String res = cst.getString(2);// 获得执行后的输出值
   System.out.println(res);// 打印输出值
} catch (SQLException e) {
   DBManage.printException(sql, "Process", e);
} finally {
   close(conn, cst);
}
}

/*
*
* Object obj 实体类斌好值的的实例
*
* 根据实体类 get方法（识别方式是get开头的方法）来保存实体
*
* 此方法自动避开自动增长列
*
*/

protected static int addBean_static(Object bean) throws Exception {
int i = 0;
try {
   PreparedStatement prem = null;
   Connection conn = null;
   i = prem_executeUpdate(prem, conn, DBManage.adpater.getInsertSQL(bean),null);
} catch (Exception e) {
   DBManage.printException(null, "add "
     + bean.getClass().getCanonicalName() + "对象时异常:", e);
}
return i;
}

protected static Object getObj(Class beanClass, String sql, Object[] parameters)
   throws Exception {
Object obj = null;
ResultSet rs = null;
PreparedStatement prem = null;
Connection conn = null;
try {
   rs = prem_executeQuery(prem, conn, sql,parameters);
   if (rs.next()) {
    Method packMethod = null;
    Class[] classes = { Integer.class };
    Object[] p = { new Integer(0) };
    packMethod = getPackMethod(beanClass.getCanonicalName(), classes,
      packMethod, rs.getClass());
    obj = packMethod.invoke(rs, p);
   }
} catch (Exception e) {
   DBManage.printException(null, "调用StaticDBHelper的getObj方法执行" + sql
     + "时异常:", e);
} finally {
   close(conn, prem, rs);
}
return obj;
}

protected static List<String> getStringList_static(String sql, Object[] parameters)
throws Exception {
List<String> i = null;

ResultSet rs = null;
PreparedStatement prem = null;
Connection conn = null;
try {
   rs = prem_executeQuery(prem, conn, sql,parameters);
   while (rs.next()) {
    i.add(rs.getString(1));
   }
} catch (Exception e) {
   DBManage.printException(sql, "getStringList", e);
} finally {
   close(conn, prem, rs);
}
return i;
}

protected static List<Object> getBeanList(String sql, Class beanClass,
    Statement stat,PreparedStatement prem, Connection conn, boolean IsPack, Object[] parameters)
   throws Exception {
List<Object> list = null;
ResultSet rs = null;
try {
   if(parameters==null)
   {
    rs = executeQuery(conn, stat, sql);
   }
   else
   {
    rs = prem_executeQuery(prem, conn, sql,parameters);
   }
   list = (List<Object>) RsToBeanList(rs, beanClass, false, IsPack);
} catch (Exception e) {
   DBManage.printException(sql, "getBeanList", e);
} finally {
   close(stat, prem, conn, null, rs);
}
return list;
}

/*
*
* Object obj 实体类斌好值的的实例
*
* 根据实体类 get方法（识别方式是get开头的方法）来更新
*
* where条件自己指定包括Where关键字也要自己补充
*
* 此方法自动避开自动增长列
*
*/

protected static int updateByWhere_static(Object obj, String where,Object[] parameters)
throws Exception

{
int i = 0;
try {
   PreparedStatement prem = null;
   Connection conn = null;
   i = prem_executeUpdate(prem, conn, DBManage.adpater.getUpdateSQL(obj,where),parameters);
} catch (Exception e) {
   DBManage.printException(null, "updateByWhere", e);
}
return i;
}

/*
* 参数 ResultSet rs 查询后的带连结的结果集对象参数 Class 需要设置到的实体的Class信息返回 List<E> 实体列表
*
* 根据实体类 set方法（识别方式是set开头并无返回值的方法）来读ResultSet对象
* 使用时需保证实体除了属性的set方法之外没有别的set方法，实体的set方法一般与查询后返回的结果集中的列名一一对应，
* 使用时如果实体的set方法与ResultSet对象中的列名不一一对应最少应保证实体的set方法在ResultSet对象中有列名与之对应。
*
*/
protected static List<Object> RsToBeanList(ResultSet rs, Class BeanClass,
boolean IsOneRow, boolean IsPack) throws Exception {

List<Object[]> rowInfoList = getRowInfoList(BeanClass, IsPack);
List<Object> beanList = null;
try {
   beanList = new ArrayList<Object>();
   Object pack = null;
   if (IsOneRow) {
    if (rs.next())// 读每行
    {
     setBean(rs, BeanClass, IsPack, rowInfoList, beanList, pack);
    }
   } else {
    while (rs.next())// 读每行
    {
     setBean(rs, BeanClass, IsPack, rowInfoList, beanList, pack);
    }
   }
} catch (Exception e) {
   DBManage.printException(null, "ResultSet对象信息封装到BeanList时异常:"
     + e.getMessage(), e);
}
return beanList;
}

/*
*
* 参数 Class 需要设置到的实体的Class信息返回 List<Object[]> list
* list中的每个元素Object[]按约定的位置放三个元素 Object[0]实际为Method对象是包装类的getXX（）方法
* （包装类是一个自定义的适配器用于包装ResultSet对象的getXX（）结果便于反射调用） Object[1]实际为Method对象
* 是实体类的set方法 Object[2]实际为String对象是实体类的属性（根据截取set方法名的后面字节得到）
*
*/
private static List<Object[]> getRowInfoList(Class cla, boolean IsPack)
throws Exception {
List<Object[]> RowInfoList = new ArrayList<Object[]>();

// 得到实体的所有方法列表
java.lang.reflect.Method[] methods = cla.getDeclaredMethods();
// 遍历所有方法
for (java.lang.reflect.Method method : methods) {
getRowInfo(IsPack, RowInfoList, method);
}
return RowInfoList;
}

private static void SetPrepareStatement(PreparedStatement prem,
Object[] parameters) throws Exception {
Class[] classes =null;
Object[] setMethodParameters=new Object[2];
Method method = null;
   for (int i = 0; i < parameters.length; i++) {
    if (parameters[i] != null) {
     classes=new Class[2];
     classes[0]=Integer.class;
     method =getPrepareStatementMethod(parameters[i].getClass().getCanonicalName(),classes,PreparedStatementPack.class);
     setMethodParameters[0]=new Integer(i+1);
     setMethodParameters[1]=parameters[i];
     DBManage.psPack.setPreparedStatement(prem);
     method.invoke(DBManage.psPack, setMethodParameters);
    }
   }
}

// 得到要读的字段的信息
private static void getRowInfo(boolean IsPack, List<Object[]> RowInfoList,
   java.lang.reflect.Method method) throws Exception {
// 得到形参数组（如果有）
Class[] typeClass = method.getParameterTypes();
// 如果方法存在一个以DBHelper形参
if (null != typeClass && typeClass.length > 0) {
   // 得到形参类型字符串
   String MethodParameterTypes = "";
   MethodParameterTypes = typeClass[0].getCanonicalName();
   // 得到当前方法名字
   String methodName = method.getName().toString();
   String fieldName = null;
   Class[] classes = { String.class };
   // 如果是set开头的方法
   if (MethodParameterTypes != null
     && methodName.substring(0, 3).equals("set")) {
    fieldName = methodName.substring(3);
    Object[] t = new Object[3];
    Method packMethod = null;
    Class packClass = null;
    packClass = setPackClass(IsPack);
    packMethod = getPackMethod(MethodParameterTypes, classes,
      packMethod, packClass);
    t[0] = packMethod;
    t[1] = method;
    t[2] = fieldName;
    RowInfoList.add(t);
   }
}
}

// getRowInfo方法的子方法，用于设置是得到哪个对像的getXX（）方法(rs对象或Pack对象)
private static Class setPackClass(boolean IsPack) throws Exception {
Class packClass;
if (IsPack) {
packClass = ResultSetPack.class;
} else {
packClass = ResultSet.class;
}
return packClass;
}

// getInfo方法里的功能方法，得到要包装器或RS对象要执行的getXX（）方法
@SuppressWarnings("unchecked")
private static Method getPackMethod(String MethodParameterTypes,
   Class[] classes, Method packMethod, Class packClass)
   throws Exception {
if (MethodParameterTypes.equals("java.lang.String")) {
   packMethod = packClass.getMethod("getString", classes);// 得到包装类的方法
} else if (MethodParameterTypes.equals("int")
    || MethodParameterTypes.equals("java.lang.Integer")) {
   packMethod = packClass.getMethod("getInt", classes);
} else if (MethodParameterTypes.equals("java.util.Date")) {
   packMethod = packClass.getMethod("getDate", classes);
} else if (MethodParameterTypes.equals("short")
    || MethodParameterTypes.equals("java.lang.Short")) {
   packMethod = packClass.getMethod("getShort", classes);
} else if (MethodParameterTypes.equals("float")
    || MethodParameterTypes.equals("java.lang.Float")) {
   packMethod = packClass.getMethod("getFloat", classes);
} else if (MethodParameterTypes.equals("double")
    || MethodParameterTypes.equals("java.lang.Double")) {
   packMethod = packClass.getMethod("getDouble", classes);
} else if (MethodParameterTypes.equals("byte")
    || MethodParameterTypes.equals("java.lang.Byte")) {
   packMethod = packClass.getMethod("getByte", classes);
} else if (MethodParameterTypes.equals("long")
    || MethodParameterTypes.equals("java.lang.Long")) {
   packMethod = packClass.getMethod("getLong", classes);
} else {
   packMethod = packClass.getMethod("getObject", classes);
}
return packMethod;
}

// getInfo方法里的功能方法，得到要包装器或RS对象要执行的getXX（）方法
@SuppressWarnings("unchecked")
private static Method getPrepareStatementMethod(
   String MethodParameterTypes, Class[] classes,
   Class Cla) throws Exception {
Method method=null;
if (MethodParameterTypes.equals("java.lang.String")) {
   classes[1]=String.class;
   method=Cla.getMethod("setString",classes);// 得到包装类的方法;
} else if (MethodParameterTypes.equals("int")
    || MethodParameterTypes.equals("java.lang.Integer")) {
   classes[1]=int.class;
   method=Cla.getMethod("setInt", classes);
} else if (MethodParameterTypes.equals("java.util.Date")) {
   classes[1]=Date.class;
   method=Cla.getMethod("setDate", classes);
} else if (MethodParameterTypes.equals("short")
    || MethodParameterTypes.equals("java.lang.Short")) {
   classes[1]=short.class;
   method=Cla.getMethod("setShort", classes);
} else if (MethodParameterTypes.equals("float")
    || MethodParameterTypes.equals("java.lang.Float")) {
   classes[1]=float.class;
   method=Cla.getMethod("setFloat", classes);
} else if (MethodParameterTypes.equals("double")
    || MethodParameterTypes.equals("java.lang.Double")) {
   classes[1]=double.class;
   method=Cla.getMethod("setDouble", classes);
} else if (MethodParameterTypes.equals("byte")
    || MethodParameterTypes.equals("java.lang.Byte")) {
   classes[1]=byte.class;
   method=Cla.getMethod("setByte", classes);
} else if (MethodParameterTypes.equals("long")
    || MethodParameterTypes.equals("java.lang.Long")) {
   classes[1]=long.class;
   method=Cla.getMethod("setLong", classes);
} else {
   classes[1]=Object.class;
   method=Cla.getMethod("setObject", classes);
}
return   method;// 得到包装类的方法;
}

// RsToBeanList的子方法，用于设置RS对象每行的信息到Bean对象中
private static void setBean(ResultSet rs, Class BeanClass, boolean IsPack,
   List<Object[]> rowInfoList, List<Object> beanList, Object pack)
   throws Exception {
Object newBean;
newBean = (Object) BeanClass.newInstance();// 新的bean实例
// 设置每字段i表示第几个字段
for (int i = 0; i < rowInfoList.size(); i++) {
   // 定义一个值对象指针
   Object value = null;

// 得到包装类的方法
Method packMethod = (Method) rowInfoList.get(i)[0];

   // 得到set方法
   Method setMethod = (Method) rowInfoList.get(i)[1];
   // 是否启用包装器
   if (IsPack) {
    // 设置ResultSet对象到包装器对象
    ((ResultSetPack) pack).setResultSet(rs);
   } else {
    // 直接使用ResultSet
    pack = rs;
   }
   // 得到数据库对应该set方法的列名
   String columnLabel = (String) rowInfoList.get(i)[2];

// 调用包装类的get方法得到字段值
value = packMethod.invoke(pack, columnLabel);

// 设置值到字段
setMethod.invoke(newBean, value);
}
beanList.add(newBean);
}

// 用于生成sql语句判断是否加双引号，返回真是加双引号，返回假时加单引号
protected static boolean IsString(String type) throws Exception {
if (type.equalsIgnoreCase("int") || type.equals("java.lang.Integer")
    || type.equalsIgnoreCase("Short")
    || type.equals("java.lang.Short")
    || type.equalsIgnoreCase("Float")
    || type.equals("java.lang.Float")
    || type.equalsIgnoreCase("Double")
    || type.equals("java.lang.Double")
    || type.equalsIgnoreCase("Byte")
    || type.equals("java.lang.Byte")
    || type.equalsIgnoreCase("short")
    || type.equals("java.lang.Short")
    || type.equalsIgnoreCase("long")
    || type.equals("java.lang.Long")) {
   return false;
} else {
   return true;
}
}

protected static void close(Connection conn, Statement stat)
throws Exception {
close(stat, null, conn, null, null);
}

protected static void close(Connection conn, PreparedStatement prem)
throws Exception {
close(null, prem, conn, null, null);
}

protected static void close(Connection conn, PreparedStatement prem,
ResultSet rs) throws Exception {
close(null, prem, conn, null, rs);
}

protected static void close(Statement stat, PreparedStatement prem,
   Connection conn, CallableStatement cst, ResultSet rs)
   throws Exception {
try {
   if (null != conn) {
    conn.close();
   }
   if (null != stat) {
    stat.close();
   }
   if (null != prem) {
    prem.close();
   }
   if (null != cst) {
    cst.close();
   }
   if (null != rs) {
    rs.close();
   }
} catch (SQLException e) {
   DBManage.printException(null, "数据库操作资源己关闭:" + e.getMessage(), e);
}
}

protected static void setDBManage(
zhongheling.java.sql.manage.DBManageSuper manage) {
DBManage = manage;
}

protected static zhongheling.java.sql.manage.DBManageSuper getDBManage() {
return DBManage;
}

}

package zhongheling.java.sql.dbhelper;

import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.PreparedStatement;
import java.sql.Connection;
import java.sql.CallableStatement;
import java.text.DateFormat;
import java.util.Date;
import java.util.List;

import zhongheling.java.sql.basic.DBBasic;
import zhongheling.java.sql.face.IDBHelper;
import zhongheling.java.sql.manage.DBManageSuper;
import zhongheling.java.sql.pack.ResultSetPack;

public class DBHelper<E> extends DBBasic<E> implements IDBHelper<E> {

private Statement stat = null;

private PreparedStatement prem = null;

private Connection conn = null;

private CallableStatement cst = null;

private DBBasic<E> StaticDB;

protected static DateFormat dateFormat = DateFormat.getDateInstance();

protected static ResultSetPack pack = null;//得到包装类对象

public DBHelper(DBManageSuper manage) {
StaticDB.setDBManage(manage);
}

public boolean execute(String sql) throws Exception {

return StaticDB.execute(conn, stat, sql);

}

public ResultSet executeQuery(String sql) throws Exception {

return StaticDB.executeQuery(conn, stat, sql);
}

public int executeUpdate(String sql) throws Exception {
return StaticDB.executeUpdate(conn, stat, sql);
}

public boolean prem_execute(String sql) throws Exception {

return StaticDB.prem_execute(prem, conn, sql, null);
}

public java.sql.ResultSet prem_executeQuery(String sql) throws Exception {

return StaticDB.prem_executeQuery(prem, conn, sql, null);
}

public int prem_executeUpdate(String sql) throws Exception {

return StaticDB.prem_executeUpdate(prem, conn, sql, null);
}

public boolean prem_execute(String sql, Object[] parameters) throws Exception {

return StaticDB.prem_execute(prem, conn, sql, parameters);
}

public java.sql.ResultSet prem_executeQuery(String sql, Object[] parameters)
throws Exception {

return StaticDB.prem_executeQuery(prem, conn, sql, parameters);
}

public int prem_executeUpdate(String sql, Object[] parameters) throws Exception {

return StaticDB.prem_executeUpdate(prem, conn, sql, parameters);
}

public void Process(String sql) throws Exception {
StaticDB.Process(conn, cst, sql);
}

public E getBean(String sql, Class bean) throws Exception {
if (DBHelper.pack != null) {
   return (E) StaticDB.getBeanList(sql, bean,stat, prem, conn, true, null)
     .get(0);
} else {
   return (E) StaticDB.getBeanList(sql, bean, stat,prem, conn, false, null)
     .get(0);
}
}

public int updateBean(E bean) throws Exception {
return StaticDB.updateByWhere_static(bean, null, null);
}

public int updateByWhere(E bean, String where) throws Exception {
return StaticDB.updateByWhere_static(bean, where, null);
}

public List<E> getBeanList(String sql, Class bean) throws Exception {
if (DBHelper.pack != null) {
   return (List<E>) StaticDB.getBeanList(sql, bean,stat, prem, conn, true,
     null);
} else {
   return (List<E>) StaticDB.getBeanList(sql, bean, stat,prem, conn, false,
     null);
}
}

public int updateBean(E bean, Object[] parameters) throws Exception {
return StaticDB.updateByWhere_static(bean, null, parameters);
}

public int updateByWhere(E bean, String where, Object[] parameters)
throws Exception {
return StaticDB.updateByWhere_static(bean, where, parameters);
}

public E getBean(String sql, Class bean, Object[] parameters) throws Exception {
if (DBHelper.pack != null) {
   return (E) StaticDB.getBeanList(sql, bean, stat,prem, conn, true, parameters)
     .get(0);
} else {
   return (E) StaticDB.getBeanList(sql, bean, stat,prem, conn, false, parameters)
     .get(0);
}
}

public List<E> getBeanList(String sql, Class bean, Object[] parameters)
   throws Exception {
if (DBHelper.pack != null) {
   return (List<E>) StaticDB.getBeanList(sql, bean, stat,prem, conn, true,
     parameters);
} else {
   return (List<E>) StaticDB.getBeanList(sql, bean, stat,prem, conn, false,
     parameters);
}
}

public int addBean(E bean) throws Exception {
return StaticDB.addBean_static(bean);
}

public byte getByte(String sql) throws Exception {
return (Byte) StaticDB.getObj(byte.class, sql,null);
}

public int getInt(String sql) throws Exception {
return (Integer) StaticDB.getObj(int.class, sql,null);
}

public float getFloat(String sql) throws Exception {
return (Float) StaticDB.getObj(float.class, sql,null);
}

public short getShort(String sql) throws Exception {
return (Short) StaticDB.getObj(short.class, sql,null);
}

public double getDouble(String sql) throws Exception {
return (Double) StaticDB.getObj(double.class, sql,null);
}

public String getString(String sql) throws Exception {
return (String) StaticDB.getObj(String.class, sql,null);
}

public Date getDate(String sql) throws Exception {
return (Date) StaticDB.getObj(Date.class, sql,null);
}

public Object getObject(String sql) throws Exception {
return StaticDB.getObj(Object.class, sql,null);
}

public List<String> getStringList(String sql) throws Exception {
return StaticDB.getStringList_static(sql, null);
}

public byte getByte(String sql, Object[] parameters) throws Exception {
return (Byte) StaticDB.getObj(byte.class, sql, parameters);
}

public int getInt(String sql, Object[] parameters) throws Exception {
return (Integer) StaticDB.getObj(int.class, sql, parameters);
}

public float getFloat(String sql, Object[] parameters) throws Exception {
return (Float) StaticDB.getObj(float.class, sql, parameters);
}

public short getShort(String sql, Object[] parameters) throws Exception {
return (Short) StaticDB.getObj(short.class, sql, parameters);
}

public double getDouble(String sql, Object[] parameters) throws Exception {
return (Double) StaticDB.getObj(double.class, sql, parameters);
}

public String getString(String sql, Object[] parameters) throws Exception {
return (String) StaticDB.getObj(String.class, sql, parameters);
}

public Date getDate(String sql, Object[] parameters) throws Exception {
return (Date) StaticDB.getObj(Date.class, sql, parameters);
}

public Object getObject(String sql, Object[] parameters) throws Exception {
return StaticDB.getObj(Object.class, sql, parameters);
}

public List<String> getStringList(String sql, Object[] parameters)
throws Exception {
return StaticDB.getStringList_static(sql, parameters);
}

public void close() throws Exception {
StaticDB.close(stat, prem, conn, cst, null);
}

}

package zhongheling.java.sql.dbhelper;

import zhongheling.java.sql.basic.DBBasic;
import zhongheling.java.sql.face.IDBHelperNoEx;
import zhongheling.java.sql.manage.DBManageSuper;
import zhongheling.java.sql.pack.ResultSetPack;

public class DHHelperNoEx<E> extends DBBasic<E> implements IDBHelperNoEx<E> {

private Statement stat = null;

private PreparedStatement prem = null;

private Connection conn = null;

private CallableStatement cst = null;

private DBBasic<E> StaticDB;

protected static DateFormat dateFormat = DateFormat.getDateInstance();

protected static ResultSetPack pack = null;//得到包装类对象

public DHHelperNoEx(DBManageSuper manage) {
StaticDB.setDBManage(manage);
}

public boolean execute(String sql) {

boolean b = false;
try {
b = StaticDB.execute(conn, stat, sql);
} catch (Exception e) {
this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_execute", e);
}
return b;
}

public ResultSet executeQuery(String sql) {

ResultSet r = null;
try {
r = StaticDB.executeQuery(conn, stat, sql);
} catch (Exception e) {
this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_executeQuery", e);
}
return r;
}

public int executeUpdate(String sql) {

int i =0;
try {
i = StaticDB.executeUpdate(conn, stat, sql);
} catch (Exception e) {
this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_executeUpdate", e);
}
return i;
}

public boolean prem_execute(String sql) {

boolean b =false;
try {
b = StaticDB.prem_execute(prem, conn, sql,null);
} catch (Exception e) {
this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_prem_execute", e);
}
return b;
}

public java.sql.ResultSet prem_executeQuery(String sql) {

ResultSet r = null;
try {
r = StaticDB.prem_executeQuery(prem, conn, sql,null);
} catch (Exception e) {
this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_prem_executeQuery", e);
}
return r;
}

public int prem_executeUpdate(String sql) {

int i =0;
try {
   i = StaticDB.prem_executeUpdate(prem, conn, sql,null);
} catch (Exception e) {
   this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_prem_executeUpdate", e);
}
return i;
}
public boolean prem_execute(String sql,Object[] parameters) {

boolean b =false;
try {
   b = StaticDB.prem_execute(prem, conn, sql,parameters);
} catch (Exception e) {
   this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_prem_execute", e);
}
return b;
}

public java.sql.ResultSet prem_executeQuery(String sql,Object[] parameters) {

ResultSet r = null;
try {
r = StaticDB.prem_executeQuery(prem, conn, sql,parameters);
} catch (Exception e) {
this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_prem_executeQuery", e);
}
return r;
}

public int prem_executeUpdate(String sql,Object[] parameters) {

int i =0;
try {
i = StaticDB.prem_executeUpdate(prem, conn, sql,parameters);
} catch (Exception e) {
this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_prem_executeUpdate", e);
}
return i;
}

public void Process(String sql) {

try {
   StaticDB.Process(conn, cst, sql);
} catch (Exception e) {
   this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_Process", e);
}
}
public int addBean(E bean) {

int i=0;
try {
   i= StaticDB.addBean_static(bean);
} catch (Exception e) {
   this.getDBManage().printExceptionNoEx(null, "DHHelperNoEx<E>_addBean", e);
}
return i;
}
@SuppressWarnings("unchecked")
public E getBean(String sql, Class bean) {

Object object=null;
try {
   if (DBHelper.pack != null) {
    object= StaticDB.getBeanList(sql, bean,stat, prem, conn, true, null).get(0);
   } else {
    object= StaticDB.getBeanList(sql, bean,stat, prem, conn, false, null).get(0);
   }
} catch (Exception e) {
   this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_getBean", e);
}
return(E)object;
}

@SuppressWarnings("unchecked")
public List<E> getBeanList(String sql, Class bean) {

List<E> list=null;
try {
   if (DBHelper.pack != null) {
    list= (List<E>) StaticDB.getBeanList(sql, bean,stat, prem, conn, true,null);
   } else {
    list= (List<E>) StaticDB.getBeanList(sql, bean, stat,prem, conn, false,null);
   }
} catch (Exception e) {
   this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_getBeanList", e);
}

return list;
}

@SuppressWarnings("unchecked")
public List<E> getBeanList(String sql, Class bean, boolean IsPack) {

List<E> list=null;
try {
list= (List<E>) StaticDB.getBeanList(sql, bean, stat,prem, conn, IsPack,null);
} catch (Exception e) {
this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_getBeanList", e);
}
return list;
}

public int updateBean(E bean) {

int i=0;
try {
i= StaticDB.updateByWhere_static(bean, null, null);
} catch (Exception e) {
this.getDBManage().printExceptionNoEx(null, "DHHelperNoEx<E>_updateBean", e);
}
return i;
}

public int updateByWhere(E bean, String where) {

int i=0;
try {
   i= StaticDB.updateByWhere_static(bean, where,null);
} catch (Exception e) {
   this.getDBManage().printExceptionNoEx(null, "DHHelperNoEx<E>_updateByWhere", e);
}
return i;
}
@SuppressWarnings("unchecked")
public E getBean(String sql, Class bean,Object[] parameters) {

Object object=null;
try {
   if (DBHelper.pack != null) {
    object= StaticDB.getBeanList(sql, bean, stat,prem, conn, true,parameters).get(0);
   } else {
    object= StaticDB.getBeanList(sql, bean,stat, prem, conn, false,parameters).get(0);
   }
} catch (Exception e) {
   this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_getBean", e);
}
return(E)object;
}

@SuppressWarnings("unchecked")
public List<E> getBeanList(String sql, Class bean,Object[] parameters) {

List<E> list=null;
try {
   if (DBHelper.pack != null) {
    list= (List<E>) StaticDB.getBeanList(sql, bean,stat, prem, conn, true,parameters);
   } else {
    list= (List<E>) StaticDB.getBeanList(sql, bean, stat,prem, conn, false,parameters);
   }
} catch (Exception e) {
   this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_getBeanList", e);
}

return list;
}

@SuppressWarnings("unchecked")
public List<E> getBeanList(String sql, Class bean, boolean IsPack,Object[] parameters) {

List<E> list=null;
try {
list= (List<E>) StaticDB.getBeanList(sql, bean,stat, prem, conn, IsPack,parameters);
} catch (Exception e) {
this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_getBeanList", e);
}
return list;
}

public int updateBean(E bean,Object[] parameters) {

int i=0;
try {
i=StaticDB.updateByWhere_static(bean, null, parameters);
} catch (Exception e) {
this.getDBManage().printExceptionNoEx(null, "DHHelperNoEx<E>_updateBean", e);
}
return i;
}

public int updateByWhere(E bean, String where,Object[] parameters) {

int i=0;
try {
i= StaticDB.updateByWhere_static(bean, where,parameters);
} catch (Exception e) {
this.getDBManage().printExceptionNoEx(null, "DHHelperNoEx<E>_updateByWhere", e);
}
return i;
}

public byte getByte(String sql) {

   byte b=0;
   try {
    b= (Byte) StaticDB.getObj(byte.class, sql,null);
   } catch (Exception e) {
    this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_getByte", e);
   }
   return b;
}

public int getInt(String sql) {

   int i=0;
   try {
    i= (Integer) StaticDB.getObj(int.class, sql,null);
   } catch (Exception e) {
    this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_getInt", e);
   }
   return i;
}

public float getFloat(String sql) {

   float f=0;
   try {
    f= (Float) StaticDB.getObj(float.class, sql,null);
   } catch (Exception e) {
    this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_getFloat", e);
   }
   return f;
}

public short getShort(String sql) {

   short s=0;
   try {
    s= (Short) StaticDB.getObj(short.class, sql,null);
   } catch (Exception e) {
   }
   return s;
}

public double getDouble(String sql) {

   double d=0;
   try {
    d= (Double) StaticDB.getObj(double.class, sql,null);
   } catch (Exception e) {
   }
   return d;
}

public String getString(String sql) {

   String s=null;
   try {
    s= (String) StaticDB.getObj(String.class, sql,null);
   } catch (Exception e) {
    this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_getString", e);
   }
   return s;
}

public Date getDate(String sql) {

   Date d=null;
   try {
    d= (Date) StaticDB.getObj(Date.class, sql,null);
   } catch (Exception e) {
    this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_getDate", e);
   }
   return d;
}

public Object getObject(String sql) {


   Object o=null;
   try {
    o= (Object) StaticDB.getObj(Object.class, sql,null);
   } catch (Exception e) {
    this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_getObject", e);
   }
   return o;
}

public List<String> getStringList(String sql) {

   List<String> list=null;
   try {
    list= StaticDB.getStringList_static(sql,null);
   } catch (Exception e) {
    this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_getStringList", e);
   }
   return list;
}
public byte getByte(String sql,Object[] parameters) {

byte b=0;
try {
   b= (Byte) StaticDB.getObj(byte.class, sql,parameters);
} catch (Exception e) {
   this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_getByte", e);
}
return b;
}

public int getInt(String sql,Object[] parameters) {

int i=0;
try {
i= (Integer) StaticDB.getObj(int.class, sql,parameters);
} catch (Exception e) {
this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_getInt", e);
}
return i;
}

public float getFloat(String sql,Object[] parameters) {

float f=0;
try {
f= (Float) StaticDB.getObj(float.class, sql,parameters);
} catch (Exception e) {
this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_getFloat", e);
}
return f;
}

public short getShort(String sql,Object[] parameters) {

short s=0;
try {
s= (Short) StaticDB.getObj(short.class, sql,parameters);
} catch (Exception e) {
}
return s;
}

public double getDouble(String sql,Object[] parameters) {

double d=0;
try {
d= (Double) StaticDB.getObj(double.class, sql,parameters);
} catch (Exception e) {
}
return d;
}

public String getString(String sql,Object[] parameters) {

String s=null;
try {
s= (String) StaticDB.getObj(String.class, sql,parameters);
} catch (Exception e) {
this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_getString", e);
}
return s;
}

public Date getDate(String sql,Object[] parameters) {

Date d=null;
try {
d= (Date) StaticDB.getObj(Date.class, sql,parameters);
} catch (Exception e) {
this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_getDate", e);
}
return d;
}

public Object getObject(String sql,Object[] parameters) {

Object o=null;
try {
o= (Object) StaticDB.getObj(Object.class, sql,parameters);
} catch (Exception e) {
this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_getObject", e);
}
return o;
}

public List<String> getStringList(String sql,Object[] parameters) {

List<String> list=null;
try {
list= StaticDB.getStringList_static(sql,parameters);
} catch (Exception e) {
this.getDBManage().printExceptionNoEx(sql, "DHHelperNoEx<E>_getStringList", e);
}
return list;
}

public void close() {

try {
StaticDB.close(stat, prem, conn, cst, null);
} catch (Exception e) {
this.getDBManage().printExceptionNoEx(null, "DHHelperNoEx<E>_close", e);
}
}

}

package zhongheling.java.sql.face;

import java.sql.ResultSet;
import java.util.Date;
import java.util.List;

public interface IDBHelper<E> {

public abstract boolean execute(String sql) throws Exception;

public abstract ResultSet executeQuery(String sql) throws Exception;

public abstract int executeUpdate(String sql) throws Exception;

public abstract boolean prem_execute(String sql) throws Exception;

public abstract java.sql.ResultSet prem_executeQuery(String sql)
throws Exception;

public abstract int prem_executeUpdate(String sql) throws Exception;

public abstract boolean prem_execute(String sql, Object[] objs)
throws Exception;

public abstract java.sql.ResultSet prem_executeQuery(String sql,
Object[] objs) throws Exception;

public abstract int prem_executeUpdate(String sql, Object[] objs)
throws Exception;

public abstract void Process(String sql) throws Exception;

public abstract int addBean(E bean) throws Exception;

public abstract E getBean(String sql, Class cla) throws Exception;

public abstract List<E> getBeanList(String sql, Class cla) throws Exception;

public abstract int updateBean(E bean) throws Exception;

public abstract int updateByWhere(E bean, String where) throws Exception;

public abstract E getBean(String sql, Class cla, Object[] objs)
throws Exception;

public abstract List<E> getBeanList(String sql, Class cla, Object[] objs)
throws Exception;

public abstract int updateBean(E bean, Object[] objs) throws Exception;

public abstract int updateByWhere(E bean, String where, Object[] objs)
throws Exception;

public abstract byte getByte(String sql) throws Exception;

public abstract int getInt(String sql) throws Exception;

public abstract float getFloat(String sql) throws Exception;

public abstract short getShort(String sql) throws Exception;

public abstract double getDouble(String sql) throws Exception;

public abstract String getString(String sql) throws Exception;

public abstract Date getDate(String sql) throws Exception;

public abstract Object getObject(String sql) throws Exception;

public abstract List<String> getStringList(String sql) throws Exception;

public abstract byte getByte(String sql, Object[] parameters) throws Exception;

public abstract int getInt(String sql, Object[] parameters) throws Exception;

public abstract float getFloat(String sql, Object[] parameters) throws Exception;

public abstract short getShort(String sql, Object[] parameters) throws Exception;

public abstract double getDouble(String sql, Object[] parameters)
throws Exception;

public abstract String getString(String sql, Object[] parameters)
throws Exception;

public abstract Date getDate(String sql, Object[] parameters) throws Exception;

public abstract Object getObject(String sql, Object[] parameters)
throws Exception;

public abstract List<String> getStringList(String sql, Object[] parameters)
throws Exception;

public abstract void close() throws Exception;
}

package zhongheling.java.sql.face;
import java.sql.ResultSet;
import java.util.Date;
import java.util.List;

public interface IDBHelperNoEx<E> {

public abstract boolean execute(String sql) ;

public abstract ResultSet executeQuery(String sql) ;

public abstract int executeUpdate(String sql) ;

public abstract boolean prem_execute(String sql) ;

public abstract java.sql.ResultSet prem_executeQuery(String sql);

public abstract int prem_executeUpdate(String sql) ;

public abstract boolean prem_execute(String sql, Object[] parameters);

public abstract java.sql.ResultSet prem_executeQuery(String sql,
Object[] parameters) ;

public abstract int prem_executeUpdate(String sql, Object[] parameters);

public abstract void Process(String sql) ;

public abstract int addBean(E bean) ;

public abstract E getBean(String sql, Class cla) ;

public abstract List<E> getBeanList(String sql, Class cla) ;

public abstract int updateBean(E bean) ;

public abstract int updateByWhere(E bean, String where) ;

public abstract E getBean(String sql, Class cla, Object[] parameters);

public abstract List<E> getBeanList(String sql, Class cla, Object[] parameters);

public abstract int updateBean(E bean, Object[] parameters) ;

public abstract int updateByWhere(E bean, String where, Object[] parameters);

public abstract byte getByte(String sql) ;

public abstract int getInt(String sql) ;

public abstract float getFloat(String sql) ;

public abstract short getShort(String sql) ;

public abstract double getDouble(String sql) ;

public abstract String getString(String sql) ;

public abstract Date getDate(String sql) ;

public abstract Object getObject(String sql) ;

public abstract List<String> getStringList(String sql) ;

public abstract byte getByte(String sql, Object[] parameters) ;

public abstract int getInt(String sql, Object[] parameters) ;

public abstract float getFloat(String sql, Object[] parameters) ;

public abstract short getShort(String sql, Object[] parameters) ;

public abstract double getDouble(String sql, Object[] parameters);

public abstract String getString(String sql, Object[] parameters);

public abstract Date getDate(String sql, Object[] parameters) ;

public abstract Object getObject(String sql, Object[] parameters);

public abstract List<String> getStringList(String sql, Object[] parameters);

public abstract void close() ;

}

package zhongheling.java.sql.manage;

import java.sql.DriverManager;
import java.text.DateFormat;
import java.util.Date;

import zhongheling.java.sql.face.IDBHelper;

public class DBManage extends DBManageSuper {

//时间格式属性
protected static DateFormat dateFormat = DateFormat.getDateInstance();

//得到连接
public java.sql.Connection getConnection() throws Exception {

return getConnection_static();
}
//设置自动增长列字段
public void getIdentity(Class bealClass,IDBHelper s)throws Exception
{
adpater.getIdentityName(bealClass);
}

//设置入库时时间格式
public String formatTime(Date date) throws Exception {
return dateFormat.format(date);
}

//数据库访问过程中的异常处理，可以在这里打印日志等
public void printException(String sql, String message, Exception e)throws Exception {
printException_Static(sql,message,e);
}
//数据库访问过程中的异常处理，可以在这里打印日志等
public void printExceptionNoEx(String sql, String message, Exception e) {
printExceptionNoEx_Static(sql,message,e);
}
private static java.sql.Connection getConnection_static() throws Exception {
// 数据库驱动
//private final String driver = "net.sourceforge.jtds.jdbc.Driver";
//String driver = "net.sourceforge.jtds.jdbc.Driver";
String driver = "oracle.jdbc.driver.OracleDriver";

// 数据库地址以及数据源名称
//private final String url = "jdbc:jtds:sqlserver://localhost:1433/newBBS";
String url = "jdbc:oracle:thin:@10.38.202.37:1522:telf106";

// 用户名
String name = "yy0a";

// 密码
String password = "yy0a";

java.sql.Connection conn = null;
try {
   Class.forName(driver);
   conn = DriverManager.getConnection(url, name, password);
} catch (Exception e) {
   System.out.println("连接数据库错误:" + e.getMessage());
   System.out.println(e.toString());
   throw e;
}
return conn;
}

private static String formatTime_Static(Date date) throws Exception {
return dateFormat.format(date);
}

private static void printException_Static(String sql, String message, Exception e)throws Exception {
System.out.println("SQL:"+sql);
System.out.println("MESSAGE:"+message);
System.out.println(e.toString());
e.printStackTrace();
throw e;
}
private static void printExceptionNoEx_Static(String sql, String message, Exception e){

System.out.println("SQL:"+sql);
System.out.println("MESSAGE:"+message);
System.out.println(e.toString());
e.printStackTrace();
}

}

package zhongheling.java.sql.manage;

import java.util.Date;
import zhongheling.java.sql.adapter.DBAdapter;
import zhongheling.java.sql.face.IDBHelper;
import zhongheling.java.sql.pack.PreparedStatementPack;
import zhongheling.java.sql.pack.ResultSetPack;

public abstract class DBManageSuper {

// 得到包装类对象，如果为空的话则不启用
public static ResultSetPack rsPack = null;

public static PreparedStatementPack psPack=new PreparedStatementPack();;
//适配器
public static DBAdapter adpater=null;

//得到连接
public abstract java.sql.Connection getConnection()throws Exception;

//设置自动增长列
public abstract void getIdentity(Class bealClass,IDBHelper db)throws Exception;

//异常处理并抛出
public abstract   void printException(String sql, String message, Exception e)throws Exception;

//异常处理不抛出
public abstract   void printExceptionNoEx(String sql, String message, Exception e);

//入库时间格式设置
public abstract   String formatTime(Date date) throws Exception ;
}

package zhongheling.java.sql.pack;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class PreparedStatementPack {

private static PreparedStatement prem;

public void setPreparedStatement(PreparedStatement prem)
{
PreparedStatementPack.prem=prem;
}
public static void setBoolean(Integer index , Boolean value) throws SQLException {

prem.setBoolean(index, value);
}

public static void setByte(Integer index , Byte value) throws Exception {

prem.setByte(index, value);
}

public static void setShort(Integer index , Short value) throws Exception {

prem.setShort(index, value);
}

public static void setInt(Integer index , Integer value) throws Exception {

prem.setInt(index, value);
}

public static void setLong(Integer index , Long value) throws Exception {

prem.setLong(index, value);
}

public static void setFloat(Integer index , Float value) throws Exception {

prem.setFloat(index, value);

}

public static void setDouble(Integer index , Double value) throws Exception {

prem.setDouble(index, value);

}

public static void setString(Integer index , String value) throws Exception {

prem.setString(index.intValue(), value);

}

public static void setDate(Integer index , java.sql.Date value ) throws Exception {

prem.setDate(index, value);

}

package zhongheling.java.sql.pack;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;

public class ResultSetPack {

private static ResultSet resultSet;

public static Boolean getBoolean(String columnLabel) throws SQLException {

return new Boolean(resultSet.getBoolean(columnLabel));
}

public static Byte getByte(String columnLabel) throws SQLException {

return new Byte(resultSet.getByte(columnLabel));
}

public static Short getShort(String columnLabel) throws SQLException {

return new Short(resultSet.getShort(columnLabel));
}

public static Integer getInt(String columnLabel) throws SQLException {

return new Integer(resultSet.getInt(columnLabel));
}

public static Long getLong(String columnLabel) throws SQLException {

return new Long(resultSet.getLong(columnLabel));
}

public static Float getFloat(String columnLabel) throws SQLException {

return new Float(resultSet.getFloat(columnLabel));

}

public static Double getDouble(String columnLabel) throws SQLException {

return new Double(resultSet.getDouble(columnLabel));

}

public static String getString(String columnLabel) throws SQLException {

return resultSet.getString(columnLabel);

}

public static Date getDate(String columnLabel) throws SQLException {

return resultSet.getDate(columnLabel);

}

public static Boolean getBoolean(int columnIndex) throws SQLException {

return new Boolean(resultSet.getBoolean(columnIndex));

}

public static Byte getByte(int columnIndex) throws SQLException {

return new Byte(resultSet.getByte(columnIndex));

}

public static Short getShort(int columnIndex) throws SQLException {

return new Short(resultSet.getShort(columnIndex));

}

public static Integer getInt(int columnIndex) throws SQLException {

return new Integer(resultSet.getInt(columnIndex));

}

public static Long getLong(int columnIndex) throws SQLException {

return new Long(resultSet.getLong(columnIndex));

}

public static Float getFloat(int columnIndex) throws SQLException {

return new Float(resultSet.getFloat(columnIndex));

}

public static Double getDouble(int columnIndex) throws SQLException {

return new Double(resultSet.getDouble(columnIndex));

}

public static String getString(int columnIndex) throws SQLException {

return resultSet.getString(columnIndex);
}

public static Date getDate(int columnIndex) throws SQLException {

return resultSet.getDate(columnIndex);
}

public static void setResultSet(ResultSet rs) {

resultSet = rs;
}

}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/qq454952101/archive/2011/04/29/6372802.aspx

我的db类库 新版

我的db类库新版