数据访问层工具类

package dao.impl;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

public class BaseDaoUntil {
// 声明PreparedStatement、ResultSet
private PreparedStatement ps;
private ResultSet rs;

/**
* 数据库新增数据方法
*
* @param conn 数据接口传入
* @param sql SQL语句
* @param vo 新增对象
* @return 返回执行成功的行数
* @throws Exception
*/
public <T> int insert(Connection conn, String sql, T vo) throws Exception {
// TODO Auto-generated method stub
// SQL语句
// String sql = "INSERT INTO emp(empno, ename, job, mgr, hiredate, sal, comm, deptno) VALUES(?,?,?,?,?,?,?,?)";
// 预编译SQL语句
ps = conn.prepareStatement(sql);
// 拆分SQL语句生成数组
String[] str = sql.split("\\(")[1].split("\\)")[0].split(",");
// 遍历数组
for (int i = 0; i < str.length; i++) {
// 通过反射获取对象成员变量
Field f = vo.getClass().getDeclaredField(str[i].trim());
// 暴力访问私有封装
f.setAccessible(true);
// 获取成员变量内容
Object object = f.get(vo);
// 将成员变量内容替换占位符
ps.setObject(i + 1, object);
}
// 返回执行成功的行数
return ps.executeUpdate();
}

/**
* 数据库更新数据方法
*
* @param conn 数据接口传入
* @param sql SQL语句
* @param vo 更新对象
* @return 返回执行成功的行数
* @throws Exception
*/
public <T> int update(Connection conn, String sql, T vo) throws Exception {
// TODO Auto-generated method stub
// SQL语句
// String sql = "UPDATE emp SET ename=?, job=?, mgr=?, hiredate=?, sal=?, comm=?, deptno=? WHERE empno=?";
// 预编译SQL语句
ps = conn.prepareStatement(sql);
// 拆分SQL语句生成“WHERE”之前数组
String[] str1 = sql.split("SET")[1].split("WHERE")[0].split(",");
int i = 0;
// 遍历数组
for (i = 0; i < str1.length; i++) {
// 通过反射获取对象成员变量
Field f = vo.getClass().getDeclaredField(str1[i].trim().split("=")[0]);
// 暴力访问私有封装
f.setAccessible(true);
// 获取成员变量内容
Object object = f.get(vo);
// 将成员变量内容替换占位符
ps.setObject(i + 1, object);
}
// 拆分SQL语句生成“WHERE”之后字符
String str2 = sql.split("WHERE")[1].split("=")[0];
// 通过反射获取对象成员变量
Field f = vo.getClass().getDeclaredField(str2.trim());
// 暴力访问私有封装
f.setAccessible(true);
// 获取成员变量内容
Object object = f.get(vo);
// 将成员变量内容替换占位符
ps.setObject(i + 1, object);
// 返回执行成功的行数
return ps.executeUpdate();
}

/**
* 数据库删除单条数据方法
*
* @param conn 数据接口传入
* @param sql SQL语句
* @param ID 需要删除数据的ID
* @return 返回执行成功的行数
* @throws Exception
*/
public int delete(Connection conn, String sql, Object ID) throws Exception {
// TODO Auto-generated method stub
// SQL语句
// String sql = "DELETE FROM emp WHERE empno = ?";
// 预编译SQL语句
ps = conn.prepareStatement(sql);
// 将ID内容替换占位符
ps.setObject(1, ID);
// 返回执行成功的行数
return ps.executeUpdate();
}

/**
* 数据库删除多条条数据方法
*
* @param conn 数据接口传入
* @param sql SQL语句
* @param ID 需要删除数据的ID
* @return 返回执行成功的行数
* @throws Exception
*/
public int deleteBatch(Connection conn, StringBuffer sql, Object... IDs) throws Exception {
// SQL语句
// StringBuffer sql = new StringBuffer("DELECT FROM emp WHERE empno IN(");
// 遍历可变参同过StringBuffer拼接SQL语句
for (Object obj : IDs) {
sql.append(obj).append(",");
}
String str = sql.delete(sql.length() - 1, sql.length()).append(")").toString();
// 预编译SQL语句
ps = conn.prepareStatement(str);
// 返回执行成功的行数
return ps.executeUpdate();
}

/**
* 数据库的单条数据查询
*
* @param conn 数据接口传入
* @param sql SQL语句
* @param clz 对象的class文件
* @param ID 需要查询的数据ID
* @return 成功返回包含查询结果的对象，否则返回null
* @throws Exception
*/
public <T> T select(Connection conn, String sql, Class<T> clz, Object ID) throws Exception {
// TODO Auto-generated method stub
// SQL语句
// String sql = "SELECT empno, ename, job, mgr, hiredate, sal, comm, deptno FROM emp WHERE empno = ?";
// 预编译SQL语句
ps = conn.prepareStatement(sql);
// 将ID内容替换占位符
ps.setObject(1, ID);
// 将预编译SQL语句发送至数据库并接收回传数据至ResultSet
rs = ps.executeQuery();
// 通过反射获取带参构造方法
Constructor<T> c = clz.getConstructor(Integer.class, String.class, String.class, Integer.class, Date.class,
Double.class, Double.class, Integer.class);
// 声明一个空对象
T t = null;
// 判断数据库回传内容，如果为true则通过指针遍历数据库回传，false则直接方法返回null
if (rs.next()) {
// 创建带参构造方法实例，并通过先前定义的空对象接收
t = c.newInstance(rs.getInt(1), rs.getString(2), rs.getString(3), rs.getInt(4), rs.getDate(5),
rs.getDouble(6), rs.getDouble(7), rs.getInt(8));
}
// 返回对象
return t;
}

/**
* 数据库的模糊分页查询
*
* @param conn 数据接口传入
* @param sql SQL语句
* @param clz 对象的class文件
* @param cp 当前页
* @param ls 当前页数据量
* @param conditions 待查询条件数组
* @return 成功返回包含查询结果的集合，否则返回null集合
* @throws Exception
*/
public <T> List<T> selectSplitAll(Connection conn, String sql, Class<T> clz, Integer cp, Integer ls,
Object... conditions) throws Exception {
// TODO Auto-generated method stub
// 声明一个结合
List<T> list = new ArrayList<T>();
// SQL语句
// String str = "SELECT empno, ename, job, mgr, hiredate, sal, comm, deptno FROM emp WHERE ename LIKE ? LIMIT ?,?";
// 预编译SQL语句
ps = conn.prepareStatement(sql);
// 遍历可变参并替换占位符
for (int i = 0; i < conditions.length; i++) {
ps.setObject(i + 1, conditions[i]);
}
// 替换当前页、当前页数据量的占位符
ps.setInt(conditions.length + 1, (cp - 1) * ls);
ps.setInt(conditions.length + 2, ls);
// 将预编译SQL语句发送至数据库并接收回传数据至ResultSet
rs = ps.executeQuery();
// 通过反射获取带参构造方法
Constructor<T> c = clz.getConstructor(Integer.class, String.class, String.class, Integer.class, Date.class,
Double.class, Double.class, Integer.class);
// 判断数据库回传内容，如果为true则通过指针遍历数据库回传直至为false返回集合，否则false则直接方法返回null
while (rs.next()) {
// 创建带参构造方法实例，并通过先前定义的空对象接收
list.add(c.newInstance(rs.getInt(1), rs.getString(2), rs.getString(3), rs.getInt(4), rs.getDate(5),
rs.getDouble(6), rs.getDouble(7), rs.getInt(8)));
}
// 返回集合
return list;
}

/**
* 数据库的统计查询
*
* @param conn 数据接口传入
* @param sql SQL语句
* @param conditions 待查询条件数组
* @return 成功返回包含查询结果，否则返回null
* @throws Exception
*/
public int selectCount(Connection conn, String sql, Object... conditions) throws Exception {
// TODO Auto-generated method stub
// SQL语句
// String sql = "SELECT COUNT(*) FROM emp WHERE ename LIKE ?";
// 预编译SQL语句
ps = conn.prepareStatement(sql);
// 遍历可变参并替换占位符
for (int i = 0; i < conditions.length; i++) {
ps.setObject(i + 1, conditions[i]);
}
// 将预编译SQL语句发送至数据库并接收回传数据至ResultSet
rs = ps.executeQuery();
int result = 0;
while (rs.next()) {
result = rs.getInt(1);
}
// 返回查询结果
return result;
}

}