1、泛型DAO接口定义
import java.io.Serializable;
import java.util.List;
/**
* GenericDao DAO层泛型接口，定义基本的DAO功能
* @author wl
* @since 0.1
* @param <T> 实体类
* @param <PK> 主键类，必须实现Serializable接口
*
* @see com.thinkon.commons.dao.GenericIbatisDao
*/
public abstract interface GenericDao<T, PK extends Serializable> {
/**
* 插入一个实体（在数据库INSERT一条记录）
* @param entity 实体对象
*/
public abstract void insert(T entity);
/**
* 修改一个实体对象（UPDATE一条记录）
* @param entity 实体对象
* @return 修改的对象个数，正常情况=1
*/
public abstract int update(T entity);
/**
* 修改符合条件的记录
* <p>此方法特别适合于一次性把多条记录的某些字段值设置为新值（定值）的情况，比如修改符合条件的记录的状态字段</p>
* <p>此方法的另一个用途是把一条记录的个别字段的值修改为新值（定值），此时要把条件设置为该记录的主键</p>
* @param param 用于产生SQL的参数值，包括WHERE条件、目标字段和新值等
* @return 修改的记录个数，用于判断修改是否成功
*/
public abstract int update(DynamicSqlParameter param);
/**
* 按主键删除记录
* @param primaryKey 主键对象
* @return 删除的对象个数，正常情况=1
*/
public abstract int delete(PK primaryKey);
/**
* 删除符合条件的记录
* <p><strong>此方法一定要慎用，如果条件设置不当，可能会删除有用的记录！</strong></p>
* @param param 用于产生SQL的参数值，包括WHERE条件（其他参数内容不起作用）
* @return
*/
public abstract int delete(DynamicSqlParameter param);
/**
* 清空表，比delete具有更高的效率，而且是从数据库中物理删除（delete是逻辑删除，被删除的记录依然占有空间）
* <p><strong>此方法一定要慎用！</strong></p>
* @return
*/
public abstract int truncate();
/**
* 查询整表总记录数
* @return 整表总记录数
*/
public abstract int count();
/**
* 查询符合条件的记录数
* @param param 查询条件参数，包括WHERE条件（其他参数内容不起作用）。此参数设置为null，则相当于count()
* @return
*/
public abstract int count(DynamicSqlParameter param);
/**
* 按主键取记录
* @param primaryKey 主键值
* @return 记录实体对象，如果没有符合主键条件的记录，则返回null
*/
public abstract T get(PK primaryKey);
/**
* 按主键取记录
* @param primaryKey 主键值
* @return 记录实体对象，如果没有符合主键条件的记录，则 throw DataAccessException
*/
public abstract T load(PK primaryKey) throws DataAccessException;
/**
* 取全部记录
* @return 全部记录实体对象的List
*/
public abstract List<T> select();
/**
* 按条件查询记录
* @param param 查询条件参数，包括WHERE条件、分页条件、排序条件
* @return 符合条件记录的实体对象的List
*/
public abstract List<T> select(DynamicSqlParameter param);
/**
* 按条件查询记录，并处理成分页结果
* @param param 查询条件参数，包括WHERE条件、分页条件、排序条件
* @return PaginationResult对象，包括（符合条件的）总记录数、页实体对象List等
*/
public abstract PaginationResult<T> selectPagination(DynamicSqlParameter param);
/**
* 按条件查询记录，并把有外键关联的字段的关联对象也处理出来
* <p>此方法是为了避免1+N而设置的</p>
* @param param 查询条件参数，包括WHERE条件、分页条件、排序条件<strong>（不包括外键关联表条件）</strong>
* @return 符合条件记录的实体对象的List
*/
public abstract List<T> selectFk(DynamicSqlParameter param);
/**
* 按条件查询记录，并把有外键关联的字段的关联对象也处理出来，并处理成分页结果
* <p>此方法是为了避免1+N而设置的</p>
* @param param 查询条件参数，包括WHERE条件、分页条件、排序条件<strong>（不包括外键关联表条件）</strong>
* @return PaginationResult对象，包括（符合条件的）总记录数、页实体对象List等
*/
public abstract PaginationResult<T> selectFkPagination(DynamicSqlParameter param);
/**
* 批量插入
* @param list
*/
public abstract void batchInsert(final List<T> list);
/**
* 批量修改
* @param list
*/
public abstract void batchUpdate(final List<T> list);
/**
* 批量删除
* @param list
*/
public abstract void batchDelete(final List<PK> list);
}
2、泛型接口的实现类（其他DAO的基类），以iBatis实现：
import java.io.Serializable;
import java.sql.SQLException;
import java.util.List;
import org.springframework.orm.ibatis.SqlMapClientCallback;
import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;
import com.ibatis.sqlmap.client.SqlMapExecutor;
/**
* iBatis DAO层泛型基类，实现了基本的DAO功能 利用了Spring的DaoSupport功能
*
* @author wl
* @since 0.1
* @param <T>
* 实体类
* @param <PK>
* 主键类，必须实现Serializable接口
*
* @see com.thinkon.commons.dao.GenericDao
* @see org.springframework.orm.ibatis.support.SqlMapClientDaoSupport
*/
public abstract class GenericIbatisDao<T, PK extends Serializable> extends
SqlMapClientDaoSupport implements GenericDao<T, PK> {
// sqlmap.xml定义文件中对应的sqlid
public static final String SQLID_INSERT = "insert";
public static final String SQLID_UPDATE = "update";
public static final String SQLID_UPDATE_PARAM = "updateParam";
public static final String SQLID_DELETE = "delete";
public static final String SQLID_DELETE_PARAM = "deleteParam";
public static final String SQLID_TRUNCATE = "truncate";
public static final String SQLID_SELECT = "select";
public static final String SQLID_SELECT_PK = "selectPk";
public static final String SQLID_SELECT_PARAM = "selectParam";
public static final String SQLID_SELECT_FK = "selectFk";
public static final String SQLID_COUNT = "count";
public static final String SQLID_COUNT_PARAM = "countParam";
private String sqlmapNamespace = "";
/**
* sqlmapNamespace，对应sqlmap.xml中的命名空间
*
* @return
*/
public String getSqlmapNamespace() {
return sqlmapNamespace;
}
/**
* sqlmapNamespace的设置方法，可以用于spring注入
*
* @param sqlmapNamespace
*/
public void setSqlmapNamespace(String sqlmapNamespace) {
this.sqlmapNamespace = sqlmapNamespace;
}
/**
* 数据库方言，缺省为MYSQL
*/
private String dbDialect = "MYSQL";
/**
* 数据库方言dbDialect的get方法
*
* @return
*/
public String getDbDialect() {
return dbDialect;
}
/**
* 数据库方言dbDialect的set方法
*
* @return
*/
public void setDbDialect(String dbDialect) {
if (dbDialect == null
|| (!dbDialect.equals("MYSQL") && !dbDialect.equals("ORACLE")))
throw new DaoException("错误的数据库方言设置：本系统只支持MYSQL和ORACLE");
this.dbDialect = dbDialect;
}
public int count() {
Integer count = (Integer) getSqlMapClientTemplate().queryForObject(
sqlmapNamespace + "." + SQLID_COUNT);
return count.intValue();
}
public int count(DynamicSqlParameter param) {
Integer count = (Integer) getSqlMapClientTemplate().queryForObject(
sqlmapNamespace + "." + SQLID_COUNT_PARAM, param);
return count.intValue();
}
public int delete(PK primaryKey) {
int rows = getSqlMapClientTemplate().delete(
sqlmapNamespace + "." + SQLID_DELETE, primaryKey);
try {
getSqlMapClientTemplate().getSqlMapClient().startBatch();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return rows;
}
public int delete(DynamicSqlParameter param) {
int rows = getSqlMapClientTemplate().delete(
sqlmapNamespace + "." + SQLID_DELETE_PARAM, param);
return rows;
}
public int truncate() {
int rows = getSqlMapClientTemplate().delete(
sqlmapNamespace + "." + SQLID_TRUNCATE);
return rows;
}
public T get(PK primaryKey) {
return (T) getSqlMapClientTemplate().queryForObject(
sqlmapNamespace + "." + SQLID_SELECT_PK, primaryKey);
}
public void insert(T entity) {
getSqlMapClientTemplate().insert(sqlmapNamespace + "." + SQLID_INSERT,
entity);
}
public T load(PK primaryKey) throws DaoException {
Object o = getSqlMapClientTemplate().queryForObject(
sqlmapNamespace + "." + SQLID_SELECT_PK, primaryKey);
if (o == null)
throw new DataAccessException("数据查询异常：无法查询出主键数据");
return (T) o;
}
public List<T> select() {
return getSqlMapClientTemplate().queryForList(
sqlmapNamespace + "." + SQLID_SELECT);
}
public List<T> select(DynamicSqlParameter param) {
return getSqlMapClientTemplate().queryForList(
sqlmapNamespace + "." + SQLID_SELECT_PARAM, param);
}
public PaginationResult<T> selectPagination(DynamicSqlParameter param) {
if (param != null)
param.setDbDialect(this.dbDialect);
PaginationResult<T> result = new PaginationResult<T>();
int count = count(param);
result.setTotalSize(count);
if (count > 0) {
List<T> data = getSqlMapClientTemplate().queryForList(
sqlmapNamespace + "." + SQLID_SELECT_PARAM, param);
result.setData(data);
}
return result;
}
public List<T> selectFk(DynamicSqlParameter param) {
return getSqlMapClientTemplate().queryForList(
sqlmapNamespace + "." + SQLID_SELECT_FK, param);
}
public PaginationResult<T> selectFkPagination(DynamicSqlParameter param) {
if (param != null)
param.setDbDialect(this.dbDialect);
PaginationResult<T> result = new PaginationResult<T>();
int count = count(param);
result.setTotalSize(count);
if (count > 0) {
List<T> data = getSqlMapClientTemplate().queryForList(
sqlmapNamespace + "." + SQLID_SELECT_FK, param);
result.setData(data);
}
return result;
}
public int update(T entity) {
return getSqlMapClientTemplate().update(
sqlmapNamespace + "." + SQLID_UPDATE, entity);
}
public int update(DynamicSqlParameter param) {
if (param == null || param.getUpdateValueList() == null)
throw new ParameterException(
"参数设置错误:使用带参数的update必须设定update的column！");
return getSqlMapClientTemplate().update(
sqlmapNamespace + "." + SQLID_UPDATE_PARAM, param);
}
public void batchInsert(final List<T> list){
SqlMapClientCallback callback = new SqlMapClientCallback() {
public Object doInSqlMapClient(SqlMapExecutor executor) throws SQLException {
executor.startBatch();
for (T member : list) {
executor.insert(sqlmapNamespace + "." + SQLID_INSERT, member);
}
executor.executeBatch();
return null;
}
};
this.getSqlMapClientTemplate().execute(callback);
}
public void batchUpdate(final List<T> list){
SqlMapClientCallback callback = new SqlMapClientCallback() {
public Object doInSqlMapClient(SqlMapExecutor executor) throws SQLException {
executor.startBatch();
for (T member : list) {
executor.update(sqlmapNamespace + "." + SQLID_UPDATE, member);
}
executor.executeBatch();
return null;
}
};
this.getSqlMapClientTemplate().execute(callback);
}
public void batchDelete(final List<PK> list){
SqlMapClientCallback callback = new SqlMapClientCallback() {
public Object doInSqlMapClient(SqlMapExecutor executor) throws SQLException {
executor.startBatch();
for (PK member : list) {
executor.delete(sqlmapNamespace + "." + SQLID_DELETE, member);
}
executor.executeBatch();
return null;
}
};
this.getSqlMapClientTemplate().execute(callback);
}
}
3、某实体的DAO接口：
public interface UserDao extends GenericDao<User,Integer> {
//通用方法从GenericDao继承
//这里可以定义针对此类的特定方法
}
4、某实体的DAO实现：
public class UserDaoImpl extends GenericIbatisDao<User,Integer> implements UserDao {
}
分享到：
相关推荐
泛型dao接口 ：GenericDao, ID extends Serializable> 泛型作为DAO的通用接口 CRUD方法 dao接口 : PersonDAO extends GenericDao, Integer> 可以不写代码,方法已经在父类泛型dao里了,这里为了说明:可扩展添加 ...
而泛型DAO是一个类型安全的，代码精简的设计模式（相对于传统DAO），尤其在DAO组件数量庞大的时候，代码量的减少更加明显。 泛型DAO的核心是定义一个GenericDao接口，声明基本的CRUD操作： 用hibernate作为持久化...
泛型dao接口 ：GenericDao, ID extends Serializable> 泛型作为DAO的通用接口 CRUD方法 dao接口 : PersonDAO extends GenericDao, Integer> 可以不写代码,方法已经在父类泛型dao里了,这里为了说明:可扩展添加 ...
java的基于泛型+反射的通用DAO例子，原创，没事写着玩的，请多指教哈。。。
数据库见表自己会建，只要把相关jar包考进来就可以用，对于小型企业构建自己的网站已经足够，dao接口采用泛型接口，没有经验的设计不出来，权限有2种，2种我都写了，采用组和注解的方式，会员中心目前只实现修改个人...
该类必须继承com.hikvision.swdf.xx.BaseAction<{EntityName}>，该Action类有一个关键属性entity，即泛型Entity类的一个实体，该属性默认填充好了请求提交过来的entity对应参数（即entity.propertyName）；...
泛型 内部类 反射 序列化 nIo 匿名类 包装类 优先级 引用 语言工具类库 容器类 集合 链表 map 工具类 系统类 日期类 数字类 字符串+正则 流 字符流 字节流 语言特性 继承 封装 多态 JVM ...
这样的线性流程有着极大的问题，首先架构师或数据库专家不是圣人，设计数据库，Dao,Service接口之后，就不需要修改，在编码过程中，会进行大量的修改，特别是那种那只懂数据库的专家在设计之后，开发人员怨声载道。...
16.2.2 实现泛型CRUD接口 16.2.3 实现实体DAO 16.2.4 利用数据访问对象 16.3 命令模式简介 16.3.1 基础接口 16.3.2 执行命令对象 16.3.3 命令模式的变形 16.4 利用EJB 3.0设计应用...
JEECG V3.0版本采用SpringMVC+Hibernate+UI快速开发库 的基础架构,采用面向声明的开发模式， 基于泛型编写极少代码即可实现复杂的数据展示、数据编辑、 表单处理等功能，再配合代码生成器的使用,将J2EE的开发效率...
第29章 人员信息管理项目 （接口设计模式+MySQL数据库） 29.1 人员信息管理原理 29.1.1 项目结构框架分析 29.1.2 项目功能业务分析 29.2 人员信息管理项目前期准备 29.2.1 设计数据库 29.2.2 数据库操作相关类 29.3 ...
<br>6、 提供代码生成工具，生成的类代码的同时可以类之间的继承关系和接口实现关系，所有DAO类方法均以接口作为参数，使得代码更加具有可扩展性和灵活性。 <br>7、 Sql模板和ORMap直接生成.cs原代码，编译为...
<br>6、 提供代码生成工具，生成的类代码的同时可以类之间的继承关系和接口实现关系，所有DAO类方法均以接口作为参数，使得代码更加具有可扩展性和灵活性。 <br>7、 Sql模板和ORMap直接生成.cs原代码，编译为...
<br>6、 提供代码生成工具，生成的类代码的同时可以类之间的继承关系和接口实现关系，所有DAO类方法均以接口作为参数，使得代码更加具有可扩展性和灵活性。 <br>7、 Sql模板和ORMap直接生成.cs原代码，编译为...
{2.9}抽象与接口}{59}{section.2.9} {2.10}访问控制}{60}{section.2.10} {2.10.1}类的属性}{60}{subsection.2.10.1} {2.10.2}类的方法}{61}{subsection.2.10.2} {2.10.3}静态代码块}{62}{subsection.2.10.3} {...