全文检索可视化动态管理（二）--solr二次开发和solrj扩展

最新推荐文章于 2021-04-05 03:50:12 发布
最新推荐文章于 2021-04-05 03:50:12 发布
阅读量181 收藏
点赞数
文章标签： python web.xml java
原文链接：https://my.oschina.net/passerman/blog/710362
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

  要完成solr的索引动态配置，需要solr提供动态新建、修改配置等的接口。solr虽提供core的添加删除，但不提供schema.xml修改新建接口，并且如果添加一个新core，也要将另一个core的conf配置文件复制一份到新的core文件夹下，然后管理页载入新的core。因此需要二次开发。
   查看solr的web.xml，可以发现请求链接都进入org.apache.solr.servlet.SolrDispatchFilter。查看SolrDispatchFilter源码，可以在doFilter方式里看到，如果是adminPath的链接,则SolrRequestHandler的实现是cores.getMultiCoreHandler()。 

进入getMultiCoreHandler()方法，可以得知是org.apache.solr.handler.admin.CoreAdminHandler。此类则是solr管理界面的Core Admin的接口处理类。因此，可以继承CoreAdminHandler，重载handleRequestBody方法来给solr增加所需的处理接口。

    进一步查看源码，可以发现solr.xml里可以用adminHandler标签替换CoreAdminHandler。solr.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<solr persistent="true">
  <cores defaultCoreName="default" adminHandler="org.apache.solr.handler.admin.EdenCoreAdminHandler" adminPath="/admin/cores" zkClientTimeout="${zkClientTimeout:15000}" hostPort="8080" hostContext="solr">
    <core instanceDir="core0\" name="core0"/>
    <core instanceDir="default\" name="default"/>
    <core instanceDir="periodical\" name="periodical"/>

  </cores>
</solr>

EdenCoreAdminHandler:

public class EdenCoreAdminHandler  extends CoreAdminHandler {

	  public EdenCoreAdminHandler()
	  {
		  
		 
	  }
	  
	 public EdenCoreAdminHandler(final CoreContainer coreContainer) {
		    super(coreContainer);
	}
	 
