基于Spring的泛型Dao实现

本文介绍了一种基于Spring框架的SSH整合Dao泛型管理实现方法。通过泛型技术,该实现可以支持任意类型的实体对象操作,包括增删改查等基本功能。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

基于Spring的SSH整合Dao泛型管理,简单的写了一下方便以后用

public class GenericHibernateDao<T, ID extends Serializable> extends

        HibernateDaoSupport {
    /**
     * 实体Class.
     */
    private final Class<T> entityClass;

    /**
     * 注入SessionFactory
     *
     * @param SessionFactory
     */
    @Autowired
    @Qualifier("sessionFactory")
    protected void setEntityManagerFactory(SessionFactory sessionFactory) {
        super.setSessionFactory(sessionFactory);
    }

    /**
     * 构造函数,确定实体类型.
     */
    @SuppressWarnings("unchecked")
    public GenericHibernateDao() {
        this.entityClass = (Class<T>) GenericManager.getGeneric(getClass());
    }

    /**
     * @return the entityClass
     */
    public Class<T> getEntityClass() {
        return entityClass;
    }

    /**
     * 按ID返回实体对象.
     *
     * @param id
     *            实体ID.
     * @return T 按返回实体。
     */
    @SuppressWarnings("unchecked")
    public T find(ID id) {
        return (T) getHibernateSession().get(entityClass, id);
    }

    /**
     * 返回全部的实体对象.
     *
     * @return List 返回关于T的LIST.
     */
    @SuppressWarnings("unchecked")
    public Collection<T> findAll() {
        return (Collection<T>) getHibernateSession()
                .createCriteria(entityClass).list();
    }

    /**
     * 插入新的实体对象.
     *
     * @param entity
     *            需要保存的实体对象.
     */
    public void create(T entity) {
        Session session = getHibernateSession();
        session.save(entity);
        session.flush();
    }

    /**
     * 按ID删除相应的实体对象.
     *
     * @param entityId
     *            实体对象ID编号.
     */
    public void delete(ID entityId) {
        if (null != find(entityId)) {
            delete(find(entityId));
        }
    }

    /**
     * 删除相应的实体对象.
     *
     * @param entity
     *            需要保存的实体对象.
     */
    public void delete(T entity) {
        Session session = getHibernateSession();
        session.delete(entity);
        session.flush();
    }

    /**
     * 按ID修改相应的实体对象.
     *
     * @param entity
     *            需要修改的实体对象.
     */
    public void update(T entity) {
        Session session = getHibernateSession();
        session.merge(entity);
        session.flush();
    }

    /**
     * 按ID修改相应的实体对象,当对象包含类型字段时.
     *
     * @param entity
     *            需要修改的实体对象.
     */
    public void updateBlob(T entity) {
        Session session = getHibernateSession();
        session.evict(entity);
        session.update(entity);
        session.flush();
    }

    /**
     * @return Session
     */
    public Session getHibernateSession() {
        return this.getSessionFactory().getCurrentSession();
    }

    /**
     * 取得startIndex页每页pageSize的记录集合.
     *
     * @param detachedCriteria
     *            查询条件对象
     * @param pageSize
     *            每页记录数
     * @param startIndex
     *            起始数
     * @return Collection 结果集
     */
    @SuppressWarnings("unchecked")
    public Collection<T> findPageByCriteria(
            final DetachedCriteria detachedCriteria, final int pageSize,
            final int startIndex) {
        return (Collection<T>) getHibernateTemplate().execute(
                new HibernateCallback() {
                    public Object doInHibernate(Session session) {
                        Criteria criteria = detachedCriteria
                                .getExecutableCriteria(session);
                        criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
                        Collection<T> pageItems = criteria
                                .setFirstResult(startIndex)
                                .setMaxResults(pageSize).list();
                        return pageItems;
                    }
                });

    }

    /**
     * 取得所有记录.
     *
     * @param detachedCriteria
     *            查询条件对象
     * @return Collection 结果集
     */
    @SuppressWarnings("unchecked")
    public Collection<T> findAllByCriteria(
            final DetachedCriteria detachedCriteria) {
        return (Collection<T>) getHibernateTemplate().execute(
                new HibernateCallback() {
                    public Object doInHibernate(Session session) {
                        Criteria criteria = detachedCriteria
                                .getExecutableCriteria(session);
                        return criteria.list();
                    }
                });
    }

    /**
     * 计算记录的总数.
     *
     * @param detachedCriteria
     *            查询条件对象
     * @return int
     */
    public int getCountByCriteria(final DetachedCriteria detachedCriteria) {
        Integer count = (Integer) getHibernateTemplate().execute(
                new HibernateCallback() {
                    public Object doInHibernate(Session session) {
                        Criteria criteria = detachedCriteria
                                .getExecutableCriteria(session);
                        return criteria.setProjection(Projections.rowCount())
                                .uniqueResult();
                    }
                });
        return count.intValue();
    }

    /**
     * 根据索引得到分页查询结果
     *
     * @param queryString
     *            查询HSql
     * @param values
     *            值
     * @param firstReslut
     *            开始索引
     * @param maxResults
     *            最大数目
     * @return
     * @throws DataAccessException
     */
    @SuppressWarnings("unchecked")
    public List findByPage(final String queryString, final Object[] values,
            final int firstReslut, final int maxResults)
            throws DataAccessException {

        return (List) getHibernateTemplate().execute(new HibernateCallback() {
            public Object doInHibernate(Session session)
                    throws HibernateException {
                Query queryObject = session.createQuery(queryString);
                if (maxResults > 0 && firstReslut >= 0) {
                    queryObject.setFirstResult(firstReslut);
                    queryObject.setMaxResults(maxResults);
                }
                if (values != null) {
                    for (int i = 0; i < values.length; i++) {
                        queryObject.setParameter(i, values[i]);
                    }
                }
                return queryObject.list();
            }

        });
    }
}
为什么我们要使用通用DAO接口呢,因为我们的数据库操作无非是增删改查,CRUD操作,我们不需要为每个实体去编写一个dao接口,对于相似的实体操作可以只编写一个通用接口,然后采用不同的实现DAO已经成为持久层的标准模式,DAO使结构清晰,面向接口编程为代码提供了规范。而DAO是一个类安全的,代码精简的设计模式(相对于传统DAO),尤其在DAO组件数量庞大的时候,代码量的减少更加明显。 DAO的核心是定义一个GenericDao接口,声明基本的CRUD操作: 用hibernate作为持久化解决方案的GenericHibernateDao实现类,被定义为抽象类,它提取了CRUD操作,这就是简化代码的关键,以便于更好的重用,这个就不给例子了,增删改都好写,查就需要各种条件了。 然后是各个领域对象的dao接口,这些dao接口都继承GenericDao接口,这样各个领域对象的dao接口就和传统dao接口具有一样的功能了。 下一步是实现类了,个自领域对象去实现各自的接口,还要集成上面的抽象类,这样就实现了代码复用的最大化,实现类中只需要写出额外的查询操作就可以了。当然还要获得域对象的Class实例,这就要在构造方法中传入Class实例。用spring提供的HibernateTemplate注入到GenericHibernateDao中,这样在各个实现类就可以直接调用HibernateTemplate来实现额外的查询操作了。 如果在实现类中不想调用某个方法(例如:update()),就可以覆盖它,方法中抛出UnsupportedOperationException()异常。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值