jqGrid与Struts2的结合应用（七） —— 浅谈排序

转至：http://blog.youkuaiyun.com/gengv/article/details/5732698

作者：gengv

 

终于讲到排序了，这一部分应该说还是比较好理解的。

jqGrid通过colModel选项中的sortable来控制是否可以以某列的值排序。sortable的默认值是true，当设为false时，即此列不能用于排序。

 

[javascript]  view plain copy

1. $(function(){  
2.     $("#gridTable").jqGrid({  
3.       
4.         ...  
5.            
6.         colModel: [  
7.               {name:"id",index:"id",label:"编码",width:40},    
8.               {name:"lastName",index:"lastName",label:"姓",width:80},  
9.               {name:"firstName",index:"firstName",label:"名",width:80},  
10.               {name:"email",index:"email",label:"电子邮箱",width:160,sortable:false},  
11.               {name:"telNo",index:"telNo",label:"电话",width:120,sortable:false}  
12.         ],  
13.           
14.         ...  
15.           
16.     });  
17. });  

当点击sortable为true的列首时，jqGrid会向Server发送排序请求，例如：
http://localhost:8085/Hare/jqGridTest/jqGrid05.action?search=false&nd=1279006749246&rows=15&page=3&sidx=firstName&sord=asc

注：其中sord和sidx参数名都是在jqGrid的prmNames选项中设定的（可参考本系列文章的第一篇）。而sidx参数的值即各列的colModel的index选项值。（在查询和排序时，发送的关于列的参数都是基于colModel的index属性的）

后面的事情就交给服务器端的Action来处理了，还拿我们的Contact联系人列表为例。

既然我们可能会分别使用不同的字段来排序，那么就必须为Contact提供不同的Comparator来简化比较操作。因此我写了一个针对Contact的Comparator的工厂类，用来根据不同的字段提供不同的Comparator。

ContactComparatorFactory的代码：

 

 

[java]  view plain copy

