/******************************************************************************
 * Copyright (C) 2015 Shenzhen Penguin Network Technology Co., Ltd
 * All Rights Reserved.
 * ±¾Èí¼þΪÉîÛÚÆó¶ìÍøÂç¿Æ¼¼ÓÐÏÞ¹«Ë¾¿ª·¢ÑÐÖÆ¡£Î´¾­±¾¹«Ë¾ÕýʽÊéÃæͬÒ⣬ÆäËûÈκθöÈË¡¢ÍÅÌå
 * ²»µÃʹÓᢸ´ÖÆ¡¢Ð޸Ļò·¢²¼±¾Èí¼þ.
 *****************************************************************************/

package com.qxueyou.scc.base.dao;

import java.io.Serializable;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.transform.Transformers;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate4.HibernateCallback;
import org.springframework.orm.hibernate4.support.HibernateDaoSupport;

import com.qxueyou.scc.base.model.Pager;
import com.qxueyou.scc.base.model.Result;

/**
 * »ù´¡DAOÀà,×Ô¶¯×¢ÈësessionFactory
 *
 * @author Ïĵ»¢
 * @since JDK1.6
 * @history 2010-07-28 Ïĵ»¢ н¨
 */
public class BaseDAO extends HibernateDaoSupport {
	
	/** ×¢ÊÍ rawtypes  */
	private static final String RAW_TYPES = "rawtypes";
	
    /**
     * ×¢ÈësessionFactory
     *
     * @param sessionFactory
     */
    @Autowired(required = false)
    public void setSessionfactory(SessionFactory sessionFactory) {
        this.setSessionFactory(sessionFactory);
    }

    /**
     * ¶ÁÈ¡¶ÔÏó
     *
     * @param <T> ·ºÐÍÀàÐÍ
     * @param clz VO CLASSÀàÐÍ
     * @param key VO Ö÷¼ü
     * @return ²éÕÒµ½µÄ½á¹û,Èç¹ûûÕÒµ½,·µ»Ønull
     */
    public <T> T read(Class<T> clz, Serializable key) {
    	if(key==null){
    		return null;
    	}
        return clz.cast(this.getHibernateTemplate().get(clz, key));
    }

    /**
     * ±£´æ¶ÔÏó
     */
    public void update(Object obj) {
        this.getHibernateTemplate().update(obj);
    }
    
    /**
     * ±£´æ¶ÔÏó
     */
    public void save(Object obj) {
        this.getHibernateTemplate().save(obj);
    }

    /**
     * ±£´æ»ò¸üжÔÏó
     */
    public void saveOrUpdate(Object obj) {
        this.getHibernateTemplate().saveOrUpdate(obj);
    }

    /**
     * ±£´æ»ò¸üм¯ºÏ¶ÔÏó
     */
    public void saveOrUpdateAll(@SuppressWarnings(RAW_TYPES) Collection collection) {
        for(Object obj:collection){
        	this.getHibernateTemplate().saveOrUpdate(obj);
        }
    }

    /**
     * ±£´æ»ò¸üжÔÏó
     */
    public void deleteAll(@SuppressWarnings(RAW_TYPES) Collection col) {
        this.getHibernateTemplate().deleteAll(col);
    }
    
    /**
     * ¸ù¾Ýhql²éѯ,²¢·µ»ØÖ´ÐÐÀàÐ͵ÄÁбí½á¹û
     *
     * @param hql ²éѯÓï¾ä
     * @param cls ·µ»ØÀàÐÍ
     * @return
     */
    @SuppressWarnings("unchecked")
	public <T> List<T> find(String hql, Class<T> cls) {
        return find(hql,Collections.EMPTY_LIST,cls);
    }
    
