精华内容
下载资源
问答
  • Solr原理

    万次阅读 2013-03-15 18:00:54
    Solr原理 Solr对外提供标准的http接口来实现对数据的索引的增加、删除、修改、查询。在 Solr 中,用户通过向部署在servlet 容器中的 Solr Web 应用程序发送 HTTP 请求来启动索引和搜索。Solr 接受请求,确定要...
    Solr原理 

    Solr对外提供标准的http接口来实现对数据的索引的增加、删除、修改、查询。在 Solr 中,用户通过向部署在servlet 容器中的 Solr Web 应用程序发送 HTTP 请求来启动索引和搜索。Solr 接受请求,确定要使用的适当SolrRequestHandler,然后处理请求。通过 HTTP 以同样的方式返回响应。默认配置返回Solr 的标准 XML 响应,也可以配置Solr 的备用响应格式


    可以向 Solr 索引 servlet 传递四个不同的索引请求:
    add/update 允许向 Solr 添加文档或更新文档。直到提交后才能搜索到这些添加和更新。
    commit 告诉 Solr,应该使上次提交以来所做的所有更改都可以搜索到。
    optimize 重构 Lucene 的文件以改进搜索性能。索引完成后执行一下优化通常比较好。如果更新比较频繁,则应该在使用率较低的时候安排优化。一个索引无需优化也可以正常地运行。优化是一个耗时较多的过程。
    delete 可以通过 id 或查询来指定。按 id 删除将删除具有指定 id 的文档;按查询删除将删除查询返回的所有文档。

    一个典型的Add请求报文

    <add>  
      <doc>  
        <field name="id">TWINX2048-3200PRO</field>  
        <field name="name">CORSAIR  XMS 2GB (2 x 1GB) 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) Dual Channel Kit System Memory - Retail</field>  
        <field name="manu">Corsair Microsystems Inc.</field>  
        <field name="cat">electronics</field>  
        <field name="cat">memory</field>  
        <field name="features">CAS latency 2, 2-3-3-6 timing, 2.75v, unbuffered, heat-spreader</field>  
        <field name="price">185</field>  
        <field name="popularity">5</field>  
        <field name="inStock">true</field>  
      </doc>  
      <doc>  
        <field name="id">VS1GB400C3</field>  
        <field name="name">CORSAIR ValueSelect 1GB 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) System Memory - Retail</field>  
        <field name="manu">Corsair Microsystems Inc.</field>  
        <field name="cat">electronics</field>  
        <field name="cat">memory</field>  
        <field name="price">74.99</field>  
        <field name="popularity">7</field>  
        <field name="inStock">true</field>  
      </doc>  
    </add> 

    一个典型的搜索结果报文:

    <response>  
        <lst name="responseHeader">  
            <int name="status">0</int>  
            <int name="QTime">6</int>  
            <lst name="params">  
                <str name="rows">10</str>  
                <str name="start">0</str>  
                <str name="fl">*,score</str>  
                <str name="hl">true</str>  
                <str name="q">content:"faceted browsing"</str>  
            </lst>  
        </lst>  
      
        <result name="response" numFound="1" start="0" maxScore="1.058217">  
            <doc>  
                <float name="score">1.058217</float>  
                <arr name="all">  
                    <str>http://localhost/myBlog/solr-rocks-again.html</str>  
                    <str>Solr is Great</str>  
                    <str>solr,lucene,enterprise,search,greatness</str>  
                    <str>Solr has some really great features, like faceted browsing and replication</str>  
                </arr>  
                <arr name="content">  
                    <str>Solr has some really great features, like faceted browsing and replication</str>  
                </arr>  
                <date name="creationDate">2007-01-07T05:04:00.000Z</date>  
                <arr name="keywords">  
                    <str>solr,lucene,enterprise,search,greatness</str>  
                </arr>  
                <int name="rating">8</int>  
                <str name="title">Solr is Great</str>  
                <str name="url">http://localhost/myBlog/solr-rocks-again.html</str>  
            </doc>  
        </result>  
      
        <lst name="highlighting">  
            <lst name="http://localhost/myBlog/solr-rocks-again.html">  
                <arr name="content">  
                    <str>Solr has some really great features, like <em>faceted</em>  
                    <em>browsing</em> and replication</str>  
                </arr>  
            </lst>  
        </lst>  
    </response> 

    关于solr的详细使用说明,请参考
    http://wiki.apache.org/solr/FrontPage


    展开全文
  • solr原理

    2014-08-17 17:42:00
    1.solr原理: 我本人的理解:solr是为解决高性能的全文索引而出现的,它将用户输入的关键字进行智能分解,分解成一个个词,过滤掉一些多余的停词及空格等,比如,“在”、“里面”、“也”、“的”、“它”、“为...

    1.solr原理:

    我本人的理解:solr是为解决高性能的全文索引而出现的,它将用户输入的关键字进行智能分解,分解成一个个词,过滤掉一些多余的停词及空格等,比如,“在”、“里面”、“也”、“的”、“它”、“为”这些词都是停止词。这些词因为使用频率过高,几乎 每个网页上都存在,所以搜索引擎开发人员都将这一类词语全部忽略掉。如果我们的网站上存在大量这样的词语,那么相当于浪费了很多资源。然后将分解之后的词去建好的solr索引的字段中根据词的比重逐一进行匹配,最后将符合条件的数据返回给用户。

    2.分词原理:

    建立索引和查询的过程中,都是以基本的语素项为单位的。基本的语素项就是通过分词得到。这个过程决定了索引单元金额最终的匹配过程。 
    分词在文本索引的建立过程和用户提交检索过程中都存在。利用相同的分词器,把短语或者句子切分成相同的结果,才能保证检索过程顺利进行。 
    1、 英文分词的原理 
    基本的处理流程是:输入文本、词汇分割、词汇过滤(去除停留词)、词干提取(形态还原)、大写转为小写、结果输出。 
    2、 中文分词原理 
    中文分词比较复杂,并没有英文分词那么简单。这主要是因为中文的词与词之间并不像英文中那样用空格来隔开。
    主要的方法有三种:基于词典匹配的分词方法、基于语义理解的分词、基于词频统计的分词。
    View Code
    
    

    3.Lucene:分词器和索引文件

    目录
    
    分词器
    索引文件结构
    常用的中文分词器
     
    
     
    
    1、分词器
    
    分词器,对文本资源进行切分,将字符文本串按照一定的规则切分为一个个可以进行索引的最小单位(关键词),以便检索时使用。
    
    
    
    建立索引和进行检索时都要用到分词器。为了保证能正确的检索到结果,在建立索引与进行检索时使用的分词器应是同一个。   
    
     
    
    2、索引文件结构
    
    索引库是一组索引文件的集合。
    
    
    
    索引文件的检索:索引表规模相对较小,文档集合规模较大。进行检索时,先从检索索引表开始,然后找到相对应的文档。如果查询中仅包含一个关键词,则在索引表中找到该关键词,并取出它所对应的文档就可以了。如果查询中包含多个关键词,则需要将各个关键字检索出的文档记录进行合并。
     
    
    索引文件的维护:维护索引常使用三个操作:插入、删除和更新文档。但是更新操作需要较高的代价,因为文档修改后(即使是很小的修改),也可以造成文档中的很多的关键词的位置发生了变化,这时需要频繁的读取和修改记录,这种代价是相当高的。因此,一般不进行更新操作,而是使用“先删除,后创建”的方式代替更新操作。
    
     
    
    3、常用的中文分词器
    
    ik-analyzer:IK Analyzer是一个开源的,基于java语言开发的轻量级的中文分词工具包。从2006年12月推出1.0版开始, IKAnalyzer已经推出了4个大版本。最初,它是以开源项目Luence为应用主体的,结合词典分词和文法分析算法的中文分词组件。从3.0版本开始,IK发展为面向Java的公用分词组件,独立于Lucene项目,同时提供了对Lucene的默认优化实现。在2012版本中,IK实现了简单的分词歧义排除算法,标志着IK分词器从单纯的词典分词向模拟语义分词衍化。
    Ansj:Ansj中文分词是一款纯Java的主要应用于自然语言处理的高精度的中文分词。追求的目标是--准确-高效-自由。包括:中文分词、人名识别、地名识别、组织机构名识别、多级词性标注、关键词提取、指纹提取支持行业词典、用户自定义词典。Ansj 是基于中科院的 ictclas 中文分词算法,比其他常用的开源分词工具(如mmseg4j)的分词准确率更高。
    在线演示:http://ansj.sdapp.cn/demo/seg.jsp
    官网地址:http://www.ansj.org/
    Github地址:https://github.com/ansjsun/ansj_seg
    mmseg4j:用 Chih-Hao Tsai 的 MMSeg 算法(http://technology.chtsai.org/mmseg/)实现的中文分词器,并实现 lucene 的 analyzer 和 solr 的TokenizerFactory 以方便在Lucene和Solr中使用。MMSeg 算法有两种分词方法:Simple和Complex,都是基于正向最大匹配。Complex 加了四个规则过虑。官方说:词语的正确识别率达到了 98.41%。mmseg4j 已经实现了这两种分词算法。
    imdict-chinese-analyzer:imdict-chinese-analyzer 是 imdict智能词典 的智能中文分词模块,算法基于隐马尔科夫模型(Hidden Markov Model, HMM),是中国科学院计算技术研究所的ictclas中文分词程序的重新实现(基于Java),可以直接为lucene搜索引擎提供简体中文分词支持。
    ictclas4j:ICTCLAS4j中文分词系统是sinboy在中科院张华平和刘群老师的研制的FreeICTCLAS的基础上完成的一个java开源分词项目,简化了原分词程序的复杂度,旨在为广大的中文分词爱好者一个更好的学习机会。关于ICTCLAS分词系统的讨论,请访问google group关于ictclas分词系统的讨论组http://groups.google.com/group/ictclas
    ICTCLAS汉语分词系:http://ictclas.org/
    View Code

    4.solr的配置文件:

    (1)solr.xml
        与整个搜索引擎相关的配置。
    (2)solrconfig.xml。
        与某个core相关的主要配置,如定义updatehandler用于索引文件,requesthandler用于搜索内容等。
    (3)schema.xml
        定义了某类型文档的索引格式。

     

     

     

    转载于:https://www.cnblogs.com/zrp2013/p/3918024.html

    展开全文
  • solr原理分析.xmind

    2019-07-12 19:51:10
    【图解版】solr原理分析,从全文检索到solr原理分析,并对出现的问题进行分析解答,不可用于商业用途,如有版权问题,请联系删除!
  • lucene&solr原理分析

    2014-01-04 21:16:14
    lucene&solr原理分析,lucene搜索引擎和solr搜索服务器原理分析。
  • Solr 原理、API 使用

    千次阅读 2019-05-08 17:25:26
    搜索引擎:Elasticsearch、Solr、Lucene ELK中的ES:Elasticsearch SolrCloud 的搭建、使用 ... Solr 原理、API 使用 Lucene 原理、API使用 Lucene 得分算法 Solr的概述 1.Solr的下载: 官网:http://luce...

    日萌社

    人工智能AI:Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战(不定时更新)


     

    搜索引擎:Elasticsearch、Solr、Lucene


    Solr的概述

    1.Solr的下载:
    	官网:http://lucene.apache.org
    	历史版本下载网址:http://archive.apache.org/dist/lucene/solr/
    
    2.Solr的安装:
    	右键解压到当前文件夹即可,注意:解压的目录中一定不要中文和空格。
    

    Solr的的目录结构

    1.我们最需要关注的就是:example目录。其中就有搭建Solr服务的详细案例。
    2.启动Solr的jar包:需要使用内置的Jetty服务。Jetty是一个WEB容器。
    3.Solr目录:包含全文检索要存储的索引数据以及相关的一些配置文件。
    4.solr-webapp和webapps:其实包含的是一样的内容,都是Solr的内置Web应用,我们可以通过Http请求访问该应用,实现对Solr服务的管理和访问
    5.start.jar包:web应用需要一个Web容器来启动,而这个jar包会使用一个叫做Jetty的WEB容器(类似与Tomcat),来启动Solr的Web服务。
    

    启动Solr的

    第一种方式:码头服务器启动的Solr

    步骤:
    	1.第一步:进入 \solr-4.10.2\example 目录,该目录下存在“start.jar”用于 Jetty服务器启动Solr
    	2.第二步:打开命令行窗口,执行“java –jar start.jar”命令,即可启动Solr服务
    	3.第三步:打开浏览器,通过“http://localhost:8983/solr”来访问Solr管理页面。(Jetty服务的默认端口是8983)
    

    第二种方式:Tomcat的服务器启动

    步骤:
    	1.第一步:部署Web服务。
    		  1.将 \solr-4.10.2\example\webapps目录下的“solr.war”拷贝到自己的 \apache-tomcat-8.5.16\webapps目录中。
    		  2.两种方式解压“solr.war”:
    			第一种解压方式:直接右键解压“solr.war”
    			第二种解压方式:运行\apache-tomcat-8.5.16\bin目录下的“startup.bat”,便会自动解压webapps目录中的“solr.war”
    		  3.解压完毕后可以删除“solr.war”。
    		    注意:如果是使用第二种解压方式启动了“startup.bat”的话,则必须先执行“shutdown.bat”关闭Tomcat之后,才能再删除“solr.war”,
    			  否则在删除“solr.war”时,会连解压后的目录也一起删除的
    
    	2.第二步:
    		1.将“\资料\solr在tomcat运行需要导入的jar包\classes”文件夹下的“log4j.properties”拷贝到“\apache-tomcat-8.5.16\webapps\solr\WEB-INF”目录下
    		2.将“\资料\solr在tomcat运行需要导入的jar包\lib”文件夹下的jar包拷贝到“\apache-tomcat-8.5.16\webapps\solr\WEB-INF\lib”目录下

    	3.第三步:
    		1.将“\solr-4.10.2\example”目录下的(索引库)“solr”文件夹 拷贝到 不带中文/空格的目录下。比如说拷贝到“E:\solr”(索引库)。
    		2.到“\apache-tomcat-8.5.16\bin”目录下,编辑“catalina.bat”文件。
    		  在“catalina.bat”文件中的第一行处添加一条配置信息,用于指向我们的索引库及配置目录:set "JAVA_OPTS=-Dsolr.solr.home=E:/solr"

    		3.到“\apache-tomcat-8.5.16\webapps\solr\WEB-INF”下 编辑“web.xml”文件,编辑如下:

    	4.第四步:
    		1.运行\apache-tomcat-8.5.16\bin目录下的“startup.bat”
    		2.打开浏览器,访问 http://localhost:8080/solr 进入Solr管理页面
    

    Solr的教学文档

    2.1、启动Solr服务的方式
    2.1.1、方式一,Jetty服务器启动Solr(了解)
    步骤:
    1)进入solr-4.10.2/example目录
    2)打开命令行,执行java –jar start.jar命令,即可启动Solr服务
    3)打开浏览器,通过http://localhost:8983/solr来访问Solr管理页面。(Jetty服务的默认端口是8983)

    2.1.2、方式二,Tomcat服务器启动
    步骤:
    1)部署Web服务,将solr-4.10.2/example/webapps/solr.war复制到自己的tomcat/webapps目录中,并解压,然后删除solr.war文件

    2)在Tomcat中加入相关jar包:将“resource\solr在tomcat运行需要导入的jar包\lib”下的jar包复制tomcat/webapps/solr/WEB-INF/lib下。
    并且把class/log4j.properties复制到tomcat/webapps/solr/WEB-INF下

    3)修改Tomcat配置文件,指向Solr的索引库及配置目录。
    注意,这里可以指向solr-4.10.2/example/solr目录,如果想独立出来,也可以将这个solr文件夹复制出来到任意位置(不要出现中文),例如:例如:C:/tmp/solr
    		我们这里就把这个文件夹复制出来,独立使用

    		进入Tomcat文件夹,用记事本打开:tomcat/bin/catalina.bat文件

    		添加一条配置信息,指向我们的索引库及配置目录:set "JAVA_OPTS=-Dsolr.solr.home=C:/tmp/solr"

    4)进入tomcat/bin目录,双击 startup.bat文件启动服务器

    5)打开浏览器,访问 http://localhost:8080/solr 进入Solr管理页面
    


    第一种启动方式:java -jar start.jar


    Solr的管理页面

     

    面板(仪表盘)

     

    日志(日志)

     

    核心管理员(核心管理)

    在Solr中,每一个Core,代表一个索引库,里面包含索引数据及其配置信息。 Solr中可以拥有多个Core,也就同时管理多个索引库!就像在MySQL中可以有多个database一样!

     

    默认核心的目录

     

    JavaProperties和ThreadDump

     


    管理索引库的控制台

     


    CoreSelector(核心选择器)


    核心的配置文件详解

    1.Core的配置文件详解:
    	1.core.properties
    	2.schemal.xml
    	3.solrconfig.xml
    
    2.core.properties 的作用:
    	Core的属性文件,记录当前core的名称、索引位置、配置文件名称等信息,也可以不写。
    	一般要求Core名称跟Core的文件夹名称一致!这里都是collection1,我们可以手动修改这个属性,把Core的名字改成我们喜欢的。
    


    添加多个核心

     

    1.在solr的目录下创建新的文件夹的Core2,作为新的核心目录

    2)在核2下创建的conf目录和数据目录,并且创建文件core.properties,添加属性:名称= core2的

    3)从核心-1 / CONF目录下复制配置文件的Core2 / CONF /下  

    4)重启的Tomcat,访问管理页面

     



    schema.xml中配置详解

    <?xml version="1.0" encoding="UTF-8" ?>
    <schema name="example" version="1.5">
     
    	<!-- "_version_" 和 "_root_" 不能删--> 
    	<field name="_version_" type="long" indexed="true" stored="true"/>
    	<field name="_root_" type="string" indexed="true" stored="false"/>
    
       	<!-- 唯一键id:必须是 type="string"。
    		indexed="true" 创建索引。stored="true" 存储。multiValued="false" 该字段不能有多个值。 -->   
       	<field name="id" type="string" indexed="true" stored="true" required="true" multiValued="false" /> 
            
      	<field name="age" type="long" indexed="true" stored="true"/>
       	<field name="name" type="string" indexed="true" stored="true"/>
    
    	<!--  使用IK分词器(中文分词器):type="text_ik" 关联  <fieldType name="text_ik" >--> 
       	<field name="title" type="text_ik" indexed="true" stored="true"/>
     
       	<!--"text"字段是solrconfig.xml中默认定义的默认搜索字段,由solrconfig.xml中的这一句话来定义:<str name="df">text</str>。
    	    如果删除不使用"text"字段的话,那么也必须修改solrconfig.xml的默认搜索字段。 -->
       	<field name="text" type="text_ik" indexed="true" stored="true" multiValued="true"/>
    
       	<!-- 当新插入的字段名 并没有在schema.xml所定义的话,但只要符合以下规则,照样可以保存该字段名和字段值数据:
    		 新插入字段名的末尾字符 符合“<dynamicField name=“*_s”>规定的”后缀名/末尾字符 为“_s”的话,
    		 那么就能动态插入该字段名和字段值数据。 -->    
       	<dynamicField name="*_s"  type="string"  indexed="true"  stored="true" />
       
    	<!-- 唯一主键 --> 
     	<uniqueKey>id</uniqueKey>
    
    	<!--1.<copyField source=“普通字段名” dest=“复制域字段名text”>:表示把普通字段名 关联到 复制域字段“text”中。
    	    2.此处表示把"title"字段 和 "name"字段 关联到"text"字段,那么当查询时,默认把 "title"字段的值 和 "name"字段的值 
    	      赋值给"text"字段。
    	    3.当不指定查询字段时,默认查询"text"字段,也即相当于查询"text"字段所关联的 "title"字段的值 和 "name"字段的值 -->
       	<copyField source="title" dest="text"/>
       	<copyField source="name" dest="text"/>
      
        	<fieldType name="string" class="solr.StrField" sortMissingLast="true" />
        	<fieldType name="long" class="solr.TrieLongField" precisionStep="0" positionIncrementGap="0"/> 
    
    	<!-- 定义了IK中文分词器,那么只要有字段中使用type="text_ik" 关联  <fieldType name="text_ik" >,那么该字段既可以进行中文分词 --> 
    	<fieldType name="text_ik" class="solr.TextField">
    		<analyzer class="org.wltea.analyzer.lucene.IKAnalyzer"/>
    	 </fieldType>
    </schema>
    
    

    Solr中会提前对文档中的字段进行定义,并且在schema.xml中对这些字段的属性进行约束,
    例如:字段数据类型、字段是否索引、是否存储、是否分词等等。
    
    1.通过Field字段定义字段的属性信息:

    	1.属性及含义:
    		name:字段名称,最好以下划线或者字母开头
    		type:字段类型,指向的是本文件中的<fieldType>标签
    		indexed:是否创建索引
    		stored:是否被存储
    		multiValued:是否可以有多个值,如果字段可以有多个值,设置为true
    
    	2.注意:在本文件中,有两个字段是Solr自带的字段,绝对不要删除:_version_节点和_root_节点

    2)通过FieldType指定数据类型

    		1.<fieldType name="" class="">
    			1.name:字段类型的名称,可以是系统定义的数据类型,也可以是自定义的类型。
    				<field type="">标签的type属性则负责引用<fieldType name="">中的name值,用于来指定数据类型或自定义的类型。
    			2.class:字段类型在Solr中的类。
    				  class="solr.StrField":字段自动创建索引,但不会进行分词。
    				  class="solr.TextField":字段自动创建索引,并且自动进行分词,因此必须指定分词器,比如中文分词器(IK分词器)。
     
    		2.<analyzer>:在<fieldType>标签体中 使用 <analyzer>子标签 用来指定分词器,比如中文分词器(IK分词器)。
     
    3)唯一主键
    	Lucene中本来是没有主键的。删除和修改都需要根据词条进行匹配。
    	而Solr却可以设置一个字段为唯一主键,这样删改操作都可以根据主键来进行!

    4)动态字段



    Solr的中的修改:本质是先删除,再插入新的数据


    动态域(动态产生域):动态插入字段名和字段值

    动态插入字段名和字段值的规则:
    	只要插入字段名的末尾字符 符合“<dynamicField name=“*_s”>规定的”后缀名/末尾字符为_s的话,
    	那么就能动态插入字段名和字段值。
    


    复制域:“文本”字段

    复制域的用法:
    	1.首先在schema.xml中配置把其他字段关联到“text”字段。
    	2.上图分别有两个普通字段<field name=“字段名name”>、<field name=“字段名title”>,	
    	  和 一个复制域字段<field name=“复制域字段名text”>;
    	  使用<copyField source=“普通字段名” dest=“复制域字段名text”>:表示把普通字段名 关联到 复制域字段“text”中。
    	3.作用:
    		1.普通字段名 关联到 复制域字段“text”之后,便能自动把所关联的普通字段的值 赋值给 复制域字段“text”中。
    		2.在查询时不指定要查询的具体字段的话,默认使用复制域字段“text”来作为查询字段,
    		  因为在\solr\collection1\conf\solrconfig.xml中配置了<str name="df">text</str>。
    		  因为会自动把所关联的普通字段的值 赋值给 复制域字段“text”,所以当默认使用复制域字段“text”来作为查询字段进行查询时,
    		  相当于查询复制域字段“text”所关联的普通字段的值。
    

    在插入数据时无需给“text”字段插入数据,而在查询时,自动把“title”和“name”的数据作为“text”字段的数据。
    因为schema.xml中配置了“text”字段指定关联了“title”和“name”字段。
    

     


    IK分词器(中文分词器)

    1.引入IK分词器的jar包
    		<!-- 引入IK分词器 -->
    		<dependency>
    			<groupId>com.janeluo</groupId>
    			<artifactId>ikanalyzer</artifactId>
    			<version>2012_u6</version>
    		</dependency>
    
    2.下面三个配置文件 拷贝到 Tomcat根目录下的\webapps\solr\WEB-INF\classes 文件中
    

    3.在schemal.xml中自定义fieldType,引入IK分词器

     	<fieldType name="text_ik" class="solr.TextField">
    		<analyzer class="org.wltea.analyzer.lucene.IKAnalyzer"/>
    	</fieldType>
    
    4.让字段使用我们的自定义数据类型,引入IK分词器

    5.可以正确分词了:


    自定义字段的数据类型:定义有IK分词器(中文分词器)

    <field type="text_ik">标签的type属性则负责引用<fieldType name="text_ik">中的name值,用于来指定数据类型或自定义的类型。
    该字段使用到“带有IK分词器的”字段类型,那么该字段“title”就能分词了。
    如果字段不使用“带有IK分词器的”字段类型,而使用string类型声明(type=string)的话,是无法中文分词的。
    


    solrconfig.xml中

    这个配置文件主要配置跟索引库和请求处理相关的配置。
    solr服务的优化主要通过这个配置文件进行。
    

    <LIB />标签

    1.用途:配置插件依赖的jar包
    2.注意事项:
    	如果引入多个jar包,要注意包和包的依赖关系,被依赖的包配置在前面
    	这里的jar包目录如果是相对路径,那么是相对于core所在目录。
    
    3.例如 在配置文件中默认有以下配置:这些是Solr中插件所依赖的Jar包

    4.这里的相对路径其实是相对于 core所在目录。
      我们把所引来的Jar包复制到solr的HOME中:

      然后修改配置文件:

      效果:
    


    处理日志中的警告信息

    该警告信息:表示索引库目录(E:\solr\collection1\conf)下找不到contrib和dist文件夹。
    解决:
    	1.第一步:把“\solr-4.10.2”目录下的contrib和dist文件夹 拷贝到 索引库目录(E:\solr\collection1\conf)下即可。
    	2.第二步:修改“E:\solr\collection1\conf”下的solrconfig.xml文件:将“../../../”修改为“../”。
    

    索引库目录:E:\ Solr的\ collection1 \的conf目录下的solrconfig.xml中

    修改“E:\ Solr的\ collection1 \的conf”下的solrconfig.xml中文件:将“../../../”修改为“../”

    最终修改为“../”

    1.到\apache-tomcat-8.5.16\bin目录下,先执行“shutdown.bat”停止Tomcat,再执行“startup.bat”启动Tomcat
    2.打开浏览器,访问 http://localhost:8080/solr 进入Solr管理页面
    


    <requestHandler />标签

    1.用途:配置Solr处理各种请求(搜索/select、更新索引/update、等)的各种参数
    2.主要参数:
    	name:请求类型,例如:select、query、get、update
    	class:处理请求的类
    	initParams:可选。引用<initParams>标签中的配置
    	<lst name="defaults">:定义各种缺省的配置,比如缺省的parser、缺省返回条数
    
    3.例子:负责搜索请求的Handler

    	1.<int name="rows">10</int>:
    		不进行分页查询的话,默认只查询出10条数据
    
    	2.<str name="df">text</str>:
    		1.在查询时不指定要查询的具体字段的话,默认使用复制域字段“text”来作为查询字段,
    		  因为会自动把所关联的普通字段的值 赋值给 复制域字段“text”,所以当默认使用复制域字段“text”来作为查询字段进行查询时,
    		  相当于查询复制域字段“text”所关联的普通字段的值。
    		2.<str name="df">默认搜索的字段</str> 默认设置为:text。我们可以设置为title:
    


    <initParams在/>标签

    1.用途:为一些requestHandlers定义通用的配置,以便在一个地方修改后,所有地方都生效
    2.主要参数:
    	path:指明该配置应用于哪些请求路径,多个 的话用逗号分开,可以用通配符(*表示一层子路径,**表示无限层)
    	name:如果不指定path,可以指定一个name,然后在<requestHander>配置中可以引用这个name
    3.例子(配置一个缺省的df): 
    	<initParams path="/update/**,/query,/select,/tvrh,/elevate,/spell,/browse">    	
    		<lst name="defaults">      
    			<str name="df">_text_</str>    
    		</lst>  
    	</initParams>
      如果配置name,在<requestHander>中引用的例子:<requestHandler name="/dump1" class="DumpRequestHandler"  initParams="myParams"/>
    

    <updateHandler />标签

    1.用途:定义一些更新索引相关的参数,比如定义commit的时机
    2.主要参数:
    	autoCommit:定义自动commit的触发条件。如果没配置这个参数,则每次都必须手动commit
    		maxDocs
    		maxTime(毫秒)
    		penSearcher:autoCommit结束后,是否开启一个新的searcher让更改生效。缺省为false
    	autoSoftCommit:定义自动softCommit的触发条件。相关参数同autoCommit
    	listener:配置事件监听器
    		event:监听哪个事件,比如:event="postCommit", event="postOptimize"
    		class:处理的类,可以是自己的实现类。如果是RunExecutableListener,可以配置下面的参数:
    			exe:可执行文件,包括Solr Home的相对路径和文件名
    			dir:工作目录,缺省是“.”
    			wait: 调用者是否等待可执行文件执行结束,缺省是true
    			args:传递给可执行文件的参数
    			env:其他所需要的环境变量
    	updateLog:配置log的保存路径、等
    		dir:保存路径
    		numRecordsToKeep:一个log保存的记录数,缺省为100
    		maxNumLogsToKeep:log的数量,缺省为10
    		numversionBuckets:追踪max version的bucket数量(?),缺省为65535
    
    	配置这些参数要考虑到搜索的准确度和性能的平衡。^_^
    	注:commit和softCommit:
    		commit:正式提交、对索引的修改会被保存到永久存储中(比如磁盘),会比较耗时
    		softCommit:软提交,对索引的修改会被立即应用到工作中的索引中,即立即生效,但没有保存进磁盘
    

    <查询/>标签

    1.用途:配置Solr如何处理和返回搜索的相关参数
    2.主要参数:
    	filterCache:当搜索带有“fq”参数时,使用这个配置,它保存未经过排序的所有文档
    		class:实现类,有三种:solr.search.LRUCache, solr.search.FastLRUCache, solr.search.LFUCache
    		size:最大保存的记录数量
    		initialSize:初始数量
    		autowarmCount:新Index Searcher启动的时候从旧的Index Searcher缓存拷贝过来的数据量
    	queryResultCache:存储最终的搜索结果(排序后的、有范围的文档id)
    		class:实现类,有三种:solr.search.LRUCache, solr.search.FastLRUCache, solr.search.LFUCache
    		size:最大保存的记录数量
    		initialSize:初始数量
    		autowarmCount:新Index Searcher启动的时候从旧的Index Searcher缓存拷贝过来的数据量
    		maxRamMB:最大分配的容量(兆)
    	documentCache:缓存Lucene Document对象(就是每个文档的fields)
    		class:实现类,有三种:solr.search.LRUCache, solr.search.FastLRUCache, solr.search.LFUCache
    		size:最大保存的记录数量
    		initialSize:初始数量
    		autowarmCount:因为Lucene的内部文档 id 是临时的,所以这个缓存不应该被auto-warm,这个值应该为“0”
    	cache:配置自定义的缓存,通过SolrIndexSearcher类的getCache()方法和name参数调用这个缓存
    		name:被调用时的标识
    		其他参数同上
    	maxBooleanClauses:BooleanQuery的最大子句数量
    	enableLazyFieldLoading:没有知道被请求的field是否懒加载,true/false
    	useFilterForSortedQuery:如果不是按照score排序,是否从filterCache中获取数据
    	queryResultWindowsize:配合queryResultCache使用,缓存一个超集。如果搜索请求第10到19条记录,而这个参数是50,那么会缓存0到49条记录
    	queryResultMaxDocsCached:queryResultCache缓存的最大文档数量
    	useColdSearcher:但一个新searcher正在warm-up的时候,新请求是使用旧是searcher(true)还是等待新的search(false)
    	maxWarmingSearchers:定义同时在warn-up的searcher的最大数量
    	listener:监听一些事件并指定处理的类,比如在solr启动时加载一些数据到缓存中,相关参数:
    		event:被监听的事件,比如:firstSearcher是第一个searcher启动、也就是solr启动的事件,newSearcher是当已经有searcher在运行的时候有新searcher启动的事件
    		class:处理类
    		name:="queries"就是需要处理的是query
    		lst, name:针对哪些搜索条件需要处理
    

    <RequestDispatcher的/>标签

    1.用途:控制Solr HTTP RequestDispatche r响应请求的方式,比如:是否处理/select url、是否支持对流的处理、
    	上传文件的大小、如何处理带有cache头的HTTP请求、等等
    2.主要参数:
    	handleSelect:true/false,如果是false,则由requestHandler来处理/select请求。因为现在的requestHandler中/select是标配,所以这里应该填false
    	requestParsers:
    		enableRemoteStreaming:是否接受流格式的内容,缺省为ture
    		multipartUploadLimitInKB:multi-part POST请求,上传文件的大小上限(K)
    		formdataUploadLimitInKB:HTTP POST的form data大小上限(K)
    		addHttpRequestToContext:原始的HttpServletRequest对象是否应该被包含在SolrQueryRequest的httpRequest中……一般自定义的插件使用这个参数……
    	httpCaching:如何处理带有cache control头的HTTP请求
    		nerver304:如果设为true(开发阶段),则就算所请求的内容没被修改,也不会返回304,并且下面两个参数会失效
    		lastModFrom:最后修改时间的计算方式,openTime:Searcher启动的时刻;dirLastMod:索引更新的时刻
    		etagSeed:HTTP返回的ETag头内容
    		cacheControl:HTTP返回的Cache-Control头内容
    

    <updateProcessor />和<updateProcessorChain />标签

    1.用途:配置处理update请求的处理器、处理器链。如果不配置的话,Solr会使用缺省的三个处理器:
    	LogUpdateProcessorFactory:追踪和记录日志
    	DistributedUpdateProcessorFactory:分流update请求到不同的node,比如SolrCloud的情况下把请求分配给一个shard的leader,然后把更新应用到所有replica中
    	RunUpdateProcessorFactory:调用Solr的内部API执行update操作
    2.如果需要自定义update处理器:
    	updateProcessor:
    		class:负责处理的类
    		name:名字,给updateProcessorChain引用是使用
    	updateProcessorChain:
    		name:自己的名字标记
    		processor:指定updateProcessor的name,多个的话用逗号“,”分开
    

    SolrJ的使用(用于操作的Solr)

    pom.xml中添加依赖:
    	<dependencies>
    		<!-- Junit单元测试 -->
    		<dependency>
    			<groupId>junit</groupId>
    			<artifactId>junit</artifactId>
    			<version>4.12</version>
    		</dependency>
    		<dependency>
    			<groupId>org.apache.solr</groupId>
    			<artifactId>solr-solrj</artifactId>
    			<version>4.10.2</version>
    		</dependency>
    		<!-- Solr底层会使用到slf4j日志系统 -->
    		<dependency>
    			<groupId>org.slf4j</groupId>
    			<artifactId>slf4j-log4j12</artifactId>
    			<version>1.7.22</version>
    		</dependency>
    		<dependency>
    			<groupId>commons-logging</groupId>
    			<artifactId>commons-logging</artifactId>
    			<version>1.2</version>
    		</dependency>
    	</dependencies>
    	<build>
    		<plugins>
    			<!-- java编译插件 -->
    			<plugin>
    				<groupId>org.apache.maven.plugins</groupId>
    				<artifactId>maven-compiler-plugin</artifactId>
    				<version>3.2</version>
    				<configuration>
    					<source>1.7</source>
    					<target>1.7</target>
    					<encoding>UTF-8</encoding>
    				</configuration>
    			</plugin>
    		</plugins>
    	</build>
    
    1.添加数据到solr中的某个core(数据库)中
    	//当前处于java程序,solr core交由tomcat启动的solr服务器管理
    	//solr对外提供接口,用户通过http请求调用接口,进行数据的CRUD
    	@Test
    	public void addDateToSolr() throws SolrServerException, IOException
    	{
    		// URL为http://localhost:8080/solr项目名/core的名字
    		String url = "http://localhost:8080/solr/core2";
    		//solrj连接对象:连接到solr中的某个core(数据库)中,然后可以往该core(数据库)中对数据进行增删查改
    		HttpSolrServer server = new HttpSolrServer(url);
    
    		//数据封装对象: SolrInputDocument
    		SolrInputDocument document = new SolrInputDocument();
    		// 新增数据:SolrInputDocument数据封装对象 提供了addField("字段名称", "字段值")设置数据
    		document.addField("id", 2);
    		document.addField("name", "solr");
    		document.addField("age", 27L);
    		document.addField("title", "solr是独立的企业级搜索服务器");
    
    		//第一种保存方式:单个SolrInputDocument 插入保存
    		//server.add(document);
    		//第二种保存方式:批量多个SolrInputDocument 插入保存
    		List<SolrInputDocument> list = new ArrayList<SolrInputDocument>();
    		list.add(document);
    		//批量添加数据
    		server.add(list);
    		//提交数据
    		server.commit();
    	}
    
    2.使用javaBean向solr中的某个core(数据库)中添加数据
    	//使用注解:先定义JavaBean对象中的字段 和 core(数据库)中的字段名 相关联
    	public class User 
    	{
    		//@Field("core中的字段名"):使用 @Field注解显示声明javaBean中属性所对应的solr中的core(数据库)中的字段名
    		@Field("id")
    		private String id;
    		@Field("name")
    		private String name;
    		@Field("title")
    		private String title;
    		@Field("age")
    		private Long age;
    	}
    
    	@Test
    	public void addJavaBeanToSolrCore() throws IOException, SolrServerException
    	{
    		// URL为http://localhost:8080/solr项目名/core的名字
    		String url = "http://localhost:8080/solr/core2";
    		//solrj连接对象:连接到solr中的某个core(数据库)中,然后可以往该core(数据库)中对数据进行增删查改
    		HttpSolrServer server = new HttpSolrServer(url);
    		//同时新增多条数据,批量多条数据插入保存
    		List<User> list = new ArrayList<User>();
    		for(int i = 3;i<30;i++)
    		{
    			User user = new User();
    			user.setId(""+i);
    			user.setName("程序员"+i+"号");
    			user.setAge(Long.valueOf(""+i));
    			user.setTitle("机智聪明勤奋工程师"+i);
    			list.add(user);
    		}
    		
    		//第一种保存方式:直接插入保存单个javaBean对象,添加单条数据
    		//server.addBean(user);
    	
    		//第二种保存方式:批量插入保存多个javaBean对象,添加多条数据
    		server.addBeans(list);
    		//提交
    		server.commit();
    		
    	}
    
    
    3.修改/更新solr中的某个core(数据库)中的数据
    	//solr中并没有更新数据的方法,没有更新这个概念。
    	//通过唯一字段来判断:schema.xml中定义了uniqueKey,uniqueKey就是唯一字段。
    	//如果新增数据的唯一键已经存在,新增时会直接全覆盖,即存在的话便便先删除原来的数据再增加新的数据。
    	//如果新增数据时唯一键不存在,直接新增。
     
    	@Test
    	public void updateSolrCore() throws IOException, SolrServerException
    	{
    		// URL为http://localhost:8080/solr项目名/core的名字
    		String url = "http://localhost:8080/solr/core2";
    		//solrj连接对象:连接到solr中的某个core(数据库)中,然后可以往该core(数据库)中对数据进行增删查改
    		HttpSolrServer server = new HttpSolrServer(url);
    			
    		//使用JavaBean对象封装数据
    		User user = new User();
    		user.setId("7");
    		user.setName("典韦");
    		user.setTitle("勇战士典韦");
    
    		//直接插入保存单个javaBean对象,添加单条数据
    		server.addBean(user);
    		server.commit();
    	}
    
    4.删除solr中的某个core(数据库)中的数据
    
    	//根据id删除对应的数据
    	@Test
    	public void deleteById() throws SolrServerException, IOException
    	{
    		// URL为http://localhost:8080/solr项目名/core的名字
    		String url = "http://localhost:8080/solr/core2";
    		//solrj连接对象:连接到solr中的某个core(数据库)中,然后可以往该core(数据库)中对数据进行增删查改
    		HttpSolrServer server = new HttpSolrServer(url);
    		//根据id删除对应的数据
    		server.deleteById("2");
    		server.commit();
    	}
    
    	//根据 集合中保存的多个id 同时删除多条数据
    	@Test
    	public void deleteByIds() throws SolrServerException, IOException
    	{
    		// URL为http://localhost:8080/solr项目名/core的名字
    		String url = "http://localhost:8080/solr/core2";
    		//solrj连接对象:连接到solr中的某个core(数据库)中,然后可以往该core(数据库)中对数据进行增删查改
    		HttpSolrServer server = new HttpSolrServer(url);
    		//根据id删除对应的数据
    		List<String> ids = new ArrayList<String>();
    		ids.add("1");
    		ids.add("3");
    		//根据 集合中保存的多个id 同时删除多条数据
    		server.deleteById(ids);
    		server.commit();
    	}
    	
    	//根据查询条件删除
    	@Test
    	public void deleteByQuery() throws SolrServerException, IOException
    	{
    		// URL为http://localhost:8080/solr项目名/core的名字
    		String url = "http://localhost:8080/solr/core2";
    		//solrj连接对象:连接到solr中的某个core(数据库)中,然后可以往该core(数据库)中对数据进行增删查改
    		HttpSolrServer server = new HttpSolrServer(url);
    		//查询条件的格式:"*:*"。会删除所有数据,能够成功执行。安全越界,慎用。
    		String query = "*:*"; 
    		//String query = "title:聪明"; //查询条件的格式:“字段名:字段值”
    		//deleteByQuery(查询条件):根据指定的查询条件删除所有匹配的结果
    		server.deleteByQuery(query);
    		server.commit();
    	}
    
    
    5.查询solr中的某个core(数据库)中的数据
    
    	\solr\collection1\conf\solrconfig.xml中配置了如下信息:
    	<lst name="defaults">
           		<str name="echoParams">explicit</str>
           		<int name="rows">10</int>//不进行分页查询的话,默认只查询出10条数据
           		<str name="df">text</str>//不写指定查询的字段名的话,则默认查询text字段的字段值数据,即查询符合该“text字段名=字段值”的数据
         	</lst>
    
     
    	//
    	@Test
    	public void searchSolrCore() throws SolrServerException
    	{
    		// URL为http://localhost:8080/solr项目名/core的名字
    		String url = "http://localhost:8080/solr/core2";
    		//solrj连接对象:连接到solr中的某个core(数据库)中,然后可以往该core(数据库)中对数据进行增删查改
    		HttpSolrServer server = new HttpSolrServer(url);
    
     		//-----------------------------------------
    
    		//1.new SolrQuery("*:*"):查询该core(数据库)中的所有
    		//2.new SolrQuery("字段名:字段值"):指定查询符合该“字段名=字段值”的数据
    		//3.new SolrQuery("字段值"):不写指定查询的字段名的话,则默认查询text字段的字段值数据,即查询符合该“text字段名=字段值”的数据。
    		SolrQuery query = new SolrQuery("*:*");
     
    		//4.new SolrQuery("字段名:字段值?"):表示匹配出现的位置
    		//5.new SolrQuery("字段名:字段值*"):表示匹配任意字符
    		SolrQuery query = new SolrQuery("title:互*");
     
    		//布尔搜索:AND、OR和NOT布尔操作(推荐使用大写,区分普通字段)
    		//例子:new SolrQuery("字段名:字段值 OR 字段名:字段值")。
    		//使用OR表示:表示并集,符合任意一个"字段名:字段值"的数据 都能查询出来
    		//使用AND表示:表示交集,符合两方的"字段名:字段值"的数据 才能查询出来
     		SolrQuery query = new SolrQuery("title:solr OR title:iphone");
    
    		//子表达式查询:(字段名:字段值 OR 字段名:字段值) OR (字段名:字段值)
     		SolrQuery query = new SolrQuery("(title:solr OR title:聪明) OR (title:iphone)");
    
    		//相似度搜索:使用“~”字符,表示最大允许编辑次数为2次
    		//core数据库中存储的是“iphone”,那么输入要搜索的"iphon~q",编辑两次后,仍然可以得到“iphone” 
     		SolrQuery query = new SolrQuery("iphon~q");
    
    		//数字范围搜索,包含起始值和结束值:"字段名:[字段值 TO 字段值]"。
    		//[字段值 TO 字段值]:表示包含两边字段值
    		//{字段值 TO 字段值}:表示不包含两边字段值
    		SolrQuery query = new SolrQuery("age:[1 TO 5]");
     
    		//-----------------------------------------
    
    		//根据id字段倒叙排列
    		query.setSort("id", ORDER.desc);
    
    		//-----------------------------------------
    
    		//执行查询,获取出查询结果集
    		QueryResponse response = server.query(query);
    
    		//---------------- 解析查询结果集的方式一 -------------------------
     
    		SolrDocumentList list = response.getResults(); 
    
    		//默认只查询出10条数据:因为\solr\collection1\conf\solrconfig.xml中配置了<int name="rows">10</int>
    		//不进行分页查询的话,默认只查询出10条数据
    		for(SolrDocument sd : list)
    		{
    			System.out.println("id===="+sd.get("id"));
    			System.out.println("name===="+sd.get("name"));
    			System.out.println("title===="+sd.get("title"));
    			System.out.println("===========next===========");
    		}
    
    		//---------------- 解析查询结果集的方式二 -------------------------
     
    		//解析搜索结果集的方式二:
    		//	直接返回javaBean的方式。
    		//	JavaBean类中的字段上必须定义有@Field("core中的字段名")
    		List<User> list = response.getBeans(User.class);
    
    		for(User u : list)
    		{
    			System.out.println(u);
    		}
    	}
     
    
    6.分页查询:
    	\solr\collection1\conf\solrconfig.xml中配置了如下信息:
    	<lst name="defaults">
           		<str name="echoParams">explicit</str>
           		<int name="rows">10</int>//不进行分页查询的话,默认只查询出10条数据
           		<str name="df">text</str>//不写指定查询的字段名的话,则默认查询text字段的字段值数据,即查询符合该“text字段名=字段值”的数据
         	</lst>
    
    	//搜索结果集的分页
    	//	分页关键:需要页码和每页显示条数
    	//	获取结果集时,指定开始位置start和结束位置end
    	@Test
    	public void searchSolrCorePageList() throws SolrServerException
    	{
    		// URL为http://localhost:8080/solr项目名/core的名字
    		String url = "http://localhost:8080/solr/core2";
    		HttpSolrServer server = new HttpSolrServer(url);
     
    		Integer page = 2;//页码
    		Integer pageSize = 15;//每页显示条数
    		Integer start = (page -1 ) * pageSize;//从第几条开始获取
    		Integer end = page * pageSize;//获取到第几条结束
    
    		//字段名:参数值
    		SolrQuery query = new SolrQuery("title:聪明");
    		
    		//分页查询:设置从第几条开始获取 和 每页显示条数
    		query.setStart(start);//从第几条开始获取
    		query.setRows(pageSize);//每页显示条数
    
    		//根据id字段倒叙排列
    		query.setSort("id", ORDER.desc);
    
    		//开启高亮显示
    		query.setHighlight(true);
    		//高亮显示的标签前缀
    		query.setHighlightSimplePre("<em color='red'>");
    		//高亮显示的标签后缀
    		query.setHighlightSimplePost("</em>");
    		//添加需要高亮显示的字段
    		query.addHighlightField("title");
    		query.addHighlightField("name");
    
    		QueryResponse response = server.query(query);
    
    		//解析搜索结果集的方式一:获取高亮显示的结果集
    		Map<String, Map<String, List<String>>> highlighting = response.getHighlighting();
    
    		//遍历的方式获取高亮的结果集
    		for(String key : highlighting.keySet())
    		{
    			Map<String, List<String>> map = highlighting.get(key);
    			for(String key2 : map.keySet())
    			{
    				List<String> list = map.get(key2);
    				for(String str : list)
    				{
    					System.out.println(str);
    				}
    			}
    		}
    		
    		//解析搜索结果集的方式二:
    		//	直接返回javaBean的方式。
    		//	JavaBean类中的字段上必须定义有@Field("core中的字段名")
    		List<User> list = response.getBeans(User.class);
    		for(User u : list)
    		{
    			String highlightTilte = highlighting.get(u.getId()).get("title").get(0);
     			System.out.println(highlightTilte);
    			u.setTitle(highlightTilte);
    			System.out.println(u);
    		}
    		
    	}
    

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • solr原理详解

    2016-07-07 17:00:38
    Solr对外提供标准的http接口来实现对数据的索引的增加、删除、修改、查询。在 Solr 中,用户通过向部署在servlet 容器中的 Solr Web 应用程序发送 HTTP 请求来...默认配置返回 Solr 的标准 XML 响应,也可以配置 Solr
    Solr对外提供标准的http接口来实现对数据的索引的增加、删除、修改、查询。在 Solr 中,用户通过向部署在servlet 容器中的 Solr Web 应用程序发送 HTTP 请求来启动索引和搜索。Solr 接受请求,确定要使用的适当SolrRequestHandler,然后处理请求。通过
     HTTP 以同样的方式返回响应。默认配置返回 Solr 的标准 XML 响应,也可以配置 Solr 的备用响应格式。  
    可以向 Solr 索引 servlet 传递四个不同的索引请求: 
    add/update 允许向 Solr 添加文档或更新文档。直到提交后才能搜索到这些添加和更新。 
    commit 告诉 Solr,应该使上次提交以来所做的所有更改都可以搜索到。 
    optimize 重构 Lucene 的文件以改进搜索性能。索引完成后执行一下优化通常比较好。如果更新比较频繁,则应该在使用率较低的时候安排优化。一个索引无需优化也可以正常地运行。优化是一个耗时较多的过程。 
    delete 可以通过 id 或查询来指定。按 id 删除将删除具有指定 id 的文档;按查询删除将删除查询返回的所有文档。   
    一个典型的Add请求报文 Xml代码  
    1. <add>   
    2.   <doc>   
    3.     <field name="id">TWINX2048-3200PRO</field>   
    4.     <field name="name">CORSAIR  XMS 2GB (2 x 1GB) 184-Pin DDR S
    DRAM Unbuffered DDR 400 (PC 3200) Dual Channel Kit System Memory - Retail</field>   
    5.     <field name="manu">Corsair Microsystems Inc.</field>   
    6.     <field name="cat">electronics</field>   
    7.     <field name="cat">memory</field>   
    8.     <field name="features">CAS latency 2, 2-3-3-6 timing, 2.75v
    , unbuffered, heat-spreader</field>   
    9.     <field name="price">185</field>   
    10.    <field name="popularity">5</field>   
    11.    <field name="inStock">true</field>   
    12.  </doc>   
    13.  <doc>   
    14.    <field name="id">VS1GB400C3</field>   
    15.    <field name="name">CORSAIR ValueSelect 1GB 184-Pin DDR SDRA
    M Unbuffered DDR 400 (PC 3200) System Memory - Retail</field>   
    16.    <field name="manu">Corsair Microsystems Inc.</field>   
    17.    <field name="cat">electronics</field>   
    18.    <field name="cat">memory</field>   
    19.    <field name="price">74.99</field>   
    20.    <field name="popularity">7</field>   
    21.    <field name="inStock">true</field>   
    22.  </doc>   
    23.</add>     
    一个典型的搜索结果报文: Xml代码  
    1. <response>   
    2.     <lst name="responseHeader">   
    3.         <int name="status">0</int>   
    4.         <int name="QTime">6</int>   
    5.         <lst name="params">   
    6.             <str name="rows">10</str>   
    7.             <str name="start">0</str>   
    8.             <str name="fl">*,score</str>   
    9.             <str name="hl">true</str>   
    10.            <str name="q">content:"faceted browsing"</str>   
    11.        </lst>   
    12.    </lst>   
    13.   
    14.    <result name="response" numFound="1" start="0" maxScore="1.058217">   
    15.        <doc>   
    16.            <float name="score">1.058217</float>   
    17.            <arr name="all">   
    18.                <str>http://localhost/myBlog/solr-rocks-again.h
    tml</str>   
    19.                <str>Solr is Great</str>   
    20.                <str>solr,lucene,enterprise,search,greatness</str>   
    21.                <str>Solr has some really great features, like 
    faceted browsing and replication</str>   
    22.            </arr>   
    23.            <arr name="content">   
    24.                <str>Solr has some really great features, like 
    faceted browsing and replication</str>   
    25.            </arr>   
    26.            <date name="creationDate">2007-01-07T05:04:00.000Z</date>   
    27.            <arr name="keywords">   
    28.                <str>solr,lucene,enterprise,search,greatness</str>   
    29.            </arr>   
    30.            <int name="rating">8</int>   
    31.            <str name="title">Solr is Great</str>   
    32.            <str name="url">http://localhost/myBlog/solr-rocks-again.html</str>   
    33.        </doc>   
    34.    </result>   
    35.   
    36.    <lst name="highlighting">   
    37.        <lst name="http://localhost/myBlog/solr-rocks-again.html">   
    38.            <arr name="content">   
    39.                <str>Solr has some really great features, like 
    <em>faceted</em>   

    40.                <em>browsing</em> and replication</str>   
    41.            </arr>   
    42.        </lst>   
    43.    </lst>   

    44.</response>  

    展开全文
  • 关于solr的一些基础入门,基于solr6.5,了解之后可以基本上架构出属于自己的搜索引擎
  • Solr原理解析

    2018-08-07 15:24:00
    solr” 的文件。 看到这个地方,有人可能会说,全文检索的确加快了搜索的速度,但是多了索引的过程,两者加起来不一定比顺序扫描快多少。的确,加上索引的过程,全文检索不一定比顺序扫描快,尤其是在数据量...
  • Solr是一个用java开发的基于lucene引擎的 全文搜索 平台,原理是倒排索引,从关键字到文档的过程,Solr的资源都是以Doc为对象进行存储的,每个文档都由一系列的field构成,每个field表示资源的一个属性,文档的fied...
  • lily+Solr 原理与配置

    2021-06-03 13:29:19
    为什么要引入lily和solr ​ 在Hbase中,表的RowKey 按照字典排序, 单一的通过RowKey检索数据的方式,不再满足更多的需求,查询成为Hbase的瓶颈,希望像Sql一样快速检索数据,Hbase之前定位的是大表的存储,要进行这样...
  • Solr简介 1.Solr是什么? Solr它是一种开放源码的、基于 Lucene Java 的搜索服务器,易于加入到 Web 应用程序中。Solr 提供了层面搜索(就是统计)、命中醒目显示并且支持多种输出格式(包括XML/XSLT 和JSON等...
  • Solr原理

    2012-04-04 10:04:00
    转载于:https://www.cnblogs.com/hznet/archive/2012/04/04/2431731.html

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 795
精华内容 318
关键字:

solr原理