1. package cn.gengv.struts2ex.jqGrid;  
2. import java.text.Collator;  
3. import java.util.Comparator;  
4. import com.byzl.hare.model.Contact;  
5. public class ContactComparatorFactory {  
6.     private static Collator collator_Chinese = Collator.getInstance(java.util.Locale.CHINA);  
7.     private final static Comparator<Contact> idComparator = new IdComparator();  
8.     private final static Comparator<Contact> firstNameComparator = new FirstNameComparator();  
9.     private final static Comparator<Contact> lastNameComparator = new LastNameComparator();  
10.     private final static Comparator<Contact> fullNameComparator = new FullNameComparator();  
11.     private final static Comparator<Contact> idCardNoNoComparator = new IdCardNoComparator();  
12.     private final static Comparator<Contact> nationalityComparator = new NationalityComparator();  
13.       
14.       
15.     public static Comparator<Contact> getComparator(String compareType) {  
16.         if ("id".equalsIgnoreCase(compareType)) {  
17.             return idComparator;  
18.         } else if ("firstName".equalsIgnoreCase(compareType)) {  
19.             return firstNameComparator;  
20.         } else if ("lastName".equalsIgnoreCase(compareType)) {  
21.             return lastNameComparator;  
22.         } else if ("fullName".equalsIgnoreCase(compareType)) {  
23.             return fullNameComparator;  
24.         } else if ("idCardNoNo".equalsIgnoreCase(compareType)) {  
25.             return idCardNoNoComparator;  
26.         } else if ("nationality".equalsIgnoreCase(compareType)) {  
27.             return nationalityComparator;  
28.         } else {  
29.             return null;  
30.         }  
31.     }  
32.       
33.     public static class IdComparator implements Comparator<Contact> {  
34.         public int compare(Contact c1, Contact c2) {  
35.             if (c1 == null && c2 == null) {  
36.                 return 0;  
37.             } else if (c1 == null && c2 != null) {  
38.                 return -1;  
39.             } else if (c1 != null && c2 == null) {  
40.                 return 1;  
41.             } else {  
42.                 int id1 = c1.getId();  
43.                 int id2 = c2.getId();  
44.                 return id1 == id2 ? 0 : (id1 < id2 ? -1 : 1);  
45.             }  
46.         }  
47.     }  
48.       
49.     public static class FirstNameComparator implements Comparator<Contact> {  
50.         public int compare(Contact c1, Contact c2) {  
51.             if (c1 == null && c2 == null) {  
52.                 return 0;  
53.             } else if (c1 == null && c2 != null) {  
54.                 return -1;  
55.             } else if (c1 != null && c2 == null) {  
56.                 return 1;  
57.             } else {  
58.                 String s1 = c1.getFirstName();  
59.                 String s2 = c2.getFirstName();  
60.                   
61.                 if (s1 == null && s2 == null) {  
62.                     return 0;  
63.                 } else if (s1 == null && s2 != null) {  
64.                     return -1;  
65.                 } else if (s1 != null && s2 == null) {  
66.                     return 1;  
67.                 } else {  
68.                     return collator_Chinese.compare(s1, s2);  
69.                 }  
70.             }  
71.         }  
72.     }  
73.       
74.     public static class LastNameComparator implements Comparator<Contact> {  
75.         public int compare(Contact c1, Contact c2) {  
76.             if (c1 == null && c2 == null) {  
77.                 return 0;  
78.             } else if (c1 == null && c2 != null) {  
79.                 return -1;  
80.             } else if (c1 != null && c2 == null) {  
81.                 return 1;  
82.             } else {  
83.                 String s1 = c1.getLastName();  
84.                 String s2 = c2.getLastName();  
85.                   
86.                 if (s1 == null && s2 == null) {  
87.                     return 0;  
88.                 } else if (s1 == null && s2 != null) {  
89.                     return -1;  
90.                 } else if (s1 != null && s2 == null) {  
91.                     return 1;  
92.                 } else {  
93.                     return collator_Chinese.compare(s1, s2);  
94.                 }  
95.             }  
96.         }  
97.     }  
98.       
99.     public static class FullNameComparator implements Comparator<Contact> {  
100.         public int compare(Contact c1, Contact c2) {  
101.             if (c1 == null && c2 == null) {  
102.                 return 0;  
103.             } else if (c1 == null && c2 != null) {  
104.                 return -1;  
105.             } else if (c1 != null && c2 == null) {  
106.                 return 1;  
107.             } else {  
108.                 String s1 = c1.getFullName();  
109.                 String s2 = c2.getFullName();  
110.                   
111.                 if (s1 == null && s2 == null) {  
112.                     return 0;  
113.                 } else if (s1 == null && s2 != null) {  
114.                     return -1;  
115.                 } else if (s1 != null && s2 == null) {  
116.                     return 1;  
117.                 } else {  
118.                     return collator_Chinese.compare(s1, s2);  
119.                 }  
120.             }  
121.         }  
122.     }  
123.       
124.     public static class IdCardNoComparator implements Comparator<Contact> {  
125.         public int compare(Contact c1, Contact c2) {  
126.             if (c1 == null && c2 == null) {  
127.                 return 0;  
128.             } else if (c1 == null && c2 != null) {  
129.                 return -1;  
130.             } else if (c1 != null && c2 == null) {  
131.                 return 1;  
132.             } else {  
133.                 String s1 = c1.getIdCardNo();  
134.                 String s2 = c2.getIdCardNo();  
135.                   
136.                 if (s1 == null && s2 == null) {  
137.                     return 0;  
138.                 } else if (s1 == null && s2 != null) {  
139.                     return -1;  
140.                 } else if (s1 != null && s2 == null) {  
141.                     return 1;  
142.                 } else {  
143.                     return s1.compareToIgnoreCase(s2);  
144.                 }  
145.             }  
146.         }  
147.     }  
148.       
149.     public static class NationalityComparator implements Comparator<Contact> {  
150.         public int compare(Contact c1, Contact c2) {  
151.             if (c1 == null && c2 == null) {  
152.                 return 0;  
153.             } else if (c1 == null && c2 != null) {  
154.                 return -1;  
155.             } else if (c1 != null && c2 == null) {  
156.                 return 1;  
157.             } else {  
158.                 String s1 = c1.getNationality();  
159.                 String s2 = c2.getNationality();  
160.                   
161.                 if (s1 == null && s2 == null) {  
162.                     return 0;  
163.                 } else if (s1 == null && s2 != null) {  
164.                     return -1;  
165.                 } else if (s1 != null && s2 == null) {  
166.                     return 1;  
167.                 } else {  
168.                     return collator_Chinese.compare(s1, s2);  
169.                 }  
170.             }  
171.         }  
172.     }  
173.       
174.       
175. }  

 

 

