对dao层的所有dao类设计一个Interface,为了针对接口编程

接口的参数写成Object 然后在具体类中用instanceof判断类型，具体调用哪个方法

接口里面的方法参数设置为Object.........这个接口是你设计的，你肯定知道参数传递的规定.....至于如果你说到后期给别人开发的话，那就在前期写全注释.....别人也能清楚你的参数传递规定，判断Object的类型，在DAO里别做.....留给Service层去做........

http://blog.csdn.net/APOLLO_TS/archive/2010/02/24/5322131.aspx

public interface BaseDao<T> {    /**
     * List by page.
     *
     * @param queryStr the query str
     * @param offest the offest
     * @param limit the limit
     *
     * @return the list< t>
     */
    List<T> listByPage(String queryStr, int offest, int limit);
}

把参数设置为object和参数的类

下面这些是 JPA 的，可以参考一下：import java.io.Serializable;
import java.util.List;interface BaseDao<T> {    /**
     * 根据主键值查询记录
     * @param id
     * @return
     * 2009-11-25 上午11:32:36
     */
    public T find(Serializable id);

    /**
     * 翻页查询数据记录
     * @param page
     * @return
     * 2009-11-25 上午11:32:49
     */
    public List<T> getPageData(int page);

    /**
     * 设置页数大小
     *
     * @param pageSize
     * 2009-11-26 上午10:56:42
     */
    public void setPageSize(int pageSize);

    /**
     * 获得分页查询时页数大小
     *
     * @return
     * 2009-11-26 上午10:58:12
     */
    public int getPageSize();

    /**
     * 删除受托管对象
     * @param t
     * 2009-11-25 上午11:33:01
     */
    public void remove(T t);

    /**
     * 合并非托管对象
     * @param t
     * 2009-11-25 上午11:33:10
     */
    public void merge(T t);

    /**
     * 持久化对象
     * @param t
     * 2009-11-25 上午11:33:23
     */
    public void persist(T t);

    /**
     * 获得数据记录总数
     * @return
     * 2009-11-25 上午11:33:31
     */
    public Long count();

    /**
     * 根据字段名和字段值为条件查询记录数
     * @param fieldNames
     * @param values
     * @return
     * 2009-11-26 上午11:16:47
     */
    public Long count(String[] fieldNames, Object... values);

    /**
     * 刷新 EntityManager 强行 EntityManager 刷新缓冲区
     *
     * 2009-11-25 上午11:33:39
     */
    public void flush();

    /**
     * 清空 EntityManager 中所托管所有的对象
     *
     * 2009-11-25 上午11:34:08
     */
    public void clear();

    /**
     * 判断对象是否处于受托管状态
     * @return
     * 2009-11-25 上午11:34:23
     */
    public boolean isManaged(T t);
}import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;import com.jingdian.om.server.util.SystemConfig;/**
* JPA dao 基类<br />
* 用于实现一些常用的
*
* 2009-11-2 下午03:31:07
*/
public class JpaBaseDao<T> implements BaseDao<T> {

    @PersistenceContext
    protected EntityManager em;

    /**
     * Entity 的 Class 对象
     */
    private Class<T> entityClass;

    private int pageSize;

    private final String baseCount;

    @SuppressWarnings("unchecked")
    public JpaBaseDao() {
        // 获得参数化类型中的 Class 对象
        Type genType = getClass().getGenericSuperclass();
        Type[] params = ((ParameterizedType)genType).getActualTypeArguments();
        entityClass = (Class)params[0];
        this.pageSize = SystemConfig.PAGE_SIZE;
        baseCount = "SELECT count(t.id) FROM " + entityClass.getSimpleName() + " t";
    }    /**
     * 根据主键查找实体
     */
    public T find(Serializable id) {
        return em.find(entityClass, id);
    }    /**
     * 获得所有的数据
     */
    @SuppressWarnings("unchecked")
    public List<T> getPageData(int page) {
        String jpql = "SELECT t FROM " + entityClass.getSimpleName() + " t";
        Query q = em.createQuery(jpql);
        q.setFirstResult((page - 1) * pageSize);
        q.setMaxResults(pageSize);
        return (List<T>)q.getResultList();
    }    /**
     * 合并实体
     */
    public void merge(T t) {
        em.merge(t);
    }    /**
     * 持久化实体
     */
    public void persist(T t) {
        em.persist(t);
    }    /**
     * 删除实体
     */
    public void remove(T t) {
        em.remove(t);
    }    /**
     * 获得记录总数
     */
    public Long count() {
        return count(null);
    }

    public Long count(String[] fieldNames, Object... values) {
        Query query = null;
        if(fieldNames == null || values == null || fieldNames.length == 0 ||
                values.length == 0 || fieldNames.length != values.length) {
            query = em.createQuery(baseCount);
        } else {
            StringBuffer sb = new StringBuffer(baseCount);
            sb.append(" WHERE");
            for(int i = 0; i < fieldNames.length; i++) {
                if(i > 0) {
                    sb.append(" AND");
                }
                sb.append(" t.").append(fieldNames[i]).append(" = ?").append(i + 1);
            }
            query = em.createQuery(sb.toString());
            for(int i = 0; i < values.length; i++) {
                query.setParameter(i + 1, values[i]);
            }
        }
        return (Long)em.createQuery(baseCount).getSingleResult();
    }    public void flush() {
        em.flush();
    }

    public void clear() {
        em.clear();
    }

    public boolean isManaged(T t) {
        return em.contains(t);
    }    public void setPageSize(int pageSize) {
        this.pageSize = (pageSize < 1) ? SystemConfig.PAGE_SIZE : pageSize;
    }

    public int getPageSize() {
        return this.pageSize;
    }
}继承这个 JpaBaseDao 加上泛型参数就可以了，比如：public class UserDao extends JpaBaseDao<UserDao>不过，我感觉这种基类的 DAO 实用性不大，因为大多数的数据库操作并不只是简单地操纵一张表。

泛型化的Dao接口http://www.phome.asia/forum/thread/16526.html

申明一个Dao继承HibernateDaoSupport，使用泛型
public class Dao<Pojo extends BaseObject> extends HibernateDaoSupport{
// ...
}pojo是实体类，BaseObject是所有实体类的父类

然后BaseDao登场：
public class BaseDao<Pojo extends BaseObject> extends Dao{
// ....
}然后所有的Dao都继承BaseDao

调试易

对dao层的所有dao类设计一个Interface,为了针对接口编程

解决方案 »