安科网

lucene入门

exitzhang

exitzhang

2011-08-12

关注 关注

lucene是一个高性能，可伸缩的全文搜索工具包，可以使用它为你的应用程序添加索引和搜索能力，下面是一个建立索引，并对索引进行查询的小例子

package com.lamp.lucene.util;

import java.io.File;

import org.apache.lucene.document.Document;
import org.apache.lucene.document.NumberTools;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.Term;
import org.junit.Test;

public class IndexDaoTest {

	// 需要建立索引的数据源目录
	public String dataPath = "D:\\javaEEProject\\Lucene\\dataPath";

	// 具体的数据源文件路径
	public String filePath = "D:\\javaEEProject\\Lucene\\dataPath\\JDBC.txt";
	public String filePath2 = "D:\\javaEEProject\\Lucene\\dataPath\\反射机制.txt";

	public IndexDao indexDao = new IndexDao();

	/**
	 * 对数据源文件建立索引
	 */
	@Test
	public void testSave() throws Exception {
		File file = new File(dataPath);
		traverseFile(file);
	}

	/**
	 * 对目录下的文件进行遍历并对后缀为.txt的文件建立索引
	 */
	public void traverseFile(File file) throws Exception {
		if (file.isDirectory()) {
			File[] files = file.listFiles();
			for (File f : files) {
				traverseFile(f);
			}
		}
		if (file.getName().endsWith(".txt")) {
			Document doc = FileToDocument.fileToDocument(file);
			indexDao.save(doc);
		}

	}

	/**
	 * 删除指定文件的索引文件
	 */
	@Test
	public void testDelete() {
		Term term = new Term("path", filePath);
		indexDao.delete(term);
	}

	/**
	 * 更新指定文件的索引
	 */
	@Test
	public void testUpdate() throws Exception {
		Term term = new Term("path", filePath);
		Document doc = FileToDocument.fileToDocument(filePath);
		doc.getField("content").setValue("这是更新后的文件内容");
		indexDao.update(term, doc);
	}

	/**
	 * 根据关键字对索引文件进行查询
	 */
	@Test
	public void testSearch() {
		String queryString = "操作";
		// search(queryString, 0, 10)说的是从第一条匹配结果开始，返回最多前10条记录
		QueryResult qr = indexDao.search(queryString, 0, 10);
		System.out.println("总共有" + qr.getRecordCount() + "条匹配结果");
		for (Document doc : qr.getRecordList()) {
			System.out.println(doc.get("name"));
			System.out.println(doc.get("content"));
			System.out.println(NumberTools.stringToLong(doc.get("size")));
		}
	}

}
package com.lamp.lucene.util;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.Field.Index;
import org.apache.lucene.document.Field.Store;
import org.apache.lucene.document.NumberTools;

public class FileToDocument {

	//对其name,content字段建立索引
	public static Document fileToDocument(String dataPath) throws Exception {
		File file = new File(dataPath);
		Document doc = new Document();
		doc.add(new Field("name", file.getName(), Store.YES, Index.ANALYZED));
		doc.add(new Field("content", getContent(file), Store.YES,
				Index.ANALYZED));
		doc.add(new Field("size", NumberTools.longToString(file.length()), Store.YES,
				Index.NOT_ANALYZED));
		doc.add(new Field("path", file.getAbsolutePath(), Store.YES,
				Index.NOT_ANALYZED));
		return doc;

	}

	//返回文件内容
	private static String getContent(File file) throws Exception {
		StringBuffer buffer = new StringBuffer();
		BufferedReader reader = null;
		reader = new BufferedReader(new FileReader(file));
		String str = "";
		while (null != (str = reader.readLine())) {
			buffer.append(str).append("\n");
		}
		return buffer.toString();
	}

	public static Document fileToDocument(File file) throws Exception {
		Document doc = new Document();
		doc.add(new Field("name", file.getName(), Store.YES, Index.ANALYZED));
		doc.add(new Field("content", getContent(file), Store.YES,
				Index.ANALYZED));
		doc.add(new Field("size", NumberTools.longToString(file.length()), Store.YES,
				Index.NOT_ANALYZED));
		doc.add(new Field("path", file.getAbsolutePath(), Store.YES,
				Index.NOT_ANALYZED));
		return doc;
	}

}
package com.lamp.lucene.util;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import jeasy.analysis.MMAnalyzer;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.NumberTools;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriter.MaxFieldLength;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryParser.MultiFieldQueryParser;
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.RangeFilter;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.Sort;
import org.apache.lucene.search.SortField;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.search.highlight.Formatter;
import org.apache.lucene.search.highlight.Fragmenter;
import org.apache.lucene.search.highlight.Highlighter;
import org.apache.lucene.search.highlight.QueryScorer;
import org.apache.lucene.search.highlight.Scorer;
import org.apache.lucene.search.highlight.SimpleFragmenter;
import org.apache.lucene.search.highlight.SimpleHTMLFormatter;

