`

一个Hibernate Dao的模板

 
阅读更多
Model:
package com.pandy.model;


import com.pandy.common.BaseObject;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;

import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;

@Entity
@Table(name = "rh_sys_user")
@NamedQueries(
        value = {
                @NamedQuery(name = "getAllByNamedQuery1", query = "from RhSysUser"),
                @NamedQuery(name = "getAllByNamedQuery2", query = "from RhSysUser")
        }

)
public class RhSysUser extends BaseObject implements Serializable {
    private static final long serialVersionUID = 9812345L;
    private Long userId;
    private String code;
    private String loginName;
    private String userName;
    //......

    @Id
    @Column(name = "user_id", unique = true, nullable = false)
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Long getUserId() {
        return this.userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    @Column(name = "code", length = 50)
    public String getCode() {
        return this.code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    //......
}





公共接口:
package com.pandy.dao;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Order;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

public interface BaseDAO <T, PK extends Serializable>{
    public void setSessionFactoryOverride(SessionFactory sessionFactory);
    public Session getSession();

    T get(PK id);
    boolean exists(PK id);
    T save(T object);
    void remove(T object);
    void remove(PK id);
    void delete(T object);
    public int delete(Map<String,Object> map);


    List<T> getAll();
    public List<T> getAll(List<Order> orderList);
    List<T> searchByField(String field,Object value, String orderField) throws RuntimeException;
    List<T> searchByFields(Map fields) throws RuntimeException;
    List<T> searchByFields(Map fields,Map<String,String> order) throws RuntimeException;
    T searchFirstByFields(Map fields) throws RuntimeException;
    T getFirstByCode(String code);
    List<T> findByNamedQuery(String queryName, Map<String, Object> queryParams);
    T findFirstByNamedQuery(String queryName, Map<String, Object> queryParams);
}



公共实现:
package com.pandy.dao.impl;

import com.pandy.dao.BaseDAO;
import org.hibernate.*;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.ObjectRetrievalFailureException;
import org.springframework.orm.hibernate4.support.HibernateDaoSupport;

import javax.annotation.Resource;
import javax.persistence.EntityManagerFactory;
import java.io.Serializable;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class BaseDAOImpl<T, PK extends Serializable> extends HibernateDaoSupport implements BaseDAO<T, PK> {
    protected EntityManagerFactory entityManagerFactory;
    private Class<T> persistentClass;
    @Resource
    private SessionFactory sessionFactory;

    public BaseDAOImpl(final Class<T> persistentClass) {
        this.persistentClass = persistentClass;
    }

    public BaseDAOImpl(final Class<T> persistentClass, SessionFactory sessionFactory) {
        this.persistentClass = persistentClass;
        this.sessionFactory = sessionFactory;
    }

    @Autowired
    public void setSessionFactoryOverride(SessionFactory sessionFactory) {
        super.setSessionFactory(sessionFactory);
        this.sessionFactory=sessionFactory;
    }
    public void setEntityManagerFactory(EntityManagerFactory entityManagerFactory) {
        this.entityManagerFactory = entityManagerFactory;
    }

    public Session getSession() throws HibernateException {
        Session sess = getSessionFactory().getCurrentSession();
        if (sess == null) {
            sess = getSessionFactory().openSession();
        }
        return sess;
    }

    @SuppressWarnings("unchecked")
    public List<T> getAll() {
        Session sess = getSession();
        return sess.createCriteria(persistentClass).list();
    }

    public List<T> getAll(List<Order> orderList) {
        Session sess = getSession();
        Criteria criteria = sess.createCriteria(persistentClass);
        criteria.setCacheable(true);
        if (orderList != null) {
            for (Order order : orderList) {
                criteria.addOrder(order);
            }
        }
        return criteria.list();
    }

    public List<T> searchByField(String field, Object value, String orderField) throws RuntimeException {
        Session sess = getSession();
        Criteria criteria = sess.createCriteria(persistentClass);
        criteria.setCacheable(true);

        if (field != null && field.trim().length() > 0) {
            criteria.add(Restrictions.eq(field, value));
        }

        if (orderField != null && orderField.trim().length() > 0) {
            criteria.addOrder(Order.asc(orderField));
        }

        return criteria.list();
    }


    public List<T> searchByFields(Map fields) throws RuntimeException {
        Session sess = getSession();
        Criteria criteria = sess.createCriteria(persistentClass);
        criteria.setCacheable(true);

        for (Object field : fields.keySet()) {
            String fieldName = field != null ? field.toString() : "";

            if (!fieldName.equals("")) {
                Object fieldValue = fields.get(field);
                criteria.add(Restrictions.eq(fieldName, fieldValue));

                if (fieldName.equals("orderField")) {
                    criteria.addOrder(Order.asc(fieldValue.toString()));
                }

            }


        }

        return criteria.list();

    }

    @Override
    public T getFirstByCode(String code) {
        Map<String, Object> param = new HashMap<String, Object>();
        param.put("code", code);
        return searchFirstByFields(param);
    }

    @Override
    public T searchFirstByFields(Map fields) throws RuntimeException {
        List<T> list = searchByFields(fields);
        if (list != null && list.size() > 0) return list.get(0);
        return null;
    }

    @SuppressWarnings("unchecked")
    public T get(PK id) {
        Session sess = getSession();
        IdentifierLoadAccess byId = sess.byId(persistentClass);
        T entity = (T) byId.load(id);

        if (entity == null) {
            throw new ObjectRetrievalFailureException(this.persistentClass, id);
        }

        return entity;
    }

    @SuppressWarnings("unchecked")
    public boolean exists(PK id) {
        Session sess = getSession();
        IdentifierLoadAccess byId = sess.byId(persistentClass);
        T entity = (T) byId.load(id);
        return entity != null;
    }

    @SuppressWarnings("unchecked")
    public T save(T object) {
        Session sess = getSession();
        return (T) sess.merge(object);
    }

    public void remove(T object) {
        Session sess = getSession();
        sess.delete(object);
    }

    public void remove(PK id) {
        Session sess = getSession();
        IdentifierLoadAccess byId = sess.byId(persistentClass);
        T entity = (T) byId.load(id);
        sess.delete(entity);
    }

    @SuppressWarnings("unchecked")
    public List<T> findByNamedQuery(String queryName, Map<String, Object> queryParams) {
        Session sess = getSession();
        Query namedQuery = sess.getNamedQuery(queryName);
        namedQuery.setCacheable(true);
        for (String s : queryParams.keySet()) {
            namedQuery.setParameter(s, queryParams.get(s));
        }

        return namedQuery.list();
    }

    @SuppressWarnings("unchecked")
    public T findFirstByNamedQuery(String queryName, Map<String, Object> queryParams) {
        List<T> list = findByNamedQuery(queryName, queryParams);
        if (list != null && list.size() > 0)
            return list.get(0);
        return null;
    }

    @Override
    public void delete(T object) {
        getSession().delete(object);
    }

    @Override
    public int delete(Map<String, Object> map) {
        // TODO Auto-generated method stub
        if (map == null || map.size() == 0) {
            throw new RuntimeException("参数map不能为空或者size=0");
        }

        String className = this.persistentClass.getName();
        String name = className.substring(className.lastIndexOf(".") + 1);
        //System.out.println(name);
        String hql = "delete from " + name + " a where 1=1 ";

        for (String key : map.keySet()) {
            hql += " and a." + key + "=:" + key.replace(".", "_");
        }
        Query query = getSession().createQuery(hql);
        for (String key : map.keySet()) {
            //TODO: add by Pandy: 这里可能会有问题,比如int的类型经过instanceof会是Integer么?
            Object value = map.get(key);
            key = key.replace(".", "_");
            if (value instanceof Integer) {
                query.setInteger(key, (Integer) value);
            } else if (value instanceof Double) {
                query.setDouble(key, (Double) value);
            } else if (value instanceof Boolean) {
                query.setBoolean(key, (Boolean) value);
            } else if (value instanceof Date) {
                query.setDate(key, (Date) value);
            } else if (value instanceof Long) {
                query.setLong(key, (Long) value);
            } else {
                query.setString(key, value.toString());
            }


        }

        return query.executeUpdate();

    }


    @SuppressWarnings({"rawtypes", "unchecked"})
    @Override
    public List<T> searchByFields(Map fields, Map<String, String> orders) throws RuntimeException {
        Session sess = getSession();
        Criteria criteria = sess.createCriteria(persistentClass);
        criteria.setCacheable(true);

        for (Object field : fields.keySet()) {
            String fieldName = field != null ? field.toString() : "";

            if (!fieldName.equals("")) {
                Object fieldValue = fields.get(field);
                criteria.add(Restrictions.eq(fieldName, fieldValue));
            }
        }

        for (String field : orders.keySet()) {
            String order = orders.get(field);
            if ("desc".equalsIgnoreCase(order)) {
                criteria.addOrder(Order.desc(field));
            } else {
                criteria.addOrder(Order.asc(field));
            }

        }

        return criteria.list();
    }
}



使用接口定义:
package com.pandy.dao;

import com.pandy.model.RhSysUser;

public interface RhSysUserDao extends BaseDAO<RhSysUser, Integer> {
    public void test();
}



最终使用实现:

package com.pandy.dao.impl;

import com.pandy.dao.RhSysUserDao;
import com.pandy.model.RhSysUser;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.util.List;
@Repository(value="rhSysUserDao")
public class RhSysUserDaoImpl extends BaseDAOImpl<RhSysUser, Integer> implements RhSysUserDao{

    public RhSysUserDaoImpl() {
        super(RhSysUser.class);
    }

    @Override
    public void test() {
        Session session = getSessionFactory().getCurrentSession();
        Query query = session.createQuery("from RhSysUser");
        List<RhSysUser> list = query.list();
        if(list!=null && list.size()>0){
            for(RhSysUser rhSysUser :list){
                System.out.println(rhSysUser.getUserName());
            }
        }
    }
}
分享到:
评论

相关推荐

    HibernateDao.java

    `HibernateDao.java`是Hibernate框架中一个常见的数据访问对象(DAO,Data Access Object)类,它的主要职责是封装对数据库的操作,提供一套面向对象的接口,使得业务逻辑层可以无需关心底层SQL语句,直接通过对象...

    springMVC + Hibernate 工程模板

    hibernate dao 操作(一个basedao全部搞定) 两种配置:oracle mysql,切换数据库只要把SessionFactory的配置文件改成对应就可以了 c3p0配置:mysql调试通过,oracle由于存在问题,未配置 spring配置式事务管理...

    Hibernate DAO生成器

    在Java开发中,Hibernate是一个非常流行的ORM(对象关系映射)框架,它使得Java开发者能够方便地操作数据库,无需过多关注SQL的细节。然而,随着项目规模的扩大,手动编写数据访问对象(DAO)类会变得繁琐且容易出错...

    hibernate反向工程模板(已修改)

    在"hibernate反向工程模板(已修改)"中,我们看到的可能是针对特定项目或需求优化过的模板,如`pojo`目录下的实体类模板,`dao`目录下的DAO接口和实现模板,以及`hbm`目录下的持久化映射文件模板。 三、模板定制...

    Hibernate泛型DAO(结合spring模板支持)

    在Java开发中,Hibernate是一个非常流行的ORM(对象关系映射)框架,它允许开发者用面向对象的方式处理数据库操作。在大型项目中,为了提高代码的复用性和可维护性,通常会采用DAO(数据访问对象)模式来隔离业务...

    自定义 Hibernate Tools 的模板

    VTL 是一个轻量级的模板引擎,允许开发者用简单的语法来控制代码生成逻辑。 3. **自定义模板步骤**: - 首先,你需要找到 Hibernate Tools 安装目录下的 `hbmtemplates` 文件夹,这个文件夹包含了默认的模板文件。...

    hibernate4 通用dao,service

    由于没有具体的文件列表,我们无法详细讨论每个文件的内容,但根据标题和描述,我们可以推断这是一个关于使用Hibernate4创建通用DAO和Service的教程或资源,旨在帮助Java开发者理解和应用这种模式来提高开发效率。...

    Struts2+spring+hibernate项目模板例子

    总之,“Struts2+spring+hibernate项目模板例子”是一个完整的Java Web项目实例,展示了这三大框架如何协同工作,为开发者提供了一个学习和实践的基础平台。通过深入理解和实践这个模板,开发者可以更好地掌握企业级...

    vc生成hibernate的dao类

    Hibernate是一个流行的Java ORM(对象关系映射)框架,它简化了Java应用与数据库之间的交互。 在描述中提到的“根据自定义的模板生成java代码”,意味着开发者可能使用了某种代码生成工具,如JCodeGenerator、...

    hibernate模板项目

    Hibernate模板项目为Java开发者提供了一个直观的起点,便于快速上手ORM开发。通过理解并实践项目中的各个部分,开发者可以深入掌握Hibernate的核心功能,从而提高开发效率,降低维护成本。在实际应用中,还可以结合...

    hibernate封装.pdf

    以上就是`HibernateDao`类中封装的Hibernate操作的基本知识点,这个类提供了一个基础的DAO(数据访问对象)模板,方便开发者进行数据库操作。在实际应用中,通常还会添加更多的方法,如更新(update)、保存(save)...

    使用Struts + DAO + Hibernate完成用户登陆

    这个实例不仅提供了一个学习如何整合Struts、DAO和Hibernate的基础模板,也演示了如何在实际项目中实现用户认证这一常见功能。对于初学者,这是一个很好的起点,帮助他们理解这些框架和技术在实际开发中的应用。通过...

    Hibernate通用Dao设计。

    为了解决这个问题,我们可以通过设计一个通用的Hibernate DAO来减少重复工作。 1. **通用Dao的设计思想** - **继承机制**:创建一个基类AbstractHibernateDao,其中包含常用的CRUD(Create, Read, Update, Delete...

    myeclipse中自动生成hibernate的POJO、DAO和hbm.xml文件

    在MyEclipse中,需要新建一个WEB项目来容纳生成的Hibernate文件。具体步骤如下: 1. 新建WEB Project,名为hibernate_demo 2. 在项目上右键-&gt;MyEclipse-&gt;Add HibernateCapabilities,为工程添加Hibernate功能 3. ...

    springmvc+hibernate idea项目模板

    标题中的“SpringMVC+Hibernate IDEA项目模板”指的是一个基于SpringMVC和Hibernate框架的Java Web项目开发模板,适用于IntelliJ IDEA集成开发环境。这个模板可以帮助开发者快速搭建一个具备基本功能的Web应用,减少...

    hibernate不是泛型的通用DAo1

    在这种情况下,"hibernate不是泛型的通用DAo1"可能提供了一个无需继承的DAO实现。例如,`DynamicDao`可能是一个非泛型接口,它包含了一些基本的CRUD操作,可以直接被任何类实现,而不需要指定特定的实体类型。`...

    hibernate自动生成dao,配置文件等的学习笔记,在myeclipse下实现

    Hibernate是一款强大的对象关系映射(ORM)框架,它允许开发者用Java对象来操作数据库,而无需直接编写SQL语句。在本教程中,我们将探讨如何在MyEclipse环境下利用Hibernate工具自动生成DAO(数据访问对象)、POJO...

    hibenate 对DAO的封装

    本主题主要探讨的是如何使用泛型和反射技术来实现Hibernate对DAO的封装,从而创建一个通用的DAO模板,减少开发者重复编写CRUD(Create、Read、Update、Delete)操作的工作。 首先,我们需要理解DAO(Data Access ...

    java ssh通用DAO另类实现示例

    4. 现在,当需要为新的实体创建DAO时,只需继承`HibernateDAO`并创建一个对应的接口,然后通过`Proxy.newProxyInstance()`创建一个代理对象。 ```java public interface UserRepository extends BaseDAO&lt;User&gt; { /...

Global site tag (gtag.js) - Google Analytics