Compass基础知识

1、Compass简单介绍

Compass是一个强大的,事务的,高性能的对象/搜索引擎映射(OSEM:object/search engine mapping)与一个Java持久层框架。

  Compass包括以下功能: 

          * 搜索引擎抽象层(使用Lucene搜索引荐),

          * OSEM (Object/Search Engine Mapping) 支持,

          * 事务管理,

          * 类似于Google的简单关键字查询语言,

          * 可扩展与模块化的框架,

          * 简单的API.

2、Compass的优点与缺点

   优点：

      * Compass将lucene、Spring、Hibernate三者的起来，以很低很低的成本快速实现企业应用中的搜索功能;

      * Compass比较成熟，网上的文档很多，入门很简单；

      * 更多优点

   缺点：

       * Compass目前版本是2.2.0，已经很久没有更新与维护。Compass2.2的版本所对应的Lucene2.4.1,但现在Lucene已经升级到3以上的版本，Lucene3以上的版本的API差别很大，3.0以后版本貌似效率更高

      *  说这么多最终目的是说Compass目前只支持到Lucene2.4.1版本，如果你想使用Lucene就不能使用Compass了

      *  现在已经有Hibernate Search作为搜索引擎框架，可以与Lucene进行联合使用。但我没有真正的去使用过。

         

