Lucene 之 Facet

标签：

 说到Facet，我还真找不到一个合适的中文词汇来描述它，英文翻译是方面，感觉不够贴切，大家也不必纠结它的中文叫法是啥，你只需要知道使用Facet能解决什么类型的问题就行了，来看几个典型的应用案例：

 

 

        看了上面几张图，大家应该知道Facet是用来干嘛的了，如果非要用语言描述Facet的用途，那Facet的用途就是根据域的域值进行分组统计，注意这 里的域必须是FacetField,你Facet域的域值有几个就会分几组，并统计在Query查询条件下各组的命中结果数量。但通常不需要显示所有分 组，就如图上面3张图，一般都是显示Top N 个分组即可。是不是觉得Facet和Group有点相似，对，看起来是有那么一点相似，那两者到底有什么区别呢？

Html代码  

1. They are two different lucene features:  

2.   

3. Grouping was first released with Lucene 3.2, its related jira issue is LUCENE-1421: it allows to group search results by specified field. For example, if you group by the author field, then all documents with the same value in the author field fall into a single group. You will have a kind of tree as output. If you want to go deeper into using this lucene feature, this blog post should be useful.  

4. Faceting was first released with Lucene 3.4, its related jira issue is LUCENE-3079: this feature doesn‘t group documents, it just tells you how many documents fall in a specific value of a facet. For example, if you have a facet based on the author field, you will receive a list of all your authors, and for each author you will know how many documents belong to that specific author. After, if you want to see those documents, you have to query one more time adding a specific filter (author=whatever). The faceted search is in fact based on browsing documents applying multiple filters to progressively reach the documents you‘re really interested in.  

    对不起，只有英文的说明，大意就是：Grouping分组功能是在跟随Lucene 3.2稳定版首次发布的，它允许你根据一个指定的域进行分组，举个例子，如果你根据一个author域进行分组，那么这个域的所有域值相同的索引文档进行 落入到这个分组中。Facet是在跟随Lucene3.4稳定版首次发布的，facet并不对文档进行分组，Facet只是告诉你某个Facet下每个域 值的命中数量，举个例子，如果你有个facet是基于author域的，那么facet会返回author域下的每个域值，以及每个author域值下的 命中结果总数。如果你想查看每个author域值下的命中结果，那么你可能需要再发起 一次请求，通过添加一个filter如author=xxxx.  其实Facet搜索就是通过应用多个filter来让用户浏览索引文档，使用户逐步找到自己感兴趣的索引文档，一句话：Facet分组统计的目的是通过 统计的数量诱发你点击的欲望，一般你看到数量多的，你会有点击欲望，点击进去了你自己会判断是不是你感兴趣的内容，如果不是，那么你会点击数据量次之的， 如此下去，逐步诱导你找到你感兴趣的内容，这就是Facet功能设计的目的。说白了就是利用羊群效应诱发你去点击。

       首先来你需要创建FacetField域，在创建之前你需要了解FacetField的是否分词，存储，位置信息等。看看FacetField源码一切就知晓了。

    FacetField的域名称都是dummy， 域类型都是默认的DOCS_AND_FREQS_AND_POSITIONS即需要记录Term频率和Document频率(即项向量)和位置信息。而 FieldType对于默认是Stored=false,而tokenized=true(即会进行分词处理转化为多个Term),了解这些很有必要。

       然后FacetField跟普通的Field一样，需要添加到document中，然后document需要通过IndexWriter对象a调用addDocument写入索引，但此时document需要做一个转换过程，即

Java代码  

1. FacetsConfig.build(DirectoryTaxonomyWriter writer,Document document);  

    我们来看看FacetsConfig的build方法背地里都干了些什么？

     首先定义了3个Map分别对应了3种类型的FacetField:FacetField,SortedSetDocValuesFacetField,AssociationFacetField, FacetField就是普通的Facet域，SortedSetDocValuesFacetField就是可以用来排序的DocValuesField域，AssociationFacetField是用来自定义Facets的域，它可以关联任意的byte[]字节数组.把用户添加的域用3个map分开后，分别用了3个函数进行处理，如图：

     processFacetFields内部关键点代码就是：

     pathToString就是把多个域值拼在一起，比如:

