compass学习笔记

以下是鄙人在学习compass所做的笔记（如果鄙人写的不是很清楚的话，可以从电驴或者迅雷上搜索v521刘伟老师的compass学习视频）。系统框架采用Struts2.1.6+Spring2.5.4+Hibernate3+compass2.1.0，JDK版本采用6.0的。

 

首先，需要将将SSH整合好。具体的我不在此说明，可以在google上进行搜索。我将重点说明compass如何与SSH进行整合。

 

使用compass框架，首先需要进行compass关于实体类的映射。compass在其文档中说明，一般是在实体类相对应的*.cpm.xml中进行配置的。但是在开发中，我们可以借助jdk关于标注的新特性，将此文件省略。具体代码如下所示：

[java]  view plain copy

1. package com.zhou.model;     
2.     
3.     
4. import java.io.Serializable;     
5.     
6. import org.compass.annotations.Searchable;     
7. import org.compass.annotations.SearchableId;     
8. import org.compass.annotations.SearchableProperty;     
9.     
10. @Searchable    
11. public class Product implements Serializable {     
12.     
13.     
14.     private static final long serialVersionUID = -3148838659193709682L;     
15.          
16.     //Field     
17.          
18.     @SearchableId    
19.     private String id;     
20.     @SearchableProperty(name="name")     
21.     private String name;     
22.     @SearchableProperty(name="price")     
23.     private Integer price;     
24.     @SearchableProperty(name="brand")     
25.     private String brand;     
26.     @SearchableProperty(name="description")     
27.     private String description;     
28.     
29.     // Constructors     
30.     
31.     /** default constructor */    
32.     public Product() {     
33.     }     
34.     
35.     /** full constructor */    
36.     public Product(String name, Integer price, String brand, String description) {     
37.         this.name = name;     
38.         this.price = price;     
39.         this.brand = brand;     
40.         this.description = description;     
41.     }     
42.     
43.     // Property accessors     
44.     
45.     public String getId() {     
46.         return this.id;     
47.     }     
48.     
49.     public void setId(String id) {     
50.         this.id = id;     
51.     }     
52.     
53.     public String getName() {     
54.         return this.name;     
55.     }     
56.     
57.     public void setName(String name) {     
58.         this.name = name;     
59.     }     
60.     
61.     public Integer getPrice() {     
62.         return this.price;     
63.     }     
64.     
65.     public void setPrice(Integer price) {     
66.         this.price = price;     
67.     }     
68.     
69.     public String getBrand() {     
70.         return this.brand;     
71.     }     
72.     
73.     public void setBrand(String brand) {     
74.         this.brand = brand;     
75.     }     
76.     
77.     public String getDescription() {     
78.         return this.description;     
79.     }     
80.     
81.     public void setDescription(String description) {     
82.         this.description = description;     
83.     }     
84.     
85. }    

如代码所示，实体类的类声明和属性声明分别加入了相应的标注。public class前面的“@Searchable”表示此类可以被索引，也就是此类对应的数据库可以被索引。属性id前的“@SearchableId”表示索引建立的id。其他属性前面的“@SearchableProperty(name="name")”表示此字段可以被索引、被检索。name=“name”表示此字段被索引后的名称。在检索类中，可以根据此名字指定搜索的字段名称。

建立索引的类（CompassIndexBuilder.java）

[java]  view plain copy

1. package com.zhou.service.impl;     
2.     
3. import java.util.Date;     
4.     
5. import org.compass.gps.CompassGps;     
6. import org.springframework.beans.factory.InitializingBean;     
7.     
8. public class CompassIndexBuilder implements InitializingBean {     
9.     private boolean buildIndex = false;     
10.     
11.     private int lazyTime = 5;     
12.     private CompassGps compassGps;     
13.     private Thread indexThread = new Thread() {     
14.         public void run() {     
15.             try {     
16.                 Thread.sleep(lazyTime * 1000);     
17.                 System.out.println("begin compass index...");     
18.                 long beginTime = System.currentTimeMillis();     
19.                 compassGps.index();     
20.                 long costTime = System.currentTimeMillis() - beginTime;     
21.                 System.out.println("compss index finished.");     
22.                 System.out.println("costed " + costTime + " milliseconds");     
23.             } catch (InterruptedException e) {     
24.                 e.printStackTrace();     
25.             }     
26.         }     
27.     };     
28.     
29.     public void afterPropertiesSet() throws Exception {     
30.         System.out.println(new Date()+"调用");     
31.         if (buildIndex) {     
32.             indexThread.setDaemon(true);     
33.             indexThread.setName("Compass Indexer");     
34.             indexThread.start();     
35.         }     
36.     }     
37.     
38.     public void setBuildIndex(boolean buildIndex) {     
39.         this.buildIndex = buildIndex;     
40.     }     
41.     
42.     public void setLazyTime(int lazyTime) {     
43.         this.lazyTime = lazyTime;     
44.     }     
45.     
46.     public void setCompassGps(CompassGps compassGps) {     
47.         this.compassGps = compassGps;     
48.     }     
49.     
50. }    

 

详细的解释可以观看视频，在此不再说明。

 

将compass的配置写在同一个文件（applicationContext-compass）中，以便同一管理。内容如下：