	  public CoreContainer getCoreContainer() {
		    return this.coreContainer;
		  }
	 
	
	@Override
	public void handleRequestBody(SolrQueryRequest req, SolrQueryResponse rsp)
			throws Exception {
		  CoreContainer cores = getCoreContainer();
		    if (cores == null) {
		      throw new SolrException(SolrException.ErrorCode.BAD_REQUEST,
		              "Core container instance missing");
		    }
		    String action = req.getParams().get(CoreAdminParams.ACTION);
			//String newCoreName=req.getParams().get("newCoreName");
			if (action!=null&&action.equals("ADDNEWCORE")) {
				doAddCore( req,  rsp);
			}else if (action!=null&&action.equals("CHANGESCHEMA")) {
				changeSchemaXml(req, rsp);
			}else if (action!=null&&action.equals("DELCORE")) {
				delCore(req, rsp);
			}else{
				super.handleRequestBody( req, rsp);
			}
        
	}
	
	
	/**
	 * 添加core
     *将默认core下conf里的solrconfig.xml和schema.xml拷贝到新core的conf下。这步是必须的
     *因为新建的core solr会去其conf文件夹下找这两个文件，如果没有就会报错，新core则不会创建成功
	 * @param req
	 * @param rsp
	 * @throws Exception
	 */
	public void doAddCore(SolrQueryRequest req, SolrQueryResponse rsp)	throws Exception 
	{
		  CoreContainer cores = getCoreContainer();
		 
		String defaultCoreName=  cores.getDefaultCoreName();
		SolrCore core=cores.getCore(defaultCoreName);
		
		final SolrResourceLoader loader = core.getResourceLoader();
		File srcCoredir = new File(loader.getInstanceDir());

	
		if (!srcCoredir.exists()) {
			throw new SolrException(ErrorCode.FORBIDDEN,
					"当前core不存在!");
		}

		String newCoreName=req.getParams().get(CoreAdminParams.NAME);
		if (newCoreName==null||newCoreName.equals("")) {
			 
			 throw new SolrException(ErrorCode.FORBIDDEN,
						"name不能为空!");
		 }
		 if (coreContainer.getCore(newCoreName) != null) {
			 
			 throw new SolrException(ErrorCode.FORBIDDEN,
						"已经创建了"+newCoreName+"的core!");
		 }
			
		String solrHome=srcCoredir.getParent();
		String srcConfPath= solrHome+File.separator+"default"+ File.separator+"conf";  //复制default文件夹
		String fromCoreName=req.getParams().get(CoreAdminParams.OTHER);
		if(fromCoreName!=null&&!fromCoreName.equals(""))  //如果有参数，则用这个的配置
		{
			SolrCore fromcore=cores.getCore(fromCoreName);
			SolrResourceLoader fromcoreLoader = fromcore.getResourceLoader();
			srcConfPath=fromcoreLoader.getConfigDir();
			
		}
	
		  // 建立新core所在文件夹
       File newCorePath = new File(solrHome + File.separator + newCoreName);
       if (!newCorePath.exists()) {
    	   newCorePath.mkdir();
       }
       // 建立新core下的conf文件夹
       File newConfPath = new File(newCorePath.getAbsolutePath() + File.separator
               + "conf/");
       if (!newConfPath.exists()) {
    	   newConfPath.mkdir();
       }
  
       boolean doPersist=this.handleCreateAction(req, rsp);
       
       if (doPersist) {
           cores.persist();
           rsp.add("saved", cores.getConfigFile().getAbsolutePath());
         }
         rsp.setHttpCaching(false);
		
	}
	
	.......

	@Override
	public String getDescription() {
		return "add new core";
	}

	@Override
	public String getSource() {
		return null;
	}

}

 

同时solrj也要扩展新接口的请求方法。按照solrj源码里的请求方式。

EdenCoreAdminParams：

public class EdenCoreAdminParams implements CoreAdminParams{
	  public enum EdenCoreAdminAction {
	    CORESINFO,
	    ADDNEWCORE,
	    CHANGESCHEMA,
	    DELCORE;
	    public static CoreAdminAction get( String p )
	    {
	      if( p != null ) {
	        try {
	          return CoreAdminAction.valueOf( p.toUpperCase(Locale.ROOT) );
	        }
	        catch( Exception ex ) {}
	      }
	      return null; 
	    }
	  }
	
}

EdenSchemaUpdateRequest(动态修改schema.xml):

public class EdenSchemaUpdateRequest extends AbstractUpdateRequest{

	private String xmlContent=null;
	
	public EdenSchemaUpdateRequest( String path) {
		super(METHOD.POST, path);
	}

	@Override
	public Collection<ContentStream> getContentStreams() throws IOException {
		 return ClientUtils.toContentStreams(getXmlContent(), ClientUtils.TEXT_XML);
	}

	public String getXmlContent() {
		return xmlContent;
	}

	public void setXmlContent(String xmlContent) {
		this.xmlContent = xmlContent;
	}

	
}

EdenCoreAdminRequest:

/**
 *  solrj CoreAdminRequest扩展
 * @author hanxuetong
 * 
 */
@SuppressWarnings("serial")
public class EdenCoreAdminRequest extends CoreAdminRequest{

	protected  ModifiableSolrParams params;
    protected EdenCoreAdminAction edenAction; 
	
	
    @Override
    public SolrParams getParams() {
    	
        if(params==null)
        {
        	params = new ModifiableSolrParams(); 
        }
        if( edenAction == null&&params==null ) { //使用原来的
	        return super.getParams();
	    }
        if(edenAction==null||edenAction.equals(EdenCoreAdminAction.CORESINFO)  ) //直接查询所有信息
        {
        	 return params;
        }
        
        params.set( EdenCoreAdminParams.ACTION, edenAction.toString() );
        params.set( EdenCoreAdminParams.NAME, core );
    	if(other!=null)
    	{
    		params.set( EdenCoreAdminParams.OTHER, other );
    	}

      return params;
    }
	public void setParams(ModifiableSolrParams params) {
		this.params = params;
	}