Java代码  

1. new FacetField("Author", new String[] { "Bob" ,"Jack","Tom"})  

    那拼一起后就是BobJackTom,然后创建了一个StringField且Store.NO,意思就是我们add一个FacetField其实就是add了一个StringField,当然两者不能完全等同。注意是if里的条件：

ft.multiValued && (ft.hierarchical || ft.requireDimCount)即如果是多值域且(path有多个值或者需要统计facet总数)，如果不是多值域，则会add一个BinaryDocValuesField域：

Java代码  

1. doc.add(new BinaryDocValuesField(indexFieldName, dedupAndEncode(ordinals.get())));  

    然后我们通过IndexSearcher查询的时候需要传入FacetsCollector结果收集器，剩下的套路基本都是固定的，没什么好说的，如下：

Java代码  

1. FacetsCollector fc = new FacetsCollector();  

2.   

3.         searcher.search(new MatchAllDocsQuery(), null, fc);  

4.   

5.         List<FacetResult> results = new ArrayList<FacetResult>();  

6.   

7.         Facets facets = new FastTaxonomyFacetCounts(taxoReader, this.config, fc);  

8.   

9.         results.add(facets.getTopChildren(10, "Author"));  

10.         results.add(facets.getTopChildren(10, "Publish Date"));  

11.   

12.         indexReader.close();  

13.         taxoReader.close();  

     至于DrillDownQuery，他其实就是根据用户传入的path数组用BooleanQuery进行链接的：

 

     先用BooleanQuery把多个TermQuery用Or链接起来，再用ConstantScoreQuery包装下，主要是为了禁用查询权重的。

    至于DrillSideways更不需要被它的外表迷惑了，其实他内部其实还是根据传入的IndexSearch和Facet结果收集器去查询的：

       内部就是为了包装得到一个DrillSidewaysQuery对象，最后还是调用的IndexSearcher的search方法。

       下面是一个Facet使用简单示例：

Java代码  

1. package com.yida.framework.lucene5.facet;  

2.   

3. import java.io.IOException;  

4. import java.util.ArrayList;  

5. import java.util.List;  

6.   

7. import org.apache.lucene.analysis.core.WhitespaceAnalyzer;  

8. import org.apache.lucene.document.Document;  

9. import org.apache.lucene.facet.DrillDownQuery;  

10. import org.apache.lucene.facet.DrillSideways;  

11. import org.apache.lucene.facet.FacetField;  

12. import org.apache.lucene.facet.FacetResult;  

13. import org.apache.lucene.facet.Facets;  

14. import org.apache.lucene.facet.FacetsCollector;  

15. import org.apache.lucene.facet.FacetsConfig;  

16. import org.apache.lucene.facet.taxonomy.FastTaxonomyFacetCounts;  

17. import org.apache.lucene.facet.taxonomy.TaxonomyReader;  

18. import org.apache.lucene.facet.taxonomy.directory.DirectoryTaxonomyReader;  

19. import org.apache.lucene.facet.taxonomy.directory.DirectoryTaxonomyWriter;  

20. import org.apache.lucene.index.DirectoryReader;  

21. import org.apache.lucene.index.IndexWriter;  

22. import org.apache.lucene.index.IndexWriterConfig;  

23. import org.apache.lucene.search.IndexSearcher;  

24. import org.apache.lucene.search.MatchAllDocsQuery;  

25. import org.apache.lucene.store.Directory;  

26. import org.apache.lucene.store.RAMDirectory;  

27.   

28. /** 

29.  * Facet简单示例 

30.  *  

31.  * @author Lanxiaowei 

32.  *  

33.  */  

