Lucene 中自定义排序的实现

最新推荐文章于 2020-05-30 16:15:00 发布
最新推荐文章于 2020-05-30 16:15:00 发布
阅读量116 收藏
点赞数
文章标签： lucene Apache J# junit 工作
使用Lucene来搜索内容,搜索结果的显示顺序当然是比较重要的.Lucene中Build-in的几个排序定义在大多数情况下是不适合我们使用的.要适合自己的应用程序的场景,就只能自定义排序功能,本节我们就来看看在Lucene中如何实现自定义排序功能.

Lucene中的自定义排序功能和Java集合中的自定义排序的实现方法差不多,都要实现一下比较接口. 在Java中只要实现Comparable接口就可以了.但是在Lucene中要实现SortComparatorSource接口和ScoreDocComparator接口.在了解具体实现方法之前先来看看这两个接口的定义吧.

SortComparatorSource接口的功能是返回一个用来排序ScoreDocs的comparator(Expert: returns a comparator for sorting ScoreDocs).该接口只定义了一个方法.如下:

Java代码 复制代码
  1. /**
  2. *Createsacomparatorforthefieldinthegivenindex.
  3. *@paramreader-Indextocreatecomparatorfor.
  4. *@paramfieldname-Fieldtocreatecomparatorfor.
  5. *@returnComparatorofScoreDocobjects.
  6. *@throwsIOException-Ifanerroroccursreadingtheindex.
  7. */
  8. publicScoreDocComparatornewComparator(IndexReaderreader,Stringfieldname)throwsIOException 
/**
 * Creates a comparator for the field in the given index. 
 * @param reader - Index to create comparator for. 
 * @param fieldname - Field to create comparator for.
 * @return Comparator of ScoreDoc objects. 
 * @throws IOException - If an error occurs reading the index. 
 */
public ScoreDocComparator newComparator(IndexReader reader,String fieldname) throws IOException

该方法只是创造一个ScoreDocComparator 实例用来实现排序.所以我们还要实现ScoreDocComparator 接口.来看看ScoreDocComparator 接口.功能是比较来两个ScoreDoc 对象来排序(Compares two ScoreDoc objects for sorting) 里面定义了两个Lucene实现的静态实例.如下:

Java代码 复制代码
  1. //Specialcomparatorforsortinghitsaccordingtocomputedrelevance(documentscore).
  2. publicstaticfinalScoreDocComparatorRELEVANCE;
  4. //Specialcomparatorforsortinghitsaccordingtoindexorder(documentnumber).
  5. publicstaticfinalScoreDocComparatorINDEXORDER; 
//Special comparator for sorting hits according to computed relevance (document score). 
public static final ScoreDocComparator RELEVANCE;
	
//Special comparator for sorting hits according to index order (document number). 
public static final ScoreDocComparator INDEXORDER;

有3个方法与排序相关,需要我们实现 分别如下:

Java代码 复制代码
  1. /**
  2. *ComparestwoScoreDocobjectsandreturnsaresultindicatingtheirsortorder.
  3. *@paramiFirstScoreDoc
  4. *@paramjSecondScoreDoc
  5. *@return-1ifishouldcomebeforej;
  6. *1ifishouldcomeafterj;
  7. *0iftheyareequal
  8. */
  9. publicintcompare(ScoreDoci,ScoreDocj);
  11. /**
  12. *Returnsthevalueusedtosortthegivendocument.Theobjectreturnedmustimplementthejava.io.Serializableinterface.Thisisusedbymultisearcherstodeterminehowtocollateresultsfromtheirsearchers.
  13. *@paramiDocument
  14. *@returnSerializableobject
  15. */
  16. publicComparablesortValue(ScoreDoci);
  18. /**
  19. *Returnsthetypeofsort.ShouldreturnSortField.SCORE,SortField.DOC,SortField.STRING,SortField.INTEGER,SortField.FLOATorSortField.CUSTOM.ItisnotvalidtoreturnSortField.AUTO.Thisisusedbymultisearcherstodeterminehowtocollateresultsfromtheirsearchers.
  20. *@returnOneoftheconstantsinSortField.
  21. */
  22. publicintsortType(); 
               /**
	 * Compares two ScoreDoc objects and returns a result indicating their sort order. 
	 * @param i First ScoreDoc 
	 * @param j Second ScoreDoc
	 * @return -1 if i should come before j; 
	 *         1 if i should come after j;
	 *         0 if they are equal
	 */
	public int compare(ScoreDoc i,ScoreDoc j);

	/**
	 * Returns the value used to sort the given document. The object returned must implement the java.io.Serializable interface. This is used by multisearchers to determine how to collate results from their searchers. 
	 * @param i Document
	 * @return Serializable object
	 */
	public Comparable sortValue(ScoreDoc i);

	/**
	 * Returns the type of sort. Should return SortField.SCORE, SortField.DOC, SortField.STRING, SortField.INTEGER, SortField.FLOAT or SortField.CUSTOM. It is not valid to return SortField.AUTO. This is used by multisearchers to determine how to collate results from their searchers. 
	 * @return One of the constants in SortField. 
	 */
	public int sortType();

