Lucene学习笔记

Lucene 版本:Lucene 7.3.1
luke工具:https://github.com/DmitryKey/luke/releases

索引操作

  索引操作的核心类是IndexWriter,IndexWriter需要指定索引的生成位置directory和生成索引要用的分词器analyzer。分词器以及其他的配置信息通过IndexWriterConfig类来指定.

//构造函数
new IndexWriter(direcroty,config)

lucene创建索引

  创建索引需要Document对象,Document对象有Field对象组成。这是一个通用的模型概念,具有很强的扩展性。一个Document可以是数据库中的一条记录,则Field就是具体字段值;一个Document也可以是一个文件对象,则Filed可以代表是fileName,fileContent,fileSize等信息。

Field域的属性(4.10.3)

是否分析:是否对域的内容进行分词处理。前提是我们要对域的内容进行查询。
是否索引:将Field分析后的词或整个Field值进行索引,只有索引方可搜索到。
比如:商品名称、商品简介分析后进行索引,订单号、身份证号不用分析但也要索引,这些将来都要作为查询条件。
是否存储:将Field值存储在文档中,存储在文档中的Field才可以从Document中获取
比如:商品名称、订单号,凡是将来要从Document中获取的Field都要存储。

Field类 数据类型 Analyzed是否分析 Index是否索引 Stored是否存储 说明
StringField(FieldName, FieldValue,Store.YES)) 字符串 N Y Y 或 N 这个Field用来构建一个字符串Field,但是不会进行分析,会将整个串存储在索引中,比如(订单号,姓名等);是否存储在文档中用Store.YES或Store.NO决定
LongField(FieldName, FieldValue,Store.YES) Long型 Y Y Y 或 N 这个Field用来构建一个Long数字型Field,进行分析和索引,比如(价格);是否存储在文档中用Store.YES或Store.NO决定
StoredField(FieldName, FieldValue) 重载方法,支持多种类型 N Y Y 这个Field用来构建不同类型Field,不分析,不索引,但要Field存储在文档中(如图片,因为要存放图片地址)
TextField(FieldName, FieldValue, Store.NO) 或 TextField(FieldName, reader) 字符串或流 Y Y Y 或N 如果是一个Reader, lucene猜测内容比较多,会采用Unstored的策略.

实现步骤

  • 第一步:创建一个java工程,并导入jar包。
  • 第二步:创建一个indexwriter对象。
      1)指定索引库的存放位置Directory对象
      2)指定一个分析器,对文档内容进行分析。
  • 第二步:创建document对象。
  • 第三步:创建field对象,将field添加到document对象中。
  • 第四步:使用indexwriter对象将document对象写入索引库,此过程进行索引创建。并将索引和document对象写入索引库。
  • 第五步:关闭IndexWriter对象。
    @Test
    public void testIndexCreate() throws Exception {
        //创建Lucene索引的步骤

        //**:核心:创建索引index和文档document写对象(需要指定目录和配置信息(分词器))
        //  a:创建索引存储位置
        Directory directory = FSDirectory.open(Paths.get("dic"));
        //  b:创建分词器
//        IKAnalyzer analyzer = new IKAnalyzer(); //lucene 7 已经不兼容IKAnalyzer分词器
        StandardAnalyzer analyzer = new StandardAnalyzer();
        //  c:创建索引文档写对象的配置文件(指定分词器)
        IndexWriterConfig conf = new IndexWriterConfig(analyzer);
        // d:创建索引文档写对象
        IndexWriter indexWriter = new IndexWriter(directory, conf);

        //创建文档document
        File dataDir = new File("data");
        for (File file : dataDir.listFiles()) {
            String fileName = file.getName();
            Long fileSize = FileUtils.sizeOf(file);
            String fileContent = FileUtils.readFileToString(file, "utf-8");
            Document doc = new Document();
            TextField nameField = new TextField("fileName", fileName, Field.Store.YES);
            TextField sizeField = new TextField("fileSize", fileSize.toString(), Field.Store.YES);
            TextField contentField = new TextField("fileContent", fileContent, Field.Store.YES);
            doc.add(nameField);
            doc.add(sizeField);
            doc.add(contentField);
            indexWriter.addDocument(doc);
        }


        //提交
        indexWriter.commit();
        //关闭流
        indexWriter.close();

    }

