Compass基础知识一

yufenfei

浏览: 801041 次
性别:
来自: 北京

最近访客更多访客>>

sd_zf

mingtianfb

hanmiao

邱董233

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

Lucene

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

<!-- 使用annotation配置，指定要转换的POJO。PO类在compass的classMappings值指定 -->
    <bean id="annotationConfiguration"
        class="org.compass.annotations.config.CompassAnnotationsConfiguration">
    </bean>
   
   <bean id="compass" class="org.compass.spring.LocalCompassBean">
        <!-- OSEM映射的对象PO类 -->
        <property name="classMappings">
            <list>
               <value>com.core.persistence.po.Article</value>
               <value>com.core.persistence.po.Author</value>
            </list>
        </property>
        <!-- 使用注解配置 -->
        <property name="compassConfiguration" ref="annotationConfiguration"/>
        <property name="compassSettings">
            <props>
                <!-- 索引文件在服务器上的存储路径 如：file://d:/index -->
                <prop key="compass.engine.connection">/lucene/indexes</prop>
                <!-- 在内存中建立索引
               <prop key="compass.engine.connection">ram://index</prop>
               -->
                <prop key="compass.transaction.factory">
                    org.compass.spring.transaction.SpringSyncTransactionFactory
                 </prop>
                 <!-- 配置高亮为红色 -->
                <prop key="compass.engine.highlighter.default.formatter.simple.pre">
                    <![CDATA[<font color="red"><b>]]>
                </prop>
                <prop
                    key="compass.engine.highlighter.default.formatter.simple.post">
                    <![CDATA[</b></font>]]>
                </prop>
            </props>
        </property>
 
        <property name="transactionManager" ref="transactionManager"/>
    </bean>
   
    <bean id="compassTemplate" class="org.compass.core.CompassTemplate">
        <property name="compass" ref="compass"/>
    </bean>
   
    <!-- 与hibernate的绑定，经Hiberante的数据改变会自动被反射到索引里面(增加、修改、删除操作). -->
   <bean id="hibernateGpsDevice"
        class="org.compass.gps.device.hibernate.HibernateGpsDevice">
        <property name="name">
            <value>hibernateDevice</value>
        </property>
        <property name="sessionFactory" ref="sessionFactory"/>
        <property name="mirrorDataChanges">
            <value>true</value>
        </property>
    </bean>
   
    <bean id="compassGps" class="org.compass.gps.impl.SingleCompassGps"
        init-method="start" destroy-method="stop">
        <property name="compass" ref="compass"/>
        <property name="gpsDevices">
            <list>
              <ref local="hibernateGpsDevice"/>  
            </list>
        </property>
    </bean>
 
    <!-- 定时重建索引(利用quartz)或随Spring ApplicationContext启动而重建索引 -->
    <bean id="compassIndexBuilder" class="com.lucene.service.CompassIndexBuilder" lazy-init="false">
        <property name="compassGps" ref="compassGps"/>
        <property name="buildIndex" value="true"/>
        <property name="lazyTime" value="10"/>
    </bean>
 

 
public class CompassIndexBuilder implements InitializingBean {
 
    private static final Logger log = Logger.getLogger(CompassIndexBuilder.class);
 
    // 是否需要建立索引，可被设置为false使本Builder失效.
    private boolean buildIndex = true;
 
    // 索引操作线程延时启动的时间，单位为秒
    private int lazyTime = 10;
 
    // Compass封装
    private CompassGps compassGps;
 
    // 索引线程
    private Thread indexThread = new Thread() {
 
        @Override
        public void run() {
            try {
                Thread.sleep(lazyTime * 1000);
 
                log.info("begin compass index...");
                long beginTime = System.currentTimeMillis();
                // 重建索引.
                // 如果compass实体中定义的索引文件已存在，索引过程中会建立临时索引，
                // 索引完成后再进行覆盖.
                compassGps.index();
                long costTime = System.currentTimeMillis() - beginTime;
                log.info("compss index finished.");
                log.info("costed " + costTime + " milliseconds");
            } catch (InterruptedException e) {
            }
        }
    };
 
    /**
     * 实现<code>InitializingBean</code>接口，在完成注入后调用启动索引线程.
     * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
     */
    public void afterPropertiesSet() throws Exception {
        if (buildIndex) {
            indexThread.setDaemon(true);
            indexThread.setName("Compass Indexer");
            indexThread.start();
        }
    }
 
    public void setBuildIndex(boolean buildIndex) {
        this.buildIndex = buildIndex;
    }
 
    public void setLazyTime(int lazyTime) {
        this.lazyTime = lazyTime;
    }
 
    public void setCompassGps(CompassGps compassGps) {
        this.compassGps = compassGps;
    }
}

5、进行简单搜索

Compass compass = compassTemplate.getCompass();
CompassSession session=compass.openSession();
List list = new ArrayList();
CompassHits hits= session.queryBuilder().queryString(queryString).toQuery().hits();
for(int i=0;i<hits.length();i++){
    Person hit=( Person)hits.data(i);
    list.add(hit);
}
session.close();
return list;

以上内容有参考他人之处，不在这列出，谢谢！