基于lucene的案例开发：查询语句创建PackQuery

转载请注明出处：http://blog.csdn.net/xiaojimanman/article/details/44656141

http://www.llwjy.com/blogdetail/162e5e70516d7ddfb6df8f77e6b13a2b.html

个人博客站已经上线了，网址 www.llwjy.com ~欢迎各位吐槽

-----------------------------------------------------------------------------------------------------------

      在之前的《基于lucene的案例开发：Query查询》这篇博客中对实际开发过程中比较常见的Query做了简单的介绍，这里就介绍下具体的代码实现。查看最新代码点击这里或访问 http://www.llwjy.com/source/com.lulei.lucene.query.PackQuery.html 

 /**
 *@Description:  创建查询Query
 */
package com.lulei.lucene.query;

import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
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.NumericRangeQuery;
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;
import org.apache.lucene.search.WildcardQuery;
import org.apache.lucene.util.Version;

import com.lulei.lucene.index.manager.IndexManager;


public class PackQuery {
    //分词器
    private Analyzer analyzer;
    //使用索引中的分词器
    public PackQuery(String indexName) {
        analyzer = IndexManager.getIndexManager(indexName).getAnalyzer();
    }
    //使用自定义分词器
    public PackQuery(Analyzer analyzer) {
        this.analyzer = analyzer;
    }

    /**
     * @param key
     * @param fields
     * @return Query
     * @throws ParseException
     * @Author: lulei
     * @Description: 查询字符串匹配多个查询域
     */
    public Query getMultiFieldQuery(String key, String[] fields) throws ParseException{
        MultiFieldQueryParser parse = new MultiFieldQueryParser(Version.LUCENE_43, fields, analyzer);
        Query query = null;
        query = parse.parse(key);
        return query;
    }

    /**
     * @param key
     * @param field
     * @return Query
     * @throws ParseException
     * @Author: lulei
     * @Description: 查询字符串匹配单个查询域
     */
    public Query getOneFieldQuery(String key, String field) throws ParseException{
        if (key == null || key.length() < 1){
            return null;
        }
        QueryParser parse = new QueryParser(Version.LUCENE_43, field, analyzer);
        Query query = null;
        query = parse.parse(key);
        return query;
    }

    /**
     * @param key
     * @param fields
     * @param occur
     * @return Query
     * @throws IOException
     * @Author: lulei
     * @Description: 查询字符串、多个查询域以及查询域在查询语句中的关系
     */
    public Query getBooleanQuery(String key, String[] fields, Occur[] occur) throws IOException{
        if (fields.length != occur.length){
            System.out.println("fields.length isn't equals occur.length, please check params!");
            return null;
        }
        BooleanQuery query = new BooleanQuery();
        TokenStream tokenStream = analyzer.tokenStream("", new StringReader(key));
        ArrayList<String> analyzerKeys = new ArrayList<String>();
        while(tokenStream.incrementToken()){
            CharTermAttribute term = tokenStream.getAttribute(CharTermAttribute.class);
            analyzerKeys.add(term.toString());
        }
        for(int i = 0; i < fields.length; i++){
            BooleanQuery queryField = new BooleanQuery();
            for(String analyzerKey : analyzerKeys){
                TermQuery termQuery = new TermQuery(new Term(fields[i], analyzerKey));
                queryField.add(termQuery, Occur.SHOULD);
            }
            query.add(queryField, occur[i]);
        }
        return query;
    }

    /**
     * @param querys
     * @param occur
     * @return Query
     * @Author: lulei
     * @Description: 组合多个查询，之间的关系由occur确定
     */
    public Query getBooleanQuery(ArrayList<Query> querys, ArrayList<Occur> occurs){
        if (querys.size() != occurs.size()){
            System.out.println("querys.size() isn't equals occurs.size(), please check params!");
            return null;
        }
        BooleanQuery query = new BooleanQuery();
        for (int i = 0; i < querys.size(); i++){
            query.add(querys.get(i), occurs.get(i));
        }
        return query;
    }