	public void setEdenAction(EdenCoreAdminAction edenAction) {
		this.edenAction = edenAction;
	}
	 public static class DelCore extends EdenCoreAdminRequest {
		    protected String deleteDir;

		    public DelCore(String deleteDir) {
		      edenAction=EdenCoreAdminAction.DELCORE;
		      this.deleteDir = deleteDir;
		    }

		    public String isDeleteDir() {
		      return deleteDir;
		    }

		    public void setDeleteDir(String deleteDir) {
		      this.deleteDir = deleteDir;
		    }

		    @Override
		    public SolrParams getParams() {
		      ModifiableSolrParams params = new ModifiableSolrParams();
		      params.set( EdenCoreAdminParams.ACTION, edenAction.toString());
		      params.set( EdenCoreAdminParams.CORE, core );
		      if(deleteDir!=null)
		      {
		    	  params.set("deleteDir", deleteDir);
		      }
		     
		      return params;
		    }
	 }
	  public static CoreAdminResponse delCore( String name, String deleteDir, SolrServer server ) throws SolrServerException, IOException
	  {
		  DelCore req = new DelCore(deleteDir);
		  req.setCoreName( name );
		  return req.process( server );
	  }	 
}

EdenSolrCoresRequest:

/**
 * solr控制台管理交互类
 * @author hanxuetong
 * 
 */
public class EdenSolrCoresRequest {

	/**
	 * 获得所有core信息
	 * @return
	 * @throws IOException 
	 * @throws SolrServerException 
	 */
	public static NamedList<NamedList<Object>>  getSolrCoresInfo(HttpSolrServer rootServer) throws SolrServerException, IOException
	{
		EdenCoreAdminRequest req = new EdenCoreAdminRequest();
	    req.setEdenAction( EdenCoreAdminAction.CORESINFO );
		CoreAdminResponse list = req.process( rootServer );
		
		NamedList<NamedList<Object>>  coresInfoList=list.getCoreStatus();

		return coresInfoList;
			
	}
	
	/**
	 * 获取某一core信息
	 * @param coreName
	 * @param rootServer
	 * @return
	 * @throws SolrServerException
	 * @throws IOException
	 */
	public static NamedList<Object>  getSolrOneCoreInfo(String coreName,HttpSolrServer rootServer) throws SolrServerException, IOException
	{
		
		NamedList<Object> list = EdenCoreAdminRequest
				       .getStatus(coreName, rootServer)
				       .getCoreStatus()
				       .get(coreName);

		return list;
	}
	
	/**
	 * 添加core,默认
	 * @param newCoreName
	 * @param rootServer
	 * @throws SolrServerException
	 * @throws IOException
	 */
	public static void addCore(String newCoreName,HttpSolrServer rootServer) throws SolrServerException, IOException
	{
		
		
		EdenCoreAdminRequest req = new EdenCoreAdminRequest();
		req.setCoreName(newCoreName);
		req.setEdenAction(EdenCoreAdminAction.ADDNEWCORE);
	
		CoreAdminResponse list = req.process(rootServer);
		int state = list.getStatus();
		if (state != 0) {
			throw new SolrServerException("添加core失败！");
		}

		
	}
	
	
	/**
	 * 添加core
	 * @param newCoreName
	 * @param from 复制的core配置
	 * @throws SolrServerException
	 * @throws IOException
	 */
	public static void addCore(String newCoreName,String from,HttpSolrServer rootServer) throws SolrServerException, IOException
	{
		
		
		EdenCoreAdminRequest req = new EdenCoreAdminRequest();
		req.setCoreName(newCoreName);
		req.setEdenAction(EdenCoreAdminAction.ADDNEWCORE);
		req.setOtherCoreName(from);
		CoreAdminResponse list = req.process(rootServer);
		int state = list.getStatus();
		if (state != 0) {
			throw new SolrServerException("添加core失败！");
		}

		
	}
	