    /**
     * ¸ù¾Ýhql²éѯ,²¢·µ»ØÖ´ÐÐÀàÐ͵ÄÁбí½á¹û
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊý
     * @param cls ·µ»ØÀàÐÍ
     * @return
     */
	public <T> List<T> find(final String hql,final List<Object> args,final Class<T> cls) {
    	return this.getHibernateTemplate().execute(new HibernateCallback<List<T>>() {

            @SuppressWarnings("unchecked")
			public List<T> doInHibernate(Session session) {
                Query query = session.createQuery(hql);
                int i = 0;
                for (Object arg : args) {
                    query.setParameter(i++, arg);
                }
                query.setFirstResult(0);
                query.setMaxResults(Integer.MAX_VALUE);
                return query.list();
            }
        });
    }
    
    /**
     * ¸ù¾Ýhql²éѯ,²¢·µ»ØÖ´ÐÐÀàÐ͵ÄÁбí
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊý
     * @param cls ·µ»ØÀàÐÍ 
     * @return
     */
	@SuppressWarnings("unchecked")
	public List<Object[]> findwithRawResult(String hql, List<Object> args) {
        return (List<Object[]>) this.getHibernateTemplate().find(hql, args.toArray());
    }
    
    /**
     * ¸ù¾Ýhql²éѯ,·µ»ØÁбíÊý¾Ý×ÜÊý
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊý
     * @param cls ·µ»ØÀàÐÍ
     * @return
     */
	public int findCount(final String hql, final List<Object> args) {
    	return getHibernateTemplate().execute(new HibernateCallback<Integer>() {
    		 
            @Override
            public Integer doInHibernate(Session session){
            	
            	Query query = session.createQuery(hql.trim().startsWith("from")?"select count(1) ".concat(hql):hql);
            	int i = 0;
            	for (Object arg : args) {
                    query.setParameter(i++, arg);
                }
            	
            	if(null != query.uniqueResult()){
            		return ((Long)query.uniqueResult()).intValue();
            	}else{
            		return 0 ;
            	}
            }
        });
    }
	
	 /**
     * ¸ù¾Ýhql²éѯ,·µ»ØÁбíÊý¾Ý×ÜÊý
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊý
     * @param cls ·µ»ØÀàÐÍ
     * @return
     */
	public int findCountBySql(final String sql, final List<Object> args) {
    	return getHibernateTemplate().execute(new HibernateCallback<Integer>() {
    		 
            @Override
            public Integer doInHibernate(Session session){
            	
            	Query query = session.createSQLQuery(sql.trim().startsWith("from")?"select count(1) ".concat(sql):sql);
            	int i = 0;
            	for (Object arg : args) {
                    query.setParameter(i++, arg);
                }
            	
            	if(null != query.uniqueResult()){
            		return ((BigInteger)query.uniqueResult()).intValue();
            	}else{
            		return 0 ;
            	}
            }
        });
    }
    
    /**
     * ¸ù¾Ýhql²éѯ,·µ»ØÁбí·ÖÒ³Êý¾Ý
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊý
     * @param cls ·µ»ØÀàÐÍ
     * @return
     */
    @SuppressWarnings({ "unchecked" })
	public <T> List<T> findList(final String hql, final Pager page, final List<Object> args,Class<T> cls) {
        return this.getHibernateTemplate().execute(new HibernateCallback<List<T>>() {

            public List<T> doInHibernate(Session session) {
                Query query = session.createQuery(hql);
                int i = 0;
                for (Object arg : args) {
                    query.setParameter(i++, arg);
                }
                query.setFirstResult(page.getPageSize()*(page.getPageNum()-1));
                query.setMaxResults(page.getPageSize());
                return query.list();
            }
        });
    }
    
    /**
     * ¸ù¾Ýhql²éѯ,·µ»ØΨһµÄÊý¾Ý
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊý
     * @param cls ·µ»ØÀàÐÍ
     * @return
     */
    @SuppressWarnings({ RAW_TYPES, "unchecked" })
	public <T> T findUnique(final String hql, final List<Object> args,Class<T> cls) {
        return  (T)this.getHibernateTemplate().execute(new HibernateCallback() {

            public Object doInHibernate(Session session) {
                Query query = session.createQuery(hql);
                int i = 0;
                for (Object arg : args) {
                    query.setParameter(i++, arg);
                }
                query.setFirstResult(0);
                query.setMaxResults(1);
                List result =  query.list();
                return result.isEmpty()?null:result.get(0);
            }

        });
    }

