以下详细讲讲通过我自己的方式对有关DAO层数据库基本CRUD操作的JAVA实现(此处已MySQL为例，其它数据库仅仅需做部分改动就可以)。
备注：若要试用本演示样例，仅仅需依照给出的顺序依次复制代码建立对应的类就可以。另外。在项目lib文件夹下增加mysql链接jar包。
(1)定义数据源常量类
package com.jkitn.jkits.common;
/**
* 定义数据源常量类
* @author xdweleven
* @version 1.0
*/
public class JdbcConfig {
/** 数据库驱动 */
public static final String DRIVERCLASSNAME = "com.mysql.jdbc.Driver";
/** 数据库URL */
public static final String URL = "jdbc:mysql://localhost:3306/app_jkit";
/** 数据库username */
public static final String USERNAME = "root";
/** 数据库password */
public static final String PASSWORD = "root";
}
(2)定义结果集(ResultSet)到pojo对象的映射
package com.jkitn.jkits.dao.common;
import java.lang.reflect.Field;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
/**
* 说明：实现结果集到pojo对象的映射
* @author xdweleven
* @version 1.0
*/
public class RowMapper{
private Class objectClass;
public RowMapper(Class objectClass) {
this.objectClass = objectClass;
}
/**
* 实现单条记录到对象的映射
* @param rs 结果集
* @param rowNum 当前行数
* @return
* @throws SQLException
*/
public T mapRow(ResultSet rs, int rowNum) throws SQLException {
try {
T object = objectClass.newInstance();
// 得到结果集的字段集合
ResultSetMetaData metaData = rs.getMetaData();
int columnNum = metaData.getColumnCount();
Field[] fields = object.getClass().getDeclaredFields();
// 设置对象属性的值。若不存在。则设置为null.
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
int flag = 0;
for (int j = 1; j <= columnNum; j++) {
if (metaData.getColumnName(j).toLowerCase().equals(field.getName().toLowerCase())) {
flag = 1;
break;
}
}
field.setAccessible(true);
if (flag == 1) {
this.typeMapper(field, object, rs);
}else {
field.set(object, null);
}
field.setAccessible(false);
}
return object;
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return null;
}
/**
* 实现多条记录到结果集的映射
* @param rs
* @return
*/
public List mapRows(ResultSet rs){
int rowNum = 0;
List objList = new ArrayList();
try {
while(rs.next()){
objList.add(this.mapRow(rs, rowNum++));
}
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
return objList;
}
/**
* 类型的映射
* @param field
* @param obj
* @param rs
* @throws IllegalArgumentException
* @throws IllegalAccessException
* @throws SQLException
*/
private void typeMapper(Field field, Object obj, ResultSet rs) {
String typeName = field.getType().getName(); // 得到字段类型
try {
if (typeName.equals("java.lang.String")) {
field.set(obj, rs.getString(field.getName()));
} else if (typeName.equals("int")
|| typeName.equals("java.lang.Integer")) {
field.set(obj, rs.getInt(field.getName()));
} else if (typeName.equals("long")
|| typeName.equals("java.lang.Long")) {
field.set(obj, rs.getLong(field.getName()));
} else if (typeName.equals("float")
|| typeName.equals("java.lang.Float")) {
field.set(obj, rs.getFloat(field.getName()));
} else if (typeName.equals("double")
|| typeName.equals("java.lang.Double")) {
field.set(obj, rs.getDouble(field.getName()));
} else if (typeName.equals("boolean")
|| typeName.equals("java.lang.Boolean")) {
field.set(obj, rs.getBoolean(field.getName()));
} else if (typeName.equals("java.util.Date")) {
field.set(obj, rs.getTimestamp(field.getName()));
} else {
}
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
(3)定义数据库连接辅助类DBConn
package com.jkitn.jkits.common;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import com.jkitn.jkits.dao.common.RowMapper;
/**
* 定义数据库连接辅助类DBConn
* @author xdweleven
* @version 1.0
*/
public class DBConn {
private Connection conn = null;
private PreparedStatement pstmt = null;
private ResultSet rs = null;
/**
* 创建数据库的连接
* @return 返回数据库连接对象
*/
public Connection getConn(){
try {
// 载入数据库驱动
Class.forName(JdbcConfig.DRIVERCLASSNAME);
// 创建Connection接口对象。用于获取MySQL数据库的连接对象
conn = DriverManager.getConnection(JdbcConfig.URL, JdbcConfig.USERNAME, JdbcConfig.PASSWORD);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
return conn;
}
/**
* 更新数据库操作(包含增删改操作)
* @param sql 待运行sql语句
* @param objs 用于设置预编译语句中带入的參数
* @return null
* @throws Exception
*/
public int execUpdate(String sql, Object ...objs) throws Exception{
// 获取预编译环境
pstmt = this.getConn().prepareStatement(sql);
if(objs != null && objs.length > 0){
for(int i = 0; i < objs.length; i++){
pstmt.setObject(i+1, objs[i]);
}
}
// 运行更新语句
int result = pstmt.executeUpdate();
// 断开连接。释放资源
this.close(rs, pstmt, conn);
return result;
}
/**
* 数据库查询操作
* @param sql 待运行sql语句
* @param objs 用于设置预编译语句中带入的參数
* @return 类T的List数据类型，即返回查询到的全部数据信息
* @throws Exception
*/
public List execQuery(String sql, RowMapper mapper, Object ...objs) throws Exception{
// 获取预编译环境
pstmt = this.getConn().prepareStatement(sql);
if(objs != null && objs.length > 0){
for(int i = 0; i < objs.length; i++){
pstmt.setObject(i+1, objs[i]);
}
}
// 运行更新语句
rs = pstmt.executeQuery();
// 运行关系到对象的映射
List result = mapper.mapRows(rs);
// 断开连接。释放资源
this.close(rs, pstmt, conn);
return result;
}
/**
* 运行运行的SQL语句并返回结果集
* @param sql SQL语句
* @param params 參数
* @return 返回结果集
*/
public ResultSet queryForResultSet(String sql, Object... objs) throws Exception{
// 获取预编译环境
pstmt = conn.prepareStatement(sql);
if(objs != null && objs.length > 0){
for(int i = 0; i < objs.length; i++){
pstmt.setObject(i+1, objs[i]);
}
}
// 运行更新语句
rs = pstmt.executeQuery();
// 断开连接，释放资源
this.close(null, pstmt, conn);
return rs;
}
/**
* 关闭数据库连接，释放所占的系统资源
* @param rs结果集、ppst预编译命令、conn数据库
* @return null
* @throws Exception
*/
public void close(ResultSet rs, PreparedStatement ppst, Connection conn) throws Exception{
if(rs != null){
rs.close();
}
if(ppst != null){
ppst.close();
}
if(conn != null){
conn.close();
}
}
}
(4)定义通用分页查询实体类
package com.jkitn.jkits.common;
import java.util.List;
/**
* 说明：实现通用分页查询实体类
* @author xdweleven
* @version 1.0
*/
public class PageBean {
private int totalRows; // 总记录数
private int totalPages; // 总页数
private int curPage; // 当前页码
private int prePage; // 上一页页码
private int nextPage; // 下一页页码
private int rowsPerPage; // 每页显示的记录数
private List pageList; // 当前页的数据集
/**
* 初始化分页bean对象
* @param totalRows 总记录数
* @param rowsPerPage 每页显示的记录数
*/
public void initPageBean(int totalRows, int rowsPerPage){
this.rowsPerPage = rowsPerPage;
this.totalRows = totalRows;
this.totalPages = (this.totalRows-1)/this.rowsPerPage + 1;
// 设置上一页
if(this.curPage == 1){
this.setPrePage(1);
}else{
this.setPrePage(this.curPage-1);
}
// 设置下一页
if(this.curPage == this.totalPages){
this.setNextPage(this.totalPages);
}else{
this.setNextPage(this.curPage + 1);
}
}
/**
* 生成SQLServer的分页查询语句
* @param sql 原始sql语句
* @param curPage 第几页
* @param rowsPerPage 每页多少行
*/
public String getPageSQLServer(String sql, int curPage, int rowsPerPage){
String afterFrom = sql.toLowerCase().substring(sql.indexOf("from"));
String pageSql = null;
if(afterFrom.indexOf("where") == -1){
pageSql = "select top "+ rowsPerPage + " * "+afterFrom
+" where id not in(select top "+rowsPerPage*(curPage-1)+" id "
+afterFrom+" order by id desc)"+"order by id desc";
}else{
pageSql = "select top "+ rowsPerPage + " * "+afterFrom
+" and id not in(select top "+rowsPerPage*(curPage-1)+" id "
+afterFrom+" order by id desc)"+"order by id desc";
}
return pageSql;
}
/**
* 生成MySql分页sql语句
* @param sql 原始sql语句
* @param curPage 第几页
* @param rowsPerPage 每页多少行
* @return 返回分页SQL语句
*/
public String getPageMySQL(String sql, int curPage, int rowsPerPage){
String pageSql = sql+" limit "+ (curPage-1)*rowsPerPage+","+rowsPerPage;
return pageSql;
}
/**
* 生成Oracle分页查询语句
* @param sql 原始sql语句
* @return 返回分页SQL语句
*/
public String getOrclPageSql(String sql){
int begin = (curPage - 1) * rowsPerPage;
int end = begin + rowsPerPage;
StringBuffer pagingSelect = new StringBuffer(300);
pagingSelect.append("select * from ( select row_.*, rownum rownum_ from ( ");
pagingSelect.append(sql);
pagingSelect.append(" ) row_ where rownum <= "+end+") where rownum_ > "+begin);
return pagingSelect.toString();
}
public List getPageList() {
return pageList;
}
public void setPageList(List pageList) {
this.pageList = pageList;
}
public int getTotalRows() {
return totalRows;
}
public void setTotalRows(int totalRows) {
this.totalRows = totalRows;
}
public int getTotalPages() {
return totalPages;
}
public void setTotalPages(int totalPages) {
this.totalPages = totalPages;
}
public int getCurPage() {
return curPage;
}
public void setCurPage(int curPage) {
this.curPage = curPage;
}
public int getPrePage() {
return prePage;
}
public void setPrePage(int prePage) {
this.prePage = prePage;
}
public int getNextPage() {
return nextPage;
}
public void setNextPage(int nextPage) {
this.nextPage = nextPage;
}
public int getRowsPerPage() {
return rowsPerPage;
}
public void setRowsPerPage(int rowsPerPage) {
this.rowsPerPage = rowsPerPage;
}
}
(5)定义SQL语句的经常用法工具类
package com.jkitn.jkits.util;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 说明：自己主动生成对象的增删改查SQL语句的通用方法工具类
* @author xdweleven
* @version 1.0
*/
public class SQLUtil {
/**
* 自己主动生成插入指定对象的SQL语句,不包括对象属性的值为空的字段
* @param obj 待生成插入SQL语句的对象
* @param tableName 待插入语句相应的数据库表的名称
* @return 返回一个包括SQL语句、SQL语句參数值及參数值类型的Map对象
*/
public static Map generateInsertExceptNull(Object obj, String tableName) {
StringBuffer columnStrBuf = new StringBuffer(); // 记录数据表的字段名称
StringBuffer paramStrBuf = new StringBuffer(); // 记录SQL语句相应插入的占位符
List paramValues = new ArrayList(); // 记录对象參数值
List paramsType = new ArrayList(); // 记录參数值类型
// 查询待插入对象的属性值不为空的属性名称
List fieldList = ReflectionUtil.getNotNullField(obj);
try {
for (int i = 0; i < fieldList.size(); i++) {
Field field = (Field) fieldList.get(i);
field.setAccessible(true);
// 记录对象属性名称
columnStrBuf.append(field.getName());
if (i != fieldList.size() - 1) {
columnStrBuf.append(",");
}
// 记录插入SQL语句的參数占位符
if("class java.util.Date".equals(field.getType().toString())
&& field.get(obj) != null){
String timeStr = DateUtil.formatDate((Date)field.get(obj), "yyyy-MM-dd HH:mm:ss");
paramStrBuf.append("to_date(?, 'yyyy-MM-dd HH24:mi:ss')");
paramValues.add(timeStr);
// 记录对象属性的数据类型
paramsType.add(getOrclDataType(field.getType().toString()));
}else{
paramStrBuf.append("?");
paramValues.add(field.get(obj));
// 记录对象属性的数据类型
paramsType.add(getOrclDataType(field.getType().toString()));
}
if (i != fieldList.size() - 1) {
paramStrBuf.append(",");
}
}
} catch (Exception e) {
throw new RuntimeException(e);
}
// 生成插入操作的SQL语句
StringBuffer sb = new StringBuffer();
sb.append("insert into ");
sb.append(tableName);
sb.append(" (");
sb.append(columnStrBuf);
sb.append(") ");
sb.append("values");
sb.append(" (");
sb.append(paramStrBuf);
sb.append(")");
// 将生成的SQL语句、SQL语句參数值及各參数值的数据类型用map保存并返回
Map sqlMap = new HashMap();
sqlMap.put("sql", sb.toString());
sqlMap.put("paramsValues", paramValues.toArray());
sqlMap.put("paramsTypes", paramsType.toArray());
return sqlMap;
}
/**
* 自己主动生成插入指定对象的SQL语句,包括对象属性的值为空的字段，不包括自增长主键,若不存在，调用时直接置为null.
* @param obj 待生成插入SQL语句的对象
* @param tableName 待插入语句相应的数据库表的名称
* @param keyColumn 数据表主键名称
* @return 返回一个包括SQL语句、SQL语句參数值及參数值类型的Map对象
* @throws IllegalAccessException
* @throws IllegalArgumentException
*/
public static Map generateInsertWithNull(Object obj,
String tableName, String keyColumn) throws IllegalArgumentException, IllegalAccessException {
StringBuffer columnStrBuf = new StringBuffer();
StringBuffer paramStrBuf = new StringBuffer(); // 记录SQL语句相应插入的占位符
List columnNameList = new ArrayList(); // 记录数据表的字段名称
List paramValues = new ArrayList(); // 记录对象參数值
List paramsType = new ArrayList(); // 记录參数值类型
Field[] fields = obj.getClass().getDeclaredFields();
for(int i = 0; i < fields.length; i++){
fields[i].setAccessible(true);
// 记录对象属性名称
if(!fields[i].getName().equalsIgnoreCase(keyColumn)){ // 非主键列记录插入SQL语句的參数占位符
columnStrBuf.append(fields[i].getName());
columnNameList.add(fields[i].getName());
if (i != fields.length - 1) {
columnStrBuf.append(",");
}
if("class java.util.Date".equals(fields[i].getType().toString())
&& fields[i].get(obj) != null){
String timeStr = DateUtil.formatDate((Date)fields[i].get(obj), "yyyy-MM-dd HH:mm:ss");
paramStrBuf.append("to_date(?
, 'yyyy-MM-dd HH24:mi:ss')");
paramValues.add(timeStr);
// 记录对象属性的数据类型
paramsType.add(getOrclDataType(fields[i].getType().toString()));
}else{
paramStrBuf.append("?");
paramValues.add(fields[i].get(obj));
// 记录对象属性的数据类型
paramsType.add(getOrclDataType(fields[i].getType().toString()));
}
if (i != fields.length - 1) {
paramStrBuf.append(",");
}
}
}
// 生成插入操作的SQL语句
StringBuffer sb = new StringBuffer();
sb.append("insert into ");
sb.append(tableName);
sb.append(" (");
sb.append(columnStrBuf);
sb.append(") ");
sb.append("values");
sb.append(" (");
sb.append(paramStrBuf);
sb.append(")");
// 将生成的SQL语句、SQL语句的列名称用map保存并返回
Map sqlMap = new HashMap();
/*
System.out.println(sb.toString());
System.out.println(columnNameList.toString());
System.out.println(paramValues.toString());
System.out.println(paramsType.toString());
*/
sqlMap.put("sql", sb.toString());
sqlMap.put("columnNameList", columnNameList.toArray());
sqlMap.put("paramsValues", paramValues.toArray());
sqlMap.put("paramsTypes", paramsType.toArray());
return sqlMap;
}
/**
* 自己主动生成更新指定对象的SQL语句
* @param obj 待生成更新SQL语句的对象
* @param tableName 待更新语句相应的数据库表的名称
* @param keyColumn 待更新记录的限定字段
* @return 返回一个包括SQL语句及參数值的数组
*/
public static Object[] generateUpdate(Object obj, String tableName, String keyColumn) {
StringBuffer columnSB = new StringBuffer();
List params = new ArrayList();
Object keyValue = null;
// 获取属性值不为空的数据表字段名称
List fieldList = ReflectionUtil.getNotNullField(obj);
try {
for (int i = 0; i < fieldList.size(); i++) {
Field field = (Field) fieldList.get(i);
field.setAccessible(true);
if (field.getName().equalsIgnoreCase(keyColumn)) {
keyValue = field.get(obj);
} else {
columnSB.append(field.getName());
if("class java.util.Date".equals(field.getType().toString())
&& field.get(obj) != null){
String timeStr = DateUtil.formatDate((Date)field.get(obj), "yyyy-MM-dd HH:mm:ss");
columnSB.append("=to_date(?, 'yyyy-MM-dd HH24:mi:ss')");
params.add(timeStr);
}else{
columnSB.append("=?");
params.add(field.get(obj));
}
if (i != fieldList.size() - 1) {
columnSB.append(",");
}
}
}
} catch (Exception e) {
throw new RuntimeException(e);
}
if (keyValue == null) {
throw new IllegalArgumentException("数据表 [" + tableName+ "] 中的字段'"+keyColumn+"'的值不能为空.");
}else{
params.add(keyValue);
}
StringBuffer sb = new StringBuffer();
sb.append("update ");
sb.append(tableName);
sb.append(" set ");
if(columnSB.length() >= 0){
sb.append(columnSB);
}else{
sb.append(keyColumn);
sb.append("=? ");
params.add(keyValue);
}
sb.append(" where ");
sb.append(keyColumn);
sb.append("=?
");
return new Object[] { sb.toString(), params.toArray() };
}
/**
* 返回java数据类型相应的Oracle数据库的数据类型值
* @param javaType java数据类型
* @return 返回Oracle数据表的字段数据类型
*/
public static int getOrclDataType(String javaType){
if("class java.lang.String".equals(javaType)){
return java.sql.Types.VARCHAR;
}else if("class java.lang.Integer".equals(javaType) || "int".equals(javaType)){
return java.sql.Types.INTEGER;
}else if("class java.lang.Double".equals(javaType) || "double".equals(javaType)){
return java.sql.Types.DOUBLE;
}else if("class java.lang.Float".equals(javaType) || "float".equals(javaType)){
return java.sql.Types.FLOAT;
}else if("char".equals(javaType)){
return java.sql.Types.CHAR;
}else if("class java.lang.Long".equals(javaType) || "long".equals(javaType)){
return java.sql.Types.NUMERIC;
}else if("class java.util.Date".equals(javaType)){
return java.sql.Types.DATE;
}else{
return java.sql.Types.VARCHAR;
}
}
/**
* 生成SQL语句中的where子句及where子句中參数值
* @param obj where条件子句的对象
* @return 返回条件不为空的where子句
* @throws Exception
* @throws
*/
public static Map generateWhereStr(Object obj) throws Exception{
StringBuffer whereStrBuf = new StringBuffer(); // where子句
List whereParamValues = new ArrayList(); // where子句中的參数值
whereStrBuf.append(" where 1 = 1 ");
if(obj != null){
Field[] fields = obj.getClass().getDeclaredFields();
for(int i = 0; i < fields.length; i++){
fields[i].setAccessible(true);
Object columnName = fields[i].get(obj);
if(columnName != null && !"".equals(columnName)){
whereStrBuf.append(" and ");
whereStrBuf.append(fields[i].getName());
whereStrBuf.append("=?");
whereParamValues.add(columnName);
}
}
}
Map whereMap = new HashMap();
/*System.out.println(whereStrBuf.toString());
System.out.println(whereParamValues);
*/
whereMap.put("whereStr", whereStrBuf.toString());
whereMap.put("whereParamValues", whereParamValues.toArray());
return whereMap;
}
}
(6)扩展JAVA对象的反射工具类packagecom.jkitn.jkits.util;importjava.lang.reflect.Field;importjava.util.ArrayList;importjava.util.List;/*** 说明：扩展JAVA对象的反射机制
*@authorxdweleven
*@version1.0*/
public classReflectionUtil {/*** 设置对象的指定属性名称的属性值
*@paramobj 待设置的对象
*@paramfieldName 对象属性名称
*@paramvalue 属性值*/
public static voidsetFieldValue(Object obj, String fieldName, Object value) {
Class extends Object> c =obj.getClass();try{
Field field= null;
Field[] fields=c.getDeclaredFields();for(int i = 0; i < fields.length; i++){
String fieldNameTemp=fields[i].getName();if(fieldNameTemp.equalsIgnoreCase(fieldName)){
field=c.getDeclaredField(fieldNameTemp);
field.setAccessible(true);
field.set(obj, value);return;
}
}
}catch(Exception e) {throw newRuntimeException(e);
}
}/*** 获取对象的指定属性名称的属性值
*@paramobj 待设置的对象
*@paramfieldName 对象属性名称*/
public staticObject getFieldValue(Object obj, String fieldName) {
Class extends Object> c =obj.getClass();
Field[] fields=c.getDeclaredFields();try{for(int i = 0; i < fields.length; i++){if(fields[i].getName().equalsIgnoreCase(fieldName)){
fields[i].setAccessible(true);returnfields[i].get(obj);
}
}
}catch(Exception e) {throw newRuntimeException(e);
}return null;
}/*** 获取对象的属性值不为空的属性名称
*@paramobj 待获取的对象
*@return返回属性值不为空的对象的属性名称列表*/
public static ListgetNotNullField(Object obj) {
Class extends Object> c =obj.getClass();
List list = new ArrayList();try{
Field[] fields=c.getDeclaredFields();for(int i = 0; i < fields.length; i++){
fields[i].setAccessible(true);if(fields[i].get(obj) != null){
list.add(fields[i]);
}
}
}catch(Exception e) {throw newRuntimeException(e);
}returnlist;
}
}
(7)定义实现数据库的CRUD基本操作BaseDaopackagecom.jkitn.jkits.dao.common;importjava.io.Serializable;importjava.sql.ResultSet;importjava.util.List;importjava.util.Map;importcom.jkitn.jkits.common.DBConn;importcom.jkitn.jkits.common.PageBean;importcom.jkitn.jkits.util.ReflectionUtil;importcom.jkitn.jkits.util.SQLUtil;/*** 说明：封装实现数据库的CRUD相关的底层操作。
*@authorxdweleven
*@version1.0*/
public classBaseDao{//获取数据库链接实例
private DBConn dbconn = newDBConn();/**数据库表的前缀*/
public static final String TB_PREFIX = "tb_jkit_";/**数据库表的查询前缀*/
public static final String SELECT_TB_PREFIX = "select * from tb_jkit_";/**升序排列*/
public static final String ASC = "asc";/**降序排列*/
public static final String DESC = "desc";/*** 依据ID查找对象
*@paramclassType 对象类型
*@paramcolumnName 编号字段名称
*@paramid 对象编号
*@return返回实体对象*/
public T queryById(ClassclassType, String columnName, Serializable id)throwsException{
StringBuffer sqlBuffer= newStringBuffer();
sqlBuffer.append(SELECT_TB_PREFIX);
sqlBuffer.append(this.toLowerCaseFirstOne(classType.getSimpleName()));
sqlBuffer.append(" where ");
sqlBuffer.append(columnName);
sqlBuffer.append(" = ? ");this.showSQL(sqlBuffer.toString());return dbconn.execQuery(sqlBuffer.toString(), new RowMapper(classType),new Object[]{id}).get(0);
}/*** 查询全部指定class类型的对象信息
*@paramclassType 对象类型
*@return返回实体对象列表*/
public List queryAll(Class classType) throwsException{
String sql= SELECT_TB_PREFIX + this.toLowerCaseFirstOne(classType.getSimpleName());this.showSQL(sql);return dbconn.execQuery(sql, new RowMapper(classType));
}/*** 查询指定对象类型的对象信息，并依照指定的排序字段进行升序或降序排序
*@paramclassType 对象类型
*@paramorderColumn 排序字段
*@paramascOrDesc 降序或升序:asc表示升序。desc表示降序
*@return返回实体对象列表*/
public List queryAllWithOrder(ClassclassType, String orderColumn,
String ascOrDesc)throwsException{
StringBuffer sqlBuffer= newStringBuffer();
sqlBuffer.append(SELECT_TB_PREFIX);
sqlBuffer.append(this.toLowerCaseFirstOne(classType.getSimpleName()));
sqlBuffer.append(" order by ");
sqlBuffer.append(orderColumn);
sqlBuffer.append(" ");
sqlBuffer.append(ascOrDesc);this.showSQL(sqlBuffer.toString());return dbconn.execQuery(sqlBuffer.toString(), new RowMapper(classType));
}/*** 查询指定SQL语句的对象信息列表
*@paramsql 查询语句
*@paramclassType 对象类型
*@paramparams SQL语句參数
*@return返回实体对象列表*/
public List query(String sql, ClassclassType, Object... params)throwsException{this.showSQL(sql);return dbconn.execQuery(sql, new RowMapper(classType), params);
}/*** 查询指定SQL语句的对象信息列表
*@paramsql 查询语句
*@paramclassType 对象类型
*@paramparams SQL语句參数
*@return返回实体对象列表*/
public T queryForObj(String sql, ClassclassType, Object... params)throwsException{this.showSQL(sql);return dbconn.execQuery(sql, new RowMapper(classType), params).get(0);
}/*** 分页查询实体对象列表信息
*@paramsql 原始的SQL语句
*@paramclassType 对象类型
*@paramcurPage 当前页码
*@paramrowsPerPage 每页显示的记录数
*@paramparams SQL语句參数
*@return返回当前页码的分页对象*/
public PageBean queryByPage(String sql, Class classType, intcurPage,int rowsPerPage, Object... params) throwsException{//获取记录总数
int totalRows = this.getTotalRows(sql, params);
PageBean pageBean = new PageBean();
pageBean.setCurPage(curPage);//设置当前页码
pageBean.initPageBean(totalRows, rowsPerPage); //初始化分页对象的相关属性//生成当前分页查询语句(MySql)
String pageSql =pageBean.getPageMySQL(sql, curPage, rowsPerPage);this.showSQL(pageSql);//运行查询操作
pageBean.setPageList(dbconn.execQuery(sql, new RowMapper(classType), params));returnpageBean;
}/*** 保存对象到数据库中，若数据库中的用户表有自增序列，则须要指出表中自增列的字段名称，另外，
* 数据库中相应的自增序列的名称需按例如以下格式取名：class名称_自增列字段名称_SEQ,
* 比如用户的class为Users，自增序列字段名称为id，则数据库中的自增序列的名称取名为USERS_ID_SEQ.
*@paramobj 实体对象
*@paramsequenceKeyColumn 数据表自增序列的字段名称，若不存在。则置为null。
*@return返回被更新的记录数
*@throwsIllegalAccessException
*@throwsIllegalArgumentException*/
public int insert(T obj, String sequenceKeyColumn) throwsException{
String tableName= TB_PREFIX + this.toLowerCaseFirstOne(obj.getClass().getSimpleName());//自己主动生成对象的无自增序列插入SQL语句及其相关插入的參数值和类型
Map sqlMap =SQLUtil.generateInsertWithNull(obj, tableName, sequenceKeyColumn);
String sql= sqlMap.get("sql").toString(); //SQL语句
Object[] paramsValues = (Object[])sqlMap.get("paramsValues"); //SQL语句的參数值//int[] paramsTypes = this.parseArrayToInt((Object[])sqlMap.get("paramsTypes"));//參数值类型
this.showSQL(sql);returndbconn.execUpdate(sql, paramsValues);
}/*** 更新对象
*@paramobj 待更新的实体对象
*@paramkeyColumn 更新对象的限定条件字段名称
*@return返回被更新的记录数*/
public int update(T obj, String keyColumn) throwsException{
String tableName= TB_PREFIX + this.toLowerCaseFirstOne(obj.getClass().getSimpleName());//自己主动生成对象的更新操作的SQL语句及其參数值
Object[] updateSql =SQLUtil.generateUpdate(obj, tableName, keyColumn);this.showSQL(updateSql[0].toString());return dbconn.execUpdate(updateSql[0].toString(), (Object[])updateSql[1]);
}/*** 删除对象
*@paramobj 待更新的实体对象
*@paramkeyColumn 删除的限定条件字段
*@return返回被删除的记录数*/
public int delete(T obj, String keyColumn) throwsException{//获取限定条件的值
Object keyValue =ReflectionUtil.getFieldValue(obj, keyColumn);if(keyValue == null){throw new RuntimeException("["+obj.getClass()+"]中不存在属性'"+keyColumn+"'或属性值为空.");
}
StringBuffer sqlBuffer= newStringBuffer();
sqlBuffer.append("delete from ");
sqlBuffer.append(TB_PREFIX);
sqlBuffer.append(this.toLowerCaseFirstOne(obj.getClass().getSimpleName()));
sqlBuffer.append(" where ");
sqlBuffer.append(keyColumn);
sqlBuffer.append(" = ? ");this.showSQL(sqlBuffer.toString());returndbconn.execUpdate(sqlBuffer.toString(), keyValue.toString());
}/*** 删除指定编号的实体对象
*@paramclassType 对象类型
*@paramkeyColumn ID相应的数据表列名称
*@paramid 实体对象编号
*@return返回删除的记录数*/
public int deleteById(ClassclassType, String keyColumn, Serializable id)throwsException{
StringBuffer sqlBuffer= newStringBuffer();
sqlBuffer.append("delete from ");
sqlBuffer.append(TB_PREFIX);
sqlBuffer.append(this.toLowerCaseFirstOne(classType.getSimpleName()));
sqlBuffer.append(" where ");
sqlBuffer.append(keyColumn);
sqlBuffer.append(" = ? ");this.showSQL(sqlBuffer.toString());returndbconn.execUpdate(sqlBuffer.toString(), id);
}/*** 批量删除指定编号的实体对象
*@paramclassType 对象类型
*@paramidColumnName 编号字段名称
*@paramids 待删除对象的编号数组*/
public int deleteByIds(ClassclassType, String idColumnName,
Serializable[] ids)throwsException{
StringBuffer sqlBuffer= newStringBuffer();
sqlBuffer.append("delete from ");
sqlBuffer.append(TB_PREFIX);
sqlBuffer.append(this.toLowerCaseFirstOne(classType.getSimpleName()));
sqlBuffer.append(" where ");
sqlBuffer.append(idColumnName);
sqlBuffer.append(" = ? ");this.showSQL(sqlBuffer.toString());int rowNums = 0; //删除的记录数
for(int i = 0; i < ids.length; i++){
rowNums+= this.deleteById(classType, idColumnName, ids[i]);
}returnrowNums;
}/*** 更新操作
*@paramsql 删除操作的SQL语句
*@paramparams SQL语句中的參数值
*@return返回删除的记录数*/
public int update(String sql, Object... params) throwsException{this.showSQL(sql);returndbconn.execUpdate(sql, params);
}/*** 批量更新对象
*@paramobjs 待更新的实体对象列表
*@paramkeyColumn 主键字段名称*/
public int batchUpdate(List objs, String keyColumn) throwsException{if(objs == null ||objs.isEmpty()){return 0;
}int updateNum = 0;//自己主动生成对象的更新操作的SQL语句及其參数值
for(int i = 0; i < objs.size(); i++){
T obj=objs.get(i);
updateNum+= this.update(obj, keyColumn);
}returnupdateNum;
}/*** 批量插入对象
*@paramobjs 待新增的实体对象列表
*@paramkeyColumn 数据表主键列名称
*@throwsIllegalAccessException
*@throwsIllegalArgumentException*/
public int batchInsert(List objs, String keyColumn) throwsException {if(objs == null ||objs.isEmpty()){return 0;
}int updateNum = 0;//自己主动生成对象的更新操作的SQL语句及其參数值
for(int i = 0; i < objs.size(); i++){
T obj=objs.get(i);
updateNum+= this.insert(obj, keyColumn);
}returnupdateNum;
}/*** 统计指定统计数量的SQL语句
*@paramsql 待运行的SQL语句
*@paramparams SQL语句參数值
*@return返回记录总数
*@throwsException*/
public int getTotalRows(String sql, Object... params) throwsException{
String totalRowsSql= "select count(*) totalRows from ( "+sql+" )";this.showSQL(totalRowsSql);
ResultSet rs=dbconn.queryForResultSet(totalRowsSql, params);while(rs.next()){return rs.getInt("totalRows");
}return 0;
}/*** 删除操作
*@paramsql 删除操作的SQL语句
*@paramparams SQL语句中的參数值
*@return返回删除的记录数*/
public int delete(String sql, Object... params) throwsException{this.showSQL(sql);returndbconn.execUpdate(sql, params);
}/*** 获取下一个指定自增序列的值(MySql)
*@paramclassType 对象类型
*@paramseqColName 自增字段名称
*@return返回指定表的主键自增序列的最新值*/
public int getNextAutoIncrementVal(Class classType, String seqColName) throwsException{
StringBuffer sqlBuf= newStringBuffer();
sqlBuf.append("select max(");
sqlBuf.append(seqColName);
sqlBuf.append(")+1 nextId from ");
sqlBuf.append(TB_PREFIX);
sqlBuf.append(this.toLowerCaseFirstOne(classType.getSimpleName()));this.showSQL(sqlBuf.toString());
ResultSet rs=dbconn.queryForResultSet(sqlBuf.toString());if(rs.next()){return rs.getInt("nextId");
}else{return 0;
}
}/*** 首字母转小写
*@paramstr 待转换的字符创
*@return返回首字母小写后的字符串*/
publicString toLowerCaseFirstOne(String str){if(Character.isLowerCase(str.charAt(0))){returnstr;
}else{return (new StringBuilder()).append(Character.toLowerCase(str.charAt(0))).
append(str.substring(1)).toString();
}
}/*** 首字母转大写
*@paramstr 待转换的字符串
*@return返回首字母大写的字符串*/
publicString toUpperCaseFirstOne(String str){if(Character.isUpperCase(str.charAt(0))){returnstr;
}else{return (new StringBuilder()).append(Character.toUpperCase(str.charAt(0))).
append(str.substring(1)).toString();
}
}/*** 打印SQL语句
*@paramsql*/
public voidshowSQL(String sql){
System.out.println(sql);
}
}
5055
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
