DAO层使用泛型的两种方式

最新推荐文章于 2025-06-16 14:20:41 发布
转载 最新推荐文章于 2025-06-16 14:20:41 发布 · 623 阅读 · 0
文章标签：

#DAO层使用泛型类

DAO层使用泛型的两种方式

1.DAO层使用泛型类，主要是定义一些通用的增删改查，然后其他DAO的类都来继承该类，通过构造方法将class对象传给该泛型类-

定义泛型接口

package sanitation.dao;

import java.util.List;
/**
 *
 * @param <T>
 */

public interface GenericDAO <T>{
    /**
     * 通过ID获得实体对象
     * 
     * @param id实体对象的标识符
     * @return 该主键值对应的实体对象
     */
    T findById(int id);

    /**
     * 将实体对象持久化
     * 
     * @param entity 需要进行持久化操作的实体对象
     * @return 持久化的实体对象
     */
    T makePersitent(T entity); 

    /**
     * 将实体变为瞬态
     * 
     * @param entity需要转变为瞬态的实体对象
     */
    void makeTransient(T entity);

    /**
     * 将一系列的实体变为瞬态，使用本地sql
     * 
     * @param hql
     */
    void makeTransientByIds(String sql);

    /**
     * 
     * 使用hql语句进行分页操作
     * 
     * @param hql    
     * @param offset    第一条记录索引
     * @param pageSize    每页需要显示的记录数
     * @return    查询的记录
     */
    List<T> findByPage(final String hql,final int offset,final int pageSize);


    /**
     * 使用hql 语句进行分页查询操作
     * 
     * @param hql 需要查询的hql语句
     * @param value 如果hql有一个参数需要传入，value就是传入的参数
     * @param offset 第一条记录索引
     * @param pageSize 每页需要显示的记录数
     * @return 当前页的所有记录
     */
    List<T> findByPage(final String hql , final Object value ,
             final int offset, final int pageSize);

    /**
     * 使用hql 语句进行分页查询操作
     * 
     * @param hql 需要查询的hql语句
     * @param values 如果hql有一个参数需要传入，value就是传入的参数
     * @param offset 第一条记录索引
     * @param pageSize 每页需要显示的记录数
     * @return 当前页的所有记录
     */
    List<T> findByPage(final String hql, final Object[] values,
             final int offset, final int pageSize);


    /**
     * 使用sql 语句进行分页查询操作
     * 
     * @param sql
     * @param offset
     * @param pageSize
     * @return
     */
    List findByPageSQL(final String sql, 
             final int offset, final int pageSize);

    /**
     * 根据语句查找总数
     * @param hql hql语句
     * @return 对应的数目
     */
    Integer getCount(String hql);


    void updateObj(final String hql,final Object[] values);
}

定义实现类

package sanitation.dao.impl;

import java.sql.SQLException;
import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import sanitation.dao.GenericDAO;