    /**
     * @param fieldName
     * @param value
     * @return
     * @Author: lulei
     * @Description: StringField属性的搜索
     */
    public Query getStringFieldQuery(String value, String fieldName){
        Query query = null;
        query = new TermQuery(new Term(fieldName, value));
        return query;
    }

    /**
     * @param fields
     * @param values
     * @return
     * @Author: lulei
     * @Description: 多个StringField属性的搜索
     */
    public Query getStringFieldQuery(String[] values, String[] fields, Occur occur){
        if (fields == null || values == null || fields.length != values.length){
            return null;
        }
        ArrayList<Query> querys = new ArrayList<Query>();
        ArrayList<Occur> occurs = new ArrayList<Occur>();
        for (int i = 0; i < fields.length; i++){
            querys.add(getStringFieldQuery(values[i], fields[i]));
            occurs.add(occur);
        }
        return getBooleanQuery(querys, occurs);
    }

    /**
     * @param key
     * @param field
     * @param lucene43
     * @return
     * @throws ParseException
     * @Author: lulei
     * @Description: 查询字符串和单个查询域 QueryParser是否使用4.3
     */
    public Query getOneFieldQuery(String key, String field, boolean lucene43) throws ParseException{
        if (key == null || key.length() < 1){
            return null;
        }
        if (lucene43){
            return getOneFieldQuery(key, field);
        }
        @SuppressWarnings("deprecation")
        QueryParser parse = new QueryParser(Version.LUCENE_30, field, analyzer);
        Query query = null;
        query = parse.parse(key);
        return query;
    }

    /**
     * @param key
     * @param field
     * @Author: lulei
     * @Description: key开头的查询字符串，和单个域匹配
     */
    public Query getStartQuery(String key, String field) {
        if (key == null || key.length() < 1){
            return null;
        }
        Query query = new PrefixQuery(new Term(field, key));
        return  query;
    }

    /**
     * @param key
     * @param fields
     * @param occur
     * @Author: lulei
     * @Description: key开头的查询字符串，和多个域匹配，每个域之间的关系由occur确定
     */
    public Query getStartQuery(String key, String []fields, Occur occur){
        if (key == null || key.length() < 1){
            return null;
        }
        ArrayList<Query> querys = new ArrayList<Query>();
        ArrayList<Occur> occurs = new ArrayList<Occur>();
        for (String field : fields) {
            querys.add(getStartQuery(key, field));
            occurs.add(occur);
        }
        return getBooleanQuery(querys, occurs);
    }

    /**
     * @param key
     * @param fields
     * @Author: lulei
     * @Description: key开头的查询字符串，和多个域匹配，每个域之间的关系Occur.SHOULD
     */
    public Query getStartQuery(String key, String []fields) {
        return getStartQuery(key, fields, Occur.SHOULD);
    }

