dbdaoimpl.java

本源码为教学管理信息系统

package com.wygl.dbdao;

import java.sql.Types;
import java.util.Iterator;
import java.util.List;

import javax.sql.DataSource;

import net.sf.hibernate.HibernateException;
import net.sf.hibernate.Query;
import net.sf.hibernate.ReplicationMode;
import net.sf.hibernate.Session;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.dao.DataAccessException;
import org.springframework.orm.hibernate.HibernateCallback;
import org.springframework.orm.hibernate.HibernateTemplate;
import org.springframework.orm.hibernate.support.HibernateDaoSupport;

import com.wygl.page.Constants;
import com.wygl.page.HQuery;
import com.wygl.page.Paras;

/**
 * 针对hibernate的通用数据库访问接口实现
 * 
 * @spring.bean id ="***ServiceTarget"
 * @spring.property name="sessionFactory" ref="sessionFactory"
 */
public class DbDaoImpl extends HibernateDaoSupport implements DbDao {

	/**
	 * 数据源
	 */
	private DataSource dataSource;

	/**
	 * 日志记录
	 */
	private static final Log LOG = LogFactory.getLog(DbDaoImpl.class);

	/**
	 * 刷新对象
	 * @param entity
	 */
	public void refresh(final Object entity) throws Exception{
		try {
			getHibernateTemplate().execute(new HibernateCallback() {
				public Object doInHibernate(Session session)
						throws HibernateException {
					session.refresh(entity);
					return null;
				}

			});
		} catch (DataAccessException e) {
			e.printStackTrace();
			throw new DbDaoException("向数据库表中刷新对象错误.");
		}
	}

	/**
	 * 替换对象
	 * @param entity
	 */
	public void replicate(final Object entity) throws Exception{
		try {
			getHibernateTemplate().execute(new HibernateCallback() {

				public Object doInHibernate(Session session)
						throws HibernateException {
					session.replicate(entity, ReplicationMode.OVERWRITE);
					return null;
				}

			});
		} catch (DataAccessException e) {
			e.printStackTrace();
			throw new DbDaoException("向数据库表中替换对象错误.");
		}
	}	
	/**
	 * 清除对象
	 * @param entity
	 */
	public void clear(Object entity) throws Exception{
		try {
			getHibernateTemplate().evict(entity);
		} catch (DataAccessException e) {
			e.printStackTrace();
			throw new DbDaoException("清除缓存的session对象错误.");
		}
		
	}
	/**
	 * 向数据库表中添加记录
	 * 
	 * @param obj
	 *            Object
	 * @throws java.lang.Exception
	 * @roseuid 431CF26001FA
	 */
	public void addObject(Object obj) throws Exception {
		try {
			getHibernateTemplate().save(obj);
		} catch (DataAccessException e) {
			e.printStackTrace();
			throw new DbDaoException("向数据库表中添加记录错误.");
		}
	}

	/**
	 * 更新数据库表中记录
	 * 
	 * @param obj
	 *            Object
	 * @throws java.lang.Exception
	 * @roseuid 431CF2600268
	 */
	public void updateObject(Object obj) throws Exception {
		try {
			getHibernateTemplate().saveOrUpdate(obj);
		} catch (DataAccessException e) {
			e.printStackTrace();
			throw new DbDaoException("更新数据库表中记录错误.");
		}
	}

	/**
	 * 删除数据库表中记录
	 * 
	 * @param obj
	 *            Object
	 * @throws java.lang.Exception
	 * @roseuid 431CF26002B9
	 */
	public void deleteObject(Object obj) throws Exception {
		try {
			getHibernateTemplate().delete(obj);
		} catch (DataAccessException e) {
			e.printStackTrace();
			throw new DbDaoException("删除数据库表中记录错误.");
		}
	}
	
	/**
	 * 删除数据库表中记录
	 * 
	 * @param obj
	 *            Class
	 * @param obj_id
	 *            String          
	 * @throws java.lang.Exception
	 * @roseuid 431CF26002B1
	 */
	public void deleteObject(Class obj, String obj_id) throws Exception{
		try {
			if (obj_id == null || obj_id.equals(""))
				return;
			this.deleteObject(this.getHibernateTemplate().load(obj, obj_id));
		} catch (DataAccessException e) {
			e.printStackTrace();
			throw new DbDaoException("删除数据库表中记录错误.");
		} catch (Exception e) {
			e.printStackTrace();
			throw new DbDaoException("删除数据库表中记录错误.");
		}
	}
	/**
	 * 批量删除数据库表中记录
	 * 
	 * @param list
	 *            List
	 * @param obj
	 * @throws java.lang.Exception
	 * @roseuid 431CF2600312
	 */
	public void deleteObjects(Class obj, List list) throws Exception {
		try {
			if (list == null)
				return;
			for (Iterator it = list.iterator(); it.hasNext();) {
				String class_id = (String) it.next();
				if (class_id == null || class_id.equals(""))
					continue;
				this.deleteObject(this.getHibernateTemplate().load(obj, class_id));
			}
		} catch (DataAccessException e) {
			e.printStackTrace();
			throw new DbDaoException("批量删除数据库表中记录错误.");
		} catch (Exception e) {
			e.printStackTrace();
			throw new DbDaoException("批量删除数据库表中记录错误.");
		}
	}

