搜索引擎-基于solrj客户端的solr增删改查

Solrj已经是很强大的solr客户端了。以完全对象的方式对solr进行交互。很小很好很强大。最基本的功能就是管理Solr索引，包括添加、更新、删除和查询等。

在此之前：先介绍一个异常，以前有朋友问过这个，最近查了下solrj的源码。

2014-10-16 17:52:07,486 ERROR [org.apache.solr.client.solrj.impl.ConcurrentUpdateSolrServer] - <error>

org.apache.solr.common.SolrException: Not Found

或者 org.apache.solr.client.solrj.impl.HttpSolrServer$RemoteSolrException: Expected mime type application/xml but got text/html

这是报错的solrj部分源代码

method = new HttpPost(server.getBaseURL() + "/update"

+ ClientUtils.toQueryString(requestParams, false));--注意这里路径getBaseURL

int statusCode = response.getStatusLine().getStatusCode();

if (statusCode != HttpStatus.SC_OK) {

StringBuilder msg = new StringBuilder();

msg.append(response.getStatusLine().getReasonPhrase()); -----这里NOT FOUND

msg.append("\n\n");

msg.append("\n\n");

msg.append("request: ").append(method.getURI());

handleError(new SolrException(ErrorCode.getErrorCode(statusCode), msg.toString())); --执向这一行异常，并且打印msg，这里打印确实有点坑

} else {

onSuccess(response);

}

通过其端点跟踪 ，不难发现是由于URL拼接而成的路径报错，也就是说服务器的请求路径不对。一般是服务器后面跟踪的core的不对，所导致整个请求路径不对

老习惯：直接代码分析

package com.hhc.searchEngine;

import org.apache.log4j.Logger;
import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.SolrServer;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.response.QueryResponse;
import org.apache.solr.client.solrj.response.UpdateResponse;
import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.SolrDocumentList;
import org.apache.solr.common.SolrInputDocument;
import org.springframework.beans.BeanUtils;
import org.springframework.web.servlet.ModelAndView;

import com.ws.cache.model.FieldInfo;
import com.ws.cache.model.Scheme;
import com.ws.utils.SearchInitException;
import com.ws.utils.StringUtils;
import com.ws.utils.converter.ConverterUtils;

import freemarker.template.TemplateException;

import java.io.IOException;
import java.net.MalformedURLException;
import java.sql.Clob;
import java.util.*;
import java.util.Map.Entry;

import javax.servlet.http.HttpServletRequest;

