`
jessen163
  • 浏览: 464711 次
  • 性别: Icon_minigender_1
  • 来自: 潘多拉
社区版块
存档分类
最新评论

DAO层公共类(Spring+Hibernate实现)

阅读更多
package rong.common.dao;
import java.io.Serializable;
import java.sql.SQLException;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.stereotype.Repository;
import rong.common.utils.Pager;
import rong.util.MyHibernateDaoSupport;

/**
 * Dao层接口的实现类
 * 许多人习惯根据不多的业务逻辑定义不同的DAO层接口,如UserDao,NewsDao,CompanyDao等等,
 * 这样往往使得编码量十分庞大,而且带来了维护的困难,因此,抽取此DAO层接口,收录大部分
 * DAO层必须的方法,以供Service层调用。
 * @author rongxinhua
 * @version 1.0
 * @param <T> 范型,指实体类
 * @param <PK> 范型,指实体类主键的数据类型,如Integer,Long
 * @see rong.common.dao.EntityDao
 */

@Repository(value="entityDao")
public class EntityDaoImpl<T,PK extends Serializable> extends MyHibernateDaoSupport implements EntityDao<T, PK>{

    /**
     * 保存实体
     * 包括添加和修改
     * @param t 实体对象
     */
    public void saveOrUpdate(T t){
        getHibernateTemplate().saveOrUpdate(t);
    }
    
    /**
     * 更新实体
     * 可用于添加、修改、删除操作
     * @param hql 更新的HQL语句
     * @param params 参数,可有项目或多项目,代替Hql中的"?"号
     */
    public void update(final String hql,final Object params){
        getHibernateTemplate().execute(new HibernateCallback(){

            public Object doInHibernate(Session session)
                    throws HibernateException, SQLException {
                Query query = session.createQuery(hql);
                for(int i=0; i<params.length; i++){
                    query.setParameter(i, params[i]);
                }
                query.executeUpdate();
                return null;
            }
        });
    }
    
    /**
     * 删除实体
     * @param t 实体对象
     */
    public void delete(T t){
        getHibernateTemplate().delete(t);
    }
    
    /**
     * 删除实体
     * @param entityClass 实体类名
     * @param id 实体的ID
     */
    public void delete(Class<T> entityClass,PK id){
        getHibernateTemplate().delete(get(entityClass,id));
    }
    
    /**
     * 单查实体
     * @param entityClass 实体类名
     * @param id 实体的ID
     * @return 实体对象
     */
    @SuppressWarnings("unchecked")
    public T get(Class<T> entityClass,PK id){
        return (T)getHibernateTemplate().get(entityClass, id);
    }
    
    /**
     * 查询全部记录列表
     * @param entityClass 实体类名
     * @param propertyName 排序的参照属性
     * @param isAsc 排序方式
     * @param criterions 查询条件,可为0项或任意多项目
     * @return 记录List集
     */
    public List<T> findAll(final Class<T> entityClass,final String propertyName,final boolean isAsc,final Criterion criterions){
        int firstResult = 0;
        int maxResults = 0;        //设置为0,则表示查询全部记录
        return findByCriteria(entityClass, propertyName, isAsc, firstResult, maxResults, criterions);
    }
    
    /**
     * 查询列表
     * @param entityClass 实体类名
     * @param propertyName 排序的参照属性
     * @param isAsc 排序方式,true表示升序,false表示降序,当propertyName赋值为null时,此参数无效
     * @param firstResult 开始记录序号
     * @param maxResults 最大记录数
     * @param criterions 查询条件,可有0项或任意多项目
     * @return 记录List集
     */
    @SuppressWarnings("unchecked")
    public List<T> findByCriteria(final Class<T> entityClass,final String propertyName,final boolean isAsc,final int firstResult,final int maxResults,final Criterion criterions){
        List<T> list = (List<T>)getHibernateTemplate().execute(new HibernateCallback(){

            public Object doInHibernate(Session session)
                    throws HibernateException, SQLException {
                Criteria criteria = session.createCriteria(entityClass);
                //按属性条件查询
                for(Criterion criterion : criterions){
                    criteria.add(criterion);
                }
                //按某个属性排序
                if(null != propertyName){
                    if(isAsc){
                        criteria.addOrder(Order.asc(propertyName));
                    }else{
                        criteria.addOrder(Order.desc(propertyName));
                    }
                }
                //用于分页查询
                if(maxResults != 0){
                    criteria.setFirstResult(firstResult);
                    criteria.setMaxResults(maxResults);
                }
                List<T> list = criteria.list();
                return list;
            }
        });
        return list;
    }
    
    /**
     * 查询总记录数
     * @param entityClass 实体类名
     * @param criterions 查询条件,可有0项或任意多项
     * @return 总记录数
     */
    public int findCountsByCriteria(final Class<T> entityClass,final Criterion criterions){
            int totalCounts = (Integer)getHibernateTemplate().execute(new HibernateCallback(){

            public Object doInHibernate(Session session)
                    throws HibernateException, SQLException {
                Criteria criteria = session.createCriteria(entityClass);
                //按属性条件查询
                for(Criterion criterion : criterions){
                    criteria.add(criterion);
                }
                int totalCounts = criteria.list().size();
                return totalCounts;
            }
        });
        return totalCounts;
    }
    
    
    /**
     * 分页查询
     * @param entityClass 实体类名
     * @param propertyName 排序参照属性
     * @param isAsc 排序方式,true表示升序,false表示降序,当propertyName赋值为null时,此参数无效
     * @param firstResult 开始记录序号
     * @param maxResults 最大记录数
     * @param criterions 查询条件,可为0项或任意多项目
     * @return 封装List和totalCounts的Pager对象
     */
    @SuppressWarnings("unchecked")
    public Pager<T> findForPager(final Class<T> entityClass,final String propertyName,final boolean isAsc,final int firstResult,final int maxResults,final Criterion criterions){
        int totalCounts = findCountsByCriteria(entityClass, criterions);
        List<T> entityList = findByCriteria(entityClass, propertyName, isAsc, firstResult, maxResults, criterions);
        Pager pager = new Pager();
        pager.setTotalCounts(totalCounts);
        pager.setEntityList(entityList);
        return pager;
    }
    
    /**
     * 根据属性值查询列表
     * @param entityClass 实体类名
     * @param propertyName 属性名
     * @param value 属性值
     * @return List列表
     */
    public List<T> findByProperty(Class<T> entityClass,String propertyName,Object value){
        Criterion criterion = Restrictions.eq(propertyName, value);
        List<T> list = findAll(entityClass, null, true, criterion);
        return list;
    }
    
    /**
     * 根据属性值查询单个对象
     * @param entityClass 实体类名
     * @param propertyName 属性名
     * @param value 属性值
     * @return 实体对象
     */
    @SuppressWarnings("unchecked")
    public T findUniqueByProperty(final Class<T> entityClass,final String propertyName,final Object value){
        T t = (T)getHibernateTemplate().execute(new HibernateCallback(){

            public Object doInHibernate(Session session)
                    throws HibernateException, SQLException {
                Criteria criteria = session.createCriteria(entityClass).add(Restrictions.eq(propertyName, value));
                T t = (T)criteria.uniqueResult();
                return t;
            }
        });
        return t;
    }
    
    /**
     * 根据属性值查询实体是否存在
     * @param entityClass 实体类名
     * @param propertyName 参照的属性名
     * @param value 属性值
     * @return 存在则返回true,不存在则返回false
     */
    public boolean isPropertyExist(final Class<T> entityClass,final String propertyName,final Object value){
        boolean isExist = (Boolean)getHibernateTemplate().execute(new HibernateCallback(){

            public Object doInHibernate(Session session)
                    throws HibernateException, SQLException {
                Criteria criteria = session.createCriteria(entityClass).add(Restrictions.eq(propertyName, value));
                boolean isEmpty = criteria.list().isEmpty();
                return ! isEmpty;
            }
        });
        return isExist;
    }
    
    /**
     * 
     * @param hql 查询语句
     * 用法如:可用于登录验证时,根据用户名、密码等信息查询用户
     * @param params 参数数组,代替HQL中的"?"号,可有0项目或多项
     * @return 唯一实体,返回null则表示不存在配置的实体
     * @exception 如果查询的结果集不唯一,则抛异常
     */
    @SuppressWarnings("unchecked")
    public T findUniqueByHql(final String hql, final Object params ){
        
        T t = (T)getHibernateTemplate().execute(new HibernateCallback(){

            public Object doInHibernate(Session session)
                    throws HibernateException, SQLException {
                Query query = session.createQuery(hql);
                for(int i=0; i<params.length; i++){
                    query.setParameter(i, params[i]);
                }
                T t = (T)query.uniqueResult();
                return t;
            }
        });
        return t;
    }
    
    /**
     * 按HQL条件查询列表
     * @param hql 查询语句,支持连接查询和多条件查询
     * @param params 参数数组,代替hql中的"?"号
     * @return 结果集List
     */
    @SuppressWarnings("unchecked")
    public List<T> findByHql(String hql,Object params){
        List list = getHibernateTemplate().find(hql, params);
        return list;
    }
    
    /**
     * 按HQL分页查询
     * @param firstResult 开始记录号
     * @param maxResults 最大记录数
     * @param hql 查询语句,支持连接查询和多条件查询
     * @param params 参数数组,代替餐hql中的"?"号
     * @return 封装List和total的Pager对象
     */
    @SuppressWarnings("unchecked")
    public Pager<T> findForPagerByHql(final int firstResult, final int maxResults, final String hql, final Object params){
        Pager<T> pager = (Pager<T>)getHibernateTemplate().execute(new HibernateCallback(){

            public Object doInHibernate(Session session)
                    throws HibernateException, SQLException {
                Query query = session.createQuery(hql);
                for(int position = 0; position < params.length; position ++){
                    query.setParameter(position, params[position]);
                }
                int totalCounts = query.list().size();    //总记录数
                //用于分页查询
                if(maxResults > 0){
                    query.setFirstResult(firstResult);
                    query.setMaxResults(maxResults);
                }
                List<T> list = query.list();
                Pager<T> pager = new Pager<T>();
                pager.setEntityList(list);
                pager.setTotalCounts(totalCounts);
                return pager;
            }
        });
        return pager;
    }
    

}
分享到:
评论

相关推荐

    Spring+Hibernate实现)Hibernate公用类

    本文将详细解析如何利用Spring和Hibernate来实现一个通用的DAO(Data Access Object)层,以提高代码复用性和项目开发效率。 首先,让我们了解Spring框架。Spring是一个全面的企业级应用开发框架,提供了依赖注入...

    JSF+Spring+Hibernate的实例讲解.doc

    在 JCatalog 示例中,Spring 可能用于实现业务服务接口,提供对 Hibernate DAO 的封装,而 JSF 的 Managed Beans 作为视图与控制器的结合,负责处理用户请求并调用 Spring 服务。此外,安全控制也应纳入设计考虑,如...

    AnyFo - Util - AnyFoDao :Spring + Hibernate整合通用的DAO层类

    Util下的一个子项目,其中只包含一个类,这个类是一个通用的DAO层类,这里包含了一个普通系统的DAO层的各种功 能,所以,在开发时,大家不用多次在各个模块开发DAO层的类了,各个模块共用这个公共的DAO类即可。...

    Struts+Spring+Hibernate通用分页解决方案

    然后,通过Spring的依赖注入,Action类可以获取到由Hibernate管理的数据访问对象(DAO)。DAO层利用Hibernate的查询功能,结合Limit和Offset实现数据库的分页查询。查询结果返回给Action,Action再将数据封装成模型...

    Struts2+Spring+Hibernate集成过程

    2. **实现类**:实现上述接口,并利用Spring和Hibernate进行数据操作。 #### 五、集成Struts2框架 1. **添加依赖库**:在项目的Libraries中添加Struts2相关的jar包。 2. **配置Struts2**: - 创建`struts.xml`...

    Struts2+Spring+Hibernate整合的例子.doc

    在Action类中,通过调用Service层的方法来处理业务,而Service层又会调用DAO层的方法来操作数据库。DAO层通常会使用Hibernate的Session接口进行数据库交互。 在Struts2的配置文件(struts.xml)中,需要定义Action...

    struts2+hibernate+spring三大框架技术

    ### Struts2+Hibernate+Spring三大框架技术 #### Struts2 框架技术 **MVC概述** MVC(Model-View-Controller)是一种软件架构设计模式,它将应用程序分为三个基本部分:模型(Model)、视图(View)与控制器...

    Struts2.0+hibernate+spring紧急发布2.0代码生成器

    这个“Struts2.0+hibernate+spring紧急发布2.0代码生成器”是一个工具,旨在帮助开发者快速生成基于这三个框架的项目代码,提高开发效率。 Struts2.0是Apache组织维护的一个MVC框架,它提供了强大的动作(Action)...

    (2.0版本)自己写的struts2+hibernate+spring实例

    愿意与所有软件爱好者成为好友. 邮箱:menxin32@163.com&lt;br&gt;当前版本1.0 包含内容:一个用户表格的增删改查实现. 基本的七层分层框架. 内写多个公共类.为了日后可以很好的解耦合. 注释清晰. ...

    基于JAVA公共资源模块的设计与开发(源代码+论文).zip

    Smart 在线考试项目(以下简称“Smart”),将在struts+sprintg 管理的hibernate作为平台框架搭建具体的Smart在线考试业务系统。 采用struts MVC框架主要...而将建立专门的业务层,对WEB层及其他子模块或类进行接口。

    spring_struts_hibernate集成(干净版)

    3. 创建DAO接口及实现:定义数据访问接口,使用Spring的`@Repository`注解标记实现类,便于自动代理事务管理。 4. 配置Struts:编写`struts.xml`,定义Action类及其对应的视图,同时可以配置拦截器以实现权限控制等...

    Struts2、Spring和Hibernate应用实例

    接下来,我们可以继续构建更多的组件和服务层,例如Service层、DAO层等,同时也可以编写具体的Action类,来处理不同的请求。此外,还需要配置Spring的bean文件,以及Hibernate的相关配置文件,确保各个框架之间能够...

    SpringMVC+Hibernate

    在Spring MVC中,Controller接收用户请求,调用Service层进行业务处理,Service层再通过DAO层与数据库交互。最后,View负责渲染结果并返回给用户。Spring MVC的核心组件包括DispatcherServlet、Model、ViewResolver...

    SpringMVC+Spring+Mybatis(SSM) demo

    Mybatis 是一个轻量级的持久层框架,它简化了 SQL 操作,允许开发者直接编写 SQL 语句,避免了 JPA 或 Hibernate 等 ORM 框架的复杂性。在 SSM 结构中,Mybatis 负责与数据库交互,通过 XML 或注解方式定义 SQL 映射...

    Spring整合hibernate(4)之BaseDao的编写示例

    Spring整合hibernate(4)之BaseDao的编写示例 说明:因为我们在实际编码中会编写一些重复的数据库操作方法CRUD,每个类...这样基本上就实现了大量的基础方法,如果DAO中又一些特殊方法,再再具体的实现类的DAO中创建。

    Struts+Spring框架下的单元测试[总结].pdf

    Struts和Spring是两个在Java Web开发中广泛使用的框架,Struts主要负责控制层的处理,而Spring则提供了全面的依赖注入(DI)和面向切面编程(AOP)等功能,便于实现业务逻辑和服务的解耦。在这样的框架组合下进行...

    spring2.5 -3.0 hibernate3.3 jar包说明

    它还包含了核心工具类,如BeanFactory,它是工厂模式的一种实现,也是Spring IoC容器的基础。 2. **spring-beans.jar** 此Jar包为BeanFactory提供了具体的实现,提供了对Bean的实例化、配置、装配等功能的支持。...

    Spring 系列,第 2 部分 当 Hibernate 遇上 Spring

    接着,文章提到了Spring对Hibernate的集成支持,它解决了许多常见的Hibernate集成问题,并符合Spring的一致事务和DAO异常层次结构。Spring的ORM支持使得开发者可以选择Hibernate、JDO或iBATIS SQL Maps,无论使用哪...

    struts2 spring hibernate 整合的SSH API

    Struts2、Spring和Hibernate是Java开发中三大主流框架,它们各自负责Web应用程序的不同层面,共同构建了一个强大的企业级应用开发平台。这三个框架的整合,通常被称为SSH(Struts2-Spring-Hibernate)集成,旨在提供...

Global site tag (gtag.js) - Google Analytics