`
xiangxingchina
  • 浏览: 524057 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

用compass实现站内全文搜索引擎

搜索引擎全文检索BeanSpringAOP 
阅读更多

Compass是一个强大的,事务的,高性能的对象/搜索引擎映射(OSEM:object/search engine mapping)与一个Java持久层框架.Compass包括: 
* 搜索引擎抽象层(使用Lucene搜索引荐),
* OSEM (Object/Search Engine Mapping) 支持,
* 事务管理,
* 类似于Google的简单关键字查询语言,
* 可扩展与模块化的框架,
* 简单的API.

如果你需要做站内搜索引擎，而且项目里用到了hibernate，那用compass是你的最佳选择。

本文用到compass2.14和IK中文分词包,另外将会使用注解来实现

废话不说，先给出关键的实现代码

假如现在有个需求，需要根据关键字搜索出文章，

Java代码
  1. @Searchable (alias= "article" )   
  2. public   class  Article {  
  3.   
  4.     private  Long ID;  // 标识ID   
  5.     private  String content;  // 正文   
  6.     private  String title;  // 文章标题   
  7.     private  Date createTime;  // 创建时间   
  8.   
  9.     @SearchableId   
  10.     public  Long getID() {  
  11.         return  ID;  
  12.     }  
  13.   
  14.     public   void  setID(Long id) {  
  15.         ID = id;  
  16.     }  
  17.   
  18.     @SearchableProperty (index = Index.TOKENIZED, store = Store.YES)  
  19.     public  String getContent() {  
  20.         return  content;  
  21.     }  
  22.   
  23.     public   void  setContent(String content) {  
  24.         this .content = content;  
  25.     }  
  26.   
  27.   
  28.   
  29.     @SearchableProperty (index = Index.TOKENIZED, store = Store.YES)  
  30.     public  String getTitle() {  
  31.         return  title;  
  32.     }  
  33.   
  34.     public   void  setTitle(String title) {  
  35.         this .title = title;  
  36.     }  
  37.   
  38.   
  39.     @SearchableProperty (index = Index.TOKENIZED, store = Store.YES)  
  40.     public  Date getCreateTime() {  
  41.         return  createTime;  
  42.     }  
  43.   
  44.     public   void  setCreateTime(Date createTime) {  
  45.         this .createTime = createTime;  
  46.     }  
  47.   
  48.   
  49.   
  50.       
  51.   
  52.   
  53. }   
@Searchable(alias="article") 
public class Article {

	private Long ID; // 标识ID
	private String content; // 正文
	private String title; // 文章标题
	private Date createTime; // 创建时间

	@SearchableId
	public Long getID() {
		return ID;
	}

	public void setID(Long id) {
		ID = id;
	}

	@SearchableProperty(index = Index.TOKENIZED, store = Store.YES)
	public String getContent() {
		return content;
	}

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



	@SearchableProperty(index = Index.TOKENIZED, store = Store.YES)
	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}


	@SearchableProperty(index = Index.TOKENIZED, store = Store.YES)
	public Date getCreateTime() {
		return createTime;
	}

	public void setCreateTime(Date createTime) {
		this.createTime = createTime;
	}



	


}



简单解释一下：
@Searchable(alias="article")表示这个是可以搜索实体，别人为article.
@SearchableId  这个是实体搜索的标识ID,和hibernate里的概念差不多，用来区分索引文件里的实体索引。
@SearchableProperty(index = Index.TOKENIZED, store = Store.YES) 表示这个属性存入索引文件,而且是在分词后在存入.

 

 

接下来是要建立搜索的服务类

Java代码
  1. import  java.util.ArrayList;  
  2. import  java.util.HashMap;  
  3. import  java.util.List;  
  4. import  java.util.Map;  
  5. import  org.compass.core.Compass;  
  6. import  org.compass.core.CompassCallback;  
  7. import  org.compass.core.CompassException;  
  8. import  org.compass.core.CompassHighlighter;  
  9. import  org.compass.core.CompassHits;  
  10. import  org.compass.core.CompassQuery;  
  11. import  org.compass.core.CompassSession;  
  12. import  org.compass.core.CompassTemplate;  
  13. import  org.compass.core.CompassTransaction;  
  14. import  cn.rgcenter.entity.Article;  
  15.   
  16. public   class  SearchServiceBean {  
  17.   
  18.     private  Compass compass;  
  19.     /** 索引查询 * */   
  20.     public  Map find( final  String keywords,  final  String type,  final   int  start,  
  21.             final   int  end) {  
  22.         CompassTemplate ct = new  CompassTemplate(compass);  
  23.         return  ct.execute( new  CompassCallback<Map>() {  
  24.   
  25.             public  Map doInCompass(CompassSession session)  
  26.                     throws  CompassException {  
  27.                 List result = new  ArrayList();  
  28.                 int  totalSize =  0 ;  
  29.                 Map container = new  HashMap();  
  30.                 CompassQuery query = session.queryBuilder().queryString(  
  31.                         keywords).toQuery();  
  32.                 CompassHits hits = query.setAliases(type).hits();  
  33.                 totalSize = hits.length();  
  34.                 container.put("size" , totalSize);  
  35.                 int  max =  0 ;  
  36.                 if  (end < hits.length()) {  
  37.                     max = end;  
  38.                 } else  {  
  39.                     max = hits.length();  
  40.                 }  
  41.   
  42.        if (type.equals( "article" )){  
  43.                     for  ( int  i = start; i < max; i++) {  
  44.                         Article article = (Article) hits.data(i);  
  45.                         String title = hits.highlighter(i).fragment("title" );  
  46.                         if  (title !=  null ) {  
  47.                             article.setTitle(title);  
  48.                         }  
  49.                         String content = hits.highlighter(i).setTextTokenizer(  
  50.                                 CompassHighlighter.TextTokenizer.AUTO)  
  51.                                 .fragment("content" );  
  52.                         if  (content !=  null ) {  
  53.   
  54.                             article.setContent(content);  
  55.                         }  
  56.                         result.add(article);  
  57.                     }  
  58.                 }  
  59.                 container.put("result" , result);  
  60.                 return  container;  
  61.             }  
  62.         });  
  63.     }  
  64.   
  65.     public  Compass getCompass() {  
  66.         return  compass;  
  67.     }  
  68.   
  69.     public   void  setCompass(Compass compass) {  
  70.         this .compass = compass;  
  71.     }  
  72.   
  73. }   
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具有一样的一样的功能，另外还多了个很重要的功能，自动选择正文中最匹配关键字的内容中的一部分输出。因为很多时候一篇文章几千字，我们只想显示有关键字的那部分的摘要，这时候这个功能就很方便.


这之后还要写一个建立索引的服务类，让服务器启动的时候或者定时重建索引.

Java代码
  1. import  org.compass.gps.CompassGps;  
  2. import  org.springframework.beans.factory.InitializingBean;  
  3.   
  4. public   class  CompassIndexBuilder  implements  InitializingBean {    
  5.       
  6.     // 是否需要建立索引，可被设置为false使本Builder失效.      
  7.     private   boolean  buildIndex =  false ;     
  8.     
  9.     // 索引操作线程延时启动的时间，单位为秒      
  10.     private   int  lazyTime =  10 ;     
  11.     
  12.     // Compass封装      
  13.     private  CompassGps compassGps;     
  14.     
  15.     // 索引线程      
  16.     private  Thread indexThread =  new  Thread() {     
  17.     
  18.         @Override     
  19.         public   void  run() {     
  20.             try  {     
  21.                 Thread.sleep(lazyTime * 1000 );     
  22.                 System.out.println("begin compass index..." );     
  23.                 long  beginTime = System.currentTimeMillis();     
  24.                 // 重建索引.      
  25.                 // 如果compass实体中定义的索引文件已存在，索引过程中会建立临时索引，      
  26.                 // 索引完成后再进行覆盖.      
  27.                 compassGps.index();     
  28.                 long  costTime = System.currentTimeMillis() - beginTime;     
  29.                 System.out.println("compss index finished." );     
  30.                 System.out.println("costed "  + costTime +  " milliseconds" );     
  31.             } catch  (InterruptedException e) {     
  32.                 e.printStackTrace();     
  33.             }     
  34.         }     
  35.     };     
  36.     
  37.     /**    
  38.      * 实现<code>InitializingBean</code>接口，在完成注入后调用启动索引线程.  
  39.      */     
  40.     public   void  afterPropertiesSet()  throws  Exception {     
  41.         if  (buildIndex) {     
  42.             indexThread.setDaemon(true );     
  43.             indexThread.setName("Compass Indexer" );     
  44.             indexThread.start();     
  45.         }     
  46.     }     
  47.     
  48.     public   void  setBuildIndex( boolean  buildIndex) {     
  49.         this .buildIndex = buildIndex;     
  50.     }     
  51.     
  52.     public   void  setLazyTime( int  lazyTime) {     
  53.         this .lazyTime = lazyTime;     
  54.     }     
  55.     
  56.     public   void  setCompassGps(CompassGps compassGps) {     
  57.         this .compassGps = compassGps;     
  58.     }     
  59. }    
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初始化的时候去建立索引


剩下的就是配置文件了

Java代码
  1. <?xml version= "1.0"  encoding= "UTF-8" ?>  
  2.   
  3. <beans xmlns="http://www.springframework.org/schema/beans"   
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
  5.     xmlns:aop="http://www.springframework.org/schema/aop"   
  6.     xmlns:tx="http://www.springframework.org/schema/tx"   
  7.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
  8.             http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd   
  9.             http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">   
  10.   
  11.     <bean id="annotationConfiguration"   
  12.         class = "org.compass.annotations.config.CompassAnnotationsConfiguration" >  
  13.     </bean>  
  14.   
  15.     <!-- compass Bean  -->  
  16.     <bean id="compass"   class = "org.compass.spring.LocalCompassBean" >  
  17.         <property name="compassConfiguration"   
  18.             ref="annotationConfiguration"  />  
  19.         <!-- 数据索引存储位置 -->  
  20.         <property name="connection" >  
  21.             <value>/compass/indexes</value>  
  22.         </property>  
  23.         <property name="transactionManager"  ref= "transactionManager"  />  
  24.         <property name="compassSettings" >  
  25.             <props>  
  26.                 <prop key="compass.transaction.factory" >  
  27.                     org.compass.spring.transaction.SpringSyncTransactionFactory  
  28.                 </prop>  
  29.               
  30.                 <prop  
  31.                     key="compass.engine.highlighter.default.formatter.simple.pre" >  
  32.                     <![CDATA[<span style='background-color:yellow;color:red;' >]]>  
  33.                 </prop>  
  34.                 <prop  
  35.                     key="compass.engine.highlighter.default.formatter.simple.post" >  
  36.                     <![CDATA[</span>]]>  
  37.                 </prop>  
  38.     <!--定义分词器-->            
  39. <prop  
  40.                     key="compass.engine.analyzer.default.type" >  
  41.                     org.mira.lucene.analysis.IK_CAnalyzer  
  42.                 </prop>  
  43.             </props>  
  44.         </property>  
  45.         <property name="classMappings" >  
  46.             <list>  
  47.               
  48.                 <value>cn.rgcenter.entity.Article</value>  
  49.             </list>  
  50.         </property>  
  51.     </bean>  
  52.   
  53.     <!--hibernate驱动-->  
  54.     <bean id="hibernateGpsDevice"   
  55.         class = "org.compass.spring.device.hibernate.dep.SpringHibernate3GpsDevice" >  
  56.         <property name="name" >  
  57.             <value>hibernateDevice</value>  
  58.         </property>  
  59.         <property name="sessionFactory"  ref= "sessionFactory"  />  
  60.         <property name="mirrorDataChanges" >  
  61.             <value>true </value>  
  62.         </property>  
  63.     </bean>  
  64.   
  65.     <!-- 数据库中的数据变化后同步更新索引 -->  
  66.     <bean id="hibernateGps"   
  67.         class = "org.compass.gps.impl.SingleCompassGps"  init-method= "start"   
  68.         destroy-method="stop" >  
  69.         <property name="compass" >  
  70.             <ref bean="compass"  />  
  71.         </property>  
  72.         <property name="gpsDevices" >  
  73.             <list>  
  74.                 <bean  
  75.                     class = "org.compass.spring.device.SpringSyncTransactionGpsDeviceWrapper" >  
  76.                     <property name="gpsDevice"  ref= "hibernateGpsDevice"  />  
  77.                 </bean>  
  78.             </list>  
  79.         </property>  
  80.     </bean>  
  81.   
  82.     <!-- compass模版 -->  
  83.     <bean id="compassTemplate"   
  84.         class = "org.compass.core.CompassTemplate" >  
  85.         <property name="compass"  ref= "compass"  />  
  86.     </bean>  
  87.   
  88.     <!-- 定时重建索引(利用quartz)或随Spring ApplicationContext启动而重建索引 -->  
  89.     <bean id="compassIndexBuilder"   
  90.         class = "cn.rgcenter.compass.service.CompassIndexBuilder"   
  91.         lazy-init="false" >  
  92.         <property name="compassGps"  ref= "hibernateGps"  />  
  93.         <property name="buildIndex"  value= "true"  />  
  94.         <property name="lazyTime"  value= "5"  />  
  95.     </bean>  
  96.   
  97.     <!-- 搜索引擎服务类 -->  
  98.     <bean id="searchService"   
  99.         class = "cn.rgcenter.compass.service.SearchServiceBean" >  
  100.         <property name="compass" >  
  101.             <ref bean="compass"  />  
  102.         </property>  
  103.     </bean>  
  104.   
  105.     <!-- 搜索引擎Action -->  
  106.     <bean id="searchAction"   class = "cn.rgcenter.action.SearchAction" >  
  107.         <property name="searchService" >  
  108.             <ref bean="searchService"  />  
  109.         </property>  
  110.     </bean>  
  111.   
  112. </beans>   
<?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就不列出代码了，很简单了，只需要传搜索方法的那几个参数过去就可以了.

最后看一下搜索结果示例图:



  • 大小: 41.1 KB
分享到：
| ant环境变量的配置
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

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

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

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

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

    lucene 搜索引擎 compass

    总的来说，Lucene和Compass结合使用，可以构建出强大的企业级搜索引擎，实现对大量结构化和非结构化数据的快速、高效的检索。通过理解并熟练掌握这两者的使用，开发者可以轻松地在自己的应用中实现复杂的搜索功能，...

    compass搜索引擎技术

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

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

    总结，Compass作为基于Lucene的搜索引擎框架，为Java开发者提供了更为便捷的全文搜索解决方案，降低了搜索引擎开发的复杂度，提高了开发效率。理解并掌握Compass，有助于在实际项目中更好地利用全文搜索技术提升用户...

    compass对象搜索引擎

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

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

    Compass是一款基于Lucene的全文搜索引擎，它使得Java应用能够方便地集成全文搜索功能。Compass提供了对JDBC、Hibernate等数据源的直接支持，可以自动索引数据库中的数据，实现快速检索。 在"struts2+spring2.5+...

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

    Compass 和 Lucene 是两个在 Java 开发环境中广泛使用的全文搜索引擎工具。它们可以帮助开发者构建高效、强大的文本搜索功能。本文将详细介绍如何使用 Compass 和 Lucene 实现一个简单的全文检索功能。 首先，...

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

    标题 "Spring ,JPA,Compass使用注解开发的博客站内搜索" 涉及的是在Java开发环境中，利用Spring框架、Java Persistence API (JPA) 和 Compass搜索引擎来实现一个博客系统的站内搜索功能。这是一项关键的技术，因为...

    Compass+SSH搜索引擎简单项目

    【SSH+Compass搜索引擎简单项目】是一个基于Struts2（S），Hibernate（H）和Spring（S）的Java Web应用程序，结合了Compass搜索引擎库，用于实现对数据库中两个表的高效检索功能。这个项目旨在提供一个清晰易懂的...

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

    Compass是一个基于Lucene的开源搜索引擎框架，它简化了将Lucene集成到Java应用程序中的过程，特别是与ORM框架（如Hibernate）的整合。 首先，我们需要了解Compass的核心概念。Compass提供了一个Gps接口，它允许我们...

    COMPASS+spring构建自己的搜索引擎.pdf

    标题提及的"COMPASS+spring构建自己的搜索引擎"是关于如何使用Compass搜索引擎框架与Spring框架集成，构建一个自定义的全文搜索引擎。Compass是一个开源的搜索引擎库，它提供了与ORM框架（如Hibernate）的集成，使得...

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

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

    Compass原理深入学习笔记

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

    compass annotation关联关系

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

    compass-2.2.0.zip

    Compass的出现就是为了降低这个门槛，使得开发人员可以更加专注于业务逻辑，而无需过多关注搜索引擎的实现细节。 Compass的核心特性包括： 1. **搜索引擎API**：Compass提供了一个简单易用的API，使得开发者可以...

    compass完整可用项目

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

Magicbox
Global site tag (gtag.js) - Google Analytics