一、自定义QueryParser

• 1、有些时候我们需要自定义一些QueryParser，一般原因为两个：
  • （1）对于某些QueryParser在查询时会使得性能降低，所以考虑将这些查询取消，比如FuzzyQuery和WildcardQuery。
  • （2）在具体的查询时，很有可能有这样一种需求：需要获取的是一个数字的范围查询。所以必须扩展原有的QueryParser才能进行查询。

说明：就是有些默认的QueryParser查询性能很低，比如上面说到的FuzzyQuery和WildcardQuery，所以我们需要将这样的查询禁用。

• 2、步骤（工程lucene_analyzer05）
  自定义QueryParser
CustomParser.java

package cn.itcast.util;
import java.text.SimpleDateFormat;
import java.util.regex.Pattern;
import jdk.nashorn.internal.runtime.ParserException;
import org.apache.lucene.search.NumericRangeQuery;
import org.apache.lucene.search.Query;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.util.Version;

public class CustomParser extends QueryParser {

    public CustomParser(Version matchVersion, String f, Analyzer a) {
        super(matchVersion, f, a);
    }

    @Override
    protected Query getWildcardQuery(String field, String termStr)
            throws ParseException {
        throw new ParserException("由于性能原因，这种通配符查询已经被禁用");
    }

    @Override
    protected Query getFuzzyQuery(String field, String termStr,
            float minSimilarity) throws ParseException {
        throw new ParserException("由于性能原因，这种模糊查询已经被禁用");
    }
}

说明：这里当进行模糊查询和通配符查询时我们让其抛出异常。

CustomParserUtil.java

package cn.itcast.util;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.util.Version;

public class CustomParserUtil {
    public void searchByQuery(String value){
        try {
            IndexSearcher searcher = new IndexSearcher(IndexReader.open(FileIndexUtil.getDirectory()));
            TopDocs tds = null;
            
            CustomParser parser = new CustomParser(Version.LUCENE_35, "content", new StandardAnalyzer(Version.LUCENE_35));
            Query query = parser.parse(value);
            
            tds = searcher.search(query, 50);
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            for (ScoreDoc sd : tds.scoreDocs) {
                Document doc = searcher.doc(sd.doc);
                System.out.println("id:" + sd.doc + "，评分：" + sd.score + "，名称："
                        + doc.get("filename") + "，路径：" + doc.get("path")
                        + "，文件大小：" + doc.get("size") + "，日期："
                        + sdf.format(new Date(Long.valueOf(doc.get("date")))));
            }
            searcher.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            System.err.println(e.getMessage());
        }
    }
}

说明：这是一个工具类，接收一个查询的字符串，然后我们在其中进行查询。

测试：
TestCustomParser.java

@Test
public void test01(){
    CustomParserUtil cp = new CustomParserUtil();
    //cp.searchByQuery("ja?va");
    cp.searchByQuery("java~");
}

说明：这里的两个测试都会抛出异常。

二、扩展基于数字和日期的查询

同样我们也是在自定义QueryParser中进行定义：

@Override
protected Query getRangeQuery(String field,
        String part1, String part2, boolean inclusive) throws ParseException {
    if(field.equals("size")){
        return NumericRangeQuery.newIntRange(field, Integer.parseInt(part1), Integer.parseInt(part2), inclusive, inclusive);
    }else if(field.equals("date")){
        String dateType = "yyyy-MM-dd";
        Pattern pattern = Pattern.compile("\\d{4}-\\d{2}-\\d{2}");
        if(pattern.matcher(part1).matches() && pattern.matcher(part2).matches()){
            SimpleDateFormat sdf = new SimpleDateFormat(dateType);
            try {
                long start = sdf.parse(part1).getTime();
                long end = sdf.parse(part2).getTime();
                return NumericRangeQuery.newLongRange(field, start, end, inclusive, inclusive);
            } catch (java.text.ParseException e) {
                e.printStackTrace();
            }
        }else{
            throw new ParseException("要检索的日期格式不正确，请使用" + dateType + "这种格式");
        }
    }
    return super.newRangeQuery(field, part1, part2, inclusive);
}

说明：这里我们判断传递进来的参数是不是符合我们要求的格式，如果不是则抛出异常，否则让其进行查询。

测试：

@Test
public void test02(){
    CustomParserUtil cp = new CustomParserUtil();
    //cp.searchByQuery("size:[30 TO 800]");
    //cp.searchByQuery("content:[a TO j]");
    cp.searchByQuery("date:[2006-12-04 TO 2016-12-04]");
}