然后再来看JqGridBaseAction，其中添加了一个抽象方法，用来将数据结果进行排序。

 

[java]  view plain copy

1. package cn.gengv.struts2ex.jqGrid;  
2.    
3. // import ...  
4.    
5. @SuppressWarnings("serial")  
6. public abstract class JqGridBaseAction<T> extends ActionSupport {  
7.     ...  
8.       
9.     // (1)添加排序方法  
10.     public abstract void sortResults(List<T> results, String field, String order);  
11.       
12.     public String refreshGridModel() {  
13.         try {  
14.             List<Criterion> criteria = Collections.emptyList();  
15.                
16.             if(search == true) {  
17.                 criteria = new ArrayList<Criterion>();  
18.                   
19.                 if(filters != null && filters.length()>0) {  
20.                     criteria.addAll(this.generateSearchCriteriaFromFilters(filters));  
21.                 }  
22.                    
23.                 Criterion criterion = this.generateSearchCriterion(searchField, searchString, searchOper);  
24.                 if(criterion != null) {  
25.                     criteria.add(criterion);  
26.                 }  
27.             }  
28.                
29.             List<T> results = Collections.emptyList();  
30.               
31.               
32.             int from = rows * (page - 1);  
33.             int length = rows;   
34.               
35.             if(loadonce) {  
36.                 from = 0;  
37.                 length = 100;  
38.             }  
39.                
40.             if(!criteria.isEmpty()) {  
41.                 record = this.getResultSize(criteria);  
42.                 results = this.listResults(criteria, from, length);  
43.                   
44.             } else {  
45.                 record = this.getResultSize();  
46.                 results = this.listResults(from, length);  
47.                   
48.             }  
49.               
50.             // (2)将结果排序  
51.             if(sidx != null && sord != null) {  
52.                 sortResults(results, sidx, sord);  
53.             }  
54.    
55.             this.setGridModel(results);  
56.             total = (int) Math.ceil((double) record / (double) rows);  
57.             return SUCCESS;  
58.         } catch (Exception e) {  
59.             e.printStackTrace();  
60.             this.addActionError(e.getMessage());  
61.             return ERROR;  
62.         }  
63.     }  
64.       
65.     ...  
66. }  

 

而在ListContactsAction中提供了方法实现：

 

[java]  view plain copy

1. package cn.gengv.struts2ex.jqGrid;  
2.    
3. import java.util.Collections;  
4. import java.util.Comparator;  
5. import java.util.List;  
6. import com.byzl.hare.dao.impl.Criterion;  
7. import com.byzl.hare.model.Contact;  
8. import com.byzl.hare.service.ContactService;  
9.    
10. @SuppressWarnings("serial")  
11. public class ListContactsAction extends JqGridBaseAction<Contact> {  
12.       
13.     ...  
14.       
15.     @Override  
16.     public void sortResults(List<Contact> results, String field, String order) {  
17.         // (1)根据field获得对应的Comparator  
18.         Comparator<Contact> comparator = ContactComparatorFactory.getComparator(field);  
19.           
20.         if(comparator != null) {  
21.             // (2)使用Comparator排序  
22.             Collections.sort(results, comparator);  
23.               
24.             // (3)如果需要的排序顺序为desc，则颠倒顺序  
25.             if("desc".equals(order)) {  
26.                 Collections.reverse(results);  
27.             }  
28.         }  
29.           
30.     }  
31.    
32.     ...  
33. }  

 

 

不过这个例子存在一定的局限性，即只能将当前页中的数据根据某列进行排序；而不能跨页间进行数据排序。之所以存在这种局限，也是源于实际应用中的客观限制。还以这个例子来说，数据库里总共模拟了两万多条数据记录。如果每次要将这些记录进行排里的话，除非有数据库索引支持，否则所要消耗的时间也是相当客观的，对于用户体验来说，几乎就是灾难。如果数据量更多的话，结果可想而知。

因此，我们应该换一个角度来看这个问题，用户之所以使用排序，更多的目的还是在于查找数据方便，既然我们可以提供条件查询（尤其是复杂条件查询），那么用户对于排序的需求也就不会那么迫切了。同时也可以体会到，排序更多地应用在少量数据的场合下。