    /**
     * ¸ù¾Ýhql²éѯ,²¢·µ»ØÖ´ÐÐÀàÐ͵ÄÁбí½á¹û
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊý
     * @param cls ·µ»ØÀàÐÍ
     * @return
     */
    @SuppressWarnings({ RAW_TYPES})
    public List findBySql(final String sql, final List args) {
        return this.getHibernateTemplate().execute(new HibernateCallback<List>() {

            public List doInHibernate(Session session) {
                SQLQuery query = session.createSQLQuery(sql);
                int i = 0;
                for (Object arg : args) {
                    query.setParameter(i++, arg);
                }
                return query.list();
            }

        });
    }
    
    /**
     * ¸ù¾Ýhql²éѯ,²¢·µ»ØÖ´ÐÐÀàÐ͵ÄÁбí½á¹û
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊý
     * @param cls ·µ»ØÀàÐÍ
     * @return
     */
    @SuppressWarnings({ RAW_TYPES})
    public List findByPageSql(final String sql, final List args, final Pager pager) {
        return this.getHibernateTemplate().execute(new HibernateCallback<List>() {

            public List doInHibernate(Session session) {
                SQLQuery query = session.createSQLQuery(sql);
                int i = 0;
                for (Object arg : args) {
                    query.setParameter(i++, arg);
                }
                query.setFirstResult(pager.getPageSize()*(pager.getPageNum()-1));
	            query.setMaxResults(pager.getPageSize());
                return query.list();
            }

        });
    }
    
    
    /**
     * hqlÖ»º¬µ¥Ò»²ÎÊý
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊýÊý×é
     * @param cls ·µ»ØÀàÐÍ
     * @return
     */
    public Result bulkUpdateInLoop(String hql, Object args[]) {
    	int iCount = 0;
        for(Object arg:args){
        	iCount += getHibernateTemplate().bulkUpdate(hql, arg);
        }
        Map<String,Object> attrs = new HashMap<String,Object>(1);
        attrs.put("doCount", iCount);
        Result result = new Result(true);
        result.setData(attrs);
    	return result;
    }
    
    /**
     * hqlÖ»º¬µ¥Ò»²ÎÊý
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊýÊý×é
     * @param cls ·µ»ØÀàÐÍ
     * @return
     */
    public Result bulkUpdate(String hql, Object args[]) {
        int count = getHibernateTemplate().bulkUpdate(hql, args);      
        Map<String,Object> attrs = new HashMap<String,Object>(1);
        attrs.put("doCount", count);
        Result result = new Result(true);
        result.setData(attrs);
    	return result;
    }
    
    /**
     * ´æ´¢¹ý³ÌÓï¾ä
     *
     * @param hql call ´æ´¢Óï¾ä sqlÓï¾ä
     * @param args ²ÎÊýÊý×é
     * @return
     */
	public Result executeProduce(final String sql, final Object args[]) {
    	
    	Integer result = getHibernateTemplate().execute(new HibernateCallback<Integer>(){

			@Override
			public Integer doInHibernate(Session session)
					throws HibernateException {
				
				Query query = session.createSQLQuery("{ "+sql+" }");
				for(int i=0;i<args.length;i++){
					query.setParameter(i, args[i]);
				}
                return query.executeUpdate();
			}
        	
        });
        return new Result(true,String.valueOf(result));
    }
    
