`
小嘴冰凉
  • 浏览: 455901 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

构建各种Lucene Query

luceneApache搜索引擎CC++ 
阅读更多 
[size=x-large]

搜索流程中的第二步就是构建一个Query。下面就来介绍Query及其构建。

当用户输入一个关键字，搜索引擎接收到后，并不是立刻就将它放入后台开始进行关键字的检索，而应当首先对这个关键字进行一定的分析和处理，使之成为一种后台可以理解的形式，只有这样，才能提高检索的效率，同时检索出更加有效的结果。那么，在Lucene中，这种处理，其实就是构建一个Query对象。

就Query对象本身言，它只是Lucene的search包中的一个抽象类，这个抽象类有许多子类，代表了不同类型的检索。如常见的TermQuery就是将一个简单的关键字进行封装后的对象，类似的还有BooleanQuery，即布尔型的查找。

IndexSearcher对象的search方法中总是需要一个Query对象（或是Query子类的对象），本节就来介绍各种Query类。

11.4.1  按词条搜索—TermQuery 
TermQuery是最简单、也是最常用的Query。TermQuery可以理解成为“词条搜索”，在搜索引擎中最基本的搜索就是在索引中搜索某一词条，而TermQuery就是用来完成这项工作的。

在Lucene中词条是最基本的搜索单位，从本质上来讲一个词条其实就是一个名/值对。只不过这个“名”是字段名，而“值”则表示字段中所包含的某个关键字。

要使用TermQuery进行搜索首先需要构造一个Term对象，示例代码如下：

Term aTerm = new Term("contents", "java")；

然后使用aTerm对象为参数来构造一个TermQuery对象，代码设置如下：

Query query = new TermQuery(aTerm)；

这样所有在“contents”字段中包含有“java”的文档都会在使用TermQuery进行查询时作为符合查询条件的结果返回。

下面就通过代码11.4来介绍TermQuery的具体实现过程。

代码11.4  TermQueryTest.java

package ch11;

import org.apache.lucene.analysis.standard.StandardAnalyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.document.Field;

import org.apache.lucene.index.IndexWriter;

import org.apache.lucene.index.Term;

import org.apache.lucene.search.Hits;

import org.apache.lucene.search.IndexSearcher;

import org.apache.lucene.search.Query;

import org.apache.lucene.search.TermQuery;

 

public class TermQueryTest

{

  public static void main(String[] args) throws Exception

  {

     //生成Document对象

    Document doc1 = new Document();

     //添加“name”字段的内容

    doc1.add(Field.Text("name", "word1 word2 word3"));

     //添加“title”字段的内容

    doc1.add(Field.Keyword("title", "doc1"));

     //生成索引书写器

    IndexWriter writer = new IndexWriter("c:\\index", new StandardAnalyzer(), true);

     

    //将文档添加到索引中

    writer.addDocument(doc1);

     //关闭索引

    writer.close();

 

     //生成查询对象query

    Query query = null;

     

    //生成hits结果对象，保存返回的检索结果

    Hits hits = null;

    

     //生成检索器

    IndexSearcher searcher = new IndexSearcher("c:\\index");

    

     // 构造一个TermQuery对象

    query = new TermQuery(new Term("name","word1"));

     //开始检索，并返回检索结果到hits中

    hits = searcher.search(query);

     //输出检索结果中的相关信息

    printResult(hits, "word1");

 

     // 再次构造一个TermQuery对象，只不过查询的字段变成了"title"

    query = new TermQuery(new Term("title","doc1"));

     //开始第二次检索，并返回检索结果到hits中

    hits = searcher.search(query);

     //输出检索结果中的相关信息

    printResult(hits, "doc1");

 

  }

 

  public static void printResult(Hits hits, String key) throws Exception

  {

    System.out.println("查找 \"" + key + "\" :");

    if (hits != null)

    {

      if (hits.length() == 0)

      {

        System.out.println("没有找到任何结果");

      }

      else

      {

        System.out.println("找到" + hits.length() + "个结果");

        for (int i = 0; i < hits.length(); i++)

        {

          Document d = hits.doc(i);

          String dname = d.get("title");

          System.out.print(dname + "   ");

        }

        System.out.println();

        System.out.println();

      }

    }

  }

}

在代码11.4中使用TermQuery进行检索的运行结果如图11-8所示。

注意：字段值是区分大小写的，因此在查询时必须注意大小写的匹配。

从图11-8中可以看出，代码11.4两次分别以“word1”和“doc1”为关键字进行检索，并且都只得到了一个检索结果。

在代码11.4中通过构建TermQuery的对象，两次完成了对关键字的查找。两次查找过程中不同的是，第一次构建的TermQuery是查找“name”这个字段，而第二次构建的TermQuery则查找的是“title”这个字段。

11.4.2  “与或”搜索—BooleanQuery 
BooleanQuery也是实际开发过程中经常使用的一种Query。它其实是一个组合的Query，在使用时可以把各种Query对象添加进去并标明它们之间的逻辑关系。在本节中所讨论的所有查询类型都可以使用BooleanQuery综合起来。BooleanQuery本身来讲是一个布尔子句的容器，它提供了专门的API方法往其中添加子句，并标明它们之间的关系，以下代码为BooleanQuery提供的用于添加子句的API接口：

public void add(Query query, boolean required, boolean prohibited)；

注意：BooleanQuery是可以嵌套的，一个BooleanQuery可以成为另一个BooleanQuery的条件子句。

下面以11.5为例来介绍进行“与”操作的布尔型查询。

代码11.5  BooleanQueryTest1.java

package ch11;

import org.apache.lucene.analysis.standard.StandardAnalyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.document.Field;

import org.apache.lucene.index.IndexWriter;

import org.apache.lucene.index.Term;

import org.apache.lucene.search.BooleanQuery;

import org.apache.lucene.search.Hits;

import org.apache.lucene.search.IndexSearcher;

import org.apache.lucene.search.Query;

import org.apache.lucene.search.TermQuery;

 

public class BooleanQueryTest1

{

  public static void main (String [] args) throws Exception {

     //生成新的Document对象

    Document doc1 = new Document();

    doc1.add(Field.Text("name", "word1 word2 word3"));

    doc1.add(Field.Keyword("title", "doc1"));

    

    Document doc2 = new Document();

    doc2.add(Field.Text("name", "word1 word4 word5"));

    doc2.add(Field.Keyword("title", "doc2"));

    

    Document doc3 = new Document();

    doc3.add(Field.Text("name", "word1 word2 word6"));

    doc3.add(Field.Keyword("title", "doc3"));

    

     //生成索引书写器

    IndexWriter writer = new IndexWriter("c:\\index", new StandardAnalyzer(), true);

     //添加到索引中

    writer.addDocument(doc1);

    writer.addDocument(doc2);

    writer.addDocument(doc3);

    writer.close();

    

    Query query1 = null;

    Query query2 = null;

    BooleanQuery query = null;

    Hits hits = null;

    

     //生成IndexSearcher对象

    IndexSearcher searcher = new IndexSearcher("c:\\index");

    

    query1 = new TermQuery(new Term("name","word1"));

    query2 = new TermQuery(new Term("name","word2"));

    

    // 构造一个布尔查询

    query = new BooleanQuery();

    

    // 添加两个子查询

    query.add(query1, true, false);

    query.add(query2, true, false);

    

    hits = searcher.search(query);

    printResult(hits, "word1和word2");

    

  }

  

  public static void printResult(Hits hits, String key) throws Exception

  {

    System.out.println("查找 \"" + key + "\" :");

    if (hits != null)

    {

      if (hits.length() == 0)

      {

        System.out.println("没有找到任何结果");

      }

      else

      {

        System.out.println("找到" + hits.length() + "个结果");

        for (int i = 0; i < hits.length(); i++)

        {

          Document d = hits.doc(i);

          String dname = d.get("title");

          System.out.print(dname + "   ");

        }

        System.out.println();

        System.out.println();

      }

    }

  }

}

代码11.5首先构造了两个TermQuery，然后构造了一个BooleanQuery的对象，并将两个TermQuery当成它的查询子句加入Boolean查询中。

再来看一下BooleanQuery的add方法，除了它的第一个参数外，它还有另外两个布尔型的参数。第1个参数的意思是当前所加入的查询子句是否必须满足，第2个参数的意思是当前所加入的查询子句是否不需要满足。这样，当这两个参数分别选择true和false时，会有4种不同的组合。

     true ＆false：表明当前加入的子句是必须要满足的。

     false＆true：表明当前加入的子句是不可以被满足的。

     false＆false：表明当前加入的子句是可选的。

     true＆true：错误的情况。

由前面的示例可以看出由于加入的两个子句都选用了true＆false的组合，因此它们两个都是需要被满足的，也就构成了实际上的“与”关系，运行效果如图11-9所示。

如果是要进行“或”运算，则可按如下代码来构建查询子句：

query.add(query1, false, false);

query.add(query2, false, false);

代码的运行效果如图11-10所示。

                 

       图11-9  BooleanQuery测试1                          图11-10  BooleanQuery测试2

由于布尔型的查询是可以嵌套的，因此可以表示多种条件下的组合。不过，如果子句的数目太多，可能会导致查找效率的降低。因此，Lucene给出了一个默认的限制，就是布尔型Query的子句数目不能超过1024。

11.4.3  在某一范围内搜索—RangeQuery 
有时用户会需要一种在一个范围内查找某个文档，比如查找某一时间段内的所有文档，此时，Lucene提供了一种名为RangeQuery的类来满足这种需求。

RangeQuery表示在某范围内的搜索条件，实现从一个开始词条到一个结束词条的搜索功能，在查询时“开始词条”和“结束词条”可以被包含在内也可以不被包含在内。它的具体用法如下：

RangeQuery query = new RangeQuery(begin, end, included);

在参数列表中，最后一个boolean值表示是否包含边界条件本身，即当其为TRUE时，表示包含边界值，用字符可以表示为“[begin TO end]”；当其为FALSE时，表示不包含边界值，用字符可以表示为“{begin TO end}”。

下面通过代码11.6介绍RangeQuery使用的方法。

代码11.6  RangeQueryTest.java

package ch11;

import org.apache.lucene.analysis.standard.StandardAnalyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.document.Field;

import org.apache.lucene.index.IndexWriter;

import org.apache.lucene.index.Term;

import org.apache.lucene.search.Hits;

import org.apache.lucene.search.IndexSearcher;

import org.apache.lucene.search.RangeQuery;

 

public class RangeQueryTest {

     public static void main (String [] args) throws Exception {

         

         //生成文档对象，下同

         Document doc1 = new Document();

         //添加“time”字段中的内容，下同

         doc1.add(Field.Text("time", "200001"));

         //添加“title”字段中的内容，下同

         doc1.add(Field.Keyword("title", "doc1"));

         

         Document doc2 = new Document();

         doc2.add(Field.Text("time", "200002"));

         doc2.add(Field.Keyword("title", "doc2"));

         

         Document doc3 = new Document();

         doc3.add(Field.Text("time", "200003"));

         doc3.add(Field.Keyword("title", "doc3"));

         

         Document doc4 = new Document();

         doc4.add(Field.Text("time", "200004"));

         doc4.add(Field.Keyword("title", "doc4"));

         

         Document doc5 = new Document();

         doc5.add(Field.Text("time", "200005"));

         doc5.add(Field.Keyword("title", "doc5"));

         

         //生成索引书写器

         IndexWriter writer = new IndexWriter("c:\\index", new StandardAnalyzer(), true);

         //设置为混合索引格式

          writer.setUseCompoundFile(true);

         

         //将文档对象添加到索引中

         writer.addDocument(doc1);

         writer.addDocument(doc2);

         writer.addDocument(doc3);

         writer.addDocument(doc4);

         writer.addDocument(doc5);

         

         //关闭索引

         writer.close();

         

         //生成索引搜索器

         IndexSearcher searcher = new IndexSearcher("c:\\index");

         

         //构造词条

         Term beginTime = new Term("time","200001");

         Term endTime = new Term("time","200005");

         

         //用于保存检索结果

         Hits hits = null;

         //生成RangeQuery对象，初始化为null

         RangeQuery query = null;

         

         //构造RangeQuery对象，检索条件中不包含边界值

         query = new RangeQuery(beginTime, endTime, false);

         //开始检索，并返回检索结果

         hits = searcher.search(query);

         //输出检索结果的相关信息

         printResult(hits, "从200001～200005的文档，不包括200001和200005");

         

         //再构造一个RangeQuery对象，检索条件中包含边界值

         query = new RangeQuery(beginTime, endTime, true);

         //开始第二次检索

         hits = searcher.search(query);

         //输出检索结果的相关信息

         printResult(hits, "从200001～200005的文档，包括200001和200005");

         

     }

     

     public static void printResult(Hits hits, String key) throws Exception 

         {System.out.println("查找 \"" + key + "\" :");

         if (hits != null) {

             if (hits.length() == 0) {

                 System.out.println("没有找到任何结果");

             } else {

                 System.out.print("找到");

                 for (int i = 0; i < hits.length(); i++) {

                     Document d = hits.doc(i);

                     String dname = d.get("title");

                     System.out.print(dname + "   " );

                 }

                 System.out.println();

                 System.out.println();

             }

         }

     }

}

在上述代码中首先构造了两个Term词条，然后构造了一个RangeQuery对象。在初始化RangeQuery对象的时候，使用构造的两个Term词条作为RangeQuery构造函数的参数。前面已经说过，RangeQuery的构造函数中的两个参数分别称为“开始词条”和“结束词条”，它的含义也就是查找介于这两者之间的所有Document。

构建的Document的“time”字段值均介于200001～200005之间，其检索结果如图11-11所示。



图11-11  RangeQuery测试结果

从图11-11中可以看出，在代码11.6中使用RangeQuery共进行了两次检索，第一次的检索条件中不包括边界值，第二次的检索条件中包括边界值。

从代码11.6和图11-11中可以看出，第1次使用FALSE参数构造的RangeQuery对象不包括2个边界值，因此只返回3个Document，而第2次使用TRUE参数构造的RangeQuery则包括2个边界值，因此将5个Document全部返回了。

11.4.4  使用前缀搜索—PrefixQuery 
PrefixQuery就是使用前缀来进行查找的。通常情况下，首先定义一个词条Term。该词条包含要查找的字段名以及关键字的前缀，然后通过该词条构造一个PrefixQuery对象，就可以进行前缀查找了。

下面以代码11.7为例来介绍使用PrefixQuery进行检索的运行过程。

代码11.7  PrefixQueryTest.java

package ch11;

import org.apache.lucene.analysis.standard.StandardAnalyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.document.Field;

import org.apache.lucene.index.IndexWriter;

import org.apache.lucene.index.Term;

import org.apache.lucene.search.Hits;

import org.apache.lucene.search.IndexSearcher;

import org.apache.lucene.search.PrefixQuery;

import org.apache.lucene.search.RangeQuery;

 

public class PrefixQueryTest {

     public static void main(String[] args) throws Exception {

         //生成Document对象，下同

         Document doc1 = new Document();

         //添加“name”字段的内容，下同

         doc1.add(Field.Text("name", "David"));

         //添加“title”字段的内容，下同

         doc1.add(Field.Keyword("title", "doc1"));

 

         Document doc2 = new Document();

         doc2.add(Field.Text("name", "Darwen"));

         doc2.add(Field.Keyword("title", "doc2"));

 

         Document doc3 = new Document();

         doc3.add(Field.Text("name", "Smith"));

         doc3.add(Field.Keyword("title", "doc3"));

 

         Document doc4 = new Document();

         doc4.add(Field.Text("name", "Smart"));

         doc4.add(Field.Keyword("title", "doc4"));

 

         //生成索引书写器

         IndexWriter writer = new IndexWriter("c:\\index",

                 new StandardAnalyzer(), true);

         //设置为混合索引模式

         writer.setUseCompoundFile(true);

         //依次将文档添加到索引中

         writer.addDocument(doc1);

         writer.addDocument(doc2);

         writer.addDocument(doc3);

         writer.addDocument(doc4); 

         //关闭索引书写器

         writer.close();

 

         //生成索引搜索器对象

         IndexSearcher searcher = new IndexSearcher("c:\\index");

         //构造词条

         Term pre1 = new Term("name", "Da");

         Term pre2 = new Term("name", "da");

         Term pre3 = new Term("name", "sm");

 

         //用于保存检索结果

         Hits hits = null;

         //生成PrefixQuery类型的对象，初始化为null

         PrefixQuery query = null;

 

         query = new PrefixQuery(pre1);

 

         //开始第一次检索，并返回检索结果

         hits = searcher.search(query);

         //输出相应的检索结果

         printResult(hits, "前缀为'Da'的文档");

         

         query = new PrefixQuery(pre2);

         //开始第二次检索，并返回检索结果

         hits = searcher.search(query);

         //输出相应的检索结果

         printResult(hits, "前缀为'da'的文档");

         

         query = new PrefixQuery(pre3);

         //开始第二次检索，并返回检索结果

         hits = searcher.search(query);

         //输出相应的检索结果

         printResult(hits, "前缀为'sm'的文档");

 

     }

 

     public static void printResult(Hits hits, String key) throws Exception 

         {System.out.println("查找 \"" + key + "\" :");

         if (hits != null) {

             if (hits.length() == 0) {

                 System.out.println("没有找到任何结果");

                 System.out.println();

             } else {

                 System.out.print("找到");

                 for (int i = 0; i < hits.length(); i++) {

                     //取得文档

                     Document d = hits.doc(i);

                     //取得“title”字段的内容

                     String dname = d.get("title");

                     System.out.print(dname + "   ");

                 }

                 System.out.println();

                 System.out.println();

             }

         }

     }

}

在上述代码中，首先构造了4个不同的Document。每个Document都有一个名为“name”的字段，其中存储了人物的名称。然后，代码构建了3个不同的词条，分别为“Da”、“da”和“sm”，可以看到，它们正好都是“name”字段中关键字的前缀。

代码的运行结果如图11-12所示。

从图11-12中可以看出，使用PrefixQuery共进行了3次检索，关键字分别为“Da”、“da”和“sm”，返回的检索结果情况在图中已经有明确的说明。不过，如果使用“Da”作为关键字会没有任何的检索结果，而使用“da”就有检索结果，这个问题将在后面作详细介绍。

从代码11.7和图11-12中可以看出，“da”前缀和“sm”前缀都顺利地找到了它们所在的文档，可是为什么与文档中关键字大小写一致的“Da”却没有找到呢？这是因为Lucene的标准分析器在进行分词过滤时将所有的关键字一律转成了小写，所以才会出现这样的结果。这也是开发者应当引起注意的地方。

11.4.5  多关键字的搜索—PhraseQuery 
除了普通的TermQuery外，Lucene还提供了一种Phrase查 询的功能。用户在搜索引擎中进行搜索时，常常查找的并非是一个简单的单词，很有可能是几个不同的关键字。这些关键字之间要么是紧密相联，成为一个精确的短 语，要么是可能在这几个关键字之间还插有其他无关的关键字。此时，用户希望将它们找出来。不过很显然，从评分的角度看，这些关键字之间拥有与查找内容无关 短语所在的文档的分值一般会较低一些。

PhraseQuery正是Lucene所提供的满足上述需求的一种Query对象。它的add方法可以让用户往其内部添加关键字，在添加完毕后，用户还可以通过setSlop()方法来设定一个称之为“坡度”的变量来确定关键字之间是否允许、允许多少个无关词汇的存在。

下面以代码11.8为例对PhraseQuery进行介绍。

代码11.8  PhraseQueryTest.java

package ch11;

import org.apache.lucene.analysis.standard.StandardAnalyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.document.Field;

import org.apache.lucene.index.IndexWriter;

import org.apache.lucene.index.Term;

import org.apache.lucene.search.Hits;

import org.apache.lucene.search.IndexSearcher;

import org.apache.lucene.search.PhraseQuery;

import org.apache.lucene.search.PrefixQuery;

 

public class PhraseQueryTest {

     public static void main(String[] args) throws Exception {

         //生成Document对象

         Document doc1 = new Document();

         //添加“content”字段的内容

         doc1.add(Field.Text("content", "david mary smith robert"));

         //添加“title”字段的内容

         doc1.add(Field.Keyword("title", "doc1"));

 

         //生成索引书写器

         IndexWriter writer = new IndexWriter("c:\\index",

                 new StandardAnalyzer(), true);

         //设置为混合索引格式

         writer.setUseCompoundFile(true);

         //将文档添加到索引中

         writer.addDocument(doc1);

         //关闭索引

         writer.close();

 

         //生成索引搜索器

         IndexSearcher searcher = new IndexSearcher("c:\\index");

         //构造词条

         Term word1 = new Term("content", "david");

         Term word2 = new Term("content","mary");

         Term word3 = new Term("content","smith");

         Term word4 = new Term("content","robert");

         

         //用于保存检索结果

         Hits hits = null;

         //生成PhraseQuery对象，初始化为null

         PhraseQuery query = null;

 

         // 第一种情况，两个词本身紧密相连，先设置坡度为0，再设置坡度为2

         query = new PhraseQuery();

         query.add(word1);

         query.add(word2);

         //设置坡度

         query.setSlop(0);

         //开始检索，并返回检索结果

         hits = searcher.search(query);

         //输出检索结果的相关信息

         printResult(hits, "'david'与'mary'紧紧相隔的Document");

         

         //再次设置坡度

         query.setSlop(2);

         //开始第二次检索

         hits = searcher.search(query);

         //输出检索结果

         printResult(hits, "'david'与'mary'中相隔两个词的短语");

         

         // 第二种情况，两个词本身相隔两个词，先设置坡度为0，再设置坡度为2

         query = new PhraseQuery();

         query.add(word1);

         query.add(word4);

         //设置坡度

         query.setSlop(0);

         //开始第三次检索，并返回检索结果

         hits = searcher.search(query);

         //输出检索结果

         printResult(hits, "'david'与'robert'紧紧相隔的Document");

         

         //设置坡度

         query.setSlop(2);

         //开始第四次检索，并返回检索结果

         hits = searcher.search(query);

         //输出检索结果

         printResult(hits, "'david'与'robert'中相隔两个词的短语");

         

 

     }

 

     public static void printResult(Hits hits, String key) throws Exception 

         {System.out.println("查找 \"" + key + "\" :");

         if (hits != null) {

             if (hits.length() == 0) {

                 System.out.println("没有找到任何结果");

                 System.out.println();

             } else {

                 System.out.print("找到");

                 for (int i = 0; i < hits.length(); i++) {

                     //取得文档对象

                     Document d = hits.doc(i);

                     //取得“title”字段的内容

                     String dname = d.get("title");

                     //输出相关的信息

                     System.out.print(dname + "   ");

                 }

                 System.out.println();

                 System.out.println();

             }

         }

     }

}

在上述代码中创建了一个Document，这个Document的“content”域中含有4个关键字。接下来，代码创建了一个PhraseQuery对象，首先将前两个紧紧相连关键字放入其中，并设置它们的坡度值分别为0和2，接下来，又将第一个和最后一个关键字放入其中，同样设置它们的坡度值为0和2。

代码11.8的运行效果，如图11-13所示。

从图11.8中可以看出，代码11.8共进行了4次检索测试，并且分两组分别对检索结果进行对比。

从代码11.8和图11-13中可以看出，对两个紧连的关键字来说无论将坡度设置为多少，Lucene总能找到它所在的文档，而对两个不紧连的关键字，如果坡度值小于它们之间无关词的数量，那么则无法找到。其实，当两个关键字之间的无关词数小于等于坡度值时，总是可以被找到。

11.4.6  使用短语缀搜索—PhrasePrefixQuery 
PhrasePrefixQuery与Phrase有些类似。在PhraseQuery中，如果用户想查找短语“david robert”，又想查找短语“mary robert”。那么，他就只能构建两个PhraseQuery，然后再使用BooleanQuery将它们作为其中的子句，并使用“或”操作符来连接，这样就能达到需要的效果。PhrasePrefixQuery可以让用户很方便地实现这种需要。

接下来看看在代码11.9中是如何使用PhrasePrefixQuery来实现的。

代码11.9  PhrasePrefixQueryTest.java

package ch11;

import org.apache.lucene.analysis.standard.StandardAnalyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.document.Field;

import org.apache.lucene.index.IndexWriter;

import org.apache.lucene.index.Term;

import org.apache.lucene.search.Hits;

import org.apache.lucene.search.IndexSearcher;

import org.apache.lucene.search.PhrasePrefixQuery;

import org.apache.lucene.search.PhraseQuery;

import org.apache.lucene.search.RangeQuery;

 

public class PhrasePrefixQueryTest {

     public static void main(String[] args) throws Exception {

         //生成Document对象

         Document doc1 = new Document();

         //添加“content”字段的内容

         doc1.add(Field.Text("content", "david mary smith robert"));

         //添加“title”字段的内容

         doc1.add(Field.Keyword("title", "doc1"));

 

         //生成索引书写器对象

         IndexWriter writer = new IndexWriter("c:\\index",

                 new StandardAnalyzer(), true);

         //将文档添加到索引中

         writer.addDocument(doc1);

         //关闭索引书写器

         writer.close();

  

         //生成索引检索器

         IndexSearcher searcher = new IndexSearcher("c:\\index");

         //构造词条

         Term word1 = new Term("content", "david");

         Term word2 = new Term("content", "mary");

         Term word3 = new Term("content", "smith");

         Term word4 = new Term("content", "robert");

 

         //用于保存检索结果

         Hits hits = null;

         //生成PhrasePrefixQuery对象，初始化为null

         PhrasePrefixQuery query = null;

         

         query = new PhrasePrefixQuery();

         // 加入可能的所有不确定的词

         query.add(new Term[]{word1, word2});

         // 加入确定的词

         query.add(word4);

         //设置坡度

         query.setSlop(2);

         //开始检索，并返回检索结果

         hits = searcher.search(query);

         //输出检索结果的相关信息

         printResult(hits, "存在短语'david robert'或'mary robert'的文档");

     }

 

     public static void printResult(Hits hits, String key) throws Exception 

         {System.out.println("查找 \"" + key + "\" :");

         if (hits != null) {

             if (hits.length() == 0) {

                 System.out.println("没有找到任何结果");

                 System.out.println();

             } else {

                 System.out.print("找到");

                 for (int i = 0; i < hits.length(); i++) {

                 //获取文档对象

                     Document d = hits.doc(i);

                     //取得“title”字段内容

                     String dname = d.get("title");

                     System.out.print(dname + "   ");

                 }

                 System.out.println();

                 System.out.println();

             }

         }

     }

}

在上述代码中，首先构建了一个Document，它的“content”字段中包含4个关键字。接下来，构建了一个PhrasePrefixQuery的对象，调用它的add(Term [])方法设定出现在短语中的第一个关键词。由于这个方法的参数类型为一个Term型的数组，所以，它可以设置多个Term，即出现在短语中的第一个词就在这个数组中进行选择。然后，再使用add(Term)方法设置出现在短语中的后一个词。代码的运行结果如图11-14所示。



图11-14  PhrasePrefixQuery的测试结果

从图11-14中可以看出，使用PhrasePrefixQuery可以非常容易的实现相关短语的检索功能。

11.4.7  相近词语的搜索—FuzzyQuery 
FuzzyQuery是一种模糊查询，它可以简单地识别两个相近的词语。下面以11.10为例进行详细介绍。

代码11.10  FuzzyQueryTest.java

package ch11;

 

import org.apache.lucene.analysis.standard.StandardAnalyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.document.Field;

import org.apache.lucene.index.IndexWriter;

import org.apache.lucene.index.Term;

import org.apache.lucene.search.FuzzyQuery;

import org.apache.lucene.search.Hits;

import org.apache.lucene.search.IndexSearcher;

 

public class FuzzyQueryTest {

     public static void main(String[] args) throws Exception {

         //生成Document对象

         Document doc1 = new Document();

         //添加“content”字段的内容

         doc1.add(Field.Text("content", "david"));

         //添加“title”字段的内容

         doc1.add(Field.Keyword("title", "doc1"));

 

         Document doc2 = new Document();

         doc2.add(Field.Text("content", "sdavid"));

         doc2.add(Field.Keyword("title", "doc2"));

 

         Document doc3 = new Document();

         doc3.add(Field.Text("content", "davie"));

         doc3.add(Field.Keyword("title", "doc3"));

 

         //生成索引书写器

         IndexWriter writer = new IndexWriter("c:\\index",

                 new StandardAnalyzer(), true);

         //将文档添加到索引中

         writer.addDocument(doc1);

         writer.addDocument(doc2);

         writer.addDocument(doc3);

         //关闭索引写器

         writer.close();

 

         //生成索引搜索器

         IndexSearcher searcher = new IndexSearcher("c:\\index");

         Term word1 = new Term("content", "david");

 

         //用于保存检索结果

         Hits hits = null;

         //生成FuzzyQuery对象，初始化为null

         FuzzyQuery query = null;

 

         query = new FuzzyQuery(word1);

         //开始检索，并返回检索结果

         hits = searcher.search(query);

         //输出检索结果的相关信息

         printResult(hits,"与'david'相似的词");

     }

 

     public static void printResult(Hits hits, String key) throws Exception 

         {System.out.println("查找 \"" + key + "\" :");

         if (hits != null) {

             if (hits.length() == 0) {

                 System.out.println("没有找到任何结果");

                 System.out.println();

             } else {

                 System.out.print("找到");

                 for (int i = 0; i < hits.length(); i++) {

                     //取得文档对象

                     Document d = hits.doc(i);

                     //取得“title”字段的内容

                     String dname = d.get("title");

                     System.out.print(dname + "   ");

                 }

                 System.out.println();

                 System.out.println();

             }

         }

     }

}

在上述代码中，首先构建了3个Document，这3个Document的“content”字段中都有一个与“david”较为相似的关键字（其中第一个就是david）。然后使用FuzzyQuery来对其进行检索。运行效果如图11-15所示。

从图11-15中可以看出，使用FuzzyQuery可以检索到索引中所有包含与“david”相近词语的文档。

11.4.8  使用通配符搜索—WildcardQuery 
Lucene也提供了通配符的查询，这就是WildcardQuery。下面以代码11.11为例进行介绍。

代码11.11  WildcardQueryTest.java

package ch11;

 

import org.apache.lucene.analysis.standard.StandardAnalyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.document.Field;

import org.apache.lucene.index.IndexWriter;

import org.apache.lucene.index.Term;

import org.apache.lucene.search.Hits;

import org.apache.lucene.search.IndexSearcher;

import org.apache.lucene.search.WildcardQuery;

 

public class WildcardQueryTest {

     public static void main(String[] args) throws Exception {

         //生成Document对象，下同

         Document doc1 = new Document();

         //添加“content”字段的内容，下同

         doc1.add(Field.Text("content", "whatever"));

         //添加“title”字段的内容，下同

         doc1.add(Field.Keyword("title", "doc1"));

         

         Document doc2 = new Document();

         doc2.add(Field.Text("content", "whoever"));

         doc2.add(Field.Keyword("title", "doc2"));

         

         Document doc3 = new Document();

         doc3.add(Field.Text("content", "however"));

         doc3.add(Field.Keyword("title", "doc3"));

         

         Document doc4 = new Document();

         doc4.add(Field.Text("content", "everest"));

         doc4.add(Field.Keyword("title", "doc4"));

         

         //生成索引书写器

         IndexWriter writer = new IndexWriter("c:\\index",

                 new StandardAnalyzer(), true);

         //将文档对象添加到索引中

         writer.addDocument(doc1);

         writer.addDocument(doc2);

         writer.addDocument(doc3);

         writer.addDocument(doc4);

         //关闭索引书写器

         writer.close();

 

         //生成索引书写器

         IndexSearcher searcher = new IndexSearcher("c:\\index");

         //构造词条

         Term word1 = new Term("content", "*ever");

         Term word2 = new Term("content", "wh?ever");

         Term word3 = new Term("content", "h??ever");

         Term word4 = new Term("content", "ever*");

         //生成WildcardQuery对象，初始化为null

         WildcardQuery query = null;

         //用于保存检索结果

         Hits hits = null;

         

         query = new WildcardQuery(word1);

         //开始第一次检索，并返回检索结果

         hits = searcher.search(query);

         //输出检索结果的相关信息

         printResult(hits, "*ever");

         

         query = new WildcardQuery(word2);

         //开始第二次检索，并返回检索结果

         hits = searcher.search(query);

         //输出检索结果的相关信息

         printResult(hits, "wh?ever");

         

         query = new WildcardQuery(word3);

         //开始第三次检索，并返回检索结果

         hits = searcher.search(query);

         //输出检索结果的相关信息

         printResult(hits, "h??ever");

         

         query = new WildcardQuery(word4);

         //开始第四次检索，并返回检索结果

         hits = searcher.search(query);

         //输出检索结果的相关信息

         printResult(hits, "ever*");

     }

    

     public static void printResult(Hits hits, String key) throws Exception 

         {System.out.println("查找 \"" + key + "\" :");

         if (hits != null) {

             if (hits.length() == 0) {

                 System.out.println("没有找到任何结果");

                 System.out.println();

             } else {

                 System.out.print("找到");

                 for (int i = 0; i < hits.length(); i++) {

                     //取得文档对象

                     Document d = hits.doc(i);

                     //取得“title”字段的内容

                     String dname = d.get("title");

                     System.out.print(dname + "   ");

                 }

                 System.out.println();

                 System.out.println();

             }

         }

     }

}

代码11.11的运行结果如图11-16所示。


由上述代码可以看出，通配符“?”代表1个字符，而“*”则代表0至多个字符。不过通配符检索和上面的FuzzyQuery由于需要对字段关键字进行字符串匹配，所以，在搜索的性能上面会受到一些影响。


 


[/size]
  • 大小: 4.7 KB
  • 大小: 4.7 KB
  • 大小: 4.7 KB
  • 大小: 9.4 KB
  • 大小: 7.5 KB
  • 大小: 7.5 KB
  • 大小: 7.5 KB
  • 大小: 6.8 KB
  • 大小: 5 KB
  • 大小: 5.7 KB
分享到：
| 基于JNDI的应用程序开发
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    lucene中的SpanQuery和PhraseQuery详解(有图示)

    Lucene中的SpanQuery和...SpanQuery 和 PhraseQuery 都是 Lucene 中强大的查询工具，旨在帮助开发者快速构建高效的搜索引擎。但是，它们的使用场景和实现机制有所不同，需要根据实际情况选择合适的查询方式。

    Lucene 使用正则表达式

    它为开发者提供了构建搜索应用所需的工具,包括索引文档和执行查询的能力。Lucene的核心特性之一就是支持复杂的查询语言,其中包括正则表达式。 #### 正则表达式在Lucene中的应用 正则表达式是一种强大的文本模式匹配...

    lucene-query-string-builder:使用基本功能构建复杂的Lucene查询字符串

    npm install lucene-query-string-builder --save 特征 创建术语字符串时转义lucene特殊字符 包含所有lucene用途的运算符 简单的lucene.builder函数，用于定义lucene查询构建器 用法 让我们看看如何使用Lucene查询...

    Lucene 搜索方法（模糊搜索）

    在IT领域，搜索引擎技术是不可或缺的一部分，而Apache Lucene是一个高性能、全文本搜索库，它为开发者提供了构建自定义搜索引擎应用程序所需的所有工具。本篇我们将深入探讨如何在Lucene中实现模糊搜索，以及相关的...

    我封装的搜索引擎之lucene篇

    描述中的“NULL”意味着没有具体的细节，但我们可以从标签“源码”和“工具”推断，这个压缩包可能包含了使用Lucene构建的搜索工具的源代码，或者是关于如何使用Lucene的示例代码。 标签“源码”表明文件内可能有...

    Lucene示例 BM25相似度计算

    在IT领域，搜索引擎技术是至关重要的，而Lucene作为一个开源全文搜索引擎库，广泛应用于各种文本检索系统中。本文将深入探讨Lucene示例中的BM25相似度计算，旨在帮助初学者理解如何利用Lucene 4.7.1版本构建索引、...

    Lucene时间区间搜索

    Lucene是一款强大的全文搜索引擎库，广泛应用于各种数据检索场景。在C#环境下，利用Lucene进行时间区间搜索是提高数据检索效率和精确度的重要手段。本篇将深入探讨如何在C#中实现Lucene的时间区间查询匹配，以及涉及...

    Lucene各种jar包

    总之，"Lucene各种jar包"提供的资源使得开发者能够充分利用Lucene的强大功能，构建高效的全文搜索引擎。通过理解并熟练运用这些jar包，开发者可以创建能够处理大量文本数据并提供精确、快速搜索结果的应用程序。

    Lucene使用代码实例之搜索文档

    TermQuery luceneQuery = new TermQuery(term); // 执行查询 Hits hits = searcher.search(luceneQuery); // 输出搜索结果 for(int i = 0; i (); i++){ Document document = hits.doc(i); System.out....

    Annotated Lucene 中文版 Lucene源码剖析

    Lucene是一款开源的Java库，它提供了高效的文本搜索功能，被广泛应用于各种信息检索系统。这本书面向对Java编程和信息检索感兴趣的开发者，通过详尽的注释和分析，使读者能够深入掌握Lucene的内部机制。 首先，...

    lucene 全包 包括源码

    3. 查询（Query）：用户查询被转换成 Lucene Query 对象，如TermQuery、BooleanQuery等。这些查询对象与索引交互，寻找匹配的文档。解析查询字符串的类，如QueryParser，也是在这个阶段发挥作用。 4. 搜索（Search...

    lucene

    在Java编程语言中，Lucene被广泛应用于各种需要全文搜索功能的系统，如网站、文档管理、知识库等。其强大的搜索性能和灵活的配置使得开发者能够快速构建自己的搜索引擎。 一、Lucene的基本架构 Lucene的核心架构...

    spring-lucene简单项目

    用户可以通过提供查询字符串，由查询解析器转化为LuceneQuery，然后在索引上执行搜索。搜索结果会返回一个ScoreDoc数组，每个ScoreDoc对应一个匹配的文档及其相关性分数。 此外，项目可能还涉及了对索引的优化和...

    基于Lucene的Lucene

    基于Lucene构建的文件检索系统，能够高效地索引和搜索各种文本文件。通过扩展Analyzer和文件解析能力，可以轻松支持更多文件格式，满足不同场景的需求。在实际应用中，还需要考虑性能优化、并发处理、增量索引和实时...

    lucene 5.1.0 码源

    2. **分词器（Tokenizer）**: 在`org.apache.lucene.analysis`包下，可以看到各种分词器的实现，如标准分词器（StandardTokenizer）、中文分词器（ICUTokenizer）等，它们负责将输入文本分割成有意义的词汇单元。...

    Lucene学习源码.rar

    4. `org.apache.lucene.search.Query` 和 `org.apache.lucene.queryparser.classic.QueryParser`：理解查询的构建和解析过程。 5. `org.apache.lucene.search.Searcher`：研究搜索过程，特别是如何计算相关性和返回...

    lucene 索引小示例

    在Java编程环境中，Lucene被广泛应用于构建搜索功能，特别是对于大量文本数据的高效检索。本篇文章将通过一个简单的小示例，深入探讨Lucene的核心概念和操作流程。 首先，我们需要理解Lucene的索引机制。索引是...

    lucene基础jar包

    "lucene基础jar包"指的是包含Lucene核心组件的基础Java档案（JAR）文件集合，这些文件是构建基于Lucene的搜索应用所必需的。 Lucene 的核心功能包括： 1. **索引创建**：Lucene 提供了对文本数据进行高效索引的...

    lucene1.4.3.jar

    Apache Lucene 是一个开源全文搜索引擎库，自1999年诞生以来，它为开发者提供了强大的文本检索功能，广泛应用于各种信息检索系统。本次我们将聚焦于Lucene 1.4.3版本，这个版本虽然相对较为古老，但仍然具有重要的...

    Lucene资料大全(包括Lucene_in_Action书等)

    2. **索引构建**：Lucene将文档转换为倒排索引结构，这是一种高效的数据结构，允许快速查找包含特定词汇的文档。 3. **搜索查询**：用户可以通过QueryParser或直接构造Query对象来创建搜索请求。Lucene支持布尔查询...

Magicbox
Global site tag (gtag.js) - Google Analytics