3、Compass

       Compass 通过OSEM(Object/Search Engine Mapping)允许把应用对象的领域模型映射到搜索引擎，目前有两种方式来进行OSEM，分别是XML方式和JDK5以上的注解（Annotation）

   方式。

      与采用xml配置文件相比较，采用Annonation方式还是相对简单。使用注解方式核心标注只有@Searchable、@SearchableId、@SearchableProperty、 @SearchableComponent个，很容易记忆，

   不想XML那么麻烦，尤其是和spring、hiberante一起使用时，建议采用注解方式。

  

   （1）、注解详细信息

       @Searchable、@SearchableId、@SearchableProperty、 @SearchableComponent分别代表搜索类、主键、可搜索的属性与关联的、另一个可搜索的对象

      （注：Compass要求POJO要有默认构造函数，要实现equals()和hashcode()）:   

  

      （a）、@Searchable

             如：

              @Searchable

              public class Article {

             

      （b）、@SearchableId

         如：

            @SearchableId

             private String id;

                           

    也可以这样写

               @SearchableId

                public Integer getId() {

                       return this.id;

                 }

                                                    

      （c）、@SearchableProperty

            @SearchableProperty(name="name", store=Store.NA)

              private String name;

                                                       

             也可以放在该属性的getter方法的前

                  @SearchableProperty注解有几个属性需要注意：

                      

                  store：

                        Store.NA,默认值，等同Store.YES

                         Store.NO 与Lucene中的Field.Store.NO;指定不存储域值

                         Store.YES  与Lucene中的Field.Store.YES;指定存储域值

                         Store.COMPRESS                                         

                   index:         

                              Index.NA:

                              Index.NO:使对应的域值不进行搜索

                               INDEX.ANALYZED：对域进行索引，并将域值分解成对应的词汇单元，并使每个词汇单元能被搜索

                              INDEX.NOT_ANALYZED：对域进行索引，但不对string值进行分析

                      boost：域的加权

                                                 

                       其它的可以仔细了解

   

（2）、Compass核心API

 

Compass的核心API借鉴了Hibernate的术语，因此在操作上基本上与Hibernate类似，以下为Compass的几个核心接口：

 

    CompassConfiguration(类似Hibernate Configuration)：用来在一些设置参数、配置文件和映射定义上配置Compass。通常用来创建Compass接口。

    Compass(类似Hibernate SessionFactory)：为单线程使用，创建线程安全的实例来打开Compass Seesion。同样还提供了一些搜索引擎索引级别的操作。

    CompassSesssion(类似Hibernate Session)：用来执行像保存、删除、查找、装载这样的搜索操作。很轻量但是并不是线程安全的。

    CompassTransaction(类似Hibernate Transaction)：管理Compass事务的接口。使用它并不需要事务管理环境（像Spring、JTA）。

 

   Compass和Hibernate很相像,无非就是Hibernate把JDBC封装了一把.所以从结构上来说,只要我们了解了Hibernate,就已经对Compass有了了解.那么Hibernate需要提供API和配置文件来对JDBC进行操作,那么Compass呢?Compass不仅从结构上模仿了Hibernate,就连API风格也不尽相同.我们把它和Hibernate的API做个对比就知道了:

再把两个session的核心方法比较一下:

Hibernate session API	CompassSession API
save(Object)	create(Object)	建立索引
saveOrUpdate(Object)	save(Object)	保存或更新
delete(Object)	delete(Class, ids...)	删除索引
get()	get()	获取
createQuery(hql).list()	find(String)	使用查询字符串查询

所以说,Compass与Hibernate极为相似,Compass总结起来就两句话:

 

4、Compass、Lucene、Spring、Hibernate集成

  可以不为compass编写一行代码或者很少的代码,就可以做完搜索引擎的检索

 

 

使用Lucene2.4.1；Compass2.2.0

 

 

Java代码  

1.   
2.     "annotationConfiguration"  
3.         class="org.compass.annotations.config.CompassAnnotationsConfiguration">  
4.       
5.      
6.    "compass" class="org.compass.spring.LocalCompassBean">  
7.           
8.         "classMappings">  
9.               
10.                com.core.persistence.po.Article  
11.                com.core.persistence.po.Author  
12.               
13.           
14.           
15.         "compassConfiguration" ref="annotationConfiguration"/>  
16.         "compassSettings">  
17.               
18.                   
19.                 "compass.engine.connection">/lucene/indexes  
20.                   
21.                 "compass.transaction.factory">  
22.                     org.compass.spring.transaction.SpringSyncTransactionFactory  
23.                    
24.                    
25.                 "compass.engine.highlighter.default.formatter.simple.pre">  
26.                     "red">]]>  
27.                   
28.                 
29.                     key="compass.engine.highlighter.default.formatter.simple.post">  
30.                     ]]>  
31.                   
32.               
33.           
34.    
35.         "transactionManager" ref="transactionManager"/>  
36.       
37.      
38.     "compassTemplate" class="org.compass.core.CompassTemplate">  
39.         "compass" ref="compass"/>  
40.       
41.      
42.       
43.    "hibernateGpsDevice"  
44.         class="org.compass.gps.device.hibernate.HibernateGpsDevice">  
45.         "name">  
46.             hibernateDevice  
47.           
48.         "sessionFactory" ref="sessionFactory"/>  
49.         "mirrorDataChanges">  
50.             true  
51.           
52.       
53.      
54.     "compassGps" class="org.compass.gps.impl.SingleCompassGps"  
55.         init-method="start" destroy-method="stop">  
56.         "compass" ref="compass"/>  
57.         "gpsDevices">  
58.               
59.               "hibernateGpsDevice"/>    
60.               
61.           
62.       
63.    
64.       
65.     "compassIndexBuilder" class="com.lucene.service.CompassIndexBuilder" lazy-init="false">  
66.         "compassGps" ref="compassGps"/>  
67.         "buildIndex" value="true"/>  
68.         "lazyTime" value="10"/>  
69.       
70.    
71.   
72.    
73. public class CompassIndexBuilder implements InitializingBean {  
74.    
75.     private static final Logger log = Logger.getLogger(CompassIndexBuilder.class);  
76.    
77.     // 是否需要建立索引，可被设置为false使本Builder失效.  
78.     private boolean buildIndex = true;  
79.    
80.     // 索引操作线程延时启动的时间，单位为秒  
81.     private int lazyTime = 10;  
82.    
83.     // Compass封装  
84.     private CompassGps compassGps;  
85.    
86.     // 索引线程  
87.     private Thread indexThread = new Thread() {  
88.    
89.         @Override  
90.         public void run() {  
91.             try {  
92.                 Thread.sleep(lazyTime * 1000);  
93.    
94.                 log.info("begin compass index...");  
95.                 long beginTime = System.currentTimeMillis();  
96.                 // 重建索引.  
97.                 // 如果compass实体中定义的索引文件已存在，索引过程中会建立临时索引，  
98.                 // 索引完成后再进行覆盖.  
99.                 compassGps.index();  
100.                 long costTime = System.currentTimeMillis() - beginTime;  
101.                 log.info("compss index finished.");  
102.                 log.info("costed " + costTime + " milliseconds");  
103.             } catch (InterruptedException e) {  
104.             }  
105.         }  
106.     };  
107.    
108.     /** 
109.      * 实现InitializingBean接口，在完成注入后调用启动索引线程. 
110.      * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet() 
111.      */  
112.     public void afterPropertiesSet() throws Exception {  
113.         if (buildIndex) {  
114.             indexThread.setDaemon(true);  
115.             indexThread.setName("Compass Indexer");  
116.             indexThread.start();  
117.         }  
118.     }  
119.    
120.     public void setBuildIndex(boolean buildIndex) {  
121.         this.buildIndex = buildIndex;  
122.     }  
123.    
124.     public void setLazyTime(int lazyTime) {  
125.         this.lazyTime = lazyTime;  
126.     }  
127.    
128.     public void setCompassGps(CompassGps compassGps) {  
129.         this.compassGps = compassGps;  
130.     }  
131. }  

 

 

5、进行简单搜索

 

Java代码  

1. Compass compass = compassTemplate.getCompass();  
2. CompassSession session=compass.openSession();  
3. List list = new ArrayList();  
4. CompassHits hits= session.queryBuilder().queryString(queryString).toQuery().hits();  
5. for(int i=0;i
6.     Person hit=( Person)hits.data(i);  
7.     list.add(hit);  
8. }  
9. session.close();  
10. return list;