乡下人产国偷v产偷v自拍,国产午夜片在线观看,婷婷成人亚洲综合国产麻豆,久久综合给合久久狠狠狠9

    • <output id="e9wm2"></output>
    <s id="e9wm2"><nobr id="e9wm2"><ins id="e9wm2"></ins></nobr></s> 
    

    • 
    
    
      



    
      
        
      
            
        
      
        
      
    
      
    
      
        
      
        
      
            
            
      
                
      
                    
                
      
                搜索
            
      

            分享
                
            

            
            
            
            
            
            
            
            

            
        
      
    
      
    
      

    
      

    
      
        
      
        
      
        
      
        
      
            
      
                
      
                    
      基于hibernate的BaseDAO接口
      
                    
                    
                    
                    
      
                         feimishiwo
                        
                        
                        2015-09-11
                        
                            
                        
                    
      
                    
      
                        
                        
      
                    
      
                    
                    
      
                        
      
                            
                        
      
                        
      
                            
                                
      
                                    
                                        
      

                                        
                                        

                                        
      BaseDao.java
      


      1. import java.io.Serializable;  
      2. import java.util.Collection;  
      3. import java.util.List;  
      4. import java.util.Map;  
      5.   
      6. import com.xxx.finance.utils.HibernateHandler;  
      7. import com.xxx.finance.utils.Pagination;  
      8.   
      9. public interface BaseDao<T> {  
      10.   
      11.     /**  
      12.      * 保存實體  
      13.      *   
      14.      * @param entity  
      15.      *            實體對象  
      16.      * @return 實體主鍵  
      17.      */  
      18.     Object save(Object entity);  
      19.   
      20.     /**  
      21.      *   
      22.      * 刪除實體  
      23.      *   
      24.      * @param entity  
      25.      *            實體對象  
      26.      *   
      27.      */  
      28.     void delete(Object entity);  
      29.   
      30.     /**  
      31.      *   
      32.      * 更新實體  
      33.      *   
      34.      * @param entity  
      35.      *            實體對象  
      36.      *   
      37.      */  
      38.     void update(Object entity);  
      39.   
      40.     /**  
      41.      *   
      42.      * 保存或更新實體, 實體沒有主鍵時保存，否則更新  
      43.      *   
      44.      * @param entity  
      45.      *            實體對象  
      46.      *   
      47.      */  
      48.     void saveOrUpdate(Object entity);  
      49.   
      50.     /**  
      51.      *   
      52.      * 批量保存實體  
      53.      *   
      54.      * @param entities  
      55.      *            實體集合  
      56.      */  
      57.     void saveAll(Collection<?> entities);  
      58.   
      59.     /**  
      60.      *   
      61.      * 批量刪除實體  
      62.      *   
      63.      * @param entities  
      64.      *            實體集合  
      65.      *   
      66.      */  
      67.     void deleteAll(Collection<?> entities);  
      68.   
      69.     /**  
      70.      *   
      71.      * 批量更新實體  
      72.      *   
      73.      * @param entities  
      74.      *            實體集合  
      75.      *   
      76.      */  
      77.     void updateAll(Collection<?> entity);  
      78.   
      79.     /**  
      80.      *   
      81.      * 批量保存或更新實體, 實體沒有主鍵時保存，否則更新  
      82.      *   
      83.      * @param entity  
      84.      *            實體集合  
      85.      *   
      86.      */  
      87.     void saveOrUpdateAll(Collection<?> entities);  
      88.   
      89.     /**  
      90.      *   
      91.      * 獲取單個實體，根據實體類及實體的主鍵獲取。  
      92.      *   
      93.      * @param entityClass  
      94.      *            實體類  
      95.      * @param id  
      96.      *            實體主鍵  
      97.      * @return 實體對象  
      98.      */  
      99.     @SuppressWarnings("hiding")  
      100.     <T> T get(Class<T> entityClass, Serializable id);  
      101.   
      102.     /**  
      103.      * 獲取單個實體，根據查詢語句及參數獲取。  
      104.      *   
      105.      * @param queryString  
      106.      *            查詢語句  
      107.      * @param params  
      108.      *            可選的查詢參數  
      109.      * @return 單個實體，如果查詢結果有多個，則返回第一個實體  
      110.      */  
      111.     @SuppressWarnings("hiding")  
      112.     <T> T get(CharSequence queryString, Map<String, Object> params);  
      113.   
      114.     /**  
      115.      * 獲取單個實體，根據查詢語句及參數獲取。  
      116.      *   
      117.      * @param queryString  
      118.      *            查詢語句  
      119.      * @param params  
      120.      *            可選的查詢參數  
      121.      * @return 單個實體，如果查詢結果有多個，則返回第一個實體  
      122.      */  
      123.     @SuppressWarnings("hiding")  
      124.     <T> T get(CharSequence queryString, Object... params);  
      125.   
      126.     /**  
      127.      *   
      128.      * 查詢實體列表  
      129.      *   
      130.      * @param queryString  
      131.      *            查詢語句  
      132.      * @param params  
      133.      *            可選的查詢參數  
      134.      * @return 實體列表  
      135.      */  
      136.     @SuppressWarnings("hiding")  
      137.     <T> List<T> findList(CharSequence queryString, Object... params);  
      138.   
      139.     /**  
      140.      *   
      141.      * 查詢實體列表  
      142.      *   
      143.      * @param queryString  
      144.      *            查詢語句  
      145.      * @param params  
      146.      *            可選的查詢參數  
      147.      * @return 實體列表  
      148.      */  
      149.     @SuppressWarnings("hiding")  
      150.     <T> List<T> findList(CharSequence queryString, Map<String, Object> params);  
      151.   
      152.     /**  
      153.      * 分頁查詢實體  
      154.      *   
      155.      * @param queryString  
      156.      *            查詢語句  
      157.      * @param pageIndex  
      158.      *            當前頁碼，如果pageIndex<1則不分頁，且返回pageSize條記錄。  
      159.      * @param pageSize  
      160.      *            每頁記錄數，如果pageSize<1則返回所有記錄。  
      161.      * @param params  
      162.      *            可選的查詢參數  
      163.      * @return 實體分頁對象  
      164.      */  
      165.     @SuppressWarnings("hiding")  
      166.     <T> Pagination<T> findPagination(CharSequence queryString, int pageIndex, int pageSize, Object... params);  
      167.   
      168.     /**  
      169.      * 分頁查詢實體  
      170.      *   
      171.      * @param queryString  
      172.      *            查詢語句  
      173.      * @param params  
      174.      *            可選的查詢參數  
      175.      * @param pageIndex  
      176.      *            當前頁碼，如果pageIndex<2則不分頁，且返回pageSize條記錄。  
      177.      * @param pageSize  
      178.      *            每頁記錄數，如果pageSize<1則返回所有記錄。  
      179.      *   
      180.      * @return 實體分頁對象  
      181.      */  
      182.     @SuppressWarnings("hiding")  
      183.     <T> Pagination<T> findPagination(CharSequence queryString, Map<String, Object> params, int pageIndex, int pageSize);  
      184.   
      185.     /**  
      186.      * 分頁查詢實體，自定義總條數查詢語句，適合復雜的hql分頁查詢  
      187.      *   
      188.      * @param queryString  
      189.      *            查詢語句  
      190.      * @param countString  
      191.      *            查詢記錄總條數語句  
      192.      * @param pageIndex  
      193.      *            當前頁碼，如果pageIndex<1則不分頁，且返回pageSize條記錄。  
      194.      * @param pageSize  
      195.      *            每頁記錄數，如果pageSize<1則返回所有記錄。  
      196.      * @param params  
      197.      *            可選的查詢參數  
      198.      * @return 實體分頁對象  
      199.      */  
      200.     @SuppressWarnings("hiding")  
      201.     <T> Pagination<T> findPagination(CharSequence queryString, CharSequence countString, int pageIndex, int pageSize,  
      202.             Object... params);  
      203.   
      204.     /**  
      205.      * 分頁查詢實體，自定義總條數查詢語句，適合復雜的hql分頁查詢  
      206.      *   
      207.      * @param queryString  
      208.      *            查詢語句  
      209.      * @param countString  
      210.      *            查詢記錄總條數語句  
      211.      * @param params  
      212.      *            可選的查詢參數  
      213.      * @param pageIndex  
      214.      *            當前頁碼，如果pageIndex<2則不分頁，且返回pageSize條記錄。  
      215.      * @param pageSize  
      216.      *            每頁記錄數，如果pageSize<1則返回所有記錄。  
      217.      *   
      218.      * @return 實體分頁對象  
      219.      */  
      220.     @SuppressWarnings("hiding")  
      221.     <T> Pagination<T> findPagination(CharSequence queryString, CharSequence countString, Map<String, Object> params,  
      222.             int pageIndex, int pageSize);  
      223.   
      224.     /**  
      225.      * 分頁查詢實體，自定義總條數查詢語句，適合復雜的sql分頁查詢  
      226.      *   
      227.      * @param queryString  
      228.      *            查詢語句  
      229.      * @param countString  
      230.      *            查詢記錄總條數語句  
      231.      * @param params  
      232.      *            可選的查詢參數  
      233.      * @param pageIndex  
      234.      *            當前頁碼，如果pageIndex<2則不分頁，且返回pageSize條記錄。  
      235.      * @param pageSize  
      236.      *            每頁記錄數，如果pageSize<1則返回所有記錄。  
      237.      *   
      238.      * @return 實體分頁對象  
      239.      */  
      240.     @SuppressWarnings("hiding")  
      241.     public <T> Pagination<T> findSqlPagination(final CharSequence queryString, final CharSequence countString,  
      242.             final Map<String, Object> params, int pageIndex, int pageSize);  
      243.   
      244.     /**  
      245.      * 執(zhí)行數據庫更新操作  
      246.      *   
      247.      * @deprecated 用{@link #executeUpdate(String)}替換  
      248.      * @param hql  
      249.      */  
      250.     void execute(String hql);  
      251.   
      252.     /**  
      253.      * 執(zhí)行數據庫更新操作  
      254.      *   
      255.      * @deprecated 用{@link #executeUpdate(HibernateHandler)}替換  
      256.      * @param hql  
      257.      */  
      258.     void execute(HibernateHandler handler);  
      259.   
      260.     /**  
      261.      * 執(zhí)行數據庫更新操作  
      262.      *   
      263.      * @deprecated 用{@link #executeSqlUpdate(String)}替換  
      264.      * @param sql  
      265.      */  
      266.     void executeSql(String sql);  
      267.   
      268.     /**  
      269.      * 執(zhí)行數據庫查詢操作  
      270.      *   
      271.      * @param handler  
      272.      *            處理器  
      273.      * @return  
      274.      * @throws Exception  
      275.      */  
      276.     Object executeQuery(HibernateHandler handler);  
      277.   
      278.     /**  
      279.      * 執(zhí)行數據庫更新操作  
      280.      *   
      281.      * @param sql  
      282.      * @return 更新的記錄條數  
      283.      */  
      284.     int executeSqlUpdate(String sql);  
      285.   
      286.     /**  
      287.      * 執(zhí)行數據庫更新操作  
      288.      *   
      289.      * @param hql  
      290.      * @return 更新的記錄條數  
      291.      */  
      292.     int executeUpdate(String hql);  
      293.   
      294.     /**  
      295.      * 執(zhí)行數據庫更新操作  
      296.      *   
      297.      * @param handler  
      298.      *            處理器  
      299.      * @return  
      300.      * @throws Exception  
      301.      */  
      302.     Object executeUpdate(HibernateHandler handler);  
      303.   
      304.     public T getById(Serializable id);  
      305.   
      306.     public T saveEntity(T o);  
      307.   
      308.     public T insert(T o);  
      309.   
      310.     public void save(List<T> list);  
      311.   
      312.     public void insert(List<T> list);  
      313.   
      314.     public void delete(List<T> list);  
      315.   
      316.     public void update(List<T> list);  
      317.   
      318.     public List<T> findByProperty(String name, Object value);  
      319.   
      320.     public List<T> findByProperty(Map<String, Object> conditionMap);  
      321.   
      322.     /**  
      323.      *   
      324.      * 查詢實體列表  
      325.      *   
      326.      * @param queryString  
      327.      *            查詢語句  
      328.      * @param maxResults  
      329.      *            列表最大數  
      330.      * @param params  
      331.      *            可選的查詢參數  
      332.      * @return 實體列表  
      333.      */  
      334.     public <V> List<V> findListByMax(CharSequence queryString, int maxResults, Object... params);  
      335.   
      336.     /**  
      337.      *   
      338.      * 查詢實體列表  
      339.      *   
      340.      * @param queryString  
      341.      *            查詢語句  
      342.      * @param maxResults  
      343.      *            列表最大數  
      344.      * @param params  
      345.      *            可選的查詢參數  
      346.      * @return 實體列表  
      347.      */  
      348.     public <V> List<V> findListByMax(CharSequence queryString, int maxResults, Map<String, Object> params);  
      349. }  

      