    /**
     * Ö´ÐÐsqlɾ³ý
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊýÊý×é
     * @return
     */
	public int executeSqlDelete(final String sql, final Object args[]) {
    	
    	return getHibernateTemplate().execute(new HibernateCallback<Integer>(){

			@Override
			public Integer doInHibernate(Session session)
					throws HibernateException {
				
				Query query = session.createSQLQuery(sql);
				for(int i=0;i<args.length;i++){
					query.setParameter(i, args[i]);
				}
                return query.executeUpdate();
			}
        	
        });
    }
    
    /**
     * ¸ù¾Ýhql²éѯ,²¢·µ»ØÖ´ÐÐÀàÐ͵ÄÁбí½á¹û
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊý
     * @param cls ·µ»ØÀàÐÍ
     * @return
     */
    @SuppressWarnings({RAW_TYPES, "unchecked" })
    public List<Object[]> findRawByComplexHql(final String hql, final Map<String, Object> map) {
    	// ²éѯ½á¹û
        return  (List<Object[]>)this.getHibernateTemplate().execute(new HibernateCallback<List>() {
            public List doInHibernate(Session session) {
                Query query = session.createQuery(hql);
                if (map != null) {  
                    Set<String> keySet = map.keySet();  
                    for (String string : keySet) {  
                        Object obj = map.get(string);  
                        //ÕâÀÂÇ´«ÈëµÄ²ÎÊýÊÇʲôÀàÐÍ£¬²»Í¬ÀàÐÍʹÓõķ½·¨²»Í¬  
                        if(obj instanceof Collection<?>){  
                            query.setParameterList(string, (Collection<?>)obj);  
                        }else if(obj instanceof Object[]){  
                            query.setParameterList(string, (Object[])obj);  
                        }else{  
                            query.setParameter(string, obj);  
                        }  
                    }  
                }  
                return query.list();
            }

        });
    }   
    
    /**
     * ¸ù¾Ýhql²éѯ,·µ»ØÁбíÊý¾Ý×ÜÊý
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊý
     * @param cls ·µ»ØÀàÐÍ
     * @return
     */
	public int findCountByComplexHql(final String hql, final Map<String, Object> map) {
    	return getHibernateTemplate().execute(new HibernateCallback<Integer>() {
    		 
            @Override
            public Integer doInHibernate(Session session){
            	
            	Query queryHql = session.createQuery(hql.trim().startsWith("from")?"select count(1) ".concat(hql):hql);
            	
            	if (map != null) {  
                    Set<String> keySet = map.keySet();  
                    for (String string : keySet) {  
                        Object obj = map.get(string);  
                        //ÕâÀÂÇ´«ÈëµÄ²ÎÊýÊÇʲôÀàÐÍ£¬²»Í¬ÀàÐÍʹÓõķ½·¨²»Í¬  
                        if(obj instanceof Collection<?>){  
                        	queryHql.setParameterList(string, (Collection<?>)obj);  
                        }else if(obj instanceof Object[]){  
                        	queryHql.setParameterList(string, (Object[])obj);  
                        }else{  
                        	queryHql.setParameter(string, obj);  
                        }  
                    }  
            	}
            	
            	if(null != queryHql.uniqueResult()){
            		return ((Long)queryHql.uniqueResult()).intValue();
            	}else{
            		return 0 ;
            	}
            }
        });
    }
	
