最常用的hibernate的接口和实现类

import java.util.List;
/**
 * @file_name BaseDao.java
 * @author janson_chang
 * @param <E>
 * @todo BaseDao
 */
public interface BaseDao<E> {
/**
 * 返回ID=ID的持久對象
 * @param id
 * @return E
 */
public E get(String id);
/**
 * 返回ID=ID的代理對象
 * @param id
 * @return E
 */
public E load(String id);
/**
 * 返回根據字段的得到的持久對象
 * @param name
 * @param value
 * @return E
 */
public E loadBy(String name, Object value);
/**
 * 返回根據數組字段的得到的持久對象
 * @param names
 * @param values
 * @return E
 */
public E loadBy(String[] names, Object[] values);
/**
 * 返回保存的對象的ID
 * @param entity
 * @return String
 */
public String save(E entity);
/**
 * 更新對象信息
 * @param entity
 */
public void update(E entity);
/**
 * saveOrUpdate對象信息
 * @param entity
 */
public void saveOrUpdate(E entity);
/**
 * 刪除對象
 * @param entity
 */
public void delete(E entity);
/**
 * 返回所有的對象信息list
 * @return List<E>
 */
public List<E> listAll();
/**
 * 根據字段name和數據value返回對象list
 * @param name
 * @param value
 * @return List<E>
 */
public List<E> findBy(String name, Object value);
/**
 * 根據數組字段name,數據value返回對象list
 * @param names
 * @param values
 * @return List<E>
 */
public List<E> findBy(String[] names, Object[] values);
/**
 * 更新内存中的數據
 * @param entity
 */
public void refresh(E entity);
/**
 * 提交内存中的數據
 */
public void flush();
/**
     * 根据域对象类和条件查询对象查询一组域对象
     * @param <T>
     * @param clazz
     * @param enhanceRule
     * @return
     */
     List<E> query(Class clazz, EnhancedRule enhanceRule);
/**
 * 执行SQL
 */
public void executeSQL(String sql);
/**
 * 执行HSQL,语句必须符合HSQL规范
 */
public List<E> queryHQL(String sql);
/**
 * 执行本地SQL
 */
public List<E> queryNQL(String sql);
}

import java.lang.reflect.ParameterizedType;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

/**
 * @file_name BaseDaoHibernateImpl.java
 * @author janson_chang
 * @param <E>
 * @todo BaseDaoHibernateImpl<E>
 */
@SuppressWarnings("unchecked")
public class BaseDaoHibernateImpl<E> extends HibernateDaoSupport implements BaseDao<E> {
/**
 * 
 */
protected Class<E> entityClass;

/**
 * 
 */
protected Logger log = Logger.getLogger(this.getClass());

/**
 * 
 * 
 */
public BaseDaoHibernateImpl() {
super();
entityClass = (Class<E>) ((ParameterizedType) getClass().getGenericSuperclass())
.getActualTypeArguments()[0];
}
/**
 * 
 * @param entityClassName
 * @throws ClassNotFoundException
 */
public void setEntityClass(String entityClassName) throws ClassNotFoundException {
this.entityClass = (Class<E>)Class.forName(entityClassName);
}
/**
 * 
 * @param entityClass 
 */
public void setEntityClass(Class<E> entityClass) {
this.entityClass = entityClass;
}
/**
 * 返回Criteria
 * 
 * @return Criteria
 */
protected Criteria getCriteria() {
Criteria criteria = getSession().createCriteria(entityClass);
criteria.setCacheable(true);
return criteria;
}
public void executeSQL(String sql){
getSession().createSQLQuery(sql).executeUpdate();
}
public List<E> queryHQL(String sql){
return getSession().createQuery(sql).list();
}
public List<E> queryNQL(String sql){
return getSession().createSQLQuery(sql).list();
}
/**
 * @param entity
 */
public void delete(E entity) {
getHibernateTemplate().delete(entity);
flush();
}

/**
 * @param name
 * @param value
 * @return List<E>
 * 
 */
public List<E> findBy(String name, Object value) {
return findBy(new String[] { name }, new Object[] { value });
}

/**
 * @param names
 * @param values
 * @return List<E>
 * 
 */
@SuppressWarnings ("unchecked")
public List<E> findBy(String[] names, Object[] values) {
if (names == null || values == null || names.length != values.length) {
throw new HibernateException("Illegal name and values" + names + ":" + values);
}
Criteria criteria = getCriteria();
Map<String, Object> criteriaMap = new HashMap<String, Object>();
for (int i = 0; i < names.length; i++) {
criteriaMap.put(names[i], values[i]);
}
criteria.add(Restrictions.allEq(criteriaMap));
criteria.setCacheable(true);
return criteria.list();
}

/**
 * 
 */
public void flush() {
getHibernateTemplate().flush();
}

/**
 * @param id
 * @return E
 */
public E get(String id) {
return (E) getHibernateTemplate().get(entityClass, id);
}

/**
 * @return List<E>
 * 
 */
public List<E> listAll() {
return getHibernateTemplate().loadAll(entityClass);
}

/**
 * @param id
 * @return E
 */
public E load(String id) {
return (E) getHibernateTemplate().load(entityClass, id);
}

/**
 * @param name
 * @param value
 * @return E
 * 
 */
public E loadBy(String name, Object value) {
return loadBy(new String[] { name }, new Object[] { value });
}

/**
 * @param names
 * @param values
 * @return E
 * 
 */
public E loadBy(String[] names, Object[] values) {
E result = null;
List<E> resultList = findBy(names, values);
if (resultList.size() > 0) {
result = resultList.get(0);
}
return result;
}

/**
 * @param entity
 * 
 */
public void refresh(E entity) {
getHibernateTemplate().refresh(entity);
}
/**
 * @param entity
 * @return String
 */
public String save(E entity) {
return (String) getHibernateTemplate().save(entity);
}
/**
 * @param entity
 * 
 */
public void saveOrUpdate(E entity) {
getHibernateTemplate().saveOrUpdate(entity);
}
/**
 * @param entity
 * 
 */
public void update(E entity) {
getHibernateTemplate().update(entity);
}
public List<E> query(Class clazz, EnhancedRule enhanceRule) {
        if (enhanceRule == null) {
            return listAll();
        }
        return enhanceRule.getCriteria (clazz, getSession (false)).list ();
}
}