看个例子吧!

该例子为Lucene in Action中的一个实现,用来搜索距你最近的餐馆的名字. 餐馆坐标用字符串"x,y"来存储.

Java代码 复制代码
  1. packagecom.nikee.lucene;
  3. importjava.io.IOException;
  5. importorg.apache.lucene.index.IndexReader;
  6. importorg.apache.lucene.index.Term;
  7. importorg.apache.lucene.index.TermDocs;
  8. importorg.apache.lucene.index.TermEnum;
  9. importorg.apache.lucene.search.ScoreDoc;
  10. importorg.apache.lucene.search.ScoreDocComparator;
  11. importorg.apache.lucene.search.SortComparatorSource;
  12. importorg.apache.lucene.search.SortField;
  14. //实现了搜索距你最近的餐馆的名字.餐馆坐标用字符串"x,y"来存储
  15. //DistanceComparatorSource实现了SortComparatorSource接口
  16. publicclassDistanceComparatorSourceimplementsSortComparatorSource{
  17. privatestaticfinallongserialVersionUID=1L;
  19. //xy用来保存坐标位置
  20. privateintx;
  21. privateinty;
  23. publicDistanceComparatorSource(intx,inty){
  24. this.x=x;
  25. this.y=y;
  26. }
  28. //返回ScoreDocComparator用来实现排序功能
  29. publicScoreDocComparatornewComparator(IndexReaderreader,Stringfieldname)throwsIOException{
  30. returnnewDistanceScoreDocLookupComparator(reader,fieldname,x,y);
  31. }
  33. //DistanceScoreDocLookupComparator实现了ScoreDocComparator用来排序
  34. privatestaticclassDistanceScoreDocLookupComparatorimplementsScoreDocComparator{
  35. privatefloat[]distances;//保存每个餐馆到指定点的距离
  37. //构造函数,构造函数在这里几乎完成所有的准备工作.
  38. publicDistanceScoreDocLookupComparator(IndexReaderreader,Stringfieldname,intx,inty)throwsIOException{
  39. System.out.println("fieldName2="+fieldname);
  40. finalTermEnumenumerator=reader.terms(newTerm(fieldname,""));
  42. System.out.println("maxDoc="+reader.maxDoc());
  43. distances=newfloat[reader.maxDoc()];//初始化distances
  44. if(distances.length>0){
  45. TermDocstermDocs=reader.termDocs();
  46. try{
  47. if(enumerator.term()==null){
  48. thrownewRuntimeException("notermsinfield"+fieldname);
  49. }
  50. inti=0,j=0;
  51. do{
  52. System.out.println("indo-while:"+i++);
  53. Termterm=enumerator.term();//取出每一个Term
  54. if(term.field()!=fieldname)//与给定的域不符合则比较下一个
  55. break;
  57. //SetsthistothedataforthecurrentterminaTermEnum.
  58. //Thismaybeoptimizedinsomeimplementations.
  59. termDocs.seek(enumerator);//参考TermDocsDoc
  60. while(termDocs.next()){
  61. System.out.println("inwhile:"+j++);
  62. System.out.println("inwhile,Term:"+term.toString());
  64. String[]xy=term.text().split(",");//去处xy
  65. intdeltax=Integer.parseInt(xy[0])-x;
  66. intdeltay=Integer.parseInt(xy[1])-y;
  67. //计算距离
  68. distances[termDocs.doc()]=(float)Math.sqrt(deltax*deltax+deltay*deltay);
  69. }
  70. }
  71. while(enumerator.next());
  72. }finally{
  73. termDocs.close();
  74. }
  75. }
  76. }
  78. //有上面的构造函数的准备这里就比较简单了
  79. publicintcompare(ScoreDoci,ScoreDocj){
  80. if(distances[i.doc]<distances[j.doc])
  81. return-1;
  82. if(distances[i.doc]>distances[j.doc])
  83. return1;
  84. return0;
  85. }
  87. //返回距离
  88. publicComparablesortValue(ScoreDoci){
  89. returnnewFloat(distances[i.doc]);
  90. }
  92. //指定SortType
  93. publicintsortType(){
  94. returnSortField.FLOAT;
  95. }
  96. }
  98. publicStringtoString(){
  99. return"Distancefrom("+x+","+y+")";
  100. }
  101. }
