lucene添加索引并查询

最新推荐文章于 2022-06-26 21:48:48 发布
最新推荐文章于 2022-06-26 21:48:48 发布
阅读量1.1k 收藏
点赞数
分类专栏： lucene 文章标签： lucene 创建索引

一、

项目结构


constans.java 是常量类

LuceneIndex.java 建立索引类

LuceneSearch.java 搜索类

数据文件：


 

package com.xin;

public class Constants { 
    public final static String INDEX_FILE_PATH = "e:\\lucene\\test"; //索引的文件的存放路径 
    public final static String INDEX_STORE_PATH = "e:\\lucene\\index"; //索引的存放位置 
}

 

package com.xin;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.util.Date;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.StringField;
import org.apache.lucene.document.TextField;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.IndexWriterConfig.OpenMode;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;
/**
 * @author chongxin
 * @since 2013/6/19
 * @version Lucene 4.3.1
 * */
public class LuceneIndex {
	// 索引器
	private IndexWriter writer = null;
	public LuceneIndex() {
		try {
			//索引文件的保存位置
			Directory dir = FSDirectory.open(new File(Constants.INDEX_STORE_PATH));
			//分析器
			Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_40);
			//配置类
			IndexWriterConfig iwc = new IndexWriterConfig(Version.LUCENE_40,analyzer);
			iwc.setOpenMode(OpenMode.CREATE);//创建模式 OpenMode.CREATE_OR_APPEND 添加模式
			
			writer = new IndexWriter(dir, iwc);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	// 将要建立索引的文件构造成一个Document对象，并添加一个域"content"
	private Document getDocument(File f) throws Exception {
		Document doc = new Document();

		FileInputStream is = new FileInputStream(f);
		Reader reader = new BufferedReader(new InputStreamReader(is));
		//字符串 StringField LongField TextField
		Field pathField = new StringField("path", f.getAbsolutePath(),Field.Store.YES);
		Field contenField = new TextField("contents", reader);
		//添加字段
		doc.add(contenField);
		doc.add(pathField);
		return doc;
	}

	public void writeToIndex() throws Exception {
		File folder = new File(Constants.INDEX_FILE_PATH);
		
		if (folder.isDirectory()) {
			String[] files = folder.list();
			for (int i = 0; i < files.length; i++) {
				File file = new File(folder, files[i]);
				Document doc = getDocument(file);
				System.out.println("正在建立索引 : " + file + "");
				writer.addDocument(doc);
			}
		}
	}

	public void close() throws Exception {
		writer.close();
	}

	public static void main(String[] args) throws Exception {
		// 声明一个对象
		LuceneIndex indexer = new LuceneIndex();
		// 建立索引
		Date start = new Date();
		indexer.writeToIndex();
		Date end = new Date();

		System.out.println("建立索引用时" + (end.getTime() - start.getTime()) + "毫秒");

		indexer.close();
	}
}

执行结果：

正在建立索引 : e:\lucene\test\a.txt
正在建立索引 : e:\lucene\test\b.txt
正在建立索引 : e:\lucene\test\c.txt
正在建立索引 : e:\lucene\test\d.txt
建立索引用时109毫秒

 

生成的索引文件：

查找：

package com.xin;

import java.io.File;
import java.util.Date;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;

/**
 * @author chongxin
 * @since 2013/6/19
 * @version Lucene 4.3.1
 * */
public class LuceneSearch {
	// 声明一个IndexSearcher对象
	private IndexSearcher searcher = null;
	// 声明一个Query对象
	private Query query = null;
	private String field = "contents";