	 /**
     * ¸ù¾Ýsql²éѯ,·µ»ØÁбíÊý¾Ý×ÜÊý
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊý
     * @param cls ·µ»ØÀàÐÍ
     * @return
     */
	public int findCountByComplexSql(final String hql, final Map<String, Object> map) {
    	return getHibernateTemplate().execute(new HibernateCallback<Integer>() {
    		 
            @Override
            public Integer doInHibernate(Session session){
            	
            	Query querySql = session.createSQLQuery(hql.trim().startsWith("from")?"select count(1) ".concat(hql):hql);
            	
            	if (map != null) {  
                    Set<String> keySet = map.keySet();  
                    for (String string : keySet) {  
                        Object obj = map.get(string);  
                        //ÕâÀÂÇ´«ÈëµÄ²ÎÊýÊÇʲôÀàÐÍ£¬²»Í¬ÀàÐÍʹÓõķ½·¨²»Í¬  
                        if(obj instanceof Collection<?>){  
                        	querySql.setParameterList(string, (Collection<?>)obj);  
                        }else if(obj instanceof Object[]){  
                        	querySql.setParameterList(string, (Object[])obj);  
                        }else{  
                        	querySql.setParameter(string, obj);  
                        }  
                    }  
            	}
            	
            	if(null != querySql.uniqueResult()){
            		return ((BigInteger)querySql.uniqueResult()).intValue();
            	}else{
            		return 0 ;
            	}
            }
        });
    }
	
    /**
     * ¸ù¾Ýhql²éѯ,²¢·µ»ØÖ´ÐÐÀàÐ͵ÄÁбí½á¹û
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊý
     * @param cls ·µ»ØÀàÐÍ
     * @return
     */
    public <T> List<T> findByComplexHql(final String hql, final Map<String, Object> map, Class<T> cls) {
    	Pager page = new Pager();
    	page.setPageSize(Integer.MAX_VALUE);
    	page.setPageNum(1);
        return findByComplexHql(hql, page, map, cls);
    }
    
    /**
     * ¸´ÔÓhql
     * @param sql
     * @param map
     * @param cls
     * @return
     */
    public <T> T findUniqueByHql(final String hql, final Map<String, Object> map){
    	// ²éѯ½á¹û
        List<T> lst =  this.getHibernateTemplate().execute(new HibernateCallback<List<T>>() {
        	
            @SuppressWarnings("unchecked")
			public List<T> doInHibernate(Session session) {
                Query queryHql = session.createQuery(hql);
                if (map != null) {  
                    Set<String> keySet = map.keySet();  
                    for (String string : keySet) {  
                        Object obj = map.get(string);  
                        //ÕâÀÂÇ´«ÈëµÄ²ÎÊýÊÇʲôÀàÐÍ£¬²»Í¬ÀàÐÍʹÓõķ½·¨²»Í¬  
                        if(obj instanceof Collection<?>){  
                        	queryHql.setParameterList(string, (Collection<?>)obj);  
                        }else if(obj instanceof Object[]){  
                        	queryHql.setParameterList(string, (Object[])obj);  
                        }else{  
                        	queryHql.setParameter(string, obj);  
                        }  
                    }  
                }  
                queryHql.setFirstResult(0);
                queryHql.setMaxResults(1);
                
                List<?> r = queryHql.list();
                
                List<T> lst = new ArrayList<T>(r.size());
                for(Object o:r) {
                	lst.add((T)o);
                }
                return lst;
            }

        });
        
        return lst.isEmpty()?null:lst.get(0);
    }
    
    /**
     * ¸ù¾Ýhql²éѯ,²¢·µ»ØÖ´ÐÐÀàÐ͵ÄÁбí½á¹û£¬ÁбíÊý¾ÝΪMap
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊý
     * @return
     */
    public List<Map<String,Object>> findListWithMapByHql(final String hql, final Map<String, Object> map) {
    	Pager page = new Pager();
    	page.setPageNum(1);
    	page.setPageSize(Integer.MAX_VALUE);
    	
        return findListWithMapByHql(hql,map,page);
    }
    