public class GenericHibernateDAO<T> extends HibernateDaoSupport 
    implements GenericDAO<T>{

    private Class<T> persistentClass;

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

    public Class<T> getPersistentClass(){
        return persistentClass;
    }

    @SuppressWarnings("unchecked")
    public T findById(int id) {
        return (T)getHibernateTemplate().get(getPersistentClass(), id);
    }

    @SuppressWarnings("unchecked")
    public List<T> findByPage(final String hql, 
         final int offset, final int pageSize){
        List<T> list= getHibernateTemplate().executeFind(new HibernateCallback(){
                public Object doInHibernate(final Session session)
                    throws HibernateException, SQLException{
                    Query query=session.createQuery(hql);
                    if(!(offset==0 && pageSize==0)){
                        query.setFirstResult(offset).setMaxResults(pageSize);
                    }
                    List<T> result = query.list();
                    return result;
                }
            });
        return list;
    }

    @SuppressWarnings("unchecked")
    public List findByPageSQL(final String sql, 
         final int offset, final int pageSize){
        List list= getHibernateTemplate().executeFind(new HibernateCallback(){
                public Object doInHibernate(final Session session)
                    throws HibernateException, SQLException{
                    Query query=session.createSQLQuery(sql);
                    if(!(offset==0 && pageSize==0)){
                        query.setFirstResult(offset).setMaxResults(pageSize);
                    }
                    List result = query.list();
                    return result;
                }
            });
        return list;
    }


    @SuppressWarnings("unchecked")
    public List<T> findByPage(final String hql, final Object value, 
            final int offset, final int pageSize) {
        List<T> list = getHibernateTemplate().executeFind(new HibernateCallback()
        {
            public Object doInHibernate(Session session)
                throws HibernateException, SQLException
            {
                Query query=session.createQuery(hql).setParameter(0, value);
                if(!(offset==0 && pageSize==0)){
                    query.setFirstResult(offset).setMaxResults(pageSize);
                }
                List<T> result = query.list();
                return result;
            }
        });
        return list;
    }

    @SuppressWarnings("unchecked")
    public List<T> findByPage(final String hql, final Object[] values, final int offset,
            final int pageSize) {
        List<T> list = getHibernateTemplate().executeFind(new HibernateCallback(){
            public Object doInHibernate(Session session)
                throws HibernateException, SQLException{
                Query query=session.createQuery(hql);
                for (int i = 0 ; i < values.length ; i++){
                    query.setParameter( i, values[i]);
                }
                if(!(offset==0 && pageSize==0)){
                    query.setFirstResult(offset).setMaxResults(pageSize);
                }
                List<T> result = query.list();
                return result;
            }
        });
    return list;
    }


    public void updateObj(final String hql, final Object[] values) {
        getHibernateTemplate().execute(new HibernateCallback(){
            public Object doInHibernate(Session session)
            throws HibernateException, SQLException{
                Query query=session.createQuery(hql);
                for(int i=0;i<values.length;i++){
                    query.setParameter( i, values[i]);
                }
                query.executeUpdate();
                return null;    
            }
        });
    }

    public Integer getCount(String hql) {
        Integer count;
        //iterate方法与list方法的区别是list取出全部，iterator取出主键，迭代的时候才取出数据
        count = ((Long)getHibernateTemplate().iterate(hql).next()).intValue();
        return count;
    }

    public T makePersitent(T entity) {
        getHibernateTemplate().saveOrUpdate(entity);
        return entity;
    }

    public void makeTransient(T entity) {
        getHibernateTemplate().delete(entity);
    }

    public void makeTransientByIds(final String sql) {
        getHibernateTemplate().execute(new HibernateCallback(){
            public Object doInHibernate(Session session)
            throws HibernateException, SQLException{
                Query query=session.createQuery(sql);
                query.executeUpdate();
                return null;
            }
        });
    }

}

2.而有时我们为了方便起见，对于一些简单的项目，DAO的操作很单一，不会有很复杂的操作，那么我们直接用泛型方法类代替泛型类，主要就不需要写其他的DAO来继承，整个DAO层就一个DAO类。

接口：

package com.xidian.dao;

import java.util.List;

import com.xidian.bean.Admin;
import com.xidian.bean.HostIntroduce;
import com.xidian.bean.Reply;

public interface CommonDAO {
    public <T> void sava(T entity);                                        //保存用户，无返回值；
    public <T> void remove(T entity);                                    //删除用户
    public <T> void update(T entity);                                    //更新用户
    public <T> T findById(Class<T> entityClass, Integer id);            //通过id来查找某一个用户；
    public <T> List<T> findAll(Class<T> entityclass);                    //使用范型List<>，查询所有的用户信息

}

实现类：

package com.xidian.dao.impl;

import java.util.List;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.xidian.bean.Admin;
import com.xidian.bean.HostIntroduce;
import com.xidian.bean.Reply;
import com.xidian.dao.CommonDAO;

public class CommonDAOImpl extends HibernateDaoSupport implements CommonDAO {
    @SuppressWarnings("unchecked")
    @Override
    public <T> List<T> findAll(Class<T> entityclass) {
        //String name = entity.getClass().getName();
        String hql = "from "+entityclass.getName()+" as aaa order by aaa.id desc";
        return this.getHibernateTemplate().find(hql);
    }

    @SuppressWarnings("unchecked")
    @Override
    public <T> T findById(Class<T> entityClass, Integer id) {
        return (T) this.getHibernateTemplate().get(entityClass, id);
    }

    @Override
    public <T> void remove(T entity) {
        this.getHibernateTemplate().delete(entity);
    }

    @Override
    public <T> void sava(T entity) {
        this.getHibernateTemplate().save(entity);
    }

    @Override
    public <T> void update(T entity) {
        this.getHibernateTemplate().update(entity);
    }

}

使用泛型可以使代码大大的精简