	/**
	 * 获取schema.xml内容
	 * @param coreName
	 * @param rootServer
	 * @return
	 * @throws SolrServerException
	 * @throws IOException
	 */
	public static String getSchemaXmlContent(String coreName,HttpSolrServer rootServer) throws SolrServerException, IOException
	{
		ModifiableSolrParams params = new ModifiableSolrParams();
		params.set("file", "schema.xml");
		params.set("contentType", "text/xml;charset=utf-8");
		EdenCoreAdminRequest req = new EdenCoreAdminRequest();
		req.setPath("/" + coreName + "/admin/file");
		req.setParams(params);
		NamedList<Object> ob = rootServer.request(req, null);
		InputStream respBody = (InputStream) ob.get("stream");
		String con=StringStreamUtil.convertStreamToString(respBody);
				
		return con;
	}
	
	/**
	 * 远程修改schema.xml的内容
	 * @param coreName
	 * @param xmlContent
	 * @param rootServer
	 * @throws SolrServerException
	 * @throws IOException
	 */
	public static void postSchemaXmlContent(String coreName,String xmlContent,HttpSolrServer rootServer) throws SolrServerException, IOException
	{
	
		EdenSchemaUpdateRequest edenSchemaUpdateRequest=new EdenSchemaUpdateRequest("/admin/cores");
	    edenSchemaUpdateRequest.setParam("name", coreName);
	    edenSchemaUpdateRequest.setParam("action", "CHANGESCHEMA");
	    edenSchemaUpdateRequest.setXmlContent(xmlContent);	  
	    UpdateResponse rep=edenSchemaUpdateRequest.process(rootServer);
	    int state =  rep.getStatus();
		if (state != 0) {
			throw new SolrServerException("postSchemaXml失败！");
		}
		
	}
	
	/**
	 * 重新加载core
	 * @param coreName
	 * @param rootServer
	 * @throws SolrServerException
	 * @throws IOException
	 */
	public static void reloadCore(String coreName,HttpSolrServer rootServer) throws SolrServerException, IOException
	{
		CoreAdminRequest req = new CoreAdminRequest();
		req.setAction(CoreAdminAction.RELOAD);
		req.setCoreName(coreName);
		CoreAdminResponse list = req.process(rootServer);
		int state = list.getStatus();
		if (state != 0) {
			throw new SolrServerException("reload失败！");
		}
		
		
	}
	
	/***
	 * 加载core
	 * @param coreName
	 * @param rootServer
	 * @throws SolrServerException
	 * @throws IOException
	 */
	public static void loadCore(String coreName,HttpSolrServer rootServer) throws SolrServerException, IOException
	{
		CoreAdminRequest req = new CoreAdminRequest();
		req.setAction(CoreAdminAction.LOAD);
		req.setCoreName(coreName);
		CoreAdminResponse list = req.process(rootServer);
		int state = list.getStatus();
		if (state != 0) {
			throw new SolrServerException("load失败！");
		}
		
		
	}
	
	/**
	 * 删除core
	 * @param coreName
	 * @param isDeleteDir 是否删除文件夹
	 * @param rootServer
	 * @throws SolrServerException
	 * @throws IOException
	 */
	public static void delCore(String coreName,boolean isDeleteDir,HttpSolrServer rootServer) throws SolrServerException, IOException
	{
		String instanceDir=null;
		if(isDeleteDir)
		{
			NamedList<Object> list = EdenCoreAdminRequest
				       .getStatus(coreName, rootServer)
				       .getCoreStatus()
				       .get(coreName);
			instanceDir=(String) list.get("instanceDir");
		}
		
	
		int state= EdenCoreAdminRequest
			       .delCore(coreName, instanceDir, rootServer)
			       .getStatus();
		if (state != 0) {
			throw new SolrServerException("delCore失败！");
		}
		
		
	}
	
