hibernate通用方法接口与实现

hibernate通用方法接口（一）

package com.diyjava.dao;

import java.io.Serializable;
import java.util.List;

/**
 * 一些通用的CRUD方法接口
 * http://www.diyjava.com
 * @author colin
 *
 * @param <T>
 */
public interface BaseDao<T extends Serializable> {
 /**
  * 添加对象
  *
  * @param t
  * @return
  */
 T add(T t);

 /**
  * 修改对象
  *
  * @param t
  * @return
  */
 T update(T t);

 /**
  * 删除对象
  *
  * @param t
  * @return
  */
 T remove(T t);

 /**
  * 按id进行删除对象
  *
  * @param id
  * @return
  */
 T removeById(Serializable id);

 /**
  * 按id进行查询对象
  *
  * @param id
  * @return
  */
 T load(Serializable id);

 /**
  * 按id进行查询对象
  *
  * @param id
  * @param lock
  *            是否锁定对象
  * @return
  */
 T load(Serializable id, bOOlean lock);

 /**
  * 按id进行查询对象
  *
  * @param id
  * @return
  */
 T get(Serializable id);

 /**
  * 查询对象
  *
  * @param first
  *            记录开始位置
  * @param max
  *            返回最大的记录数
  * @return
  */
 List<T> find(int first, int max);

 /**
  * 按条件进行查询
  *
  * @param parameter
  *            属性
  * @param value
  *            属性对应的值
  * @return
  */
 List<T> find(String[] parameter, Object[] value);

 /**
  * 按条件进行查询，返回从first开始的max条记录
  *
  * @param parameter
  *            属性
  * @param value
  *            属性对应的值
  * @param first
  *            记录起始位置
  * @param max
  *            返回最大的记录
  * @return
  */
 List<T> find(String[] parameter, Object[] value, int first, int max);

 /**
  * 按条件进行查询并进行排序，返回从first开始的max条记录
  *
  * @param parameter
  *            属性
  * @param value
  *            属性对应的值
  * @param first
  *            记录起始位置
  * @param max
  *            返回最大的记录
  * @param order
  *            排序
  * @return
  */
 List<T> find(String[] parameter, Object[] value, int first, int max,
   String[][] order);

 /**
  * 查找所有结果
  *
  * @return
  */
 List<T> findAll();
 
 /**
  * 查找所有结果并进行排序
  * @param order
  * @return
  */
 List<T> findAll(String[][] order);
}

 

 

接口实现请参考http://www.diyjava.com/kyjs/ShowArticle.asp?ArticleID=6289

引用请注明出处：http://www.diyjava.com

 

hibernate通用方法接口实现（二）

package com.diyjava.dao;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.sql.SQLException;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.hibernateException;
import org.hibernate.LockMode;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.orm.hibernate3.hibernateCallback;
import org.springframework.orm.hibernate3.support.hibernateDaoSupport;
import org.springframework.util.Assert;

/**
 * 实现通用的CRUD方法
 * http://www.diyjava.com
 * @author colin
 *
 * @param <T>
 */
