使用Solrj管理Solr索引

最新推荐文章于 2024-02-22 16:07:52 发布
最新推荐文章于 2024-02-22 16:07:52 发布
阅读量1.6w 收藏 7
点赞数 1
分类专栏： Open Source 文章标签： solr string exception object lucene 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shirdrn/article/details/7094551
版权
本文详细介绍了如何使用Solrj客户端与Solr搜索服务器进行交互，包括添加、更新、删除和查询索引等功能。重点阐述了索引的批量处理、自动提交策略、基于MongoDB的文档资源获取以及优化操作。同时提供了测试用例以验证SolrPostServer类的正确性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Solrj是Solr搜索服务器的一个比较基础的客户端工具，可以非常方便地与Solr搜索服务器进行交互，最基本的功能就是管理Solr索引，包括添加、更新、删除和查询等。对于一些比较基础的应用，用Solj基本够用，而且你可以非常容易地通过使用Solrj的API实现与Solr搜索服务器进行交互，实现对Solr的基本管理功能。如果你的应用比较复杂，可以扩展Solrj来满足需要。

下面是一个使用Solrj的API实现与Solr服务器交互的工具类SolrPostServer，能够实现索引的添加、更新、删除和查询功能。SolrPostServer类中两个内部类是与访问MongoDB的配置和工具。

在实际应用中，对于是否进行commit，可以有两种方式：

  • 一种是直接在客户端进行计算，亦即，进行索引时计算添加的文档数，满足设置的值则进行手动commit，这种方式比较灵活，你可以根据搜索服务器的运行状况选择合理的commit文档数量；
  • 另一种是，直接在Solr搜索服务器上进行配置，一般来说，对索引进行大批量更新，一般不会选择在搜索服务器业务繁忙的时候进行，所以能够自动进行commit也便利了对索引的管理，更新文档可以完全可以实现自动化处理。
在Solr服务器端进行配置有关commit的功能，可以在requestHandler中进行配置，示例如下： 
	<requestHandler name="/update" class="solr.XmlUpdateRequestHandler">
		<maxPendingDeletes>10000</maxPendingDeletes>
		<autoCommit>
			<maxDocs>20</maxDocs>
			<maxTime>86000</maxTime>
		</autoCommit>
	</requestHandler>
上面autoCommit中的maxDocs指定的pending多少个文档后执行一次commit，而maxTime指定了多长时间间隔进行一次commit，一般这两个选项只需要配置一个即可满足需要。另外，每次commit会将最近的更新生效，但是如果一次commit操作尚未完成，又达到了下一次commit的时刻，这样做会严重影响索引的吞吐量。
在Solr 4.0将会实现一种基于“软自动提交”（soft auto commit）的功能，它会根据当前的系统上下文决定是否提交（简单的情况就是，确保每次commit完成，也就是最近的索引数据更新已经更新同步到磁盘上之后再自动执行下一次commit）。

实现代码如下所示：

package org.shirdrn.solr.solrj;

import java.io.IOException;
import java.io.Serializable;
import java.net.MalformedURLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.commons.httpclient.HttpClient;
import org.apache.log4j.Logger;
import org.apache.lucene.document.Document;
import org.apache.solr.client.solrj.ResponseParser;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.impl.CommonsHttpSolrServer;
import org.apache.solr.client.solrj.impl.XMLResponseParser;
import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.SolrDocumentList;
import org.apache.solr.common.SolrInputDocument;
import org.apache.solr.common.params.SolrParams;

import com.mongodb.BasicDBObject;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.Mongo;
import com.mongodb.MongoException;

/**
 * Solr server for indexes operations.
 * 
 * @author shirdrn
 * @date   2011-12-20
 */
public class SolrPostServer {

	private static final Logger LOG = Logger.getLogger(SolrPostServer.class);
	private CommonsHttpSolrServer server; 
	private ResponseParser responseParser;
	
	private MongoConfig mongoConfig;
	private String[] collectionNames;
	private  int maxCommitCount = 100;
	private boolean manualOptimize = true;

	private boolean manualCommit = false;
	private Collection<SolrInputDocument> docContainer = new ArrayList<SolrInputDocument>();
	private static int totalCount = 0;
	