BaseDaoImpl.java



      1. import java.io.Serializable;  
      2. import java.lang.reflect.ParameterizedType;  
      3. import java.lang.reflect.Type;  
      4. import java.math.BigInteger;  
      5. import java.text.ParseException;  
      6. import java.text.SimpleDateFormat;  
      7. import java.util.ArrayList;  
      8. import java.util.Calendar;  
      9. import java.util.Collection;  
      10. import java.util.Date;  
      11. import java.util.Iterator;  
      12. import java.util.List;  
      13. import java.util.Map;  
      14.   
      15. import javax.annotation.Resource;  
      16.   
      17. import org.hibernate.Query;  
      18. import org.hibernate.SQLQuery;  
      19. import org.hibernate.Session;  
      20. import org.hibernate.SessionFactory;  
      21. import org.hibernate.transform.Transformers;  
      22. import org.springframework.stereotype.Repository;  
      23.   
      24. import com.xxx.finance.dao.BaseDao;  
      25. import com.xxx.finance.utils.HibernateHandler;  
      26. import com.xxx.finance.utils.ObjectUtil;  
      27. import com.xxx.finance.utils.Pagination;  
      28.   
      29. /**  
      30.  * @author   
      31.  */  
      32. @Repository  
      33. public class BaseDaoImpl<T> implements BaseDao<T> {  
      34.   
      35.     protected Class<T> entityClazz;  
      36.   
      37.     protected SessionFactory sessionFactory;  
      38.   
      39.     @SuppressWarnings("unchecked")  
      40.     public BaseDaoImpl() {  
      41.         Type type = getClass().getGenericSuperclass();  
      42.         if (type instanceof ParameterizedType) {  
      43.             this.entityClazz = (Class<T>) ((ParameterizedType) type).getActualTypeArguments()[0];  
      44.         } else {  
      45.             this.entityClazz = null;  
      46.         }  
      47.     }  
      48.   
      49.     @Resource  
      50.     public void setSessionFactory(SessionFactory sessionFactory) {  
      51.         this.sessionFactory = sessionFactory;  
      52.     }  
      53.   
      54.     protected Session getSession() {  
      55.         return sessionFactory.getCurrentSession();  
      56.     }  
      57.   
      58.     @SuppressWarnings("unchecked")  
      59.     public Object save(Object entity) {  
      60.         return (T) getSession().save(entity);  
      61.     }  
      62.   
      63.     public void delete(Object entity) {  
      64.   
      65.         getSession().delete(entity);  
      66.     }  
      67.   
      68.     public void update(Object entity) {  
      69.   
      70.         getSession().update(entity);  
      71.     }  
      72.   
      73.     public void saveOrUpdate(Object entity) {  
      74.   
      75.         getSession().saveOrUpdate(entity);  
      76.     }  
      77.   
      78.     public void saveAll(Collection<?> entities) {  
      79.   
      80.         for (@SuppressWarnings("rawtypes")  
      81.         Iterator localIterator = entities.iterator(); localIterator.hasNext();) {  
      82.             Object entity = localIterator.next();  
      83.             getSession().save(entity);  
      84.         }  
      85.     }  
      86.   
      87.     public void deleteAll(Collection<?> entities) {  
      88.   
      89.         for (@SuppressWarnings("rawtypes")  
      90.         Iterator localIterator = entities.iterator(); localIterator.hasNext();) {  
      91.             Object entity = localIterator.next();  
      92.             getSession().delete(entity);  
      93.         }  
      94.     }  
      95.   
      96.     public void updateAll(Collection<?> entities) {  
      97.   
      98.         for (@SuppressWarnings("rawtypes")  
      99.         Iterator localIterator = entities.iterator(); localIterator.hasNext();) {  
      100.             Object entity = localIterator.next();  
      101.             getSession().update(entity);  
      102.         }  
      103.     }  
      104.   
      105.     public void saveOrUpdateAll(Collection<?> entities) {  
      106.   
      107.         for (@SuppressWarnings("rawtypes")  
      108.         Iterator localIterator = entities.iterator(); localIterator.hasNext();) {  
      109.             Object entity = localIterator.next();  
      110.             getSession().saveOrUpdate(entity);  
      111.         }  
      112.     }  
      113.   
      114.     @SuppressWarnings({ "unchecked", "hiding" })  
      115.     public <T> T get(Class<T> entityClass, Serializable id) {  
      116.   
      117.         return (T) getSession().get(entityClass, id);  
      118.     }  
      119.   
      120.     @SuppressWarnings({ "unchecked", "rawtypes", "hiding" })  
      121.     public <T> T get(CharSequence queryString, Object... params) {  
      122.   
      123.         Query qry = getSession().createQuery(queryString.toString());  
      124.         for (int i = 0; i < params.length; ++i) {  
      125.             qry.setParameter(i, params[i]);  
      126.         }  
      127.         List list = qry.setMaxResults(1).list();  
      128.         if (list.isEmpty())  
      129.             return null;  
      130.         return (T) list.get(0);  
      131.     }  
      132.   
      133.     @SuppressWarnings({ "unchecked", "hiding" })  
      134.     public <T> T get(CharSequence queryString, Map<String, Object> params) {  
      135.   
      136.         Query qry = getSession().createQuery(queryString.toString());  
      137.         setParameter(qry, params);  
      138.         @SuppressWarnings("rawtypes")  
      139.         List list = qry.setMaxResults(1).list();  
      140.         if (list.isEmpty())  
      141.             return null;  
      142.         return (T) list.get(0);  
      143.     }  
      144.   
      145.     @SuppressWarnings({ "unchecked", "hiding" })  
      146.     public <T> List<T> findList(CharSequence queryString, Object... params) {  
      147.         Query query = getSession().createQuery(queryString.toString());  
      148.         for (int i = 0; i < params.length; ++i) {  
      149.             query.setParameter(i, params[i]);  
      150.         }  
      151.         return query.list();  
      152.     }  
      153.   
      154.     @SuppressWarnings({ "unchecked", "hiding" })  
      155.     public <T> List<T> findList(CharSequence queryString, Map<String, Object> params) {  
      156.         Query query = getSession().createQuery(queryString.toString());  
      157.         setParameter(query, params);  
      158.         return query.list();  
      159.     }  
      160.   
      161.     @SuppressWarnings({ "unchecked", "hiding" })  
      162.     public <T> Pagination<T> findPagination(CharSequence queryString, int pageIndex, int pageSize, Object... params) {  
      163.         Query query = getSession().createQuery(queryString.toString());  
      164.   
      165.         if ((pageSize > 0) && (pageIndex > 0)) {  
      166.             query.setFirstResult((pageIndex < 2) ? 0 : (pageIndex - 1) * pageSize);  
      167.             query.setMaxResults(pageSize);  
      168.         }  
      169.   
      170.         for (int i = 0; i < params.length; ++i) {  
      171.             query.setParameter(i, params[i]);  
      172.         }  
      173.         @SuppressWarnings("rawtypes")  
      174.         List items = query.list();  
      175.         long rowsCount = 0L;  
      176.   
      177.         if ((pageSize > 0) && (pageIndex > 0)) {  
      178.             String hql = parseSelectCount(queryString.toString());  
      179.             rowsCount = ((Long) get(hql, params)).longValue();  
      180.         } else {  
      181.             rowsCount = items.size();  
      182.         }  
      183.   
      184.         @SuppressWarnings("rawtypes")  
      185.         Pagination pagination = new Pagination(pageIndex, pageSize, rowsCount);  
      186.         pagination.setItems(items);  
      187.         return pagination;  
      188.     }  
      189.   
      190.     @SuppressWarnings({ "unchecked", "hiding" })  
      191.     public <T> Pagination<T> findPagination(CharSequence queryString, Map<String, Object> params, int pageIndex,  
      192.             int pageSize) {  
      193.         Query query = getSession().createQuery(queryString.toString());  
      194.   
      195.         if ((pageSize > 0) && (pageIndex > 0)) {  
      196.             query.setFirstResult((pageIndex < 2) ? 0 : (pageIndex - 1) * pageSize);  
      197.             query.setMaxResults(pageSize);  
      198.         }  
      199.   
      200.         setParameter(query, params);  
      201.         @SuppressWarnings({ "rawtypes" })  
      202.         List items = query.list();  
      203.         long rowsCount = 0L;  
      204.   
      205.         if ((pageSize > 0) && (pageIndex > 0)) {  
      206.             String hql = parseSelectCount(queryString.toString());  
      207.             rowsCount = ((Long) get(hql, params)).longValue();  
      208.         } else {  
      209.             rowsCount = items.size();  
      210.         }  
      211.   
      212.         @SuppressWarnings("rawtypes")  
      213.         Pagination pagination = new Pagination(pageIndex, pageSize, rowsCount);  
      214.         pagination.setItems(items);  
      215.         return pagination;  
      216.     }  
      217.   
      218.     @SuppressWarnings({ "unchecked", "hiding" })  
      219.     public <T> Pagination<T> findPagination(CharSequence queryString, CharSequence countString, int pageIndex,  
      220.             int pageSize, Object... params) {  
      221.         Query query = getSession().createQuery(queryString.toString());  
      222.   
      223.         if ((pageSize > 0) && (pageIndex > 0)) {  
      224.             query.setFirstResult((pageIndex < 2) ? 0 : (pageIndex - 1) * pageSize);  
      225.             query.setMaxResults(pageSize);  
      226.         }  
      227.   
      228.         for (int i = 0; i < params.length; ++i) {  
      229.             query.setParameter(i, params[i]);  
      230.         }  
      231.         @SuppressWarnings("rawtypes")  
      232.         List items = query.list();  
      233.         long rowsCount = 0L;  
      234.   
      235.         if ((pageSize > 0) && (pageIndex > 0)) {  
      236.             rowsCount = ((Long) get(countString, params)).longValue();  
      237.         } else  
      238.             rowsCount = items.size();  
      239.   
      240.         @SuppressWarnings("rawtypes")  
      241.         Pagination pagination = new Pagination(pageIndex, pageSize, rowsCount);  
      242.         pagination.setItems(items);  
      243.         return pagination;  
      244.     }  
      245.   
      246.     @SuppressWarnings({ "unchecked", "hiding" })  
      247.     public <T> Pagination<T> findPagination(CharSequence queryString, CharSequence countString,  
      248.             Map<String, Object> params, int pageIndex, int pageSize) {  
      249.         Query query = getSession().createQuery(queryString.toString());  
      250.   
      251.         if ((pageSize > 0) && (pageIndex > 0)) {  
      252.             query.setFirstResult((pageIndex < 2) ? 0 : (pageIndex - 1) * pageSize);  
      253.             query.setMaxResults(pageSize);  
      254.         }  
      255.   
      256.         setParameter(query, params);  
      257.         @SuppressWarnings("rawtypes")  
      258.         List items = query.list();  
      259.         long rowsCount = 0L;  
      260.   
      261.         if ((pageSize > 0) && (pageIndex > 0)) {  
      262.             rowsCount = ((Long) get(countString, params)).longValue();  
      263.         } else  
      264.             rowsCount = items.size();  
      265.   
      266.         @SuppressWarnings("rawtypes")  
      267.         Pagination pagination = new Pagination(pageIndex, pageSize, rowsCount);  
      268.         pagination.setItems(items);  
      269.         return pagination;  
      270.     }  
      271.   
      272.     @SuppressWarnings({ "serial", "unchecked", "hiding" })  
      273.     public <T> Pagination<T> findSqlPagination(CharSequence queryString, final CharSequence countString,  
      274.             final Map<String, Object> params, int pageIndex, int pageSize) {  
      275.         SQLQuery query = getSession().createSQLQuery(queryString.toString());  
      276.         query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);  
      277.   
      278.         if ((pageSize > 0) && (pageIndex > 0)) {  
      279.             query.setFirstResult((pageIndex < 2) ? 0 : (pageIndex - 1) * pageSize);  
      280.             query.setMaxResults(pageSize);  
      281.         }  
      282.         if ((params != null) && (!(params.isEmpty()))) {  
      283.             setParameter(query, params);  
      284.         }  
      285.         @SuppressWarnings("rawtypes")  
      286.         List items = query.list();  
      287.         BigInteger rowsCount = BigInteger.valueOf(0L);  
      288.   
      289.         if ((pageSize > 0) && (pageIndex > 0)) {  
      290.             rowsCount = (BigInteger) executeQuery(new HibernateHandler() {  
      291.                 public Object doInHibernate(Session session) {  
      292.                     SQLQuery query = session.createSQLQuery(countString.toString());  
      293.                     if ((params != null) && (!(params.isEmpty()))) {  
      294.                         setParameter(query, params);  
      295.                     }  
      296.                     return query.uniqueResult();  
      297.                 }  
      298.             });  
      299.         }  
      300.   
      301.         @SuppressWarnings("rawtypes")  
      302.         Pagination pagination = new Pagination(pageIndex, pageSize, rowsCount.intValue());  
      303.         pagination.setItems(items);  
      304.         return pagination;  
      305.     }  
      306.   
      307.     public Object executeQuery(HibernateHandler handler) {  
      308.         return handler.doInHibernate(getSession());  
      309.     }  
      310.   
      311.     public void execute(String hql) {  
      312.         executeUpdate(hql);  
      313.     }  
      314.   
      315.     public void execute(HibernateHandler handler) {  
      316.         executeUpdate(handler);  
      317.     }  
      318.   
      319.     public void executeSql(String sql) {  
      320.         executeSqlUpdate(sql);  
      321.     }  
      322.   
      323.     public int executeSqlUpdate(String sql) {  
      324.         return getSession().createSQLQuery(sql).executeUpdate();  
      325.     }  
      326.   
      327.     public int executeUpdate(String hql) {  
      328.         return getSession().createQuery(hql).executeUpdate();  
      329.     }  
      330.   
      331.     public Object executeUpdate(HibernateHandler handler) {  
      332.         return handler.doInHibernate(getSession());  
      333.     }  
      334.   
      335.     protected Query setParameter(Query query, Map<String, Object> parameterMap) {  
      336.         for (@SuppressWarnings("rawtypes")  
      337.         Iterator iterator = parameterMap.keySet().iterator(); iterator.hasNext();) {  
      338.             String key = (String) iterator.next();  
      339.             query.setParameter(key, parameterMap.get(key));  
      340.         }  
      341.         return query;  
      342.     }  
      343.   
      344.     protected boolean followWithWord(String s, String sub, int pos) {  
      345.         int i = 0;  
      346.         for (; (pos < s.length()) && (i < sub.length()); ++i) {  
      347.             if (s.charAt(pos) != sub.charAt(i))  
      348.                 return false;  
      349.             ++pos;  
      350.         }  
      351.   
      352.         if (i < sub.length()) {  
      353.             return false;  
      354.         }  
      355.   
      356.         if (pos >= s.length()) {  
      357.             return true;  
      358.         }  
      359.         return (!(isAlpha(s.charAt(pos))));  
      360.     }  
      361.   
      362.     protected String parseSelectCount(String queryString) {  
      363.         String hql = queryString.toLowerCase();  
      364.         int noBlankStart = 0;  
      365.         for (int len = hql.length(); noBlankStart < len; ++noBlankStart) {  
      366.             if (hql.charAt(noBlankStart) > ' ') {  
      367.                 break;  
      368.             }  
      369.         }  
      370.   
      371.         int pair = 0;  
      372.   
      373.         if (!(followWithWord(hql, "select", noBlankStart))) {  
      374.             pair = 1;  
      375.         }  
      376.         int fromPos = -1;  
      377.         for (int i = noBlankStart; i < hql.length();) {  
      378.             if (followWithWord(hql, "select", i)) {  
      379.                 ++pair;  
      380.                 i += "select".length();  
      381.             } else if (followWithWord(hql, "from", i)) {  
      382.                 --pair;  
      383.                 if (pair == 0) {  
      384.                     fromPos = i;  
      385.                     break;  
      386.                 }  
      387.                 i += "from".length();  
      388.             } else {  
      389.                 ++i;  
      390.             }  
      391.         }  
      392.         if (fromPos == -1) {  
      393.             throw new IllegalArgumentException("parse count sql error, check your sql/hql");  
      394.         }  
      395.   
      396.         String countHql = "select count(*) " + queryString.substring(fromPos);  
      397.         return countHql;  
      398.     }  
      399.   
      400.     protected boolean isAlpha(char c) {  
      401.         return ((c == '_') || (('0' <= c) && (c <= '9')) || (('a' <= c) && (c <= 'z')) || (('A' <= c) && (c <= 'Z')));  
      402.     }  
      403.   
      404.     public void delete(Serializable id) {  
      405.         T entity = getById(id);  
      406.         delete(entity);  
      407.     }  
      408.   
      409.     public void delete(List<T> entitys) {  
      410.         for (T entity : entitys) {  
      411.             delete(entity);  
      412.         }  
      413.     }  
      414.   
      415.     public T getById(Serializable id) {  
      416.         if (id == null)  
      417.             return null;  
      418.   
      419.         return (T) get(entityClazz, id);  
      420.     }  
      421.   
      422.     @Override  
      423.     public T saveEntity(T o) {  
      424.         saveOrUpdate(o);  
      425.         return o;  
      426.     }  
      427.   
      428.     @Override  
      429.     public void save(List<T> list) {  
      430.         saveOrUpdateAll(list);  
      431.     }  
      432.   
      433.     @Override  
      434.     public T insert(T entity) {  
      435.         save(entity);  
      436.         return entity;  
      437.     }  
      438.   
      439.     @Override  
      440.     public void insert(List<T> entitys) {  
      441.         for (T entity : entitys) {  
      442.             save(entity);  
      443.         }  
      444.     }  
      445.   
      446.     @Override  
      447.     public void update(List<T> entitys) {  
      448.         for (T entity : entitys) {  
      449.             update(entity);  
      450.         }  
      451.     }  
      452.   
      453.     @Override  
      454.     public List<T> findByProperty(String name, Object value) {  
      455.         String hql = "from  " + entityClazz.getSimpleName() + " where " + name + "=? ";  
      456.         return findList(hql, value);  
      457.     }  
      458.   
      459.     @Override  
      460.     public List<T> findByProperty(Map<String, Object> conditionMap) {  
      461.         StringBuilder hql = new StringBuilder();  
      462.         hql.append("from  " + entityClazz.getSimpleName());  
      463.         if (!conditionMap.isEmpty()) {  
      464.             Iterator<String> it = conditionMap.keySet().iterator();  
      465.             String key = it.next();  
      466.             hql.append(" where  " + key + "=:" + key);  
      467.             while (it.hasNext()) {  
      468.                 key = it.next();  
      469.                 hql.append(" and  " + key + "=:" + key);  
      470.             }  
      471.         }  
      472.         return findList(hql.toString(), conditionMap);  
      473.     }  
      474.   
      475.     @Override  
      476.     public <V> List<V> findListByMax(final CharSequence queryString, final int maxResults, final Object... params) {  
      477.         @SuppressWarnings({ "unchecked", "serial" })  
      478.         List<V> list = (List<V>) executeQuery(new HibernateHandler() {  
      479.             @Override  
      480.             public List<V> doInHibernate(Session paramSession) {  
      481.                 try {  
      482.                     Query query = paramSession.createQuery(queryString.toString());  
      483.                     for (int i = 0; i < params.length; ++i) {  
      484.                         query.setParameter(i, params[i]);  
      485.                     }  
      486.                     return query.setMaxResults(maxResults).list();  
      487.                 } catch (RuntimeException re) {  
      488.                     throw re;  
      489.                 }  
      490.             }  
      491.         });  
      492.         return list;  
      493.     }  
      494.   
      495.     @Override  
      496.     public <V> List<V> findListByMax(final CharSequence queryString, final int maxResults,  
      497.             final Map<String, Object> params) {  
      498.         @SuppressWarnings({ "unchecked", "serial" })  
      499.         List<V> list = (List<V>) executeQuery(new HibernateHandler() {  
      500.             @Override  
      501.             public List<V> doInHibernate(Session paramSession) {  
      502.                 try {  
      503.                     Query query = paramSession.createQuery(queryString.toString());  
      504.                     for (Iterator<String> iterator = params.keySet().iterator(); iterator.hasNext();) {  
      505.                         String key = iterator.next();  
      506.                         query.setParameter(key, params.get(key));  
      507.                     }  
      508.                     return query.setMaxResults(maxResults).list();  
      509.                 } catch (RuntimeException re) {  
      510.                     throw re;  
      511.                 }  
      512.             }  
      513.   
      514.         });  
      515.         return list;  
      516.     }  
      517.   
      518.     /**  
      519.      * HQL/SQL之數據操作命令(DML)拼接輔助類  
      520.      *   
      521.      * @author PanJun  
      522.      * @deprecated by fu.zhanghua  
      523.      *   
      524.      */  
      525.     public class DmlHelper {  
      526.   
      527.         private ThreadLocal<Calendar> cal = new ThreadLocal<Calendar>() {  
      528.             @Override  
      529.             protected Calendar initialValue() {  
      530.                 return Calendar.getInstance();  
      531.             }  
      532.         };  
      533.   
      534.         /** HQL/SQL參數 */  
      535.         public final List<Object> paramList = new ArrayList<Object>();  
      536.         /** HQL/SQL語句 */  
      537.         public final StringBuilder dmlCmd = new StringBuilder();  
      538.   
      539.         public DmlHelper() {  
      540.         }  
      541.   
      542.         public DmlHelper(CharSequence dml, Object... params) {  
      543.             if (dml != null) {  
      544.                 dmlCmd.append(dml);  
      545.                 for (Object o : params) {  
      546.                     paramList.add(o);  
      547.                 }  
      548.             }  
      549.         }  
      550.   
      551.         @Override  
      552.         public String toString() {  
      553.             return "dml=" + dmlCmd + ", params=" + paramList;  
      554.         }  
      555.   
      556.         public DmlHelper append(CharSequence dmlPart, Object... params) {  
      557.             if (dmlPart != null) {  
      558.                 dmlCmd.append(" ").append(dmlPart);  
      559.                 for (Object o : params) {  
      560.                     paramList.add(o);  
      561.                 }  
      562.             }  
      563.             return this;  
      564.         }  
      565.   
      566.         public DmlHelper addEqual(String fieldName, Object value, Object... nullVal) {  
      567.             if (value == null || fieldName == null) {  
      568.                 return this;  
      569.             }  
      570.   
      571.             if (value instanceof String) {  
      572.                 value = value.toString().trim();  
      573.                 if ("".equals(value)) {  
      574.                     return this;  
      575.                 }  
      576.             }  
      577.   
      578.             for (Object NULL : nullVal) {  
      579.                 if (NULL == value) {  
      580.                     return this;  
      581.                 }  
      582.   
      583.                 if (value.equals(NULL)) {  
      584.                     return this;  
      585.                 }  
      586.             }  
      587.   
      588.             dmlCmd.append(" and ").append(fieldName).append("=? ");  
      589.             paramList.add(value);  
      590.             return this;  
      591.         }  
      592.   
      593.         public DmlHelper addLikeAll(String name, String value) {  
      594.             if (null == value || null == name)  
      595.                 return this;  
      596.   
      597.             value = "%" + value.trim().toLowerCase() + "%";  
      598.             dmlCmd.append(" and lower(").append(name).append(") like ? ");  
      599.             paramList.add(value);  
      600.             return this;  
      601.         }  
      602.   
      603.         /**  
      604.          * 清除時間里的時分秒，只留日期  
      605.          *   
      606.          * @param date  
      607.          * @return new date  
      608.          */  
      609.         private void clearTime(Calendar calendar) {  
      610.             int y = calendar.get(Calendar.YEAR);  
      611.             int m = calendar.get(Calendar.MONTH);  
      612.             int d = calendar.get(Calendar.DAY_OF_MONTH);  
      613.             calendar.clear();  
      614.             calendar.set(Calendar.YEAR, y);  
      615.             calendar.set(Calendar.MONTH, m);  
      616.             calendar.set(Calendar.DAY_OF_MONTH, d);  
      617.         }  
      618.   
      619.         /**  
      620.          * 添加開始日期、結束日期(注意時分秒不記入查詢條件)查詢條件，包含開始日期和結束日期  
      621.          *   
      622.          * @param fieldName  
      623.          *            hbm對象屬性名稱或字段名  
      624.          * @param minDay  
      625.          *            開始日期  
      626.          * @param maxDay  
      627.          *            結果日期  
      628.          */  
      629.         public DmlHelper addDayRange(String fieldName, Date minDay, Date maxDay) {  
      630.             Calendar calendar = cal.get();  
      631.             if (minDay != null) {  
      632.                 calendar.setTime(minDay);  
      633.                 clearTime(calendar);  
      634.                 calendar.add(Calendar.SECOND, -1);  
      635.                 dmlCmd.append(" and ").append(fieldName).append(">? ");  
      636.                 paramList.add(calendar.getTime());  
      637.             }  
      638.   
      639.             if (maxDay != null) {  
      640.                 calendar.setTime(maxDay);  
      641.                 clearTime(calendar);  
      642.                 calendar.add(Calendar.DAY_OF_MONTH, 1);  
      643.                 dmlCmd.append(" and ").append(fieldName).append("<? ");  
      644.                 paramList.add(calendar.getTime());  
      645.             }  
      646.             return this;  
      647.         }  
      648.   
      649.         /**  
      650.          * 添加開始時間、結束時間查詢條件，包含開始時間和結束時間  
      651.          *   
      652.          * @param fieldName  
      653.          *            hbm對象屬性名稱或字段名  
      654.          * @param minTime  
      655.          *            開始時間  
      656.          * @param maxTime  
      657.          *            結果時間  
      658.          */  
      659.         public DmlHelper addDayRange(String fieldName, String minTime, String maxTime) {  
      660.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");  
      661.             Date start_ = null, end_ = null;  
      662.             if (ObjectUtil.hasText(minTime) && ObjectUtil.hasText(maxTime)) {  
      663.                 try {  
      664.                     start_ = sdf.parse(minTime);  
      665.                     end_ = sdf.parse(maxTime);  
      666.                 } catch (ParseException e) {  
      667.                 }  
      668.             }  
      669.   
      670.             return addTimeRange(fieldName, start_, end_);  
      671.         }  
      672.   
      673.         /**  
      674.          * 添加開始時間、結束時間查詢條件，包含開始時間和結束時間  
      675.          *   
      676.          * @param fieldName  
      677.          *            hbm對象屬性名稱或字段名  
      678.          * @param minTime  
      679.          *            開始時間  
      680.          * @param maxTime  
      681.          *            結果時間  
      682.          */  
      683.         public DmlHelper addTimeRange(String fieldName, Date minTime, Date maxTime) {  
      684.             if (minTime != null) {  
      685.                 dmlCmd.append(" and ").append(fieldName).append(">? ");  
      686.                 paramList.add(minTime);  
      687.             }  
      688.   
      689.             if (maxTime != null) {  
      690.                 dmlCmd.append(" and ").append(fieldName).append("<? ");  
      691.                 paramList.add(maxTime);  
      692.             }  
      693.             return this;  
      694.         }  
      695.   
      696.         public <D> Pagination<D> findPagin(int pageIndex, int pageSize) {  
      697.             String hql = dmlCmd.toString();  
      698.             Object[] allParams = new Object[paramList.size()];  
      699.             int i = 0;  
      700.             for (Object o : paramList) {  
      701.                 allParams[i++] = o;  
      702.             }  
      703.             return findPagination(hql, pageIndex, pageSize, allParams);  
      704.         }  
      705.   
      706.     }  
      707.   
      708. }  

      