package com.nikee.lucene;

import java.io.IOException;

import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.index.TermDocs;
import org.apache.lucene.index.TermEnum;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.ScoreDocComparator;
import org.apache.lucene.search.SortComparatorSource;
import org.apache.lucene.search.SortField;

//实现了搜索距你最近的餐馆的名字. 餐馆坐标用字符串"x,y"来存储
//DistanceComparatorSource 实现了SortComparatorSource接口
public class DistanceComparatorSource implements SortComparatorSource {
	private static final long serialVersionUID = 1L;
	
	// x y 用来保存 坐标位置
	private int x;
	private int y;
	
	public DistanceComparatorSource(int x, int y) {
		this.x = x;
		this.y = y;
	}
	
	// 返回ScoreDocComparator 用来实现排序功能
	public ScoreDocComparator newComparator(IndexReader reader, String fieldname) throws IOException {
		return new DistanceScoreDocLookupComparator(reader, fieldname, x, y);
	}
	
	//DistanceScoreDocLookupComparator 实现了ScoreDocComparator 用来排序
	private static class DistanceScoreDocLookupComparator implements ScoreDocComparator {
		private float[] distances;  // 保存每个餐馆到指定点的距离
		
		// 构造函数 , 构造函数在这里几乎完成所有的准备工作.
		public DistanceScoreDocLookupComparator(IndexReader reader, String fieldname, int x, int y) throws IOException {
			System.out.println("fieldName2="+fieldname);
			final TermEnum enumerator = reader.terms(new Term(fieldname, ""));
			
			System.out.println("maxDoc="+reader.maxDoc());
			distances = new float[reader.maxDoc()];  // 初始化distances
			if (distances.length > 0) {
				TermDocs termDocs = reader.termDocs();
				try {
					if (enumerator.term() == null) {
						throw new RuntimeException("no terms in field " + fieldname);
					}
					int i = 0,j = 0;
					do {
						System.out.println("in do-while :" + i ++);
						Term term = enumerator.term();  // 取出每一个Term 
						if (term.field() != fieldname)  // 与给定的域不符合则比较下一个
							break;
						
						//Sets this to the data for the current term in a TermEnum. 
						//This may be optimized in some implementations.
						termDocs.seek(enumerator); //参考TermDocs Doc
						while (termDocs.next()) {
							System.out.println("    in while :" + j ++);
							System.out.println("    in while ,Term :" + term.toString());
							
							String[] xy = term.text().split(","); // 去处x y
							int deltax = Integer.parseInt(xy[0]) - x;
							int deltay = Integer.parseInt(xy[1]) - y;
							// 计算距离
							distances[termDocs.doc()] = (float) Math.sqrt(deltax * deltax + deltay * deltay);
						}
					} 
					while (enumerator.next());
				} finally {
					termDocs.close();
				}
			}
		}

		//有上面的构造函数的准备 这里就比较简单了
		public int compare(ScoreDoc i, ScoreDoc j) {
			if (distances[i.doc] < distances[j.doc])
				return -1;
			if (distances[i.doc] > distances[j.doc])
				return 1;
			return 0;
		}
		
