Hibernate底层操作

package com.soft.common;

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

import com.soft.Exception.CommonException;
import com.soft.query.HqlExecute;

/**
 *
 * @author  通用接口
 */
public interface ICommon<POJO> {
 /**
  * 添加对象
  *
  * @param Object
  * @throws CommonException
  */
 public abstract void insert(POJO obj) throws CommonException;

 /**
  * 修改对象
  *
  * @param Object
  * @throws CommonException
  */
 public abstract void update(POJO obj) throws CommonException;

 /**
  * 删除对象
  *
  * @param object
  * @throws CommonException
  */
 public abstract void delete(POJO obj) throws CommonException;

 /**
  * 根据主键查询对象
  *
  * @param Class
  * @param id
  * @return Object
  * @throws CommonException
  */
 public abstract POJO getById(Class cl, Serializable id)
   throws CommonException;

 /**
  * 根据主键删除对象
  *
  * @param Class
  * @param id
  * @throws CommonException
  */
 public abstract void deleteById(Class cl, Serializable id)
   throws CommonException;

 /**
  * 批量删除
  *
  * @param Class
  * @param serializables（id数组）
  * @throws CommonException
  */
 public abstract void deletebatch(Class cl, Serializable... serializables)
   throws CommonException;

 /**
  * 总记录条数
  *
  * @param Class
  * @return int
  * @throws CommonException
  */
 public abstract int gettotal(Class cl) throws CommonException;
 
 /**
  * 总记录条数
  *
  * @param Class 类名
  * @prama String 状态属性名
  * @return int
  * @throws CommonException
  */
 public abstract int gettotal(Class cl,String state) throws CommonException;

 /**
  * 总页数，总记录
  *
  * @param Class
  * @param pagesize
  * @return int[]
  * @throws CommonException
  */
 public abstract int[] getpagetotal(Class cl, int pagesize)throws CommonException;
 
 /**
  * 总页数，总记录
  * @param Class 类名
  * @prama String 状态属性名
   * @param pagesize ��大小
  * @return int[]
  * @throws CommonException
  */
 public abstract int[] getpagetotal(Class cl,String state, int pagesize)throws CommonException;
 /**
  * 查询
  * @param hqlexe
  * @return
  * @throws CommonException
  */
 public abstract List query(HqlExecute hqlexe) throws CommonException;
}
-----------------------------------------------------------------------------------------------------------------

package com.soft.common;

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

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

import com.soft.Exception.CommonException;
import com.soft.hbm.HibernateSessionFactory;
import com.soft.query.HqlExecute;
import com.soft.query.QueryException;

/**
 *
 * @author 通用接口实现类
 */
public class Common<POJO> extends HibernateDaoSupport  implements ICommon<POJO>{
 

 /**
  * 实现通用接口:删除
  */
 public void delete(POJO obj) throws CommonException {
  try {
   this.getHibernateTemplate().delete(obj);
  } catch (HibernateException e) {
   e.printStackTrace();
   throw new CommonException(e);
  }

 }

 /**
  * 实现通用接口:根据主键删除对象
  */
 public void deleteById(Class cl, Serializable id) throws CommonException {
  try {
   this.getHibernateTemplate().delete(this.getHibernateTemplate().load(cl, id));
  } catch (HibernateException e) {
   e.printStackTrace();
   throw new CommonException(e);
  }

 }

 /**
  * 实现通用接口:批量删除
  */
 public void deletebatch(Class cl, Serializable... serializables)
   throws CommonException {
  try {
   
   // 连接参数
   String ins = "";
   for (Serializable a : serializables) {
    ins += a + ",";
   }
   if (ins.endsWith(",")) {
    ins = ins.substring(0, ins.length() - 1);
   }
   final  StringBuffer sb = new StringBuffer("delete from ").append(
     cl.getSimpleName()).append(" as a where a.id in(").append(
     ins).append(")");
   
   this.getHibernateTemplate().executeFind(new HibernateCallback(){

    public Object doInHibernate(Session session) throws HibernateException, SQLException {
     try {
      session.createQuery(sb.toString());
      return session.createQuery(sb.toString()).executeUpdate();
     } catch (RuntimeException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      throw new HibernateException(e);
     }
    }
   });
   
  } catch (HibernateException e) {
   e.printStackTrace();
   throw new CommonException(e);
  }
 }