	/**
	 * 通过ID检索数据库表中记录
	 * 
	 * @param id
	 *            String
	 * @param obj
	 * @param obj_id
	 * @return Object@throws java.lang.Exception
	 * @roseuid 431CF260038A
	 */
	public Object queryObjectById(Class obj, String obj_id) throws Exception {
		try {
			return (Object) this.getHibernateTemplate().load(obj, obj_id);
		} catch (DataAccessException e) {
			e.printStackTrace();
			throw new DbDaoException("通过ID检索数据库表中记录错误.");			
		}
	}

	/**
	 * 查询数据库表中记录总数
	 * 
	 * @param queryStr
	 *            String
	 * @param hqlString
	 * @return int@throws java.lang.Exception
	 * @roseuid 431CF26003E5
	 */
	public int queryObjectsCount(String hqlString) throws Exception {
		try {
			return ((Integer) getHibernateTemplate().find("select count(*) " +hqlString).get(0)).intValue();
		} catch (Exception e) {
			e.printStackTrace();
			throw new DbDaoException("查询数据库表中记录总数错误.");	
		}
	}

	/**
	 * 查询数据库表中记录
	 * 
	 * @param hql
	 *            String
	 * @param hqlString
	 * @return List@throws java.lang.Exception
	 * @roseuid 431CF2610056
	 */
	public List queryObjects(String hqlString) throws Exception {
		try {
			return getHibernateTemplate().find(hqlString);
		} catch (DataAccessException e) {
			e.printStackTrace();
			throw new DbDaoException("查询数据库表中记录错误.");	
		}
	}

	/**
	 * 分页查询数据库表中记录
	 * 
	 * @param hquery
	 * @return List@throws net.sf.hibernate.HibernateException
	 * @roseuid 431CF26100B2
	 */
	public List queryObjectsToPages(final HQuery hquery) {
		HibernateTemplate hibernateTemplate = new HibernateTemplate(
				getSessionFactory());
		return (List) hibernateTemplate.execute(new HibernateCallback() {
			public Object doInHibernate(Session session)
					throws HibernateException {
				List itr = null;
				try {
					StringBuffer query_str = new StringBuffer(hquery
							.getQueryString());
					// 是否要排序
					if (hquery.getOrderby() != null) {
						query_str.append(hquery.getOrderby());
					}
					// 是否要分组
					if (hquery.getGroupby() != null) {
						query_str.append(hquery.getGroupby());
					}
					Query query = session.createQuery(query_str.toString());
					if (hquery.getParaslist() != null) {
						List list = hquery.getParaslist();
						for (int i = 0; i < list.size(); i++) {
							Paras param = (Paras) list.get(i);
							switch (param.getTypeNo()) {
							// 此处要根据参数类型的增加要增加相应的“case”
							case Types.VARCHAR:
								query.setString(i, param.getPName().toString());
								break;
							case Types.INTEGER:
								query
										.setInteger(i, ((Integer) param
												.getPName()).intValue());
								break;
							case Types.DATE:
								query.setTimestamp(i, (java.util.Date) param
										.getPName());
								break;
							case Types.DOUBLE:
								query.setDouble(i, ((Double) param.getPName())
										.doubleValue());
								break;
							case Types.CHAR:
								query.setCharacter(i, ((Character) param
										.getPName()).charValue());
								break;
							}
						}
					}
					// 是否存在分页，当hquery.getPageStartNo()==0是不分页
					if (hquery.getPageStartNo() != 0) {
						long pageno = hquery.getPageStartNo();
						query.setFirstResult(Integer.parseInt(Long
								.toString(pageno - 1))
								* Constants.RECORD_PER_PAGE);
						query.setMaxResults(Constants.RECORD_PER_PAGE);
					}
					itr = query.list();
				} catch (Exception e) {
					e.printStackTrace();
				}
				return itr;
			}
		});
	}
	
