basicdao.java

struts+spring+hibernate自创框架

package com.pegasus.framework.dao.impl;

import java.io.Serializable;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.lang.CharUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.pegasus.framework.component.taglib.html.pager.PageAgent;
import com.pegasus.framework.dao.IBasicDAO;
import com.pegasus.framework.exception.DAOException;
import com.pegasus.framework.pojo.IBusinessObject;

/**
 * The Hibernate implementation of the <code>UserDao</code>.
 * 
 * @author tommy.chong
 * @see UserDao
 */
public abstract class BasicDAO extends HibernateDaoSupport implements IBasicDAO {

	protected final Log log = LogFactory.getLog(this.getClass());

	private String tableName;

	private String tableClass;

	private String defaultOrderBy = null;

	private String defaultBoPath = null;

	private Class clazz;

	/**
	 * Default constructor.
	 */
	public BasicDAO() {
		super();
	}

	/**
	 * @return Returns the defaultBoPath.
	 */
	public String getDefaultBoPath() {
		return defaultBoPath;
	}

	/**
	 * @param defaultBoPath The defaultBoPath to set.
	 */
	public void setDefaultBoPath(String defaultBoPath) {
		this.defaultBoPath = defaultBoPath;
	}

	public void setTableClass(String tableClass) {
		this.tableClass = tableClass;
	}

	public String getTableClass() {
		return tableClass;
	}

	public void setTableName(String tableName) {
		this.tableName = tableName;
	}

	public String getTableName() {
		if (tableName != null)
			return tableName;
		else if (tableClass != null)
			return tableClass.substring(tableClass.lastIndexOf('.') + 1);
		else
			return "";
	}

	public void setDefaultOrderBy(String defaultOrderBy) {
		this.defaultOrderBy = defaultOrderBy;
	}

	public Class retrieveClass() {
		try {
			if (clazz == null) {
				if (tableClass != null)
					clazz = Class.forName(tableClass);
				else if (tableName != null)
					clazz = Class.forName(this.defaultBoPath + "." + tableName);
				else
					clazz = Class.forName(this.defaultBoPath + "." + this.getTableName());
			}
			return clazz;
		}
		catch (ClassNotFoundException e) {
			log.error("ERROR in retrieveClass", e);
			return null;
		}
	}

	public IBusinessObject selectOne(Serializable id) throws DAOException {
		IBusinessObject bo = (IBusinessObject)this.getHibernateTemplate().load(retrieveClass(), id);
		if(bo == null) {
			return null;
		}
		return bo;
	}

	public IBusinessObject selectOneByOtherPK(String pk, String value) throws DAOException {
		List criteriaList = new ArrayList();
		criteriaList.add(Restrictions.eq(pk, value));
		List list = select(criteriaList, null);
		logger.info("selectOneByOtherPK: " + list.size());
		if (list != null && !list.isEmpty()) {
			IBusinessObject bo = (IBusinessObject) list.get(0);
			logger.info("selectOneByOtherPK: " + bo.toXMLString());
			return bo;
		}
		else {
			return null;
		}
	}

