06-lucene自定义评分-（分数会很高）和域评分-（查后缀为.txt和.ini）

最新推荐文章于 2018-10-29 23:15:46 发布
最新推荐文章于 2018-10-29 23:15:46 发布
阅读量837 收藏
点赞数
分类专栏： lucene
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shuangrenyu1234/article/details/45152941
版权 
package org.itat.lucene.util;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.Random;

import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.NumericField;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;

public class FileIndexUtil {
	private static Directory directory = null;
	static {
		try {
			directory = FSDirectory.open(new File("d:/lucene/files"));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static Directory getDirectory() {
		return directory;
	}

	/**
	 *@MethodName:index
	 *@Description:创建索引
	 *@param hasNew是否要新建索引
	 *@author:半仙儿
	 *@return void
	 *@date:2015-4-15下午04:05:04
	 */
	public static void index(boolean hasNew) {
		IndexWriter writer = null;
		try {
			writer = new IndexWriter(directory, new IndexWriterConfig(
					Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35)));
			if (hasNew) {
				writer.deleteAll();
			}
			File file = new File("d:/lucene/example");
			Document doc = null;
			
			//定义一个随机数
			Random ran=new Random();
			
			for (File f : file.listFiles()) {
				//分数
				int score=ran.nextInt(600);
				
				doc = new Document();
				doc.add(new Field("content", new FileReader(f)));
				doc.add(new Field("filename", f.getName(), Field.Store.YES,
						Field.Index.NOT_ANALYZED));
				doc.add(new Field("path", f.getAbsolutePath(), Field.Store.YES,
						Field.Index.NOT_ANALYZED));
				doc.add(new NumericField("date", Field.Store.YES, true)
						.setLongValue(f.lastModified()));
				doc.add(new NumericField("size", Field.Store.YES, true)
						.setIntValue((int) f.length()));
				doc.add(new NumericField("score",Field.Store.NO,true).setIntValue(score));
				writer.addDocument(doc);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (writer != null)
					writer.close();
			} catch (CorruptIndexException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

TestSearch.java（需要重新建立索引）

package org.itat.lucene.test;

import org.apache.lucene.index.Term;
import org.apache.lucene.search.Filter;
import org.apache.lucene.search.NumericRangeFilter;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.QueryWrapperFilter;
import org.apache.lucene.search.Sort;
import org.apache.lucene.search.SortField;
import org.apache.lucene.search.TermRangeFilter;
import org.apache.lucene.search.WildcardQuery;
import org.itat.lucene.util.FileIndexUtil;
import org.itat.lucene.util.SearchTest;
import org.junit.Before;
import org.junit.Test;

public class TestSearch {
	private SearchTest st;

	@Before
	public void init() {
		st = new SearchTest();
	}

	@Test
	public void index() {
		FileIndexUtil.index(true);
	}

	@Test
	public void test01() {
		// 不进行排序
		st.searcherBySort("java", Sort.INDEXORDER);
		// 以Doc的Id进行排序
		// st.searcherBySort("java", Sort.INDEXORDER);
		// 通过评分进行排序--设置了排序，就不能看到评分了。
		// st.searcherBySort("java", Sort.RELEVANCE);
		// 根据文件的大小进行排序
		// st.searcherBySort("java", new Sort(new SortField("size",
		// SortField.INT)));
		// 通过日期进行排序
		// st.searcherBySort("java", new Sort(new SortField("date",
		// SortField.LONG)));
		// 通过文件名进行排序
		// st.searcherBySort("java", new Sort(
		// new SortField("filename", SortField.STRING)));
		// 使用降序进行排序(通过设置SortField的最后的一个参数设置降序排序)
		// st.searcherBySort("java", new Sort(new SortField("filename",
		// SortField.STRING, true)));
		// 根据文件的大小和评分进行排序
		st.searcherBySort("java", new Sort(
				new SortField("size", SortField.INT), SortField.FIELD_SCORE));

	}

	@Test
	public void test02() {
		Filter tr = new TermRangeFilter("filename", "java.hhh", "java.ttt",
				true, true);
		tr = NumericRangeFilter.newIntRange("size", 500, 4900, true, true);
		//通过query进行过滤
		tr = new QueryWrapperFilter(new WildcardQuery(new Term("filename",
				"*.ff")));
		st.searcherByFilter("java", tr);
	}

	@Test
	public void test03() {
		Query query = new WildcardQuery(new Term("filename", "c*"));
		st.searcherByQuery(query);
	}
}
MyScoreQuery.java 
package org.itat.lucene.util;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

import org.apache.lucene.document.Document;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.FieldCache;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.search.function.CustomScoreProvider;
import org.apache.lucene.search.function.CustomScoreQuery;
import org.apache.lucene.search.function.FieldScoreQuery;
import org.apache.lucene.search.function.ValueSourceQuery;
import org.apache.lucene.search.function.FieldScoreQuery.Type;

/**
 * @ProjectName:lucene_advance_search2 
 * @ClassName:MyScoreQuery  
 * @Description:自定义评分排序
 * @date: 2015-4-20下午05:25:26
 * @author: 半仙儿
 * @version: V1.0
 * @date:2015-4-20下午05:25:26
 */
public class MyScoreQuery {
	public void searchByScoreQuery() {
		try {
			IndexSearcher searcher = new IndexSearcher(IndexReader
					.open(FileIndexUtil.getDirectory()));
			Query q = new TermQuery(new Term("content", "java"));
			// 1.创建一个评分域
			FieldScoreQuery fd = new FieldScoreQuery("score", Type.INT);
			// 2.根据评分域和原有的Query，创建自定义的Query对象
			MycustomScoreQuery query = new MycustomScoreQuery(q, fd);
			TopDocs tds = null;
			tds = searcher.search(query, 100);
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			for (ScoreDoc sd : tds.scoreDocs) {
				Document d = searcher.doc(sd.doc);
				System.out.println(sd.doc + ":(" + sd.score + ")["
						+ d.get("filename") + "[" + d.get("path") + "]-->"
						+ d.get("size") + "----"
						+ sdf.format(new Date(Long.valueOf(d.get("date"))))
						+ "]");
			}
			searcher.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	@SuppressWarnings("serial")
	private class FilenameScoreQuery extends CustomScoreQuery {

		public FilenameScoreQuery(Query subQuery) {
			super(subQuery);
		}

		@Override
		protected CustomScoreProvider getCustomScoreProvider(IndexReader reader)
				throws IOException {
			return new FilenameScoreProvider(reader);
		}
	}

	@SuppressWarnings("unused")
	private class FilenameScoreProvider extends CustomScoreProvider {
		String[] filenames = null;

		public FilenameScoreProvider(IndexReader reader) {
			super(reader);
			try {
				filenames = FieldCache.DEFAULT.getStrings(reader, "filename");
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

		@Override
		public float customScore(int doc, float subQueryScore, float valSrcScore)
				throws IOException {
			// 如何根据Field的名称获取相应的field的值
			// 在reader没有关闭之前，所有的数据会存储到一个域缓存中，可以通过域缓存获取很多有用的东西
			// filenames=FieldCache.DEFAULT.getStrings(reader,
			// "filename");可以获取所有的filename域的信息
			String filename=filenames[doc];
			
					if(filename.endsWith(".txt")||filename.endsWith(".ini")){
						return subQueryScore*1.5f;
					}	
					return subQueryScore/1.5f;
		}	
	}

	public void searchByFileScoreQuery() {
		try {
			IndexSearcher searcher = new IndexSearcher(IndexReader
					.open(FileIndexUtil.getDirectory()));
			Query q = new TermQuery(new Term("content", "java"));
			// 2.根据评分域和原有的Query，创建自定义的Query对象
			FilenameScoreQuery query = new FilenameScoreQuery(q);
			TopDocs tds = null;
			tds = searcher.search(query, 100);
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			for (ScoreDoc sd : tds.scoreDocs) {
				Document d = searcher.doc(sd.doc);
				System.out.println(sd.doc + ":(" + sd.score + ")["
						+ d.get("filename") + "[" + d.get("path") + "]-->"
						+ d.get("size") + "----"
						+ sdf.format(new Date(Long.valueOf(d.get("date"))))
						+ "]");
			}
			searcher.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	
	
	
	
	
	
	
	
	
	
	
	
	@SuppressWarnings("serial")
	private class MycustomScoreQuery extends CustomScoreQuery {
		// 构造方法
		public MycustomScoreQuery(Query subQuery, ValueSourceQuery valSrcQuery) {
			super(subQuery, valSrcQuery);
		}

		@Override
		protected CustomScoreProvider getCustomScoreProvider(IndexReader reader)
				throws IOException {
			return super.getCustomScoreProvider(reader);
		}

	}
}
TestCustomScore.java 
package org.itat.lucene.test;

import org.itat.lucene.util.MyScoreQuery;
import org.junit.Test;

public class TestCustomScore {
	@Test
	public void test01() {
		MyScoreQuery msq = new MyScoreQuery();
		msq.searchByScoreQuery();
	}

	@Test
	public void test02() {
		MyScoreQuery msq = new MyScoreQuery();
		msq.searchByFileScoreQuery();
	}
}

SearchTest.java 

package org.itat.lucene.util;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.Filter;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.Sort;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.util.Version;

public class SearchTest {
	// 高效获取indexReader
	private static IndexReader reader = null;
	static {
		try {
			reader = IndexReader.open(FileIndexUtil.getDirectory());
		} catch (CorruptIndexException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public IndexSearcher getSeacher() {
		try {
			if (reader == null) {
				reader = IndexReader.open(FileIndexUtil.getDirectory());
			} else {
				IndexReader tr = IndexReader.openIfChanged(reader);
				if (tr != null) {
					reader.close();
					reader = tr;
				}
			}
			return new IndexSearcher(reader);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	public void searcherByFilter(String queryStr, Filter filter) {
		try {
			IndexSearcher searcher = getSeacher();
			QueryParser parser = new QueryParser(Version.LUCENE_35, "content",
					new StandardAnalyzer(Version.LUCENE_35));
			Query query = parser.parse(queryStr);
			TopDocs tds = null;
			if (filter != null) {
				tds = searcher.search(query, filter, 50);
			} else {
				tds = searcher.search(query, 50);
			}
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			for (ScoreDoc sd : tds.scoreDocs) {
				Document d = searcher.doc(sd.doc);
				System.out.println(sd.doc + ":(" + sd.score + ")["
						+ d.get("filename") + "[" + d.get("path") + "]-->"
						+ d.get("size") + "----"
						+ sdf.format(new Date(Long.valueOf(d.get("date"))))
						+ "]");
			}
			searcher.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void searcherByQuery(Query queryStr) {
		try {
			IndexSearcher searcher = getSeacher();
			TopDocs tds = null;
			tds = searcher.search(queryStr, 50);
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			for (ScoreDoc sd : tds.scoreDocs) {
				Document d = searcher.doc(sd.doc);
				System.out.println(sd.doc + ":(" + sd.score + ")["
						+ d.get("filename") + "[" + d.get("path") + "]-->"
						+ d.get("size") + "----"
						+ sdf.format(new Date(Long.valueOf(d.get("date"))))
						+ "]");
			}
			searcher.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void searcherBySort(String queryStr, Sort sort) {
		try {
			IndexSearcher searcher = getSeacher();
			QueryParser parser = new QueryParser(Version.LUCENE_35, "content",
					new StandardAnalyzer(Version.LUCENE_35));
			Query query = parser.parse(queryStr);
			TopDocs tds = null;
			if (sort != null) {
				tds = searcher.search(query, 50, sort);
			} else {
				tds = searcher.search(query, 50);
			}
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			for (ScoreDoc sd : tds.scoreDocs) {
				Document d = searcher.doc(sd.doc);
				System.out.println(sd.doc + ":(" + sd.score + ")["
						+ d.get("filename") + "[" + d.get("path") + "]-"+d.get("score")+"->"
						+ d.get("size") + "----"
						+ sdf.format(new Date(Long.valueOf(d.get("date"))))
						+ "]");
			}
			searcher.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}


会编程的阿强
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【lucene】lucene自定义评分
九师兄
02-11 265
1.概述 @SuppressWarnings("serial") private class MyCustomScoreQuery extends CustomScoreQuery { public MyCustomScoreQuery(Query subQuery, ValueSourceQuery valSrcQuery) { super(subQuery, valSrcQuery); } @Override protected CustomScoreProvi.
lucene 自定义评分
05-01
lucene 自定义评分 实现 增加自定义的权重
Lucene自定义评分查询
weixin_30735391的博客
04-22 83
1 package com.lucene.score; 2 3 import java.io.IOException; 4 import java.sql.Date; 5 import java.text.SimpleDateFormat; 6 7 import org.apache.lucene.document.Document; 8 im...
lucene学习之自定义评分
小魏的博客
04-21 372
想要根据城市来自定义评分，原来的输出： 根据【你好.我是jack】 一共找到3文件 编号：0 分数: 1.0 id: 1 city: 北京 编号：1 分数: 1.0 id: 2 city: 南京 编号：2 分数: 1.0 id: 3 city: 上海 自己新建的query对象： public class MyFieldScoreQuery extends CustomScore
lucene自定义评分域
千丈之松的专栏
11-25 2873
搜索查询业务场景： 1：搜索一组数据，这些数据录入时间在3个月之内；提高权重。1年以内，权重不变；1年以前，降低查询权重； 2：如果 是vip客户，提高该用户下所在查询文档权重（类似百度的竞价排名）； 分析：有两种思路 第一种方式：在构建索引的时候，根据业务，去构建索引，第二种方式：自定义评分
hanlp-lucene-plugin：HanLP中文分词Lucene插件，支持包括Solr内置的基于Lucene的系统
02-03
hanlp-lucene-pluginHanLP中文分词Lucene插件基于HanLP，支持包括Solr（7.x）在内的任何基于Lucene（7.x）的系统。Maven < dependency> < groupId>...
lucene-core-3.0.0.rar_lucene_lucene-core3
09-20
学习Java搜索引擎，不妨看看这个，有助你的Java水平提高
apache-lucene-snowball.jar
03-08
jar包，亲测可用
搜索引擎-基于Lucene的主题搜索引擎研究.pdf
06-26
搜索引擎-基于Lucene的主题搜索引擎研究.pdf
scala-akka-http-lucene:使用Akka-http和Lucene在Scala中使用Rest API
05-19
scala-akka-http-lucene 使用Akka-http和Lucene在Scala中使用Rest API
Lucene笔记24-Lucene的使用-自定义评分简介
王劭阳的博客
10-29 367
一、自定义评分流程 有时候，Lucene提供的计算评分规则可能不符合业务需求，所以我们需要自定义评分规则，来实现自定义评分。自定义评分的流程：创建一个类继承CustomScoreQuery、重写getCustomScoreProvider()方法、创建CustomScoreProvider类、重写customScore()方法。 二、代码实现 package com.wsy; impor...
【Lucene3.6.2入门系列】第08节_高级搜索之自定义评分
半步多
08-19 1870
完整版见https://jadyer.github.io/2013/08/19/lucene-advanced-search-score/
lucene6中自定义评分的方法
u013905744的专栏
07-24 2135
仍然在上篇博客案例的基础上，来实现lucene6中的自定义评分。 案例参考：lucene6中的创建正排索引以及进行字段排序的方法 与上面案例不同的一点是，在这里，添加了一个score字段，用来表示我们的评分域。 创建索引FileIndexUtils01类 public class FileIndexUtils01 { private static Directory direct...
Lucene3.5自定义评分以及根据域进行自定义评分设定
西楚小羽的专栏
03-29 1165
一、首先来综述一下Lucene自定义评分的步骤： 1、创建一个评分域 FieldScoreQuery fd = new FieldScoreQuery("score", Type.INT); 2、根据评分域和原有的query创建自定义的query对象 MyCustomScoreQuery query = new MyCustomScoreQuery(q, fd);@SuppressWa
18、学习Lucene3.5索引之自定义评分
panchang199266的博客
03-02 207
/** * 自定义评分流程： * 1.创建一个评分域 * 2.根据原有Query（termQuery）和评分域Query（scoreQuery）创建自定义的MyCustomScoreQuery对象 * 2.1创建自定义的MyCustomScoreQuery对象 * 2.2重载“getCustomScoreProvider()”方法 * 3.自定义评分步骤： * ...
【Lucene】Lucene通过CustomScoreQuery实现自定义评分
weixin_33933118的博客
06-12 188
建立业务查询的query，该query嵌套在自定义评分CustomScoreQuery中，从而为query添加了自定义评分功能Queryquery=newTermQuery(newTerm("name","myname")); query=newProductCustomScoreQuery(query);从上一步可以看出, 我们需要新建一个ProductC...
Lucene4.10使用教程(八)：Lucene的自定义评分(2)
七夜之家
01-14 2527
第二种自定义评分的实现方式如下： **  * 自定义评分的第二种写法，基于FunctionQuery  * (1)创建类并继承ValueSource  * (2)重写getValues方法  * @author Johnny  *  */ public class MySelfScore2 {     public void searchBySelfScore(){      
lucene实现自定义的评分
学习笔记
05-01 4876
1、工程目录 2、自定义评分一、根据文件大小来评分，文件越大，权重越低 package util; import java.io.IOException; import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.Term; import org.apache.lucene.search.In
Lucene知识小总结7:评分设置
weixin_33911824的博客
02-23 148
2019独角兽企业重金招聘Python工程师标准>>> ...
apache.lucene:lucene-lucene
最新发布
05-25
Apache Lucene是一个开源的全文搜索引擎库。它提供了一组简单的API，用于索引和搜索文本文件。lucene-lucene是Lucene项目的核心组件，提供了索引和搜索的基本功能。此外，Lucene还提供了许多其他组件，例如分词器、查询解析器和评分器，可以根据需要选择使用。Lucene被广泛用于各种应用程序，例如搜索引擎、电子邮件客户端和内容管理系统。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

会编程的阿强

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值