compass入门例子1

在新架构中打算选择Compass或Hibernate Search作为搜索引擎框架，比较后，感觉Hibernate Search上还是没有Compass成熟，另外考虑到后期对网页的爬取及搜索需求，决定还是基于Compass来作为架构缺省的搜索引擎。网上关于Compass的文档很多，但说得相对完整其详细的入门文档基本上没有，Compass的官方文档倒是说得很详细，但是例子一塌糊涂，存在很大问题。记录一下搭建的过程，作为入门的指南。

Compass 通过OSEM(Object/Search Engine Mapping)允许把应用对象的领域模型映射到搜索引擎，最终通过访问common meta data来达到访问对象的目的。

1、几个核心概念
1.1、annotation vs. xml配置文件

Compass的配置文件主要分成三类：

第一类：*.cmd.xml文件*

.cmd.xml文件是对common meta data进行定义，定义了最终搜索的结果中的最基本的元数据。

第二类：*.cpm.xml文件

*.cpm.xml是Object/Search Engine Mapping,提供了POJO到common meta data的映射。

第三类：*.cfg.xml文件

Compass的*.cfg.xml定义了Compass的Index存放路径、搜索引擎分词等相关信息。

与采用xml配置文件相比较，采用Annonation方式还是相对简单，尤其是采用Spring时候，不用写*.cmd.xml文件、*.cpm.xml、*.cfg.xml，相对很方便，而且不像Hibernate的Annonation很多，Compass的Annonation的核心标注只有@Searchable、@SearchableId、@SearchableProperty、@SearchableComponent个，很容易记忆。因此推荐使用Annonation方式

１.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）。

1.3、Compass与Spring集成

Compass已经对对spring集成做了很好的封装，同时与Spring对Hibernate的支持类似，Compass也提供了CompassTemplate来简化诸如对Session、Transaction、Exception等操作，尽量充分使用此工具，可以有效提高效率。例如：

CompassTemplate ct = (CompassTemplate) context.getBean("compassTemplate");

Article article = new Article();
article.setTitle("Compass Test");
article.setPublishDate(new Date());
article.setAuthor(1);

ct.save(article); //存储对象需要索引的数据到Compass的索引中。

2、软件环境
Spring ：2.5

Compas：1.2.1

Hibernate：3.2.5

Mysql ：5.0.5

3、数据库脚本
CREATE TABLE `article` (

`Id` int(11) NOT NULL auto_increment,

`title` varchar(40) NOT NULL default '',

`author` int(11) default '0',

`publish_date` date NOT NULL default '0000-00-00',

PRIMARY KEY (`Id`) ) TYPE=MyISAM;

CREATE TABLE `author` (

`Id` int(11) NOT NULL auto_increment,

`username` varchar(20) NOT NULL default '',

`password` varchar(20) NOT NULL default '',

`age` smallint(6) default '0',

PRIMARY KEY (`Id`) ) TYPE=MyISAM;
4、测试用例
从测试用例讲起比较容易把关系理清楚，不然一堆术语和概念很让人晕乎。

import org.apache.log4j.Logger;
import java.util.Date;

import junit.framework.TestCase;

import org.compass.core.Compass;
import org.compass.core.CompassDetachedHits;
import org.compass.core.CompassHit;
import org.compass.core.CompassHits;
import org.compass.core.CompassSession;
import org.compass.core.CompassTemplate;
import org.compass.core.CompassTransaction;
import org.compass.core.support.search.CompassSearchCommand;
import org.compass.core.support.search.CompassSearchResults;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.mobilesoft.esales.dao.hibernate.ArticleDAO;
import com.mobilesoft.esales.dao.hibernate.AuthorDAO;
import com.mobilesoft.esales.model.Article;
import com.mobilesoft.esales.model.Author;
import com.mobilesoft.framework.search.service.CompassSearchService;

/**
* Compass服务使用的测试用例
*
* @author [e-mail]
*
*/

