搜索框架的搭建（适用大部分框架）

 

                                                              搜索框架的搭建（适用大部分框架）

1.      UML图

说明：首先这个框架是针对接口编程的，我们先定义一个serverFactory让它可以创建所有实现接口的fulltextservice的类。其中fullTextServiceImpl实现了fulltextservice接口的所有空方法，它的存在是为了让子类实现空方法并对外提供多态（工厂生产成fullTextServiceImpl的类，并调用fullTextServiceImpl子类方法）。毫无疑问地，LunceneService和solrService是最终子类封装了通用的index和query方法，他们可以通过fulltextindexParam和fullTextSearchParam获取需要的参数。

 

其中贴出solrService的示例代码：

 

importjava.io.IOException;
importjava.util.ArrayList;
importjava.util.HashMap;
importjava.util.Iterator;
importjava.util.List;
importjava.util.Map;
importjava.util.Set;
 
importorg.apache.solr.client.solrj.SolrQuery;
importorg.apache.solr.client.solrj.SolrServer;
importorg.apache.solr.client.solrj.SolrServerException;
importorg.apache.solr.client.solrj.SolrQuery.ORDER;
importorg.apache.solr.client.solrj.impl.HttpSolrServer;
importorg.apache.solr.client.solrj.response.FacetField;
importorg.apache.solr.client.solrj.response.QueryResponse;
importorg.apache.solr.common.SolrDocument;
importorg.apache.solr.common.SolrDocumentList;
importorg.apache.solr.common.SolrInputDocument;
 
importcom.example.config.ConstantParams;
importcom.example.retrieve.api.FullTextIndexParams;
importcom.example.retrieve.api.FullTextResult;
importcom.example.retrieve.api.FullTextSearchParams;
importcom.myretrieve.util.StringsUtil;
 