索引库的添加

向索引库中添加document对象。
第一步:先创建一个indexwriter对象
第二步:创建一个document对象
第三步:把document对象写入索引库
第四步:关闭indexwriter。

   //添加索引(4.10.3)
    @Test
    public void addDocument() throws Exception {
        //索引库存放路径
        Directory directory = FSDirectory.open(new File("dic"));

        IndexWriterConfig config = new IndexWriterConfig(Version.LATEST, new IKAnalyzer());
        //创建一个indexwriter对象
        IndexWriter indexWriter = new IndexWriter(directory, config);
        //创建一个Document对象
        Document document = new Document();
        //向document对象中添加域。
        //不同的document可以有不同的域,同一个document可以有相同的域。
        document.add(new TextField("filename", "新添加的文档", Store.YES));
        document.add(new TextField("content", "新添加的文档的内容", Store.NO));
        document.add(new TextField("content", "新添加的文档的内容第二个content", Store.YES));
        document.add(new TextField("content1", "新添加的文档的内容要能看到", Store.YES));
        //添加文档到索引库
        indexWriter.addDocument(document);
        //关闭indexwriter
        indexWriter.close();

    }

lucene删除全部索引

indexWriter.deleteAll();
 @Test
    public void testIndexDeleAll() throws Exception {
        //核心:常见索引文档写对象
        Directory directory = FSDirectory.open(Paths.get("dic"));
        StandardAnalyzer analyzer = new StandardAnalyzer();
        IndexWriterConfig config = new IndexWriterConfig(analyzer);
        IndexWriter indexWriter = new IndexWriter(directory, config);

        indexWriter.deleteAll();
        indexWriter.commit();
        indexWriter.close();
    }

lucene删除指定索引

indexWriter.deleteDocuments(Term ... terms);

    或者

indexWriter.deleteDocuments(Query ... querys);
    @Test
    // 指定Term删除document,删除索引
    public void testIndexDeleByDocuments1() throws Exception {
        //核心:创年索引文档写对象
        Directory dir = FSDirectory.open(Paths.get("dic"));
        IndexWriterConfig conf = new IndexWriterConfig(new StandardAnalyzer());
        IndexWriter indexWriter = new IndexWriter(dir, conf);

        // 指定Term删除document,删除索引
        indexWriter.deleteDocuments(new Term("fileName", "apache"));
        // 指定查询条件删除document,删除索引
        QueryParser parser = new QueryParser("fileName", new StandardAnalyzer());
        Query query = parser.Query("apache");
        indexWriter.deleteDocuments(query);
        indexWriter.commit();
        indexWriter.close();
    }

索引库的修改

原理就是先删除后添加。

    //修改索引库(4.10.3)
    @Test
    public void updateIndex() throws Exception {
        IndexWriter indexWriter = getIndexWriter();
        //创建一个Document对象
        Document document = new Document();
        //向document对象中添加域。
        //不同的document可以有不同的域,同一个document可以有相同的域。
        document.add(new TextField("filename", "要更新的文档", Store.YES));
        document.add(new TextField("content", "2013年11月18日 - Lucene 简介 Lucene 是一个基于 Java 的全文信息检索工具包,它不是一个完整的搜索应用程序,而是为你的应用程序提供索引和搜索功能。", Store.YES));
        indexWriter.updateDocument(new Term("content", "java"), document);
        //关闭indexWriter
        indexWriter.close();
    }

查询索引

对要搜索的信息创建Query查询对象,Lucene会根据Query查询对象生成最终的查询语法,类似关系数据库Sql语法一样Lucene也有自己的查询语法,比如:“name:lucene”表示查询Field的name为“lucene”的文档信息。

可通过两种方法创建查询对象:
1)使用Lucene提供Query子类
  Query是一个抽象类,lucene提供了很多查询对象,比如TermQuery项精确查询,NumericRangeQuery数字范围查询等。
如下代码:

Query query = new TermQuery(new Term("name", "lucene"));

2)使用QueryParse解析查询表达式
  QueryParse会将用户输入的查询表达式解析成Query对象实例。
