`

Compass实现站内全文搜索(二)

 
阅读更多
接下来是要建立搜索的服务类
    import java.util.ArrayList;  
    import java.util.HashMap;  
    import java.util.List;  
    import java.util.Map;  
    import org.compass.core.Compass;  
    import org.compass.core.CompassCallback;  
    import org.compass.core.CompassException;  
    import org.compass.core.CompassHighlighter;  
    import org.compass.core.CompassHits;  
    import org.compass.core.CompassQuery;  
    import org.compass.core.CompassSession;  
    import org.compass.core.CompassTemplate;  
    import org.compass.core.CompassTransaction;  
    import cn.rgcenter.entity.Article;  
      
    public class SearchServiceBean {  
      
        private Compass compass;  
        /** 索引查询 * */  
        public Map find(final String keywords, final String type, final int start,  
                final int end) {  
            CompassTemplate ct = new CompassTemplate(compass);  
            return ct.execute(new CompassCallback<Map>() {  
      
                public Map doInCompass(CompassSession session)  
                        throws CompassException {  
                    List result = new ArrayList();  
                    int totalSize = 0;  
                    Map container = new HashMap();  
                    CompassQuery query = session.queryBuilder().queryString(  
                            keywords).toQuery();  
                    CompassHits hits = query.setAliases(type).hits();  
                    totalSize = hits.length();  
                    container.put("size", totalSize);  
                    int max = 0;  
                    if (end < hits.length()) {  
                        max = end;  
                    } else {  
                        max = hits.length();  
                    }  
      
           if(type.equals("article")){  
                        for (int i = start; i < max; i++) {  
                            Article article = (Article) hits.data(i);  
                            String title = hits.highlighter(i).fragment("title");  
                            if (title != null) {  
                                article.setTitle(title);  
                            }  
                            String content = hits.highlighter(i).setTextTokenizer(  
                                    CompassHighlighter.TextTokenizer.AUTO)  
                                    .fragment("content");  
                            if (content != null) {  
      
                                article.setContent(content);  
                            }  
                            result.add(article);  
                        }  
                    }  
                    container.put("result", result);  
                    return container;  
                }  
            });  
        }  
      
        public Compass getCompass() {  
            return compass;  
        }  
      
        public void setCompass(Compass compass) {  
            this.compass = compass;  
        }  
      
    }  


索引的查询主要是根据传过来的参数,关键字keywords,是搜索的关键字,类型type,先判断是不是要搜索文章,因为一般来说,页面的搜索引擎不单单只搜索文章一个实体.
至于int 和end是为了分页取出部分结果的.
String title = hits.highlighter(i).fragment("title");这段是检索titile这个属性有没有出现搜索的关键字,有就将它高亮(其实就是在关键字前后加个<font></font>的html标记设置颜色,等下可以看到在配置文件里可以自由设置高亮的颜色).
String content = hits.highlighter(i).setTextTokenizer(
CompassHighlighter.TextTokenizer.AUTO)
.fragment("content");

这段代码和上面的title具有一样的一样的功能,另外还多了个很重要的功能,自动选择正文中最匹配关键字的内容中的一部分输出。因为很多时候一篇文章几千字,我们只想显示有关键字的那部分的摘要,这时候这个功能就很方便.


这之后还要写一个建立索引的服务类,让服务器启动的时候或者定时重建索引.
    import org.compass.gps.CompassGps;  
    import org.springframework.beans.factory.InitializingBean;  
      
    public class CompassIndexBuilder implements InitializingBean {    
          
        // 是否需要建立索引,可被设置为false使本Builder失效.     
        private boolean buildIndex = false;     
        
        // 索引操作线程延时启动的时间,单位为秒     
        private int lazyTime = 10;     
        
        // Compass封装     
        private CompassGps compassGps;     
        
        // 索引线程     
        private Thread indexThread = new Thread() {     
        
            @Override    
            public void run() {     
                try {     
                    Thread.sleep(lazyTime * 1000);     
                    System.out.println("begin compass index...");     
                    long beginTime = System.currentTimeMillis();     
                    // 重建索引.     
                    // 如果compass实体中定义的索引文件已存在,索引过程中会建立临时索引,     
                    // 索引完成后再进行覆盖.     
                    compassGps.index();     
                    long costTime = System.currentTimeMillis() - beginTime;     
                    System.out.println("compss index finished.");     
                    System.out.println("costed " + costTime + " milliseconds");     
                } catch (InterruptedException e) {     
                    e.printStackTrace();     
                }     
            }     
        };     
        
        /**   
         * 实现<code>InitializingBean</code>接口,在完成注入后调用启动索引线程. 
         */    
        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;     
        }     
    }   




实现了spring的InitializingBean接口,让服务器启动,bean初始化的时候去建立索引


剩下的就是配置文件了
    <?xml version="1.0" encoding="UTF-8"?>  
      
    <beans xmlns="http://www.springframework.org/schema/beans"  
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
        xmlns:aop="http://www.springframework.org/schema/aop"  
        xmlns:tx="http://www.springframework.org/schema/tx"  
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
                http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd  
                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
      
        <bean id="annotationConfiguration"  
            class="org.compass.annotations.config.CompassAnnotationsConfiguration">  
        </bean>  
      
        <!-- compass Bean  -->  
        <bean id="compass" class="org.compass.spring.LocalCompassBean">  
            <property name="compassConfiguration"  
                ref="annotationConfiguration" />  
            <!-- 数据索引存储位置 -->  
            <property name="connection">  
                <value>/compass/indexes</value>  
            </property>  
            <property name="transactionManager" ref="transactionManager" />  
            <property name="compassSettings">  
                <props>  
                    <prop key="compass.transaction.factory">  
                        org.compass.spring.transaction.SpringSyncTransactionFactory  
                    </prop>  
                  
                    <prop  
                        key="compass.engine.highlighter.default.formatter.simple.pre">  
                        <![CDATA[<span style='background-color:yellow;color:red;'>]]>  
                    </prop>  
                    <prop  
                        key="compass.engine.highlighter.default.formatter.simple.post">  
                        <![CDATA[</span>]]>  
                    </prop>  
        <!--定义分词器-->            
    <prop  
                        key="compass.engine.analyzer.default.type">  
                        org.mira.lucene.analysis.IK_CAnalyzer  
                    </prop>  
                </props>  
            </property>  
            <property name="classMappings">  
                <list>  
                  
                    <value>cn.rgcenter.entity.Article</value>  
                </list>  
            </property>  
        </bean>  
      
        <!--hibernate驱动-->  
        <bean id="hibernateGpsDevice"  
            class="org.compass.spring.device.hibernate.dep.SpringHibernate3GpsDevice">  
            <property name="name">  
                <value>hibernateDevice</value>  
            </property>  
            <property name="sessionFactory" ref="sessionFactory" />  
            <property name="mirrorDataChanges">  
                <value>true</value>  
            </property>  
        </bean>  
      
        <!-- 数据库中的数据变化后同步更新索引 -->  
        <bean id="hibernateGps"  
            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模版 -->  
        <bean id="compassTemplate"  
            class="org.compass.core.CompassTemplate">  
            <property name="compass" ref="compass" />  
        </bean>  
      
        <!-- 定时重建索引(利用quartz)或随Spring ApplicationContext启动而重建索引 -->  
        <bean id="compassIndexBuilder"  
            class="cn.rgcenter.compass.service.CompassIndexBuilder"  
            lazy-init="false">  
            <property name="compassGps" ref="hibernateGps" />  
            <property name="buildIndex" value="true" />  
            <property name="lazyTime" value="5" />  
        </bean>  
      
        <!-- 搜索引擎服务类 -->  
        <bean id="searchService"  
            class="cn.rgcenter.compass.service.SearchServiceBean">  
            <property name="compass">  
                <ref bean="compass" />  
            </property>  
        </bean>  
      
        <!-- 搜索引擎Action -->  
        <bean id="searchAction" class="cn.rgcenter.action.SearchAction">  
            <property name="searchService">  
                <ref bean="searchService" />  
            </property>  
        </bean>  
      
    </beans>  

于action就不列出代码了,很简单了,只需要传搜索方法的那几个参数过去就可以了.

最后看一下搜索结果示例图:
分享到:
评论

相关推荐

    S2SH+compass (实现站内全文检索)

    标题中的"S2SH+compass"指的是一个基于Struts2(S),Spring(S)和Hibernate(H)这三种开源框架的Java Web应用,再加上Compass搜索引擎来实现站内全文检索的功能。这种组合常用于构建复杂的企业级应用,因为它提供...

    ssh+compass实现站内搜索分页.rar

    通过以上步骤,你可以在SSH框架下成功集成Compass实现站内搜索分页。这一过程涉及到Java Web开发的多个层面,包括MVC架构、数据库操作、全文检索以及用户体验设计。熟练掌握这些技能将有助于构建高效且功能丰富的Web...

    使用compass+lucene实现简单的全文检索功能

    总的来说,使用 Compass 和 Lucene 实现全文检索功能,能够极大地提升 Java 应用的搜索体验,让开发者能够快速响应用户的查询需求。这两个工具的结合使用,不仅可以处理简单的文本搜索,还能够应对复杂的查询条件和...

    Spring ,JPA,Compass使用注解开发的博客站内搜索

    接下来,为了实现搜索功能,我们需要创建一个Service层的接口和实现类,这个类会调用Compass的API来执行搜索查询。搜索方法可能接受关键词参数,然后使用Compass的QueryBuilder或直接写入Lucene的Query语法来构建...

    Compass全文检索系列之一:Compass入门

    本文将介绍Compass,一个基于Lucene的全文搜索引擎库,为Java开发者提供了一种简单易用的方式来集成全文检索功能。Compass不仅提供了与ORM框架(如Hibernate、JPA等)的无缝集成,还支持动态索引更新,使得实时数据...

    struts2+spring2.5+hibernate3.26+compass2.1搜索引擎简单实现(无jar包)

    为了实现搜索功能,你需要创建一个搜索Action,该Action可以调用由Spring管理的Service,Service再通过CompassTemplate执行查询。你可以使用Compass提供的Gps接口或者自定义查询语句来实现对索引的检索。检索结果...

    compass搜索引擎技术

    Compass搜索引擎技术是一种基于Lucene的全文检索框架,它提供了更高级别的API和集成机制,使得在Java应用程序中实现搜索引擎功能变得更加便捷。Compass的主要目标是将全文索引能力无缝地融入到现有的业务应用程序中...

    java搜索 compass资料

    在题目中提供的部分Java代码中,展示了一个名为`ProductInfo`的实体类,该类通过使用Compass注解实现了全文检索功能。 1. **实体类定义** ```java @Entity @Searchable public class ProductInfo implements ...

    基于Lucene的搜索引擎框架Compass教程

    5. **实时搜索**:与ORM框架集成后,数据库的变更会立即反映到索引中,实现搜索结果的实时更新。 **三、Compass工作流程** 1. **初始化**:创建并配置Compass实例,指定数据源和存储路径。 2. **对象映射**:定义...

    compass对象搜索引擎

    综上所述,Compass对象搜索引擎通过提供面向对象的接口和强大的元数据映射,简化了Java开发者在应用中集成全文检索的复杂性,让搜索功能的实现变得更为高效和便捷。结合Lucene的优秀性能,Compass成为了一个强大的...

    compass完整可用项目

    【compass完整可用项目】是一个基于特定技术栈的软件开发项目,该项目的核心是Compass库,一个与Lucene紧密集成的全文搜索引擎工具。Compass提供了一种简单的方式来在Java应用程序中集成全文搜索功能,使得开发者...

    compass annotation关联关系

    Compass 是一个全文搜索引擎库,它是对 Lucene 的封装,为 Java 应用提供了一种简单易用的接口。在 Compass 中,Annotation 是一种元数据注解方式,它允许开发者在对象模型上直接定义搜索映射,使得对象与索引之间的...

    compass+lucene

    总的来说,Compass 和 Lucene 的结合是Java开发中实现高效全文搜索的理想工具。它们不仅提供了强大的搜索功能,还具有灵活的配置和扩展性,适用于各种规模的项目。如果你正在寻找一种将搜索功能集成到Java应用的方法...

    Compass 的java代码

    Compass是一款基于Apache Lucene的全文搜索引擎库,它为Java开发者提供了一个高级的、易于使用的搜索框架。在Java应用中集成搜索引擎功能时,Compass提供了一种简化的方式来管理和操作Lucene索引。通过Compass,你...

    Compass原理深入学习笔记

    【Compass原理深入学习笔记】 Compass是一款基于Apache Lucene的全文搜索引擎框架,它为...通过Compass,可以实现类似Hibernate对数据库的操作体验,但针对搜索引擎进行数据管理,提高了大规模文本数据的检索效率。

Global site tag (gtag.js) - Google Analytics