	public LuceneSearch() {
		try {
			IndexReader reader = DirectoryReader.open(FSDirectory.open(new File(Constants.INDEX_STORE_PATH)));
			searcher = new IndexSearcher(reader);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
    //返回查询结果 
	public final TopDocs search(String keyword) {
		System.out.println("正在检索关键字 : " + keyword);
		try {
			Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_40);
			QueryParser parser = new QueryParser(Version.LUCENE_40, field,analyzer);
			// 将关键字包装成Query对象
			query = parser.parse(keyword);
			Date start = new Date();
			TopDocs results = searcher.search(query, 5 * 2);
			Date end = new Date();
			System.out.println("检索完成，用时" + (end.getTime() - start.getTime())
					+ "毫秒");
			return results;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
      //打印结果
	public void printResult(TopDocs results) {
		ScoreDoc[] h = results.scoreDocs;
		if (h.length == 0) {
			System.out.println("对不起，没有找到您要的结果。");
		} else {
			for (int i = 0; i < h.length; i++) {
				try {
					Document doc = searcher.doc(h[i].doc);
					System.out.print("这是第" + i + "个检索到的结果，文件名为：");
					System.out.println(doc.get("path"));
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
		System.out.println("--------------------------");
	}

	public static void main(String[] args) throws Exception {
		LuceneSearch test = new LuceneSearch();
		TopDocs h = null;
		h = test.search("中国");
		test.printResult(h);
		h = test.search("人民");
		test.printResult(h);
		h = test.search("共和国");
		test.printResult(h);
	}

}

 


二、如果要查询的是个对象，以Goods对象为例，那LuceneIndex文件中的private Document getDocument(File f)该方法就该变成private Document getDocument(Goods gosds)，以下是全码

/**
      * 从goods对象生成一个document对象便于建立索引
      * @param goods
      * @return
      */
     public static Document parseDocumentFromGoods(Goods goods){


         Document doc = new Document();

         doc.add(new StringField("goodsId", goods.getgoodsId(), Store.YES));
         doc.add(new StoredField("goodsPic", goods.getGoodsPic()));
         doc.add(new LongField("addDate", Long.parseLong(goods.getGoodsAddDate()), Store.YES));
         doc.add(new StringField("shopId", goods.getShopId() + "", Store.YES));
         doc.add(new DoubleField("goodsPrice", goods.getGoodsPrice(), Store.YES));
         doc.add(new IntField("goodsSellNum", goods.getGoodsSellNum(), Store.YES));


         TextField title = new TextField("goodsName", goods.getGoodsName(), Store.YES);
         title.setBoost(2.0f);
         doc.add(title);


         if(goods.getKeywords() != null){
             TextField keywords = new TextField("keywords", goods.getKeywords(),Store.YES);
             keywords.setBoost(1.5f);
             doc.add(keywords);
         }
<span style="white-space:pre">	</span> return doc;
     }
三、删除某个索引，在luceneIndex中添加如下方法 

public boolean deleteGoodsIndexById(String id){
         Term t = new Term("goodsId", id);
         Query q = new TermQuery(t);
         try {
             writer.deleteDocuments(q);
             return true;
         } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
             return false;
         }
 }

四、如果要查询某个对象中的索引 

/**
     * 根据传入的参数查询商品
     *
     * @param searchVo 要查询的类
     * @return 返回结果，GoodsResultBean的类结构如下
<span style="white-space:pre">	public class GoodsResultBean {
     		private int total;
     		private List<Goods> goodss;
     		public int getTotal() {
         		return total;
     		}
     		public void setTotal(int total) {
         		this.total = total;
     		}
     		public List<Goods> getGoodss() {
         		return goodss;
     		}
     		public void setGoodss(List<Goods> goodss) {
         		this.goodss = goodss;
     		}
	}</span>
     */
    String[] goodsFields = new String[]{"goodsName"};
    String[] goodsIdsFields = new String[]{"goodsId"};
    String[] goodsCateFields = new String[]{"goodsClassification", "goodsType", "goodsCategoryId"};

    public GoodsResultBean search(GoodsSearchVo searchVo) throws ParseException, IOException {


        BooleanQuery booleanQuery = new BooleanQuery();
        Query query = null;
        if (searchVo.getGoodsIds() == null && searchVo.getGoodsCategory() == null && searchVo.getKey() == null && searchVo.getGoodsType() == 0 && searchVo.getGoodsClassification() == 0 && searchVo.getCategoryId() == 0) {
            query = NumericRangeQuery.newLongRange("addDate", //field name
                    null, //min 从它开始
                    null,//max 到它结束
                    true,  //是否包含min
                    true); //是否包含maxj
            booleanQuery.add(query, BooleanClause.Occur.MUST);
        }
        if (StringUtil.isNotBlank(searchVo.getGoodsCategory())) {
            MultiFieldQueryParser parser = new MultiFieldQueryParser(Version.LUCENE_43, goodsCateFields, analyzer);
            query = parser.parse(searchVo.getGoodsCategory());
            booleanQuery.add(query, BooleanClause.Occur.MUST);
        }

        if (StringUtil.isNotBlank(searchVo.getKey())) {
            searchVo.setKey(StringUtil.getKey(searchVo.getKey()));
            //            关键词组较长分词查询
            //        多字段查询parser
            MultiFieldQueryParser parser = new MultiFieldQueryParser(Version.LUCENE_43, goodsFields, analyzer);
            query = parser.parse(QueryParser.escape(searchVo.getKey()));
            booleanQuery.add(query, BooleanClause.Occur.MUST);
        }
        if (StringUtil.isNotBlank(searchVo.getGoodsIds())) {
            MultiFieldQueryParser parser = new MultiFieldQueryParser(Version.LUCENE_43, goodsIdsFields, analyzer);
            query = parser.parse(QueryParser.escape(searchVo.getGoodsIds()));
            booleanQuery.add(query, BooleanClause.Occur.MUST);
        }

        if (searchVo.getCategoryId() != 0 || searchVo.getGoodsType() != 0 || searchVo.getGoodsClassification() != 0) {
            if (searchVo.getCategoryId() != 0)
                query = new TermQuery(new Term("goodsCategoryId", searchVo.getCategoryId() + ""));
            else if (searchVo.getGoodsType() != 0)
                query = new TermQuery(new Term("goodsType", searchVo.getGoodsType() + ""));
            else if (searchVo.getGoodsClassification() != 0)
                query = new TermQuery(new Term("goodsClassification", searchVo.getGoodsClassification() + ""));

            booleanQuery.add(query, BooleanClause.Occur.MUST);
        }
        if (StringUtil.isNotBlank(searchVo.getFinishedDate())) {
            query = new TermQuery(new Term("finishedDate", searchVo.getFinishedDate()));
            booleanQuery.add(query, BooleanClause.Occur.MUST);
        }
        if (searchVo.getMaxPrice() != 0 || searchVo.getMinPrice() != 0) {
            query = NumericRangeQuery.newDoubleRange("goodsPrice", searchVo.getMinPrice() == 0 ? null : searchVo.getMinPrice(), searchVo.getMaxPrice() == 0 ? null : searchVo.getMaxPrice(), true, true);
            booleanQuery.add(query, BooleanClause.Occur.MUST);
        }
        if (StringUtil.isNotBlank(searchVo.getOrigin())) {
            query = new TermQuery(new Term("origin", searchVo.getOrigin()));
            booleanQuery.add(query, BooleanClause.Occur.MUST);
        }
        GoodsResultBean goodsResultBean;
        if(searchVo.getPriceOrder() != 0) {
            goodsResultBean = priceSearch(searchVo, query);
        } else if(searchVo.getTimeOrder() != 0) {
            goodsResultBean = addDateSearch(searchVo,query);
        } else if(searchVo.getSales() != 0) {
            goodsResultBean = sellNumSearch(searchVo,query);
        } else {
            goodsResultBean = defaultSearch(searchVo, booleanQuery);
        }

        return goodsResultBean;
    }



yflxc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
luceneDemo（创建索引+关键字查询）
07-17
创建索引 一、创建词法分析器 二、创建索引存储目录 三、创建索引写入器 四、将内容存储到索引 关键字查询 一、创建索引存储目录读取器 二、创建索引搜索器 三、解析查询 四、获取结果
lucene实现索引查询
10-22
以下是关于使用Lucene实现索引查询的详细知识： ### 一、创建索引 创建索引是Lucene的核心过程，它涉及到以下步骤： 1. **定义索引目录**：首先，你需要指定一个目录来存储索引文件。这通常是一个文件夹，可以...
Lucene –快速添加索引和搜索功能
最佳 Java 编程
05-13 353
什么是Lucene？ Apache LuceneTM是完全用Java编写的高性能，功能齐全的文本搜索引擎库。 它是一项适用于几乎所有需要全文搜索的应用程序的技术，尤其是跨平台的应用程序。 Lucene可以纯文本，整数，索引PDF，Office文档。 等等。， Lucene如何启用更快的搜索？ Lucence创建了一个称为倒排索引的东西。 通常我们在文档中映射文档->术语。...
05Lucene索引库的添加
阿甘兄
05-10 616
步骤 向索引库中添加document对象。 第一步：先创建一个indexwriter对象 第二步：创建一个document对象 第三步：把document对象写入索引库 第四步：关闭indexwriter。 代码实现 //添加索引 @Test public void addDocument() throws Exception { //索引库存放路径 Directory directo...
lucene创建索引
weixin_30237281的博客
05-17 64
实现步骤 第一步：创建一个indexwriter对象。 1）指定索引库的存放位置Directory对象 2）指定一个分析器，对文档内容进行分析。 第二步：创建document对象。 第三步：创建field对象，将field添加到document对象中。 第四步：使用indexwriter对象将document对象写入索引库，此过程进行索引创建。并将索引和document对象写...
第二章：lucene构建索引（新增、查询、更新、删除）
01-20 2213
package lucene2; import java.io.IOException; import junit.framework.TestCase; import org.apache.lucene.analysis.WhitespaceAnalyzer; import org.apache.lucene.document.Document; import org.apache.
Lucene 索引的简单使用
11-03
本篇文章将详细阐述如何使用Lucene来创建和查询索引，帮助你深入理解其核心概念和操作流程。 ### 1. Lucene基本概念 - **文档（Document）**：在Lucene中，一个文档代表你要索引的信息单元，它可以包含多个字段...
Lucene4.10.3索引+查询
01-23
在这个场景中，我们主要关注的是如何在Lucene 4.10.3版本中对数据进行索引和查询。 **1. Lucene 4.10.3 的核心概念** - **文档（Document）**：在 Lucene 中，一个文档对应于要索引的信息源，比如网页、电子邮件...
lucene全文索引
06-25
Lucene的核心功能包括文本分析、索引构建、搜索查询以及结果排序。 在解决中文和英文分词问题上，Lucene表现得相当出色。对于英文，Lucene默认使用StandardAnalyzer进行分词，它可以处理常见的英文词汇规则，如去除...
基于lucene技术的增量索引
05-15
- **处理新增数据**：对于新插入的数据，我们创建一个新的Lucene文档，并添加到索引writer中。确保每个文档都关联有唯一标识符，以便后续更新和删除操作。 - **处理更新数据**：如果数据被修改，我们需要找到索引中...
Lucene对本地文件多目录创建索引
03-20
NULL 博文链接：https://85600367.iteye.com/blog/849554
Lucene建立索引及查询包含“java”关键字 示例代码
02-20
根据博客调试的程序，比较简单，英文分词和检索，希望对大家学习有帮助。
lucene功能四；索引库的维护；索引库的添加；修改；删除；及代码实现；代码示例
boss_way的博客
11-13 829
1. 功能四：索引库的维护 1.1. 索引库的添加 1.1.1. 步骤 向索引库中添加document对象。 第一步：先创建一个indexwriter对象 第二步：创建一个document对象 第三步：把document对象写入索引库 第四步：关闭indexwriter。   1.1.2. 代码实现 //添加索引 @Test public void addD
【Lucene总结-介绍】1.lucene简介和创建索引初步
程序猿之洞
05-04 1002
一、全文检索存在的意义 Lucene实际上就是全文搜索引擎的核心，那什么是全文搜索引擎呢？它的意义是什么呢？ 1、内容模糊查询 在我们使用Mysql的时候，需要搜索内容时，可能使用最多的是“like”语句，例如搜索content字段含有“东方明珠”的内容，在Mysql中的语句如下： select * from table where content like '%东方明珠%'; like的搜索...
Lucene索引创建方法和步骤
Jonney's house
04-01 1752
在全文索引工具中，都是由这样的三部分组成 1.索引部分 2.分词部分 3.搜索部分 ---------------------------------- 索引创建域选项 ---------------------------------- Field.Store.YES或者NO（存储域选项） YES:表示会把这个域中的内容完全存储到文件中，方便进行还原[对于主键，标题可以是这种方式
导致Lucene无法索引查询的NoClassDefFoundError
碧荷故乡_胡奇的专栏
03-07 1517
Lucene乃是当今免费开源搜索引擎的霸主，确实它十分好用，发展势头也很生猛，在Apache组织的支持下不断的更新、推出新版本。但是其存在一个隐藏的很深的bug，相信困扰了不少和我一样研究使用过它的人，这个bug从早期的版本到目前的V2.3.1一个存在，不能不说是一个遗憾。具体触发这个bug的原因很复杂，在某些环境、服务器、应用中……表现为建立索引文件和执行查询时报“NoClassDe
Lucene构建索引的原理及源代码分析
u013978512的博客
06-26 2810
​ Lucene是apache软件基金会 jakarta项目组的一个子项目，是一个开放源代码的全文检索引擎工具包，但它不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎，部分文本分析引擎（英文与德文两种西方语言）。Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便的在目标系统中实现全文检索的功能，或者是以此为基础建立起完整的全文检索引擎。​ 在讲全文检索之前，我们先聊下数据的分类。那么什么是数据呢？提起数据，大家可能会说数据库里存的就是数据。.....
lucene索引的增删改查/lucene索引维护
ckinghan58 学习工作分享空间
10-07 1916
lucene供了完整的查询引擎和索引引擎,像商城之类的很多网站都会使用，包括大数据也在使用类似的工具，所以很有必要了解决一下，文章 主要是测试了lucene的索引创建、删除、更新及queryParser查询索引的方式。创建lucene数据库，并创建book表，SQL语句内容如下：USE `lucene`;DROP TABLE IF EXISTS `book`;CREATE TABLE `book`
Lucene索引详解
yin4302008的专栏
01-23 1394
      今天我给大家讲讲Lucene是如何索引文档的，索引文档就是把文档变成索引这种数据结构的过程。        文档是Lucene索引的基本单位，比文档更小的单位是字段，字段是文档的一部分，每个字段由名称、类型和取值组成。字段的取值一般为文本（字符串、字符流）、二进制类型和数值类型。Lucene中的字段类型主要有以下几种：             TextField：        ...
Lucene 3.6 索引格式详解
7. **段的合并与更新**：当新的文档被添加或删除时，Lucene会创建新的段，并更新segments文件。通过管理不同世代的段，Lucene能够实现高效的搜索性能，同时保持索引的紧凑性。 理解这些索引文件格式对于优化Lucene...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值