[ lucene扩展 ] 自定义Collector实现统计功能

对于lucene的统计,我基本放弃使用factedSearch了,效率不高,而且两套索引总觉得有点臃肿!

这次我们通过改造Collector,实现简单的统计功能。经过测试,对几十万的统计还是比较快的。

 

首先我们简单理解下Collector在search中的使用情况!

Collector是一个接口,主要包括以下重要方法:

public abstract class Collector {
  
//指定打分器
  public abstract void setScorer(Scorer scorer) throws IOException;
  
//对目标结果进行收集,很重要!
  public abstract void collect(int doc) throws IOException;

//一个索引可能会有多个子索引,这里相当于是对子索引的遍历操作
  public abstract void setNextReader(IndexReader reader, int docBase) throws IOException;

//
  public abstract boolean acceptsDocsOutOfOrder();
  
}

在search中我们来看看collector是怎么收集结果的!

public void search(Weight weight, Filter filter, Collector collector)
			throws IOException {

		// TODO: should we make this
		// threaded...? the Collector could be sync'd?

		// always use single thread:
		for (int i = 0; i < subReaders.length; i++) { // 检索每个子索引
			collector.setNextReader(subReaders[i], docBase + docStarts[i]);
			final Scorer scorer = (filter == null) ? weight.scorer(
					subReaders[i], !collector.acceptsDocsOutOfOrder(), true)
					: FilteredQuery.getFilteredScorer(subReaders[i],
							getSimilarity(), weight, weight, filter);//构建打分器
			if (scorer != null) {
				scorer.score(collector);//打分
			}
		}
	}

scorer.score(collector)的过程如下:

public void score(Collector collector) throws IOException {
    collector.setScorer(this);
    int doc;
    while ((doc = nextDoc()) != NO_MORE_DOCS) {
      collector.collect(doc);//搜集结果
    }
  }

collector.collect(doc)的过程如下:

    @Override
    public void collect(int doc) throws IOException {
      float score = scorer.score();

      // This collector cannot handle these scores:
      assert score != Float.NEGATIVE_INFINITY;
      assert !Float.isNaN(score);

      totalHits++;
      if (score <= pqTop.score) {
        // 以下的实现使用了优先级队列,如果当前分值小于队列中pqTop.score则直接pass!
        return;
      }
      pqTop.doc = doc + docBase;
      pqTop.score = score;
      pqTop = pq.updateTop();
    }

从上面这一坨坨代码我们可以大概看清collector在search中的应用情况。

那么统计呢?

首先我们来分析最简单的统计——“一维统计”,就只对一个字段的统计。例如统计图书每年的出版量、专利发明人发明专利数量的排行榜等。

统计的输入:检索式、统计字段

统计的输出:<统计项、数量>的集合

其中关键是我们怎么拿到统计项。这个又分成以下一种情况:

1)统计字段没有存储、不分词

我们可以使用FieldCache.DEFAULT.getStrings(reader, f);获取统计项。

2)统计字段没有存储、分词

需要通过唯一标识从数据库(如果正向信息存在数据库的话)取出统计项(字段内容),然后统计分析。可想而知效率极低。

3)统计字段存储、分词

可以通过doc.get(fieldName)取出统计项,依然比较低效

4)统计字段存储、不分词

和1)类似

因此我们如果要对某个字段进行统计,那么最好选用不分词(Index.NOT_ANALYZED),这个和排序字段的要求类似!

拿到统计项后,我们可以通过累加然后排序。(这里可以借助map)

 

下面给出主要代码:

package com.fox.group;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.lucene.index.IndexReader;
import org.apache.lucene.search.Collector;
import org.apache.lucene.search.FieldCache;
import org.apache.lucene.search.Scorer;

/**
 * @author huangfox
 * @data 2012-7-10
 * @email huangfox009@126.com
 * @desc 
 */
public class GroupCollectorDemo extends Collector {

	private GF gf = new GF();// 保存分组统计结果
	private String[] fc;// fieldCache
	private String f;// 统计字段
	String spliter;
	int length;

	public void setFc(String[] fc) {
		this.fc = fc;
	}

	@Override
	public void setScorer(Scorer scorer) throws IOException {
	}

	@Override
	public void setNextReader(IndexReader reader, int docBase)
			throws IOException {
		fc = FieldCache.DEFAULT.getStrings(reader, f);
	}

	@Override
	public void collect(int doc) throws IOException {
		// 添加的GroupField中,由GroupField负责统计每个不同值的数目
		gf.addValue(fc[doc]);
	}

