研究一下springside的核心部分源代码

 这两天,有一些时间,研究一下springside的源代码,结果感觉不错,于是对自己做过一些代码做了一些优化与重构.
分页的代码如下:
(说明:这里的代码是我参考了springside的源代码后作了一些比较小的改动,这里没有给出完整的例子,只是讨论一下核心的代码)
这里想说的代码主要是泛型DAO层的应用与分页的写法.

分页,采用了hibernate的一些API来分页,这里同时采用了两种分页方式,CriteriaPage分页方式,适用于多表单时查询后分页用的,而第二种方式是采用Hql语句查询后分页的.代码如下:

CriteriaPage.java文件:

1. package org.mmc.commons;   
2.   
3. import java.util.ArrayList;   
4. import java.util.List;   
5.   
6. import org.hibernate.Criteria;   
7. import org.hibernate.criterion.CriteriaSpecification;   
8. import org.hibernate.criterion.Projection;   
9. import org.hibernate.criterion.Projections;   
10. import org.hibernate.impl.CriteriaImpl;   
11. import org.hibernate.impl.CriteriaImpl.OrderEntry;   
12. import org.mmc.utils.BeanUtils;   
13.   
14. /**  
15.  * 使用Hql查询的的分页查询类.  
16.  * 支持执行Count查询取得总记录条数  
17.  * 本类参考了springside项目的分页设计  
18.  */  
19. public class CriteriaPage {   
20.   
21.     /**  
22.      * 得到一个PageInstance实例,.  
23.      */  
24.     public static Page getPageInstance(Criteria criteria, int pageNo, int pageSize) {   
25.           
26.             return CriteriaPage.getPageInstanceByCount(criteria, pageNo, pageSize);   
27.     }   
28.   
29.     /**  
30.      * 以查询Count的形式获取totalCount的函数  
31.      */  
32.     protected static Page getPageInstanceByCount(Criteria criteria, int pageNo, int pageSize) {   
33.         CriteriaImpl impl = (CriteriaImpl) criteria;   
34.   
35.         //先把Projection和OrderBy条件取出来,清空两者来执行Count操作   
36.         Projection projection = impl.getProjection();   
37.         List orderEntries;   
38.         try {   
39.             orderEntries = (List) BeanUtils.getPrivateProperty(impl, "orderEntries");   
40.             BeanUtils.setPrivateProperty(impl, "orderEntries", new ArrayList());   
41.         }   
42.         catch (Exception e) {   
43.             throw new InternalError(" Runtime Exception impossibility throw ");   
44.         }   
45.   
46.         //执行查询   
47.         int totalCount = (Integer) criteria.setProjection(Projections.rowCount()).uniqueResult();   
48.   
49.         //将之前的Projection和OrderBy条件重新设回去   
50.         criteria.setProjection(projection);   
51.         if (projection == null) {   
52.             criteria.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);   
53.         }   
54.   
55.         try {   
56.             BeanUtils.setPrivateProperty(impl, "orderEntries", orderEntries);   
57.         } catch (Exception e) {   
58.             throw new InternalError(" Runtime Exception impossibility throw ");   
59.         }   
60.   
61.         return getPageResult(criteria, totalCount, pageNo, pageSize);   
62.     }   
63.        
64.     /**  
65.      * 取得totalCount后，根据pageNo和PageSize, 执行criteria的分页查询，取得Page变量  
66.      */  
67.     private static Page getPageResult(Criteria criteria, int totalCount, int pageNo, int pageSize) {   
68.         if (totalCount < 1) return new Page();   
69.   
70.         int startIndex = Page.getStartOfPage(pageNo, pageSize);   
71.         List list = criteria.setFirstResult(startIndex).setMaxResults(pageSize).list();   
72.   
73.         return new Page(startIndex, totalCount, pageSize, list);   
74.     }   
75.   
76. }   
77.   

HqlPage.java文件的代码

Page.java文件的源代码如下:

