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);
}

}

使用泛型可以使代碼大大的精簡

?

轉載于:https://www.cnblogs.com/shenliang123/archive/2012/04/05/2433134.html

總結

以上是生活随笔為你收集整理的DAO层使用泛型的两种方式的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。