/**
* 基于solr实现的搜索引擎.
*
* @author huhuichao (huhc3@asiainfo.com)
* @version V1.0
* @createTime 2014-10-13
*/
@SuppressWarnings("unchecked")
public class SearchEngine {

private static final Logger logger = Logger.getLogger(SearchEngine.class);

private String server = "http://localhost:8080/solr";

private SolrServer solrServer = null;

private SolrServer getSolrServer(Scheme scheme) throws SearchInitException {

try {
solrServer = scheme.getConcurrentUpdateSolrServer();
} catch (Exception e) {
e.printStackTrace();
logger.error("null solr server path! !");
throw new SearchInitException(
"null solr server path! !");
}
return solrServer;

}

/**
* 根据数据模型
* 增加维护索引
* @param scheme  --索引方案
* @param list  --数据模型
* @throws Exception
*/
public synchronized void AddSearchIndex(Scheme scheme,List<Map<String, Object>> list)
throws Exception {
SolrServer solrServer = getSolrServer(scheme);
//用来存储数据文档
List<SolrInputDocument> lstDocument=new ArrayList<SolrInputDocument>();

SolrInputDocument document=null;
for(Map<String,Object> map:list){
//map.remove("RN");
//构造数据模型
document=new SolrInputDocument();
/*
* 先数据自定义处理,然后把处理的数据创建相应的索引
*/
for(Entry<String, Object> ety:map.entrySet()){
for(FieldInfo fieldInfo:scheme.getFiledInfos()){
if(ety.getKey().toString().equals(fieldInfo.getFieldcode())){
//取得数据库中字段的值，分析其在数据库中的类型
Object obj=ety.getValue();

//对CLOB字段的处理
if(obj instanceof Clob){
//对这种格式的文本转化成String类型
obj = ConverterUtils.clobToStr((Clob)obj);
}
//防止分词器出现异常。
//对特殊字符处理
if(obj!=null){
obj = obj.toString().trim().replaceAll("\'", "”");
obj = obj.toString().replaceAll("\"", "”");
}

// 保证每个对象的唯一性,而且通过对象的主键可以明确的找到这个对象在solr中的索引
if(scheme.getPkfield().equalsIgnoreCase(fieldInfo.getFieldcode())){
document.addField("primary_key", obj);//主键
document.addField("schecode", scheme.getCode().toLowerCase());//方案code
}else{
document.addField(ety.getKey().toLowerCase(), obj);//ent.getValue()
if(scheme.getInsertsjcfield().equalsIgnoreCase(fieldInfo.getFieldcode())){
document.addField("insertsj", obj);//插入时间戳
}
if(scheme.getUpdatesjcfield().equalsIgnoreCase(fieldInfo.getFieldcode())){
document.addField("updatesj", obj);//更新时间戳
}
}
}
}
}
lstDocument.add(document);
}
solrServer.add(lstDocument);
solrServer.commit();
}

/**
* 删除单个solr文本节点--通过文档id
* @param bean
* @throws Exception
*/
public synchronized void deleteIndex(String id,Scheme scheme) throws Exception {
if (scheme == null) {
logger.warn("Get search bean is empty!");
return;
}
SolrServer server = getSolrServer(scheme);
server.deleteById(id);
server.commit();
}

/**
* 删除多个个solr文本节点--通过文档id集
* @param list--(id的集合)
* @throws Exception
*/
@SuppressWarnings("unchecked")
public synchronized void deleteIndexs(List list,Scheme scheme)
throws Exception {
if (scheme == null) {
logger.warn("Get search bean is empty!");
return;
}
SolrServer server = getSolrServer(scheme);
server.deleteById(list);
server.commit();
}

/**
* solr查询
* @param request
* @return
*/
public ModelAndView solrSearch (HttpServletRequest request){
ModelAndView mav = new ModelAndView("/huhuichao/solr/test.jsp");
Map map = super.getParamValues(request);
//获取拼接好的查询参数
String pueryParams=getQueryParams(map);

map = super.pageXX(map, request);

//创建远程服务--调用方案
SolrServer httpSolrServer = getSolrServer((Scheme)map.get("scheme"));
//设置查询参数
SolrQuery params=new SolrQuery();
params.setParam("q", pueryParams);
//设置查询展示字段-- *,score 的话 查询所有字段。。会很慢。
//params.setParam("fl","c495,c505,c639,c610,c554,c555,c502,score");
//返回结果集。。全文检索从第0页开始   +1
params.setStart((Integer.parseInt(map.get("page").toString())-1)*10);
params.setRows(10);
//设置排序字段
params.setSortField("c610", SolrQuery.ORDER.desc);
//执行查询-返回结果集
try {
QueryResponse reponse = httpSolrServer.query(params);
List list=reponse.getResults();
//组装pager对象
Pager<T> pager=new Pager<T>((int)reponse.getResults().getNumFound(), 10, Integer.parseInt(map.get("page").toString()));
//System.out.println(reponse.getResults());
//				for (SolrDocument result : reponse.getResults()) {
//					System.out.println(result);
//				}
pager.setResults(list);
mav.addObject("pager", pager);
} catch (SolrServerException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//Pager pager = this.wscbajManager.wscbajQuery(map);
mav.addObject("map", map);
return mav;
}

/**
* 通过索引类型删除索引
* @param indexType
* @param scheme
* @throws Exception
*/
public synchronized void deleteIndexsByIndexType(String indexType,Scheme scheme)
throws Exception {
SolrServer server = getSolrServer(scheme);
UpdateResponse ur = server.deleteByQuery("indexType:" + indexType);
server.commit();
}

/**
* 清空索引
* @param scheme
* @throws Exception
*/
public synchronized void deleteAllIndexs(Scheme scheme) throws Exception {
SolrServer server = getSolrServer(scheme);
UpdateResponse ur = server.deleteByQuery("*:*");
server.commit();
}

/**
* 更新索引<br/>
* 在solr中更新索引也就是创建索引(当有相同ID存在的时候,会覆盖上一个索引节点,否则新建)<br/>
* {@link SolrSearchEngine#doIndex(java.util.List)}
*
* @param Schemes
*            需要更新的方案
* @throws Exception
*/
public void updateIndexs(Scheme scheme,List<Map<String, Object>> list) throws Exception {
this.AddSearchIndex(scheme,list);
}

}

通过url获取solr服务器的时候。注意在solr4.0后 CommonsHttpSolrServer 这个类已经被 HttpSolrServer取代了

在solrj中 提出了3种常用的删除操作对外接口

这是从其源码中拷贝出来的删除代码

/**

* Deletes a single document by unique ID

* @param id the ID of the document to delete

* @throws IOException If there is a low-level I/O error.

*/

public UpdateResponse deleteById(String id) throws SolrServerException, IOException {

return deleteById(id, -1);

}

/**

* Deletes a list of documents by unique ID

* @param ids the list of document IDs to delete

* @throws IOException If there is a low-level I/O error.

*/

public UpdateResponse deleteById(List<String> ids) throws SolrServerException, IOException {

return deleteById(ids, -1);

}

/**

* Deletes documents from the index based on a query

* @param query the query expressing what documents to delete

* @throws IOException If there is a low-level I/O error.

*/

public UpdateResponse deleteByQuery(String query) throws SolrServerException, IOException {

return deleteByQuery(query, -1);

}

//从这段代码 可以看出，就是循环删除单个文本节点操作

public UpdateRequest deleteById(List<String> ids) {

if (deleteById == null) {

deleteById = new LinkedHashMap<>();

}

for (String id : ids) {

deleteById.put(id, null);

}

return this;

}

}