basedaoimpl.java

一个关于tlms的一个小程序 看看能否帮助到别人

package com.szmx.framework.base.dao.impl;

import java.io.Serializable;
import java.util.*;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.lang.StringUtils;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.hibernate.criterion.*;
import org.hibernate.Criteria;
import org.hibernate.Query;
import com.szmx.framework.base.dao.BaseDao;
import com.szmx.framework.base.model.Pagination;
import com.szmx.framework.util.StringUtil;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.engine.impl.ExtendedSqlMapClient;
import com.ibatis.sqlmap.engine.mapping.statement.MappedStatement;
import com.ibatis.sqlmap.engine.scope.RequestScope;

/**
 * This class serves as the Base class for all other DAOs - namely to hold
 * common methods that they might all use. Can be used for standard CRUD
 * operations.</p>
 * <p/>
 * <p><a href="BaseDaoImpl.java.html"><i>View Source</i></a></p>
 *
 * @author <a href="mailto:[e-mail]">Matt Raible</a>
 */
public class BaseDaoImpl extends HibernateDaoSupport implements BaseDao {
    protected final Log logger = LogFactory.getLog(getClass());
    private SqlMapClient sqlMapClient;

    public void setSqlMapClient(SqlMapClient sqlMapClient) {
        this.sqlMapClient = sqlMapClient;
    }

    //~ Methods CRUD ========================================================

    public Object getObject(Class clazz, Serializable id) {
        return getHibernateTemplate().get(clazz, id);
    }

    public List getAllObject(Class clazz) {
        return getHibernateTemplate().loadAll(clazz);
    }

    public void saveObject(Object o) {
        getHibernateTemplate().saveOrUpdate(o);
    }

    public void removeObject(Object o) {
        getHibernateTemplate().delete(o);
    }

    public void removeObject(Class clazz, Serializable id) {
        getHibernateTemplate().delete(getObject(clazz, id));
    }

    public void removeAllObject(Collection collection) {
        getHibernateTemplate().deleteAll(collection);
    }


    //~ Methods Query ========================================================

    public Object findBy(Class clazz, String name, Object value) {
        Criteria criteria = getSession().createCriteria(clazz);
        criteria.add(Restrictions.eq(name, value));
        criteria.setMaxResults(1);
        return criteria.uniqueResult();
    }

    public List findLike(Class clazz, String name, String value) {
        Criteria criteria = getSession().createCriteria(clazz);
        criteria.add(Restrictions.like(name, value, MatchMode.ANYWHERE));
        return criteria.list();
    }

    public List findAllBy(Class clazz, String name, Object value) {
        Criteria criteria = getSession().createCriteria(clazz);
        criteria.add(Restrictions.eq(name, value));
        return criteria.list();
    }

    protected Pagination findPageByCriteria(final DetachedCriteria detachedCriteria, Pagination pagination) {
        Criteria criteria = detachedCriteria.getExecutableCriteria(getSession());
        int totalCount = ((Integer) criteria.setProjection(Projections.rowCount()).uniqueResult()).intValue();
        criteria.setProjection(null);
        criteria.setFirstResult(pagination.getFirstResult())
                .setMaxResults(pagination.getPageSize());
        if (!StringUtils.isEmpty(pagination.getSortCriterion())) {
            if (Pagination.SORT_DESC.equals(pagination.getSortType())) {
                criteria.addOrder(Order.desc(pagination.getSortCriterion()));
            } else {
                criteria.addOrder(Order.asc(pagination.getSortCriterion()));
            }
        }
        List items = criteria.list();
        pagination.setList(items);
        pagination.setTotalCount(totalCount);
        return pagination;
    }

    protected Pagination findPageByCombinedHsql(final String sqlId, final Map paraMap, Pagination pagination) {
        String hsql = getCombinedHsqlStatement(sqlId, paraMap);
        String countSql = convertToCountHsqlStatement(hsql);

        if (hsql != null) {
            // prepare sort info
            StringBuffer buffHSQL = new StringBuffer(hsql);
            if (! StringUtil.isNull(pagination.getSortCriterion())) {
                buffHSQL.append(" order by ");
                buffHSQL.append( pagination.getSortCriterion() );
                if (Pagination.SORT_DESC.equals(pagination.getSortType())) {
                    buffHSQL.append(" desc");
                } else {
                    buffHSQL.append(" asc");
                }
            }

            // Prepare Query
            Query query = getSession().createQuery(buffHSQL.toString());
            setQueryParameters(query, paraMap);
            query.setFirstResult(pagination.getFirstResult());
            query.setMaxResults(pagination.getPageSize());

            // Execute Query List
            List restList = query.list();

            // set result List info
            pagination.setList( restList );

            // Query the totalCount
            if (countSql != null) {
                Query countQuery = getSession().createQuery(countSql);
                setQueryParameters(countQuery, paraMap);
                Integer count = (Integer) countQuery.uniqueResult();
                pagination.setTotalCount(count.intValue());
            }
        }

        return pagination;
    }

    protected List findListByCombinedHsql(final String sqlId, final Map paraMap) {
        List restList = null;
        String hsql = getCombinedHsqlStatement(sqlId, paraMap);
        if (hsql != null) {
            // Prepare Query
            Query query = getSession().createQuery(hsql);
            setQueryParameters(query, paraMap);

            // Execute Query List
            restList = query.list();
        }
        return restList;
    }

    protected int executeUpdateByHsql(String hsql, Map paraMap) {
        if (hsql != null) {
            // Prepare Query
            Query query = getSession().createQuery(hsql);
            setQueryParameters(query, paraMap);

            // Execute Query List
            return query.executeUpdate();
        }
        return 0;
    }


    //~ Methods Util ========================================================

    private String getCombinedHsqlStatement(String sqlId, Object paramObject) {
        if (sqlMapClient == null) {
            logger.error("No IBATIS sqlMapClient setted!");
            return null;
        }

        String sql = null;
        ExtendedSqlMapClient extendedSqlMapClient = (ExtendedSqlMapClient) sqlMapClient;
        MappedStatement mappedStatement = extendedSqlMapClient.getMappedStatement(sqlId);
        if (mappedStatement != null) {
            RequestScope request = new RequestScope();
            request.setStatement(mappedStatement);
            sql = mappedStatement.getSql().getSql(request, paramObject);
        }
        return sql;
    }

    private String convertToCountHsqlStatement(String selectSQL) {
        if (!StringUtil.isNull(selectSQL)) {
            int indexOfFrom = selectSQL.toLowerCase().indexOf("from");
            return "select count(*) " + selectSQL.substring( indexOfFrom );
        }
        return null;
    }

    private void setQueryParameters(Query query, Map paraMap) {
        if (query != null && paraMap != null) {
            List namedParms = Arrays.asList(query.getNamedParameters());
            Iterator iter = paraMap.keySet().iterator();
            while (iter.hasNext()) {
                String paraName = (String) iter.next();
                if (namedParms.contains(paraName)) {
                    query.setParameter(paraName, paraMap.get(paraName));
                }
            }
        }
    }
}