sky_dream
- 浏览: 6309 次
- 性别:
- 来自:
-
最新评论
今天把以前使用的的DAO层操作整理了下，包括分页，由于以前项目比较近，没有成为一个独立可复用的模块，整理后基本满足了可复用需求。
由于经验不足，DAO层设计比较单一，希望论坛里的大虾们，共同对此DAO修改，如果你的修改可以是DAO层更灵活，我将十分感谢，此DAO是由robin和HTT的思想和自己工作中的经验而成，再次感谢他们。
DAO顶级接口类：IBaseDao.java
package com.frame.ssh.dao.base;
import java.io.Serializable;
import java.util.List;
import java.util.Map;
import com.frame.ssh.util.PagesBean;
import com.sun.istack.internal.FinalArrayList;
/**
* Dao的顶级接口，为基本的操作提供接口
*
*
* @author zjc
* @version 1.0
* @since 1.0
*/
public interface IBaseDao<T,ID extends Serializable> {
/**
* 添加实体类
*
* @param entity:需要添加的实体类
* @return 无返回值
* */
Serializable saveEntity(final T entity);
/**
* 添加修改实体类
*
* @param entity:需要添加的实体类
* @return 无返回值
* */
void saveOrUpdateEntity(final T entity);
/**
* 修改实体类
*
* @param entity:修改持久化的对象
* @return 实现序列化的对象
* */
Serializable updateEntity(final T entity);
/**
* 删除持久化实体类
*
* @param entity:删除持久化的对象
* @return 实现序列化的对象
* */
void deleteEntity(final T entity);
/**
* 查询单个实体对象
*
* @param clazz:查询实体的CLASS
* @param id:查询实体的标示符
* @return 实体对象
* */
T getEntity(final Class<T> clazz,final ID id);
/**
* 通过主键查询实体类
*
* @param id:查询实体的标示符
* @return 实体对象
* */
T getEntityByID(final ID id);
/**
* 无分页查询所有的对象集合
*
* @param conditionMap:查询条件集合
* @return 实体对象集合
* */
List<T> findEntity(final Map<ID,T> conditionMap);
/**
* 查询所有对象
*
* @param conditionMap:查询条件集合
* @return 实体对象集合
* */
List<T> findAllEntity(final Class<T> clazz);
/**
* 带分页的查询方法,基于HQL
*
* @param entity:实体类
* @return 实体对象集合
* */
PagesBean<T> findEntityByPageHQL(final T entity,final PagesBean<T> page,final String HQL,final String condHQL);
/**
* 带分页的查询方法,基于SQL
*
* @param entity:实体类
* @return 实体对象集合
* */
PagesBean<T> findEntityByPageSQL(final T entity,final PagesBean<T> page,final String SQL,final String condSQL);
}
抽象类：AbstractBaseDaoImplement.java
package com.frame.ssh.dao.base;
import java.io.Serializable;
import java.util.List;
import java.util.Map;
import org.springframework.orm.hibernate3.HibernateTemplate;
import com.frame.ssh.util.PagesBean;
/**
* Spring 集成 Hibernate DAO 的抽象类,通过IOC将SessionFactory注入. 基本操作功能实现.
*
* @author zjc
* @version 1.0
* @since 1.0
*/
public abstract class AbstractBaseDaoImplement<T, ID extends Serializable> extends AbstractDividePage<T> implements IBaseDao<T, ID> {
private HibernateTemplate hibernateTemplate;
abstract Class<T> getEntityClazz();
HibernateTemplate getHibernateTemplate() {
return hibernateTemplate;
}
@Override
public void deleteEntity(final T entity) {
hibernateTemplate.delete(entity);
}
@SuppressWarnings("unchecked")
@Override
public List<T> findEntity(Map<ID, T> conditionMap) {
StringBuffer HQL = new StringBuffer();
HQL.append(" from "+getEntityClazz().getSimpleName());
HQL.append(" where 1=1 ");
if(conditionMap instanceof Map<?,?> && conditionMap.size()>0){
for (ID id : conditionMap.keySet()) {
HQL.append(" and").append(id).append(conditionMap.get(id));
}
}else{
throw new IllegalArgumentException();
}
return hibernateTemplate.find(HQL.toString());
}
@SuppressWarnings("unchecked")
@Override
public T getEntity(Class<T> clazz, ID id) {
return (T) hibernateTemplate.load(clazz, id);
}
@Override
public Serializable saveEntity(T entity) {
return hibernateTemplate.save(entity);
}
@SuppressWarnings("unchecked")
@Override
public T getEntityByID(ID id) {
return (T) hibernateTemplate.load(getEntityClazz(), id);
}
@Override
public Serializable updateEntity(T entity) {
return (Serializable) hibernateTemplate.merge(entity);
}
@SuppressWarnings("unchecked")
@Override
public List<T> findAllEntity(Class<T> clazz) {
return hibernateTemplate.loadAll(clazz);
}
@Override
public void saveOrUpdateEntity(T entity) {
hibernateTemplate.saveOrUpdate(entity);
}
@Override
public PagesBean<T> findEntityByPageHQL(T entity, PagesBean<T> page,String HQL,String condHQL) {
return super.dividePageOperation(entity, page, HQL, condHQL);
}
@Override
public PagesBean<T> findEntityByPageSQL(T entity, PagesBean<T> page,String SQL, String condSQL) {
return super.dividePageOperationSQL(entity, page, SQL, condSQL);
}
public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}
}
分页抽象类：AbstractDividePage.java
package com.frame.ssh.dao.base;
import java.sql.SQLException;
import java.util.List;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.HibernateTemplate;
import com.frame.ssh.util.PagesBean;
/**
* 分页抽象类，提供HQL、SQL两种方式.
*
* @author zjc
* @version 1.0
* @since 1.0
*/
public abstract class AbstractDividePage<T> {
private static int TOTAL_COUNT = 0; // 总记录数
private static int BEGIN_INDEX = 0; // 起始位置
private static int TOTAL_PAGE = 0; // 总页数
private static int PAGE_COUNT = 0; // 每页记录数
private static int CURRENT_PAGE= 0; // 当前第几页
private PagesBean<T> pageBean;
abstract HibernateTemplate getHibernateTemplate();
/**
* 基于HQL的分页方法
* @param entity 实体分页对象
* @param page 分页类
* @return 分页后的对象
* */
@SuppressWarnings("unchecked")
PagesBean<T> dividePageOperation(T entity,PagesBean<T> page,final String HQL,String condHQL) {
if(entity == null || page == null || HQL == null || condHQL == null){
throw new IllegalArgumentException("传入参数为空！");
}
TOTAL_COUNT = ((Long) this.getHibernateTemplate().find(condHQL).iterator().next()).intValue();
BEGIN_INDEX = PagesBean.getIndex(page.getPageSize(), page.getCurrentPage());
TOTAL_PAGE = PagesBean.countTotalPage(page.getPageSize(), page.getTotalCount());
CURRENT_PAGE = PagesBean.countCurrentPage(page.getCurrentPage());
PAGE_COUNT = page.getPageSize();
pageBean = new PagesBean<T>();
pageBean.setTotalCount(TOTAL_COUNT);
pageBean.setCurrentPage(CURRENT_PAGE);
pageBean.setPageSize(PAGE_COUNT);
pageBean.setTotalPage(TOTAL_PAGE);
pageBean.setUrl(page.getUrl());
List<T> list = this.getHibernateTemplate().executeFind(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException, SQLException {
return session.createQuery(HQL).setFirstResult(BEGIN_INDEX).setMaxResults(PAGE_COUNT);
}
});
pageBean.setList(list);
return pageBean;
}
/**
* 基于HQL的分页方法
* @param entity 实体分页对象
* @param page 分页类
* @return 分页后的对象
* */
@SuppressWarnings("unchecked")
PagesBean<T> dividePageOperationSQL(T entity,PagesBean<T> page,final String SQL,final String condSQL) {
if(entity == null || page == null || SQL == null || condSQL == null){
throw new IllegalArgumentException("传入参数为空！");
}
Object object = this.getHibernateTemplate().execute(new HibernateCallback() {
@Override
public Object doInHibernate(Session session) throws HibernateException,SQLException {
return session.createSQLQuery(condSQL).uniqueResult();
}
});
TOTAL_COUNT = Integer.valueOf(object.toString());
BEGIN_INDEX = PagesBean.getIndex(page.getPageSize(), page.getCurrentPage());
TOTAL_PAGE = PagesBean.countTotalPage(page.getPageSize(), page.getTotalCount());
CURRENT_PAGE = PagesBean.countCurrentPage(page.getCurrentPage());
PAGE_COUNT = page.getPageSize();
pageBean = new PagesBean<T>();
pageBean.setTotalCount(TOTAL_COUNT);
pageBean.setCurrentPage(CURRENT_PAGE);
pageBean.setPageSize(PAGE_COUNT);
pageBean.setTotalPage(TOTAL_PAGE);
pageBean.setUrl(page.getUrl());
List<T> list = this.getHibernateTemplate().executeFind(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException, SQLException {
return session.createSQLQuery(SQL).setFirstResult(BEGIN_INDEX).setMaxResults(PAGE_COUNT);
}
});
pageBean.setList(list);
return pageBean;
}
}
分页基本类：PagesBean.java
package com.frame.ssh.util;
import java.util.List;
/**
* 分页基本类
*
* @author zjc
* @version 1.0
* @since 1.0
*/
public final class PagesBean<T> {
private int totalCount;
private int pageSize;
private int currentPage;
private int totalPage;
private List<T> list;
private String url;
private String key;
private String value;
private String remark;
private String remark1;
private String remark2;
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public List<T> getList() {
return list;
}
public void setList(List<T> list) {
this.list = list;
}
/**
* 计算总页数
* @param pageSize 每页记录数
* @param totalCount 总记录数
* @return 总页数
*/
public static int countTotalPage(final int pageSize,final int totalCount){
int totalPage = totalCount % pageSize == 0 ? totalCount/pageSize : totalCount/pageSize+1;
return totalPage;
}
/**
* 计算当前页开始记录
* @param pageSize 每页记录数
* @param currentPage 当前第几页
* @return 当前页开始记录号
*/
public static int getIndex(final int pageSize,final int currentPage){
final int startCount = pageSize*(currentPage-1);
return startCount;
}
/**
* 计算当前页,若为0或者请求的URL中没有"?page=",则用1代替
* @param page 传入的参数(可能为空,即0,则返回1)
* @return 当前页
*/
public static int countCurrentPage(int page){
final int curPage = (page==0?1:page);
return curPage;
}
public int getTotalCount() {
return totalCount;
}
public void setTotalCount(int totalCount) {
this.totalCount = totalCount;
}
public int getTotalPage() {
return totalPage;
}
public void setTotalPage(int totalPage) {
this.totalPage = totalPage;
}
public int getCurrentPage() {
return currentPage;
}
public void setCurrentPage(int currentPage) {
this.currentPage = currentPage;
}
public int getPageSize() {
return pageSize;
}
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getRemark1() {
return remark1;
}
public void setRemark1(String remark1) {
this.remark1 = remark1;
}
public String getRemark2() {
return remark2;
}
public void setRemark2(String remark2) {
this.remark2 = remark2;
}
}
再次希望大家对此提出你宝贵意见，我将非常感谢。
分享到：
发表评论
相关推荐
总结来说，"SSH中通用DAO类"是基于SSH框架设计的可复用数据访问组件，它利用Spring的DAO支持和Hibernate的ORM能力，提供了一套标准的数据库操作接口和实现，以满足多种业务需求。在实际开发中，这样的DAO设计有助于...
《基于SSH的论坛系统详解》 SSH（Struts + Spring + Hibernate）是Java Web开发中的经典框架组合，常用于构建高效、稳定的企业级应用。在本篇中，我们将深入探讨如何利用这三大框架构建一个基于SSH的论坛系统，以及...
Java课程设计基于SSH的课程设计管理系统是一个典型的Web应用程序开发项目，使用了Struts、Spring和Hibernate这三大流行框架的组合，通常称为SSH框架。SSH框架是Java Web开发中的一个重要工具，它极大地简化了企业级...
【基于SSH框架的房屋租赁系统】是一个典型的Java Web应用程序，它利用了Struts2、Spring和Hibernate这三大开源框架的组合，以实现高效且模块化的后端开发。SSH框架是Java开发领域中广泛采用的技术栈，它能帮助开发者...
总结来说，"基于SSH框架的员工管理系统"是一个利用Struts2处理Web请求，Spring管理业务逻辑和对象依赖，Hibernate负责数据库操作的Java Web项目。它为企业级应用开发提供了强大而稳定的支撑，实现了对员工信息的有效...
【基于SSH的学生选课系统】是一个使用SSH（Struts2 + Spring + Hibernate）技术栈构建的JavaEE应用程序，主要用于实现高校学生选课的功能。SSH框架是Java Web开发中常用的一套整合框架，它结合了Struts2的MVC设计...
SSH（Struts + Spring + Hibernate）是一种经典的Java Web开发框架组合，广泛应用于企业级应用，特别是电子商务领域，如本项目“基于SSH的购物系统”。这个系统利用SSH的优势，实现了高效、稳定且功能丰富的购物平台...
【基于SSH框架开发的在线考试系统】是一种使用Java技术栈，结合Struts、Spring和Hibernate三个开源框架构建的Web应用程序。SSH是这三个框架首字母的缩写，它们分别是：Struts（表示MVC架构的Action层）、Spring...
【基于SSH框架的网上电器商场】是一个典型的Java Web项目，SSH是Struts2、Spring和Hibernate三个开源框架的缩写，它们共同构建了一个强大的MVC（Model-View-Controller）架构，用于开发复杂的Web应用程序。...
在这个基于SSH的客房信息管理系统中，这三个框架协同工作，实现了对客房数据的有效管理和交互。 1. **Struts2**：作为MVC（模型-视图-控制器）架构的一部分，Struts2负责处理HTTP请求，并将这些请求映射到相应的...
【基于SSH+MySQL的学生成绩管理系统】是一个典型的Java Web应用程序，它利用Struts2（S）、Spring（S）和Hibernate（H）三大框架构建，同时结合MySQL数据库进行数据存储和管理。SSH框架是Java领域中广泛使用的MVC...
**基于SSH商场管理系统详解** SSH（Struts2 + Spring + Hibernate）是一个常见的Java Web开发框架组合，被广泛用于构建高效、稳定的企业级应用，如商场管理系统。SSH框架结合了Struts2的MVC设计模式、Spring的依赖...
综上所述，基于SSH框架的人力资源管理系统增删查改功能的实现，涉及了从开发环境搭建、数据库设计、实体类与映射文件创建、DAO层设计与实现、业务逻辑处理到控制器层响应等多个环节。这一过程不仅体现了SSH框架的...
**基于SSH学生成绩管理系统** SSH（Struts2 + Spring + Hibernate）是一个经典的Java Web开发框架，用于构建高效、可扩展的企业级应用。这个“基于SSH学生成绩管理系统”是利用这三个技术栈来实现的一个教育领域的...
【基于SSH框架旅游信息管理系统】是一个综合性的应用项目，它结合了Struts、Spring和Hibernate这三个主流的Java Web开发框架，旨在实现一个高效、稳定且功能完善的旅游信息管理平台。SSH框架是Java社区中广泛使用的...
综上所述，这个【基于SSH招聘管理系统设计源代码】项目涵盖了Web应用开发的多个核心领域，包括前端交互、后端业务逻辑、数据持久化以及数据分析可视化。它提供了一套完整的招聘流程管理解决方案，对于学习SSH框架、...
【标题】"基于SSH框架的网上客车售票系统"是一个典型的Web应用开发项目，它利用了Struts、Spring和Hibernate这三大主流开源框架的集成，即我们常说的SSH框架。SSH框架在Java Web开发中有着广泛的应用，因其强大的...
标题"基于SSH的增删改查程序"表明这是一个使用SSH框架实现的基础CRUD（Create, Read, Update, Delete）功能的项目。对于初学者来说，这是一个很好的起点，因为它涵盖了Web应用开发的基本操作。 在SSH框架中，Struts...
【基于SSH的OA系统】是一种基于Struts2、Spring和Hibernate三大开源框架集成开发的办公自动化（Office Automation，简称OA）系统。这个系统为开发者提供了一个基础平台，可以在其上进行二次开发，以满足不同企业对OA...
**基于SSH图书管理系统详解** SSH（Struts+Spring+Hibernate）是Java开发中常见的Web应用程序框架，用于构建高效、可扩展的企业级应用。本系统是一个适用于初学者实践SSH框架的图书管理系统，它集成了JSP（Java...