HibernateHandler.java



      1. import java.io.Serializable;  
      2.   
      3. import org.hibernate.Session;  
      4.   
      5. public abstract interface HibernateHandler extends Serializable {  
      6.     public abstract Object doInHibernate(Session paramSession);  
      7. }  

      
Pagination.java



      1. import java.io.Serializable;  
      2. import java.util.List;  
      3.   
      4. /**  
      5.  * 數據分頁類  
      6.  *   
      7.  * @author GST  
      8.  * @version 1.0, 2006-12-30  
      9.  */  
      10.   
      11. public class Pagination<T> implements Serializable {  
      12.   
      13.     private static final long serialVersionUID = -5884976706259160221L;  
      14.     /**  
      15.      * 上一頁  
      16.      */  
      17.     private long preIndex;  
      18.     /**  
      19.      * 當前頁  
      20.      */  
      21.     private long curIndex;  
      22.     /**  
      23.      * 下一頁  
      24.      */  
      25.     private long nextIndex;  
      26.     /**  
      27.      * 每頁條數  
      28.      */  
      29.     private long pageSize;  
      30.     /**  
      31.      * 總條數  
      32.      */  
      33.     private long rowsCount;  
      34.   
      35.     public void setPreIndex(long preIndex) {  
      36.         this.preIndex = preIndex;  
      37.     }  
      38.   
      39.     public void setCurIndex(long curIndex) {  
      40.         this.curIndex = curIndex;  
      41.     }  
      42.   
      43.     public void setNextIndex(long nextIndex) {  
      44.         this.nextIndex = nextIndex;  
      45.     }  
      46.   
      47.     public void setPageSize(long pageSize) {  
      48.         this.pageSize = pageSize;  
      49.     }  
      50.   
      51.     /**  
      52.      * 總頁數  
      53.      */  
      54.     private long pagesCount;  
      55.     /**  
      56.      * 對象列表  
      57.      */  
      58.     private List<T> items;  
      59.   
      60.     /**  
      61.      *   
      62.      * 分頁類構建函數  
      63.      *   
      64.      */  
      65.     public Pagination() {  
      66.         updateInfo(0, 0, 0);  
      67.     }  
      68.   
      69.     /**  
      70.      *   
      71.      * 分頁類構建函數  
      72.      *   
      73.      * @param pageIndex  
      74.      *            當前頁碼  
      75.      * @param pageSize  
      76.      *            每頁記錄數  
      77.      */  
      78.     public Pagination(long pageIndex, long pageSize) {  
      79.         updateInfo(pageIndex, pageSize, 0);  
      80.     }  
      81.   
      82.     /**  
      83.      * 分頁類構建函數  
      84.      *   
      85.      * @param pageIndex  
      86.      *            當前頁碼  
      87.      * @param pageSize  
      88.      *            每頁記錄數  
      89.      * @param rowsCount  
      90.      *            記錄總數  
      91.      */  
      92.     public Pagination(long pageIndex, long pageSize, long rowsCount) {  
      93.         updateInfo(pageIndex, pageSize, rowsCount);  
      94.     }  
      95.   
      96.     /**  
      97.      * 獲取當前面記錄  
      98.      *   
      99.      * @return  
      100.      */  
      101.     public List<T> getItems() {  
      102.         return items;  
      103.     }  
      104.   
      105.     /**  
      106.      * 設置當前頁記錄  
      107.      *   
      108.      * @param items  
      109.      */  
      110.     public void setItems(List<T> items) {  
      111.         this.items = items;  
      112.     }  
      113.   
      114.     /**  
      115.      * 獲取當前頁碼  
      116.      *   
      117.      * @return  
      118.      */  
      119.     public long getCurIndex() {  
      120.         return curIndex;  
      121.     }  
      122.   
      123.     /**  
      124.      * 獲取下一頁碼  
      125.      *   
      126.      * @return  
      127.      */  
      128.     public long getNextIndex() {  
      129.         return nextIndex;  
      130.     }  
      131.   
      132.     /**  
      133.      * 獲取總頁數  
      134.      *   
      135.      * @return  
      136.      */  
      137.     public long getPagesCount() {  
      138.         return pagesCount;  
      139.     }  
      140.   
      141.     /**  
      142.      * 獲取每頁記錄數  
      143.      *   
      144.      * @return  
      145.      */  
      146.     public long getPageSize() {  
      147.         return pageSize;  
      148.     }  
      149.   
      150.     /**  
      151.      * 獲取上一頁碼  
      152.      *   
      153.      * @return  
      154.      */  
      155.     public long getPreIndex() {  
      156.         return preIndex;  
      157.     }  
      158.   
      159.     /**  
      160.      * 獲取總記錄數  
      161.      *   
      162.      * @return  
      163.      */  
      164.     public long getRowsCount() {  
      165.         return rowsCount;  
      166.     }  
      167.   
      168.     /**  
      169.      * 獲取首頁碼  
      170.      *   
      171.      * @return  
      172.      */  
      173.     public long getFirstIndex() {  
      174.         return 1;  
      175.     }  
      176.   
      177.     /**  
      178.      * 獲取末頁碼  
      179.      *   
      180.      * @return  
      181.      */  
      182.     public long getLastIndex() {  
      183.         return pagesCount;  
      184.     }  
      185.   
      186.     private void updateInfo(long pageIndex, long pageSize, long rowsCount) {  
      187.   
      188.         if (pageSize > 0) {  
      189.   
      190.             this.curIndex = pageIndex;  
      191.             this.rowsCount = rowsCount;  
      192.             this.pageSize = pageSize;  
      193.   
      194.             // 確定頁數  
      195.             pagesCount = (rowsCount + pageSize - 1) / pageSize;  
      196.             // 確定當前頁碼  
      197.             if (curIndex <= 0)  
      198.                 curIndex = 1;  
      199.             if (curIndex > pagesCount)  
      200.                 curIndex = pagesCount;  
      201.             // 確定下一頁碼  
      202.             nextIndex = curIndex + 1;  
      203.             if (nextIndex > pagesCount)  
      204.                 nextIndex = pagesCount;  
      205.             // 確定上一頁碼  
      206.             preIndex = curIndex - 1;  
      207.             if (preIndex <= 0)  
      208.                 preIndex = 1;  
      209.         } else {  
      210.             this.preIndex = 1;  
      211.             this.curIndex = 1;  
      212.             this.nextIndex = 1;  
      213.             this.pageSize = 0;  
      214.             this.pagesCount = 1;  
      215.         }  
      216.     }  
      217.   
      218.     /**  
      219.      * 設置總記錄數  
      220.      *   
      221.      * @param rowsCount  
      222.      */  
      223.     public void setRowsCount(long rowsCount) {  
      224.         updateInfo(curIndex, pageSize, rowsCount);  
      225.     }  
      226.   
      227.     /**  
      228.      * 設置總頁數  
      229.      *   
      230.      * @param pagesCount  
      231.      */  
      232.     public void setPagesCount(long pagesCount) {  
      233.         this.pagesCount = pagesCount;  
      234.     }  
      235.   
      236. }  

      
