java实现dao层基本crud操作_JAVA实现DAO基本层CRUD操作（转）

傷城~ 2022-11-03 04:09 269阅读 0赞

以下详细讲讲通过我自己的方式对有关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);

java实现dao层基本crud操作_JAVA实现DAO基本层CRUD操作（转）

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Mybatis实现接口自动生成实现类完成Dao层CRUD操作-----Mybatis框架

相关使用MyBatisPlus实现基本的CRUD操作

相关 dao层(dao层的作用)

相关 Mybatis 传统 DAO 层实现CRUD

相关 Mybatis 代理DAO实现CRUD操作、模糊查询实现

相关 Elasticsearch 基本CRUD操作

相关 java实现dao层基本crud操作_JAVA实现DAO基本层CRUD操作（转）

相关 mongodb基本操作（CRUD）

相关 dao实现层继承 HibernateDaoSupport对数据表进行操作

相关 MyBatis 实现基本CRUD操作