lucene分词器与搜索

一、分词器

　　lucene针对不同的语言和虚伪提供了许多分词器，我们可以针对应用的不同的需求使用不同的分词器进行分词。我们需要注意的是在创建索引时使用的分词器与搜索时使用的分词器要保持一致。否则搜索的结果就不是我们期望的结果。lucene提供的常规分词器如下：

•StandardAnalyzer 标准分词器

•IKAnalyzer 基于Lucene的第三方中文分词技术

•WhitespaceAnalyzer 空格分词器

•SimpleAnalyzer 简单分词器

•CJKAnalyzer 二分法分词器

•KeywordAnalyzer 关键词分词器

•StopAnalyzer 被忽略词分词器

•FrenchAnalyzer 法国语言分词

•GermanAnalyzer 德国语言分词

•GreekAnalyzer 希腊语言分词

•RussianAnalyzer 俄罗斯语言分词

　　相关分词器示例如下：

 package com.test.lucene;

 import java.io.IOException;
 import java.io.StringReader;

 import org.apache.lucene.analysis.Analyzer;
 import org.apache.lucene.analysis.TokenStream;
 import org.apache.lucene.analysis.cjk.CJKAnalyzer;
 import org.apache.lucene.analysis.cn.smart.SmartChineseAnalyzer;
 import org.apache.lucene.analysis.core.KeywordAnalyzer;
 import org.apache.lucene.analysis.core.SimpleAnalyzer;
 import org.apache.lucene.analysis.core.StopAnalyzer;
 import org.apache.lucene.analysis.core.WhitespaceAnalyzer;
 import org.apache.lucene.analysis.standard.StandardAnalyzer;
 import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;

 /**
  * 分词器
  */
 public class AnalyzerStudy {

     /**
      * 分词并打印分词结果
      *
      * @param analyzer
      *            分词器种类
      * @param content
      *            需要分词的内容
      */
     private static void print(Analyzer analyzer, String content) {
         StringReader reader = new StringReader(content);
         try {
             TokenStream tokenStream = analyzer.tokenStream("", reader);
             tokenStream.reset();
             CharTermAttribute term = tokenStream.getAttribute(CharTermAttribute.class);
             System.out.println("分词技术" + analyzer.getClass());
             while (tokenStream.incrementToken()) {
                 System.out.print(term.toString() + "|");
             }
             System.out.println();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }

     public static void main(String[] args) {
         String content = "上海广州， lucene 软件 开发";
         Analyzer analyzer = null;
         // 标准分词
         analyzer = new StandardAnalyzer();
         print(analyzer, content);

         // 空格分词
         analyzer = new WhitespaceAnalyzer();
         print(analyzer, content);

         // 简单分词
         analyzer = new SimpleAnalyzer();
         print(analyzer, content);

         // 二分法分词
         analyzer = new CJKAnalyzer();
         print(analyzer, content);

         // 关键字分词
         analyzer = new KeywordAnalyzer();
         print(analyzer, content);

         // 被忽略词分词
         analyzer = new StopAnalyzer();
         print(analyzer, content);

         // 中文分词
         analyzer = new SmartChineseAnalyzer();
         print(analyzer, content);
     }

 }

　　运行结果如下：

二、搜索条件

　　在有些应用场景中，我们需要在搜索的时候，使用多个条件进行查询。此时我们可以使用lucene提供的搜索条件进行搜索。如对多个域进行查询、前缀查询、通配符查询等。

　　相关示查询例如下：

 package com.test.lucene;

 import org.apache.lucene.analysis.Analyzer;
 import org.apache.lucene.analysis.standard.StandardAnalyzer;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.queryparser.classic.MultiFieldQueryParser;
 import org.apache.lucene.queryparser.classic.ParseException;
 import org.apache.lucene.queryparser.classic.QueryParser;
 import org.apache.lucene.search.BooleanClause.Occur;
 import org.apache.lucene.search.BooleanQuery;
 import org.apache.lucene.search.PhraseQuery;
 import org.apache.lucene.search.PrefixQuery;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.TermQuery;
 import org.apache.lucene.search.TermRangeQuery;

 /**
  * 查询条件
  */
 public class QueryStudy {
     public static void main(String[] args) {
         // 搜索关键词
         String keyword = "上海";
         // 搜索域名
         String field = "name";
         // 搜索多个域的域名数组
         String[] fields = { "name", "content" };
         // Query 创建过程中的分词技术
         Analyzer analyzer = new StandardAnalyzer();
         Query query = null;
         // 对单个域创建查询语句
         QueryParser parser = new QueryParser(field, analyzer);
         try {
             query = parser.parse(keyword);
         } catch (ParseException e) {
             e.printStackTrace();
         }
         System.out.println(QueryParser.class + " " + query.toString());

         // 对多个域创建查询语句
         MultiFieldQueryParser parser2 = new MultiFieldQueryParser(fields, analyzer);
         try {
             query = parser2.parse(keyword);
         } catch (ParseException e) {
             e.printStackTrace();
         }
         System.out.println(MultiFieldQueryParser.class + " " + query.toString());

         // 词条查询语句
         query = new TermQuery(new Term(field, keyword));
         System.out.println(TermQuery.class + " " + query.toString());

         // 前缀查询语句
         query = new PrefixQuery(new Term(field, keyword));
         System.out.println(PrefixQuery.class + " " + query.toString());

         // 多余查询语句
         PhraseQuery query2 = new PhraseQuery();
         // 设置短语之间的最大距离
         query2.add(new Term(field, "上海"));
         query2.add(new Term(field, "lucene开发"));
         System.out.println(PhraseQuery.class + " " + query2.toString());

         // 通配符查询语句，Lucene中有 * ? 两个通配符， *表示任意多个字符，?表示一个任意字符
         query = TermRangeQuery.newStringRange(field, "abc", "azz", false, false);
         System.out.println(TermRangeQuery.class + " " + query.toString());

         // 布尔查询
         BooleanQuery query3 = new BooleanQuery();
         query3.add(new TermQuery(new Term(field, "上海")), Occur.SHOULD);
         query3.add(new TermQuery(new Term(field, "lucene")), Occur.SHOULD);
         query3.add(new TermQuery(new Term(field, "案例")), Occur.MUST_NOT);
         System.out.println(BooleanQuery.class + " " + query3.toString());
     }
 }

　　运行结果如下：