ObjectUtil.java



      1. import java.lang.reflect.InvocationTargetException;  
      2. import java.lang.reflect.Method;  
      3. import java.lang.reflect.ParameterizedType;  
      4. import java.lang.reflect.Type;  
      5. import java.util.ArrayList;  
      6. import java.util.Date;  
      7. import java.util.HashMap;  
      8. import java.util.List;  
      9. import java.util.Map;  
      10.   
      11. /**  
      12.  * @author Administrator  
      13.  * @date 2013-4-27 上午10:51:14  
      14.  * @since 1.0  
      15.  */  
      16. public class ObjectUtil {  
      17.     /**  
      18.      * <p>  
      19.      * 把原對象的屬性值拷貝到目標對象，并返回目標對象.<b>拷貝空值</b>.  
      20.      * </p>  
      21.      *   
      22.      * @param source  
      23.      *            數據來源對象  
      24.      * @param target  
      25.      *            目標對象  
      26.      * @return 目標對象  
      27.      */  
      28.     public static <T> T copyPropVal(Object source, T target) {  
      29.         return copyPropVal(source, target, true);  
      30.     }  
      31.   
      32.     /**  
      33.      * 把原對象的屬性值拷貝到目標對象，并返回目標對象；不處理復合屬性；<b>不拷貝空值</b>  
      34.      *   
      35.      * @param <T>  
      36.      * @param source  
      37.      * @param target  
      38.      * @return 目標對象  
      39.      */  
      40.     public static <T> T copyNotNullPropVal(Object source, T target) {  
      41.         return copyPropVal(source, target, false);  
      42.     }  
      43.   
      44.     private static Object callGetter(Object o, List<Method> getterList) {  
      45.         if (getterList == null || o == null)  
      46.             return null;  
      47.   
      48.         for (Method m : getterList) {  
      49.             if (!m.getReturnType().equals(void.class) && m.getParameterTypes().length == 0) {  
      50.                 try {  
      51.                     return m.invoke(o);  
      52.                 } catch (Exception e) {  
      53.                 }  
      54.             }  
      55.         }  
      56.         return null;  
      57.     }  
      58.   
      59.     private static void callSetter(Object o, Object val, List<Method> setterList) {  
      60.         if (setterList == null || o == null)  
      61.             return;  
      62.   
      63.         for (Method m : setterList) {  
      64.             if (m.getReturnType().equals(void.class) && m.getParameterTypes().length == 1) {  
      65.                 try {  
      66.                     m.invoke(o, val);  
      67.                     return;  
      68.                 } catch (Exception e) {  
      69.                 }  
      70.             }  
      71.         }  
      72.     }  
      73.   
      74.     /**  
      75.      * 見prepareToSave，空值默認<b>不</b>覆蓋  
      76.      *   
      77.      * @param savingEntity  
      78.      *            要保存到數據庫的實體對象  
      79.      * @param valueEntity  
      80.      *            數值實體  
      81.      * @param userId  
      82.      *            當前用戶ID  
      83.      * @return 處理以后的參數savingEntity  
      84.      */  
      85.     public static <T> T prepareToSave(T savingEntity, Object valueEntity, String userId) {  
      86.         return prepareToSave(savingEntity, valueEntity, userId, false);  
      87.     }  
      88.   
      89.     /**  
      90.      * 在保存savingEntity實體之前，完成對savingEntity字段值的設置操作，具體如下：<br>  
      91.      * 1)設置savingEntity的通用字段getDisabled(isDisabled), getCreateTime,  
      92.      * getCreatedBy,setCreateTime,setCreateBy,setUpdateTime,setUpdateBy 2)拷貝  
      93.      * 數值實體valueEntity 所有屬性值到savingEntity相應屬性<br>  
      94.      * 本方法返回待保存的實體  
      95.      *   
      96.      * @param <T>  
      97.      * @param savingEntity  
      98.      *            要保存到數據庫的實體對象  
      99.      * @param valueEntity  
      100.      *            數值實體  
      101.      * @param userId  
      102.      *            當前用戶ID  
      103.      * @param copyNull  
      104.      *            是否拷貝空值  
      105.      * @return 處理以后的參數savingEntity  
      106.      */  
      107.     public static <T> T prepareToSave(T savingEntity, Object valueEntity, String userId, boolean copyNull) {  
      108.         if (savingEntity == null)  
      109.             return savingEntity;  
      110.   
      111.         HashMap<String, List<Method>> methodMap = new HashMap<String, List<Method>>();  
      112.         for (Method m : savingEntity.getClass().getMethods()) {  
      113.             List<Method> list = methodMap.get(m.getName());  
      114.             if (list == null) {  
      115.                 list = new ArrayList<Method>();  
      116.                 methodMap.put(m.getName(), list);  
      117.             }  
      118.             list.add(m);  
      119.         }  
      120.   
      121.         Object createTime = callGetter(savingEntity, methodMap.get("getCreateTime"));  
      122.         Object createBy = callGetter(savingEntity, methodMap.get("getCreateBy"));  
      123.   
      124.         copyPropVal(valueEntity, savingEntity, copyNull);  
      125.   
      126.         Date now = new Date();  
      127.         if (createTime == null)  
      128.             createTime = now;  
      129.         if (createBy == null)  
      130.             createBy = userId;  
      131.   
      132.         // ~~exam or ERP~~  
      133.         Object creationDate = callGetter(savingEntity, methodMap.get("getCreationDate"));  
      134.         Object createdBy = callGetter(savingEntity, methodMap.get("getCreatedBy"));  
      135.         if (createdBy == null)  
      136.             createdBy = userId;  
      137.         if (creationDate == null)  
      138.             creationDate = now;  
      139.         // ~~exam or ERP~~  
      140.   
      141.         Object disabled = callGetter(savingEntity, methodMap.get("getDisabled"));  
      142.         if (disabled == null)  
      143.             disabled = callGetter(savingEntity, methodMap.get("isDisabled"));  
      144.         if (disabled == null)  
      145.             callSetter(savingEntity, false, methodMap.get("setDisabled"));  
      146.   
      147.         callSetter(savingEntity, createBy, methodMap.get("setCreateBy"));  
      148.         callSetter(savingEntity, createTime, methodMap.get("setCreateTime"));  
      149.         callSetter(savingEntity, now, methodMap.get("setUpdateTime"));  
      150.         callSetter(savingEntity, userId, methodMap.get("setUpdateBy"));  
      151.   
      152.         // ~~exam or ERP~~  
      153.         callSetter(savingEntity, createdBy, methodMap.get("setCreatedBy"));  
      154.         callSetter(savingEntity, creationDate, methodMap.get("setCreationDate"));  
      155.         callSetter(savingEntity, now, methodMap.get("setLastUpdateDate"));  
      156.         callSetter(savingEntity, userId, methodMap.get("setLastUpdatedBy"));  
      157.         callSetter(savingEntity, userId, methodMap.get("setLastUpdateLogin"));  
      158.         // ~~exam or ERP~~  
      159.         return savingEntity;  
      160.     }  
      161.   
      162.     private static boolean isZteClass(Type type) {  
      163.         if (!(type instanceof Class))  
      164.             return false;  
      165.         DataObjectDescriptor annotation = ((Class<?>) type).getAnnotation(DataObjectDescriptor.class);  
      166.         return annotation != null;  
      167.     }  
      168.   
      169.     @SuppressWarnings({ "unchecked", "rawtypes" })  
      170.     private static Map<?, ?> makeTargetMap(Map<?, ?> source, Type keyType, Type valType, boolean copyNull)  
      171.             throws Exception {  
      172.         if (!(keyType instanceof Class))  
      173.             throw new UnsupportedOperationException("makeTargetMap " + keyType);  
      174.   
      175.         Class<?> keyClzz = (Class<?>) keyType;  
      176.   
      177.         Map result = new HashMap();  
      178.         for (Object k : source.keySet()) {  
      179.             Object srcVal = source.get(k);  
      180.             Object value = srcVal;  
      181.             Object key = k;  
      182.             if (isZteClass(keyClzz))  
      183.                 key = copyNotNullPropVal(k, keyClzz.newInstance());  
      184.   
      185.             if (isZteClass(valType)) {  
      186.                 value = copyPropVal(srcVal, ((Class<?>) valType).newInstance(), copyNull);  
      187.             } else if (checkCopyAsList(srcVal, valType)) {  
      188.                 Type actualType = ((ParameterizedType) valType).getActualTypeArguments()[0];  
      189.                 value = makeTargetList((List<?>) srcVal, (Class<?>) actualType, copyNull);  
      190.             } else if (checkCopyAsMap(srcVal, valType)) {  
      191.                 ParameterizedType prmType = (ParameterizedType) valType;  
      192.                 Type subKeyType = prmType.getActualTypeArguments()[0];  
      193.                 Type subValType = prmType.getActualTypeArguments()[1];  
      194.                 value = makeTargetMap((Map<?, ?>) srcVal, subKeyType, subValType, copyNull);  
      195.             }  
      196.             result.put(key, value);  
      197.         }  
      198.         return result;  
      199.     }  
      200.   
      201.     /**  
      202.      * 把原對象的屬性值拷貝到目標對象，并返回目標對象；不處理復合屬性，可控制是否拷貝空值  
      203.      *   
      204.      * @param <T>  
      205.      * @param source  
      206.      * @param target  
      207.      * @param copyNull  
      208.      *            是否拷貝空值  
      209.      * @return 目標對象  
      210.      */  
      211.     public static <T> T copyPropVal(Object source, T target, boolean copyNull) {  
      212.         if (source == null || target == null)  
      213.             return target;  
      214.   
      215.         Map<String, Method> getterMap = new HashMap<String, Method>();  
      216.         for (Method m : source.getClass().getMethods()) {  
      217.             if (m.getParameterTypes().length > 0)  
      218.                 continue;  
      219.   
      220.             String name = m.getName();  
      221.             if (name.startsWith("get") && name.length() > 3) {  
      222.                 name = name.substring(3);  
      223.                 getterMap.put(name, m);  
      224.             } else if (name.startsWith("is") && name.length() > 2 && m.getReturnType() == boolean.class) {  
      225.                 name = name.substring(2);  
      226.                 getterMap.put(name, m);  
      227.             }  
      228.   
      229.         }  
      230.   
      231.         for (Method setter : target.getClass().getMethods()) {  
      232.             String name = setter.getName();  
      233.             Type[] paramTypes = setter.getGenericParameterTypes();  
      234.             if (name.startsWith("set") && name.length() > 3 && paramTypes.length == 1) {  
      235.                 name = name.substring(3);  
      236.                 Method getter = getterMap.get(name);  
      237.                 if (getter != null) {  
      238.                     try {  
      239.                         Object value = getter.invoke(source);  
      240.                         if (value != null) {  
      241.                             Type paramType = paramTypes[0];  
      242.                             if (isZteClass(paramType)) {  
      243.                                 try {  
      244.                                     value = copyPropVal(value, ((Class<?>) paramType).newInstance(), copyNull);  
      245.                                 } catch (InstantiationException e) {  
      246.                                 }  
      247.                             } else if (checkCopyAsList(value, paramType)) {  
      248.                                 Type actualType = ((ParameterizedType) paramType).getActualTypeArguments()[0];  
      249.                                 value = makeTargetList((List<?>) value, (Class<?>) actualType, copyNull);  
      250.                             } else if (checkCopyAsMap(value, paramType)) {  
      251.                                 Type keyType = ((ParameterizedType) paramType).getActualTypeArguments()[0];  
      252.                                 Type valType = ((ParameterizedType) paramType).getActualTypeArguments()[1];  
      253.                                 try {  
      254.                                     value = makeTargetMap((Map<?, ?>) value, keyType, valType, copyNull);  
      255.                                 } catch (Exception e) {  
      256.                                     value = null;  
      257.                                 }  
      258.                             }  
      259.   
      260.                             setter.invoke(target, value);  
      261.                         } else if (copyNull) {  
      262.                             setter.invoke(target, value);  
      263.                         }  
      264.                     } catch (IllegalArgumentException e) {  
      265.                         // do nothing  
      266.                     } catch (IllegalAccessException e) {  
      267.                         // do nothing  
      268.                     } catch (InvocationTargetException e) {  
      269.                         // do nothing  
      270.                     }  
      271.                 }  
      272.   
      273.             }  
      274.         }  
      275.   
      276.         return target;  
      277.     }  
      278.   
      279.     public static <T> T copyAs(Object srcBean, Class<T> targetClass) {  
      280.         if (srcBean == null) {  
      281.             return null;  
      282.         }  
      283.   
      284.         T ret;  
      285.         try {  
      286.             ret = targetClass.newInstance();  
      287.         } catch (Exception e) {  
      288.             e.printStackTrace();  
      289.             return null;  
      290.         }  
      291.         return copyPropVal(srcBean, ret);  
      292.     }  
      293.   
      294.     /**  
      295.      * 判斷Value是否是List類型，type是泛型List，從而他們可以作為List進行bean Copy  
      296.      *   
      297.      * @param value  
      298.      * @param type  
      299.      * @return  
      300.      */  
      301.     private static boolean checkCopyAsList(Object value, Type type) {  
      302.         if (!(value instanceof List) || !(type instanceof ParameterizedType))  
      303.             return false;  
      304.   
      305.         ParameterizedType paramType = (ParameterizedType) type;  
      306.         if (!(paramType.getRawType() instanceof Class))  
      307.             return false;  
      308.   
      309.         Class<?> rawType = (Class<?>) paramType.getRawType();  
      310.         if (!List.class.isAssignableFrom(rawType) || paramType.getActualTypeArguments().length != 1)  
      311.             return false;  
      312.   
      313.         return true;  
      314.     }  
      315.   
      316.     /**  
      317.      * 判斷Value是否是Map類型，type是泛型Map，從而他們可以作為Map進行bean Copy  
      318.      *   
      319.      * @param value  
      320.      * @param type  
      321.      * @return  
      322.      */  
      323.     private static boolean checkCopyAsMap(Object value, Type type) {  
      324.         if (!(value instanceof Map) || !(type instanceof ParameterizedType))  
      325.             return false;  
      326.   
      327.         ParameterizedType paramType = (ParameterizedType) type;  
      328.         if (!(paramType.getRawType() instanceof Class))  
      329.             return false;  
      330.   
      331.         Class<?> rawType = (Class<?>) paramType.getRawType();  
      332.         if (!Map.class.isAssignableFrom(rawType) || paramType.getActualTypeArguments().length != 2)  
      333.             return false;  
      334.   
      335.         return true;  
      336.     }  
      337.   
      338.     @SuppressWarnings("unchecked")  
      339.     public static <T> List<T> makeTargetList(List<?> sourceList, Class<T> targetClzz, boolean copyNull) {  
      340.         if (sourceList == null || targetClzz == null)  
      341.             return null;  
      342.   
      343.         List<T> ret = new ArrayList<T>();  
      344.         for (Object source : sourceList) {  
      345.             if (isZteClass(targetClzz)) {  
      346.                 try {  
      347.                     T target = targetClzz.newInstance();  
      348.                     ret.add(copyPropVal(source, target, copyNull));  
      349.                 } catch (Exception e) {  
      350.                     // do nothing  
      351.                 }  
      352.             } else if (targetClzz.isInstance(source)) {  
      353.                 ret.add((T) source);  
      354.             }  
      355.         }  
      356.         return ret;  
      357.     }  
      358.   
      359.     public static <T> List<T> makeTargetList(List<?> sourceList, Class<T> targetClzz) {  
      360.         return makeTargetList(sourceList, targetClzz, true);  
      361.     }  
      362.   
      363.     public static <T, S> Pagination<T> makePagination(Pagination<S> src, Class<T> targetClzz) {  
      364.         if (src == null)  
      365.             return null;  
      366.   
      367.         Pagination<T> result = new Pagination<T>(src.getCurIndex(), src.getPageSize(), src.getRowsCount());  
      368.         List<T> items = makeTargetList(src.getItems(), targetClzz);  
      369.         result.setItems(items);  
      370.         return result;  
      371.     }  
      372.   
      373.     public static boolean hasText(String textValue) {  
      374.         return textValue != null && !"".equals(textValue);  
      375.     }  
      376.   
      377.     public static boolean hasDate(Date dateValue) {  
      378.         return dateValue != null;  
      379.     }  
      380.   
      381.     public static boolean hasNumeric(Integer numeric) {  
      382.         return numeric != null;  
      383.     }  
      384.   
      385.     /**  
      386.      * 獲取字符串的長度，如果有中文，則每個中文字符計為2位  
      387.      *   
      388.      * @param value  
      389.      *            指定的字符串  
      390.      * @return 字符串的長度  
      391.      */  
      392.     public static int length(String value) {  
      393.         int valueLength = 0;  
      394.         String chinese = "[\u0391-\uFFE5]";  
      395.         /* 獲取字段值的長度，如果含中文字符，則每個中文字符長度為2，否則為1 */  
      396.         for (int i = 0; i < value.length(); i++) {  
      397.             /* 獲取一個字符 */  
      398.             String temp = String.valueOf(value.charAt(i));  
      399.             /* 判斷是否為中文字符 */  
      400.             if (temp.matches(chinese)) {  
      401.                 /* 中文字符長度為2 */  
      402.                 valueLength += 2;  
      403.             } else {  
      404.                 /* 其他字符長度為1 */  
      405.                 valueLength += 1;  
      406.             }  
      407.         }  
      408.         return valueLength;  
      409.     }  
      410.   
      411. }  
      


      DataObjectDescriptor.java
      


      1. import java.lang.annotation.Documented;  
      2. import java.lang.annotation.Retention;  
      3. import java.lang.annotation.RetentionPolicy;  
      4. import java.lang.annotation.Target;  
      5.   
      6. @Retention(RetentionPolicy.RUNTIME)  
      7. @Target({ java.lang.annotation.ElementType.TYPE })  
      8. @Documented  
      9. public @interface DataObjectDescriptor {  
      10.     public abstract String value();  
      11. }  

      