[java]  view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>    
2.     
3. <beans xmlns="http://www.springframework.org/schema/beans"    
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    
5.     xsi:schemaLocation=" http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"    
6.     default-lazy-init="true">    
7.     
8.        <!--  如果使用jdk标注新特性，此处必须有的  -->    
9.     <bean id="annotationConfiguration" class="org.compass.annotations.config.CompassAnnotationsConfiguration">    
10.     </bean>    
11.     
12.     
13.     <bean id="compass" class="org.compass.spring.LocalCompassBean">    
14.         <property name="resourceDirectoryLocations">    
15.             <list>    
16.                 <value>classpath:com/zhou</value>    
17.             </list>    
18.         </property>    
19.         <property name="connection">    
20.             <value>/lucene/indexes</value>    
21.         </property>    
22.     
23.     
24.         <property name="classMappings">    
25.             <list>    
26.                 <value>com.zhou.model.Product</value>    
27.             </list>    
28.         </property>    
29.         <property name="compassConfiguration"    
30.             ref="annotationConfiguration" />    
31.     
32.         <property name="compassSettings">    
33.             <props>    
34.                 <prop key="compass.transaction.factory">    
35.                     org.compass.spring.transaction.SpringSyncTransactionFactory     
36.                 </prop>    
37.                 <prop    
38.                     key="compass.engine.analyzer.MMAnalyzer.CustomAnalyzer">    
39.                     net.paoding.analysis.analyzer.PaodingAnalyzer     
40.                 </prop>    
41.                 <prop    
42.                     key="compass.engine.highlighter.default.formatter.simple.pre">    
43.                     <!--[CDATA[<font color="red"><b>]]>    
44.                 </prop>    
45.                 <prop    
46.                     key="compass.engine.highlighter.default.formatter.simple.post">    
47.                     <![CDATA[</b></font>]]-->    
48.                 </prop>    
49.             </props>    
50.         </property>    
51.     
52.         <property name="transactionManager" ref="transactionManager" />    
53.     </bean>    
54.     
55.     
56.     <bean id="hibernateGpsDevice"    
57.         class="org.compass.gps.device.hibernate.HibernateGpsDevice">    
58.         <property name="name">    
59.             <value>hibernateDevice</value>    
60.         </property>    
61.         <property name="sessionFactory" ref="sessionFactory" />    
62.         <property name="mirrorDataChanges">    
63.             <value>true</value>    
64.         </property>    
65.     </bean>    
66.     <!-- 同步更新索引 -->    
67.     <bean id="compassGps" class="org.compass.gps.impl.SingleCompassGps"    
68.         init-method="start" destroy-method="stop">    
69.         <property name="compass" ref="compass" />    
70.         <property name="gpsDevices">    
71.             <list>    
72.                 <bean    
73.                     class="org.compass.spring.device.SpringSyncTransactionGpsDeviceWrapper">    
74.                     <property name="gpsDevice" ref="hibernateGpsDevice" />    
75.                 </bean>    
76.             </list>    
77.         </property>    
78.     </bean>    
79.     
80.     
81.     <bean id="compassTemplate"    
82.         class="org.compass.core.CompassTemplate">    
83.         <property name="compass" ref="compass" />    
84.     </bean>    
85.     
86.     <!-- 定时重建索引(利用quartz)或随Spring ApplicationContext启动而重建索引 -->    
87.     <bean id="compassIndexBuilder"    
88.         class="com.zhou.service.impl.CompassIndexBuilder" lazy-init="false">    
89.     
90.         <property name="compassGps" ref="compassGps" />    
91.     
92.         <property name="buildIndex" value="true" />    
93.         <property name="lazyTime" value="5" />    
94.     </bean>    
95.     
96. </beans>    

  

 

在业务层进行数据检索的代码如下：

 

[java]  view plain copy

1. public List<Product> searchProducts(String queryString) {     
2.     
3.     List<Product> products = new ArrayList<Product>();     
4.     
5.     Compass compass = compassTemplate.getCompass();     
6.     CompassSession session = compass.openSession();     
7.     
8.     CompassHits hits = session.queryBuilder().queryString(     
9.             "name:" + queryString).toQuery().hits();     
10.     System.out.println("---------------------------------------------");     
11.     System.out.println("queryString=" + queryString);     
12.     System.out.println("结果个数=" + hits.length());     
13.     
14.     for (int i = 0; i < hits.length(); i++) {     
15.         Product hit = (Product) hits.data(i);     
16.     
17.         String ht = hits.highlighter(i).fragment("name");     
18.         if (null != ht) {     
19.             hit.setName(ht);     
20.         }     
21.         products.add(hit);     
22.     }     
23.     
24.     return products;     
25. }    

 

  以上是关键部分的说明。在bs层中的检索方法searchProducts(String queryString)中，有很多地方需要深入的思考一下。比如：在“CompassHits hits = session.queryBuilder().queryString("name:" + queryString).toQuery().hits();”中的“name”就是至前面实体类中的“@SearchableProperty(name="name")”中“name”的值，表示只对该字段进行检索。又比如涉及到结果分页显示的话，该如何封装返回的结果。究竟是一次全部封装到List中还是每页显示n条就封装n条，翻页的时候继续hit呢？有待深入思考。

       附件为样例程序，但是相关的jar包太大了，无法上传！需要自己查找。