	public SolrPostServer(String url, HttpClient httpClient, MongoConfig mongoConfig) {
		try {
			if(httpClient==null) {
				server = new CommonsHttpSolrServer(url);
				server.setSoTimeout(500000);  // socket read timeout
				server.setConnectionTimeout(5000);  
				server.setDefaultMaxConnectionsPerHost(10);  
				server.setMaxTotalConnections(100);
				server.setAllowCompression(true);  
				server.setMaxRetries(1); // defaults to 0.  > 1 not recommended. 
			} else {
				server = new CommonsHttpSolrServer(url, httpClient);
			}
		} catch (MalformedURLException e) {
			e.printStackTrace();
		}
		this.mongoConfig = mongoConfig;
		initialize();
	}

	/**
	 * Initialize the {@link CommonsHttpSolrServer}'s basic parameters.
	 */
	private void initialize() {
		if(responseParser!=null) {
			server.setParser(responseParser);
		} else {
			server.setParser(new XMLResponseParser());
		}
	}
	
	@SuppressWarnings("unchecked")
	public void postUpdate() {
		DBCursor cursor = null;
		try {
			for (String c : collectionNames) {
				LOG.info("MongoDB collection name: " + c);
				DBCollection collection = MongoHelper.newHelper(mongoConfig).getCollection(c);
				DBObject q = new BasicDBObject();
				cursor = collection.find(q);
				while(cursor.hasNext()) {
					try {
						Map<Object, Object> m = cursor.next().toMap();
						if(manualCommit) {
							add(m, true);
						} else {
							add(m, false);
						}
						++totalCount;
						LOG.info("Add fragment: _id = " + m.get("_id").toString());
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
				cursor.close();
			}
			LOG.info("Add totalCount: " + totalCount);
			finallyCommit();
			optimize(manualOptimize);
		} catch (MongoException e) {
			e.printStackTrace();
		} catch (SolrServerException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * Detele lucene {@link Document} by IDs.
	 * @param strings
	 */
	public void deleteById(List<String> strings) {
		try {
			server.deleteById(strings);
		} catch (SolrServerException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * Detele lucene {@link Document} by query.
	 * @param query
	 */
	public void deleteByQuery(String query) {
		try {
			server.deleteByQuery(query);
		} catch (SolrServerException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * Query.
	 * @param params
	 * @param fields
	 * @return
	 */
	public List<Map<String, Object>> query(SolrParams params, String[] fields) {
		List<Map<String, Object>> results = new ArrayList<Map<String, Object>>();
		try {
			SolrDocumentList documents = server.query(params).getResults();
			Iterator<SolrDocument> iter = documents.iterator();
			while(iter.hasNext()) {
				SolrDocument doc = iter.next();
				Map<String, Object> map = new HashMap<String, Object>();
				for(String field : fields) {
					map.put(field, doc.getFieldValue(field));
				}
				results.add(map);
			}
		} catch (SolrServerException e) {
			e.printStackTrace();
		}
		return results;
	}
	
	/**
	 * When controlling the committing action at client side, finally execute committing.
	 * @throws SolrServerException
	 * @throws IOException
	 */
	private void finallyCommit() throws SolrServerException, IOException {
		if(!docContainer.isEmpty()) {
			server.add(docContainer);
			commit(false, false);
		}
	}
	
	/**
	 * Commit.
	 * @param waitFlush
	 * @param waitSearcher
	 * @throws SolrServerException
	 * @throws IOException
	 */
	public void commit(boolean waitFlush, boolean waitSearcher) {
		try {
			server.commit(waitFlush, waitSearcher);
		} catch (SolrServerException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * When controlling the optimizing action at client side, finally execute optimizing.
	 * @param waitFlush
	 * @param waitSearcher
	 * @throws SolrServerException
	 * @throws IOException
	 */
	public void optimize(boolean waitFlush, boolean waitSearcher) {
		try {
			server.optimize(waitFlush, waitSearcher);
			commit(waitFlush, waitSearcher);
		} catch (Exception e) {
			LOG.error("Encounter error when optimizing.",  e);
			try {
				server.rollback();
			} catch (SolrServerException e1) {
				e1.printStackTrace();
			} catch (IOException e1) {
				e1.printStackTrace();
			}
		}
	}
	
	/**
	 * Optimize.
	 * @param optimize
	 * @throws SolrServerException
	 * @throws IOException
	 */
	private void optimize(boolean optimize) {
		if(optimize) {
			optimize(true, true);
		}
	}

	/**
	 * Add a {@link SolrInputDocument} or collect object and add to the a collection for batch updating
	 * from a mongodb's recored, a Map object.
	 * @param m
	 * @param oneByOne
	 * @throws SolrServerException
	 * @throws IOException
	 */
	private void add(Map<Object, Object> m, boolean oneByOne) throws SolrServerException, IOException {
		SolrInputDocument doc = createDocument(m);
		if(oneByOne) {
			server.add(doc);
		} else {
			docContainer.add(doc);
			if(docContainer.size()>maxCommitCount) {
				server.add(docContainer);
				server.commit(false, false);
				docContainer = new ArrayList<SolrInputDocument>();
			}
		}
	}
	
	/**
	 * Create a {@link SolrInputDocument} object.
	 * @param record
	 * @return
	 */
	private SolrInputDocument createDocument(Map<Object, Object> record) {
		String id = record.get("_id").toString();
		String articleId = (String) record.get("articleId");
		String title = (String) record.get("title");
		String url = (String) record.get("url");
		String spiderName = (String) record.get("spiderName");
		String fragment = makeFragment((BasicDBObject) record.get("fragment"));
		String word = (String) record.get("word");
		int pictureCount = (Integer) record.get("pictureCount");
		int selectedCount = (Integer) record.get("selectedCount");
		int fragmentSize = (Integer) record.get("fragmentSize");
		
		SolrInputDocument doc = new SolrInputDocument();
		doc.addField("_id", id, 1.0f);
		doc.addField("articleId", articleId, 1.0f);
		doc.addField("title", title, 1.0f);
		doc.addField("url", url, 1.0f);
		doc.addField("spiderName", spiderName, 1.0f);
		doc.addField("fragment", fragment, 1.0f);
		doc.addField("word", word, 1.0f);
		// Additional processing for lucene payload metadata.
		doc.addField("pictureCount", word + "|" + pictureCount);
		doc.addField("coverage", word + "|" + (float)selectedCount/fragmentSize);
		return doc;
	}
	
	@SuppressWarnings("unchecked")
	private String makeFragment(BasicDBObject fragment) {
		StringBuilder builder = new StringBuilder();
		Iterator<Map.Entry<Integer, String>> iter = fragment.toMap().entrySet().iterator();
		while(iter.hasNext()) {
			Map.Entry<Integer, String> entry = iter.next();
			builder.append(entry.getValue().trim()).append("<br>");
		}
		return builder.toString();
	}
	
	/**
	 * Set {@link ResponseParser}, default value is {@link XMLResponseParser}.
	 * @param responseParser
	 */
	public void setResponseParser(ResponseParser responseParser) {
		this.responseParser = responseParser;
	}

	/**
	 * Pulling document resource from multiple collections of MongoDB.
	 * @param collectionNames
	 */
	public void setCollectionNames(String[] collectionNames) {
		this.collectionNames = collectionNames;
	}
	
	public void setMaxCommitCount(int maxCommitCount) {
		this.maxCommitCount = maxCommitCount;
	}

	public void setManualCommit(boolean manualCommit) {
		this.manualCommit = manualCommit;
	}

	public void setManualOptimize(boolean manualOptimize) {
		this.manualOptimize = manualOptimize;
	}

	/**
	 * Mongo database configuration.
	 * 
	 * @author shirdrn
	 * @date   2011-12-20
	 */
	public static class MongoConfig implements Serializable {
		private static final long serialVersionUID = -3028092758346115702L;
		private String host;
		private int port;
		private String dbname;
		private String collectionName;
		public MongoConfig(String host, int port, String dbname, String collectionName) {
			super();
			this.host = host;
			this.port = port;
			this.dbname = dbname;
			this.collectionName = collectionName;
		}
		@Override
		public boolean equals(Object obj) {
			MongoConfig other = (MongoConfig) obj;
			return host.equals(other.host) && port==other.port
				&& dbname.equals(other.dbname) && collectionName.equals(other.collectionName);
		}
	}
	
	/**
	 * Mongo database utility.
	 * 
	 * @author shirdrn
	 * @date   2011-12-20
	 */
	static class MongoHelper {
		private static Mongo mongo;
		private static MongoHelper helper;
		private MongoConfig mongoConfig;
		private MongoHelper(MongoConfig mongoConfig) {
			super();
			this.mongoConfig = mongoConfig;
		}
		public synchronized static MongoHelper newHelper(MongoConfig mongoConfig) {
			try {
				if(helper==null) {
					helper = new MongoHelper(mongoConfig);
					mongo = new Mongo(mongoConfig.host, mongoConfig.port);
					Runtime.getRuntime().addShutdownHook(new Thread() {
						@Override
						public void run() {
							if(mongo!=null) {
								mongo.close();
							}
						}
					});
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
			return helper;
		}			
		public DBCollection getCollection(String collectionName) {
			DBCollection c = null;
			try {
				c = mongo.getDB(mongoConfig.dbname).getCollection(collectionName);
			} catch (Exception e) {
				e.printStackTrace();
			}
			return c;
		}	
	}
}

下面，我们可以通过写一个测试用例测试一下。

首先，我的Solr搜索服务器已经部署好并启动成功，对应的url为http://192.168.0.197:8080/server/fragment/。测试用例如下所示：

package org.shirdrn.solr.solrj;

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

import junit.framework.TestCase;

import org.apache.solr.common.params.CommonParams;
import org.apache.solr.common.params.SolrParams;
import org.apache.solr.request.MapSolrParams;
import org.shirdrn.solr.solrj.SolrPostServer.MongoConfig;

@SuppressWarnings("deprecation")
public class TestSolrPostServer extends TestCase {
	
	SolrPostServer myServer;
	MongoConfig config;
	String url;
	String[] collectionNames;
	
	@Override
	protected void setUp() throws Exception {
		url = "http://192.168.0.197:8080/server/fragment/";
		config = new MongoConfig("192.168.0.184", 27017, "fragment", "");
		myServer = new SolrPostServer(url, null, config);
		myServer.setMaxCommitCount(100);
	}
	
	@Override
	protected void tearDown() throws Exception {
		super.tearDown();
	}
	
	public void testPostUpdate() {
		collectionNames = new String[] {
				"sina",
				"lvping",
				"daodao",
				"go2eu",
				"mafengwo",
				"lotour",
				"17u",
				"sohu",
				"baseSe",
				"bytravel"
		};
		myServer.setCollectionNames(collectionNames);
		myServer.setManualCommit(true);
		myServer.setManualOptimize(false);
		myServer.postUpdate();
	}
	
	public void testPostDelete() {
		List<String> strings = new ArrayList<String>();
		strings.add("4ef051342c4117a38f63ee97");
		strings.add("4ef051322c4117a38f63ee36");
		strings.add("4ef051a42c4117a38f63fb51");
		strings.add("4ef050d92c4117a38f63dda4");
		strings.add("4ef051fe2c4117a38f640bc8");
		strings.add("4ef048ef2c4117a38f6207ce");
		strings.add("4ef049062c4117a38f620e13");
		strings.add("4ef046f12c4117a38f6185c0");
		myServer.deleteById(strings);
		myServer.commit(false, false);
		myServer.optimize(true, false);
	}
	
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public void testQuery() {
		Map map = new HashMap();
		map.put(CommonParams.Q, "法国");
		map.put(CommonParams.START, "0");
		map.put(CommonParams.ROWS, "10");
		map.put(CommonParams.FQ, "word:卢浮宫");
		SolrParams params = new MapSolrParams(map);
		List<Map<String, Object>> results = myServer.query(params, new String[] {"_id", "title", "url"});
		assertEquals(10, results.size());
	}
}

在实际开发的过程中，使用Solrj客户端可以非常容易为测试做一些基本操作，如创建索引，测试Solr基本参数及其开发定制Solr相关接口（Retrieval、Highlighting、Faceted Search、Clustering等等）。


solr查询索引
12-06 6012
查询索引的方法有2种：            一.通过solr搜索引擎自己已经实现的功能来查询。即发送url请求到solr服务器。solr会通过这个url请求，返回相应的响应。                                  solr有个管理界面，url：http://localhost:12002/solr/                  在有数据的情况下，可
[Nutch]使用LUKE查看Solr的索引文件内容
Kandy
05-07 3152
上一篇博文有介绍使用Solr的命令solrindex建立索引并提交到Solr服务器，那么我们怎么样查看solrindex命令产生的索引内容呢？这就要使用本篇博文要分享的工具LUKE，通过LUKE工具，我们可以很清楚的看到通过solrindex命令产生的索引内容。
SolrJ查询索引库
天高任鸟飞
08-13 473
查询索引库 查询步骤 第一步：创建一个SolrServer对象 第二步：创建一个SolrQuery对象 第三步：向SolrQuery中添加查询条件、过滤条件 第四步：执行查询，得到一个Response对象 第五步：取查询结果 第六步：遍历结果并打印 查询 @Test public void queryDocument() throws Exception { ...
Solr之查询索引。
孤芳不自赏
10-26 1292
博文中的内容来源《Solr基础知识》这本书，感激不尽。
Solr更新、删除索引
那个谁的空间
04-29 4968
Solr 删除全部索引：*:*&stream.contentType=text/xml;charset=utf-8&commit=true">http://localhost:8080/solr/update/?stream.body=*:*&stream.contentType=text/xml;charset=utf-8&commit=true Solr 查询索引记录：http://lo
使用Solrj操作Solr索引库：添加、删除、修改和查询
"1.4、solrj的使用_代码开始1" ...SolrJ提供了一套完整的API，使得开发者可以方便地在Java应用中集成Solr，进行全文检索和管理索引库。通过理解并熟练使用SolrJ，可以有效地提升Solr服务的开发效率和应用性能。
人工智能-项目实践-搜索引擎-基于solrj开发solr主从搜索引擎服务的dubbo组件
最新发布
02-26
2. 使用Solrj进行索引构建：编写Java代码，利用Solrj的API将数据导入Solr索引库，支持批量导入和增量导入。 3. 创建Dubbo服务：定义Solr搜索服务的接口，实现服务的业务逻辑，然后在服务提供者侧注册该服务。 4. ...
java solr solrj 带账号密码增量查询添加索引
11-14
主要讲解了 solr客户端如何调用带账号密码的solr服务器调用，实现添加索引和查询索引，以及分组查询
Apache Solr入门：SolrJ与Solr服务器的配置与使用
"本文介绍了SolrJ与Solr的使用和原理，包括Solr的基本概念、安装步骤以及SolrJ作为Java客户端与Solr交互的方法。" Solr是基于Apache Lucene构建的一个企业级搜索服务器，它提供了XML/HTTP和JSON API，支持高亮查询...
Apache Solr入门：SolrJ与Solr服务器的使用与原理解析
"SolrJ是访问Solr的Java客户端，用于与Solr服务器进行交互，包括添加、更新和查询索引。Solr是基于Apache Lucene的企业级搜索服务器，提供XML/HTTP和JSON API，支持高亮显示查询结果、缓存、复制功能，并带有Web管理...
solr创建索引并查询
02-26
solr创建索引并查询,希望能够帮助有需要的人。。。
solr创建索引
07-06
索引是设计表的一部分,创建的索引对sql的语句木有任何影响,对sql语句的执行效率有影响
solr 通过URL的方式删除索引
xiao_jun_0820的专栏
09-19 1万+
Solr 删除全部索引：*:*&stream.contentType=text/xml;charset=utf-8&commit=true">http://localhost:8080/solr/update/?stream.body=*:*&stream.contentType=text/xml;charset=utf-8&commit=true solr 删除指定ID的索引：*:*&stre
solr创建索引源码解析
weixin_34268843的博客
10-30 117
为什么80%的码农都做不了架构师？>>> ...
org.apache.solr.client.solrj.SolrServerException:Timeout occurred while waiting response from server
mizuhokaga的博客
02-22 1011
猜测是写过程中某个组件的timeout阈值为120s,检查solr/zookeeper/spark相关timeout 配置,追踪发现。,基于github开源项目(https://github.com/lucidworks/spark-solr),报错如上。知道相关参数,那么很简单了, spark-submit脚本里增加/调整相关参数,这里改为300。(任务是写每天的增量50w数据左右),盲 猜因为solr表太大导致spark写的时间导致。使用spark-submit提交任务,利用spark写CDH 的。
Solr之索引
清风自来
06-30 394
下面来记录并分享下solr对索引的添加、修改及删除操作： 一、简介 在solr中，通过向部署在servlet容器中的solr web应用程序发送HTTP请求来启动索引，还可以向solr索引servlet传递四个不同的索引请求： 1）add/update：允许通过solr添加文档或更新文档。直到提交后才能搜索到添加或更新。 2）commit：告诉solr，应该使上次提交以来所做的更改都可以搜索到。 ...
org.apache.solr.client.solrj.beans.BindingException: Could not instantiate object of class 处理
Syntacticsugar's blog
11-25 2279
solr进行范围超找时候抛异常： 1、问题描述： solrJ中进行范围搜索时候报错： org.apache.solr.client.solrj.beans.BindingException: Could not instantiate object of class com.baidu.Item Caused by: org.apache.solr.client.solrj.beans.Bind...
solr管理界面详解
热门推荐
爱雨轩
08-02 3万+
目录 1.Dashboard(仪表盘) 1 2.Logging(日志) 2 3.Core Admin (core管理) 3 4.Java Properties 6 5. Core Selecter(core选择器) 6 5.1 overview（概览） 6 5.2 Analysis（分析） 7 5.3 Dataimport(从数据库导入数据)
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值