    /**
     * ¸ù¾Ýhql²éѯ,²¢·µ»ØÖ´ÐÐÀàÐ͵ÄÁбí½á¹û£¬ÁбíÊý¾ÝΪMap
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊý
     * @return
     */
    @SuppressWarnings("unchecked")
    public List<Map<String,Object>> findListWithMapByHql(final String hql, final Map<String, Object> map,final Pager page) {
    	// ²éѯ½á¹û
        List<Map<String,Object>> lst =  getHibernateTemplate().execute(new HibernateCallback<List<Map<String,Object>>>() {
			public List<Map<String,Object>> doInHibernate(Session session) {
                Query query = session.createQuery(hql).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
                if (map != null) {  
                    Set<String> keySet = map.keySet();  
                    for (String string : keySet) {  
                        Object obj = map.get(string);  
                        //ÕâÀÂÇ´«ÈëµÄ²ÎÊýÊÇʲôÀàÐÍ£¬²»Í¬ÀàÐÍʹÓõķ½·¨²»Í¬  
                        if(obj instanceof Collection<?>){  
                            query.setParameterList(string, (Collection<?>)obj);  
                        }else if(obj instanceof Object[]){  
                            query.setParameterList(string, (Object[])obj);  
                        }else{  
                            query.setParameter(string, obj);  
                        }  
                    }
                }  
                query.setFirstResult(page.getPageSize()*(page.getPageNum()-1));
                query.setMaxResults(page.getPageSize());
                return query.list();
            }

        });
        
        return lst;
    }
    
    /**
     * ¸ù¾Ýhql²éѯ,²¢·µ»ØΨһһÌõ½á¹û
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊý
     * @param cls ·µ»ØÀàÐÍ
     * @return
     */
    @SuppressWarnings({RAW_TYPES })
    public <T> T findUniqueByComplexHql(final String hql, final Map<String, Object> map, Class<T> cls) {
    	// ²éѯ½á¹û
        List<T> lst =  this.getHibernateTemplate().execute(new HibernateCallback<List<T>>() {
            public List doInHibernate(Session session) {
                Query query = session.createQuery(hql);
                if (map != null) {  
                    Set<String> keySet = map.keySet();  
                    for (String string : keySet) {  
                        Object obj = map.get(string);  
                        //ÕâÀÂÇ´«ÈëµÄ²ÎÊýÊÇʲôÀàÐÍ£¬²»Í¬ÀàÐÍʹÓõķ½·¨²»Í¬  
                        if(obj instanceof Collection<?>){  
                            query.setParameterList(string, (Collection<?>)obj);  
                        }else if(obj instanceof Object[]){  
                            query.setParameterList(string, (Object[])obj);  
                        }else{  
                            query.setParameter(string, obj);  
                        }  
                    }  
                }  
                query.setFirstResult(0);
                query.setMaxResults(1);
                return query.list();
            }

        });
        
        return lst.isEmpty()?null:cls.cast(lst.get(0));
    }

    
    /**
     * ¸ù¾ÝSql²éѯ,²¢·µ»ØÖ´ÐÐÀàÐ͵ÄÁбí½á¹û
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊý
     * @param cls ·µ»ØÀàÐÍ
     * @return
     */
    public <T> List<T> findByComplexSql(final String sql, final Map<String, Object> map, Class<T> cls) {
    	Pager page = new Pager();
    	page.setPageSize(Integer.MAX_VALUE);
    	page.setPageNum(1);
        return findByComplexSql(sql, page, map, cls);
    }
    
    
    /**
     * ¸ù¾ÝSql²éѯ,²¢·µ»ØÖ´ÐÐÀàÐ͵ÄÁбí½á¹û
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊý
     * @param cls ·µ»ØÀàÐÍ
     * @return
     */
    @SuppressWarnings({RAW_TYPES, "unchecked" })
    public List<Object[]> findRawByComplexSql(final String sql, final Map<String, Object> map) {
    	// ²éѯ½á¹û
        return  (List<Object[]>)this.getHibernateTemplate().execute(new HibernateCallback<List>() {
            public List doInHibernate(Session session) {
                SQLQuery query = session.createSQLQuery(sql);
                if (map != null) {  
                    Set<String> keySet = map.keySet();  
                    for (String string : keySet) {  
                        Object obj = map.get(string);  
                        //ÕâÀÂÇ´«ÈëµÄ²ÎÊýÊÇʲôÀàÐÍ£¬²»Í¬ÀàÐÍʹÓõķ½·¨²»Í¬  
                        if(obj instanceof Collection<?>){  
                            query.setParameterList(string, (Collection<?>)obj);  
                        }else if(obj instanceof Object[]){  
                            query.setParameterList(string, (Object[])obj);  
                        }else{  
                            query.setParameter(string, obj);  
                        }  
                    }  
                }  
                return query.list();
            }

        });
        
     
    }
    