public class TestCompass extends TestCase {

private static final Logger logger = Logger.getLogger(TestCompass.class);

private static ClassPathXmlApplicationContext context = null;
private static CompassTemplate ct;

static {
context = new ClassPathXmlApplicationContext(new String[] {
"applicationContext.xml", "applicationContext-resources.xml",
"applicationContext-dao.xml", "applicationContext-service.xml",
"applicationContext-compass.xml" });
ct = (CompassTemplate) context.getBean("compassTemplate");
}

protected void setUp() throws Exception {

}

/**
* 插入测试数据
*/
public void testInsert() {

ArticleDAO articleDao = (ArticleDAO) context.getBean("articleDAO");
AuthorDAO authorDao = (AuthorDAO) context.getBean("authorDAO");
Article article = new Article();
Author author = new Author();
author.setAge((short) 27);
author.setUsername("liangchuan");
author.setPassword("liangchuan");
article.setTitle("Compass Test");
article.setPublishDate(new Date());
article.setAuthor(1);
authorDao.save(author);
articleDao.save(article);
ct.save(article);
ct.save(author);
}

/**
* 用于测试使用CompassTransaction事务方式
*/
public void testTransactionalFind() {

Compass compass = ct.getCompass();
CompassSession session = compass.openSession();
CompassTransaction tx = null;
try {
tx = session.beginTransaction();
CompassHits hits = session.find("Compass*");

logger.error("testTransactionalFind() - CompassHits hits="
+ hits.getLength());
for (int i = 0; i < hits.getLength(); i++) {
Object hit = hits.data(i);
if (hit instanceof Article) {
Article item = (Article) hit;
logger.error("testTransactionalFind() - article hits="
+ item.getTitle());
} else if (hit instanceof Author) {
Author item = (Author) hit;
logger.error("testTransactionalFind() - author hits="
+ item.getUsername());
} else {
logger.error("testTransactionalFind() - error hits=");
}
}
tx.commit();
} catch (Exception e) {
if (tx != null) {
tx.rollback();
}
} finally {
session.close();
}
}

/**
* 用于演示CompassDetachedHits的使用。
* 由于CompassTempalte得到的结果集必须在transactionalcontext中才能使用，
* 因此必须使用CompassDetachedHits方式测试CompassDetachedHits方式
*/
public void testDetachedFind() {

// 由于CompassTempalte得到的结果集必须在transactional
// context中才能使用，因此必须使用CompassDetachedHits方式
// 测试CompassDetachedHits方式
CompassDetachedHits hits = ct.findWithDetach("Compass*");

logger.error("testDetachedFind() - CompassHits hits="
+ hits.getLength());
for (int i = 0; i < hits.getLength(); i++) {
Object hit = hits.data(i);
if (hit instanceof Article) {
Article item = (Article) hit;
logger.error("testDetachedFind() - article hits="
+ item.getTitle());
} else if (hit instanceof Author) {
Author item = (Author) hit;
logger.error("testDetachedFind() - author hits="
+ item.getUsername());
} else {
logger.error("testDetachedFind() - error hits=");
}
}

}

/**
* 用于演示com.mobilesoft.framework.search.service.CompassSearchService的使用
*
*/
class CompassSearch extends CompassSearchService{
CompassSearch(){
Compass compass = ct.getCompass();
CompassSession session = compass.openSession();
CompassTransaction tx = null;

try {
tx = session.beginTransaction();
CompassSearchCommand command = new CompassSearchCommand();
command.setQuery("Compass");
CompassSearchResults results= performSearch(command,session);
logger.error("CompassSearch() - CompassHit TotalHits value=" +results.getTotalHits());

for (int i = 0; i < results.getHits().length; i++) {
CompassHit hits=results.getHits()[i];
Object hit=hits.getData();
logger.error("CompassSearch() - CompassHit hit=" + hit); //$NON-NLS-1$

if (hit instanceof Article) {
Article item = (Article) hit;
logger.error("testCompassSearchService() - article hits="
+ item.getTitle());
} else if (hit instanceof Author) {
Author item = (Author) hit;
logger.error("testCompassSearchService() - author hits="
+ item.getUsername());
} else {
logger.error("testCompassSearchService() - error hits=");
}

tx.commit();
}
} catch (Exception e) {
if (tx != null) {
tx.rollback();
}
} finally {
session.close();
}

}

}
public void testCompassSearchService() {
new CompassSearch();
}

protected void tearDown() throws Exception {
}
}

5、配置文件
applicationContext-compass.xml
<?xml version="1.0"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"
"http://www.springframework.org/dtd/spring-beans-2.0.dtd">
<beans default-lazy-init="true">
<bean id="compassTemplate" class="org.compass.core.CompassTemplate">
<property name="compass" ref="compass"/>
</bean>
<bean id="annotationConfiguration"
class="org.compass.annotations.config.CompassAnnotationsConfiguration">
</bean>
<bean id="compass" class="org.compass.spring.LocalCompassBean">
<property name="classMappings">
<list>
<value>com.mobilesoft.esales.model.Article</value>
<value>com.mobilesoft.esales.model.Author</value>
</list>
</property>
<property name="compassConfiguration" ref="annotationConfiguration"/>