		// 返回距离
		public Comparable sortValue(ScoreDoc i) {
			return new Float(distances[i.doc]);
		}
		
		//指定SortType
		public int sortType() {
			return SortField.FLOAT;
		}
	}
		
	public String toString() {
		return "Distance from (" + x + "," + y + ")";
	}
}


这是一个实现了上面两个接口的两个类, 里面带有详细注释, 可以看出 自定义排序并不是很难的. 该实现能否正确实现,我们来看看测试代码能否通过吧.

Java代码 复制代码
  1. packagecom.nikee.lucene.test;
  3. importjava.io.IOException;
  5. importjunit.framework.TestCase;
  7. importorg.apache.lucene.analysis.WhitespaceAnalyzer;
  8. importorg.apache.lucene.document.Document;
  9. importorg.apache.lucene.document.Field;
  10. importorg.apache.lucene.index.IndexWriter;
  11. importorg.apache.lucene.index.Term;
  12. importorg.apache.lucene.search.FieldDoc;
  13. importorg.apache.lucene.search.Hits;
  14. importorg.apache.lucene.search.IndexSearcher;
  15. importorg.apache.lucene.search.Query;
  16. importorg.apache.lucene.search.ScoreDoc;
  17. importorg.apache.lucene.search.Sort;
  18. importorg.apache.lucene.search.SortField;
  19. importorg.apache.lucene.search.TermQuery;
  20. importorg.apache.lucene.search.TopFieldDocs;
  21. importorg.apache.lucene.store.RAMDirectory;
  23. importcom.nikee.lucene.DistanceComparatorSource;
  25. publicclassDistanceComparatorSourceTestextendsTestCase{
  26. privateRAMDirectorydirectory;
  28. privateIndexSearchersearcher;
  29. privateQueryquery;
  31. //建立测试环境
  32. protectedvoidsetUp()throwsException{
  33. directory=newRAMDirectory();
  34. IndexWriterwriter=newIndexWriter(directory,newWhitespaceAnalyzer(),true);
  36. addPoint(writer,"ElCharro","restaurant",1,2);
  37. addPoint(writer,"CafePocaCosa","restaurant",5,9);
  38. addPoint(writer,"LosBetos","restaurant",9,6);
  39. addPoint(writer,"Nico'sTacoShop","restaurant",3,8);
  41. writer.close();
  42. searcher=newIndexSearcher(directory);
  43. query=newTermQuery(newTerm("type","restaurant"));
  44. }
  46. privatevoidaddPoint(IndexWriterwriter,Stringname,Stringtype,intx,inty)throwsIOException{
  47. Documentdoc=newDocument();
  48. doc.add(newField("name",name,Field.Store.YES,Field.Index.TOKENIZED));
  49. doc.add(newField("type",type,Field.Store.YES,Field.Index.TOKENIZED));
  50. doc.add(newField("location",x+","+y,Field.Store.YES,Field.Index.UN_TOKENIZED));
  51. writer.addDocument(doc);
  52. }
  54. publicvoidtestNearestRestaurantToHome()throwsException{
  55. //使用DistanceComparatorSource来构造一个SortField
  56. Sortsort=newSort(newSortField("location",newDistanceComparatorSource(0,0)));
  57. Hitshits=searcher.search(query,sort);//搜索
  59. //测试
  60. assertEquals("closest","ElCharro",hits.doc(0).get("name"));
  61. assertEquals("furthest","LosBetos",hits.doc(3).get("name"));
  62. }
  64. publicvoidtestNeareastRestaurantToWork()throwsException{
  65. Sortsort=newSort(newSortField("location",newDistanceComparatorSource(10,10)));//工作的坐标10,10
  66. //上面的测试实现了自定义排序,但是并不能访问自定义排序的更详细信息,利用
  67. //TopFieldDocs可以进一步访问相关信息
  68. TopFieldDocsdocs=searcher.search(query,null,3,sort);
  70. assertEquals(4,docs.totalHits);
  71. assertEquals(3,docs.scoreDocs.length);
  73. //取得FieldDoc利用FieldDoc可以取得关于排序的更详细信息请查看FieldDocDoc
  74. FieldDocfieldDoc=(FieldDoc)docs.scoreDocs[0];
  76. assertEquals("(10,10)->(9,6)=sqrt(17)",newFloat(Math.sqrt(17)),fieldDoc.fields[0]);
  77. Documentdocument=searcher.doc(fieldDoc.doc);
  78. assertEquals("LosBetos",document.get("name"));
  79. dumpDocs(sort,docs);//显示相关信息
  80. }
  82. //显示有关排序的信息
  83. privatevoiddumpDocs(Sortsort,TopFieldDocsdocs)throwsIOException{
  84. System.out.println("Sortedby:"+sort);
  85. ScoreDoc[]scoreDocs=docs.scoreDocs;
  86. for(inti=0;i<scoreDocs.length;i++){
  87. FieldDocfieldDoc=(FieldDoc)scoreDocs[i];
  88. Floatdistance=(Float)fieldDoc.fields[0];
  89. Documentdoc=searcher.doc(fieldDoc.doc);
  90. System.out.println(""+doc.get("name")+"@("+doc.get("location")+")->"+distance);
  91. }
  92. }
  93. }