    /**
     * ¸ù¾Ýhql²éѯ,²¢·µ»ØÖ´ÐÐÀàÐ͵ÄÁбí½á¹û
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊý
     * @param cls ·µ»ØÀàÐÍ
     * @return
     */
    @SuppressWarnings({RAW_TYPES })
    public <T> List<T> findByComplexHql(final String hql,final Pager page, final Map<String, Object> map, Class<T> cls) {
    	// ²éѯ½á¹û
        List lst =  this.getHibernateTemplate().execute(new HibernateCallback<List>() {
            public List doInHibernate(Session session) {
                Query queryHql = session.createQuery(hql);
                if (map != null) {  
                    Set<String> keySet = map.keySet();  
                    for (String string : keySet) {  
                        Object obj = map.get(string);  
                        //ÕâÀÂÇ´«ÈëµÄ²ÎÊýÊÇʲôÀàÐÍ£¬²»Í¬ÀàÐÍʹÓõķ½·¨²»Í¬  
                        if(obj instanceof Collection<?>){  
                        	queryHql.setParameterList(string, (Collection<?>)obj);  
                        }else if(obj instanceof Object[]){  
                        	queryHql.setParameterList(string, (Object[])obj);  
                        }else{  
                        	queryHql.setParameter(string, obj);  
                        }  
                    }  
                }  
                queryHql.setFirstResult(page.getPageSize()*(page.getPageNum()-1));
                queryHql.setMaxResults(page.getPageSize());
                return queryHql.list();
            }

        });
        
        // ×é×°½á¹û
        List<T> result = new ArrayList<T>();
        for (Object obj : lst) {
            result.add(cls.cast(obj));
        }
        return result;
    }
    
    /**
     * ¸ù¾ÝSql²éѯ,²¢·µ»ØÖ´ÐÐÀàÐ͵ÄÁбí½á¹û
     *
     * @param hql ²éѯÓï¾ä
     * @param args ²ÎÊý
     * @param cls ·µ»ØÀàÐÍ
     * @return
     */
    @SuppressWarnings({RAW_TYPES })
    public <T> List<T> findByComplexSql(final String sql,final Pager page, final Map<String, Object> map, Class<T> cls) {
    	// ²éѯ½á¹û
        List lst =  this.getHibernateTemplate().execute(new HibernateCallback<List>() {
            public List doInHibernate(Session session) {
            	 SQLQuery querySql = session.createSQLQuery(sql);
                if (map != null) {  
                    Set<String> keySet = map.keySet();  
                    for (String string : keySet) {  
                        Object obj = map.get(string);  
                        //ÕâÀÂÇ´«ÈëµÄ²ÎÊýÊÇʲôÀàÐÍ£¬²»Í¬ÀàÐÍʹÓõķ½·¨²»Í¬  
                        if(obj instanceof Collection<?>){  
                        	querySql.setParameterList(string, (Collection<?>)obj);  
                        }else if(obj instanceof Object[]){  
                        	querySql.setParameterList(string, (Object[])obj);  
                        }else{  
                        	querySql.setParameter(string, obj);  
                        }  
                    }  
                }  
                querySql.setFirstResult(page.getPageSize()*(page.getPageNum()-1));
                querySql.setMaxResults(page.getPageSize());
                return querySql.list();
            }

        });
        
        // ×é×°½á¹û
        List<T> result = new ArrayList<T>();
        for (Object obj : lst) {
            result.add(cls.cast(obj));
        }
        return result;
    }
    
    
}