1. package org.mmc.commons;   
2.   
3. import java.util.ArrayList;   
4.   
5. /**  
6.  * 分页对象. 包含数据及分页信息.  
7.  *   
8.  * @author lighter 天马行空  
9.  */  
10. public class Page implements java.io.Serializable {   
11.  /**  
12.   * 当前页第一条数据的位置,从0开始  
13.   */  
14.  private int start;   
15.   
16.  /**  
17.   * 每页的记录数  
18.   */  
19.  private int pageSize = Constants.DEFAULT_PAGE_SIZE;   
20.   
21.  /**  
22.   * 当前页中存放的记录  
23.   */  
24.  private Object data;   
25.   
26.  /**  
27.   * 总记录数  
28.   */  
29.  private int totalCount;   
30.   
31.  /**  
32.   * 构造方法，只构造空页  
33.   */  
34.  public Page() {   
35.   this(0, 0, Constants.DEFAULT_PAGE_SIZE, new ArrayList());   
36.  }   
37.   
38.  /**  
39.   * 默认构造方法  
40.   *   
41.   * @param start  
42.   *            本页数据在数据库中的起始位置  
43.   * @param totalSize  
44.   *            数据库中总记录条数  
45.   * @param pageSize  
46.   *            本页容量  
47.   * @param data  
48.   *            本页包含的数据  
49.   */  
50.  public Page(int start, int totalSize, int pageSize, Object data) {   
51.   this.pageSize = pageSize;   
52.   this.start = start;   
53.   this.totalCount = totalSize;   
54.   this.data = data;   
55.  }   
56.   
57.  /**  
58.   * 取数据库中包含的总记录数  
59.   */  
60.  public int getTotalCount() {   
61.   return this.totalCount;   
62.  }   
63.   
64.  /**  
65.   * 取总页数  
66.   */  
67.  public int getTotalPageCount() {   
68.   if (totalCount % pageSize == 0)   
69.    return totalCount / pageSize;   
70.   else  
71.    return totalCount / pageSize + 1;   
72.  }   
73.   
74.  /**  
75.   * 取每页数据容量  
76.   */  
77.  public int getPageSize() {   
78.   return pageSize;   
79.  }   
80.   
81.  /**  
82.   * 当前页中的记录  
83.   */  
84.  public Object getResult() {   
85.   return data;   
86.  }   
87.   
88.  /**  
89.   * 取当前页码,页码从1开始  
90.   */  
91.  public int getCurrentPageNo() {   
92.   return (start / pageSize) + 1;   
93.  }   
94.   
95.  /**  
96.   * 是否有下一页  
97.   */  
98.  public boolean hasNextPage() {   
99.   return (this.getCurrentPageNo() < this.getTotalPageCount() - 1);   
100.  }   
101.   
102.  /**  
103.   * 是否有上一页  
104.   */  
105.  public boolean hasPreviousPage() {   
106.   return (this.getCurrentPageNo() > 1);   
107.  }   
108.   
109.  /**  
110.   * 获取任一页第一条数据的位置，每页条数使用默认值  
111.   * 关键字设为pretected  
112.   */  
113.  protected static int getStartOfPage(int pageNo) {   
114.   return getStartOfPage(pageNo, Constants.DEFAULT_PAGE_SIZE);   
115.  }   
116.   
117.  /**  
118.   * 获取任一页第一条数据的位置,startIndex从0开始  
119.   * 关键字设为pretected  
120.   */  
121.  protected static int getStartOfPage(int pageNo, int pageSize) {   
122.   return (pageNo - 1) * pageSize;   
123.  }   
124. }   
125.   

分页的改造已经完成,现在重构一下DAO层的写法,利用了spring对hibernate支持的一些的API.

DAO层:
AbstractHibernateDao.java的源代码