iteye_4965
关注
java Lucene 中自定义排序的实现
01-08
Lucene中的自定义排序功能和Java集合中的自定义排序的实现方法差不多,都要实现一下比较接口. 在Java中只要实现Comparable接口就可以了.但是在Lucene中要实现SortComparatorSource接口和ScoreDocComparator接口.在...
Lucene3.6 之 排序篇
Ricky
01-30 1668
Lucene的默认排序是按照Document的得分进行排序的。当检索结果集中的两个Document的具有相同的得分时，默认按照Document的ID对结果进行排序。  一、使用Sort、SortField类实现排序  Lucene在查询的时候，可以通过以一个Sort作为参数构造一个检索器IndexSearcher，在构造Sort的时候，指定排序规则。 调用sIndexSearche
（转）Elasticsearch .net client NEST使用说明 2.x
aibi2794的博客
11-03 215
Elasticsearch.Net与NEST是Elasticsearch为C#提供的一套客户端驱动，方便C#调用Elasticsearch服务接口。Elasticsearch.Net是较基层的对Elasticsearch服务接口请求响应的实现，NEST是在前者基础之上进行的封装。本文是针对NEST的使用的总结。 引用 Install-Package NEST 包含以下...
ElasticSearch7.x系列四:实战
蜀云泉
05-30 65
目录前言ES系列安装数据同步.net代码怎么搜索ES单Index和多Index单字段搜索和全文检索多条件,时间范围+分页+高亮使用QueryContainerDescriptor查询完结前言 前面的三篇系列了解了安装和一些基本使用,这一章节呢,我来个实战. 首先不管是在公司使用还是个人使用,面临的最初的问题是: ElasticSearch系列包括ES,ES-head,Kibana,分词器等怎么...
lucene 排序 (Sort SortField 构造函数）
rabbit9898
11-09 376
注意： 在lucene2.9中，排序的字段域必须indexed但是不能tokenized。因为虽然tokenized后虽然可以排序，但是有可能不是你想要的结果，因为tokenized可能会去除停用词或者大小写转换等。 (in Lucene 2.9 and when reading java doc for the Sort class I noticed it says "The f...
Lucene的高级使用之排序
qq_40208605的博客
04-28 272
/ 排序 @Test public void testSortQuery() throws Exception { // 目录对象 Directory directory = FSDirectory.open(new File("indexDir")); // 创建读取工具 IndexReader reader = ...
lucene自定义排序实现
05-24
因此，了解如何在 Lucene 中实现自定义排序是非常关键的。在这个话题中，我们将深入探讨如何根据特定的业务需求对搜索结果进行定制排序。 首先，我们要明白 Lucene 默认的排序机制。默认情况下，Lucene 搜索结果是...
Lucene5学习之自定义排序
08-10
本文将深入探讨“Lucene5学习之自定义排序”这一主题，帮助你理解如何在Lucene5中实现自定义的排序规则。 首先，Lucene的核心功能之一就是提供高效的全文检索能力，但默认的搜索结果排序通常是基于相关度得分...
lucene 自定义评分
05-01
本文将深入探讨如何在 Lucene 中实现自定义评分，以及它对提高搜索质量的重要性。 在 Lucene 中，每个匹配文档都会有一个评分，这个评分通常基于 TF-IDF（词频-逆文档频率）算法，它是衡量一个词在文档中重要性的...
全文检索lucene学习笔记(五)
【昆山人在上海】
06-08 883
Lucene实现对查询结果的排序：Sort sort = new Sort(new SortField("isbn", false)); //单个字段Sort sort = new Sort(new SortField[]{new SortField("isbn", false), new SortField("pbl_dt", true)}); //多个字段其中,SortField的
C# Asp.net中使用Elasticsearch5.x 的NEST客户端
coderK2014
03-21 1165
一、事前准备： 1、安装： elasticsearch-5.6.2 2、引用： Elasticsearch.Net（这里使用的是6.0.0） Nest（这里使用的是6.0.0） 二、映射（简单映射，sku嵌套在spu中）： //IdProperty指定主键 [ElasticsearchType(Name = "ES_GoodsSpu", IdProperty = "Good...
Lucene性能优化之使用Lucene预排序加速搜索速度
起跑人生,追逐梦想,超越现实
12-30 588
　　                                                                                                                  简单说搜索个过程，Lucene 在搜索的程序简单分成两部分，搜索与排序。高手请忽略下面我的讲解。 　　搜索： 　　　通过倒排的索引找到对应的 docId 集，...
Lucene系列五：Field域
布道
10-19 4985
为何要写这一篇呢？主要是为了补充上一篇《系统架构及核心模块》中的章节，Field是文档中的域，包括Field名和Field值两部分，一个文档可以包括多个Field，Document只是Field的一个承载体，Field值即为要索引的内容，也是要搜索的内容。 1.最基本常用属性 是否分词(tokenized) 是：作分词处理，即将Field值进行分词，分词的目的是为了索引 ...
lucene-使用自定义排序方法
深未来技术
12-24 490
计算基点与索引库中每个地理位置的距离，按距离大小排序。基点为(0,0)，计算从(0,0)到地图中各个地方的距离，然后依此排序，但地方进行了分类，包括restaurant、school、shop。这些类放在一个type域中，1、通过实现SortComparatorSource接口来完成自定义排序。对每个类分别完成计算基点到这些类的地方的距离public class DistanceCompa
Lucene教程详解
kanwoerzi
09-26 481
Lucene-3.0.0配置 一、Lucene开发环境配置 step1.Lucene开发包下载 step2.Java开发环境配置 step3.Tomcat安装 step4.Lucene开发环境配置 解压下载的lucene-3.0.0.zip，可以看到lucene-core-3.0.0.jar和lucene-demos-3.0.0.jar这两个文件,将其解压...
Lucene中的各种Field字段
qq_28702747的博客
03-10 5419
Lucene的Field说明Lucene存储对象是以document为存储单元，对象中相关的属性值则存放到Field中；lucene中所有Field都是IndexableField接口的实现[html] view plain copyorg.apache.lucene.index.IndexableField      Represents a single field for indexing....
Lucene 中的 自定义排序的实现
baggio785的专栏
02-19 2372
Lucene 中的 自定义排序的实现 使用Lucene来搜索内容,搜索结果的显示顺序当然是比较重要的.Lucene中Build-in的几个排序定义在大多数情况下是不适合我们使用的.要适合自己的应用程序的场景,就只能自定义排序功能,本节我们就来看看在Lucene中如何实现自定义排序功能.Lucene中的自定义排序功能和Java集合中的自定义排序的实现方法差不多,都要实现一下比较接口. 在Java
Lucene Java 自定义排序实现详解
在Lucene中，自定义排序是一项关键功能，它允许用户根据特定的需求对搜索结果进行排序，而不仅仅依赖于默认的分数排序。为了实现这个功能，Lucene提供了SortComparatorSource和ScoreDocComparator两个接口。 首先，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值