如下代码:

QueryParser queryParser = new QueryParser("name", new IKAnalyzer());
Query query = queryParser.parse("name:lucene");

查询步骤

  • 第一步:创建一个Directory对象,也就是索引库存放的位置。
  • 第二步:创建一个indexReader对象,需要指定Directory对象。
  • 第三步:创建一个indexsearcher对象,需要指定IndexReader对象
  • 第四步:创建一个TermQuery对象,指定查询的域和查询的关键词。
  • 第五步:执行查询。
  • 第六步:返回查询结果。遍历查询结果并输出。
  • 第七步:关闭IndexReader对象

IndexSearcher搜索方法

方法 说明
indexSearcher.search(query, n) 根据Query搜索,返回评分最高的n条记录
indexSearcher.search(query, filter, n) 根据Query搜索,添加过滤策略,返回评分最高的n条记录
indexSearcher.search(query, n, sort) 根据Query搜索,添加排序策略,返回评分最高的n条记录
indexSearcher.search(booleanQuery, filter, n, sort) 根据Query搜索,添加过滤策略,添加排序策略,返回评分最高的n条记录

TopDocs

Lucene搜索结果可通过TopDocs遍历,TopDocs类提供了少量的属性,如下:

方法 说明
totalHits 匹配搜索条件的总记录数
scoreDocs 顶部匹配记录

注意:
Search方法需要指定匹配记录数量n:indexSearcher.search(query, n)
TopDocs.totalHits:是匹配索引库中所有记录的数量
TopDocs.scoreDocs:匹配相关度高的前边记录数组,scoreDocs的长度小于等于search方法指定的参数n

使用queryparser查询

  通过QueryParser也可以创建Query,QueryParser提供一个Parse方法,此方法可以直接根据查询语法来查询。Query对象执行的查询语法可通过System.out.println(query);查询。
需要使用到分析器。建议创建索引时使用的分析器和查询索引时使用的分析器要一致。

查询语法
1、基础的查询语法,关键词查询:
  域名+“:”+搜索的关键字
  例如:content:java
2、范围查询
  域名+“:”+[最小值 TO 最大值]
  例如:size:[1 TO 1000]
  范围查询在lucene中不支持数值类型,支持字符串类型。在solr中支持数值类型。
3、组合条件查询
  1)+条件1 +条件2:两个条件之间是并且的关系and
  例如:+filename:apache +content:apache
  2)+条件1 条件2:必须满足第一个条件,应该满足第二个条件
  例如:+filename:apache content:apache
  3)条件1 条件2:两个条件满足其一即可。
  例如:filename:apache content:apache
  4)-条件1 条件2:必须不满足条件1,要满足条件2
  例如:-filename:apache content:apache

Tables Are
Occur.MUST 查询条件必须满足,相当于and +(加号)
Occur.SHOULD 查询条件可选,相当于or 空(不用符号)
Occur.MUST_NOT 查询条件不能满足,相当于not非 -(减号)

第二种写法:
条件1 AND 条件2
条件1 OR 条件2
条件1 NOT 条件2

    @Test
    public void testIndexSearch() throws Exception {
        //核心类:IndexSearch IndexReader 
        Directory directory = FSDirectory.open(Paths.get("dic"));
        IndexReader indexReader = StandardDirectoryReader.open(directory);
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);

        StandardAnalyzer analyzer = new StandardAnalyzer();
        //查询解析器,指定分词器(同索引创年分词器一致),指定默认的查询字段
        QueryParser queryParser = new QueryParser("fileContent", analyzer);
        //查询语法=域名:搜索的关键字,若没有指定域名,则按照默认的查询域查询
        Query query = queryParser.parse("fileName:apache");

        //按照查询条件查询,并指定最多显示几条结果
        //第一个参数是查询对象,第二个参数是查询结果返回的最大值
        TopDocs topDocs = indexSearcher.search(query, 5);
        //满足查询条件的全部记录条数
        long totalHits = topDocs.totalHits;
        System.out.println("总的记录数:" + totalHits);
        //结果集
        //topDocs.scoreDocs存储了document对象的id
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;

        for (ScoreDoc scoreDoc : scoreDocs) {
            //索引ID值 scoreDoc.doc属性就是document对象的id
            int docID = scoreDoc.doc;
            Document document = indexReader.document(docID);
            //document.getField("fileName") 返回 IndexableField
            System.out.println(document.getField("fileName").stringValue()+" : "+document.getField("fileSize").stringValue());
            System.out.println("=============================================================================");
        }
    }

