已加入Opensymphony的Compass 是对Lucene搜索引擎在企业应用（数据库相关应用）中的封装和增强。 Lucene本身的API已经非常简单，那Compass还能做什么样的增强呢？

    心里数一下还是挺多的，不过可能只有一小部分适合自己的项目，在我的项目里最实际的增强就是索引的建立与Data Change Mirror的功能，其他功能用不用的上就要看缘分了。

1.1 参考资料

    InfoQ：Compass: Integrate Search into your apps

 1.2 What SpringSide Done

    SpringSide在core中仿照Compass的Spring MVC Controller封装了SearchService与Advanced SearchService，方便不使用Spring MVC的同志

    同时在书店示例中演示了图书搜索及结果关键字高亮，在Spring启动时建立索引并基于Hibernate event机制的自动索引更新。

2. Data Change Mirror功能

    DataMirror会把数据库的增删改变化实时映射到索引文件中。

    如果你采用Hibernate等ORM方案，Compass就会与Hibernate的event机制结合，或者使用AOP的方式，自动在数据库增删改时变更索引；如果你只是采用JDBC，也可以在XML文件配置Table Mapping或ResultSet Mapping，指定version列，Compasss定时对version列变化了的数据进行索引更新。

    而且，Compass还支持事务，在查询数据库遍历结果集的过程中如果出现异常，会在Index Segments 文件一级进行事务控制。

    如果没有Compass，我们一般会在每天深夜重建一次索引。相比Compass的做法，
    一来反应迟缓，平均延时半天；
    二来效率没有Compass高。如果采用完全重建索引，效率就不用说了。如果进行增量索引，就要增加一个字段，在数据更新时进行特殊的处理，删除时也不能直接删除数据，要等lucene删完索引数据才能删除，这样Lucene对应用就非常不透明了。
    三来不支持事务，如果建立索引过程中出现异常，索引文件的状态是不可控的。

3. Compass 下简化的索引建立过程

    在lucene 下建立索引的过程是自己用JDBC 跑SQL 获得ResultSet，遍历ResultSet建立Document对象并用IndexWriter写入文件目录。

    在Compass下就变成一个宣告的过程：

3.1 宣告待搜索的POJO

   @SearchableId 宣告Document的id列；

   @SearchableProperty 宣告要索引的field；

   @SearchableComponent宣告关联其他对象如Category分类。
       

public   class  Product  {
      @SearchableId
      privateInteger id;

      @SearchableProperty
      privateString name;

      @SearchableComponent
      private Category category;
 }

      CompassGps是Compass下用来建立索引，Mirror Data Change的类。

      在ApplicationContext.xml定义了Compass与Spring的集成，配置参数，并让GPS随ApplicationContext启动开始监控Hibernate的DataChange ：