//SolrServer 是solr包原有的，而我们的类名是SolrService
publicclass SolrService  extendsFullTextServiceImpl{
private String serverName="";
public Map<String, SolrServer>solrServerMap = new HashMap<String, SolrServer>();
//-------beginservice-------------
@Override
public int beginService(String serverName) {
           SolrServer solrServer  = solrServerMap.get(serverName);
           if(solrServer == null){
                    solrServer = beginServer();
                    solrServerMap.put(serverName,solrServer);
                    return 1;
           }
           return -1;
}
@Override
public int beginService(String serverName,String url) {
           SolrServer solrServer  = solrServerMap.get(serverName);
           if(solrServer == null){
                    solrServer =beginServer(url);
                    solrServerMap.put(serverName,solrServer);
                    return 1;
           }
           return -1;
}
 
private  SolrServer beginServer() {
           SolrServer solrServer;
           String url =StringsUtil.getConfParams(ConstantParams.SOLR_URL, ConstantParams.CONF_PATH,"");
           solrServer = new HttpSolrServer(url);
           return solrServer;
}
private SolrServer beginServer(String url){
           SolrServer solrServer = newHttpSolrServer(url);
           return solrServer;
}
 
@Override
public int beginService(String serverName,String flag, String indexPath) {
           // TODO Auto-generated method stub
           return super.beginService(serverName,flag, indexPath);
}
//-------endService-------
@Override
public int endService(String serverName) {
           // TODO Auto-generated method stub
           return super.endService(serverName);
}
 
@Override
public void doIndex(FullTextIndexParamsfullTextIndexParams) {
           long preStart =System.currentTimeMillis();
           preIndexMethod();
           long preEnd =System.currentTimeMillis();
           System.out.println("YourpreIndex spent on "+(preEnd-preStart)+" ms.");
          
           List<Map<String, Object>>indexData = fullTextIndexParams.getIndexData();
           try {
                    if(indexData != null ||indexData.size() > 0){
                             List<SolrInputDocument>docs = new ArrayList<SolrInputDocument>();
                             for(Map<String,Object> map : indexData){
                                       SolrInputDocumentdoc = new SolrInputDocument();
                                       Set<String>keys =  map.keySet();
                                       Iterator<String>iterator = keys.iterator();
                                       while(iterator.hasNext()){
                                                Stringkey = iterator.next();
                                                Objecto = map.get(key);
                                                doc.addField(key,o);
                                       }
                                       docs.add(doc);
                             }
                             this.solrServerMap.get(this.serverName).add(docs);
                             this.solrServerMap.get(this.serverName).commit();
                    }else{
                             return;
                    }
           } catch (Exception e) {
                    e.printStackTrace();
           }
           long afterStart =System.currentTimeMillis();
           afterIndexMethod();
           long afterEnd = System.currentTimeMillis();
           System.out.println("YourafterIndex spent on "+(afterEnd-afterStart)+" ms again.");
}
 
@Override
public void preIndexMethod() {
           // TODO Auto-generated method stub
           super.preIndexMethod();
}
 
@Override
public void afterIndexMethod() {
           // TODO Auto-generated method stub
           super.afterIndexMethod();
}
 
@Override
public void updateIndex(FullTextIndexParamsfullTextIndexParams) {
           // TODO Auto-generated method stub
           super.updateIndex(fullTextIndexParams);
}
 
@Override
public void preUpdateIndexMethod() {
           // TODO Auto-generated method stub
           super.preUpdateIndexMethod();
}
 
@Override
public void afterUpdateIndexMethod() {
           // TODO Auto-generated method stub
           super.afterUpdateIndexMethod();
}
 
@Override
public void deleteIndex(FullTextIndexParamsfullTextIndexParams) {
           // TODO Auto-generated method stub
           super.deleteIndex(fullTextIndexParams);
}
 
@Override
public void preDeleteIndexMethod() {
           // TODO Auto-generated method stub
           super.preDeleteIndexMethod();
}
 
@Override
public void afterDeleteIndexMethod() {
           // TODO Auto-generated method stub
           super.afterDeleteIndexMethod();
}
 
@Override
public FullTextResultdoQuery(FullTextSearchParams fullTextSearchParams) {
           FullTextResult result = new SolrResult();
           try {
                    String queryWord =fullTextSearchParams.getQueryWord();
                    if(StringsUtil.isEmpty(queryWord)){
                             return null;
                    }
                    List<String>assignmentFields = fullTextSearchParams.getAssignmentFields();
                    List<Map<String,String>>assignFields = fullTextSearchParams.getAssignFields();
                    String queryString ="";
                    if(assignmentFields != null&& assignmentFields.size()>0){
                             for(StringassignmentField : assignmentFields){
                                       queryString+= assignmentField+":"+queryWord+" OR ";
                             }
                             int pos =queryString.lastIndexOf(" OR ");
                             queryString =queryString.substring(0, pos);
                    }else if(assignFields !=null && assignFields.size()>0){
                             String lastValue ="";
                             for(Map<String,String>assignField : assignFields){
                                       Set<String>set = assignField.keySet();
                                       Iterator<String>iter = set.iterator();
                                       while(iter.hasNext()){
                                                Stringkey = iter.next();
                                                Stringvalue = assignField.get(key);
                                                queryString+= key+":"+queryWord + ConstantParams.SINGLE_BLANK + value + ConstantParams.SINGLE_BLANK;
                                                lastValue= value;
                                       }
                             }
                             int pos =queryString.lastIndexOf(" "+lastValue+" ");
                             queryString =queryString.substring(0, pos);
                    }else{
                             queryString =queryWord;
                    }
                   
                    System.out.println("queryString:"+queryString);
                    SolrQuery params = newSolrQuery(queryString);
                   
                    //设置显示域
                    String[] viewFields =fullTextSearchParams.getViewFields();
                    params.setFields(viewFields);
                   
                    //高亮参数
                    boolean isHighlight =fullTextSearchParams.getIsHighlight();
                    String[] highlightFields =fullTextSearchParams.getHighlightFields();
                    if(isHighlight &&highlightFields != null && highlightFields.length > 0){
                             params.setHighlight(true);
                             for(int i=0;i<highlightFields.length;i++){
                                       params.addHighlightField(highlightFields[i]);
                             }
                            
                             params.setHighlightSimplePre(fullTextSearchParams.getPreHighlight());
                             params.setHighlightSimplePost(fullTextSearchParams.getPostHighlight());
                             params.setHighlightFragsize(fullTextSearchParams.getViewNums());
                    }
                   
                    //排序域 String:需要排序的域名，Boolean：true 升序 false 降序
                    Map<String,Boolean>sortField = fullTextSearchParams.getSortField();
                    if(sortField != null){
                             Set<String>set = sortField.keySet();
                             Iterator<String>iter = set.iterator();
                             while(iter.hasNext()){
                                       Stringkey = iter.next();
                                       Booleanvalue = sortField.get(key);
                                       if(value){
                                                params.addSort(key,ORDER.asc);
                                       }else{
                                                params.addSort(key,ORDER.desc);
                                       }
                                      
                             }
                    }
                   
                    //过滤域
                    Map<String,String>filterField = fullTextSearchParams.getFilterField();
                    if(filterField != null&& filterField.size() > 0){
                             StringBuilder str =new StringBuilder();
                             Set<String>set = filterField.keySet();
                             Iterator<String>iter = set.iterator();
                             while(iter.hasNext()){
                                       Stringkey = iter.next();
                                       Stringvalue = filterField.get(key);
                                       str.append(key+":"+value);
                                       str.append("-beifeng-");
                             }
                             String[]fieldFields = str.toString().split("-beifeng-");
                             params.addFilterQuery(fieldFields);
                    }
                   
                    //开始行
                    params.setStart(fullTextSearchParams.getStartNums());
                    //一页显示多少行
                    params.setRows(fullTextSearchParams.getPageCount());
                   
                    //统计域
                    boolean isFacet =fullTextSearchParams.getIsFacet();
                    String[] facetFields =fullTextSearchParams.getFacetFields();
                    if(isFacet &&facetFields != null && facetFields.length>0){
                             params.addFacetField(facetFields);
                    }
                   
                    QueryResponse response =this.solrServerMap.get(this.serverName).query(params);
                    SolrDocumentList list =response.getResults();
                    result.setNumFound(list.getNumFound());
                   
                    SolrDocument document = newSolrDocument();
                    SolrDocumentList hlList =new SolrDocumentList();
                   
                    //高亮结果
                    if(isHighlight &&highlightFields != null && highlightFields.length > 0){
                             Map<String,Map<String,List<String>>>map = response.getHighlighting();
                             for(inti=0;i<list.size();i++){
                                       for(intj=0;j<highlightFields.length;j++){
                                                document= list.get(i);
                                                if(map!= null && map.get(document.getFieldValue("id")) != null&&map.get(document.getFieldValue("id")).get(highlightFields[j]) !=null){
                                                         document.setField(highlightFields[j],map.get(document.getFieldValue("id")).get(highlightFields[j]).get(0));
                                                }else{
                                                         document.setField(highlightFields[j],document.getFieldValue(highlightFields[j]));
                                                }
                                       }
                                       hlList.add(document);
                             }
                             result.setResultList(hlList);
                    }else{
                             result.setResultList(list);
                    }
                   
                    //统计结果
                    if(isFacet &&facetFields != null && facetFields.length>0){
                             List<FacetField>listField = response.getFacetFields();
                             result.setFacetList(listField);
                    }
                   
           } catch (Exception e) {
                    e.printStackTrace();
           }
           return result;
}
 
@Override
public int hashCode() {
           // TODO Auto-generated method stub
           return super.hashCode();
}
 
@Override
public boolean equals(Object obj) {
           // TODO Auto-generated method stub
           return super.equals(obj);
}
 
@Override
protected Object clone() throwsCloneNotSupportedException {
           // TODO Auto-generated method stub
           return super.clone();
}
 
@Override
public String toString() {
           // TODO Auto-generated method stub
           return super.toString();
}
 
@Override
protected void finalize() throws Throwable {
           // TODO Auto-generated method stub
           super.finalize();
}
//--------------------------bean---------------------------
 
public String getServerName() {
           return serverName;
}
@Override
public void setServerName(String serverName) {
           this.serverName = serverName;
}
}