	public List select() throws DAOException {
		return getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(Session session) throws HibernateException, SQLException {
				Criteria criteria = session.createCriteria(retrieveClass());
				if (defaultOrderBy != null)
					criteria.addOrder(Order.asc(defaultOrderBy));
				else
					criteria.addOrder(Order.asc("id"));
				return criteria.list();
			}
		});
	}

	
	/*  public Collection query(final Collection ids) {
		return query(ids, false);
	}

	public Collection query(final Collection ids, final boolean inOrder) {
		if (ids == null || ids.isEmpty()) {
			return new ArrayList();
		}
		List list = getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(Session session) throws HibernateException, SQLException {
				Criteria criteria = session.createCriteria(retrieveClass());
				Long[] idsArr = new Long[ids.size()];
				ids.toArray(idsArr);
				criteria.add(Expression.in("id", idsArr));
				return criteria.list();
			}
		});
		if (!inOrder) {
			return list;
		} else {
			List retList = new ArrayList();
			if (!list.isEmpty()) {
				Iterator itr = null;
				Iterator itr2 = null;
				itr = ids.iterator();
				while (itr.hasNext()) {
					Long id = (Long) itr.next();
					itr2 = list.iterator();
					while (itr2.hasNext()) {
						IBusinessObject bo = (IBusinessObject) itr2.next();
						if (id.equals(bo.getId())) {
							retList.add(bo);
							itr2.remove();
							break;
						}
					}
				}
			}
			return retList;
		}
	}*/
	 

	public Serializable insert(IBusinessObject o) throws DAOException {
		return this.getHibernateTemplate().save(o);
	}

	public void update(IBusinessObject o) throws DAOException {
		this.getHibernateTemplate().update(o);
	}
	
	public void merge(IBusinessObject o) throws DAOException {
		this.getHibernateTemplate().merge(o);
	}

	public void insertOrUpdate(IBusinessObject o) throws DAOException {
		this.getHibernateTemplate().saveOrUpdate(o);
	}

	public void delete(IBusinessObject o) throws DAOException {
		this.getHibernateTemplate().delete(o);
	}
	
	public void delete(Serializable id) throws DAOException {
		this.getHibernateTemplate().delete(id);
	}

	protected void fixSQL(StringBuffer stmt) {
		String tempString = stmt.toString().toUpperCase();
		if (tempString.endsWith("WHERE"))
			stmt.setLength(stmt.length() - 5);
		if (tempString.endsWith("AND"))
			stmt.setLength(stmt.length() - 3);
		if (tempString.endsWith("OR"))
			stmt.setLength(stmt.length() - 2);
	}

	protected void fixOrderBy(StringBuffer stmt, String orderBy, boolean ascending) {
		if (orderBy != null) {
			stmt.append(" order by " + orderBy);
			if (!ascending)
				stmt.append(" desc");
		}
	}

	public List select(List criterionList, PageAgent pageAgent) throws DAOException {
		return select(criterionList, null, pageAgent);
	}

	public List select(List criterionList) throws Exception {
		return select(criterionList, null, null);
	}

	public List select(List criterionList, List orderList, PageAgent pageAgent) throws DAOException {
		Criterion[] criterionArray;
		if (criterionList == null)
			criterionArray = new Criterion[0];
		else {
			criterionArray = new Criterion[criterionList.size()];
			criterionList.toArray(criterionArray);
		}
		Order[] orderArray;
		if (orderList == null) {
			orderArray = new Order[0];
		}
		else {
			orderArray = new Order[orderList.size()];
			orderList.toArray(orderArray);
		}
		return select(criterionArray, orderArray, pageAgent);
	}

	public List select(Criterion[] criterionArray, Order[] orderArray) throws DAOException {
		return select(criterionArray, orderArray, null);
	}

	public List select(Criterion[] criterionArray, Order[] orderArray, PageAgent pageAgent)
			throws DAOException {
		Criteria criteria = getSession().createCriteria(this.retrieveClass());
		if (criterionArray != null) {
			for (int index = 0; index < criterionArray.length; index++) {
				criteria.add(criterionArray[index]);
			}
		}
		if (orderArray != null) {
			for (int index = 0; index < orderArray.length; index++) {
				criteria.addOrder(orderArray[index]);
			}
		}
		if (pageAgent != null) {
			pageAgent.setTotalObjectCount(criteria.list().size());
			criteria.setFirstResult(pageAgent.getFirstObjectIndexOfResult());
			criteria.setMaxResults(pageAgent.getFetchSize());
		}
		return criteria.list();

	}

	public List selectByHQL(String hql, Collection criteria, PageAgent pageAgent) throws DAOException {
		Query query = getSession().createQuery(hql);

		if (pageAgent != null) {
			pageAgent.setTotalObjectCount(query.list().size());
			query.setFirstResult(pageAgent.getFirstObjectIndexOfResult());
			query.setMaxResults(pageAgent.getFetchSize());

		}
		int i = 0;
		Iterator itr = criteria.iterator();
		while (itr.hasNext()) {
			query.setParameter(i++, itr.next());
		}
		return query.list();
	}

	public List selectByHQL(String hql, Collection criteria) throws DAOException {
		if(criteria != null) {
			return this.getHibernateTemplate().find(hql, criteria.toArray());
		} else {
			return this.getHibernateTemplate().find(hql);
		}
		
	}

	public Object selectOneByHQL(String hql, Collection criteria) throws DAOException {
		List list = this.getHibernateTemplate().find(hql, criteria.toArray());
		if (list != null && !list.isEmpty())
			return list.get(0);
		else
			return null;
	}
	/**
	 *  select {cat.*}, {kitten.*} from cats cat, cats kitten where kitten.mother = cat.id 
	 * @param sql
	 * @param classMap
	 * @param criteria
	 * @param pageAgent
	 * @return
	 * @throws Exception
	 */
	public List selectByNativeSQL(String sql, Map classMap, Collection criteria, PageAgent pageAgent) throws DAOException {
        SQLQuery query = getSession().createSQLQuery(sql);
        if (classMap != null) {
            Set set = classMap.keySet();
            Iterator iterator = set.iterator();
            while (iterator.hasNext()) {
                String className = (String) iterator.next();
                query.addEntity(className, (Class) classMap.get(className));
            }
        }
        int i = 0;
		Iterator itr = criteria.iterator();
		while (itr.hasNext()) {
			query.setParameter(i++, itr.next());
		}
        if (pageAgent != null) {
            pageAgent.setTotalObjectCount(query.list().size());
            query.setFirstResult(pageAgent.getFirstObjectIndexOfResult());
            query.setMaxResults(pageAgent.getFetchSize());
        }
        return query.list();
    }

	public static boolean isEmpty(Object o) {
		if (o == null)
			return true;
		else {
			if (o instanceof String)
				return ((String) o).equals("");
			else
				return false;
		}
	}

	protected static String stripNonNumeric(String str) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0, n = str != null ? str.length() : 0; i < n; i++) {
			if (CharUtils.isAsciiNumeric(str.charAt(i)))
				sb.append(str.charAt(i));
		}
		return sb.toString();
	}
}