Lucene搜索方法

布尔搜索：
布尔查询的对象中，包含一个子句的集合。各种子句间都是“与”、“或”这样的布尔逻辑。

IndexSearcher search = new IndexSearcher("d://demo");
Term t1 = new Term("bookname","女");
Term t2 = new Term("bookname","狗");

TermQuery q1 = new TermQuery(t1);
TermQuery q2 = new TermQuery(t2);

BooleanQuery query = new BooleanQuery();
query.add(q1,BooleanClause.Occur.MUST);
query.add(q2,BooleanClause.Occur.MUST);

Hits hits = search.search(query); 

 

2.MUST、MUST_NOT、SHOULD

MUST表示结果必须包含

MUST_NOT表示结果必须不能包含

SHOULD表示可以包含也可以不包含

布尔查询对其子句的数量是有限制的默认限制为1024条子查询，如果查过了，会抛出TooManyClauses异常，当然用户也可以通过BooleanQuery的方法setMaxClauseCount(int maxClauseCount).

布尔查询的子句并非只能对TermQuery的原子查询，也可以进行BooleanQuery的符合查询。

 

 

范围搜索：

在某些情况下，用户需要查找一定范围内的文档，比如时间，ID等。

 

IndexSearcher search = new IndexSearcher("d://demo");
   Term t1 = new Term("bookname","001");
   Term t2 = new Term("bookname","005");
   
   RangeQuery query = new RangeQuery(t1,t2,false);
   
   
   Hits hits = search.search(query)

 

 

首先为QUERY设置一个上届和一个下届，然后设置一个布尔值，布尔值表示，如果为TRUE，那么这两个临界值加入到结果中，如果为FALSE那么就不加到结果中。在RangeQuery判断某个TERM是否在某一范围内时，使用的是STRING的toString方法。

由于该类的rewrite方法将对某个范围内的查询转化为一个由多个TERMQUERY组成的布尔查询，而且每个子查询的条件都为SHOULD，所以查询满足的条件文档较大的时候，性能非常的低。

如果你设置的查询的范围超过了1024，那么就会抛出异常，TooManyClause就是由于地层采用的是BooleanQuery来查询。

 

 

模糊搜索：

LUCENE提供了一种模糊搜索的机制。

 

IndexSearcher search = new IndexSearcher("d://demo");
   
   Term term1 = new Term("bookname","work");
   FuzzyQuery query = new FuzzyQuery(term1,0.1f,1);
   Hits hits = search.search(query);  

 

 

注释：首先构建了一个TERM，并将其作为FuzzyQuery的构造函数，对于FuzzyQuery有两个构造函数，

public FuzzyQuery(Term term,float minimumSimilarity) throws IllegalArgumentException

public FuzzyQuery(Term term,float minimumSimilarity,int prefixLength) throws IllegalArgumentException

 

minimumSimilarity表示是最小相似度，可以通过指定一个相似度来决定模糊匹配的严格程度。默认为0.5，当这个值越小，通过模糊查找出的文档的匹配程度就越低，文档的数量也就越多；当这个值越大，说明要匹配程度更大，匹配的文档数也就越少，当相似度设置为1，那么就退化为TermQuery查询，所以当这个值>=1或<0会抛出IllegalArgumentException异常。

另外一个参数prefixLength表示在进行模糊匹配的时候，要有多少个前缀字母必须完全匹配。例如当该值设置为“1”，则表示所有此条只有第一个字母与检索关键字相符时，才会被集合选中。

 

以上程序设置相似度为0.1f,并且匹配第一个字母相符的检索结果。

 

 

前缀搜索：

PrefixQuery是一种前缀搜索，在检索的时候，常常需要进行某种前缀查找，例如到图书馆查找一本书，可能只能记得书名的前面几个字，这种情况就可以用该种搜索模式。

 

 IndexSearcher search = new IndexSearcher("d://demo");
   Term term = new Term("bookname","钢");
   PrefixQuery query = new PrefixQuery(term);
   Hits hits = search.search(query);

 

这种查询方式可能比较慢

 

 

短语搜索：

用户在搜索的时候，更多的情况是输入一个以上的关键字，这些关键字和可能组成一个短语。

 

IndexSearcher search = new IndexSearcher("d://demo");
   PhraseQuery query = new PhraseQuery();
   Term term1 = new Term("bookname","钢");
   Term term2 = new Term("bookname","铁");
   query.add(term1);
   query.add(term2);
   query.setSlop(2);
   Hits hits = search.search(query);

 

搜索结果都是钢和铁两字相连，而且顺序也一致的文档，即严格包含有“钢铁”这个短语的文档。

但是有时候用户会经常的输漏一个字或是多输入一个字，比如“钢或铁”等。

该类提供了一个setSlop(int num)的方式，表示设置坡度，它用于表示词组的两个字间可以插入无关字数的个数。

这个坡度默认值为0，在默认情况下，它将只给出那些严格匹配短语的文档作为查询结果。比如例子中设置的是2，那么表示在钢铁这两个字之间可以插入2个无关的字。

 

 

多短语搜索：