MulitFieldQueryParser

可以指定多个默认搜索域

@Test
    public void testMultiFiledQueryParser() throws Exception {
        IndexSearcher indexSearcher = getIndexSearcher();
        //可以指定默认搜索的域是多个
        String[] fields = {"filename", "content"};
        //创建一个MulitFiledQueryParser对象
        MultiFieldQueryParser queryParser = new MultiFieldQueryParser(fields, new IKAnalyzer());
        Query query = queryParser.parse("java and apache");
        System.out.println(query);
        //执行查询
        printResult(query, indexSearcher);

    }

使用query的子类查询

TermQuery

TermQuery,通过项查询,TermQuery不使用分析器,所以建议匹配不分词的Field域查询,比如订单号、分类ID号等。
指定要查询的域和要查询的关键词。

//使用Termquery查询(4.10.3)
    @Test
    public void testTermQuery() throws Exception {
        IndexSearcher indexSearcher = getIndexSearcher();
        //创建查询对象
        Query query = new TermQuery(new Term("content", "lucene"));
        //执行查询
        TopDocs topDocs = indexSearcher.search(query, 10);
        //共查询到的document个数
        System.out.println("查询结果总数量:" + topDocs.totalHits);
        //遍历查询结果
        for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
            Document document = indexSearcher.doc(scoreDoc.doc);
            System.out.println(document.get("filename"));
            //System.out.println(document.get("content"));
            System.out.println(document.get("path"));
            System.out.println(document.get("size"));
        }
        //关闭indexreader
        indexSearcher.getIndexReader().close();
    }

NumericRangeQuery

可以根据数值范围查询。

//数值范围查询
    @Test
    public void testNumericRangeQuery() throws Exception {
        IndexSearcher indexSearcher = getIndexSearcher();
        //创建查询
        //参数:
        //1.域名
        //2.最小值
        //3.最大值
        //4.是否包含最小值
        //5.是否包含最大值
        Query query = NumericRangeQuery.newLongRange("size", 1l, 1000l, true, true);
        //执行查询
        printResult(query, indexSearcher);
    }

BooleanQuery

可以组合查询条件。

//组合条件查询(4.10.3)
    @Test
    public void testBooleanQuery() throws Exception {
        IndexSearcher indexSearcher = getIndexSearcher();
        //创建一个布尔查询对象
        BooleanQuery query = new BooleanQuery();
        //创建第一个查询条件
        Query query1 = new TermQuery(new Term("filename", "apache"));
        Query query2 = new TermQuery(new Term("content", "apache"));
        //组合查询条件
        query.add(query1, Occur.MUST);
        query.add(query2, Occur.MUST);
        //执行查询
        printResult(query, indexSearcher);
    }

Occur.MUST:必须满足此条件,相当于and
Occur.SHOULD:应该满足,但是不满足也可以,相当于or
Occur.MUST_NOT:必须不满足。相当于not

MatchAllDocsQuery

使用MatchAllDocsQuery查询索引目录中的所有文档

@Test(4.10.3)
    public void testMatchAllDocsQuery() throws Exception {
        IndexSearcher indexSearcher = getIndexSearcher();
        //创建查询条件
        Query query = new MatchAllDocsQuery();
        //执行查询
        printResult(query, indexSearcher);
    }

从Lucene 4.10.3到Lucene 7.1.0:带你了解版本之间的些许差异

https://blog.csdn.net/cslucifer/article/details/78548980?locationNum=10&fps=1

阅读更多
版权声明:本文只为记录博主的学习点滴,欢迎转载与交流。 https://blog.csdn.net/u010758410/article/details/80346523
个人分类: Lucene
上一篇luke各版本的下载地址
下一篇初始化顺序总结 - 静态变量、静态代码块、成员变量、构造函数
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