34. public class SimpleFacetsExample {  

35.     private final Directory indexDir = new RAMDirectory();  

36.     private final Directory taxoDir = new RAMDirectory();  

37.     private final FacetsConfig config = new FacetsConfig();  

38.   

39.     public SimpleFacetsExample() {  

40.         this.config.setHierarchical("Author", true);  

41.         this.config.setHierarchical("Publish Date", true);  

42.     }  

43.   

44.     /** 

45.      * 创建测试索引 

46.      *  

47.      * @throws IOException 

48.      */  

49.     private void index() throws IOException {  

50.         IndexWriter indexWriter = new IndexWriter(this.indexDir,  

51.                 new IndexWriterConfig(new WhitespaceAnalyzer())  

52.                         .setOpenMode(IndexWriterConfig.OpenMode.CREATE));  

53.   

54.         DirectoryTaxonomyWriter taxoWriter = new DirectoryTaxonomyWriter(  

55.                 this.taxoDir);  

56.   

57.         Document doc = new Document();  

58.         doc.add(new FacetField("Author", new String[] { "Bob" }));  

59.         doc.add(new FacetField("Publish Date", new String[] { "2010", "10",  

60.                 "15" }));  

61.         indexWriter.addDocument(this.config.build(taxoWriter, doc));  

62.   

63.         doc = new Document();  

64.         doc.add(new FacetField("Author", new String[] { "Lisa" }));  

65.         doc.add(new FacetField("Publish Date", new String[] { "2010", "10",  

66.                 "20" }));  

67.         indexWriter.addDocument(this.config.build(taxoWriter, doc));  

68.   

69.         doc = new Document();  

70.         doc.add(new FacetField("Author", new String[] { "Lisa" }));  

71.         doc.add(new FacetField("Publish Date",  

72.                 new String[] { "2012", "1", "1" }));  

73.         indexWriter.addDocument(this.config.build(taxoWriter, doc));  

74.   

75.         doc = new Document();  

76.         doc.add(new FacetField("Author", new String[] { "Susan" }));  

77.         doc.add(new FacetField("Publish Date",  

78.                 new String[] { "2012", "1", "7" }));  

79.         indexWriter.addDocument(this.config.build(taxoWriter, doc));  

80.   

81.         doc = new Document();  

82.         doc.add(new FacetField("Author", new String[] { "Frank" }));  

83.         doc.add(new FacetField("Publish Date",  

84.                 new String[] { "1999", "5", "5" }));  

85.         indexWriter.addDocument(this.config.build(taxoWriter, doc));  

86.   

87.         indexWriter.close();  

88.         taxoWriter.close();  

89.     }  

90.   

91.     private List<FacetResult> facetsWithSearch() throws IOException {  

92.         DirectoryReader indexReader = DirectoryReader.open(this.indexDir);  

93.         IndexSearcher searcher = new IndexSearcher(indexReader);  

94.         TaxonomyReader taxoReader = new DirectoryTaxonomyReader(this.taxoDir);  

95.   

96.         FacetsCollector fc = new FacetsCollector();  

97.   

98.         FacetsCollector.search(searcher, new MatchAllDocsQuery(), 10, fc);  

99.   

100.         List<FacetResult> results = new ArrayList<FacetResult>();  

101.   

102.         Facets facets = new FastTaxonomyFacetCounts(taxoReader, this.config, fc);  

103.         results.add(facets.getTopChildren(10, "Author", new String[0]));  

104.         results.add(facets.getTopChildren(10, "Publish Date", new String[0]));  

105.   

106.         indexReader.close();  

107.         taxoReader.close();  

108.   

109.         return results;  

110.     }  

111.   

112.     private List<FacetResult> facetsOnly() throws IOException {  

113.         DirectoryReader indexReader = DirectoryReader.open(this.indexDir);  

114.         IndexSearcher searcher = new IndexSearcher(indexReader);  

115.         TaxonomyReader taxoReader = new DirectoryTaxonomyReader(this.taxoDir);  

116.   

117.         FacetsCollector fc = new FacetsCollector();  

118.   

119.         searcher.search(new MatchAllDocsQuery(), null, fc);  

120.   

121.         List<FacetResult> results = new ArrayList<FacetResult>();  

122.   

123.         Facets facets = new FastTaxonomyFacetCounts(taxoReader, this.config, fc);  

124.   

125.         results.add(facets.getTopChildren(10, "Author"));  

126.         results.add(facets.getTopChildren(10, "Publish Date"));  

127.   

128.         indexReader.close();  

129.         taxoReader.close();  

130.   

131.         return results;  

132.     }  

133.   

134.     private FacetResult drillDown() throws IOException {  

135.         DirectoryReader indexReader = DirectoryReader.open(this.indexDir);  

136.         IndexSearcher searcher = new IndexSearcher(indexReader);  

137.         TaxonomyReader taxoReader = new DirectoryTaxonomyReader(this.taxoDir);  

138.   

139.           

140.         DrillDownQuery q = new DrillDownQuery(this.config);  

141.         q.add("Publish Date", new String[] { "2010" });  

142.           

143.         FacetsCollector fc = new FacetsCollector();  

144.         FacetsCollector.search(searcher, q, 10, fc);  

145.   

146.         Facets facets = new FastTaxonomyFacetCounts(taxoReader, this.config, fc);  

147.         FacetResult result = facets.getTopChildren(10, "Author", new String[0]);  

148.   

149.         indexReader.close();  

150.         taxoReader.close();  

151.   

152.         return result;  

153.     }  

154.   

155.     private List<FacetResult> drillSideways() throws IOException {  

156.         DirectoryReader indexReader = DirectoryReader.open(this.indexDir);  

157.         IndexSearcher searcher = new IndexSearcher(indexReader);  

158.         TaxonomyReader taxoReader = new DirectoryTaxonomyReader(this.taxoDir);  

159.   

160.         DrillDownQuery q = new DrillDownQuery(this.config);  

161.   

162.         q.add("Publish Date", new String[] { "2010" });  

163.   

164.         DrillSideways ds = new DrillSideways(searcher, this.config, taxoReader);  

165.         DrillSideways.DrillSidewaysResult result = ds.search(q, 10);  

166.   

167.         List<FacetResult> facets = result.facets.getAllDims(10);  

168.   

169.         indexReader.close();  

170.         taxoReader.close();  

171.   

172.         return facets;  

173.     }  

174.   

175.     public List<FacetResult> runFacetOnly() throws IOException {  

176.         index();  

177.         return facetsOnly();  

178.     }  

179.   

180.     public List<FacetResult> runSearch() throws IOException {  

181.         index();  

182.         return facetsWithSearch();  

183.     }  

184.   

185.     public FacetResult runDrillDown() throws IOException {  

186.         index();  

187.         return drillDown();  

188.     }  

189.   

190.     public List<FacetResult> runDrillSideways() throws IOException {  

191.         index();  

192.         return drillSideways();  

193.     }  

194.   

195.     public static void main(String[] args) throws Exception {  

196.         // one  

197.         System.out.println("Facet counting example:");  

198.         System.out.println("-----------------------");  

199.         SimpleFacetsExample example = new SimpleFacetsExample();  

200.         List<FacetResult> results1 = example.runFacetOnly();  

201.         System.out.println("Author: " + results1.get(0));  

202.         System.out.println("Publish Date: " + results1.get(1));  

203.           

204.           

205.         // two  

206.         System.out.println("Facet counting example (combined facets and search):");  

207.         System.out.println("-----------------------");  

208.         List<FacetResult> results = example.runSearch();  

209.         System.out.println("Author: " + results.get(0));  

210.         System.out.println("Publish Date: " + results.get(1));  

211.           

212.           

213.         // three  

214.         System.out.println("Facet drill-down example (Publish Date/2010):");  

215.         System.out.println("---------------------------------------------");  

216.         System.out.println("Author: " + example.runDrillDown());  

217.   

218.         // four  

219.         System.out.println("Facet drill-sideways example (Publish Date/2010):");  

220.         System.out.println("---------------------------------------------");  

221.         for (FacetResult result : example.runDrillSideways()) {  

222.             System.out.println(result);  

223.         }  

224.     }  

225. }  

Lucene 之 Facet

标签：

原文地址：http://my.oschina.net/u/2273085/blog/403106