basedao.java

学生信息管理

/*
 * 创建日期 2007-7-22
 *
 * TODO 要更改此生成的文件的模板，请转至
 * 窗口 － 首选项 － Java － 代码样式 － 代码模板
 */
package limq.hibernate.dao;

import java.util.*;
import net.sf.hibernate.HibernateException;
import net.sf.hibernate.Query;
import net.sf.hibernate.Hibernate;
import net.sf.hibernate.Session;
import net.sf.hibernate.Criteria;
import org.apache.log4j.Logger;
import org.springframework.orm.hibernate.HibernateCallback;
import org.springframework.orm.hibernate.support.HibernateDaoSupport;
import org.springframework.orm.hibernate.SessionFactoryUtils;
import limq.exception.*;
public class BaseDao extends HibernateDaoSupport{
	 private Logger log = Logger.getLogger(this.getClass());
	
	/** 
     * 向数据库添加一条对应于一个业务对象实例的记录 
     * 
     * @param entity 
     *            业务对象实例 
     * @throws DaoException 
     *         
     */ 
    public void create(Object entity)  { 
        try { 
            getHibernateTemplate().save(entity); 
            
        } catch (Exception e) { 
            log.error("保存 " + entity.getClass().getName() + " 实例到数据库失败", e); 
           
        } 
    } 
	/** 
     * 获得一个session        
     */ 
    public Session openSession() {
        return SessionFactoryUtils.getSession(getSessionFactory(), false);
    }

	/** 
     * 获得Query对象       
     */ 
    public Query getQuery(String sql) throws Exception{
        Session session = this.openSession();
        Query query = session.createQuery(sql); 
    return query;
    }
    /** 
     * 获得Criteria对象       
     */
    public Criteria getCriteria(Class clazz) throws Exception{
        
    Session session=this.openSession();
    Criteria criteria = session.createCriteria(clazz);
    return criteria;
    }
	/** 
     * 在分页显示时获得总数据数 
     *         
     */  
    public  int getTotalCount(String hql) throws Exception 
    { 
    Integer amount = new Integer(0); 
    int sql_from = hql.indexOf(" from"); 
    int sql_orderby=hql.indexOf("order by");
    String countStr=""; 
    if(sql_orderby>0) 
    { 
    countStr="select count(*) "+hql.substring(sql_from,sql_orderby); 
    } 
    else 
    countStr = "select count(*) "+hql.substring(sql_from); 
    Session session=this.openSession();
    Query query = session.createQuery(countStr); 
    if(!query.list().isEmpty()){ 
    amount = (Integer) query.list().get(0); 
    } 
    else 
    return 0; 

    return amount.intValue(); 
    } 
    
	/** 
     * 在分页显示时获得总页数 
     *         
     */ 
    public int getTotalPage(int totalCount,int pageSize){
        
      return (totalCount+pageSize-1)/pageSize;
      
    
    }
    /** 
     * 向数据库更新一条对应于一个业务对象实例的记录 
     * 
     * @param entity 
     *            业务对象实例 
     * @throws DaoException 
     *          
     */ 
    public void update(Object entity)  { 
        try { 
            getHibernateTemplate().update(entity); 
        } catch (Exception e) { 
            log.error("更新 " + entity.getClass().getName() + " 实例到数据库失败", e); 
           
        } 
    } 

    /** 
     * 从数据库删除一条对应于一个业务对象的记录 
     * 
     * @param entity 
     *            业务对象实例 
     * @throws DaoException 
     *         
     */ 
    public void delete(Object entity) throws DaoException { 
        try { 
            getHibernateTemplate().delete(entity); 
        } catch (Exception e) { 
            log.error("从数据库删除 " + entity.getClass().getName() + " 实例失败", e); 
          
        } 
    } 
    /** 
     * 从数据库删除所有对应于一个业务对象的记录 
     * @param clazz 
     *            指定类型的业务对象 
     * @throws DaoException        
     */ 
    public void deleteAll(Class clazz) throws DaoException { 
        try { 
            List result = getHibernateTemplate().loadAll(clazz); 
            getHibernateTemplate().deleteAll(result); 
        } catch (Exception e) { 
            log.error("从数据库删除 " + clazz.getName() + " 的所有记录失败", e); 
           
        } 
    } 

    public void deleteAll(Collection entities) throws DaoException { 
        try { 
            getHibernateTemplate().deleteAll(entities); 
            
        } catch(Exception e) { 
           
        } 
    } 
    /** 
     * 从数据库查询一个业务对象的所以记录 
     * @param clazz 
     *            指定类型的业务对象  
     */ 
    public List LoadAll(Class clazz){
        List list=null;
        try{
               list=getHibernateTemplate().loadAll(clazz);
        }catch(Exception e){
           log.error("从数据库查询"+clazz.getName()+"失败");
       }
        return list;
    }
    
    
    /** 
     * 根据关键字从数据库加载指定类型的业务对象。 
     * 
     * @param clazz 
     *            业务对象的Class 
     * @param keyName 
     *            指定关键字对应的字段名称 
     * @param keyValue 
     *            指定关键字的值 
     * @return <ul> 
     *         <li>当关键字唯一并存在该记录时，返回该记录对应的业务对象</li> 
     *         <li>当关键字不唯一，返回查询结果的第一条记录所对应的业务对象</li> 
     *         <li>当不存在该记录时,返回null</li> 
     *         </ul> 
     * @throws DaoException 
     *         
     */ 
    public Object loadByKey(Class clazz, String keyName, Object keyValue) 
            { 
      
            List result = getHibernateTemplate().find( 
                    "from " + clazz.getName() + " where " + keyName + " = ?", 
                    keyValue); 
            if (result != null && result.size() > 0) { 
                return result.get(0); 
            } else { 
                return null; 
            }
     }
    
    /** 
     * 根据主键查询唯一数据对象。 
     * 
     * @param clazz 
     *            业务对象的Class 
     * @return 返回查询结果包含的业务对象 
     * @throws DaoException 
     *           
     */ 
    public Object getByPk(Class clazz,Integer id){
        
      Object obj = (Object)getHibernateTemplate().get(clazz,id);
      return obj;
    
    }
    public Object getByPk(Class clazz,Long id){
        
      Object obj = (Object)getHibernateTemplate().get(clazz,id);
      return obj;
    }
    public Object getByPk(Class clazz,String id){
        
      Object obj = (Object)getHibernateTemplate().get(clazz,id);
      return obj;
    
    }
    
    /** 
     * 根据查询语句查询数据库并返回查询结果所包含的业务对象集合。 
     * 
     * @param queryString 
     *            指定查询语句 
     * @return 返回查询结果包含的业务对象集合 
     * @throws DaoException 
     *      
     */ 
    public List find(String queryString) throws DaoException {
    	List list =null;
        try { 
            list= getHibernateTemplate().find(queryString); 
        } catch (Exception e) { 
            log.error("执行查询 " + queryString + " 失败", e); 
            
        } 
        return list;
    } 


    /** 
     * 根据带一个参数的查询语句查询数据库并返回查询结果所包含的业务对象集合。 
     * 
     * @param queryString 
     *            指定查询语句 
     * @param param 
     *            指定所带参数 
     * @return 返回查询结果包含的业务对象集合 
     * @throws DaoException 
     *            牭±查询失败时抛