	@Override
	public boolean acceptsDocsOutOfOrder() {
		return true;
	}

	public GF getGroupField() {
		return gf;
	}

	public void setSpliter(String spliter) {
		this.spliter = spliter;
	}

	public void setLength(int length) {
		this.length = length;
	}

	public void setF(String f) {
		this.f = f;
	}
}

class GF {
	// 所有可能的分组字段值,排序按每个字段值的文档个数大小排序
	private List<String> values = new ArrayList<String>();
	// 保存字段值和文档个数的对应关系
	private Map<String, Integer> countMap = new HashMap<String, Integer>();

	public Map<String, Integer> getCountMap() {
		return countMap;
	}

	public void setCountMap(Map<String, Integer> countMap) {
		this.countMap = countMap;
	}

	public List<String> getValues() {
		Collections.sort(values, new ValueComparator());
		return values;
	}

	public void setValues(List<String> values) {
		this.values = values;
	}

	public void addValue(String value) {
		if (value == null || "".equals(value))
			return;
		if (countMap.get(value) == null) {
			countMap.put(value, 1);
			values.add(value);
		} else {
			countMap.put(value, countMap.get(value) + 1);
		}
	}

	class ValueComparator implements Comparator<String> {
		public int compare(String value0, String value1) {
			if (countMap.get(value0) > countMap.get(value1)) {
				return -1;
			} else if (countMap.get(value0) < countMap.get(value1)) {
				return 1;
			}
			return 0;
		}
	}
}

这里是对collector的collect方法的讨巧应用,search是对打分的排序,统计是构造一个结果收集器,提供排序功能。

测试类:

package com.fox.group;

import java.io.File;
import java.io.IOException;
import java.util.List;

import org.apache.lucene.index.IndexReader;
import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.store.SimpleFSDirectory;
import org.apache.lucene.util.Version;
import org.wltea.analyzer.lucene.IKAnalyzer;

/**
 * @author huangfox
 * @data 2012-7-10
 * @email huangfox009@126.com
 * @desc 
 */
public class GroupTest {
	public static void main(String[] f) throws IOException, ParseException {
		FSDirectory dir = SimpleFSDirectory.open(new File("d:/nrttest"));
		IndexReader reader = IndexReader.open(dir);
		IndexSearcher searcher = new IndexSearcher(reader);
		// GroupCollector是自定义文档收集器,用于实现分组统计
		String str = "";
		QueryParser parser = new QueryParser(Version.LUCENE_36, "f",
				new IKAnalyzer());
		while (true) {
			str = "an:cn*";
			long bt = System.currentTimeMillis();
			Query query = parser.parse(str);
			System.out.println(query);
			GroupCollectorDemo myCollector = new GroupCollectorDemo();
			// myCollector.setFc(ad);
			myCollector.setF("in");
			searcher.search(query, myCollector);
			// GroupField用来保存分组统计的结果
			GF gf = myCollector.getGroupField();
			List<String> values = gf.getValues();
			long et = System.currentTimeMillis();
			System.out.println((et - bt) + "ms");
			for (int i = 0; i < 10; i++) {
				String value = values.get(i);
				System.out.println(value + "=" + gf.getCountMap().get(value));
			}
		}
	}
}

以上是对200多万数据的统计,而且是全数据统计。测试结果如下:

an:cn*
6616ms
毛裕民;谢毅=13728
邱则有=10126
杨孟君=3771
王尔中=1712
王信锁=1658
张逶=1314
朱炜=1200
赵蕴岚;何唯平=1039
杨贻方=872
黄金富=871

系统使用情况:

你可能会说——这不是坑爹吗?要6s的时间消耗!!!

解释:

1.数据量,统计的数据量在200万;

如果数据量在几十万,测试结果如下:

ad:2006*
213ms
邱则有=1244
张云波=628
赵蕴岚;何唯平=398
余内逊;余谦梁=376
杨贻方=298
王尔中=258
汪铁良=224
赵发=222
黄振华=212
陆舟;于华章=196

  

2.运行在pc机上;

以上解释也可以理解成借口,那么还有哪些环节可以优化呢?

从cpu和io来看,cpu应该主要是由于hashMap的操作引起的,io主要是由FieldCache.DEFAULT.getStrings(reader, f)获取统计项引起的。

如果高并发的情况下,io无疑是个大问题,我们可以考虑缓存。

对于运算量大的情况,我们可以考虑分布式。

 

后续我们将分析:

1)二维统计、多维统计

2)个性化统计

 

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值