solr DataimportHanler 效率对比

最新推荐文章于 2021-08-11 15:54:16 发布
原创 最新推荐文章于 2021-08-11 15:54:16 发布 · 256 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#solr
本文详细介绍了如何利用Solr的API和data-config.xml配置文件，通过多核心创建索引和数据导入流程，实现高效的数据存储与检索。包括使用SolrInputDocument提交数据至Solr服务，构建索引，以及通过多核心合并索引至目标核心的过程，最终实现数据的高效管理和快速查询。

1：用solrj 的api 调用封装SolrInputDocument 提交solr 服务创建索引

 

package test.client.impl;

import java.io.IOException;
import java.net.MalformedURLException;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.impl.CommonsHttpSolrServer;
import org.apache.solr.client.solrj.request.CoreAdminRequest;
import org.apache.solr.common.SolrInputDocument;

public class DBTestDao extends BaseDao {
	private static final Logger LOGGER = Logger.getLogger(DBTestDao.class);
	private int per = 2000;
	private int count = 74000;
	private int start = 0;
	private int coreCount = 5;
	private String targetCore = "http://127.0.0.1:8000/solr/targetCore";
	private String url = "http://127.0.0.1:8000/solr/core";
	private String indexParentPath = "D:/solr_OB1B/app/solr_multcore/core";

	static {
		PropertyConfigurator.configure("log4j.properties");
	}

	private void removeOtherIndex() throws SolrServerException, IOException {
		for (int i = 0; i < coreCount; i++) {
			CommonsHttpSolrServer server = new CommonsHttpSolrServer(url + i);
			server.deleteByQuery("*:*");
			server.optimize();
			server.commit();
		}
	}