 /**
  * 实现通用接口:根据主键查询对象
  *
  */
 public POJO getById(Class cl, Serializable id) throws CommonException {
  try {
   return (POJO) this.getHibernateTemplate().get(cl, id);
  } catch (HibernateException e) {
   e.printStackTrace();
   throw new CommonException(e);
  }
 }

 /**
  * 实现通用接口:总页数，总记录
  *  参数：class:类名
  * pagesize:页大小
  */
 public int[] getpagetotal(Class cl, int pagesize) throws CommonException {
  int[] a = null;
  try {
   int total = this.gettotal(cl);

   a = new int[] {
     total % pagesize == 0 ? total / pagesize : total / pagesize
       + 1, total };
  } catch (CommonException e) {
   e.printStackTrace();
   throw new CommonException(e);
  }
  return a;
 }

 /**
  * 实现通用接口:总记录条数(getSimpleName得到对象)(在表中�]有���B的)
  *  参数：class:类名
  */
 public int gettotal(Class cl) throws CommonException {
  int total = 0;
  try {
   
   final StringBuffer hql = new StringBuffer("select count(a) from ")
     .append(cl.getSimpleName()).append(" a");
   total=Integer.parseInt((this.getHibernateTemplate().execute(new HibernateCallback(){

    public Object doInHibernate(Session session) throws HibernateException, SQLException {
     return session.createQuery(hql.toString()).uniqueResult();
    }
    
   })).toString());
   System.out.println("com total:"+total);
   return total;
  } catch (DataAccessException e) {
   e.printStackTrace();
   throw new CommonException(e);
  }
 }
 /**
  * 实现通用接口:总记录条数(getSimpleName得到对象)(在表中有���B的),要传个状态字段
  *  参数：class:类名
  * State:状态属性
  *
  */
 public int gettotal(Class cl,String state) throws CommonException {
  int total = 0;
  try {
   final StringBuffer hql = new StringBuffer("select count(a) from ")
     .append(cl.getSimpleName()).append(" a").append(" where a.").append(state).append("<>1");
   
   total=Integer.parseInt((this.getHibernateTemplate().execute(new HibernateCallback(){

    public Object doInHibernate(Session session) throws HibernateException, SQLException {
     try {
      return session.createQuery(hql.toString()).uniqueResult();
     } catch (RuntimeException e) {
      e.printStackTrace();
      throw new HibernateException(e);
     }
    }
   }
   )).toString());
   System.out.println("total:"+total);
   return total;
   
  } catch (DataAccessException  e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
   throw new CommonException(e);
  }
 }
 
 /**
  * 实现通用接口:总页数，总记录(有状态字段的)
  * 参数：class:类名
  * State:状态属性
  * pagesize:页大小
  */
 public int[] getpagetotal(Class cl,String state, int pagesize) throws CommonException {
  int[] a = null;
  try {
   int total = this.gettotal(cl,state);

   a = new int[] {
     total % pagesize == 0 ? total / pagesize : total / pagesize
       + 1, total };
  } catch (CommonException e) {
   e.printStackTrace();
   throw new CommonException(e);
  }
  return a;
 }
 
 
 /**
  * 实现通用接口:添加对象
  */
 public void insert(POJO obj) throws CommonException {
  try {
   this.getHibernateTemplate().save(obj);
  } catch (HibernateException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
   throw new CommonException(e);
  }

 }

 /**
  * 实现通用接口:修改对象
  */
 public void update(POJO obj) throws CommonException {
  try {
   this.getHibernateTemplate().update(obj);
  } catch (HibernateException e) {
   e.printStackTrace();
   throw new CommonException(e);
  }

 }
 /**
  * 实现通用接口:查询
  */
 public List query(final  HqlExecute hqlexe) throws CommonException {
  
  try {
   List list=this.getHibernateTemplate().executeFind(new HibernateCallback(){
    public Object doInHibernate(Session session) throws HibernateException, SQLException {
     try {
      return hqlexe.execute(session);
     } catch (QueryException e) {
      e.printStackTrace();
      throw new HibernateException(e);
     }
    }
   });
   return list;
  } catch (DataAccessException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
   throw new CommonException(e);
  }
 }

}