<property name="compassSettings">
<props>
<prop key="compass.engine.connection"> file://compass </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="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>
<bean
class="org.compass.spring.device.SpringSyncTransactionGpsDeviceWrapper">
<property name="gpsDevice" ref="hibernateGpsDevice"/>
</bean>
</list>
</property>
</bean>
<bean id="compassSearchService" class="com.mobilesoft.framework.search.service.CompassSearchService">
<property name="compass" ref="compass"/>
<property name="pageSize" value="15"/>
</bean>

<!-- 定时重建索引(利用quartz)或随Spring ApplicationContext启动而重建索引 -->
<bean id="compassIndexBuilder" class="com.mobilesoft.framework.search.service.CompassIndexBuilder" lazy-init="false">
<property name="compassGps" ref="compassGps"/>
<property name="buildIndex" value="false"/>
<property name="lazyTime" value="10"/>
</bean>


</beans>
applicationContext-dao.xml、applicationContext-service.xml、applicationContext-resources.xml等略去。

6、Service层(参考了SpringSide实现)
AdvancedSearchCommand.java

package com.mobilesoft.framework.search.service;

import java.util.HashSet;
import java.util.Set;

import org.apache.commons.lang.StringUtils;
import org.compass.core.CompassQuery.SortDirection;
import org.compass.core.CompassQuery.SortPropertyType;
import org.compass.core.support.search.CompassSearchCommand;

import org.springframework.util.Assert;

public class AdvancedSearchCommand extends CompassSearchCommand {

/**
* 封装基于Compass 的排序参数.
*/
class CompassSort {

private String name;

private SortPropertyType type;

private SortDirection direction;

public CompassSort() {
}

public CompassSort(String sortParamName, String paramType,
boolean isAscend) {
Assert.isTrue(StringUtils.isNotBlank(sortParamName));
setName(sortParamName);

if ("int".equalsIgnoreCase(paramType)) {
setType(SortPropertyType.INT);
} else if ("float".equalsIgnoreCase(paramType)) {
setType(SortPropertyType.FLOAT);
} else if ("string".equalsIgnoreCase(paramType)) {
setType(SortPropertyType.STRING);
} else {
setType(SortPropertyType.AUTO);
}

if (isAscend) {
setDirection(SortDirection.AUTO);
} else {
setDirection(SortDirection.REVERSE);
}
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public SortPropertyType getType() {
return type;
}

public void setType(SortPropertyType type) {
this.type = type;
}

public SortDirection getDirection() {
return direction;
}

public void setDirection(SortDirection direction) {
this.direction = direction;
}
}

/**
* 搜索结果排序表.
*/
private Set<CompassSort> sortMap = new HashSet<CompassSort>();

private String[] highlightFields;

/**
* @param paramType 现定义了三种类型： int string 以及 float。<br>
* 除去这三种外，其他会被自动定义为SortPropertyType.AUTO 具体的可见{@link org.compass.core.CompassQuery.SortPropertyType}
* @param isAscend 顺序还是倒序排序
* @see org.compass.core.CompassQuery.SortPropertyType#AUTO
* @see org.compass.core.CompassQuery.SortPropertyType#INT
* @see org.compass.core.CompassQuery.SortPropertyType#STRING
* @see org.compass.core.CompassQuery.SortPropertyType#FLOAT
* @see org.compass.core.CompassQuery.SortDirection#AUTO
* @see org.compass.core.CompassQuery.SortDirection#REVERSE
*/
public void addSort(String sortParamName, String paramType, boolean isAscend) {
this.sortMap.add(new CompassSort(sortParamName, paramType, isAscend));
}

public Set<CompassSort> getSortMap() {
return sortMap;
}

public void setSortMap(Set<CompassSort> sortMap) {
this.sortMap = sortMap;
}

public String[] getHighlightFields() {
return highlightFields;
}

public void setHighlightFields(String[] highlightFields) {
this.highlightFields = highlightFields;
}
}

CompassIndexBuilder.java

package com.mobilesoft.framework.search.service;

import org.apache.log4j.Logger;
import org.compass.gps.CompassGps;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.util.Assert;