[lucene那点事儿]继承RangeFilter编写数字型过滤器

Lucene提供了多种针对于区间的查询的实现方式，诸如RangeQuery和RangeFilter等，通常而言，RangeQuery是最容易联想的方式，使用起来很非常的简单，但是，使用它却很容易出现TooManyClause exception，我在另一篇文章

http://blog.csdn.net/quzishen/archive/2010/08/17/5818068.aspx 已经讲述了出现这个问题的原因。而且，这种方式很容易造成内存溢出，使系统的运行受到严重影响。

所以推荐的，是使用RangeFilter，装配进Query中进行过滤。Lucene提供的RangeFilter的过滤机制是通过对比字符来进行的，比如搜索a - e 之间的字符的方式，这样就很容出现搜索 1 - 5，却能将 200 搜出来的原因。是因为 字符'2' 处于 '1' 和 '5' 之间。

所以如果希望能够正确的过滤数字型的数据，需要我们特殊处理。这里我提出一种方案：

继承RangeFilter编写自己的数字型过滤器，看看源代码：

package com.normandy.position.common; import java.io.IOException; import java.util.BitSet; import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.Term; import org.apache.lucene.index.TermDocs; import org.apache.lucene.index.TermEnum; import org.apache.lucene.search.RangeFilter; /** * 针对于数字类型的过滤器 * <p> * 本Filter提供的是针对于数字型数据过滤的功能，其中主要是重写父类的bits(IndexReader reader)方法来实现。 * </p> * @author 曲子深 * */ public class NumberSearchFilter extends RangeFilter { private static final long serialVersionUID = 9177858730243484404L; private String fieldName; private double lowerTerm; private double upperTerm; private boolean includeLower; private boolean includeUpper; // ~~~ construct public NumberSearchFilter(String fieldName, double lowerTerm, double upperTerm, boolean includeLower, boolean includeUpper) { // father super(fieldName, lowerTerm+"", upperTerm+"", includeLower, includeUpper); this.fieldName = fieldName; this.lowerTerm = lowerTerm; this.upperTerm = upperTerm; this.includeLower = includeLower; this.includeUpper = includeUpper; } @Override public BitSet bits(IndexReader reader) throws IOException { BitSet bits = new BitSet(reader.maxDoc()); TermEnum enumerator = reader.terms(new Term(fieldName, "")); try { if (enumerator.term() == null) { return bits; } TermDocs termDocs = reader.termDocs(); try { do { Term term = enumerator.term(); if (term != null && term.field().equals(fieldName)) { if(!NorStringUtils.checkIsNumberic(term.text())){ continue; } double termDoubel = Double.parseDouble(null == term.text() ? "0" :term.text().toString()); // too small if(/**include*/(includeLower && termDoubel < lowerTerm) || /**not include*/(!includeLower && termDoubel <= lowerTerm)){ continue; } // too large if(/**include*/(includeUpper && termDoubel > upperTerm) || /**not include*/(!includeUpper && termDoubel >= upperTerm)){ continue; } /* we have a good term, find the docs */ termDocs.seek(enumerator.term()); while (termDocs.next()) { bits.set(termDocs.doc()); } } else { break; } } while (enumerator.next()); } finally { termDocs.close(); } } finally { enumerator.close(); } return bits; } @Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof NumberSearchFilter)) return false; NumberSearchFilter other = (NumberSearchFilter) o; if (!this.fieldName.equals(other.fieldName) || this.includeLower != other.includeLower || this.includeUpper != other.includeUpper) { return false; } if (this.lowerTerm != other.lowerTerm) return false; if (this.upperTerm != other.upperTerm) return false; return true; } }

 

这样就实现了数字型数据的过滤。看看如何使用（为了对比，我将另一种采用QueryRange的方式也写入了并注释掉）

先判断当前的数据是否是数字型的，如果非数字型，则使用Lucene的RangeFilter。

/** * 根据区间搜索条件组装BooleanQuery * * @param bq * @param betweensearchkeywordsMap * @param keyWordsList * @param occur * @return */ private Query addFilter2Query(BooleanQuery bq, Map<String, List<String>> betweensearchkeywordsMap, List<String> keyWordsList) { if (null == bq) { bq = new BooleanQuery(); } if(null == betweensearchkeywordsMap || 0 == betweensearchkeywordsMap.size()){ return bq; } // ~~~ return value Query query = bq; // // 默认的条件关系为 AND // occur = null == occur ? BooleanClause.Occur.MUST : occur; for (String betweenKey : betweensearchkeywordsMap.keySet()) { if (keyWordsList.contains(betweenKey)) { List<String> values = betweensearchkeywordsMap.get(betweenKey); // ~~~ check value if (null == values || 0 == values.size()) { continue; } // ~~~ 获取起始值，如果列表中的值为空串，那么取整数的最小值 String beginValue = StringUtils.isBlank(values.get(0)) ? "" + Integer.MIN_VALUE : values.get(0); // Term beginterm = new Term(betweenKey, beginValue); // ~~~ 获取结束值，如果不存在第二个最大值，那么取整数的最大值 String endValue = values.size() >= 2 ? (StringUtils .isBlank(values.get(1)) ? "" + Integer.MAX_VALUE : values.get(1)) : "" + Integer.MAX_VALUE; // Term endterm = new Term(betweenKey, endValue); // ~~~ 加入查询条件 // RangeQuery rq = new RangeQuery(beginterm, endterm, true);// 临界条件也加入 // bq.add(rq, occur);// 与其他条件应该是交集，要注意 RangeFilter rangeFilter; if(NorStringUtils.checkIsNumberic(beginValue) && NorStringUtils.checkIsNumberic(endValue)){ double beginDouble = Double.parseDouble(beginValue); double endDouble = Double.parseDouble(endValue); rangeFilter = new NumberSearchFilter(betweenKey, beginDouble, endDouble, true, true); } else { rangeFilter = new RangeFilter(betweenKey, beginValue, endValue, true, true); } FilteredQuery filteredQuery = new FilteredQuery(query, rangeFilter); query = filteredQuery; } } return query; }