一个很好的通用泛型dao（含源码）
07-29
为什么我们要使用通用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()异常。
泛型DAO
十年饮冰，难凉热血
07-29 1192
泛型DAO标准： 在公司里面，用的基本上都是泛型DAO，实现了代码的重用性。 目录结构如下：
Java泛型DAO设计模式详解与实践
最新发布
weixin_30598047的博客
06-16 981
数据访问对象（Data Access Object，简称DAO）是软件设计模式中的一种，用于将低级数据访问层与高级业务逻辑层分离的一种抽象。DAO模式通常通过封装数据库操作（如CRUD：创建、读取、更新、删除），以简化业务逻辑层的代码。DAO通常包含了与数据库交互所需的所有方法，它能将数据源的变化对业务逻辑层的影响降到最低，增强系统的可维护性和可扩展性。在Java中，DAO通常通过接口与实现类来定义，使得具体的数据访问逻辑与业务逻辑代码分离，从而提高了代码的可维护性。
泛型接口Dao层应用
aidupo6157的博客
06-02 153
class User { private int id; private String name; private int age; public User(int id, String name, int age) { this.id = id; this.name = name; ...
泛型DAO(翻译)
kevintse
12-27 246
[size=24][color=brown]泛型DAO[/color][/size] 原文地址:[url]http://www.hibernate.org/328.html[/url] [color=darkred]由于本人能力有限,加上来不及校对, 难免有些地方出现错误或者表达得不是特别准确,欢迎批评指正.[/color] 这是一个来自[url=http://caveatemp...
泛型dao 泛型dao 泛型dao
09-21
泛型serviceimpl与serviceimpl实现和dao层实现一样。 Action ： SavePersonAction直接调用PersonService。 下面是代码 为了演示减少代码量而且直观去掉些方法方便读者自己扩展写出适合自己的代码,这里我只...
ssh2 + dao泛型
04-06
这篇博客"ssh2 + dao泛型"结合了这两个概念，探讨了如何在SSH2框架下利用泛型优化DAO层的操作。 SSH2框架主要由Spring、Struts和Hibernate三个部分组成，它为Java Web开发提供了强大的支持。Spring提供依赖注入和...
Spring+Hibernate框架下的泛型DAO实现与使用
泛型DAO允许我们以一种类型安全的方式处理各种类型的实体类，而无需为每种实体类单独编写DAO。 在给出的文档中，`com.th.huz.GenericDao`接口被定义为泛型接口，它有两个类型参数：`T` 和 `PK`。`T` 表示我们需要...
Hibernate泛型DAO及使用方法.doc
05-06
泛型DAO的使用不仅简化了DAO层的代码，还降低了维护成本。开发者只需要关注业务逻辑，而无需关心底层的数据库操作细节。此外，由于接口是泛型的，所以它可以被应用于任何需要与数据库交互的领域，无论实体类是什么。...
泛型dao
04-21
NULL 博文链接：https://rooi.iteye.com/blog/1032620
DAO泛型写法很好用
10-16
DAO泛型写法很好用 hibernate支持
使用 Hibernate 和 Spring AOP 构建泛型类型安全的 DAO
baggio785的专栏
06-07 2796
对于大多数开发人员，为系统中的每个 DAO 编写几乎相同的代码到目前为止已经成为一种习惯。虽然所有人都将这种重复标识为 “代码味道”，但我们大多数都已经学会忍受它。其实有解决方案。可以使用许多 ORM 工具来避免代码重复。例如，使用 Hibernate，您可以简单地为所有的持久域对象直接使用会话操作。这种方法的缺点是损失了类型安全。为什么您要为数据访问代码提供类型安全接口？我会争辩说，当它与现
通用DAO设计（泛型方法）
jaesonchen
04-17 269
import java.io.Serializable; import java.util.List; public interface CommonDao { public &lt;T extends Serializable&gt; T save(T model); public &lt;T extends Serializable&gt; void ...
浅谈Java——泛型DAO
mosterRan的博客
11-09 404
首先解释一下为什么要学习泛型DAO。平时在写DAO的时候是一个接口对应一个实现类，实现类里面要写很多的操作数据库的方法。当我们有很多的javaben的时候我们会写很多的接口和实现类，并且里面的代码都是相同的，这样太麻烦，我们就不能写一个类，在类里面传入泛型，让类根据泛型，创建出一个实例对象，这样就出现了泛型DAO。 一、需要提前准备的知识如下 反射关键的类： Class&lt;T&gt;类 ...
DAO泛型使用
SanBa
01-05 3390
这是一个来自CaveatEmptor实例应用,在JDK5.0下实现的DAO模式. 这个模式在Java Persistence With Hibernate里面也有讲到. 另外有两个链接,可能会对你有用, Sessions and transactions 和 Open Session in View. 这次的DAO例子是基于接口的.很多工具, 像Hibernate已经提供了数据库的便
通用的DAO，运用泛型
qq_42677665的博客
07-21 523
方式一：构造方法中传入一个Class 1、通用的DAO的接口 package com.itheima.crm.dao; import java.io.Serializable; import java.util.List; import org.hibernate.criterion.DetachedCriteria; /** * 通用DAO的接口 * @author tycoon...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值