DaoException.java



      1. import org.springframework.core.NestedRuntimeException;  
      2.   
      3. /**  
      4.  * @author   
      5.  */  
      6. public class DaoException extends NestedRuntimeException {  
      7.   
      8.     private static final long serialVersionUID = 1L;  
      9.   
      10.     public DaoException(String msg) {  
      11.         super(msg);  
      12.     }  
      13.   
      14.     public DaoException(String msg, Throwable obj) {  
      15.         super(msg, obj);  
      16.     }  
      17. }  
      


      

      

      SessionTimeoutException.java
      

      1. import org.springframework.core.NestedRuntimeException;  
      2.   
      3. public class SessionTimeoutException extends NestedRuntimeException {  
      4.     private static final long serialVersionUID = 1L;  
      5.   
      6.     public SessionTimeoutException(String msg) {  
      7.         super(msg);  
      8.     }  
      9.   
      10.     public SessionTimeoutException(String msg, Throwable obj) {  
      11.         super(msg, obj);  
      12.     }  
      13.   
      14. }  

      

      


      PagerFactory.java
      1. import java.util.ArrayList;  
      2. import java.util.List;  
      3.   
      4. public class PagerFactory {  
      5.     public static <T> Pagination<T> createEmpty() {  
      6.         return create(1, 10);  
      7.     }  
      8.   
      9.     public static <T> Pagination<T> create(Number pageIndex, Number pageSize) {  
      10.         return create(pageIndex, pageSize, 0, new ArrayList<T>(0));  
      11.     }  
      12.   
      13.     public static <T> Pagination<T> create(Number pageIndex, Number pageSize, Number rowsCount) {  
      14.         return create(pageIndex, pageSize, rowsCount, new ArrayList<T>(0));  
      15.     }  
      16.   
      17.     public static <T> Pagination<T> create(Number pageIndex, Number pageSize, Number rowsCount, List<T> data) {  
      18.         Pagination<T> p = new Pagination<T>(pageIndex.longValue(), pageSize.longValue(), rowsCount.longValue());  
      19.         if (data == null) {  
      20.             data = new ArrayList<T>(0);  
      21.         }  
      22.         p.setItems(data);  
      23.         return p;  
      24.     }  
      25.   
      26.     public static <T> List<T> getPaginList(List<T> allList, int pageIndex, int pageSize) {  
      27.         List<T> result = new ArrayList<T>();  
      28.         int start = pageIndex < 2 ? 0 : ((pageIndex - 1) * pageSize);  
      29.         int end = start + pageSize > allList.size() ? allList.size() : start + pageSize;  
      30.         for (int i = start; i < end; i++) {  
      31.             result.add(allList.get(i));  
      32.         }  
      33.         return result;  
      34.     }  
      35. }  
      
        
      
                                          		
                                
      
                                  
                        
      
                    
      



                
      
                
      
                    
                    
                        
      
                            
                                
        
                                    		
                        
        
                            
                
        
                
        
                
                
                
        
                
        


                

                
        本站是提供個人知識管理的網絡存儲空間，所有內容均由用戶發(fā)布，不代表本站觀點。請注意甄別內容中的聯系方式、誘導購買等信息，謹防詐騙。如發(fā)現有害或侵權內容，請點擊一鍵舉報。
        
                
                

                
        
                    轉藏
                    
                    
                    
                    
                    
                    
                        分享
                        
                        
                    
                    獻花（0）
                            
                
        
                
                
                
        
                    
        
                        
                        
                    
        
                
        

            
        

            
        

            
        
                
                
                
        
                
        
                    
        
                        
        0條評論
        
                        
                        
                        
        
                            
                            
        
                                發(fā)表
                            
        
                        
        
                        
                    
        
                    
                    
        請遵守用戶 評論公約
        
                    
                    
          
                    
        
                    
        
                    
        
                    
                
        
               
                
        
                    
        
                        類似文章
                        更多