Solr Request Handler, component, Filter

http://blog.csdn.net/pelick/article/details/8502437

如何定制solr实现自己的搜索服务。

solr是一个可扩展的服务，我们可以添加自己的包和类，在solr已经实现的default处理逻辑之上，再添加我们自己的搜索逻辑。实现手段就是继承solr的基础类，重写或者改写新的Filter，Search Component以及Request Handler类，来取代solr默认的处理类或者与之并存。我也是读了源码，参考了默认类的实现过程，才找到了定制的方法，下面一一说明。

Request Handler

solrconfig.xml里，对/select设置的默认处理类是solr.SearchHandler

[html] view plaincopy

1. <requestHandler name="/select" class="solr.SearchHandler">  
2.    <lst name="defaults">  
3.      <str name="echoParams">explicit</str>  
4.      <int name="rows">10</int>  
5.      <str name="df">usergoods_mix</str>  
6.    </lst>  
7. </requestHandler>  

源码中，SearchHandler类在org.apache.solr.handler.component包下，继承了RequestHandlerBase类，他最主要的逻辑在handleRequestBody函数中，

[java] view plaincopy

1. @Override  
2. public void handleRequestBody(SolrQueryRequest req, SolrQueryResponse rsp) throws Exception, ParseException, InstantiationException, IllegalAccessException  
3. {}  

SearchHandler还有一个主要的成员变量

[java] view plaincopy

1. protected List<SearchComponent> components = null;  

SearchHandler主要职责是借助solrconfig.xml配置文件里设置的默认或者新增的requestHandler参数以及search component类，构建一个ResponseBuilder

[java] view plaincopy

1. ResponseBuilder rb = new ResponseBuilder(req, rsp, components);  

根据配置把各个search component该做的事都分配好，search component是真正读取处理SolrQueryRequest内的查询参数，往SolrQueryResponse里填写数据的地方。下面会再介绍search component的两个prepare()和process()函数。

定制Request Handler

默认的request handler直接得到你http里url带来的传参，然后就开始根据配置分发任务，让各自的component去处理查询请求了。定制request handler的好处是，在这个步骤之中，你可以再额外进行一些别的逻辑处理，比如你可以写写log，在得到SolrQueryRequest后，传入前查看处理一下里面的query，对SolrQueryResponse里得到的数据集再做些处理等等。定制方式是自己继承StandardRequestHandler类(该类继承了SearchHandler)，

[java] view plaincopy

1. package myplugin.handler;  
2.   
3. import org.apache.solr.handler.StandardRequestHandler;  
4. import org.apache.solr.request.SolrQueryRequest;  
5. import org.apache.solr.response.SolrQueryResponse;  
6.   
7. public class MySearchHandler extends StandardRequestHandler {  
8.     public void handleRequestBody(SolrQueryRequest request,  
9.             SolrQueryResponse response) throws Exception {  
10.         super.handleRequestBody(request, response);  
11.         //TODO: whatever you want  
12.     }  
13. }  

并在solrconfig.xml里配置即可起效。

[html] view plaincopy

1. <requestHandler name="/test" class="myplugin.handler.MySearchHandler">  
2.   <lst name="defaults">  
3.     <str name="echoParams">explicit</str>  
4.     <int name="rows">10</int>  
5.     <str name="df">usergoods_mix</str>  
6.   </lst>  
7. </requestHandler>  

别忘了把自己的jar包放到webapp/的WEB-INF的lib目录下。solr也为我们定制了别的handler，比如DisMaxRequestHandler，LukeRequestHandler，MoreLikeThisHandler

和SpellCheckerRequestHandler等等。大家可以自己看看源码，知道他们分别做什么。都在org.apache.solr.handler内。

Search Component

search component的意义远比handler重要的多。solr已经在solrconfig.xml给我们定制了几个默认的component

[html] view plaincopy

1. <searchComponent name="query"     class="solr.QueryComponent" />  
2. <searchComponent name="facet"     class="solr.FacetComponent" />  
3. <searchComponent name="mlt"       class="solr.MoreLikeThisComponent" />  
4. <searchComponent name="highlight" class="solr.HighlightComponent" />  
5. <searchComponent name="stats"     class="solr.StatsComponent" />  
6. <searchComponent name="debug"     class="solr.DebugComponent" />  