1. package org.mmc.dao;   
2.   
3. import org.apache.commons.beanutils.PropertyUtils;   
4. import org.apache.commons.lang.StringUtils;   
5. import org.apache.commons.logging.Log;   
6. import org.apache.commons.logging.LogFactory;   
7. import org.hibernate.Criteria;   
8. import org.hibernate.criterion.MatchMode;   
9. import org.hibernate.criterion.Order;   
10. import org.hibernate.criterion.Projections;   
11. import org.hibernate.criterion.Restrictions;   
12. import org.springframework.orm.ObjectRetrievalFailureException;   
13. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;   
14. import org.springframework.util.Assert;   
15. import org.springframework.util.CollectionUtils;   
16. import org.mmc.utils.GenericsUtils;   
17.   
18. import java.io.Serializable;   
19. import java.util.List;   
20. import java.util.Map;   
21. import java.util.Set;   
22.   
23. /**  
24.  * 纯Hibernate Entity DAO基类.  
25.  * 通过泛型，子类无需扩展任何函数即拥有完整的CRUD操作.  
26.  *  
27.  */  
28. abstract public class AbstractHibernateDao extends HibernateDaoSupport {   
29.   
30.     protected Log logger = LogFactory.getLog(getClass());   
31.   
32.     /**  
33.      * Dao所管理的Entity类型.  
34.      */  
35.     protected Class entityClass;   
36.   
37.     /**  
38.      * 取得entityClass的函数.  
39.      * JDK1.4不支持泛型的子类可以抛开Class entityClass,重新实现此函数达到相同效果。  
40.      */  
41.     protected Class getEntityClass() {   
42.         return entityClass;   
43.     }   
44.   
45.     /**  
46.      * 在构造函数中将泛型T.class赋给entityClass  
47.      */  
48.     public AbstractHibernateDao() {   
49.         entityClass = GenericsUtils.getGenericClass(getClass());   
50.     }   
51.   
52.     public T get(Serializable id) {   
53.         T o = (T) getHibernateTemplate().get(getEntityClass(), id);   
54.         if (o == null)   
55.             throw new ObjectRetrievalFailureException(getEntityClass(), id);   
56.         return o;   
57.     }   
58.   
59.     public List getAll() {   
60.         return getHibernateTemplate().loadAll(getEntityClass());   
61.     }   
62.   
63.     public void save(Object o) {   
64.         getHibernateTemplate().saveOrUpdate(o);   
65.     }   
66.   
67.     public void removeById(Serializable id) {   
68.         remove(get(id));   
69.     }   
70.   
71.     public void remove(Object o) {   
72.         getHibernateTemplate().delete(o);   
73.     }   
74.   
75.     public List find(String hsql, Object... values) {   
76.         if (values.length == 0)   
77.             return getHibernateTemplate().find(hsql);   
78.         else  
79.             return getHibernateTemplate().find(hsql, values);   
80.     }   
81.   
82.     /**  
83.      * 根据属性名和属性值查询对象.  
84.      *  
85.      * @return 符合条件的唯一对象  
86.      */  
87.     public T findUniqueBy(String name, Object value) {   
88.         Criteria criteria = getSession().createCriteria(getEntityClass());   
89.         criteria.add(Restrictions.eq(name, value));   
90.         return (T) criteria.uniqueResult();   
91.     }   
92.   
93.     /**  
94.      * 根据属性名和属性值查询对象.  
95.      *  
96.      * @return 符合条件的对象列表  
97.      */  
98.     public List findBy(String name, Object value) {   
99.         Assert.hasText(name);   
100.         Criteria criteria = getSession().createCriteria(getEntityClass());   
101.         criteria.add(Restrictions.eq(name, value));   
102.         return criteria.list();   
103.     }   
104.   
105.     /**  
106.      * 根据属性名和属性值以Like AnyWhere方式查询对象.  
107.      */  
108.     public List findByLike(String name, String value) {   
109.         Assert.hasText(name);   
110.         Criteria criteria = getSession().createCriteria(getEntityClass());   
111.         criteria.add(Restrictions.like(name, value, MatchMode.ANYWHERE));   
112.         return criteria.list();   
113.     }   
114.   
115.     /**  
116.      * 根据Map中过滤条件进行查询.  
117.      *  
118.      * @param filter        过滤条件.  
119.      * @param criteriaSetup 将Map中条件转换为criteria的call back类  
120.      */  
121.     public List findBy(Map filter, CriteriaSetup criteriaSetup) {   
122.         Criteria criteria = getEntityCriteria();   
123.         if (!CollectionUtils.isEmpty(filter)) {   
124.             criteriaSetup.setup(criteria, filter);   
125.         }   
126.         return criteria.list();   
127.     }   
128.   
129.     /**  
130.      * 函数作用同{@link #findBy(Map,CriteriaSetup)}  
131.      * 如果不需要分页,子类可直接重载此函数.  
132.      */  
133.     public List findBy(Map filter) {   
134.         return findBy(filter, getDefaultCriteriaSetup());   
135.     }   
136.   
137.     protected CriteriaSetup getDefaultCriteriaSetup() {   
138.         return new CriteriaSetup() {   
139.             public void setup(Criteria criteria, Map filter) {   
140.                 if (filter != null && !filter.isEmpty()) {   
141.                     Set keys = filter.keySet();   
142.                     for (Object key : keys) {   
143.                         String value = (String) filter.get(key);   
144.                         if (StringUtils.isNotBlank(value))   
145.                             criteria.add(Restrictions.eq((String) key, value));   
146.                     }   
147.                 }   
148.             }   
149.         };   
150.     }   
151.   
152.     /**  
153.      * 取得Entity的Criteria.  
154.      */  
155.     protected Criteria getEntityCriteria() {   
156.         return getSession().createCriteria(getEntityClass());   
157.     }   
158.   
159.     /**  
160.      * 构造Criteria的排序条件默认函数.可供其他查询函数调用  
161.      *  
162.      * @param criteria Criteria实例.  
163.      * @param sortMap  排序条件.  
164.      * @param entity   entity对象,用于使用反射来获取某些属性信息  
165.      */  
166.     protected void sortCriteria(Criteria criteria, Map sortMap, Object entity) {   
167.         if (!sortMap.isEmpty()) {   
168.             for (Object o : sortMap.keySet()) {   
169.                 String fieldName = o.toString();   
170.                 String orderType = sortMap.get(fieldName).toString();   
171.   
172.                 //处理嵌套属性如category.name,modify_user.id,暂时只处理一级嵌套   
173.                 if (fieldName.indexOf('.') != -1) {   
174.                     String alias = StringUtils.substringBefore(fieldName, ".");   
175.                     String aliasType = alias;   
176.                     try {   
177.                         aliasType = PropertyUtils.getProperty(entity, alias).getClass().getSimpleName();   
178.                     } catch (Exception e) {   
179.                         logger.error("Get property" + alias + " error");   
180.                     }   
181.                     criteria.createAlias(aliasType, alias);   
182.                 }   
183.   
184.                 if ("asc".equalsIgnoreCase(orderType)) {   
185.                     criteria.addOrder(Order.asc(fieldName));   
186.                 } else {   
187.                     criteria.addOrder(Order.desc(fieldName));   
188.                 }   
189.             }   
190.         }   
191.     }   
192.   
193.     /**  
194.      * 判断对象某列的值在数据库中不存在重复  
195.      *  
196.      * @param names 在POJO里相对应的属性名,列组合时以逗号分割  
197.  
198.      *              如"name,loginid,password"  
199.      */  
200.     public boolean isNotUnique(Object entity, String names) {   
201.         Assert.hasText(names);   
202.         Criteria criteria = getSession().createCriteria(entity.getClass()).setProjection(Projections.rowCount());   
203.         String[] nameList = names.split(",");   
204.         try {   
205.             for (String name : nameList) {   
206.                 criteria.add(Restrictions.eq(name, PropertyUtils.getProperty(entity, name)));   
207.             }   
208.   
209.             String keyName = getSessionFactory().getClassMetadata(entity.getClass()).getIdentifierPropertyName();   
210.             if (keyName != null) {   
211.                 Object id = PropertyUtils.getProperty(entity, keyName);   
212.                 //如果是update,排除自身   
213.                 if (id != null)   
214.                     criteria.add(Restrictions.not(Restrictions.eq(keyName, id)));   
215.             }   
216.         }   
217.         catch (Exception e) {   
218.             logger.error(e.getMessage());   
219.             return false;   
220.         }   
221.         return ((Integer) criteria.uniqueResult()) > 0;   
222.     }   
223. }   
224.   

上面只是简单的说了一下的springside项目源代码的一些优雅的地方,如果有需要的要求的话,我会贴出完整的一个简单例子的demo的,包括分页的与泛型DAO的应用.