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 ...
随机推荐
- 5.python（迭代器，装饰器，生成器，基本算法，正则）
一,迭代器 1.迭代器 (1)迭代器是访问集合元素的一种方式.迭代器对象从集合的第一个元素开始访问,知道所有的元素被访问完结束.迭代器只能往前不会后退. (2)对于原生支持随机访问的数据结构(如t ...
- [Linux] Linux进程PID散列表
linux系统中每个进程由一个进程id标识,在内核中对应一个task_struct结构的进程描述符,系统中所有进程的task_struct通过链表链接在一起,在内核中,经常需要通过进程id来获取进程描 ...
- svn 文件夹 无法提交
[root@v01 www]# svn add localsvn/kkk/ svn: warning: 'localsvn/kkk' is already under version control ...
- InnoDB引擎的索引和存储结构
在Oracle 和SQL Server等数据库中只有一种存储引擎,所有数据存储管理机制都是一样的.而MySql数据库提供了多种存储引擎.用户可以根据不同的需求为数据表选择不同的存储引擎,用户也可以根据 ...
- CI中PHP写法规范(不断更新)
1.类名首字母大写,多个单词用下划线连接,首字母小写是无效的 举例: class CI_Model 2.routes路由配置中的右侧在配置类名和方法名的时候都是小写,如果大写可能会出现404找不到的错 ...
- lucene 搜索引擎使用案例
1.使用定时框架Quartz.Net创建索引库,引用类库文件有Common.Logging.dll.Lucene.Net.dll,PanGu.dll,PanGu.HighLight.dll,PanGu ...
- ytu 2002:C语言实验——单词统计（水题）
C语言实验——单词统计 Time Limit: 1 Sec Memory Limit: 64 MBSubmit: 61 Solved: 34[Submit][Status][Web Board] ...
- Java Hour3
有句名言,叫做10000小时成为某一个领域的专家.姑且不辩论这句话是否正确,让我们到达10000小时的时候再回头来看吧. 本文作者Java 现经验约为2 Hour,请各位不吝赐教. Hour3 包和i ...
- oracle的启动过程（各个模式启动）
启动模式详解 1.NoMount 模式(启动实例不加载数据库) 命令:startup nomount 讲解:这种启动模式只会创建实例,并不加载数据库,Oracle仅为实例创建各种内存结构和服务进程,不 ...
- C语言标量类型(转)
在C语言中,枚举类型.字符型和各种整数的表示形式统一叫做标量类型. 当在C表达式中使用标量类型的值时,编译器就会自动将这些标识符转换为整数保存. 这种机制的作用是,在这些标量类型上执行的操作与整型上执 ...