一般处理我们查询请求的一定避免不了第一个query component。阅读源码发现，所有这些类都继承SearchComponent。所以我们定制的时候也要继承SearchComponent。

拿QueryComponent举例子说明search component的重要性，最重要的两个函数是

[java] view plaincopy

1. public class QueryComponent extends SearchComponent  
2. {  
3.   public static final String COMPONENT_NAME = "query";  
4.   public void prepare(ResponseBuilder rb) throws IOException{}  
5.   public void process(ResponseBuilder rb) throws IOException {}  
6.   // ...  
7. }  

下面截取一段prepare里的代码说明QueryComponent是怎么读取SolrQueryRequest(res)里的内容，并最后把结果写进SolrQueryResponse(rsp)的。

[java] view plaincopy

1. public void process(ResponseBuilder rb) throws IOException  
2.   {  
3.     SolrQueryRequest req = rb.req;  
4.     SolrQueryResponse rsp = rb.rsp;  
5.     SolrParams params = req.getParams();  
6.     if (!params.getBool(COMPONENT_NAME, true)) {  
7.       return;  
8.     }  
9.     SolrIndexSearcher searcher = req.getSearcher();  
10.     // ...  

[java] view plaincopy

1. DocListAndSet res = new DocListAndSet();  
2. res.docList = new DocSlice(0, docs, luceneIds, null, docs, 0);  
3. if (rb.isNeedDocSet()) {  
4.   // TODO: create a cache for this!  
5.   List<Query> queries = new ArrayList<Query>();  
6.   queries.add(rb.getQuery());  
7.   List<Query> filters = rb.getFilters();  
8.   if (filters != null) queries.addAll(filters);  
9.   res.docSet = searcher.getDocSet(queries);  
10. }  
11. rb.setResults(res);  
12. rsp.add("response",rb.getResults().docList);  

对同一个request handler，可以按顺序配置多个search component，这些component会在handler类里各自得到自己的任务，把SolrQueryRequest和SolrQueryResponse传承下去，在这个过程中，我们可以加入自己的component，定制我们想要的搜索结果和搜索逻辑

定制search component

我简单把实现代码帖一下，主要还是通过继承基础类，最后配置到solrconfig.xml内。

[java] view plaincopy

1. package myplugin.component;  
2.   
3. import java.io.IOException;  
4.   
5. import org.apache.solr.handler.component.ResponseBuilder;  
6. import org.apache.solr.handler.component.SearchComponent;  
7.   
8.   
9. public class MySearchComponent extends SearchComponent {  
10.     String query = null;  
11.     @Override  
12.     public void prepare(ResponseBuilder rb) throws IOException {  
13.         query = rb.req.getParams().get("q", "");   
14.         System.out.println("prepare: " + query);  
15.     }  
16.   
17.     @Override  
18.     public void process(ResponseBuilder rb) throws IOException {  
19.         if (query != null) {          
20.         <span style="white-space:pre">  </span>rb.rsp.add("mytest", "zbf"); // <str name="mytest">zbf</str>  
21.             //SimpleOrderedMap map = (SimpleOrderedMap) builder.rsp.getValues();  
22.             //DocList doclist = (DocList) map.get("response");            
23. //          System.out.println("process: " + map.get("response").toString());  
24. //          System.out.println("process: " + map.get("mytest").toString());  
25.         }  
26.     }  
27.   
28.     @Override  
29.     public String getDescription() {  
30.         return "MySearchComponent";  
31.     }  
32.   
33.     @Override  
34.     public String getSource() {  
35.         return "";  
36.     }  
37.   
38.     @Override  
39.     public String getSourceId() {  
40.         return "";  
41.     }  
42.   
43.     @Override  
44.     public String getVersion() {  
45.         return "0.1";  
46.     }  
47. }  

主要就是在prepare()里获取到SolrQueryRequest里的查询query，在process()里自己处理，并且获取到前一次component处理得到的SolrQueryResponse，里面可能会有已经排好序的查询数据集，你也可以做一些二次处理，简单过滤，重新排序等事情

[html] view plaincopy

1. <requestHandler name="/test" class="myplugin.handler.MySearchHandler">  
2.   <lst name="defaults">  
3.     <str name="echoParams">explicit</str>  
4.     <int name="rows">10</int>  
5.     <str name="df">usergoods_mix</str>  
6.   </lst>  
7.   <arr name="components">  
8.     <str>query</str>  
9.     <str>myComponent</str>  
10.   </arr>  
11. </requestHandler>  
12. <searchComponent name="myComponent" class="myplugin.component.MySearchComponent">  
13. </searchComponent>  

先声明自己的searchComponent，然后放入handler里使用起来，注意配置顺序，因为component是按顺序串接起来的。

定制Filter

最后简单说下Filter，他的作用就是如果你自己定制了Filter，你就可以按自己的方式处理字符串。比如你的查询query里传来的是“field:如何 定制 搜索服务”，如果你直接交给solr的api去做那么"如何"使用的是field字段，但是空格之后的word都会归结到default field里，这是solr包装了lucene的接口之后的结果，可能刚开始在组装自己的查询url的时候会不太适应，所以如果你定制一个自己的filter，就可以解决这样的问题。

定制Filter要继承两个类。其实在配置IKAnalyzer的时候大家可以看到

[html] view plaincopy

1. <fieldType name="text_ik" class="solr.TextField">  
2.     <analyzer type="index">  
3.       <tokenizer class="org.wltea.analyzer.solr.IKTokenizerFactory"  isMaxWordLength="true"/>  
4.       <filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt" enablePositionIncrements="true" />  
5.       <filter class="solr.LowerCaseFilterFactory"/>  
6.     </analyzer>  
7.     <analyzer type="query">  
8.        <!-- 同上 -->  
9.     </analyzer>    
10. </fieldType>  

在tokenizer处使用一个类，在filter处使用一个Factory类。下面我举solr 3.1 cookbook上的例子说明一下。先是自己的filter类，

[java] view plaincopy

1. package pl.solr;  
2. import java.io.IOException;  
3. import org.apache.lucene.analysis.TokenFilter;  
4. import org.apache.lucene.analysis.TokenStream;  
5. import org.apache.lucene.analysis.tokenattributes.TermAttribute;  
6. public class ExampleFilter extends TokenFilter {  
7.     private final TermAttribute termAttr = (TermAttribute)   
8. addAttribute(TermAttribute.class);       
9.     public ExampleFilter(TokenStream stream) {  
10.         super(stream);  
11.     }       
12.     @Override  
13.     public boolean incrementToken() throws IOException {  
14.         if (input.incrementToken()) {  
15.             String term = termAttr.term();  
16.             if (term.length() <= 1) {  
17.                 return true;  
18.             }  
19.             StringBuffer buffer = new StringBuffer();  
20.              buffer.append(term.charAt(1)).append(term.charAt(0)).  
21. append(term.substring(2));               
22.             termAttr.setTermBuffer(buffer.toString());  
23.             termAttr.setTermLength(buffer.length());  
24.             return true;  
25.         }  
26.         return false;  
27.     }  
28. }  

然后是工厂类，

[java] view plaincopy

1. package pl.solr;  
2. import org.apache.lucene.analysis.TokenStream;  
3. import org.apache.solr.analysis.BaseTokenFilterFactory;  
4. public class ExampleFilterFactory extends BaseTokenFilterFactory {  
5.     @Override  
6.     public TokenStream create(TokenStream stream) {  
7.         return new ExampleFilter(stream);  
8.     }  
9. }  

最后是配置文件：

[html] view plaincopy

1. <fieldtype name="exampleType" stored="true" indexed="true"   
2. class="solr.TextField" >  
3.  <analyzer>  
4.   <tokenizer class="solr.WhitespaceTokenizerFactory" />  
5.   <filter class="pl.solr.ExampleFilterFactory" />  
6.  </analyzer>  
7. </fieldtype>  

总结

前几天我也不知道solr的这几个玩法，把solr给小看了。其实solr是一个高可扩展的东西，你要实现自己的搜索服务，就继承solr的基本类，增加自己的扩展类到solr的配置文件里，可以取代solr的默认处理类，也可以和solr的类共同处理。所以以上说的request handler，search component以及filter给我们实现了很好的扩展方式，用起来比较像SOA的架构，像OSGi里的各部分组件。

之后如果对solr有更深的理解或者解读，会再做分享。