    /**
     * @param key
     * @param field
     * @param slop
     * @return
     * @Author:lulei
     * @Description: 自定每个词元之间的最大距离
     */
    public Query getPhraseQuery(String key, String field, int slop) {
        if (key == null || key.length() < 1){
            return null;
        }
        StringReader reader = new StringReader(key);
        PhraseQuery query = new PhraseQuery();
        query.setSlop(slop);
        try {
            TokenStream  tokenStream  = this.analyzer.tokenStream(field, reader);
            tokenStream.reset();
            CharTermAttribute  term = tokenStream.getAttribute(CharTermAttribute.class);
            while(tokenStream.incrementToken()){
                query.add(new Term(field, term.toString()));
            }
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
        return query;
    }

    /**
     * @param key
     * @param fields
     * @param slop
     * @param occur
     * @return
     * @Author:lulei
     * @Description: 自定每个词元之间的最大距离，查询多个域，每个域之间的关系由occur确定
     */
    public Query getPhraseQuery(String key, String[] fields, int slop, Occur occur) {
        if (key == null || key.length() < 1){
            return null;
        }
        ArrayList<Query> querys = new ArrayList<Query>();
        ArrayList<Occur> occurs = new ArrayList<Occur>();
        for (String field : fields) {
            querys.add(getPhraseQuery(key, field, slop));
            occurs.add(occur);
        }
        return getBooleanQuery(querys, occurs);
    }

    /**
     * @param key
     * @param fields
     * @param slop
     * @return
     * @Author:lulei
     * @Description:  自定每个词元之间的最大距离，查询多个域，每个域之间的关系是Occur.SHOULD
     */
    public Query getPhraseQuery(String key, String[] fields, int slop) {
        return getPhraseQuery(key, fields, slop, Occur.SHOULD);
    }

    /**
     * @param key
     * @param field
     * @return
     * @Author:lulei
     * @Description: 通配符检索 eg:getWildcardQuery("a*thor", "field")
     */
    public Query getWildcardQuery(String key, String field) {
        if (key == null || key.length() < 1){
            return null;
        }
        return new WildcardQuery(new Term(field, key));
    }

    /**
     * @param key
     * @param fields
     * @param occur
     * @return
     * @Author:lulei
     * @Description: 通配符检索，域之间的关系为occur
     */
    public Query getWildcardQuery(String key, String[] fields, Occur occur) {
        if (key == null || key.length() < 1){
            return null;
        }
        ArrayList<Query> querys = new ArrayList<Query>();
        ArrayList<Occur> occurs = new ArrayList<Occur>();
        for (String field : fields) {
            querys.add(getWildcardQuery(key, field));
            occurs.add(occur);
        }
        return getBooleanQuery(querys, occurs);
    }

    /**
     * @param key
     * @param fields
     * @return
     * @Author:lulei
     * @Description: 通配符检索，域之间的关系为Occur.SHOULD
     */
    public Query getWildcardQuery(String key, String[] fields) {
        return getWildcardQuery(key, fields, Occur.SHOULD);
    }

    /**
     * @param keyStart
     * @param keyEnd
     * @param field
     * @param includeStart
     * @param includeEnd
     * @return
     * @Author:lulei
     * @Description: 范围搜索
     */
    public Query getRangeQuery (String keyStart, String keyEnd, String field, boolean includeStart, boolean includeEnd) {
        return TermRangeQuery.newStringRange(field, keyStart, keyEnd, includeStart, includeEnd);
    }

    /**
     * @param min
     * @param max
     * @param field
     * @param includeMin
     * @param includeMax
     * @return
     * @Author:lulei
     * @Description: 范围搜索
     */
    public Query getRangeQuery (int min, int max, String field, boolean includeMin, boolean includeMax) {
        return NumericRangeQuery.newIntRange(field, min, max, includeMin, includeMax);
    }

    /**
     * @param min
     * @param max
     * @param field
     * @param includeMin
     * @param includeMax
     * @return
     * @Author:lulei
     * @Description: 范围搜索
     */
    public Query getRangeQuery (float min, float max, String field, boolean includeMin, boolean includeMax) {
        return NumericRangeQuery.newFloatRange(field, min, max, includeMin, includeMax);
    }

    /**
     * @param min
     * @param max
     * @param field
     * @param includeMin
     * @param includeMax
     * @return
     * @Author:lulei
     * @Description: 范围搜索
     */
    public Query getRangeQuery (double min, double max, String field, boolean includeMin, boolean includeMax) {
        return NumericRangeQuery.newDoubleRange(field, min, max, includeMin, includeMax);
    }

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

      PackQuery类的构造方法，可以手动指定分词器也可以使用索引的分词器。个人建议，在项目中使用索引中的分词器，这样就不会因为分词器的不同造成不知名的错误。

----------------------------------------------------------------------------------------------------

ps:最近发现其他网站可能会对博客转载，上面并没有源链接，如想查看更多关于 基于lucene的案例开发 请点击这里。或访问网址http://blog.csdn.net/xiaojimanman/article/category/2841877