public class IndexDao {

	public String indexPath = "D:\\javaEEProject\\Lucene\\indexPath";

	public Analyzer analyzer = new MMAnalyzer();// 词库分词

	/**
	 * 添加/创建索引
	 */
	public void save(Document doc) {
		IndexWriter indexWriter = null;
		try {
			indexWriter = new IndexWriter(indexPath, analyzer,
					MaxFieldLength.LIMITED);
			indexWriter.addDocument(doc);
		} catch (Exception e) {
			throw new RuntimeException(e);
		} finally {
			try {
				if (indexWriter != null) {
					indexWriter.close();
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * Term是搜索的最小单位，代表某个 Field 中的一个关键词，如：<title, lucene>
	 * new Term( "title", "lucene" );
	 * new Term( "id", "5" );
	 * new Term( "id", UUID );
	 */
	public void delete(Term term) {
		IndexWriter indexWriter = null;
		try {
			indexWriter = new IndexWriter(indexPath, analyzer,
					MaxFieldLength.LIMITED);
			indexWriter.deleteDocuments(term);
		} catch (Exception e) {
			throw new RuntimeException(e);
		} finally {
			try {
				indexWriter.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 更新索引
	 * 
	 * <pre>
	 * indexWriter.deleteDocuments(term);
	 * indexWriter.addDocument(doc);
	 * </pre>
	 * 
	 * @param term
	 * @param doc
	 */
	public void update(Term term, Document doc) {
		IndexWriter indexWriter = null;
		try {
			indexWriter = new IndexWriter(indexPath, analyzer,
					MaxFieldLength.LIMITED);
			indexWriter.updateDocument(term, doc);
		} catch (Exception e) {
			throw new RuntimeException(e);
		} finally {
			try {
				indexWriter.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * <pre>
	 * totalPage = recordCount / pageSize;
	 * if (recordCount % pageSize &gt; 0)
	 * 	totalPage++;
	 * </pre>
	 * 
	 */
	/*
	 * public QueryResult search(String queryString, int firstResult, int
	 * maxResults) { try { // 1，把要搜索的文本解析为 Query String[] fields = { "name",
	 * "content" }; Map<String, Float> boosts = new HashMap<String, Float>();
	 * boosts.put("name", 3f); // boosts.put("content", 1.0f); 默认为1.0f
	 * 
	 * QueryParser queryParser = new MultiFieldQueryParser(fields, analyzer,
	 * boosts); Query query = queryParser.parse(queryString);
	 * 
	 * return search(query, firstResult, maxResults); } catch (Exception e) {
	 * throw new RuntimeException(e); } }
	 */

	public QueryResult search(String queryString, int firstResult,
			int maxResults) {
		try {
			//在索引字段name,content上进行查询
			String[] fields = { "name", "content" };
			// 设置字段相关度,默认相关度为1f
			Map<String, Float> boosts = new HashMap<String, Float>();
			boosts.put("name", 5f);

			QueryParser queryParser = new MultiFieldQueryParser(fields,
					analyzer,boosts);
			// 1，把要搜索的文本解析为 Query
			Query query = queryParser.parse(queryString);

			return search(query, firstResult, maxResults);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	public QueryResult search(Query query, int firstResult, int maxResults) {
		IndexSearcher indexSearcher = null;

		try {
			// 2，进行查询
			indexSearcher = new IndexSearcher(indexPath);
			//限定所查询文件的大小在200-1000之间
			Filter filter = new RangeFilter("size",
					NumberTools.longToString(200),
					NumberTools.longToString(1000), true, true);

			// 自定义排序，此处是按照文档大小进行排序
			Sort sort = new Sort();
			sort.setSort(new SortField("size")); // 默认为升序
			// sort.setSort(new SortField("size", true));此为降序
			
			//TopDocs topDocs = indexSearcher.search(query, filter, 10000, sort);
			
			TopDocs topDocs = indexSearcher.search(query, null, 10000, sort);
			//查询到的匹配结果数
			int recordCount = topDocs.totalHits;
			List<Document> recordList = new ArrayList<Document>();

			// 准备高亮器,所谓高亮就是对查询到的关键字进行字体颜色的改变或者为其设置超链接
			Formatter formatter = new SimpleHTMLFormatter("<font color='red'>",
					"</font>");
			Scorer scorer = new QueryScorer(query);
			Highlighter highlighter = new Highlighter(formatter, scorer);

			Fragmenter fragmenter = new SimpleFragmenter(50);
			highlighter.setTextFragmenter(fragmenter);

			// 3，取出当前页的数据
			int end = Math.min(firstResult + maxResults, topDocs.totalHits);
			for (int i = firstResult; i < end; i++) {
				ScoreDoc scoreDoc = topDocs.scoreDocs[i];
				// 文档内部编号
				int docSn = scoreDoc.doc; 
				// 根据编号取出相应的文档
				Document doc = indexSearcher.doc(docSn); 
				// 返回高亮后的结果，如果当前属性值中没有出现关键字，会返回 null
				String hc = highlighter.getBestFragment(analyzer, "content",
						doc.get("content"));
				if (hc == null) {
					String content = doc.get("content");
					int endIndex = Math.min(50, content.length());
					// 最多前50个字符
					hc = content.substring(0, endIndex);
				}
				doc.getField("content").setValue(hc);
				recordList.add(doc);
			}

			// 返回结果
			return new QueryResult(recordCount, recordList);
		} catch (Exception e) {
			throw new RuntimeException(e);
		} finally {
			try {
				indexSearcher.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}
package com.lamp.lucene.util;

import java.util.List;

import org.apache.lucene.document.Document;

/**
 * 
 * QueryResult封装的是匹配结果数和Document集合
 */
public class QueryResult {
	private int recordCount;
	private List<Document> recordList;

	public QueryResult(int recordCount, List<Document> recordList) {
		super();
		this.recordCount = recordCount;
		this.recordList = recordList;
	}

	public int getRecordCount() {
		return recordCount;
	}

	public void setRecordCount(int recordCount) {
		this.recordCount = recordCount;
	}

	public List<Document> getRecordList() {
		return recordList;
	}

	public void setRecordList(List<Document> recordList) {
		this.recordList = recordList;
	}

}

当然除了关键字查询外，还有文件大小范围进行查询，通配符查询，短语查询，布尔查询，示例如下

package com.lamp.lucene.util;

import org.apache.lucene.document.Document;
import org.apache.lucene.document.NumberTools;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.BooleanClause.Occur;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.PhraseQuery;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.RangeQuery;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.WildcardQuery;
import org.junit.Test;


public class QueryTest {
	
	public IndexDao indexDao = new IndexDao();

	/**
	 * 关键字查询，即对指定的列上进行查询
	 */
	@Test
	public void testTermQuery(){
		Term term = new Term("name", "反射");
		Query query = new TermQuery(term);
		QueryResult result = indexDao.search(query, 0, 100);
		printResult(result);
	}

	/**
	 * 按照文件大小范围进行查询,由于数字字符串比较大小时由于位数不同易产生问题，这里统一将数字用工具类
	 * NumberTools.longToString(long a)进行转化
	 */
	@Test
	public void testRangeQuery(){
		Term lowerTerm = new Term("size",NumberTools.longToString(200));
		Term upperTerm = new Term("size",NumberTools.longToString(1000));
		
		Query query = new RangeQuery(lowerTerm, upperTerm, true);
		QueryResult result = indexDao.search(query, 0, 100);
		printResult(result);
	}
	
	/**
	 * 通配符查询
	 * ‘？’代表一个字符，‘*’代表0个或多个字符
	 */
	@Test
	public void testWildcardQuery(){
		Term term = new Term("name","jd*");
		Query query = new WildcardQuery(term);
		QueryResult result = indexDao.search(query, 0, 100);
		printResult(result);
	}
	
	/**
	 * 短语查询，比如你想查一首歌曲，里面有两个词语，但是这两个词语之间又隔着若干个词语，这时候可以选择短语查询
	 */
	@Test
	public void testPhraseQuery(){
		PhraseQuery query = new PhraseQuery();
		query.add(new Term("content","反射"));
		query.add(new Term("content","属性"));
		//设定最大间隔数为10
		query.setSlop(10);
		QueryResult result = indexDao.search(query, 0, 100);
		printResult(result);
	}
	/**
	 * 布尔查询，即对查询条件进行多项指定，不如大小，内容等
	 */
	@Test
	public void testBoolQuery(){
		Term lowerTerm = new Term("size",NumberTools.longToString(200));
		Term upperTerm = new Term("size",NumberTools.longToString(1000));
		Query query1 = new RangeQuery(lowerTerm, upperTerm, true);
		
		PhraseQuery query2 = new PhraseQuery();
		query2.add(new Term("content","反射"));
		query2.add(new Term("content","属性"));
		//设定最大间隔数为10 
		query2.setSlop(10);
		
		BooleanQuery booleanQuery = new BooleanQuery();
		//Occur.MUST指定的条件必须满足
		booleanQuery.add(query1, Occur.MUST);
		booleanQuery.add(query2, Occur.MUST);
		QueryResult result = indexDao.search(booleanQuery, 0, 100);
		printResult(result);
	}
	
	public void printResult(QueryResult result) {
		System.out.println("找到的匹配结果有:" + result.getRecordCount() + "条");
		for(Document doc : result.getRecordList()){
			System.out.println(doc.get("name"));
			System.out.println(doc.get("content"));
		}
	}
	
}

我使用的lucene版本是2.4，引入的jar包有lucene-core-2.4.0.jar,lucene-highlighter-2.4.0.jar,lucene-analyzers-2.4.0.jar,je-analysis-1.5.3.jar

lucene apache

exitzhang

exitzhang

0 关注 0 粉丝 0 动态

关注 关注

相关推荐

MAC OS 10.15 Lucene 源码分析环境搭建

lucene-solr 的github 项目中的 README 其实已经讲得很清楚了，但搭一个大项目的环境还是耗时耗力的。如果出现下载失败的问题，不用担心，重试就好。3，安装ant，我这里安装的是：Apache Ant version 1.10.8 com

Jacry 2020-07-04

十张图说清Elasticsearch原理！

说到 Elasticsearch，其中最明显的一个特点就是 near real-time 准实时，当文档存储在 Elasticsearch 中时，将在 1 秒内以几乎实时的方式对其进行索引和完全搜索。Segment：也叫段，类似于倒排索引，相当于一个数据

renjinlong 2020-09-03

由于Elasticsearch是在 Lucene 基础上构建

本文已经收录至我的GitHub,欢迎大家踊跃star 和 issues。为什么写Elasticsearch系列文章？后面会说到，Elasticsearch是搜索引擎，但不简单只能使用在搜索领域，他可以作用的场景非常多。Elastic 于 2018 年 6

IceStreamLab 2020-06-26

Spring Boot 教程 - Elasticsearch

它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java语言开发的，并作为Apache许可条款下的开放源码发布，是一种流行的企业级搜索引擎。Elasticsearch用于云计算中，能够达到实时搜索，

mengyue 2020-06-09

全文搜索Lucene之倒排索引

倒排索引源于实际应用中需要根据属性的值来查找记录。带有倒排索引的文件我们称为倒排索引文件，简称倒排文件。Lucerne使用的是倒排文件索引结构。

PasserbyX 2020-05-16

Elasticsearch用得好，下班下得早！

入行 Elastic-Stack 技术栈很久了，为了免于知识匮乏眼光局限，有必要到外面的世界看看，丰富自己的世界观。哪些应用场景下使用 Elasticsearch 最佳?Elasticseach 从做搜索引擎开始，到现在主攻大数据分析领域，逐步进化成了一个

mameng 2020-05-12

Elasticsearch对垒8大竞品技术，孰优孰劣？

李猛，Elastic-stack产品深度用户，ES认证工程师，2012年接触Elasticsearch，对Elastic-Stack开发、架构、运维等方面有深入体验，实践过多种Elasticsearch项目，最暴力的大数据分析应用，最复杂的业务系统应用;业

心丨悦 2020-05-06

1.elasticsearch单节点部署

就是一个jar包，里面包含了封装好的各种建立倒排索引，以及进行搜索的代码，包含各种算法，我们就用java开发的时候，引入lucene jar，然后基于lucene的api去进行开发就可以了，我们就可以将已有的数据数据建立索引，lucene会在本地磁盘上面，

编码之路 2020-05-03

lucene和Elasticsearch

归结为一句话倒排指的是把的关系颠倒为。nohup npm run start > /dev/null 2>&1 & 启动elasticsearch-head，访问9100端口

mengyue 2020-05-02

ES索引的一些长度限制

一个ES索引最大可以支持多少个shard？理论上无限扩展，我推测最大应该是java array的最大长度：Integer.MAX_VALUE。一个ES shard最多可以索引2,147,483,519个document。可以看到一个document创建多个

qiuzhuoxian 2020-02-23

Lucene

我们生活中的数据总体分为两类：结构化数据和非结构化数据。将非结构化数据的一部分信息提取出来，重新组织，使其变得具有一定的结构，然后对此有一定结构的数据进行搜索，从而达到搜索相对较快的母的。这部分从非结构化数据中提取的然后重新组织的信息，我们称之为索引。Lu

编码之路 2020-02-20

lucene&amp;solr全文检索_7solr后台界面的介绍

Logging：solr的运行日志，如果出现问题会告诉你什么问题。Core Admin:solr core 的管理界面。solr core是solr 的一个独立运行实例单位，他可以对外提供索引和搜索服务，一个solr工程可以运行多个solrcore，一个c

lionelf 2020-02-03

lucene&amp;solr全文检索_3查询索引

创建完索引之后，我们需要查询。// 第一步：创建一个java工程，并导入jar包。// 2）指定一个分析器，对文档内容进行分析。Directory directory =FSDirectory.open;//创建document

TyCoding 2020-02-01

Lucene、Solr、ElasticSearch、hibernate-search四部曲

直到昨天，在工作中刚刚得知Lucene、Solr。本质区别在于：1、Lucene是搜索库，不是独立的应用程序，而Solr是。此外Hibernate Search能够根据需要进行同步或异步的索引更新。Lucene的目的是为软件开发人员提供一个简单易用的工具包

heniancheng 2020-01-31

ElasticSearch

ES=elaticsearch简写， Elasticsearch是一个开源的高扩展的分布式全文检索引擎，它可以近乎实时的存储、检索数据；本身扩展性很好，可以扩展到上百台服务器，处理PB级别的数据。Elasticsearch也使用Java开发并使用Lucen

某某某 2020-01-30

《从Lucene到Elasticsearch全文检索实战》的P184页

其次，他说使用了books.json,在P183页说保存为books.json这个文件是直接放在curl解压缩后的文件夹的bin目录下的。汗，我第一次，关于这个问题搞了半天，之前我一直使用Kibana的，坑。后来百度看到有人说这个都出现localhost:

PinkBean 2020-01-29

es lucene搜索及聚合流程源码分析

SearchContext包含Query，Aggregator等重要信息。索引结构为倒排。Aggregator此时仅根据request创建AggregatorFactory，用于后续创建Aggregator。当shard下数据发生变化时，应当清空cache

某某某 2020-01-12

Net Core使用Lucene.Net和盘古分词器 实现全文检索

Lucene.net是Lucene的.net移植版本，是一个开源的全文检索引擎开发包，即它不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎，是一个高性能、可伸缩的文本搜索引擎库。它的功能就是负责将文本数据按照某种分词算

编码之路 2020-01-01

Solr与JDK对应版本关系，Tomcat与JDK版本对应关系

　　最新在部署solrCloud集群，由于自己机器上用的JDK都是JDK1.7的，然后我就从网上下载了最新下载了最先的solr6.6.0和最新的Tomcat9.0，部署了一下，开始报错，提示solr和JDK版本不兼容，Tomcat和JDK版本不兼容，所以在

itmale 2020-01-01

全文检索Lucene

索引一次创建可以多次使用，表现为每次查询速度都很快。把非结构化数据进行字符串拆分，得到一个单词的列表，基于单词列表创建一个索引，然后查询索引，根据单词和文档的对应关系找到文档列表，这个过程就叫做全文索引

PasserbyX 2020-01-01
exitzhang

exitzhang

W3CSchool教程
HTML 教程
CSS 教程
Bootstrap 教程
Javascript 教程
jQuery 教程
后端教程
C 教程
Java 教程
PHP 教程
Python 教程
Go 教程
移动开发
Android 教程
Swift 教程
Kotlin 教程
jQuery Mobile 教程
ionic 教程
关于我们
新闻动态
联系方式
招聘英才
安科实验室
帮助与反馈

安科网(Ancii)，中国第一极客网

Copyright © 2013 - 2019 Ancii.com

京ICP备18063983号 京公网安备11010802014868号