• Compass：核心定义类，定义要搜索的POJO 和 索引存储的路径。
• CompassGPS： 定义使用了Hibernate3GPS，定义了init-method 和destory-method，会自动随ApplicaitonContext的启动，开始监控Hibernate的变化。

								

										
										<!--
										 Compass中建立索引与mirror database change的部件 
										-->
										
												

												
										
										<
										bean id
										=
										"
										compassGps
										"
										 
										class
										=
										"
										org.compass.gps.impl.SingleCompassGps
										"
										  init
										-
										method
										=
										"
										start
										"
										 destroy
										-
										method
										=
										"
										stop
										"
										>
										
												

												    
										<
										property name
										=
										"
										compass
										"
										 ref
										=
										"
										compass
										"
										/>
										
												

												    
										<
										property name
										=
										"
										gpsDevices
										"
										>
										
												

												        
										<
										list
										>
										
												

												            
										<
										bean 
										class
										=
										"
										org.compass.spring.device.hibernate.SpringHibernate3GpsDevice
										"
										>
										
												

												                    
										<
										property name
										=
										"
										name
										"
										 value
										=
										"
										hibernateDevice
										"
										/>
										
												

												                    
										<
										property name
										=
										"
										sessionFactory
										"
										 ref
										=
										"
										sessionFactory
										"
										/>
										
												

												            
										</
										bean
										>
										
												

												        
										</
										list
										>
										
												

												    
										</
										property
										>
										
												

												
										
										</
										bean
										>
										
												

												
												

												
										
										<
										bean id
										=
										"
										compass
										"
										 
										class
										=
										"
										org.compass.spring.LocalCompassBean
										"
										>
										
												

												    
										<!--
										 anontaition式设置 
										-->
										
												

												    
										<
										property name
										=
										"
										classMappings
										"
										>
										
												

												        
										<
										list
										>
										
												

												            
										<
										value
										>
										org.springside.bookstore.model.Book
										</
										value
										>
										
												

												            
										<
										value
										>
										org.springside.bookstore.model.Category
										</
										value
										>
										
												

												        
										</
										list
										>
										
												

												    
										</
										property
										>
										
												

												
												

												    
										<
										property name
										=
										"
										compassConfiguration
										"
										>
										
												

												        
										<
										bean 
										class
										=
										"
										org.compass.annotations.config.CompassAnnotationsConfiguration
										"
										/>
										
												

												    
										</
										property
										>
										
												

												
												

												    
										<
										property name
										=
										"
										compassSettings
										"
										>
										
												

												        
										<
										props
										>
										
												

												            
										<
										prop key
										=
										"
										compass.engine.connection
										"
										>
										
												

												                file:
										//
										${user.home}/springside/compass
										
												

												
										
										            
										</
										prop
										>
										
												

												            
										<
										prop key
										=
										"
										compass.transaction.factory
										"
										>
										
												

												                org.compass.spring.transaction.SpringSyncTransactionFactory
            
										</
										prop
										>
										
												

												        
										</
										props
										>
										
												

												    
										</
										property
										>
										
												

												
												

												    
										<
										property name
										=
										"
										transactionManager
										"
										 ref
										=
										"
										transactionManager
										"
										/>
										
												

												
										
										</
										bean
										>
								
								
								
								

								
3.3 调用CompassGps.index()

   上面的Gps定义只是自启动Mirror Data Change，但索引初始建立就需要靠程序员自己写代码调用CompassGps.index()来完成。

   理论上，因为可以Mirror Data Change，所以索引只需要建立一次即可。如果索引已存在，Compass会对它gracefule override，所谓graceful，就是Compass会现在临时目录存放新的索引，新索引建立完毕后，再一次过覆盖旧索引，重建索引的漫长过程中，旧索引可以正常工作。

   为了方便演示，在Bookstore示例里定义了一个CompassIndexBuilder，实现了Spring的InitializingBean接口，自动在Spring 启动时，启动一条线程进行索引重建。

4 Compass Highlighter

4.1  定义Highlighter 字段

  只需要在AdvancedSearchCommand 上将需要highlighting 的Fields 加入即可。

  searchCommand.setHighlightFields(newString[] {"name"});

4.2 定义高亮的样式

另外，如果对高亮显示的效果不满意的话，可以在applicationContext-compass.xml 文件里配置：

    <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>

     1.在我的项目里，最实际的增强就是Data Mirror功能。

      DataMirror会把数据库的增删改变化实时映射到索引文件中。如果你采用Hibernate等ORM方案，你只须在POJO中进行annotation注释，Compass就会与Hibernate的event机制结合，或者使用AOP的方式，自动在数据库增删改时变更索引；如果你只是采用JDBC，也可以在XML文件配置Table Mapping或ResultSet Mapping，指定version列，Compasss定时进行索引更新。而且，Compass还支持事务，在查询数据库遍历结果集的过程中如果出现异常，会在Index Segments 文件一级进行事务控制。

    如果没有Compass，我们一般会在每天深夜重建一次索引。相比Compass的做法，
    一来反应迟缓，平均延时半天；
    二来效率没有Compass高。如果采用完全重建索引，效率就不用说了。如果进行增量索引，就要增加一个字段，在数据更新时进行特殊的处理，删除时也不能直接删除数据，要等lucene删完索引它才能删除，这样Lucene对应用就非常不透明了。
    三来不支持事务，如果建立索引过程中出现异常，索引文件的状态是不可控的。

    2.Compass对查询的API也作了一定简化，可以考虑使用。

    详见参考文档 10.5 Searching， 简单直接用session find,如

   加入排序，改分词Analyzer，用QueryBuilder()

CompassHits hits = session.createQueryBuilder()
  .queryString("+name:jack +familyName:london")
    .setAnalyzer("an1") // use a different analyzer
  .toQuery()
    .addSort("familyName", CompassQuery.SortPropertyType.STRING)
  .hits();

