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


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<hits.length();i++){ 
6.    Person hit=( Person)hits.data(i); 
7.    list.add(hit); 
8.} 
9.session.close(); 
10.return list;