	/**
	 * 两个core交换
	 * @param coreName
	 * @param otherCore
	 * @param rootServer
	 * @throws SolrServerException
	 * @throws IOException
	 */
	public static void swap(String coreName,String otherCore,HttpSolrServer rootServer) throws SolrServerException, IOException
	{
		CoreAdminRequest req = new CoreAdminRequest();
		req.setAction(CoreAdminAction.SWAP);
		req.setCoreName(coreName);
		req.setOtherCoreName(otherCore);
		CoreAdminResponse list = req.process(rootServer);
		int state = list.getStatus();
		if (state != 0) {
			throw new SolrServerException("swap失败！");
		}
		
		
	}
	
	
	public static void main(String[] args) {
		
		HttpSolrServer server = new HttpSolrServer("http://localhost:8082/solr");
		/*try {
			swap("newsss","dddsdd",server);
		} catch (SolrServerException e) {
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		*/
		try {
			delCore( "oa_car5", false, server);
		} catch (SolrServerException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
}

 

 

转载于:https://my.oschina.net/passerman/blog/710362

weixin_34261415
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
solr4二次开发文档
12-20
Solr4.3+Tomcat安装配置及二次开发使用说明 详细介绍各种solrj
solr-solrj-4.9.0.jar
04-15
solr-solrj-4.9.0.jar
php solr 全文检索,全文检索可视化动态管理（二）--solr二次开发和solrj扩展
weixin_33146151的博客
04-05 170
要完成solr的索引动态配置，需要solr提供动态新建、修改配置等的接口。solr虽提供core的添加删除，但不提供schema.xml修改新建接口，并且如果添加一个新core，也要将另一个core的conf配置文件复制一份到新的core文件夹下，然后管理页载入新的core。因此需要二次开发。查看solr的web.xml，可以发现请求链接都进入org.apache.solr.servlet.Sol...
solrj之二次开发
江夏lz的博客
07-11 118
Solrj已经是很强大的solr客户端了。它本身就包装了httpCliet，以完全对象的方式对solr进行交互。很小很好很强大。下面直接上自己封装的主要代码： 1、solrj操作接口   public interface SolrjQuery {         // solrj查询返回SolrDocument记录的集合 public DataGrid&lt;SolrD...
大数据Solr二次开发.pdf
10-14
大数据Solr二次开发.pdf
全文搜索服务器solr之客户端 - solrj二次开发
anzuo_0的专栏
12-02 1969
from http://blog.csdn.net/ssh_kobe/article/details/6768836 Solrj已经是很强大的solr客户端了。它本身就包装了httpCliet，以完全对象的方式对solr进行交互。很小很好很强大。     不过在实际使用中，设置SolrQuery 的过程中，为了设置多个搜索条件和排序规则等等参数，我们往往会陷入并接字符串的地步，实在是很丑陋
solr-solrj-6.1.0
03-12
总的来说，Solr-Solrj 6.1.0是Java开发者连接和操作Solr服务器的强大工具，它使得与Solr的交互变得更加简单和高效，是构建基于Solr的全文检索系统不可或缺的一部分。通过深入理解和使用Solrj，可以更好地发挥Solr在...
solr-solrj-4.10.3.jar和solr-solrj-5.0.0.jar
03-10
这个压缩包包含了两个版本的SolrJ库：solr-solrj-4.10.3.jar和solr-solrj-5.0.0.jar。这两个版本的差异主要在于对Solr服务器的兼容性和功能改进。 首先，solr-solrj-4.10.3.jar是SolrJ的一个较旧版本，对应于Solr ...
人工智能-项目实践-搜索引擎-基于solrj开发solr主从搜索引擎服务的dubbo组件
最新发布
02-26
Solrj是Java客户端库，用于与Solr服务器进行交互，简化了Solr的API调用，使开发者能够方便地进行索引构建、查询和管理操作。 其次，我们要搭建主从复制的Solr集群，这是为了提高服务的可用性和数据的一致性。主节点...
apache-solr-solrj-3.2.0.jar
03-08
jar包，亲测可用
SOLR检索调优
01-10
SOLR 检索调优
solr二次开发之solrj(转载)
Feythin Lau
11-02 222
[size=medium]Solrj已经是很强大的solr客户端了。它本身就包装了httpCliet，以完全对象的方式对solr进行交互。很小很好很强大。 不过在实际使用中，设置SolrQuery 的过程中，为了设置多个搜索条件和排序规则等等参数，我们往往会陷入并接字符串的地步，实在是很丑陋，不符合面向对象的思想。扩展性几乎为0,。基于这点，开发了一个小东西，我们只需要设置搜索对象，将对...
solr之dynamicField动态字段的使用
11-07 8592
业务场景，并不是我们业务的所有字段都需要在schema.xml、managed-schema指定成固定的字段。 、这些都是固定的 例如我现在有一个新业务，大概有5个字段，需要拼接在原来的core里面，那么dynamicField就发挥了它的用武之地了。 直接上代码： schema.xml、managed-schema文件中的配置如下               存放String类型
solr在使用solrj操作中的各个操作大全（在solrcores中测试）
热门推荐
a925907195的专栏
01-07 4万+
package com.fjsh.SearchJobsFirst; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import java.util.GregorianCalendar; import java.util.HashMap; import java.util.I
【Solr 5.1系列】Apache Solr 5.1参考指南（二）动态字段
SuperToJob的专栏
05-23 1998
*****小白一枚，若您有高效的翻译工具，麻烦在评论中推荐给我，万分感谢！***** *****本人技术、翻译水平有限，此译文仅做参考！翻译时没有严格遵循原文思路和表达方式，见谅！***** 英文原文链接：http://archive.apache.org/dist/lucene/solr/ref-guide/apache-solr-ref-guide-5.1.pdf 动态字段Dyn
Solr插件开发
weixin_34234823的博客
11-09 236
2019独角兽企业重金招聘Python工程师标准>>> ...
solr进阶-动态配置管理
qq499526040的博客
12-24 973
solr提供了DIH并集成tika，因此配置db、文档索引都会感觉到非常方便，但是如果你的业务要求你的程序必须能在友好的UI中配置DB导入，程序员刚上来难免一脸蒙逼了。 基于solr的DB导入管理功能的开发首先要解决解决以下三个问题（本篇主要针对2进行介绍）： 1、solr服务的代理调用 2、solr配置文件的远程操作 3、solr配置文件的结构化读写 新增数据库表的导入需要对db-da
CoreAdminHandler 之 CREATE
每天积累一点，一年后你会发现，自己变化很大
12-11 554
CREATE 请求将创建一个新的 core，并注册到 solr 中。如果配置了持久（元素中的 persistent=”true”），这个新 core 的配置将被保存到 solr.xml中。如果名称已存在，旧的 core 在新 core 初始化完成前继续服务，当新的 core 初始化完成后，旧的 core 将被锁定。 http://localhost:8983/solr/admin/c
solr中plugin的扩展
蓝天上，白云飘；茶碗中，加瓦游
01-13 215
  1.    将solr 源文件解压，并且使用开发工具，如：Eclipse 。新建工程，并将源文件以及相关的jar 导入。 2.    在org.apache.solr.handler 包下（一般在此包下进行扩展），新建java 类。 3.    新建的类需要继承RequestHandlerBase 类，并且实现其中的handleRequestBody(SolrQueryRequest re...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值