3. Compass的其他功能，用不用的上要看缘份了： 

   将Lucene的索引文件放入数据库或内存。
   对索引文件根据不同的主题分开subIndex。
   对XML数据进行映射和索引....

4.一段Pragmatic的Compass 搜索程序是这样写的：

1.用annotation将pojo映射为searchable。(详细请看参考文档，如果没有JDK5,可以参考XML式的配置)

2.用Compass提供的Spring2 Schema 来配置Compass与Hibernate,Spring的结合。
   SchemaBase的配置是Spring 2.0的新特征，相比原来的配置代码要少一些。

3.编写搜索结果显示页，将Hits，Command，Page三个变量显示出来。
   Compass的代码重用已经到了Controller一级，只要给Controller 配上compass bean和结果显示的jsp就可以了。Controller提供足够的配置参数，使它完全可以被配置重用，这是个值得SpringSide学习的地方。
   即使你的web应用不是采用Spring MVC，如果没有大规模改写的需求，也可以直接使用，让Struts与Spring MVC并存。

 5.Controller默认的查询需要扩展时

    Contrller默认的查询是在所有fileld里查询关键字，如果需要限定field，加入排序，加入and ,exclude，模糊查询等就不适用了。高级搜索页一般会提供比较多的过滤条件输入框让用户输入，然后在Controller对这些输入条件进行重新组合。

    组合的方式既可以按Lucene的Query语法进行拼SQL式的组合，最后得到"+name:jack -familyName:london" 这样的句子。

    也可以用类似Hibernate Criteria API的方式，如：

    因此，如果你的Lucene应用是面向数据库的，就不妨用一下Compass。
     Compass另一个让我学习的地方是它充分考虑用户客户化的需要，enough thing can be configure ，从而连Controller也可以重用的做法。 