public abstract class BaseDaoImpl<T extends Serializable> extends
  hibernateDaoSupport implements BaseDao<T> {
 public Logger log = LoggerFactory.getLogger(getClass());

 private Class<T> persistentClass = null;

 @SuppressWarnings("unchecked")
 public BaseDaoImpl() {
  this.persistentClass = (Class<T>) ((ParameterizedType) getClass()
    .getGenericSuperclass()).getActualTypeArguments()[0];
 }

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

 public T add(T t) {
  Assert.notNull(t);
  gethibernateTemplate().save(t);
  return t;
 }

 public T update(T t) {
  Assert.notNull(t);
  gethibernateTemplate().saveOrUpdate(t);
  return t;
 }

 public T remove(T t) {
  Assert.notNull(t);
  gethibernateTemplate().delete(t);
  return t;
 }

 public T removeById(Serializable id) {
  Assert.notNull(id);
  T entity = load(id);
  gethibernateTemplate().delete(entity);
  return entity;
 }

 public T load(Serializable id) {
  Assert.notNull(id);
  return load(id, false);
 }

 @SuppressWarnings("unchecked")
 public T load(Serializable id, bOOlean lock) {
  Assert.notNull(id);
  T entity = null;
  if (lock) {
   entity = (T) gethibernateTemplate().load(getPersistentClass(), id,
     LockMode.UPGRADE);
  } else {
   entity = (T) gethibernateTemplate().load(getPersistentClass(), id);
  }
  return entity;
 }

 @SuppressWarnings("unchecked")
 public T get(Serializable id) {
  Assert.notNull(id);
  T entity = (T) gethibernateTemplate().get(getPersistentClass(), id);
  return entity;
 }

 @SuppressWarnings("unchecked")
 public List<T> find(final int first, final int max) {
  return (List<T>) gethibernateTemplate().execute(
    new hibernateCallback() {
     public Object doInhibernate(Session session)
       throws hibernateException, SQLException {
      Criteria criteria = session
        .createCriteria(getPersistentClass());
      criteria.setFirstResult(first);
      criteria.setMaxResults(max);
      return criteria.list();
     }
    });
 }

 @SuppressWarnings("unchecked")
 public List<T> find(final String[] parameter, final Object[] value) {
  return (List<T>) gethibernateTemplate().execute(
    new hibernateCallback() {
     public Object doInhibernate(Session session)
       throws hibernateException, SQLException {
      Criteria criteria = session
        .createCriteria(getPersistentClass());
      for (int i = 0; i < parameter.length; i++) {
       criteria.add(Restrictions
         .eq(parameter[i], value[i]));
      }
      return criteria.list();
     }
    });
 }

 @SuppressWarnings("unchecked")
 public List<T> find(final String[] parameter, final Object[] value,
   final int first, final int max) {
  return (List<T>) gethibernateTemplate().execute(
    new hibernateCallback() {
     public Object doInhibernate(Session session)
       throws hibernateException, SQLException {
      Criteria criteria = session
        .createCriteria(getPersistentClass());
      for (int i = 0; i < parameter.length; i++) {
       criteria.add(Restrictions
         .eq(parameter[i], value[i]));
      }
      criteria.setFirstResult(first);
      criteria.setMaxResults(max);
      return criteria.list();
     }
    });
 }

 @SuppressWarnings("unchecked")
 public List<T> find(final String[] parameter, final Object[] value,
   final int first, final int max, final String[][] order) {
  return (List<T>) gethibernateTemplate().execute(
    new hibernateCallback() {
     public Object doInhibernate(Session session)
       throws hibernateException, SQLException {
      Criteria criteria = session
        .createCriteria(getPersistentClass());
      for (int i = 0; i < parameter.length; i++) {
       criteria.add(Restrictions
         .eq(parameter[i], value[i]));
      }//end条件过滤
      for (int j = 0; j < order.length; j++) {
       criteria
         .addOrder(order[j][1]
           .compareToIgnoreCase("asc") == 0 ? Order
           .asc(order[j][0])
           : Order.desc(order[j][0]));
      }//end排序
      criteria.setFirstResult(first);
      criteria.setMaxResults(max);

      return criteria.list();
     }
    });
 }

 @SuppressWarnings("unchecked")
 public List<T> findAll() {
  return gethibernateTemplate().find(
    "from " + getPersistentClass().getName());
 }

 @SuppressWarnings("unchecked")
 public List<T> findAll(final String[][] order) {
  return (List<T>) getHibernateTemplate().execute(new hibernateCallback() {
   public Object doInhibernate(Session session)
     throws hibernateException, SQLException {
    Criteria criteria = session
      .createCriteria(getPersistentClass());
    for (int i = 0; i < order.length; i++) {
     criteria
       .addOrder(order[i][1].compareToIgnoreCase("asc") == 0 ? Order
         .asc(order[i][0])
         : Order.desc(order[i][0]));
    }
    return criteria.list();
   }
  });
 }

}

 

接口请参考http://www.diyjava.com/kyjs/ShowArticle.asp?ArticleID=6288

引用请注明出处：http://www.diyjava.com

评论

1 楼 YSOLA4 2011-08-10  

那个~ 想问下实现类为什么要用abstract呢？ 有什么好处？ 不用abstract的话效果好像也是一样啊？