用Lucene实现分组，facet功能，FieldCache

假如你像用lucene来作分组，比如按类别分组，这种功能，好了你压力大了，lucene本身是不支持分组的。

当你想要这个功能的时候，就可能会用到基于lucene的搜索引擎solr。

不过也可以通过编码通过FieldCache和单字段，对索引进行分组，比如：想构造类别树。大类里面还有小类那种。

这个功能实现起来可能会比较麻烦，主要是lucene提供的支持也不多，参考资料也不多。

（以下代码都是我在做测试的时候做的，可以稍作修改满足相应需求。）

//用于分组统计的对象GroupCollector

import java.io.IOException;

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

public class GroupCollector extends Collector {

private GroupField gf = new GroupField();// 保存分组统计结果
    private int docBase;
    // fieldCache
    private String[] fc;

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

@Override
    public void collect(int doc) throws IOException {
        // 因为doc是每个segment的文档编号，需要加上docBase才是总的文档编号
        final int docId = doc + this.docBase;
        // 添加的GroupField中，由GroupField负责统计每个不同值的数目
        this.gf.addValue(this.fc[docId]);

}

@Override
    public void setNextReader(IndexReader arg0, int arg1) throws IOException {
        this.docBase = this.docBase;

}

@Override
    public void setScorer(Scorer arg0) throws IOException {

}

public GroupField getGf() {
        return this.gf;
    }

public void setGf(GroupField gf) {
        this.gf = gf;
    }

public int getDocBase() {
        return this.docBase;
    }

public void setDocBase(int docBase) {
        this.docBase = docBase;
    }

public String[] getFc() {
        return this.fc;
    }

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

}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 用于保存分组统计后每个字段的分组结果
 */
public class GroupField {

/**
     * 字段名
     */
    private String name;
    /**
     * 商品类型的对象列表
     */
    private List<SimpleCategory> values = new ArrayList<SimpleCategory>();
    /**
     * 保存字段值和文档个数的对应关系
     */
    private Map<String, Integer> countMap = new HashMap<String, Integer>();

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

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

public String getName() {
        return this.name;
    }

public void setName(String name) {
        this.name = name;
    }

public List<SimpleCategory> getValues() {
        return this.values;
    }

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

/**
     * 用于商品对象list的构造
     * 
     * @param value
     */
    public void addValue(String value) {
        if ((value == null) || "".equals(value)) return;
        // 对于多值的字段，支持按空格拆分
        final String[] temp = value.split(",");

if (this.countMap.get(temp[1]) == null) {
            this.countMap.put(temp[1], 1);
            // 构造商品类型临时对象
            final SimpleCategory simpleCategory = new SimpleCategory();

simpleCategory.setCategoryId(Integer.parseInt(temp[0]));
            simpleCategory.setCategoryName(temp[1]);
            simpleCategory.setParentId(Integer.parseInt(temp[2]));
            simpleCategory.setSortIndex(temp[3]);
            simpleCategory.setParentCategoryName(temp[4]);
            // simpleCategory.setAdImag(temp[5]);
            // simpleCategory.setParentAdImage(temp[6]);
            this.values.add(simpleCategory);
        }
        else {
            this.countMap.put(temp[1], this.countMap.get(temp[1]) + 1);
        }
        // for( String str : temp ){
        // if(countMap.get(str)==null){
        // countMap.put(str,1);
        // values.add(str);
        // }
        // else{
        // countMap.put(str, countMap.get(str)+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;
    // // }
    // }
}

自己构建想返回的对象

/**
 * 用于将lucene索引中的商品类型CategoryIndex字段，转换成商品类型的一个对象。
 * 
 * @author xiaozd
 * 
 */
public class SimpleCategory extends BaseModel {

private static final long serialVersionUID = -2345212345526771266L;
    private int parentId;
    private int categoryId;
    private String categoryName;
    private String sortIndex;
    private int goodsCount;
    private String parentCategoryName;

public int getParentId() {
        return this.parentId;
    }

public void setParentId(int parentId) {
        this.parentId = parentId;
    }

public int getCategoryId() {
        return this.categoryId;
    }

public void setCategoryId(int categoryId) {
        this.categoryId = categoryId;
    }

public String getCategoryName() {
        return this.categoryName;
    }

public void setCategoryName(String categoryName) {
        this.categoryName = categoryName;
    }

public String getSortIndex() {
        return this.sortIndex;
    }

public void setSortIndex(String sortIndex) {
        this.sortIndex = sortIndex;
    }

public static long getSerialversionuid() {
        return SimpleCategory.serialVersionUID;
    }

public int getGoodsCount() {
        return this.goodsCount;
    }

public void setGoodsCount(int goodsCount) {
        this.goodsCount = goodsCount;
    }

public String getParentCategoryName() {
        return this.parentCategoryName;
    }

public void setParentCategoryName(String parentCategoryName) {
        this.parentCategoryName = parentCategoryName;
    }

}

/**
     * 查询商品的所有类型，方式：通过索引分组查询所有类型。
     *     @return    Map<String, String> 第一个参数表示商品类型id，第二个String表示商品类型名称
     */
    public List<SimpleCategory> getGoodsCategory() {
        
        List<SimpleCategory> values=new ArrayList<SimpleCategory>();
        try {
            
            IndexReader reader = IndexReader.open(FSDirectory.open(new File(luceneSearchPath)), true); // only searching, so read-only=true

//读取"modified"字段值，放到fieldCache中
            final String[] fc=FieldCache.DEFAULT.getStrings(reader, "categoryIndex");
            IndexSearcher searcher = new IndexSearcher(reader);
            //GroupCollector是自定义文档收集器，用于实现分组统计
            GroupCollector myCollector=new GroupCollector();
            myCollector.setFc(fc);
            searcher.search(new MatchAllDocsQuery(), myCollector);
            //GroupField用来保存分组统计的结果
            GroupField gf=myCollector.getGf();
            values=gf.getValues();
            for (SimpleCategory value : values) {
                System.out.println("商品类型名称：  "+value +"  数量："+gf.getCountMap().get(value.getCategoryName())+"   商品父类型名称: "+value.getParentCategoryName());
            }
            
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        return values;
    }

http://blog.csdn.net/xiaozhengdong/article/details/7035607