Spring-JDBC通用Dao
JdbcBaseDao
JdbcBaseDao接口，内容如下：
package com.sun4j.core.jdbc.dao;
import java.io.Serializable;
import java.util.List;
import java.util.Map;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.support.rowset.SqlRowSet;
public interface JdbcBaseDao<T> {
void save(T entity);
void update(T entity);
void delete(T entity);
void delete(Serializable id);
void deleteAll();
T findById(Serializable id);
List<T> findAll();
void batchDelete(Serializable[] ids);
void batchUpdate(List<T> list);
void batchSave(List<T> list);
Map<String, Object> findOne(String sql, Object... args);
List<Map<String, Object>> findListMap(String sql, Object... args);
void execSQL(String sql);
SqlRowSet rowSet(String sql, Object... args);
JdbcTemplate getJdbcTemplate();
}
JdbcBaseDaoImpl 实现
JdbcBaseDao接口，内容如下：
package com.sun4j.core.jdbc.dao.impl;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.sql.Types;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.support.rowset.SqlRowSet;
import org.springframework.util.Assert;
import com.sun4j.core.jdbc.dao.JdbcBaseDao;
public class JdbcBaseDaoImpl<T> implements JdbcBaseDao<T> {
public static final String SQL_INSERT = "insert";
public static final String SQL_UPDATE = "update";
public static final String SQL_DELETE = "delete";
@Autowired
private JdbcTemplate jdbcTemplate;
private Class<T> entityClass;
@SuppressWarnings("unchecked")
public JdbcBaseDaoImpl() {
ParameterizedType type = (ParameterizedType) getClass().getGenericSuperclass();
entityClass = (Class<T>) type.getActualTypeArguments()[0];
System.out.println("Dao实现类是：" + entityClass.getName());
}
@Override
public void save(T entity) {
String sql = this.makeSql(SQL_INSERT);
Object[] args = this.setArgs(entity, SQL_INSERT);
int[] argTypes = this.setArgTypes(entity, SQL_INSERT);
jdbcTemplate.update(sql.toString(), args, argTypes);
}
@Override
public void update(T entity) {
String sql = this.makeSql(SQL_UPDATE);
Object[] args = this.setArgs(entity, SQL_UPDATE);
int[] argTypes = this.setArgTypes(entity, SQL_UPDATE);
jdbcTemplate.update(sql, args, argTypes);
}
@Override
public void delete(T entity) {
String sql = this.makeSql(SQL_DELETE);
Object[] args = this.setArgs(entity, SQL_DELETE);
int[] argTypes = this.setArgTypes(entity, SQL_DELETE);
jdbcTemplate.update(sql, args, argTypes);
}
@Override
public void deleteAll() {
String sql = " TRUNCATE TABLE " + entityClass.getSimpleName();
jdbcTemplate.execute(sql);
}
@Override
public void delete(Serializable id) {
String sql = " DELETE FROM " + entityClass.getSimpleName() + " WHERE id=?";
jdbcTemplate.update(sql, id);
}
@Override
public void batchSave(List<T> lt) {
Assert.notEmpty(lt);
StringBuilder sb = new StringBuilder();
sb.append("insert into ").append(entityClass.getSimpleName().toLowerCase()).append("( ");
List<Object[]> params = new ArrayList<Object[]>();
String val = "";
for (T t : lt) {
int index = 0;
Field[] fields = t.getClass().getDeclaredFields();
if (fields != null && fields.length > 0) {
Object[] objVal = new Object[fields.length];
for (Field field : fields) {
try {
field.setAccessible(true);
Object obj = field.get(t);
if (params.size() == 0) {
sb.append(field.getName()).append(" ,");
val += ", ? ";
}
objVal[index++] = obj;
} catch (Exception e) {
e.printStackTrace();
}
}
params.add(objVal);
}
}
sb.deleteCharAt(sb.length() - 1);
val = val.substring(1);
sb.append(") value (").append(val).append(")");
String sql = sb.toString();
jdbcTemplate.batchUpdate(sql, params);
}
@Override
public void batchUpdate(List<T> lt) {
Assert.notEmpty(lt);
StringBuilder sb = new StringBuilder();
sb.append("update ").append(entityClass.getSimpleName().toLowerCase()).append(" set ");
List<Object[]> params = new ArrayList<Object[]>();
Object primaryKey = "id";
for (T t : lt) {
int index = 0;
Field[] fields = entityClass.getDeclaredFields();
if (fields != null && fields.length > 0) {
Object id = null;
Object[] objVal = new Object[fields.length];
for (Field field : fields) {
try {
field.setAccessible(true);
Object obj = field.get(t);
if (field.getName().equalsIgnoreCase("id")) {
primaryKey = obj;
id = obj;
} else {
if (params.size() == 0) {
sb.append(field.getName()).append(" = ? ,");
}
objVal[index++] = obj;
}
} catch (Exception e) {
e.printStackTrace();
}
objVal[index] = id;
}
params.add(objVal);
}
}
sb.deleteCharAt(sb.length() - 1);
sb.append(" where ").append(primaryKey).append(" = ? ");
String sql = sb.toString();
jdbcTemplate.batchUpdate(sql, params);
}
@Override
public T findById(Serializable id) {
String sql = "SELECT * FROM " + entityClass.getSimpleName() + " WHERE id=?";
RowMapper<T> rowMapper = BeanPropertyRowMapper.newInstance(entityClass);
return jdbcTemplate.query(sql, rowMapper, id).get(0);
}
@Override
public List<T> findAll() {
String sql = "SELECT * FROM " + entityClass.getSimpleName();
RowMapper<T> rowMapper = BeanPropertyRowMapper.newInstance(entityClass);
return jdbcTemplate.query(sql, rowMapper);
}
@Override
public Map<String, Object> findOne(String sql, Object... args) {
return jdbcTemplate.queryForMap(sql, args);
}
@Override
public List<Map<String, Object>> findListMap(String sql, Object... args) {
return jdbcTemplate.queryForList(sql, args);
}
@Override
public void execSQL(String sql) {
jdbcTemplate.execute(sql);
}
@Override
public SqlRowSet rowSet(String sql, Object... args) {
return this.jdbcTemplate.queryForRowSet(sql, args);
}
@Override
public JdbcTemplate getJdbcTemplate() {
return jdbcTemplate;
}
/**
* 组装SQl
*
* @param entityClass
* @param sqlFlag
* @return
*/
public String makeSql(String sqlFlag) {
StringBuffer sql = new StringBuffer();
Field[] fields = entityClass.getDeclaredFields();
if (sqlFlag.equals(SQL_INSERT)) {
sql.append(" INSERT INTO " + entityClass.getSimpleName());
sql.append("(");
for (int i = 0; fields != null && i < fields.length; i++) {
fields[i].setAccessible(true); // 暴力反射
String column = fields[i].getName();
sql.append(column).append(",");
}
sql = sql.deleteCharAt(sql.length() - 1);
sql.append(") VALUES (");
for (int i = 0; fields != null && i < fields.length; i++) {
sql.append("?,");
}
sql = sql.deleteCharAt(sql.length() - 1);
sql.append(")");
} else if (sqlFlag.equals(SQL_UPDATE)) {
sql.append(" UPDATE " + entityClass.getSimpleName() + " SET ");
for (int i = 0; fields != null && i < fields.length; i++) {
fields[i].setAccessible(true); // 暴力反射
String column = fields[i].getName();
if (column.equals("id")) { // id 代表主键
continue;
}
sql.append(column).append("=").append("?,");
}
sql = sql.deleteCharAt(sql.length() - 1);
sql.append(" WHERE id=?");
} else if (sqlFlag.equals(SQL_DELETE)) {
sql.append(" DELETE FROM " + entityClass.getSimpleName() + " WHERE id=?");
}
System.out.println("SQL=" + sql);
return sql.toString();
}
/**
* 设置参数
*
* @param entity
* @param sqlFlag
* @param entityClass
* @return
*/
public Object[] setArgs(T entity, String sqlFlag) {
Field[] fields = entityClass.getDeclaredFields();
if (sqlFlag.equals(SQL_INSERT)) {
Object[] args = new Object[fields.length];
for (int i = 0; args != null && i < args.length; i++) {
try {
fields[i].setAccessible(true); // 暴力反射
args[i] = fields[i].get(entity);
} catch (Exception e) {
e.printStackTrace();
}
}
return args;
} else if (sqlFlag.equals(SQL_UPDATE)) {
Object[] tempArr = new Object[fields.length];
for (int i = 0; tempArr != null && i < tempArr.length; i++) {
try {
fields[i].setAccessible(true); // 暴力反射
tempArr[i] = fields[i].get(entity);
} catch (Exception e) {
e.printStackTrace();
}
}
Object[] args = new Object[fields.length];
System.arraycopy(tempArr, 1, args, 0, tempArr.length - 1); // 数组拷贝
args[args.length - 1] = tempArr[0];
return args;
} else if (sqlFlag.equals(SQL_DELETE)) {
Object[] args = new Object[1]; // 长度是1
fields[0].setAccessible(true); // 暴力反射
try {
args[0] = fields[0].get(entity);
} catch (Exception e) {
e.printStackTrace();
}
return args;
}
return null;
}
/**
* 设置参数类型（写的不全，只是一些常用的）
*
* @param entity
* @param sqlFlag
* @param entityClass
* @return
*/
public int[] setArgTypes(T entity, String sqlFlag) {
Field[] fields = entityClass.getDeclaredFields();
if (sqlFlag.equals(SQL_INSERT)) {
int[] argTypes = new int[fields.length];
try {
for (int i = 0; argTypes != null && i < argTypes.length; i++) {
fields[i].setAccessible(true); // 暴力反射
if (fields[i].get(entity).getClass().getName().equals("java.lang.String")) {
argTypes[i] = Types.VARCHAR;
} else if (fields[i].get(entity).getClass().getName().equals("java.lang.Double")) {
argTypes[i] = Types.DECIMAL;
} else if (fields[i].get(entity).getClass().getName().equals("java.lang.Integer")) {
argTypes[i] = Types.INTEGER;
} else if (fields[i].get(entity).getClass().getName().equals("java.util.Date")) {
argTypes[i] = Types.DATE;
}
}
} catch (Exception e) {
e.printStackTrace();
}
return argTypes;
} else if (sqlFlag.equals(SQL_UPDATE)) {
int[] tempArgTypes = new int[fields.length];
int[] argTypes = new int[fields.length];
try {
for (int i = 0; tempArgTypes != null && i < tempArgTypes.length; i++) {
fields[i].setAccessible(true); // 暴力反射
if (fields[i].get(entity).getClass().getName().equals("java.lang.String")) {
tempArgTypes[i] = Types.VARCHAR;
} else if (fields[i].get(entity).getClass().getName().equals("java.lang.Double")) {
tempArgTypes[i] = Types.DECIMAL;
} else if (fields[i].get(entity).getClass().getName().equals("java.lang.Integer")) {
tempArgTypes[i] = Types.INTEGER;
} else if (fields[i].get(entity).getClass().getName().equals("java.util.Date")) {
tempArgTypes[i] = Types.DATE;
}
}
System.arraycopy(tempArgTypes, 1, argTypes, 0, tempArgTypes.length - 1); // 数组拷贝
argTypes[argTypes.length - 1] = tempArgTypes[0];
} catch (Exception e) {
e.printStackTrace();
}
return argTypes;
} else if (sqlFlag.equals(SQL_DELETE)) {
int[] argTypes = new int[1]; // 长度是1
try {
fields[0].setAccessible(true); // 暴力反射
if (fields[0].get(entity).getClass().getName().equals("java.lang.String")) {
argTypes[0] = Types.VARCHAR;
} else if (fields[0].get(entity).getClass().getName().equals("java.lang.Integer")) {
argTypes[0] = Types.INTEGER;
}
} catch (Exception e) {
e.printStackTrace();
}
return argTypes;
}
return null;
}
@Override
public void batchDelete(Serializable[] ids) {
String idStr="";
for (int i = 0; i < ids.length; i++) {
idStr+=",'"+ids[i]+"'";
}
String sql = " DELETE FROM " + entityClass.getSimpleName() + " WHERE id in (?)";
jdbcTemplate.update(sql, idStr.charAt(1));
}
}
通用的JdbcBaseService
package com.sun4j.core.jdbc.service;
import java.io.Serializable;
import java.util.List;
import java.util.Map;
public interface JdbcBaseService<T> {
void save(T entity);
void update(T entity);
void delete(T entity);
void delete(Serializable id);
void deleteAll();
T findById(Serializable id);
List<T> findAll();
void batchDelete(Serializable[] ids);
void batchUpdate(List<T> list);
void batchSave(List<T> list);
Map<String, Object> findOne(Object... args);
List<Map<String, Object>> findListMap(Object... args);
}
通用的JdbcBaseService实现
package com.sun4j.core.jdbc.service.impl;
import java.io.Serializable;
import java.util.List;
import java.util.Map;
import com.sun4j.core.jdbc.dao.JdbcBaseDao;
import com.sun4j.core.jdbc.service.JdbcBaseService;
public abstract class JdbcBaseServiceImpl<T> implements JdbcBaseService<T> {
protected abstract JdbcBaseDao<T> jdbcDao();
@Override
public void save(T entity) {
jdbcDao().save(entity);
}
@Override
public void update(T entity) {
jdbcDao().update(entity);
}
@Override
public void delete(T entity) {
jdbcDao().delete(entity);
}
@Override
public void delete(Serializable id) {
jdbcDao().delete(id);
}
@Override
public void deleteAll() {
jdbcDao().deleteAll();
}
@Override
public T findById(Serializable id) {
return jdbcDao().findById(id);
}
@Override
public List<T> findAll() {
return jdbcDao().findAll();
}
@Override
public void batchDelete(Serializable[] ids) {
jdbcDao().batchDelete(ids);
}
@Override
public void batchUpdate(List<T> list) {
jdbcDao().batchUpdate(list);
}
@Override
public void batchSave(List<T> list) {
jdbcDao().batchSave(list);
}
@Override
public abstract Map<String, Object> findOne(Object... args);
@Override
public abstract List<Map<String, Object>> findListMap(Object... args);
}
Spring-JDBC通用Dao的更多相关文章
- spring基于通用Dao的多数据源配置详解【ds1】
spring基于通用Dao的多数据源配置详解 有时候在一个项目中会连接多个数据库,需要在spring中配置多个数据源,最近就遇到了这个问题,由于我的项目之前是基于通用Dao的,配置的时候问题不断,这种 ...
- spring基于通用Dao的多数据源配置
有时候在一个项目中会连接多个数据库,须要在spring中配置多个数据源,近期就遇到了这个问题,因为我的项目之前是基于通用Dao的,配置的时候问题不断.这样的方式和资源文件冲突:扫描映射文件的话,Sql ...
- spring+mybatis通用dao层、service层的实现
个人理解: 1.mybatis-spring.jar 提供了SqlSessionTemplate类该类可以对数据库进行CRUD操作(底层其实还是SqlSession) 2.我们可以集成SqlSessi ...
- JDBC通用DAO
dbcBaseDao接口,内容如下: package com.sun4j.core.jdbc.dao; import java.io.Serializable; import java.util.Li ...
- Spring DAO vs Spring ORM vs Spring JDBC
Pat 的疑惑 最近关注于 Spring 提供的数据访问技术,对于 Spring 相关的这几个项目有何不同我不是太明白: Spring-DAO (http://docs.spring.io/sprin ...
- Java反射结合JDBC写的一个通用DAO
以前写反射只是用在了与设计模式的结合上,并没有考虑到反射可以与DAO结合.也是一个偶然的机会,被正在上培训的老师点到这个问题,才考虑到这个可能性,于是上网参考各种代码,然后自己动手开发了一个通用DAO ...
- Spring Boot-------JPA——EntityManager构建通用DAO
EntityManager EntityManager 是用来对实体Bean 进行操作的辅助类.他可以用来产生/删除持久化的实体Bean,通过主键查找实体bean,也可以通过EJB3 QL 语言查找满 ...
- spring jdbc 查询结果返回对象、对象列表
首先,需要了解spring jdbc查询时,有三种回调方式来处理查询的结果集.可以参考 使用spring的JdbcTemplate进行查询的三种回调方式的比较,写得还不错. 1.返回对象(queryF ...
- Spring学习进阶（四） Spring JDBC
Spring JDBC是Spring所提供的持久层技术.主要目的是降低使用JDBC API的门槛,以一种更直接,更简洁的方式使用JDBC API.在Spring JDBC里用户仅需要做哪些比不可少的事 ...
- Spring JDBC 访问MSSQL
在Spring中对底层的JDBC做了浅层的封装即JdbcTemplate,在访问数据库的DAO层完全可以使用JdbcTemplate完成任何数据访问的操作,接下来我们重点说说Spring JDBC对S ...
随机推荐
- BestCoder12 1001.So easy(hdu 5058) 解题报告
题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=5058 (格式有点问题,为了方便阅读---整个复制下来吧) 题目意思:给出两个长度都为 n 的集合你,问 ...
- js将map转成数组
//根据资源的ID去查找 this.classArray = []; for(var c in this.comboData.classId){ this.classArray.push({ text ...
- 《Algorithms算法》笔记：优先队列(2)——二叉堆
二叉堆 1 二叉堆的定义 堆是一个完全二叉树结构(除了最底下一层,其他层全是完全平衡的),如果每个结点都大于它的两个孩子,那么这个堆是有序的. 二叉堆是一组能够用堆有序的完全二叉树排序的元素,并在数组 ...
- Hadoop入门经典:WordCount
转:http://blog.csdn.net/jediael_lu/article/details/38705371 以下程序在hadoop1.2.1上测试成功. 本例先将源代码呈现,然后详细说明执行 ...
- spring的IOC和AOP
spring的IOC和AOP 1.解释spring的ioc? 几种注入依赖的方式?spring的优点? IOC你就认为他是一个生产和管理bean的容器就行了,原来需要在调用类中new的东西,现在都是 ...
- C# Winform 文件编码批量转换工具
在发布产品程序包时,往往需要对程序文件进行编码检查,写了一个可以批量修改文件编码格式的辅助工具,希望对有同样需求的童鞋有帮助. 1.程序界面: 2.核心代码: /// <summary> ...
- Java Hour 55 Spring Framework 2
上一章节估计被官方的说明文档扯晕了,其实说白了不就是个IOC 注入的容器么,用过了微软Enterprise Library 的Unity 的我还会怕这个.自己随便写个demo, 将知识的主题框架先构建 ...
- IntelliJ下使用Code/Live Template加快编码速度：程序员的工作不是写程序，而是写程序解决问题
程序员的工作不是写程序,而是写程序解决问题. --- 某不知名程序员 我们每天都在写代码,有些代码有结构性的相似,但不是所有的代码都可以被抽成方法.在这种情况下,我们应该考虑使用template的方式 ...
- 抓包工具Fiddler的使用
Fiddler 教程 Fiddler是最强大最好用的Web调试工具之一,它能记录所有客户端和服务器的http和https请求,允许你监视,设置断点,甚至修改输入输出数据. 使用Fiddler无论对开发 ...
- SU suphasevel命令学习