短语搜索解决了短语搜索的问题，在很多情况下，用户输入某个关键字时，该关键字可以喝多种单字组成短语，例如，用户输入一个“声”字。它可以和“声音”，“声明”等字组成短语。LUCENE提供了MultiPhraseQuery来进行多短语搜索。

 

IndexSearcher search = new IndexSearcher("d://demo");
   MultiPhraseQuery query = new MultiPhraseQuery();
   Term term1 = new Term("bookname","钢");
   Term term3 = new Term("bookname","和");
   query.add(new Term[]{term1,term3});
   
   Term term2 = new Term("bookname","铁");
   
   Term term4 = new Term("bookname","要");
   
   query.add(new Term[]{term2,term4});
   Hits hits = search.search(query);

注释：该程序定义的是以“钢”和“和”开头的字，并且可以组合“铁”和“要”的短语。

在该类中同样可以使用坡度的方法。

 

 

对搜索结果排序：

前面介绍完查询以后，现在要对查询结果进行排序的显示。

 

IndexSearcher search = new IndexSearcher("d://demo");

   String field = "bookname";
   String queryStr = "钢铁";
   QueryParser parser = new QueryParser(field, new StandardAnalyzer());
   Query q = parser.parse(queryStr);

//上面的查询是通过QueryParser来查询，下面通过SORT来进行排序，排序规则是首先根据bookNumber来排序，然后再根据publishdate来排序，第二个参数表示该字段是什么类型，第三个字段表示排列顺序（FALSH:升序，TRUE：降序）
   Sort sort = new Sort();
   SortField f1 = new SortField("bookNumber", SortField.INT, false);
   SortField f2 = new SortField("publishdate", SortField.STRING, false);
   sort.setSort(new SortField[] { f1, f2 });

//如果指定多个FIELD来进行排序，就把多个FIELD组合成数据塞到SORT中
   Hits hits = search.search(q, sort);   

 

SortField提供的FIELD的类型：string，int,float.指定FIELD的类型对排序过程的效率有巨大的影响。

 

 

在结果中搜索：

//在搜索oldqw的结果集中搜索qw.
        public static void searchInResult(String qw, String oldqw) throws ParseException, IOException {                
                QueryParser queryParser = new QueryParser("content",new SimpleAnalyzer());
                Query query = queryParser.parse(qw.trim());
                Query oldQuery = queryParser.parse(oldqw.trim());
                QueryFilter oldFilter = new QueryFilter(oldQuery);
                CachingWrapperFilter filter = new CachingWrapperFilter(oldFilter);
                
                search(query, filter);
        }
        
        private static void search(Query query, Filter filter) throws IOException, ParseException {
                IndexSearcher ins = new IndexSearcher("d:/tesindex");
                Hits hits = ins.search(query, filter);
                for (int i = 0; i < hits.length(); i++) {
                        Document doc = hits.doc(i);
                        System.out.println(doc.get("content"));
                }
                System.out.println();
        }

 

//首先通过搜素查询0001-0004的结果
   Term begin = new Term("bookNumber", "0001");
   Term end = new Term("bookNumber", "0004");
   RangeQuery q = new RangeQuery(begin, end, true);
   

 //通过将该查询的QUERY放置到 QueryFilter中
   QueryFilter filter = new QueryFilter(q);
   

//再制定
   Term normal = new Term("securitylevel",2+"");
   IndexSearcher searcher = new IndexSearcher("d://demo");
   TermQuery query = new TermQuery(normal);
   
   System.out.println(q.toString());
   Hits hits = searcher.search(query,filter);//制定查询的时候，将过滤器配置进行，这样相当于在0001-0004
的结果中找securitylevel=2的结果信息

 

 

对结果高亮显示：

public List collect(SearchArgs args, Hits hits, Query query)
    {
        try {
            int[] postIds = new int[Math.min(args.fetchCount(), hits.length())];
           
            for (int docIndex = args.startFrom(), i = 0;
                docIndex < args.startFrom() + args.fetchCount() && docIndex < hits.length();
                docIndex++, i++) {
                Document doc = hits.doc(docIndex);
                postIds[i] = Integer.parseInt(doc.get(SearchFields.Keyword.POST_ID));
            }
           
            return this.retrieveRealPosts(postIds, query);
        }
        catch (Exception e) {
            throw new ForumException(e.toString(), e);
        }
    }

    private List retrieveRealPosts(int[] postIds, Query query) throws IOException
    {
        List posts = DataAccessDriver.getInstance().newLuceneDAO().getPostsData(postIds);
       
        for (Iterator iter = posts.iterator(); iter.hasNext(); ) {
            Post post = (Post)iter.next();
           
            Scorer scorer = new QueryScorer(query);
            Highlighter highlighter = new Highlighter(scorer);
           
            TokenStream tokenStream = this.settings.analyzer().tokenStream(
                SearchFields.Indexed.CONTENTS, new StringReader(post.getText()));

            String fragment = highlighter.getBestFragment(tokenStream, post.getText());
            post.setText(fragment != null ? fragment : post.getText());
        }
       
        return posts;
    }