	/**
	 * 分页查询数据库表中记录
	 * 
	 * @param hquery
	 * @return List@throws net.sf.hibernate.HibernateException
	 * @roseuid 431CF26100B2
	 */
	public List queryObjects(final HQuery hquery) {
		HibernateTemplate hibernateTemplate = new HibernateTemplate(
				getSessionFactory());
		return (List) hibernateTemplate.execute(new HibernateCallback() {
			public Object doInHibernate(Session session)
					throws HibernateException {
				List itr = null;
				try {
					StringBuffer query_str = new StringBuffer(hquery
							.getQueryString());
					// 是否要排序
					if (hquery.getOrderby() != null) {
						query_str.append(hquery.getOrderby());
					}
					// 是否要分组
					if (hquery.getGroupby() != null) {
						query_str.append(hquery.getGroupby());
					}
					Query query = session.createQuery(query_str.toString());
					if (hquery.getParaslist() != null) {
						List list = hquery.getParaslist();
						for (int i = 0; i < list.size(); i++) {
							Paras param = (Paras) list.get(i);
							switch (param.getTypeNo()) {
							// 此处要根据参数类型的增加要增加相应的“case”
							case Types.VARCHAR:
								query.setString(i, param.getPName().toString());
								break;
							case Types.INTEGER:
								query.setInteger(i, ((Integer) param
												.getPName()).intValue());
								break;
							case Types.DATE:
								query.setTimestamp(i, (java.util.Date) param
										.getPName());
								break;
							case Types.DOUBLE:
								query.setDouble(i, ((Double) param.getPName())
										.doubleValue());
								break;
							case Types.CHAR:
								query.setCharacter(i, ((Character) param
										.getPName()).charValue());
								break;
							}
						}
					}
					itr = query.list();
				} catch (Exception e) {
					e.printStackTrace();
				}
				return itr;
			}
		});
	}
	
	/**
	 * @return
	 * @roseuid 431CF2610147
	 */
	public DataSource getDataSource() {
		return dataSource;
	}

	/**
	 * @param source
	 * @roseuid 431CF2610151
	 */
	public void setDataSource(DataSource source) {
		dataSource = source;
	}
	/**
	 * 取记录总数 liuyc
	 * @return int
	 */
	public int count(final HQuery _query) throws HibernateException {	
		Session session = getSession();
		int count =0;
		try {
			StringBuffer query_str = new StringBuffer(_query.getQueryString());
			
			Query query = session.createQuery("select count(*) " + query_str.toString());

			if (_query.getParaslist() != null) {
				List list = _query.getParaslist();
				for (int i = 0; i < list.size(); i++) {
					Paras param = (Paras) list.get(i);
					switch (param.getTypeNo()) {//此处要根据参数类型的增加要增加相应的“case”
					case Types.VARCHAR:
						query.setString(i, param.getPName().toString());
						break;
					case Types.INTEGER:
						query.setInteger(i, ((Integer) param.getPName()).intValue());
						break;
					case Types.DATE:
						query.setTimestamp(i, (java.util.Date) param.getPName());
						break;
					case Types.DOUBLE:
						query.setDouble(i, ((Double) param.getPName()).doubleValue());
						break;
					case Types.BOOLEAN:
						query.setBoolean(i,((Boolean) param.getPName()).booleanValue());
						break;
					case Types.CHAR:
						query.setCharacter(i, ((Character) param.getPName()).charValue());
						break;
					case Types.ARRAY:
						query.setParameterList("inParam0",(List)param.getPName());
						break;
					}
				}
			}			
			count = ((Integer)(query.list().iterator().next())).intValue();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return count;
	}
	
	/**
	 * 求按照预定义参数查询条件的聚合函数值
	 * @return Object
	 */
	public Object getAggregation(final HQuery _query) throws HibernateException {	
		Session session = getSession();
		
		try {
			StringBuffer query_str = new StringBuffer(_query.getQueryString());
			
			Query query = session.createQuery(query_str.toString());

			if (_query.getParaslist() != null) {
				List list = _query.getParaslist();
				for (int i = 0; i < list.size(); i++) {
					Paras param = (Paras) list.get(i);
					switch (param.getTypeNo()) {//此处要根据参数类型的增加要增加相应的“case”
					case Types.VARCHAR:
						query.setString(i, param.getPName().toString());
						break;
					case Types.INTEGER:
						query.setInteger(i, ((Integer) param.getPName()).intValue());
						break;
					case Types.DATE:
						query.setTimestamp(i, (java.util.Date) param.getPName());
						break;
					case Types.DOUBLE:
						query.setDouble(i, ((Double) param.getPName()).doubleValue());
						break;
					case Types.BOOLEAN:
						query.setBoolean(i,((Boolean) param.getPName()).booleanValue());
						break;
					case Types.CHAR:
						query.setCharacter(i, ((Character) param.getPName()).charValue());
						break;
					case Types.ARRAY:
						query.setParameterList("inParam0",(List)param.getPName());
						break;
					}
				}
			}
			if(query.list().size()>0){
				return query.list().iterator().next();
			}
			return null;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}		
	}
	
	/**
	 * 求按照预定义参数查询条件的聚合函数值
	 * @return Object
	 */
	public Object getAggregation(String hqlString) throws HibernateException {	
		Session session = getSession();		
		try {
			StringBuffer query_str = new StringBuffer(hqlString);			
			Query query = session.createQuery(query_str.toString());			
			if(query.list().size()>0){
				return query.list().iterator().next();
			}
			return null;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}		
	}

	public String addObjectBackPK(Object obj) throws Exception {
		return (String) getHibernateTemplate().save(obj);
	}

	public String updateObjectBackPK(Object obj) throws Exception {
		return addObjectBackPK(obj);
	}
}