CREATE TABLE `article` (
  `ArticleID` bigint(20) NOT NULL,
  `PersonInfoID` bigint(20) default NULL,
  `ArticleTitle` varchar(200) default NULL,
  `PublishDate` datetime default NULL,
  `Summary` text,
  `Content` longtext,
  `KeyList` text,
  PRIMARY KEY (`ArticleID`),
  KEY `PersonInfoArticle_FK` (`PersonInfoID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

我们希望利用compass对它的ArticleTitle、Summary、Content和KeyList进行全文检索。下面开始行动吧。

2. 首先到http://www.opensymphony.com/compass/download.action 上下载一个compass的发布版，我们下载的是Version 1.0.0的With Dependencies 。这样就可能省去寻找相关信赖库的麻烦了。

3. 将compass1.0解压到一个合适的目录，我们的工作目录是d:\develop\compass1.0

4. 我们是在eclipse环境下实现当前要求的，所以建议你也安装一个eclipse 3.2。

5. 首先我们在eclipse中建立了一个java工程，名为mycompass。

6. 然后我们在工程目录中建立了一个lib目录，用来存放本次工程所需要的所有compass和其它相关的库文件，并将他们设置为当前工程构建路径中需要的库文件。所有这些文件可以在compass的安装目录的lib目录找到。

下面是我们的库文件列表：

7. 建立了Article表的pojo类。

CODE:

package com.darkhe.sample.mycompass;

// Generated 2006-8-2 10:57:06 by Hibernate Tools 3.2.0.beta6a

import java.util.Date;

/**
  * Article generated by hbm2java
  */
public class Article implements java.io.Serializable {

  // Fields  

  private long articleId;

  private Long personInfoId;

  private String articleTitle;

  private Date publishDate;

  private String summary;

  private String content;

  private String keyList;

  // Constructors

  /** default constructor */
  public Article() {
  }

  /** minimal constructor */
  public Article(long articleId) {
  this.articleId = articleId;
  }

  /** full constructor */
  public Article(long articleId, Long personInfoId, String articleTitle,
  Date publishDate, String summary, String content, String keyList) {
  this.articleId = articleId;
  this.personInfoId = personInfoId;
  this.articleTitle = articleTitle;
  this.publishDate = publishDate;
  this.summary = summary;
  this.content = content;
  this.keyList = keyList;
  }

  // Property accessors
  public long getArticleId() {
  return this.articleId;
  }

  public void setArticleId(long articleId) {
  this.articleId = articleId;
  }

  public Long getPersonInfoId() {
  return this.personInfoId;
  }

  public void setPersonInfoId(Long personInfoId) {
  this.personInfoId = personInfoId;
  }

  public String getArticleTitle() {
  return this.articleTitle;
  }

  public void setArticleTitle(String articleTitle) {
  this.articleTitle = articleTitle;
  }

  public Date getPublishDate() {
  return this.publishDate;
  }

  public void setPublishDate(Date publishDate) {
  this.publishDate = publishDate;
  }

  public String getSummary() {
  return this.summary;
  }

  public void setSummary(String summary) {
  this.summary = summary;
  }

  public String getContent() {
  return this.content;
  }

  public void setContent(String content) {
  this.content = content;
  }

  public String getKeyList() {
  return this.keyList;
  }

  public void setKeyList(String keyList) {
  this.keyList = keyList;
  }

}

[Copy to clipboard]

8. 建立hibernate的pojo到数据表映射文件

CODE:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"[url]http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd[/url]">
<!-- Generated 2006-8-2 10:57:07 by Hibernate Tools 3.2.0.beta6a -->
<hibernate-mapping>
  <class name="com.darkhe.sample.mycompass.Article" table="article" catalog="freedom">
    <comment></comment>
    <id name="articleId" type="long">
        <column name="ArticleID" />
        <generator class="assigned" />
    </id>
    <property name="personInfoId" type="java.lang.Long">
        <column name="PersonInfoID">
          <comment></comment>
        </column>
    </property>
    <property name="articleTitle" type="string">
        <column name="ArticleTitle" length="200">
          <comment></comment>
        </column>
    </property>
    <property name="publishDate" type="timestamp">
        <column name="PublishDate" length="19">
          <comment></comment>
        </column>
    </property>
    <property name="summary" type="string">
        <column name="Summary" length="65535">
          <comment></comment>
        </column>
    </property>
    <property name="content" type="string">
        <column name="Content">
          <comment></comment>
        </column>
    </property>
    <property name="keyList" type="string">
        <column name="KeyList" length="65535">
          <comment></comment>
        </column>
    </property>
  </class>
</hibernate-mapping>

[Copy to clipboard]

9. 开始配置compass，首先是compass的系统配置文件 mycompass.cfg.xml

CODE:

<?xml version="1.0" encoding="UTF-8"?>
<compass-core-config
xmlns="[url]http://www.opensymphony.com/compass/schema/core-config[/url]"
xmlns:xsi="[url]http://www.w3.org/2001/XMLSchema-instance[/url]"
xsi:schemaLocation="[url]http://www.opensymphony.com/compass/schema/core-config[/url]
      [url]http://www.opensymphony.com/compass/schema/compass-core-config.xsd[/url]">

<compass name="default"> <!—这个名字随你取了，但它是必须的-->

<connection>
  <file path="target" /> <!—这里是索引文件的存放路径，我们设置的是当前工程的相对路径target-?
</connection>

<searchEngine>
  <!-- 因是使用自己的分词算法，所以这里的类型必须是CustomAnalyzer -->
      <analyzer name="MMAnalyer" type="CustomAnalyzer" analyzerClass="jeasy.analysis.MMAnalyzer">
        <stopWords>
            <stopWord value="test" />
        </stopWords>
      </analyzer>
    </searchEngine>

</compass>
</compass-core-config>

[Copy to clipboard]

在上面的配置中，我们使用的我们选用的一个中文分词算法库，你可以用compass自带的。具体compass提供了哪些分词算法，请查阅compass的手册。

10. 然后是mycompass.cmd.xml

CODE:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE compass-core-meta-data PUBLIC
  "-//Compass/Compass Core Meta Data DTD 1.0//EN"
  "[url]http://www.opensymphony.com/compass/dtd/compass-core-meta-data.dtd[/url]">

<compass-core-meta-data>

<!-- 定义一个实体和字段组-->
  <meta-data-group id="mycompass" displayName="My Compass">
 
    <description>Mycompass Meta Data</description>    
    <uri>[url]http://com/darkhe/sample/mycompass</uri>[/url]
 
   
<!-- 申明所有需要检索的实体-->    
    <alias id="Article" displayName="Article">
        <description>Article alias</description>
        <uri>[url]http://com/darkhe/sample/mycompass/alias/Article</uri>[/url]
        <name>Article</name>
    </alias>
   
<!-- 申明所有需要检索的属性或者字段，而不管这些属性或者字段是哪个实体的 -->    
    <meta-data id="ArticleTitle" displayName="ArticleTitle">
        <description>ArticleTitle</description>
        <uri>[url]http://com/darkhe/sample/mycompass/alias/ArticleTitle</uri>[/url]
        <name>ArticleTitle</name>
    </meta-data>
   
    <meta-data id="PublishDate" displayName="PublishDate">
        <description>PublishDate</description>
        <uri>[url]http://com/darkhe/sample/mycompass/alias/PublishDate</uri>[/url]
        <name format="yyyy-MM-dd hh:mm:ss">date</name>
    </meta-data>
   
    <meta-data id="Summary" displayName="Summary">
        <description>Summary</description>
        <uri>[url]http://com/darkhe/sample/mycompass/alias/Summary</uri>[/url]
        <name>Summary</name>
    </meta-data>
   
    <meta-data id="Content" displayName="Content">
        <description>Content</description>
        <uri>[url]http://com/darkhe/sample/mycompass/alias/Content</uri>[/url]
        <name>Content</name>
    </meta-data>

    <meta-data id="KeyList" displayName="KeyList">
        <description>KeyList</description>
        <uri>[url]http://com/darkhe/sample/mycompass/alias/KeyList</uri>[/url]
        <name>KeyList</name>
    </meta-data>    
               
  </meta-data-group>
 
</compass-core-meta-data>

[Copy to clipboard]

11. 再是mycompass.cpm.xml

CODE:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE compass-core-mapping PUBLIC
  "-//Compass/Compass Core Mapping DTD 1.0//EN"
  "[url]http://www.opensymphony.com/compass/dtd/compass-core-mapping.dtd[/url]">

<!-- 这里的包名必须和pojo的包名一致 -->
<compass-core-mapping package="com.darkhe.sample.mycompass">

<!-- 定义实体及其字段的对应关系 -->

<!-- 注意实体及其字段的名称的大小写应当与pojo对象一致，而不是与数据库一致
关于pojo与数据库的对应表的一致性关系由hibernate的映谢文件定义，而不是这个文件
当前映射文件只定义compass与hibernate的关系 -->

<class name="Article" alias="${mycompass.Article}">
<id name="ArticleId" />

<property name="ArticleTitle">
  <meta-data>${mycompass.ArticleTitle}</meta-data>
</property>

<property name="PublishDate">
  <meta-data>${mycompass.PublishDate}</meta-data>
</property>

<property name="Summary">
  <meta-data>${mycompass.Summary}</meta-data>
</property>

<property name="Content">
  <meta-data>${mycompass.Content}</meta-data>
</property>

<property name="KeyList">
  <meta-data>${mycompass.KeyList}</meta-data>
</property>
</class>
</compass-core-mapping>

[Copy to clipboard]

12. log4j.properties

CODE:

log4j.rootLogger=WARN, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p %c - %m%n
log4j.logger.org.compass=INFO

[Copy to clipboard]

13. jdbc.properties

CODE:

# Properties file with JDBC-related settings.
# Applied by PropertyPlaceholderConfigurer from "applicationContext-*.xml".
# Targeted at system administrators, to avoid touching the context XML files.
jdbc.driverClassName=com.mysql.jdbc.Driver
#jdbc.driverClassName=org.hsqldb.jdbcDriver
#jdbc.url=jdbc:hsqldb:hsql://localhost:9001
jdbc.url=jdbc:mysql://localhost:3306/testdb
jdbc.username=test
jdbc.password=test
# Property that determines the Hibernate dialect
# (only applied with "applicationContext-hibernate.xml")
#hibernate.dialect=org.hibernate.dialect.HSQLDialect
hibernate.dialect=org.hibernate.dialect.MySQLDialect

[Copy to clipboard]

14. 最后是applicationContext-hibernate.xml，这里集中配置了compass如何与spring与hibernate结合的。

CODE:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "[url]http://www.springframework.org/dtd/spring-beans.dtd[/url]">

<!--
- Application context definition for Petclinic on Hibernate.
-->
<beans>
<!-- ========================= RESOURCE DEFINITIONS ========================= -->
<!-- Configurer that replaces ${...} placeholders with values from a properties file -->
<!-- (in this case, JDBC-related settings for the dataSource definition below) -->
<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location">
  <value>classpath:jdbc.properties</value>
</property>
</bean>
<!-- Local DataSource that works in any environment -->
<!-- Note that DriverManagerDataSource does not pool; it is not intended for production -->
<!-- See JPetStore for an example of using Commons DBCP BasicDataSource as alternative -->
<!-- See Image Database for an example of using C3P0 ComboPooledDataSource as alternative -->
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
  <value>${jdbc.driverClassName}</value>
</property>
<property name="url">
  <value>${jdbc.url}</value>
</property>
<property name="username">
  <value>${jdbc.username}</value>
</property>
<property name="password">
  <value>${jdbc.password}</value>
</property>
</bean>
<!-- JNDI DataSource for J2EE environments -->
<!--
<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName"><value>java:comp/env/jdbc/petclinic</value></property>
</bean>
-->
<!-- Hibernate SessionFactory -->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
  <ref local="dataSource" />
</property>
<property name="mappingResources">
  <list>
  <value>
  com/darkhe/sample/mycompass/Article.hbm.xml <!-- 这里是hibernate里需要的数据映射文件 -->
  </value>
  </list>
</property>
<property name="hibernateProperties">
  <props>
  <prop key="hibernate.dialect">
  ${hibernate.dialect}
  </prop>
  <prop key="hibernate.show_sql">false</prop>
  <prop key="hibernate.generate_statistics">true</prop>
  </props>
</property>
<property name="eventListeners">
  <map>
  <entry key="merge">
  <bean
    class="org.springframework.orm.hibernate3.support.IdTransferringMergeEventListener" />
  </entry>
  </map>
</property>
</bean>

<!-- COMPASS START -->
<bean id="compass" class="org.compass.spring.LocalCompassBean">
<property name="resourceLocations">
  <list>
  <value>classpath:mycompass.cmd.xml</value> <!-- 这里是compass所需要的两个关于数据项的配置文件 -->
  <value>classpath:mycompass.cpm.xml</value>
  </list>
</property>
<property name="configLocation">
  <value>classpath:mycompass.cfg.xml</value> <!-- 这里是compass的系统配置文件的路径 -->
</property>
<!--       <property name="compassSettings">
  <props>
  <prop key="compass.engine.connection">file://d:/target</prop>
  <prop key="compass.transaction.factory">org.compass.spring.transaction.SpringSyncTransactionFactory</prop>
  </props>
  </property>-->

<property name="transactionManager">
  <ref local="transactionManager" />
</property>
</bean>

<bean id="hibernateGpsDevice"
class="org.compass.spring.device.hibernate.SpringHibernate3GpsDevice">
<property name="name">
  <value>hibernateDevice</value>
</property>
<property name="sessionFactory">
  <ref local="sessionFactory" />
</property>
</bean>
<bean id="compassGps" class="org.compass.gps.impl.SingleCompassGps"
init-method="start" destroy-method="stop">
<property name="compass">
  <ref bean="compass" />
</property>
<property name="gpsDevices">
  <list>
  <bean
  class="org.compass.spring.device.SpringSyncTransactionGpsDeviceWrapper">
  <property name="gpsDevice" ref="hibernateGpsDevice" />
  </bean>
  </list>
</property>
</bean>
<!-- COMPASS END -->
</beans>

[Copy to clipboard]

15. 注意上面的所以配置文件，根据我们上面的配置，都应当放到classpath的根路径。
16. 建立工具类，用来进行spring引擎的初始化工作。

CODE:

/**
* <p>@(#) IOC.java 2006-2-1 0:08:23</p>
* <p>Copyright (c) 2005-2006 ???????????????????</p>
*/
package com.darkhe.sample.mycompass;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
*
*
* @version 1.0 2006-2-1
* @author darkhe
*/
public class IOC {
private static ApplicationContext context = null;

private static boolean isInit = false;

private IOC() {
super();
}

private static void init() {

if (isInit == false) {
  String[] xmlfilenames = { "applicationContext-hibernate.xml" };

  context = new ClassPathXmlApplicationContext(xmlfilenames);

  isInit = true;
}
}

/**
*
* @return
*/
public static ApplicationContext getContext() {
if (context == null || isInit == false) {
  init();
}
return context;
}

/**
*
* @param name
* @return
*/
public static Object getBean(String name) {
return getContext().getBean(name);
}

}

[Copy to clipboard]

17. 建立索引程序，用来数据库中的建立索引

CODE:

/*
* Copyright (c) 2005-2006
* ChongQing Man-Month Technology Development Co. ,Ltd
*
* ---------------------------------------------------------------------------------
* @(#) Inder.java, 2006-8-1 下午09:01:14
* ---------------------------------------------------------------------------------
*/
package com.darkhe.sample.mycompass;

import java.io.FileNotFoundException;

import org.compass.gps.CompassGps;
import org.springframework.context.ApplicationContext;

/**
* @author darkhe
*
*/
public class Indexer {

/**
* @param args
* @throws FileNotFoundException
*/
public static void main(String[] args) throws FileNotFoundException {

  // 加裁自定义词典
DictionaryUtils.loadCustomDictionary();

ApplicationContext context = IOC.getContext();

// 得到spring环境中已经配置和初始化好的compassGps对象
CompassGps compassGps = (CompassGps) context.getBean("compassGps");
// 调用index方法建立索引
compassGps.index();

}

}

[Copy to clipboard]

18. 建立搜索程序，检证compass的应用。

CODE:

/*
* Copyright (c) 2005-2006
* ChongQing Man-Month Technology Development Co. ,Ltd
*
* ---------------------------------------------------------------------------------
* @(#) Searcher.java, 2006-8-1 下午09:36:29
* ---------------------------------------------------------------------------------
*/

package com.darkhe.sample.mycompass;

import java.io.FileNotFoundException;

import org.compass.core.Compass;
import org.compass.core.CompassCallbackWithoutResult;
import org.compass.core.CompassException;
import org.compass.core.CompassHits;
import org.compass.core.CompassSession;
import org.compass.core.CompassTemplate;
import org.compass.core.Resource;
import org.springframework.context.ApplicationContext;

/**
* @author darkhe
*
*/
public class Searcher {

/**
* @param args
* @throws FileNotFoundException
*/
public static void main(String[] args) throws FileNotFoundException {

// 加裁自定义词典
DictionaryUtils.loadCustomDictionary();

ApplicationContext context = IOC.getContext();

Compass compass = (Compass) context.getBean("compass");

CompassTemplate template = new CompassTemplate(compass);

template.execute(new CompassCallbackWithoutResult() {
  protected void doInCompassWithoutResult(CompassSession session)
  throws CompassException {
  CompassHits hits = session.find("大头人");

  System.out.println("Found [" + hits.getLength()
    + "] hits for [大头人] query");
  System.out
    .println("======================================================");
  for (int i = 0; i < hits.getLength(); i++) {
  print(hits, i);
  }

  hits.close();
  }
});

}

public static void print(CompassHits hits, int hitNumber) {
Object value = hits.data(hitNumber);
Resource resource = hits.resource(hitNumber);
System.out.println("ALIAS [" + resource.getAlias() + "] SCORE ["
  + hits.score(hitNumber) + "]");
System.out.println(":::: " + value);
System.out.println("");
}
}

[Copy to clipboard]

19. 工具类DictionaryUtils是用来管理我们自己采用的中文分词算法的加载自定义词典的。

CODE:

/**
* Copyright (c) 2005-2006 重庆人月科技发展有限公司
*
* ------------------------------------------------------------------------------
* @(#) DictionaryUtils.java, 2006-8-2 下午04:55:22
* ------------------------------------------------------------------------------
*/
package com.darkhe.sample.mycompass;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;

import jeasy.analysis.MMAnalyzer;

/**
*
* @author darkhe
* @version 1.0.0
*/
public class DictionaryUtils {
// 静态变量
private static boolean isInit = false;

// 静态初始化

// 静态方法
public static void loadCustomDictionary() throws FileNotFoundException {

if (isInit == false) {

  // 添加我们自己的词典
  FileReader fr = new FileReader(new File("dict.txt"));
  MMAnalyzer.addDictionary(fr);
 
  //System.out.println("添加我们自己的词典");

  isInit = true;
}
}
}

[Copy to clipboard]

20. 执行Indexer，再执行Seracher后控制台信息如下：

Found [1] hits for [大头人] query
================================================
ALIAS [Article] SCORE [0.3988277]
:::: com.darkhe.sample.mycompass.Article@bla4e2

具体结果和你的数据表中的内容有别。

21. 这样，我们便实现了如何利用compass构建我们自己的搜索引擎的一个简单实现。