	private void removeTargetIndex() {

		try {
			CommonsHttpSolrServer server = new CommonsHttpSolrServer(targetCore);
			server.deleteByQuery("*:*");
			server.optimize();
			server.commit();
			LOGGER.info("清空targetCore的数据");
		} catch (MalformedURLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SolrServerException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	private List<SolrInputDocument> getDocList() {
		String sql = "select num,metaid,active,productname,catalogid,url,price,count_productmeta,minimum_price,maximum_price,catalogid1,catalogname1,catalogid2,catalogname2,catalogid3,catalogname3,brandid,brandname, imagepath ,[rank],[description],displayname,updatetime,createdatetime,isfirstproduct,commoncount,type from DataCenter_TempTable as t where  t.num>"
				+ start + " AND  t.num<" + (start + per);
		List<SolrInputDocument> list = new ArrayList<SolrInputDocument>();
		try {
			Statement stat = conn.createStatement();
			LOGGER.info(sql);
			ResultSet rs = stat.executeQuery(sql);
			while (rs.next()) {
				SolrInputDocument doc = new SolrInputDocument();
				doc.addField("metaid", rs.getObject("metaid"));
				doc.addField("id", rs.getObject("num"));
				//doc.addField("price", rs.getObject("price"));
				doc.addField("url", rs.getObject("url"));
				doc.addField("count_productmeta", rs.getObject("count_productmeta"));
				doc.addField("minimum_price", rs.getObject("minimum_price"));
				doc.addField("maximum_price", rs.getObject("maximum_price"));
				doc.addField("rank", rs.getObject("rank"));
				doc.addField("imagepath", rs.getObject("imagepath"));
				doc.addField("displayname", rs.getObject("displayname"));
				doc.addField("description", rs.getObject("description"));
				doc.addField("brandfacet", rs.getObject("num"));
				doc.addField("brandname", rs.getObject("brandname"));
				doc.addField("productname", rs.getObject("productname"));
				doc.addField("catalogid3", rs.getObject("metaid"));
				doc.addField("catalogfacet3", rs.getObject("catalogname3"));
				doc.addField("catalogid2", rs.getObject("metaid"));
				doc.addField("catalogfacet2", rs.getObject("catalogname2"));
				doc.addField("catalogid1", rs.getObject("metaid"));
				doc.addField("catalogfacet1", rs.getObject("catalogname1"));
				doc.addField("updatetime", rs.getObject("updatetime"));
				doc.addField("createdatetime", rs.getObject("createdatetime"));
				doc.addField("isfirstproduct", rs.getObject("isfirstproduct"));
				doc.addField("catalogid", rs.getObject("catalogid"));
				doc.addField("commoncount", rs.getObject("commoncount"));
				String searchText = rs.getString("brandname") + rs.getString("catalogname3")
						+ rs.getString("productname") + rs.getInt("catalogid1") + rs.getInt("catalogid2")
						+ rs.getInt("catalogid3");
				doc.addField("searchText", searchText);
				list.add(doc);

			}
			start = start + per;
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return list;
	}

	public void startCoreIndex(int core) throws SolrServerException, IOException {
		String solrUrl = url + core;
		List<SolrInputDocument> list = getDocList();
		CommonsHttpSolrServer server = new CommonsHttpSolrServer(solrUrl);
		server.add(list);
		LOGGER.info(".........开始为core" + core + "提交数据！！！数据开始【" + (start - 2000) + "】结束【" + start + "】");
		server.commit();
		LOGGER.info(".........core" + core + "数据提交结束");
	}

	public void mergeIndex() throws SolrServerException, IOException {
		for (int i = 0; i < coreCount; i++) {
			LOGGER.info("开始合并:core" + i);
			String[] strs = { indexParentPath + i + "/data/index" };
			CoreAdminRequest.mergeIndexes("targetCore", strs, new CommonsHttpSolrServer("http://127.0.0.1:8000/solr"));
			LOGGER.info("core" + i + "合并完成.....");
		}
		String targetCore = this.targetCore;
		CommonsHttpSolrServer targetServer = new CommonsHttpSolrServer(targetCore);
		targetServer.commit();
		targetServer.optimize();
		LOGGER.info("所有 core合并完成.....");
	}

	public void process() throws SolrServerException, IOException {
		removeTargetIndex();
		long startDate = new Date().getTime();
		while (start < count) {
			// 1.调用每一个core开始创建索引
			for (int i = 0; i < coreCount; i++) {
				if (start < count) {
					startCoreIndex(i);
				}
			}
		}
		LOGGER.info("数据索引完成");
		mergeIndex();
		long endDate = new Date().getTime();
		System.out.println("~~~~~~~~~~~~~~~~~~~" + (endDate - startDate));
		removeOtherIndex();
	}

	public static void main(String[] args) {

		DBTestDao dao = new DBTestDao();
		try {
			dao.process();
		} catch (SolrServerException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
  
package test.client.impl;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;

public class BaseDao {
	private static final Logger LOGGER = Logger.getLogger(BaseDao.class);
	private static String url = "jdbc:sqlserver://10.16.230.40:1433;DatabaseName=CrawlerDataCenter_Zol_Test";
	private static String password = "xalab@123";
	private static String username = "sa";
	protected static Connection conn;
	static {
		try {
			PropertyConfigurator.configure("log4j.properties");
			Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
			conn = DriverManager.getConnection(url, username, password);
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public BaseDao() {

	}

	public static void main(String[] args) {
		BaseDao dao = new BaseDao();
	}
}

<?xml version="1.0" encoding="UTF-8" ?>
<schema name="example" version="1.2">
  
 <types>
	<fieldType name="int" class="solr.TrieIntField" precisionStep="0" omitNorms="true" positionIncrementGap="0"/>
	<fieldType name="float" class="solr.TrieFloatField" precisionStep="0" omitNorms="true" positionIncrementGap="0"/>
	<fieldType name="long" class="solr.TrieLongField" precisionStep="0" omitNorms="true" positionIncrementGap="0"/>
	<fieldType name="double" class="solr.TrieDoubleField" precisionStep="0" omitNorms="true" positionIncrementGap="0"/>
	<fieldType name="date" class="solr.TrieDateField" omitNorms="true" precisionStep="0" positionIncrementGap="0"/>
	<fieldType name="string" class="solr.StrField" sortMissingLast="true" omitNorms="true"/>

		<fieldtype name="textZN"  class="solr.TextField">
			<analyzer class="org.wltea.analyzer.lucene.IKAnalyzer"/>		
			<analyzer type="index">
				<tokenizer class="org.wltea.analyzer.solr.IKTokenizerFactory" isMaxWordLength="false"/>  
				<filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt" enablePositionIncrements="true" />
				<filter class="solr.WordDelimiterFilterFactory" generateWordParts="1" generateNumberParts="1" catenateWords="1" catenateNumbers="1" catenateAll="0" splitOnCaseChange="0"/>
				<filter class="solr.LowerCaseFilterFactory"/>
				<filter class="solr.ReversedWildcardFilterFactory" withOriginal="true"
					 maxPosAsterisk="3" maxPosQuestion="2" maxFractionAsterisk="0.33"/>
			</analyzer>	 
		</fieldtype> 
 </types>  

 <fields>


   <field name="id" type="string" indexed="true" stored="true" required="true" /> 	

   <field name="itemPrice"  type="float"  indexed="true" stored="true" />

   <field name="metaid"  type="int"  indexed="true" stored="true" />

	<field name="imagepath" type="string" indexed="true" stored="true" />  

   <field name="brandid"    type="int"	  indexed="true" stored="false" />

   <field name="brandfacet"	type="string" indexed="true" stored="true" />
	
	 <field name="brandname"	type="string" indexed="true" stored="true" />

	 <field name="url"	type="string" indexed="true" stored="true" />

	 <field name="count_productmeta"	type="string" indexed="true" stored="true" />

	 <field name="minimum_price"	type="float" indexed="true" stored="true" />

	 <field name="maximum_price"	type="float" indexed="true" stored="true" /> 

	<field name="rank"	type="int" indexed="true" stored="true" /> 

	<field name="displayname"	type="string" indexed="true" stored="true" /> 

	<field name="description"	type="textZN" indexed="true" stored="true" /> 


   <field name="pid" type="int"  indexed="true" stored="false" multiValued="true" />	
   
   <field name="propFacet"	type="string" indexed="true" stored="true" multiValued="true" /> 
    
   <field name="productname" type="string" indexed="true" stored="true"  />

   <field name="catalogid1"		type="int"    indexed="true" stored="false" />

   <field name="catalogfacet1"	type="string" indexed="true" stored="true" />

      <field name="catalogid2"	type="int" indexed="true" stored="false" />

   <field name="catalogfacet2"	type="string" indexed="true" stored="true" />
   
      <field name="catalogid3"		type="int"    indexed="true" stored="false" />

   <field name="catalogfacet3"	type="string" indexed="true" stored="true" />


 <field name="updatetime"	type="string" indexed="true" stored="true" />
  <field name="createdatetime"	type="string" indexed="true" stored="true" />
   <field name="isfirstproduct"	type="int" indexed="true" stored="true" />
   <field name="catalogid"	type="int" indexed="true" stored="true" />
   <field name="commoncount"	type="int" indexed="true" stored="true" />
    <field name="catalogtype"	type="string" indexed="true" stored="true" />

 	  <field name="autocompleteword"			type="textZN" indexed="true" stored="true"	/> 
   <field name="searchText"			type="textZN" indexed="true" stored="true"	/> 
	
	
   <!-- Dynamic field definitions.  If a field name is not found, dynamicFields
        will be used if the name matches any of the patterns.
        RESTRICTION: the glob-like pattern in the name attribute must have
        a "*" only at the start or the end.
        EXAMPLE:  name="*_i" will match any field ending in _i (like myid_i, z_i)
        Longer patterns will be matched first.  if equal size patterns
        both match, the first appearing in the schema will be used.  -->
   <dynamicField name="*_i"  type="int"    indexed="true"  stored="true"/>
   <dynamicField name="*_s"  type="string"  indexed="true"  stored="true"/>
   <dynamicField name="*_l"  type="long"   indexed="true"  stored="true"/>
   <dynamicField name="*_f"  type="float"  indexed="true"  stored="true"/>
   <dynamicField name="*_d"  type="double" indexed="true"  stored="true"/>
   <dynamicField name="*_dt" type="date"    indexed="true"  stored="true"/>
 </fields> 
  
  <uniqueKey>id</uniqueKey>

  <defaultSearchField>searchText</defaultSearchField>
  <solrQueryParser defaultOperator="AND"/>

  <!--		
  <copyField source="itemName" dest="searchText"	/>
  <copyField source="itemBrand"		dest="searchText" 	/>
  <copyField source="itemCatalog"	dest="searchText"	/>
  <copyField source="itemDesc"		dest="searchText"	/>
  -->
</schema>
 

 

 

2：通过data-config.xml 配置进行数据导入

 

import java.io.File;
import java.io.IOException;
import java.util.Date;

import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.apache.solr.client.solrj.SolrRequest;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.impl.CommonsHttpSolrServer;
import org.apache.solr.client.solrj.request.CoreAdminRequest;
import org.apache.solr.client.solrj.request.QueryRequest;
import org.apache.solr.common.params.ModifiableSolrParams;
import org.apache.solr.common.util.NamedList;

import com.newegg.labxa.ob1b.search.tools.OpertProperty;
import com.newegg.labxa.ob1b.search.tools.SolrServiceFactory;

public class SolrCreateIndex {
	private static final Logger LOGGER = Logger.getLogger(SolrCreateIndex.class);
	private static final OpertProperty OPT = OpertProperty.getInstance();
	private static final String TARGET_CORE_NAME = OPT.getValue(OpertProperty.TARGET_CORE);
	private static String createSolrUrl = OPT.getValue(OpertProperty.CREATE_SOLR_URL);
	private static int start = 1;
	private static int size = 1000;
	static {
		size = OPT.getValueForInteger(OpertProperty.CORE_DATA_NUM);
		if (!createSolrUrl.endsWith("/")) {
			createSolrUrl = createSolrUrl + "/";
		}
		PropertyConfigurator.configure("log4j.properties");
	}

	/**
	 * multicore创建索引的入口函数
	 */
	public static void createIndex(int totalNum) {
		//在索引要全部建之前，先清空targetCore里边旧索引
		deleteCoreIndex(new String[] { TARGET_CORE_NAME });

		String[] cores = OPT.getValueForStringArray(OpertProperty.SOLR_CORES);
		if (cores == null || cores.length == 0) {
			return;
		}
		long startDate = new Date().getTime();
		while (start < totalNum) {
			// 1.调用每一个core开始创建索引
			for (int i = 0; i < cores.length; i++) {
				if (start < totalNum) {
					startOneCoreCreate(createSolrUrl + cores[i] + "/");
				}
			}
		}
		//2.merging(合并每一个core下面的索引到targetCore里)
		try {

			mergingIndex(cores, TARGET_CORE_NAME);
			long endDate = new Date().getTime();
			System.out.println("~~~~~~~~~~~~~~~~~~~" + (endDate - startDate));
		} catch (InterruptedException e) {
			if (LOGGER.isInfoEnabled()) {
				LOGGER.info(e);
			}
		} catch (Exception e) {
			if (LOGGER.isInfoEnabled()) {
				LOGGER.info(e);
			}
		}

		// 3.删除core0，core1，core2...下面的index
		deleteCoreIndex(cores);
	}

	/**
	 * 启动每一个core实现对index的创建
	 */
	private static void startOneCoreCreate(String url) {
		CommonsHttpSolrServer server = SolrServiceFactory.getSolrServer(url);
		// 判断当前的core的index是否创建完成
		boolean indexIsOk = createIndexIsOk(server);
		if (!indexIsOk) {
			return;
		}
		ModifiableSolrParams params = new ModifiableSolrParams();
		params.add("qt", "/dataimport");
		params.add("clean", "false");
		params.add("command", "full-import");
		params.add("commit", "true");
		params.add("startid", String.valueOf(start));
		params.add("endid", String.valueOf(start + size));

		try {
			start = start + size; // 修改下标
			server.query(params);
			server.commit();
		} catch (SolrServerException e) {
			if (LOGGER.isInfoEnabled()) {
				LOGGER.info(e);
			}
			start = start - size; // 回滚修改的下标
		} catch (IOException e) {
			if (LOGGER.isInfoEnabled()) {
				LOGGER.info(e);
			}
			start = start - size; // 回滚修改的下标
		}
		LOGGER.info("创建索引:" + url + "start=" + (start - size) + "  end=" + start);
	}

	/**
	 * 索引的合并
	 */
	private static void mergingIndex(String[] cores, String targetCoreName) throws Exception {
		String indexParentPath = OPT.getValue(OpertProperty.INDEX_PARENT_PATH);
		if (!indexParentPath.endsWith("/")) {
			indexParentPath = indexParentPath + "/";
		}
		CommonsHttpSolrServer server = SolrServiceFactory.getSolrServer(createSolrUrl);
		for (String coreName : cores) {
			LOGGER.info("开始合并:" + coreName);
			String indexPath = indexParentPath + coreName + "/data/index";
			File dir = new File(indexPath);
			if (!dir.exists() && !dir.isDirectory()) {
				throw new RuntimeException(indexPath);
			}
			String[] strs = { indexParentPath + coreName + "/data/index" };
			/* --------------------判断core的索引是否创建完成----------------------------- */
			String oneCoreUrl = createSolrUrl + coreName + "/";
			CommonsHttpSolrServer oneCoreServer = SolrServiceFactory.getSolrServer(oneCoreUrl);
			int i = 0;
			while (i < 500) {
				boolean isOver = createIndexIsOk(oneCoreServer);
				if (isOver) {
					break;
				}
				// 防止死循环!!!
				i++;
			}
			/* --------------------判断core的索引是否创建完成----------------------------- */
			LOGGER.info(targetCoreName);
			for (String s : strs) {
				LOGGER.info(s);
			}
			LOGGER.info(createSolrUrl);
			CoreAdminRequest.mergeIndexes(targetCoreName, strs, server);
			LOGGER.info(coreName + "合并完成.....");
		}

		String targetCore = createSolrUrl + targetCoreName;
		CommonsHttpSolrServer targetServer = SolrServiceFactory.getSolrServer(targetCore);
		targetServer.commit();
		targetServer.optimize();

		LOGGER.info("索引全部合并完成....");
	}

	/**
	 * 判断core是是否已经创建完成
	 * (通过给http：127.0.0.1:8080/solr/colrxx/dataimport来获得DIH线程的状态是'busy'还是'idle')
	 */
	private static boolean createIndexIsOk(CommonsHttpSolrServer oneCoreServer) {
		// 防止判断core状态时刷新太快，所以每次判断时先sleep 2s
		try {
			Thread.sleep(2 * 1000);
		} catch (Exception e) {
			if (LOGGER.isInfoEnabled()) {
				LOGGER.info(e);
			}
		}
		System.out.println("*************************************************");
		ModifiableSolrParams params = new ModifiableSolrParams();
		params.add("qt", "/dataimport");
		SolrRequest request = new QueryRequest(params);
		try {
			NamedList<Object> names = oneCoreServer.request(request);
			String diHStart = (String) names.get("status");
			LOGGER.info("core的状况:" + oneCoreServer.getBaseURL() + " :" + diHStart);
			if (diHStart != null && "idle".equalsIgnoreCase(diHStart)) {
				return true;
			}
		} catch (SolrServerException e) {
			if (LOGGER.isInfoEnabled()) {
				LOGGER.info(e);
			}
		} catch (IOException e) {
			if (LOGGER.isInfoEnabled()) {
				LOGGER.info(e);
			}
		}
		return false;

	}

	/**
	 * 删除core下面的index
	 * 
	 * @param cores
	 */
	private static void deleteCoreIndex(String[] cores) {
		for (String core : cores) {
			String coreUrl = createSolrUrl + core;
			CommonsHttpSolrServer coreServer = SolrServiceFactory.getSolrServer(coreUrl);
			try {
				coreServer.deleteByQuery("*:*");
				coreServer.optimize();
				coreServer.commit();
				if (LOGGER.isInfoEnabled()) {
					LOGGER.info("删除" + core + "上的索引完成");
				}
			} catch (SolrServerException e) {
				if (LOGGER.isInfoEnabled()) {
					LOGGER.info(e);
				}
			} catch (IOException e) {
				if (LOGGER.isInfoEnabled()) {
					LOGGER.info(e);
				}
			}
		}
	}

	/**
	 * 对targetCore只执行delta-import，但不进行优化，这样就在replication时只把update的index发给slave机
	 */
	public static void deltaIndex() {
		String targetCoreUrl = createSolrUrl + TARGET_CORE_NAME;
		CommonsHttpSolrServer server = SolrServiceFactory.getSolrServer(targetCoreUrl);

		ModifiableSolrParams params = new ModifiableSolrParams();
		params.add("qt", "/dataimport");
		params.add("clean", "false");
		params.add("command", "delta-import");
		params.add("commit", "true");
		// 这里增量的索引不进行合并，这样就每次给slave机分发新增的部分
		try {
			server.query(params);
			server.commit();
		} catch (SolrServerException e) {
			if (LOGGER.isInfoEnabled()) {
				LOGGER.info(e);
			}
		} catch (IOException e) {
			if (LOGGER.isInfoEnabled()) {
				LOGGER.info(e);
			}
		}
		LOGGER.info("更新索引:" + targetCoreUrl);
	}

	public static void main(String[] args) {
		//deleteCoreIndex(new String[] { "targetCore" });
		createIndex(74000);
		//deltaIndex();
	}
}
 

Sql 总记录 74000 条

方式一：

         data-config.xml 配置方式索引

         索引 field 31 个

         core数量 5个

         生成 index 文件 141MB

         共耗时 93061ms

         平均 0.001515MB/ms

方式二：

         Api SolrInputDocument 方式提交

         索引 field 25 个

         core数量 5个

         生成 index 文件 113MB

共耗时 66061ms

平均 0.001710MB/ms

solr合并集合
五哥的酒馆
05-09 723
&#13;      当需要合并两个不同项目或者是多个分开配置的服务器时，你既可以使用lucene-misc里面的IndexMergeTool工具，也可以使用CoreAdminHandler。       要合并索引，必须满足如下要求： 1.两个索引必须兼容：schema需要包含相同的字段，并且字段分析方法相同。 2.必须不包含相同数据。 最好两个索引是用相同的schema...
通过Http管理Solr Core,实现索引的分类
天道酬勤
08-21 199
使用的版本为Solr 4.9http://my.oschina.net/cloudcoder/blog/305033查看所有core的状态     使用样例         http://172.168.63.233:8983/solr/admin/cores?action=STATUS查看某一个core的状态      http://172.168.63.233:8983/solr/admi...
搜索解决方案Solr
殷志鹏的博客
08-11 601
网页右边，向下滑有目录索引，可以根据标题跳转到你想看的内容 如果右边没有就找找左边 Solr Solr是基于Apache Lucene构建的用于搜索和分析的开源解决方案。可提供可扩展索引、搜索功能、高亮显示和文件解析功能 Solr本质上就是一个java web项目，且内嵌了Jetty服务器，安装起来非常方便，客户端操作Solr的过程和平时我们所写项目一样，请求Solr中控制器（Controller），处理完数据后把结果响应给客户端 在海量数据下，对MySql或Oracl...
solr合并索引
johnhuster的专栏
01-08 1561
solr下可以通过mergeindexes命令完成一个或多个core到其他core的索引合并，合并索引需要保证要被合并到的core的schema要与其他来源core的schema兼容，否则就会出现无法启动core的问题，我们可以通过代码CoreAdminRequest.MergeIndexes类实现，实例代码如下：         try(SolrClient client = new Http...
solr配置dataimport步骤 增量 全量同步配置
Truong的专栏
07-25 2908
http://blog.csdn.net/u010367582/article/details/54095343
solr DataimportHanler
白强
09-22 166
大多数的应用程序将数据存储在关系数据库、xml文件中。对这样的数据进行搜索是很常见的应用。所谓的DataImportHandler提供一种可配置的方式向solr导入数据，可以一次全部导入，也可以增量导入。       概览          目 标      能够读取关系数据库中的数据。      通过可配置的方式，能够将数据库中多列、多表的数据生成solr文档 ...
solr8之Dataimport数据导入相关问题及教程
only1475813080的博客
04-02 3580
此教程是与前两个教程相连接的，如果您没有用小白的前两个教程进行配置，导致出错可不能怪小白的教程有问题喔。 1.导包 在配置核的文件夹下，新建一个lib文件夹，然后把D:\Solr\solr-8.5.0\dist中的两个包复制到D:\Solr\solrhome\collection1\lib，数据到的包就有了，因为小白是将数据库中的数据导入到solr6，所以还需要一个数据库连接包。（此包就不提供...
solr data import性能优化
choulengfu8923的博客
06-10 507
背景： solr 4.* 或者 solr 5.1 数据结构存在entity嵌套 问题描述： 全量导入100万条数据的话，子entity的query语句会被调用100万次，由于solr没有使用PreparedStatement（绑定变量的方式），SQL会在DB S...
solr配置dataimport步骤
热门推荐
Super girl的专栏
01-05 1万+
dataimpor
Solr dataimport详解
机会靠自己争取，不要拿道德让别人施舍
01-04 957
步骤1： 在solrconfig.xml增加   &lt;requestHandler name="/dataimport" class="org.apache.solr.handler.dataimport.DataImportHandler"&gt; &lt;lst name="defaults"&gt; &lt;str n...
在solr中使用dataimport导入数据报内存溢出问题
cx1006784951的博客
04-22 1739
solr-7.3.0\bin>Exception in thread "Thread-21" java.lang.OutOfMemoryError: Java heap space at com.mysql.jdbc.MysqlIO.readPacket(MysqlIO.java:604) at com.mysql.jdbc.MysqlIO.getResult...
Solr Data Import配置多Entity
Fenf的专栏
03-17 5606
dataConfig>     dataSource type="JdbcDataSource"                 driver="com.mysql.jdbc.Driver"                 url="jdbc:mysql://localhost/dbname"                 user="user-name"
浅谈solr-mongo-dataimport
嘿嘿嘿
12-14 2163
浅谈solr-mongo-dataimport最近项目需要一个全局搜索功能。我们的项目绝大部分数据都是存在mongodb中。搜索引擎准备用solr。 之前因为项目需要，mongodb与solr已经做过一次简单的整合。之所以说简单，是因为只是单表建立索引。用mongo-connector可以很好的将这两者整合。现在这个全局搜索的功能，需要的是多表联合。mongo-connector并不支持此功能。
solr dihwiki整理
java 技术交流。
03-03 341
https://wiki.apache.org/solr/DataImportHandler Using delta-import command 点击http://localhost:8983/solr/dataimport?command=delta-import可以启动增量导入操作。此操作将在新线程中启动，响应中的状态属性现在应显示为“忙碌”。根据数据集的大小，此操作可能需要一些时间。您...
和solr的N天N夜（四）--增量、定时导入并检索数据
jiangjun0130的博客
03-17 5648
一：引言 在上一章中导入数据的方式是全量导入，如果每次导入数据都是全量导入的话，首先是没必要，其次在海量数据下对服务器的压力也较大。所以合理的方式是更新索引采用定时增量更新。 二、修改数据库 在数据库中新增一个timestamp类型的字段，并且默认值为CURRENT_TIMESTAMP CREATE TABLE `image_info` (   `id` varchar(32)
solr 创建mysql索引慢_Solr创建数据库索引（MySql）
weixin_36060917的博客
01-19 201
1、准备的jar包(导入solr/WEB_INF/lib下)1)solr-dataimporthandler-extras-4.7.0.jar；在solr发布包solr-4.7.0\dist里面有2)solr-dataimporthandler-4.7.0.jar；在solr发布包solr-4.7.0\dist里面有3) 数据库驱动包2、修改solr的core配置要想哪个core从数据库...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值