首页 文章 精选 留言 我的

精选列表

搜索[图形后端]，共10000篇文章
优秀的个人博客,低调大师

Java后端应用架构方案的演化（架构优化）

前言 一个成熟的大型网站（如淘宝、天猫、腾讯等）的系统架构并不是一开始设计时就具备完整的高性能、高可用、高伸缩等特性的，它是随着用户量的增加，业务功能的扩展逐渐演变完善的，在这个过程中，开发模式、技术架构、设计思想也发生了很大的变化，就连技术人员也从几个人发展到一个部门甚至一条产品线。所以成熟的系统架构是随着业务的扩展而逐步完善的，并不是一蹴而就；不同业务特征的系统，会有各自的侧重点，例如：淘宝，要解决海量的商品信息的搜索、下单、支付，例如腾讯，要解决数亿用户的实时消息传输，百度它要处理海量的搜索请求，他们都有各自的业务特性，系统架构也有所不同。尽管如此我们也可以从这些不同的网站背景下，找出其中共用的技术，这些技术和手段广泛运用在大型网站系统的架构中，下面就通过介绍大型网站系统的演化过程，来认识这些技术和手段。 一、最开始的网站架构 最初的架构，应用程序、数据库、文件都部署在一台服务器上，如图： 上云采购 二、应用、数据、文件分离 随着业务的扩展，一台服务器已经不能满足性能需求，故将应用程序、数据库、文件各自部署在独立的服务器上，并且根据服务器的用途配置不同的硬件，达到最佳的性能效果。 三、利用缓存改善网站性能 在硬件优化性能的同时，同时也通过软件进行性能优化，在大部分的网站系统中，都会利用缓存技术改善系统的性能，使用缓存主要源于热点数据的存在，大部分网站访问都遵循28原则（即80%的访问请求，最终落在20%的数据上），所以我们可以对热点数据进行缓存，减少这些数据的访问路径，提高用户体验。 缓存实现常见的方式是本地缓存、分布式缓存。当然还有CDN、反向代理等，这个后面再讲。本地缓存，顾名思义是将数据缓存在应用服务器本地，可以存在内存中，也可以存在文件，OSCache就是常用的本地缓存组件。本地缓存的特点是速度快，但因为本地空间有限所以缓存数据量也有限。分布式缓存的特点是，可以缓存海量的数据，并且扩展非常容易，在门户类网站中常常被使用，速度按理没有本地缓存快，常用的分布式缓存是Memcached、Redis。 四、使用集群改善应用服务器性能 应用服务器作为网站的入口，会承担大量的请求，我们往往通过应用服务器集群来分担请求数。应用服务器前面部署负载均衡服务器调度用户请求，根据分发策略将请求分发到多个应用服务器节点。 常用的负载均衡技术硬件的有F5，价格比较贵，可以先领取卷软件的有LVS、Nginx、HAProxy。LVS是四层负载均衡，根据目标地址和端口选择内部服务 器，Nginx和HAProxy是七层负载均衡，可以根据报文内容选择内部服务器，因此LVS分发路径优于Nginx和HAProxy，性能要高些，而Nginx和HAProxy则更具配置性，如可以用来做动静分离（根据请求报文特征，选择静态资源服务器还是应用服务器）。 五、数据库读写分离和分库分表 随着用户量的增加，数据库成为最大的瓶颈，改善数据库性能常用的手段是进行读写分离以及分库分表，读写分离顾名思义就是将数据库分为读库和写库，通过主备功能实现数据同步。分库分表则分为水平切分和垂直切分，水平切分则是对一个数据库特大的表进行拆分，例如用户表。垂直切分则是根据业务的不同来切分，如用户业务、商品业务相关的表放在不同的数据库中。 六、使用CDN和反向代理提高网站性能 假如我们的服务器都部署在成都的机房，对于四川的用户来说访问是较快的，而对于北京的用户访问是较慢的，这是由于四川和北京分别属于电信和联通的不同发达地区，北京用户访问需要通过互联路由器经过较长的路径才能访问到成都的服务器，返回路径也一样，所以数据传输时间比较长。对于这种情况，常常使用CDN解决，CDN将数据内容缓存到运营商的机房，用户访问时先从最近的运营商获取数据，这样大大减少了网络访问的路径。比较专业的CDN运营商有蓝汛、网宿。 而反向代理，则是部署在网站的机房，当用户请求达到时首先访问反向代理服务器，反向代理服务器将缓存的数据返回给用户，如果没有缓存数据才会继续访问应用服务器获取，这样做减少了获取数据的成本。反向代理有Squid，Nginx。 七、使用分布式文件系统 用户一天天增加，业务量越来越大，产生的文件越来越多，单台的文件服务器已经不能满足需求，这时就需要分布式文件系统的支撑。常用的分布式文件系统有GFS、HDFS、TFS。 八、使用NoSql和搜索引擎 对于海量数据的查询和分析，我们使用nosql数据库加上搜索引擎可以达到更好的性能。并不是所有的数据都要放在关系型数据中。常用的NOSQL有mongodb、hbase、redis，搜索引擎有lucene、solr、elasticsearch。 九、将应用服务器进行业务拆分 随着业务进一步扩展，应用程序变得非常臃肿，这时我们需要将应用程序进行业务拆分，如百度分为新闻、网页、图片等业务。每个业务应用负责相对独立的业务运作。业务之间通过消息进行通信或者共享数据库来实现。 十、搭建分布式服务 这时我们发现各个业务应用都会使用到一些基本的业务服务，例如用户服务、订单服务、支付服务、安全服务，这些服务是支撑各业务应用的基本要素。我们将这些服务抽取出来利用分部式服务框架搭建分布式服务。阿里的Dubbo是一个不错的选择。 小结 大型网站的架构是根据业务需求不断完善的，根据不同的业务特征会做特定的设计和考虑，本文只是讲述一个常规大型网站会涉及的一些技术和手段。 服务器链接
2020-04-06
优秀的个人博客,低调大师

Django前后端分离实践之DRF--03

一、序列化 1. 创建表 以出版社的表为例子,例如出版社有名字和所属地区 选区_051 class Publisher(models.Model): name = models.CharField(max_length=32, verbose_name='名称', unique=True) address = models.CharField(max_length=128, verbose_name='地址') def __str__(self): return self.name class Meta: verbose_name = '出版社' verbose_name_plural = verbose_name 选区_162 2. 生成迁移文件和执行迁移 在这里我们暂时用sqlite数据库 python manage.py makemigrations python manage.py migrate 3. 什么是序列化 维基百科资料关于序列化的介绍 3.1 关于序列化的解释: 在程序运行的过程中，所有的变量都是在内存中，比如，定义一个dict： d = dict(name='Zhangsan', age=26, score=75) 可以随时修改变量，比如把name改成'LiSi'，但是一旦程序结束，变量所占用的内存就被操作系统全部回收。如果没有把修改后的'LiSi'存储到磁盘上，下次重新运行程序，变量又被初始化为'Zhangsan'。 <b style='color:red'>我们把变量从内存中变成可存储或传输的过程称之为序列化</b>，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。 序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。 反过来，<b style='color:red'>把变量内容从序列化的对象重新读到内存里称之为反序列化</b>，即unpickling。 3.2 JSON <b style='color:red'>如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式</b>，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。 JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下： JSON类型 Python类型 {} dict [] list "string" str 1234.56 int或float true/false True/False null None Python内置的json模块提供了非常完善的Python对象到JSON格式的转换: 3.3 把Python对象变成一个JSON： import json d = dict(name='Zhangsan', age=26, score=75) # dumps()方法返回一个str，内容就是标准的JSON json_str= json.dumps(d) 3.4 要把JSON反序列化为Python对象，用loads()方法: json_str = '{"age": 26, "score": 75, "name": "Zhangsan"}' json.loads(json_str) 4. 通过以下方式可以实现API： 编写视图: from .models import Publisher from django.http import HttpResponse def publisher_list(request): # 查询出所有的出版社 queryset = Publisher.objects.all() # 转换成python中的列表 data = [] for i in queryset: # 每一个对象都手动转化成一个字典 p_tmp = { 'name': i.name, 'address': i.address } data.append(p_tmp) import json return HttpResponse(json.dumps(data), content_type='application/json') 选区_163 配置路由: url(r'^publishers/', views.publisher_list) 启动项目 python manage.py runserver 选区_164 手动添加数据 选区_165 刷新浏览器 选区_166 选区_167 5. 对于以上的方案进行第一次改进: data = [] from django.forms.models import model_to_dict for i in queryset: data.append(model_to_dict(i)) 注意:这种方式有缺陷,很多字段无法转换成字典,比如图片 选区_168 6. 对于以上的方案进行第二次改进(使用Django自带的serializers): data = [] from django.core import serializers data = serializers.serialize('json', queryset) import json return HttpResponse(data, content_type='application/json') 注意:此时data已经是json类型 选区_169 刷新浏览器 选区_170 二、DRF提供的序列化 DRF提供的方案更加先进,更高级别的序列化方案,不仅仅可以实现从数据库里面读取数据,更可以存数据(增删改查) 1. 在APP下创建一个序列化一个文件 我们自己定义一个序列化 from rest_framework import serializers # 类名固定为表名称 + Serializer class PublisherSerializer(serializers.Serializer): # read_only必须为True,因为我们模型里面的id是一个自增字段,不可写,自动生成 id = serializers.IntegerField(read_only=True) name = serializers.CharField(max_length=32) address = serializers.CharField(max_length=128) 选区_171 2. 使用自己定义的序列化 非常方便的把我们的对象转化成一个字典 from app01 import models,serializers p1 = models.Publisher.objects.first()# 先找到一个出版社的对象 s = serializers.PublisherSerializer(p1) s.data 选区_172 3. 给自定义的序列化增加一个'create'和'update'的功能 重写父类 def create(self, validated_data): # validated_data参数不需要特意去记,就是经过校验的数据 return models.Publisher.objects.create(**validated_data) def update(self, instance, validated_data): instance.name = validated_data.get('name', instance.name) instance.address = validated_data.get('address', instance.address) instance.save() return instance 使用 from app01 import models,serializers p2 = {'name':'图灵出版社','address':'大兴天宫院'} s = serializers.PublisherSerializer(data=p2) s.is_valid()# 如果数据检测没有问题 Out[5]: True s.validated_data # 可以查看类型,观察到这是一个有序字典 Out[6]: OrderedDict([('name', '图灵出版社'), ('address', '大兴天宫院')]) s.save() # 保存到数据库 Out[7]: <Publisher: 图灵出版社> 选区_173 刷新浏览器 选区_174 在视图里面使用 # 第三次改进 from app01 import serializers # 如果是多个对象,一定要写many = True,就是说我们是多个对象, # many=True告诉程序要用遍历的方式去给我们做序列化 s = serializers.PublisherSerializer(queryset, many=True) import json return HttpResponse(json.dumps(s.data), content_type='application/json') 选区_175 4. 改进自定义序列化模块 因为那些字段,我们已经在模型中创建,没有必要再创建一次,所以我们再进行一次改进 class PublisherSerializer(serializers.ModelSerializer): class Meta: model = models.Publisher # 我们要使用的模型 # 我们要使用的字段 fields = ( 'id', 'name', 'address' ) 选区_176 刷新浏览器,依旧可以正常运行,也就说是我们可以自己去写每一个字段,当然可以用ModelSerializer,直接使用我们的模型(相当于和我们数据库里面的表字段一一对应) 选区_177
2018-10-20
优秀的个人博客,低调大师

使用IntelliJ IDEA新建Java Web后端resfulAPI模板

初始化项目 打开IntelliJ IDEA，我的版本是Version 2018.1.4。点击Create New Project。在左侧的列表中选择Maven。然后在右侧勾选Create from archetype。 然后在右侧的列表中选择org.apache.maven.archetypes:maven-archetype-webapp。点击next。 填写GroupId和ArtifactId。GroupId定义了项目属于哪个组织，例如，我们需要使用一个包，名字叫做fastjson，用户在项目中返回json数据的，是阿里的开源框架，被不少企业使用，是一个极其优秀的Json框架。它的groupId是com.alibaba，artifactId是fastjson。 简单理解一下，拿Github举个例子。GroupId就相当于是你的用户名，而ArtifactId就相当于是你的具体某个项目的名称，也是我们当前的项目的根目录名称。例子如下。 GroupId: com.detectivehlh.test ArtifactId: testDemo 点击next，下两页不用设置，直接点击next。此时新建项目成功，右下角会弹出一个提示框，上面写着Maven projects need to be imported.此时选择Enable Auto-Import。就可以看到项目开始自动的去加载依赖包了。加载完成之后，项目会多出一个src目录。 引入jersey和servlet 打开根目录下pom.xml文件，在dependencies标签中添加如下代码，引入servlet。 <dependency> <groupId>org.glassfish.jersey.containers</groupId> <artifactId>jersey-container-servlet</artifactId> <version>2.22.2</version> </dependency> 打开/src/main/webapp/WEB_INF/web.xml。在web-app标签之间添加如下代码。 <servlet> <servlet-name>JAX-RS Servlet</servlet-name> <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class> <init-param> <param-name>jersey.config.server.provider.packages</param-name> <param-value>com.detectivehlh.test</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>JAX-RS Servlet</servlet-name> <url-pattern>/api/*</url-pattern> </servlet-mapping> 新建项目目录和文件 在/src/main目录下新建java、resources目录，java放项目java源代码，resources放项目的静态资源文件。 打开File中的Project Structure，或者使用快捷键，command + ;就可以快捷打开了。将刚刚创建的名为java目录设置为Sources，resources设置为Resources。然后Apply。然后在java目录下依次新建com.detectivehlh.test三个包，就是我们的GroupId. 然后在com.detectivehlh.test中新建Hello类。代码如下。 package com.detectivehlh.test; import com.alibaba.fastjson.JSONObject; import javax.ws.rs.GET; import javax.ws.rs.Path; import javax.ws.rs.Produces; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.Response; import java.util.ArrayList; import java.util.List; @Path("/hello") public class Hello { @Path("get") @GET @Produces(MediaType.APPLICATION_JSON) public Response getStudent() { List<Student> lists = new ArrayList<Student>(); lists.add(new Student("1","mayun",23)); lists.add(new Student("2","mahuateng",24)); lists.add(new Student("3","zhouhongyi",25)); JSONObject json = new JSONObject(); return Response.status(Response.Status.OK).entity(json.toJSONString(lists)).build(); } } 同样的地方新建Student类。代码如下。 package com.detectivehlh.test; public class Student { private String id; private String name; private int age; public Student(String id, String name, int age) { this.id = id; this.name = name; this.age = age; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } } 引入fastjson 这个时候可以看到，Hello的class中有报错。是因为没有在pom.xml中没有引入对fastjson的依赖。在根目录下的pom.xml中添加如下依赖。 <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.21</version> </dependency> 再回到Hello中就可以看到没有错误信息了。 配置Tomcat 选择顶部菜单栏中的Run->Edit Configurations。点击左侧的+，选择Tomcat Server->local。配置好Tomcat后，选择Server旁边的Deployment标签，点击下方的+，选择Artifact，选择testDemo:war exploded。点击Apply。然后点击右上角的长得像播放键的按钮，启动项目。 就可以看到会新建一个浏览器标签页。显示"Hello World!"，然后改变浏览器中的路由为我们写的接口的路由，/api/hello/get。就可以看到返回的json数据了。
2018-08-27
优秀的个人博客,低调大师

从后端到前端的简陋博客开发---by Django

7月12日，晴，陆陆续续的把Django入门教程看完了，了解到了一些前端知识，数据库，python的一些语法，比较顺利的开发了一个究极简陋的个人博客，实现了文章的发布与修改，也算是对Django有了初步的认识，激励我继续完成个人博客开发！ 总结 1.熟悉settings.py文件的架构 2.掌握Model的运用 3.掌握urls的设置 4.编写Templates，通过浏览器呈现内容 5.熟悉Admin管理工具的运用 通过整一个流程下来，可以完成一个能上传文章，修改文章的简易博客，但之前一直是跟着教程打代码，好多细节都记不清了，甚至忘了。不多说了，准备再去理一遍思路，制作一个流程框图。 index 新文章编写 博客1
2018-07-11
优秀的个人博客,低调大师

后端技术杂谈5：云计算的前世今生

作者简介：刘超，网易云解决方案首席架构师。10年云计算领域研发及架构经验，Open DC/OS贡献者。长期专注于kubernetes, OpenStack、Hadoop、Docker、Lucene、Mesos等开源软件的企业级应用及产品化。曾出版《Lucene应用开发揭秘》。 以下为正文： 云计算概述 云计算主要解决了四个方面的内容：计算，网络，存储，应用。 计算就是CPU和内存，例如“1+1”这个最简单的算法就是把“1”放在内存里面，然后CPU做加法，返回的结果“2”又保存在内存里面。网络就是你插根网线能上网。存储就是你下个电影有地方放。本次讨论就是围绕这四个部分来讲的。其中，计算、网络、存储三个是IaaS层面，应用是PaaS层面。 云计算发展脉络 云计算整个发展过程，用一句话来形容，就是“分久必合，合久必分”。 第一阶段：合，即物理设备 物理设备简介 在互联网发展初期，大家都爱用物理设备： 服务器用物理机，像戴尔、惠普、IBM、联想等物理服务器，随着硬件设备的进步，物理服务器越来越强大了，64核128G内存都算是普通配置； 网络用的是硬件交换机和路由器，例如思科的，华为的，从1GE到10GE，现在有40GE和100GE，带宽越来越牛； 存储方面有的用普通的磁盘，也有更快的SSD盘。容量从M，到G，连笔记本电脑都能配置到T，更何况磁盘阵列； 物理设备的缺点 部署应用直接使用物理机，看起来很爽，有种土豪的感觉，却有大大的缺点： 人工运维。如果你在一台服务器上安装软件，把系统安装坏了，怎么办？只有重装。当你想配置一下交换机的参数，需要串口连上去进行配置；当你想增加一块磁盘，要买一块插进服务器，这些都需要人工来，而且很大可能要求机房。你们公司在北五环，机房在南六环，这酸爽。 浪费资源。其实你只想部署一个小小的网站，却要用128G的内存。混着部署吧，就有隔离性的问题。 隔离性差。你把好多的应用部署在同一台物理机上，他们之间抢内存、抢cpu，一个写满了硬盘，另一个就没法用了，一个弄挂了内核，另一个也跟著挂了，如果部署两个相同的应用，端口还会冲突，动不动就会出错。 第二阶段：分，即虚拟化 虚拟化简介 因为物理设备的以上缺点，就有了第一次“合久必分”的过程，叫做虚拟化。所谓虚拟化，就是把实的变成虚的： 物理机变为虚拟机。cpu是虚拟的，内存是虚拟的，内核是虚拟的，硬盘是虚拟的； 物理交换机变为虚拟交换机。网卡是虚拟的，交换机是虚拟的，带宽也是虚拟的； 物理存储变成虚拟存储。多块硬盘虚拟成一大块； 虚拟化解决的问题 虚拟化很好地解决了在物理设备阶段存在的三个问题： 人工运维。虚拟机的创建和删除都可以远程操作，虚拟机被玩坏了，删了再建一个分钟级别的。虚拟网络的配置也可以远程操作，创建网卡、分配带宽都是调用接口就能搞定的； 资源浪费。虚拟化了以后，资源可以分配地很小很小，比如1个cpu，1G内存，1M带宽，1G硬盘，都可以被虚拟出来； 隔离性差。每个虚拟机都有独立的cpu、 内存、硬盘、网卡，不同虚拟机之间的应用互不干扰； 虚拟化时代的生态 在虚拟化阶段，领跑者是Vmware，可以实现基本的计算、网络、存储的虚拟化。 如同这个世界有闭源就有开源、有windows就有linux、有Apple就有Android一样，有Vmware，就有Xen和KVM。 在开源虚拟化方面，Xen 的Citrix做的不错，后来Redhat在KVM发力不少；对于网络虚拟化，有Openvswitch，可以通过命令创建网桥、网卡、设置VLAN、设置带宽；对于存储虚拟化，本地盘有LVM，可以将多个硬盘变成一大块盘，然后在里面切出一小块给用户。 虚拟化的缺点 但是虚拟化也有缺点。通过虚拟化软件创建虚拟机，需要人工指定放在哪台机器上、硬盘放在哪个存储设备上，网络的VLAN ID、带宽的具体配置等，都需要人工指定。所以仅使用虚拟化的运维工程师往往有一个Excel表格，记录有多少台物理机，每台机器部署了哪些虚拟机。受此限制，一般虚拟化的集群数目都不是特别大。 第三阶段：合，即云计算 云计算解决的问题 为了解决虚拟化阶段遗留的问题，于是有了分久必合的过程。这个过程我们可以形象地称为池化。 虚拟化将资源分得很细，但是如此细分的资源靠Excel去管理，成本太高。池化就是将资源打成一个大的池，当需要资源的时候，帮助用户自动地选择，而非用户指定。这个阶段的关键点：调度器Scheduler。 私有云、公有云的两极分化 这样，Vmware有了自己的Vcloud；也有了基于Xen和KVM的私有云平台CloudStack（后来Citrix将其收购后开源）。 当这些私有云平台在用户的数据中心里卖得奇贵无比、赚得盆满钵盈的时候，有其他的公司开始了另外的选择。这就是AWS和Google，他们开始了公有云领域的探索。 AWS最初就是基于Xen技术进行虚拟化的，并且最终形成了公有云平台。也许AWS最初只是不想让自己的电商领域的利润全部交给私有云厂商吧，所以自己的云平台首先支撑起了自己的业务。在这个过程中，AWS严肃地使用了自己的云计算平台，使得公有云平台并不是对资源的配置更加友好，而是对应用的部署更加友好，最终大放异彩。 私有云厂商与公有云厂商的联系与区别 如果仔细观察就会发现，私有云和公有云虽然使用的是类似的技术，但在产品设计上却是完全不同的两种生物。 私有云厂商和公有云厂商也拥有类似的技术，但在产品运营上呈现出完全不同的基因。 私有云厂商是卖资源的，所以往往在卖私有云平台的时候伴随着卖计算、网络、存储设备。在产品设计上，私有云厂商往往会对客户强调其几乎不会使用的计算、网络、存储的技术参数，因为这些参数可以在和友商对标的过程中占尽优势。私有云的厂商几乎没有自己的大规模应用，所以私有云厂商的平台做出来是给别人用的，自己不会大规模使用，所以产品往往围绕资源展开，而不会对应用的部署友好。 公有云的厂商往往都是有自己大规模的应用需要部署，所以其产品的设计可以将常见的应用部署需要的模块作为组件提供出来，用户可以像拼积木一样，拼接一个适用于自己应用的架构。公有云厂商不必关心各种技术参数的PK，不必关心是否开源，是否兼容各种虚拟化平台，是否兼容各种服务器设备、网络设备、存储设备。你管我用什么，客户部署应用方便就好。 公有云生态及老二的逆袭 公有云的第一名AWS活的自然很爽，作为第二名Rackspace就不那么舒坦了。 没错，互联网行业基本上就是一家独大，那第二名如何逆袭呢？开源是很好的办法，让整个行业一起为这个云平台出力。于是Rackspace与美国航空航天局（NASA）合作创始了开源云平台OpenStack。 OpenStack现在发展的和AWS有点像了，所以从OpenStack的模块组成可以看到云计算池化的方法。 OpenStack的组件 计算池化模块Nova：OpenStack的计算虚拟化主要使用KVM，然而到底在哪个物理机上开虚拟机呢，这要靠nova-scheduler； 网络池化模块Neutron：OpenStack的网络虚拟化主要使用Openvswitch，然而对于每一个Openvswitch的虚拟网络、虚拟网卡、VLAN、带宽的配置，不需要登录到集群上配置，Neutron可以通过SDN的方式进行配置； 存储池化模块Cinder: OpenStack的存储虚拟化，如果使用本地盘，则基于LVM，使用哪个LVM上分配的盘，也是通过scheduler来的。后来就有了将多台机器的硬盘打成一个池的方式Ceph，而调度的过程，则在Ceph层完成。 OpenStack带来私有云市场的红海 有了OpenStack，所有的私有云厂商都疯了，原来VMware在私有云市场赚的实在太多了，眼巴巴的看着，没有对应的平台可以和他抗衡。现在有了现成的框架，再加上自己的硬件设备，几乎所有的IT厂商巨头，全部都加入到社区里，将OpenStack开发为自己的产品，连同硬件设备一起，杀入私有云市场。 公有or私有？网易云的选择 网易云当然也没有错过这次风口，上线了自己的OpenStack集群，网易云基于OpenStack自主研发了IaaS服务，在计算虚拟化方面，通过裁剪KVM镜像，优化虚拟机启动流程等改进，实现了虚拟机的秒级别启动。在网络虚拟化方面，通过SDN和Openvswitch技术，实现了虚拟机之间的高性能互访。在存储虚拟化方面，通过优化Ceph存储，实现高性能云盘。 但是网易云并没有杀进私有云市场，而是使用OpenStack支撑起了自己的应用，这是互联网的思维。而仅仅是资源层面弹性是不够的，还需要开发出对应用部署友好的组件。例如数据库，负载均衡，缓存等，这些都是应用部署必不可少的，也是网易云在大规模应用实践中，千锤百炼过的。这些组件称为PaaS。 第四阶段：分，即容器 现在来谈谈，应用层面，即PaaS层。 前面一直在讲IaaS层的故事，也即基础设施即服务，基本上在谈计算、网络、存储的事情。现在应该说说应用层，即PaaS层的事情了。 1. PaaS的定义与作用 IaaS的定义比较清楚，PaaS的定义就没那么清楚了。有人把数据库、负载均衡、缓存作为PaaS服务；有人把大数据Hadoop,、Spark平台作为PaaS服务；还有人将应用的安装与管理，例如Puppet、 Chef,、Ansible作为PaaS服务。 其实PaaS主要用于管理应用层。我总结为两部分：一部分是你自己的应用应当自动部署，比如Puppet、Chef、Ansible、 Cloud Foundry等，可以通过脚本帮你部署；另一部分是你觉得复杂的通用应用不用部署，比如数据库、缓存、大数据平台，可以在云平台上一点即得。 要么就是自动部署，要么就是不用部署，总的来说就是应用层你也少操心，就是PaaS的作用。当然最好还是都不用去部署，一键可得，所以公有云平台将通用的服务都做成了PaaS平台。另一些你自己开发的应用，除了你自己其他人不会知道，所以你可以用工具变成自动部署。 2. PaaS的优点 PaaS最大的优点，就是可以实现应用层的弹性伸缩。比如在双十一期间，10个节点要变成100个节点，如果使用物理设备，再买90台机器肯定来不及，仅仅有IaaS实现资源的弹性是不够的，再创建90台虚拟机，也是空的，还是需要运维人员一台一台地部署。所以有了PaaS就好了，一台虚拟机启动后，马上运行自动部署脚本，进行应用的安装，90台机器自动安装好了应用，才是真正的弹性伸缩。 3. PaaS部署的问题 当然这种部署方式也有一个问题，就是无论Puppet、 Chef、Ansible把安装脚本抽象的再好，说到底也是基于脚本的，然而应用所在的环境千差万别。文件路径的差别，文件权限的差别，依赖包的差别，应用环境的差别，Tomcat、 PHP、 Apache等软件版本的差别，JDK、Python等版本的差别，是否安装了一些系统软件，是否占用了哪些端口，都可能造成脚本执行的不成功。所以看起来是一旦脚本写好，就能够快速复制了，但是环境稍有改变，就需要把脚本进行新一轮的修改、测试、联调。例如在数据中心写好的脚本移到AWS上就不一定直接能用，在AWS上联调好了，迁移到Google Cloud上也可能会再出问题。 容器的诞生 1. 容器的定义 于是容器便应运而生。容器是Container，Container另一个意思是集装箱，其实容器的思想就是要变成软件交付的集装箱。集装箱的特点，一是打包，二是标准。设想没有集装箱的时代，如果将货物从A运到B，中间要经过三个码头，换三次船的话，货物每次都要卸下船来，摆的七零八落，然后换船的时候，需要重新摆放整齐，在没有集装箱的时候，船员们都需要在岸上待几天再走。而在有了集装箱后，所有的货物都打包在一起了，并且集装箱的尺寸全部一致，所以每次换船的时候，整体一个箱子搬过去就可以了，小时级别就能完成，船员再也不用长时间上岸等待了。 2.容器在开发中的应用 设想A就是程序员，B就是用户，货物就是代码及运行环境，中间的三个码头分别是开发，测试，上线。 假设代码的运行环境如下： Ubuntu操作系统 创建用户hadoop 下载解压JDK 1.7在某个目录下 将这个目录加入JAVA_HOME和PATH的环境变量里面 将环境变量的export放在hadoop用户的home目录下的.bashrc文件中 下载并解压tomcat 7 将war放到tomcat的webapp路径下面 修改tomcat的启动参数，将Java的Heap Size设为1024M 看，一个简单的Java网站，就需要考虑这么多零零散散的东西，如果不打包，就需要在开发，测试，生产的每个环境上查看，保证环境的一致，甚至要将这些环境重新搭建一遍，就像每次将货物打散了重装一样麻烦。中间稍有差池，比如开发环境用了JDK 1.8，而线上是JDK 1.7；比如开发环境用了root用户，线上需要使用hadoop用户，都可能导致程序的运行失败。 容器的诞生 云计算的前世今生（上）中提到：云计算解决了基础资源层的弹性伸缩，却没有解决PaaS层应用随基础资源层弹性伸缩而带来的批量、快速部署问题。于是容器应运而生。 容器是Container，Container另一个意思是集装箱，其实容器的思想就是要变成软件交付的集装箱。集装箱的特点，一是打包，二是标准。 在没有集装箱的时代，假设将货物从A运到B，中间要经过三个码头、换三次船。每次都要将货物卸下船来，摆的七零八落，然后搬上船重新整齐摆好。因此在没有集装箱的时候，每次换船，船员们都要在岸上待几天才能走。 有了集装箱以后，所有的货物都打包在一起了，并且集装箱的尺寸全部一致，所以每次换船的时候，一个箱子整体搬过去就行了，小时级别就能完成，船员再也不能上岸长时间耽搁了。这是集装箱“打包”、“标准”两大特点在生活中的应用。下面用一个简单的案例来看看容器在开发部署中的实际应用。 假设有一个简单的Java网站需要上线，代码的运行环境如下： 看，一个简单的Java网站，就有这么多零零散散的东西！这就像很多零碎地货物，如果不打包，就需要在开发、测试、生产的每个环境上重新查看以保证环境的一致，有时甚至要将这些环境重新搭建一遍，就像每次将货物卸载、重装一样麻烦。中间稍有差池，比如开发环境用了JDK 1.8，而线上是JDK 1.7；比如开发环境用了root用户，线上需要使用hadoop用户，都可能导致程序的运行失败。 那么容器如何对应用打包呢？还是要学习集装箱，首先要有个封闭的环境，将货物封装起来，让货物之间互不干扰，互相隔离，这样装货卸货才方便。好在ubuntu中的lxc技术早就能做到这一点。 封闭的环境主要使用了两种技术，一种是看起来是隔离的技术，称为namespace，也即每个namespace中的应用看到的是不同的IP地址、用户空间、程号等。另一种是用起来是隔离的技术，称为cgroup，也即明明整台机器有很多的CPU、内存，而一个应用只能用其中的一部分。有了这两项技术，集装箱的铁盒子我们是焊好了，接下来是决定往里面放什么。 最简单粗暴的方法，就是将上面列表中所有的都放到集装箱里面。但是这样太大了！因为即使你安装一个干干静静的ubuntu操作系统，什么都不装，就很大了。把操作系统装进容器相当于把船也放到了集装箱里面！传统的虚拟机镜像就是这样的，动辄几十G。答案当然是NO！所以第一项操作系统不能装进容器。 撇下第一项操作系统，剩下的所有的加起来，也就几百M，就轻便多了。因此一台服务器上的容器是共享操作系统内核的，容器在不同机器之间的迁移不带内核，这也是很多人声称容器是轻量级的虚拟机的原因。轻不白轻，自然隔离性就差了，一个容器让操作系统崩溃了，其他容器也就跟着崩溃了，这相当于一个集装箱把船压漏水了，所有的集装箱一起沉。 另一个需要撇下的就是随着应用的运行而产生并保存在本地的数据。这些数据多以文件的形式存在，例如数据库文件、文本文件。这些文件会随着应用的运行，越来越大，如果这些数据也放在容器里面，会让容器变得很大，影响容器在不同环境的迁移。而且这些数据在开发、测试、线上环境之间的迁移是没有意义的，生产环境不可能用测试环境的文件，所以往往这些数据也是保存在容器外面的存储设备上。也是为什么人们称容器是无状态的。 至此集装箱焊好了，货物也装进去了，接下来就是如何将这个集装箱标准化，从而在哪艘船上都能运输。这里的标准一个是镜像，一个是容器的运行环境。 所谓的镜像，就是将你焊好集装箱的那个时刻，将集装箱的状态保存下来，就像孙悟空说定，集装箱里面就定在了那一刻，然后将这一刻的状态保存成一系列文件。这些文件的格式是标准的，谁看到这些文件，都能还原当时定住的那个时刻。将镜像还原成运行时的过程（就是读取镜像文件，还原那个时刻的过程）就是容器的运行的过程。除了大名鼎鼎的Docker，还有其他的容器，例如AppC、Mesos Container，都能运行容器镜像。所以说容器不等于Docker。 总而言之，容器是轻量级的、隔离差的、适用于无状态的，可以基于镜像标准实现跨主机、跨环境的随意迁移。 有了容器，使得PaaS层对于用户自身应用的自动部署变得快速而优雅。容器快，快在了两方面，第一是虚拟机启动的时候要先启动操作系统，容器不用启动操作系统，因为是共享内核的。第二是虚拟机启动后使用脚本安装应用，容器不用安装应用，因为已经打包在镜像里面了。所以最终虚拟机的启动是分钟级别，而容器的启动是秒级。容器咋这么神奇。其实一点都不神奇，第一是偷懒少干活了，第二是提前把活干好了。 因为容器的启动快，人们往往不会创建一个个小的虚拟机来部署应用，因为这样太费时间了，而是创建一个大的虚拟机，然后在大的虚拟机里面再划分容器，而不同的用户不共享大的虚拟机，可以实现操作系统内核的隔离。这又是一次合久必分的过程。由IaaS层的虚拟机池，划分为更细粒度的容器池。 容器管理平台 有了容器的管理平台，又是一次分久必合的过程。 容器的粒度更加细，管理起来更难管，甚至是手动操作难以应对的。假设你有100台物理机，其实规模不是太大，用Excel人工管理是没问题的，但是一台上面开10台虚拟机，虚拟机的个数就是1000台，人工管理已经很困难了，但是一台虚拟机里面开10个容器，就是10000个容器，你是不是已经彻底放弃人工运维的想法了。 所以容器层面的管理平台是一个新的挑战，关键字就是自动化： 自发现：容器与容器之间的相互配置还能像虚拟机一样，记住IP地址，然后互相配置吗？这么多容器，你怎么记得住一旦一台虚拟机挂了重启，IP改变，应该改哪些配置，列表长度至少万行级别的啊。所以容器之间的配置通过名称来的，无论容器跑到哪台机器上，名称不变，就能访问到。 自修复：容器挂了，或是进程宕机了，能像虚拟机那样，登陆上去查看一下进程状态，如果不正常重启一下么？你要登陆万台docker了。所以容器的进程挂了，容器就自动挂掉了，然后自动重启。 弹性自伸缩 Auto Scaling：当容器的性能不足的时候，需要手动伸缩，手动部署么？当然也要自动来。 当前火热的容器管理平台有三大流派： 一个是Kubernetes，我们称为段誉型。段誉(Kubernetes)的父亲(Borg)武功高强，出身皇族(Google)，管理过偌大的一个大理国(Borg是Google数据中心的容器管理平台)。作为大理段式后裔，段誉的武功基因良好(Kubernetes的理念设计比较完善)，周围的高手云集，习武环境也好(Kubernetes生态活跃，热度高)，虽然刚刚出道的段誉武功不及其父亲，但是只要跟着周围的高手不断切磋，武功既可以飞速提升。 一个是Mesos，我们称为乔峰型。乔峰(Mesos)的主要功夫降龙十八掌(Mesos的调度功能)独步武林，为其他帮派所无。而且乔峰也管理过人数众多的丐帮(Mesos管理过Tweeter的容器集群)。后来乔峰从丐帮出来，在江湖中特例独行(Mesos的创始人成立了公司Mesosphere)。乔峰的优势在于，乔峰的降龙十八掌(Mesos)就是在丐帮中使用的降龙十八掌，相比与段誉初学其父的武功来说，要成熟很多。但是缺点是，降龙十八掌只掌握在少数的几个丐帮帮主手中(Mesos社区还是以Mesosphere为主导)，其他丐帮兄弟只能远远崇拜乔峰，而无法相互切磋(社区热度不足)。 一个是Swarm，我们称为慕容型。慕容家族(Swarm是Docker家族的集群管理软件)的个人功夫是非常棒的(Docker可以说称为容器的事实标准)，但是看到段誉和乔峰能够管理的组织规模越来越大，有一统江湖的趋势，着实眼红了，于是开始想创建自己的慕容鲜卑帝国(推出Swarm容器集群管理软件)。但是个人功夫好，并不代表着组织能力强(Swarm的集群管理能力)，好在慕容家族可以借鉴段誉和乔峰的组织管理经验，学习各家公司，以彼之道，还施彼身，使得慕容公子的组织能力(Swarm借鉴了很多前面的集群管理思想)也在逐渐的成熟中。 三大容器门派，到底鹿死谁手，谁能一统江湖，尚未可知。 网易之所以选型Kubernetes作为自己的容器管理平台，是因为基于 Borg 成熟的经验打造的 Kubernetes，为容器编排管理提供了完整的开源方案，并且社区活跃，生态完善，积累了大量分布式、服务化系统架构的最佳实践。 容器初体验 想不想尝试一下最先进的容器管理平台呢？我们先了解一下Docker的生命周期。如图所示。 图中最中间就是最核心的两个部分，一个是镜像Images，一个是容器Containers。镜像运行起来就是容器。容器运行的过程中，基于原始镜像做了改变，比如安装了程序，添加了文件，也可以提交回去(commit)成为镜像。如果大家安装过系统，镜像有点像GHOST镜像，从GHOST镜像安装一个系统，运行起来，就相当于容器；容器里面自带应用，就像GHOST镜像安装的系统里面不是裸的操作系统，里面可能安装了微信，QQ，视频播放软件等。安装好的系统使用的过程中又安装了其他的软件，或者下载了文件，还可以将这个系统重新GHOST成一个镜像，当其他人通过这个镜像再安装系统的时候，则其他的软件也就自带了。 普通的GHOST镜像就是一个文件，但是管理不方便，比如如果有十个GHOST镜像的话，你可能已经记不清楚哪个镜像里面安装了哪个版本的软件了。所以容器镜像有tag的概念，就是一个标签，比如dev-1.0，dev-1.1，production-1.1等，凡是能够帮助你区分不同镜像的，都可以。为了镜像的统一管理，有一个镜像库的东西，可以通过push将本地的镜像放到统一的镜像库中保存，可以通过pull将镜像库中的镜像拉到本地来。 从镜像运行一个容器可使用下面的命令，如果初步使用Docker，记下下面这一个命令就可以了。 这行命令会启动一个里面安装了mysql的容器。其中docker run就是运行一个容器；--name就是给这个容器起个名字；-v 就是挂数据盘，将外面的一个目录/my/own/datadir挂载到容器里面的一个目录/var/lib/mysql作为数据盘，外面的目录是在容器所运行的主机上的，也可以是远程的一个云盘；-e 是设置容器运行环境的环境变量，环境变量是最常使用的设置参数的方式，例如这里设置mysql的密码。mysql:tag就是镜像的名字和标签。 docker stop可以停止这个容器，start可以再启动这个容器，restart可以重启这个容器。在容器内部做了改变，例如安装了新的软件，产生了新的文件，则调用docker commit变成新的镜像。 镜像生产过程，除了可以通过启动一个docker，手动修改，然后调用docker commit形成新镜像之外，还可以通过书写Dockerfile，通过docker build来编译这个Dockerfile来形成新镜像。为什么要这样做呢？前面的方式太不自动化了，需要手工干预，而且还经常会忘了手工都做了什么。用Dockerfile可以很好的解决这个问题。 Dockerfile的一个简单的例子如下： 这其实是一个镜像的生产说明书，Docker build的过程就是根据这个生产说明书来生产镜像： FROM基础镜像，先下载这个基础镜像，然后从这个镜像启动一个容器，并且登陆到容器里面； RUN运行一个命令，在容器里面运行这个命令； COPY/ADD将一些文件添加到容器里面； 最终给容器设置启动命令 ENTRYPOINT，这个命令不在镜像生成过程中执行，而是在容器运行的时候作为主程序执行； 将所有的修改commit成镜像。 这里需要说明一下的就是主程序，是Docker里面一个重要的概念，虽然镜像里面可以安装很多的程序，但是必须有一个主程序，主程序和容器的生命周期完全一致，主程序在则容器在，主程序亡则容器亡。 就像图中展示的一样，容器是一个资源限制的框，但是这个框没有底，全靠主进程撑着，主进程挂了，衣服架子倒了，衣服也就垮了。 了解了如何运行一个独立的容器，接下来介绍如何使用容器管理平台。 容器管理平台初体验 容器管理平台会对容器做更高的抽象，容器不再是单打独斗，而且组成集团军共同战斗。多个容器组成一个Pod，这几个容器亲如兄弟，干的也是相关性很强的活，能够通过localhost访问彼此，真是兄弟齐心，力可断金。有的任务一帮兄弟还刚不住，就需要多个Pod合力完成，这个由ReplicationController进行控制，可以将一个Pod复制N个副本，同时承载任务，众人拾柴火焰高。 N个Pod如果对外散兵作战，一是无法合力，二是给人很乱的感觉，因而需要有一个老大，作为代言人，将大家团结起来，一致对外，这就是Service。老大对外提供统一的虚拟IP和端口，并将这个IP和服务名关联起来，访问服务名，则自动映射为虚拟IP。老大的意思就是，如果外面要访问我这个团队，喊一声名字就可以，例如”雷锋班，帮敬老院打扫卫生！”，你不用管雷锋班的那个人去打扫卫生，每个人打扫哪一部分，班长会统一分配。 最上层通过namespace分隔完全隔离的环境，例如生产环境，测试环境，开发环境等。就像军队分华北野战军，东北野战军一样。野战军立正，出发，部署一个Tomcat的Java应用。 微信公众号【Java技术江湖】一位阿里 Java 工程师的技术小站。（关注公众号后回复”Java“即可领取 Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源） ​
2018-07-10
优秀的个人博客,低调大师

后端技术杂谈3：Lucene基础原理与实践

一、总论 根据lucene.apache.org/java/docs/i…定义： Lucene是一个高效的，基于Java的全文检索库。 所以在了解Lucene之前要费一番工夫了解一下全文检索。 那么什么叫做全文检索呢？这要从我们生活中的数据说起。 我们生活中的数据总体分为两种：结构化数据和非结构化数据。 结构化数据：指具有固定格式或有限长度的数据，如数据库，元数据等。 非结构化数据：指不定长或无固定格式的数据，如邮件，word文档等。 当然有的地方还会提到第三种，半结构化数据，如XML，HTML等，当根据需要可按结构化数据来处理，也可抽取出纯文本按非结构化数据来处理。 非结构化数据又一种叫法叫全文数据。 按照数据的分类，搜索也分为两种： 对结构化数据的搜索：如对数据库的搜索，用SQL语句。再如对元数据的搜索，如利用windows搜索对文件名，类型，修改时间进行搜索等。 对非结构化数据的搜索：如利用windows的搜索也可以搜索文件内容，Linux下的grep命令，再如用Google和百度可以搜索大量内容数据。 对非结构化数据也即对全文数据的搜索主要有两种方法： 一种是顺序扫描法(Serial Scanning)：所谓顺序扫描，比如要找内容包含某一个字符串的文件，就是一个文档一个文档的看，对于每一个文档，从头看到尾，如果此文档包含此字符串，则此文档为我们要找的文件，接着看下一个文件，直到扫描完所有的文件。如利用windows的搜索也可以搜索文件内容，只是相当的慢。如果你有一个80G硬盘，如果想在上面找到一个内容包含某字符串的文件，不花他几个小时，怕是做不到。Linux下的grep命令也是这一种方式。大家可能觉得这种方法比较原始，但对于小数据量的文件，这种方法还是最直接，最方便的。但是对于大量的文件，这种方法就很慢了。 有人可能会说，对非结构化数据顺序扫描很慢，对结构化数据的搜索却相对较快（由于结构化数据有一定的结构可以采取一定的搜索算法加快速度），那么把我们的非结构化数据想办法弄得有一定结构不就行了吗？ 这种想法很天然，却构成了全文检索的基本思路，也即将非结构化数据中的一部分信息提取出来，重新组织，使其变得有一定结构，然后对此有一定结构的数据进行搜索，从而达到搜索相对较快的目的。 这部分从非结构化数据中提取出的然后重新组织的信息，我们称之索引。 这种说法比较抽象，举几个例子就很容易明白，比如字典，字典的拼音表和部首检字表就相当于字典的索引，对每一个字的解释是非结构化的，如果字典没有音节表和部首检字表，在茫茫辞海中找一个字只能顺序扫描。然而字的某些信息可以提取出来进行结构化处理，比如读音，就比较结构化，分声母和韵母，分别只有几种可以一一列举，于是将读音拿出来按一定的顺序排列，每一项读音都指向此字的详细解释的页数。我们搜索时按结构化的拼音搜到读音，然后按其指向的页数，便可找到我们的非结构化数据——也即对字的解释。 这种先建立索引，再对索引进行搜索的过程就叫全文检索(Full-text Search)。 下面这幅图来自《Lucene in action》，但却不仅仅描述了Lucene的检索过程，而是描述了全文检索的一般过程。 全文检索大体分两个过程，索引创建(Indexing)和搜索索引(Search)。 索引创建：将现实世界中所有的结构化和非结构化数据提取信息，创建索引的过程。 搜索索引：就是得到用户的查询请求，搜索创建的索引，然后返回结果的过程。 于是全文检索就存在三个重要问题： 1.索引里面究竟存些什么？(Index) 2.如何创建索引？(Indexing) 3.如何对索引进行搜索？(Search) 下面我们顺序对每个个问题进行研究。 二、索引里面究竟存些什么 索引里面究竟需要存些什么呢？ 首先我们来看为什么顺序扫描的速度慢： 其实是由于我们想要搜索的信息和非结构化数据中所存储的信息不一致造成的。 非结构化数据中所存储的信息是每个文件包含哪些字符串，也即已知文件，欲求字符串相对容易，也即是从文件到字符串的映射。而我们想搜索的信息是哪些文件包含此字符串，也即已知字符串，欲求文件，也即从字符串到文件的映射。两者恰恰相反。于是如果索引总能够保存从字符串到文件的映射，则会大大提高搜索速度。 由于从字符串到文件的映射是文件到字符串映射的反向过程，于是保存这种信息的索引称为反向索引。 反向索引的所保存的信息一般如下： 假设我的文档集合里面有100篇文档，为了方便表示，我们为文档编号从1到100，得到下面的结构 左边保存的是一系列字符串，称为词典。 每个字符串都指向包含此字符串的文档(Document)链表，此文档链表称为倒排表(Posting List)。 有了索引，便使保存的信息和要搜索的信息一致，可以大大加快搜索的速度。 比如说，我们要寻找既包含字符串“lucene”又包含字符串“solr”的文档，我们只需要以下几步： 1. 取出包含字符串“lucene”的文档链表。 2. 取出包含字符串“solr”的文档链表。 3. 通过合并链表，找出既包含“lucene”又包含“solr”的文件。 看到这个地方，有人可能会说，全文检索的确加快了搜索的速度，但是多了索引的过程，两者加起来不一定比顺序扫描快多少。的确，加上索引的过程，全文检索不一定比顺序扫描快，尤其是在数据量小的时候更是如此。而对一个很大量的数据创建索引也是一个很慢的过程。 然而两者还是有区别的，顺序扫描是每次都要扫描，而创建索引的过程仅仅需要一次，以后便是一劳永逸的了，每次搜索，创建索引的过程不必经过，仅仅搜索创建好的索引就可以了。 这也是全文搜索相对于顺序扫描的优势之一：一次索引，多次使用。 三、如何创建索引 全文检索的索引创建过程一般有以下几步： 第一步：一些要索引的原文档(Document)。 为了方便说明索引创建过程，这里特意用两个文件为例： 文件一：Students should be allowed to go out with their friends, but not allowed to drink beer. 文件二：My friend Jerry went to school to see his students but found them drunk which is not allowed. 第二步：将原文档传给分次组件(Tokenizer)。 分词组件(Tokenizer)会做以下几件事情(此过程称为Tokenize)： 1.将文档分成一个一个单独的单词。 2.去除标点符号。 3.去除停词(Stop word)。 所谓停词(Stop word)就是一种语言中最普通的一些单词，由于没有特别的意义，因而大多数情况下不能成为搜索的关键词，因而创建索引时，这种词会被去掉而减少索引的大小。 英语中挺词(Stop word)如：“the”,“a”，“this”等。 对于每一种语言的分词组件(Tokenizer)，都有一个停词(stop word)集合。 经过分词(Tokenizer)后得到的结果称为词元(Token)。 在我们的例子中，便得到以下词元(Token)： “Students”，“allowed”，“go”，“their”，“friends”，“allowed”，“drink”，“beer”，“My”，“friend”，“Jerry”，“went”，“school”，“see”，“his”，“students”，“found”，“them”，“drunk”，“allowed”。 第三步：将得到的词元(Token)传给语言处理组件(Linguistic Processor)。 语言处理组件(linguistic processor)主要是对得到的词元(Token)做一些同语言相关的处理。 对于英语，语言处理组件(Linguistic Processor)一般做以下几点： 1.变为小写(Lowercase)。 2.将单词缩减为词根形式，如“cars”到“car”等。这种操作称为：stemming。 3.将单词转变为词根形式，如“drove”到“drive”等。这种操作称为：lemmatization。 Stemming 和 lemmatization的异同： 相同之处：Stemming和lemmatization都要使词汇成为词根形式。 两者的方式不同： Stemming采用的是“缩减”的方式：“cars”到“car”，“driving”到“drive”。 Lemmatization采用的是“转变”的方式：“drove”到“drove”，“driving”到“drive”。 两者的算法不同： Stemming主要是采取某种固定的算法来做这种缩减，如去除“s”，去除“ing”加“e”，将“ational”变为“ate”，将“tional”变为“tion”。 Lemmatization主要是采用保存某种字典的方式做这种转变。比如字典中有“driving”到“drive”，“drove”到“drive”，“am, is, are”到“be”的映射，做转变时，只要查字典就可以了。 Stemming和lemmatization不是互斥关系，是有交集的，有的词利用这两种方式都能达到相同的转换。 语言处理组件(linguistic processor)的结果称为词(Term)。 在我们的例子中，经过语言处理，得到的词(Term)如下： “student”，“allow”，“go”，“their”，“friend”，“allow”，“drink”，“beer”，“my”，“friend”，“jerry”，“go”，“school”，“see”，“his”，“student”，“find”，“them”，“drink”，“allow”。 也正是因为有语言处理的步骤，才能使搜索drove，而drive也能被搜索出来。 第四步：将得到的词(Term)传给索引组件(Indexer)。 索引组件(Indexer)主要做以下几件事情： 1. 利用得到的词(Term)创建一个字典。 在我们的例子中字典如下： Term Document ID student 1 allow 1 go 1 their 1 friend 1 allow 1 drink 1 beer 1 my 2 friend 2 jerry 2 go 2 school 2 see 2 his 2 student 2 find 2 them 2 drink 2 allow 2 2.对字典按字母顺序进行排序。 Term Document ID allow 1 allow 1 allow 2 beer 1 drink 1 drink 2 find 2 friend 1 friend 2 go 1 go 2 his 2 jerry 2 my 2 school 2 see 2 student 1 student 2 their 1 them 2 3.合并相同的词(Term)成为文档倒排(Posting List)链表。 在此表中，有几个定义： Document Frequency 即文档频次，表示总共有多少文件包含此词(Term)。 Frequency 即词频率，表示此文件中包含了几个此词(Term)。 所以对词(Term) “allow”来讲，总共有两篇文档包含此词(Term)，从而词(Term)后面的文档链表总共有两项，第一项表示包含“allow”的第一篇文档，即1号文档，此文档中，“allow”出现了2次，第二项表示包含“allow”的第二个文档，是2号文档，此文档中，“allow”出现了1次。 到此为止，索引已经创建好了，我们可以通过它很快的找到我们想要的文档。 而且在此过程中，我们惊喜地发现，搜索“drive”，“driving”，“drove”，“driven”也能够被搜到。因为在我们的索引中，“driving”，“drove”，“driven”都会经过语言处理而变成“drive”，在搜索时，如果您输入“driving”，输入的查询语句同样经过我们这里的一到三步，从而变为查询“drive”，从而可以搜索到想要的文档。 三、如何对索引进行搜索？ 到这里似乎我们可以宣布“我们找到想要的文档了”。 然而事情并没有结束，找到了仅仅是全文检索的一个方面。不是吗？如果仅仅只有一个或十个文档包含我们查询的字符串，我们的确找到了。然而如果结果有一千个，甚至成千上万个呢？那个又是您最想要的文件呢？ 打开Google吧，比如说您想在微软找份工作，于是您输入“Microsoft job”，您却发现总共有22600000个结果返回。好大的数字呀，突然发现找不到是一个问题，找到的太多也是一个问题。在如此多的结果中，如何将最相关的放在最前面呢？ 当然Google做的很不错，您一下就找到了jobs at Microsoft。想象一下，如果前几个全部是“Microsoft does a good job at software industry…”将是多么可怕的事情呀。 如何像Google一样，在成千上万的搜索结果中，找到和查询语句最相关的呢？ 如何判断搜索出的文档和查询语句的相关性呢？ 这要回到我们第三个问题：如何对索引进行搜索？ 搜索主要分为以下几步： 第一步：用户输入查询语句。 查询语句同我们普通的语言一样，也是有一定语法的。 不同的查询语句有不同的语法，如SQL语句就有一定的语法。 查询语句的语法根据全文检索系统的实现而不同。最基本的有比如：AND, OR, NOT等。 举个例子，用户输入语句：lucene AND learned NOT hadoop。 说明用户想找一个包含lucene和learned然而不包括hadoop的文档。 第二步：对查询语句进行词法分析，语法分析，及语言处理。 由于查询语句有语法，因而也要进行语法分析，语法分析及语言处理。 1. 词法分析主要用来识别单词和关键字。 如上述例子中，经过词法分析，得到单词有lucene，learned，hadoop, 关键字有AND, NOT。 如果在词法分析中发现不合法的关键字，则会出现错误。如lucene AMD learned，其中由于AND拼错，导致AMD作为一个普通的单词参与查询。 2. 语法分析主要是根据查询语句的语法规则来形成一棵语法树。 如果发现查询语句不满足语法规则，则会报错。如lucene NOT AND learned，则会出错。 如上述例子，lucene AND learned NOT hadoop形成的语法树如下： 3. 语言处理同索引过程中的语言处理几乎相同。 如learned变成learn等。 经过第二步，我们得到一棵经过语言处理的语法树。 第三步：搜索索引，得到符合语法树的文档。 此步骤有分几小步： 首先，在反向索引表中，分别找出包含lucene，learn，hadoop的文档链表。 其次，对包含lucene，learn的链表进行合并操作，得到既包含lucene又包含learn的文档链表。 然后，将此链表与hadoop的文档链表进行差操作，去除包含hadoop的文档，从而得到既包含lucene又包含learn而且不包含hadoop的文档链表。 此文档链表就是我们要找的文档。 第四步：根据得到的文档和查询语句的相关性，对结果进行排序。 虽然在上一步，我们得到了想要的文档，然而对于查询结果应该按照与查询语句的相关性进行排序，越相关者越靠前。 如何计算文档和查询语句的相关性呢？ 不如我们把查询语句看作一片短小的文档，对文档与文档之间的相关性(relevance)进行打分(scoring)，分数高的相关性好，就应该排在前面。 那么又怎么对文档之间的关系进行打分呢？ 这可不是一件容易的事情，首先我们看一看判断人之间的关系吧。 首先看一个人，往往有很多要素，如性格，信仰，爱好，衣着，高矮，胖瘦等等。 其次对于人与人之间的关系，不同的要素重要性不同，性格，信仰，爱好可能重要些，衣着，高矮，胖瘦可能就不那么重要了，所以具有相同或相似性格，信仰，爱好的人比较容易成为好的朋友，然而衣着，高矮，胖瘦不同的人，也可以成为好的朋友。 因而判断人与人之间的关系，首先要找出哪些要素对人与人之间的关系最重要，比如性格，信仰，爱好。其次要判断两个人的这些要素之间的关系，比如一个人性格开朗，另一个人性格外向，一个人信仰佛教，另一个信仰上帝，一个人爱好打篮球，另一个爱好踢足球。我们发现，两个人在性格方面都很积极，信仰方面都很善良，爱好方面都爱运动，因而两个人关系应该会很好。 我们再来看看公司之间的关系吧。 首先看一个公司，有很多人组成，如总经理，经理，首席技术官，普通员工，保安，门卫等。 其次对于公司与公司之间的关系，不同的人重要性不同，总经理，经理，首席技术官可能更重要一些，普通员工，保安，门卫可能较不重要一点。所以如果两个公司总经理，经理，首席技术官之间关系比较好，两个公司容易有比较好的关系。然而一位普通员工就算与另一家公司的一位普通员工有血海深仇，怕也难影响两个公司之间的关系。 因而判断公司与公司之间的关系，首先要找出哪些人对公司与公司之间的关系最重要，比如总经理，经理，首席技术官。其次要判断这些人之间的关系，不如两家公司的总经理曾经是同学，经理是老乡，首席技术官曾是创业伙伴。我们发现，两家公司无论总经理，经理，首席技术官，关系都很好，因而两家公司关系应该会很好。 分析了两种关系，下面看一下如何判断文档之间的关系了。 首先，一个文档有很多词(Term)组成，如search, lucene, full-text, this, a, what等。 其次对于文档之间的关系，不同的Term重要性不同，比如对于本篇文档，search, Lucene, full-text就相对重要一些，this, a , what可能相对不重要一些。所以如果两篇文档都包含search, Lucene，fulltext，这两篇文档的相关性好一些，然而就算一篇文档包含this, a, what，另一篇文档不包含this, a, what，也不能影响两篇文档的相关性。 因而判断文档之间的关系，首先找出哪些词(Term)对文档之间的关系最重要，如search, Lucene, fulltext。然后判断这些词(Term)之间的关系。 找出词(Term)对文档的重要性的过程称为计算词的权重(Term weight)的过程。 计算词的权重(term weight)有两个参数，第一个是词(Term)，第二个是文档(Document)。 词的权重(Term weight)表示此词(Term)在此文档中的重要程度，越重要的词(Term)有越大的权重(Term weight)，因而在计算文档之间的相关性中将发挥更大的作用。 判断词(Term)之间的关系从而得到文档相关性的过程应用一种叫做向量空间模型的算法(Vector Space Model)。 下面仔细分析一下这两个过程： 1. 计算权重(Term weight)的过程。 影响一个词(Term)在一篇文档中的重要性主要有两个因素： Term Frequency (tf)：即此Term在此文档中出现了多少次。tf 越大说明越重要。 Document Frequency (df)：即有多少文档包含次Term。df 越大说明越不重要。 容易理解吗？词(Term)在文档中出现的次数越多，说明此词(Term)对该文档越重要，如“搜索”这个词，在本文档中出现的次数很多，说明本文档主要就是讲这方面的事的。然而在一篇英语文档中，this出现的次数更多，就说明越重要吗？不是的，这是由第二个因素进行调整，第二个因素说明，有越多的文档包含此词(Term), 说明此词(Term)太普通，不足以区分这些文档，因而重要性越低。 这也如我们程序员所学的技术，对于程序员本身来说，这项技术掌握越深越好（掌握越深说明花时间看的越多，tf越大），找工作时越有竞争力。然而对于所有程序员来说，这项技术懂得的人越少越好（懂得的人少df小），找工作越有竞争力。人的价值在于不可替代性就是这个道理。 道理明白了，我们来看看公式： 这仅仅只term weight计算公式的简单典型实现。实现全文检索系统的人会有自己的实现，Lucene就与此稍有不同。 2. 判断Term之间的关系从而得到文档相关性的过程，也即向量空间模型的算法(VSM)。 我们把文档看作一系列词(Term)，每一个词(Term)都有一个权重(Term weight)，不同的词(Term)根据自己在文档中的权重来影响文档相关性的打分计算。 于是我们把所有此文档中词(term)的权重(term weight) 看作一个向量。 Document = {term1, term2, …… ,term N} Document Vector = {weight1, weight2, …… ,weight N} 同样我们把查询语句看作一个简单的文档，也用向量来表示。 Query = {term1, term 2, …… , term N} Query Vector = {weight1, weight2, …… , weight N} 我们把所有搜索出的文档向量及查询向量放到一个N维空间中，每个词(term)是一维。 如图： 我们认为两个向量之间的夹角越小，相关性越大。 所以我们计算夹角的余弦值作为相关性的打分，夹角越小，余弦值越大，打分越高，相关性越大。 有人可能会问，查询语句一般是很短的，包含的词(Term)是很少的，因而查询向量的维数很小，而文档很长，包含词(Term)很多，文档向量维数很大。你的图中两者维数怎么都是N呢？ 在这里，既然要放到相同的向量空间，自然维数是相同的，不同时，取二者的并集，如果不含某个词(Term)时，则权重(Term Weight)为0。 相关性打分公式如下： 举个例子，查询语句有11个Term，共有三篇文档搜索出来。其中各自的权重(Term weight)，如下表格。 t10 t11 .477 .477 .176 .176 .176 .477 .954 .176 .176 .176 .176 .176 .176 .477 .176 于是计算，三篇文档同查询语句的相关性打分分别为： 于是文档二相关性最高，先返回，其次是文档一，最后是文档三。 到此为止，我们可以找到我们最想要的文档了。 说了这么多，其实还没有进入到Lucene，而仅仅是信息检索技术(Information retrieval)中的基本理论，然而当我们看过Lucene后我们会发现，Lucene是对这种基本理论的一种基本的的实践。所以在以后分析Lucene的文章中，会常常看到以上理论在Lucene中的应用。 在进入Lucene之前，对上述索引创建和搜索过程所一个总结，如图： 此图参照www.lucene.com.cn/about.htm中文章《开放源代码的全文检索引擎Lucene》 1. 索引过程： 1)有一系列被索引文件 2)被索引文件经过语法分析和语言处理形成一系列词(Term)。 3)经过索引创建形成词典和反向索引表。 4)通过索引存储将索引写入硬盘。 2. 搜索过程： a)用户输入查询语句。 b)对查询语句经过语法分析和语言分析得到一系列词(Term)。 c)通过语法分析得到一个查询树。 d)通过索引存储将索引读入到内存。 e)利用查询树搜索索引，从而得到每个词(Term)的文档链表，对文档链表进行交，差，并得到结果文档。 f)将搜索到的结果文档对查询的相关性进行排序。 g)返回查询结果给用户。 下面我们可以进入Lucene的世界了。 CSDN中此文章链接为blog.csdn.net/forfuture19… Javaeye中此文章链接为forfuture1978.javaeye.com/blog/546771 Spring Boot 中使用 Java API 调用 lucene Github 代码 代码我已放到 Github ，导入spring-boot-lucene-demo项目 githubspring-boot-lucene-demo 添加依赖 <!--对分词索引查询解析--> <dependency> <groupId>org.apache.lucene</groupId> <artifactId>lucene-queryparser</artifactId> <version>7.1.0</version> </dependency> <!--高亮 --> <dependency> <groupId>org.apache.lucene</groupId> <artifactId>lucene-highlighter</artifactId> <version>7.1.0</version> </dependency> <!--smartcn 中文分词器 SmartChineseAnalyzer smartcn分词器 需要lucene依赖 且和lucene版本同步--> <dependency> <groupId>org.apache.lucene</groupId> <artifactId>lucene-analyzers-smartcn</artifactId> <version>7.1.0</version> </dependency> <!--ik-analyzer 中文分词器--> <dependency> <groupId>cn.bestwu</groupId> <artifactId>ik-analyzers</artifactId> <version>5.1.0</version> </dependency> <!--MMSeg4j 分词器--> <dependency> <groupId>com.chenlb.mmseg4j</groupId> <artifactId>mmseg4j-solr</artifactId> <version>2.4.0</version> <exclusions> <exclusion> <groupId>org.apache.solr</groupId> <artifactId>solr-core</artifactId> </exclusion> </exclusions> </dependency> 配置 lucene private Directory directory; private IndexReader indexReader; private IndexSearcher indexSearcher; @Before public void setUp() throws IOException { //索引存放的位置，设置在当前目录中 directory = FSDirectory.open(Paths.get("indexDir/")); //创建索引的读取器 indexReader = DirectoryReader.open(directory); //创建一个索引的查找器，来检索索引库 indexSearcher = new IndexSearcher(indexReader); } @After public void tearDown() throws Exception { indexReader.close(); } ** * 执行查询，并打印查询到的记录数 * * @param query * @throws IOException */ public void executeQuery(Query query) throws IOException { TopDocs topDocs = indexSearcher.search(query, 100); //打印查询到的记录数 System.out.println("总共查询到" + topDocs.totalHits + "个文档"); for (ScoreDoc scoreDoc : topDocs.scoreDocs) { //取得对应的文档对象 Document document = indexSearcher.doc(scoreDoc.doc); System.out.println("id：" + document.get("id")); System.out.println("title：" + document.get("title")); System.out.println("content：" + document.get("content")); } } /** * 分词打印 * * @param analyzer * @param text * @throws IOException */ public void printAnalyzerDoc(Analyzer analyzer, String text) throws IOException { TokenStream tokenStream = analyzer.tokenStream("content", new StringReader(text)); CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class); try { tokenStream.reset(); while (tokenStream.incrementToken()) { System.out.println(charTermAttribute.toString()); } tokenStream.end(); } finally { tokenStream.close(); analyzer.close(); } } 创建索引 @Test public void indexWriterTest() throws IOException { long start = System.currentTimeMillis(); //索引存放的位置，设置在当前目录中 Directory directory = FSDirectory.open(Paths.get("indexDir/")); //在 6.6 以上版本中 version 不再是必要的，并且，存在无参构造方法，可以直接使用默认的 StandardAnalyzer 分词器。 Version version = Version.LUCENE_7_1_0; //Analyzer analyzer = new StandardAnalyzer(); // 标准分词器，适用于英文 //Analyzer analyzer = new SmartChineseAnalyzer();//中文分词 //Analyzer analyzer = new ComplexAnalyzer();//中文分词 //Analyzer analyzer = new IKAnalyzer();//中文分词 Analyzer analyzer = new IKAnalyzer();//中文分词 //创建索引写入配置 IndexWriterConfig indexWriterConfig = new IndexWriterConfig(analyzer); //创建索引写入对象 IndexWriter indexWriter = new IndexWriter(directory, indexWriterConfig); //创建Document对象，存储索引 Document doc = new Document(); int id = 1; //将字段加入到doc中 doc.add(new IntPoint("id", id)); doc.add(new StringField("title", "Spark", Field.Store.YES)); doc.add(new TextField("content", "Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎", Field.Store.YES)); doc.add(new StoredField("id", id)); //将doc对象保存到索引库中 indexWriter.addDocument(doc); indexWriter.commit(); //关闭流 indexWriter.close(); long end = System.currentTimeMillis(); System.out.println("索引花费了" + (end - start) + " 毫秒"); } 响应 17:58:14.655 [main] DEBUG org.wltea.analyzer.dic.Dictionary - 加载扩展词典：ext.dic 17:58:14.660 [main] DEBUG org.wltea.analyzer.dic.Dictionary - 加载扩展停止词典：stopword.dic 索引花费了879 毫秒 删除文档 @Test public void deleteDocumentsTest() throws IOException { //Analyzer analyzer = new StandardAnalyzer(); // 标准分词器，适用于英文 //Analyzer analyzer = new SmartChineseAnalyzer();//中文分词 //Analyzer analyzer = new ComplexAnalyzer();//中文分词 //Analyzer analyzer = new IKAnalyzer();//中文分词 Analyzer analyzer = new IKAnalyzer();//中文分词 //创建索引写入配置 IndexWriterConfig indexWriterConfig = new IndexWriterConfig(analyzer); //创建索引写入对象 IndexWriter indexWriter = new IndexWriter(directory, indexWriterConfig); // 删除title中含有关键词“Spark”的文档 long count = indexWriter.deleteDocuments(new Term("title", "Spark")); // 除此之外IndexWriter还提供了以下方法： // DeleteDocuments(Query query):根据Query条件来删除单个或多个Document // DeleteDocuments(Query[] queries):根据Query条件来删除单个或多个Document // DeleteDocuments(Term term):根据Term来删除单个或多个Document // DeleteDocuments(Term[] terms):根据Term来删除单个或多个Document // DeleteAll():删除所有的Document //使用IndexWriter进行Document删除操作时，文档并不会立即被删除，而是把这个删除动作缓存起来，当IndexWriter.Commit()或IndexWriter.Close()时，删除操作才会被真正执行。 indexWriter.commit(); indexWriter.close(); System.out.println("删除完成:" + count); } 响应 删除完成:1 更新文档 /** * 测试更新 * 实际上就是删除后新增一条 * * @throws IOException */ @Test public void updateDocumentTest() throws IOException { //Analyzer analyzer = new StandardAnalyzer(); // 标准分词器，适用于英文 //Analyzer analyzer = new SmartChineseAnalyzer();//中文分词 //Analyzer analyzer = new ComplexAnalyzer();//中文分词 //Analyzer analyzer = new IKAnalyzer();//中文分词 Analyzer analyzer = new IKAnalyzer();//中文分词 //创建索引写入配置 IndexWriterConfig indexWriterConfig = new IndexWriterConfig(analyzer); //创建索引写入对象 IndexWriter indexWriter = new IndexWriter(directory, indexWriterConfig); Document doc = new Document(); int id = 1; doc.add(new IntPoint("id", id)); doc.add(new StringField("title", "Spark", Field.Store.YES)); doc.add(new TextField("content", "Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎", Field.Store.YES)); doc.add(new StoredField("id", id)); long count = indexWriter.updateDocument(new Term("id", "1"), doc); System.out.println("更新文档:" + count); indexWriter.close(); } 响应 更新文档:1 按词条搜索 /** * 按词条搜索 * <p> * TermQuery是最简单、也是最常用的Query。TermQuery可以理解成为“词条搜索”， * 在搜索引擎中最基本的搜索就是在索引中搜索某一词条，而TermQuery就是用来完成这项工作的。 * 在Lucene中词条是最基本的搜索单位，从本质上来讲一个词条其实就是一个名/值对。 * 只不过这个“名”是字段名，而“值”则表示字段中所包含的某个关键字。 * * @throws IOException */ @Test public void termQueryTest() throws IOException { String searchField = "title"; //这是一个条件查询的api，用于添加条件 TermQuery query = new TermQuery(new Term(searchField, "Spark")); //执行查询，并打印查询到的记录数 executeQuery(query); } 响应 总共查询到1个文档 id：1 title：Spark content：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎! 多条件查询 /** * 多条件查询 * * BooleanQuery也是实际开发过程中经常使用的一种Query。 * 它其实是一个组合的Query，在使用时可以把各种Query对象添加进去并标明它们之间的逻辑关系。 * BooleanQuery本身来讲是一个布尔子句的容器，它提供了专门的API方法往其中添加子句， * 并标明它们之间的关系，以下代码为BooleanQuery提供的用于添加子句的API接口： * * @throws IOException */ @Test public void BooleanQueryTest() throws IOException { String searchField1 = "title"; String searchField2 = "content"; Query query1 = new TermQuery(new Term(searchField1, "Spark")); Query query2 = new TermQuery(new Term(searchField2, "Apache")); BooleanQuery.Builder builder = new BooleanQuery.Builder(); // BooleanClause用于表示布尔查询子句关系的类， // 包 括： // BooleanClause.Occur.MUST， // BooleanClause.Occur.MUST_NOT， // BooleanClause.Occur.SHOULD。 // 必须包含,不能包含,可以包含三种.有以下6种组合： // // 1．MUST和MUST：取得连个查询子句的交集。 // 2．MUST和MUST_NOT：表示查询结果中不能包含MUST_NOT所对应得查询子句的检索结果。 // 3．SHOULD与MUST_NOT：连用时，功能同MUST和MUST_NOT。 // 4．SHOULD与MUST连用时，结果为MUST子句的检索结果,但是SHOULD可影响排序。 // 5．SHOULD与SHOULD：表示“或”关系，最终检索结果为所有检索子句的并集。 // 6．MUST_NOT和MUST_NOT：无意义，检索无结果。 builder.add(query1, BooleanClause.Occur.SHOULD); builder.add(query2, BooleanClause.Occur.SHOULD); BooleanQuery query = builder.build(); //执行查询，并打印查询到的记录数 executeQuery(query); } 响应 总共查询到1个文档 id：1 title：Spark content：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎! 匹配前缀 /** * 匹配前缀 * <p> * PrefixQuery用于匹配其索引开始以指定的字符串的文档。就是文档中存在xxx% * <p> * * @throws IOException */ @Test public void prefixQueryTest() throws IOException { String searchField = "title"; Term term = new Term(searchField, "Spar"); Query query = new PrefixQuery(term); //执行查询，并打印查询到的记录数 executeQuery(query); } 响应 总共查询到1个文档 id：1 title：Spark content：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎! 短语搜索 /** * 短语搜索 * <p> * 所谓PhraseQuery，就是通过短语来检索，比如我想查“big car”这个短语， * 那么如果待匹配的document的指定项里包含了"big car"这个短语， * 这个document就算匹配成功。可如果待匹配的句子里包含的是“big black car”， * 那么就无法匹配成功了，如果也想让这个匹配，就需要设定slop， * 先给出slop的概念：slop是指两个项的位置之间允许的最大间隔距离 * * @throws IOException */ @Test public void phraseQueryTest() throws IOException { String searchField = "content"; String query1 = "apache"; String query2 = "spark"; PhraseQuery.Builder builder = new PhraseQuery.Builder(); builder.add(new Term(searchField, query1)); builder.add(new Term(searchField, query2)); builder.setSlop(0); PhraseQuery phraseQuery = builder.build(); //执行查询，并打印查询到的记录数 executeQuery(phraseQuery); } 响应 总共查询到1个文档 id：1 title：Spark content：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎! 相近词语搜索 /** * 相近词语搜索 * <p> * FuzzyQuery是一种模糊查询，它可以简单地识别两个相近的词语。 * * @throws IOException */ @Test public void fuzzyQueryTest() throws IOException { String searchField = "content"; Term t = new Term(searchField, "大规模"); Query query = new FuzzyQuery(t); //执行查询，并打印查询到的记录数 executeQuery(query); } 响应 总共查询到1个文档 id：1 title：Spark content：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎! 通配符搜索 /** * 通配符搜索 * <p> * Lucene也提供了通配符的查询，这就是WildcardQuery。 * 通配符“?”代表1个字符，而“*”则代表0至多个字符。 * * @throws IOException */ @Test public void wildcardQueryTest() throws IOException { String searchField = "content"; Term term = new Term(searchField, "大*规模"); Query query = new WildcardQuery(term); //执行查询，并打印查询到的记录数 executeQuery(query); } 响应 总共查询到1个文档 id：1 title：Spark content：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎! 分词查询 /** * 分词查询 * * @throws IOException * @throws ParseException */ @Test public void queryParserTest() throws IOException, ParseException { //Analyzer analyzer = new StandardAnalyzer(); // 标准分词器，适用于英文 //Analyzer analyzer = new SmartChineseAnalyzer();//中文分词 //Analyzer analyzer = new ComplexAnalyzer();//中文分词 //Analyzer analyzer = new IKAnalyzer();//中文分词 Analyzer analyzer = new IKAnalyzer();//中文分词 String searchField = "content"; //指定搜索字段和分析器 QueryParser parser = new QueryParser(searchField, analyzer); //用户输入内容 Query query = parser.parse("计算引擎"); //执行查询，并打印查询到的记录数 executeQuery(query); } 响应 总共查询到1个文档 id：1 title：Spark content：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎! 多个 Field 分词查询 /** * 多个 Field 分词查询 * * @throws IOException * @throws ParseException */ @Test public void multiFieldQueryParserTest() throws IOException, ParseException { //Analyzer analyzer = new StandardAnalyzer(); // 标准分词器，适用于英文 //Analyzer analyzer = new SmartChineseAnalyzer();//中文分词 //Analyzer analyzer = new ComplexAnalyzer();//中文分词 //Analyzer analyzer = new IKAnalyzer();//中文分词 Analyzer analyzer = new IKAnalyzer();//中文分词 String[] filedStr = new String[]{"title", "content"}; //指定搜索字段和分析器 QueryParser queryParser = new MultiFieldQueryParser(filedStr, analyzer); //用户输入内容 Query query = queryParser.parse("Spark"); //执行查询，并打印查询到的记录数 executeQuery(query); } 响应 总共查询到1个文档 id：1 title：Spark content：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎! 中文分词器 /** * IKAnalyzer 中文分词器 * SmartChineseAnalyzer smartcn分词器 需要lucene依赖 且和lucene版本同步 * * @throws IOException */ @Test public void AnalyzerTest() throws IOException { //Analyzer analyzer = new StandardAnalyzer(); // 标准分词器，适用于英文 //Analyzer analyzer = new SmartChineseAnalyzer();//中文分词 //Analyzer analyzer = new ComplexAnalyzer();//中文分词 //Analyzer analyzer = new IKAnalyzer();//中文分词 Analyzer analyzer = null; String text = "Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎"; analyzer = new IKAnalyzer();//IKAnalyzer 中文分词 printAnalyzerDoc(analyzer, text); System.out.println(); analyzer = new ComplexAnalyzer();//MMSeg4j 中文分词 printAnalyzerDoc(analyzer, text); System.out.println(); analyzer = new SmartChineseAnalyzer();//Lucene 中文分词器 printAnalyzerDoc(analyzer, text); } 三种分词响应 apache spark 专为 大规模 规模 模数 数据处理 数据 处理 而设 设计 快速 通用 计算 引擎 apache spark 是 专为 大规模 数据处理 而 设计 的 快速 通用 的 计算 引擎 apach spark 是 专 为 大规模 数据 处理 而 设计 的 快速 通用 的 计算 引擎 高亮处理 /** * 高亮处理 * * @throws IOException */ @Test public void HighlighterTest() throws IOException, ParseException, InvalidTokenOffsetsException { //Analyzer analyzer = new StandardAnalyzer(); // 标准分词器，适用于英文 //Analyzer analyzer = new SmartChineseAnalyzer();//中文分词 //Analyzer analyzer = new ComplexAnalyzer();//中文分词 //Analyzer analyzer = new IKAnalyzer();//中文分词 Analyzer analyzer = new IKAnalyzer();//中文分词 String searchField = "content"; String text = "Apache Spark 大规模数据处理"; //指定搜索字段和分析器 QueryParser parser = new QueryParser(searchField, analyzer); //用户输入内容 Query query = parser.parse(text); TopDocs topDocs = indexSearcher.search(query, 100); // 关键字高亮显示的html标签，需要导入lucene-highlighter-xxx.jar SimpleHTMLFormatter simpleHTMLFormatter = new SimpleHTMLFormatter("<span style='color:red'>", "</span>"); Highlighter highlighter = new Highlighter(simpleHTMLFormatter, new QueryScorer(query)); for (ScoreDoc scoreDoc : topDocs.scoreDocs) { //取得对应的文档对象 Document document = indexSearcher.doc(scoreDoc.doc); // 内容增加高亮显示 TokenStream tokenStream = analyzer.tokenStream("content", new StringReader(document.get("content"))); String content = highlighter.getBestFragment(tokenStream, document.get("content")); System.out.println(content); } } 微信公众号【Java技术江湖】一位阿里 Java 工程师的技术小站。（关注公众号后回复”Java“即可领取 Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源） ​
2018-07-09
优秀的个人博客,低调大师

后端技术杂谈4：Elasticsearch与solr入门实践

阮一峰：全文搜索引擎 Elasticsearch 入门教程 阅读 1093 收藏 76 2017-08-23 原文链接： www.ruanyifeng.com 9月7日-8日 北京，与 Google Twitch 等团队技术大咖面对面www.bagevent.com 全文搜索属于最常见的需求，开源的Elasticsearch（以下简称 Elastic）是目前全文搜索引擎的首选。 它可以快速地储存、搜索和分析海量数据。维基百科、Stack Overflow、Github 都采用它。 Elastic 的底层是开源库Lucene。但是，你没法直接用 Lucene，必须自己写代码去调用它的接口。Elastic 是 Lucene 的封装，提供了 REST API 的操作接口，开箱即用。 本文从零开始，讲解如何使用 Elastic 搭建自己的全文搜索引擎。每一步都有详细的说明，大家跟着做就能学会。 一、安装 Elastic 需要 Java 8 环境。如果你的机器还没安装 Java，可以参考这篇文章，注意要保证环境变量JAVA_HOME正确设置。 安装完 Java，就可以跟着官方文档安装 Elastic。直接下载压缩包比较简单。 $ wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-5.5.1.zip $ unzip elasticsearch-5.5.1.zip $ cd elasticsearch-5.5.1/ 接着，进入解压后的目录，运行下面的命令，启动 Elastic。 $ ./bin/elasticsearch 如果这时报错"max virtual memory areas vm.maxmapcount [65530] is too low"，要运行下面的命令。 $ sudo sysctl -w vm.max_map_count=262144 如果一切正常，Elastic 就会在默认的9200端口运行。这时，打开另一个命令行窗口，请求该端口，会得到说明信息。 $ curl localhost:9200 { "name" : "atntrTf", "cluster_name" : "elasticsearch", "cluster_uuid" : "tf9250XhQ6ee4h7YI11anA", "version" : { "number" : "5.5.1", "build_hash" : "19c13d0", "build_date" : "2017-07-18T20:44:24.823Z", "build_snapshot" : false, "lucene_version" : "6.6.0" }, "tagline" : "You Know, for Search" } 上面代码中，请求9200端口，Elastic 返回一个 JSON 对象，包含当前节点、集群、版本等信息。 按下 Ctrl + C，Elastic 就会停止运行。 默认情况下，Elastic 只允许本机访问，如果需要远程访问，可以修改 Elastic 安装目录的config/elasticsearch.yml文件，去掉network.host的注释，将它的值改成0.0.0.0，然后重新启动 Elastic。 network.host: 0.0.0.0 上面代码中，设成0.0.0.0让任何人都可以访问。线上服务不要这样设置，要设成具体的 IP。 二、基本概念 2.1 Node 与 Cluster Elastic 本质上是一个分布式数据库，允许多台服务器协同工作，每台服务器可以运行多个 Elastic 实例。 单个 Elastic 实例称为一个节点（node）。一组节点构成一个集群（cluster）。 2.2 Index Elastic 会索引所有字段，经过处理后写入一个反向索引（Inverted Index）。查找数据的时候，直接查找该索引。 所以，Elastic 数据管理的顶层单位就叫做 Index（索引）。它是单个数据库的同义词。每个 Index （即数据库）的名字必须是小写。 下面的命令可以查看当前节点的所有 Index。 $ curl -X GET 'http://localhost:9200/_cat/indices?v' 2.3 Document Index 里面单条的记录称为 Document（文档）。许多条 Document 构成了一个 Index。 Document 使用 JSON 格式表示，下面是一个例子。 { "user": "张三", "title": "工程师", "desc": "数据库管理" } 同一个 Index 里面的 Document，不要求有相同的结构（scheme），但是最好保持相同，这样有利于提高搜索效率。 2.4 Type Document 可以分组，比如weather这个 Index 里面，可以按城市分组（北京和上海），也可以按气候分组（晴天和雨天）。这种分组就叫做 Type，它是虚拟的逻辑分组，用来过滤 Document。 不同的 Type 应该有相似的结构（schema），举例来说，id字段不能在这个组是字符串，在另一个组是数值。这是与关系型数据库的表的一个区别。性质完全不同的数据（比如products和logs）应该存成两个 Index，而不是一个 Index 里面的两个 Type（虽然可以做到）。 下面的命令可以列出每个 Index 所包含的 Type。 $ curl 'localhost:9200/_mapping?pretty=true' 根据规划，Elastic 6.x 版只允许每个 Index 包含一个 Type，7.x 版将会彻底移除 Type。 三、新建和删除 Index 新建 Index，可以直接向 Elastic 服务器发出 PUT 请求。下面的例子是新建一个名叫weather的 Index。 $ curl -X PUT 'localhost:9200/weather' 服务器返回一个 JSON 对象，里面的acknowledged字段表示操作成功。 { "acknowledged":true, "shards_acknowledged":true } 然后，我们发出 DELETE 请求，删除这个 Index。 $ curl -X DELETE 'localhost:9200/weather' 四、中文分词设置 首先，安装中文分词插件。这里使用的是ik，也可以考虑其他插件（比如smartcn）。 $ ./bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v5.5.1/elasticsearch-analysis-ik-5.5.1.zip 上面代码安装的是5.5.1版的插件，与 Elastic 5.5.1 配合使用。 接着，重新启动 Elastic，就会自动加载这个新安装的插件。 然后，新建一个 Index，指定需要分词的字段。这一步根据数据结构而异，下面的命令只针对本文。基本上，凡是需要搜索的中文字段，都要单独设置一下。 $ curl -X PUT 'localhost:9200/accounts' -d ' { "mappings": { "person": { "properties": { "user": { "type": "text", "analyzer": "ik_max_word", "search_analyzer": "ik_max_word" }, "title": { "type": "text", "analyzer": "ik_max_word", "search_analyzer": "ik_max_word" }, "desc": { "type": "text", "analyzer": "ik_max_word", "search_analyzer": "ik_max_word" } } } } }' 上面代码中，首先新建一个名称为accounts的 Index，里面有一个名称为person的 Type。person有三个字段。 user title desc 这三个字段都是中文，而且类型都是文本（text），所以需要指定中文分词器，不能使用默认的英文分词器。 Elastic 的分词器称为analyzer。我们对每个字段指定分词器。 "user": { "type": "text", "analyzer": "ik_max_word", "search_analyzer": "ik_max_word" } 上面代码中，analyzer是字段文本的分词器，search_analyzer是搜索词的分词器。ik_max_word分词器是插件ik提供的，可以对文本进行最大数量的分词。 五、数据操作 5.1 新增记录 向指定的 /Index/Type 发送 PUT 请求，就可以在 Index 里面新增一条记录。比如，向/accounts/person发送请求，就可以新增一条人员记录。 $ curl -X PUT 'localhost:9200/accounts/person/1' -d ' { "user": "张三", "title": "工程师", "desc": "数据库管理" }' 服务器返回的 JSON 对象，会给出 Index、Type、Id、Version 等信息。 { "_index":"accounts", "_type":"person", "_id":"1", "_version":1, "result":"created", "_shards":{"total":2,"successful":1,"failed":0}, "created":true } 如果你仔细看，会发现请求路径是/accounts/person/1，最后的1是该条记录的 Id。它不一定是数字，任意字符串（比如abc）都可以。 新增记录的时候，也可以不指定 Id，这时要改成 POST 请求。 $ curl -X POST 'localhost:9200/accounts/person' -d ' { "user": "李四", "title": "工程师", "desc": "系统管理" }' 上面代码中，向/accounts/person发出一个 POST 请求，添加一个记录。这时，服务器返回的 JSON 对象里面，_id字段就是一个随机字符串。 { "_index":"accounts", "_type":"person", "_id":"AV3qGfrC6jMbsbXb6k1p", "_version":1, "result":"created", "_shards":{"total":2,"successful":1,"failed":0}, "created":true } 注意，如果没有先创建 Index（这个例子是accounts），直接执行上面的命令，Elastic 也不会报错，而是直接生成指定的 Index。所以，打字的时候要小心，不要写错 Index 的名称。 5.2 查看记录 向/Index/Type/Id发出 GET 请求，就可以查看这条记录。 $ curl 'localhost:9200/accounts/person/1?pretty=true' 上面代码请求查看/accounts/person/1这条记录，URL 的参数pretty=true表示以易读的格式返回。 返回的数据中，found字段表示查询成功，_source字段返回原始记录。 { "_index" : "accounts", "_type" : "person", "_id" : "1", "_version" : 1, "found" : true, "_source" : { "user" : "张三", "title" : "工程师", "desc" : "数据库管理" } } 如果 Id 不正确，就查不到数据，found字段就是false。 $ curl 'localhost:9200/weather/beijing/abc?pretty=true' { "_index" : "accounts", "_type" : "person", "_id" : "abc", "found" : false } 5.3 删除记录 删除记录就是发出 DELETE 请求。 $ curl -X DELETE 'localhost:9200/accounts/person/1' 这里先不要删除这条记录，后面还要用到。 5.4 更新记录 更新记录就是使用 PUT 请求，重新发送一次数据。 $ curl -X PUT 'localhost:9200/accounts/person/1' -d ' { "user" : "张三", "title" : "工程师", "desc" : "数据库管理，软件开发" }' { "_index":"accounts", "_type":"person", "_id":"1", "_version":2, "result":"updated", "_shards":{"total":2,"successful":1,"failed":0}, "created":false } 上面代码中，我们将原始数据从"数据库管理"改成"数据库管理，软件开发"。 返回结果里面，有几个字段发生了变化。 "_version" : 2, "result" : "updated", "created" : false 可以看到，记录的 Id 没变，但是版本（version）从1变成2，操作类型（result）从created变成updated，created字段变成false，因为这次不是新建记录。 六、数据查询 6.1 返回所有记录 使用 GET 方法，直接请求/Index/Type/_search，就会返回所有记录。 $ curl 'localhost:9200/accounts/person/_search' { "took":2, "timed_out":false, "_shards":{"total":5,"successful":5,"failed":0}, "hits":{ "total":2, "max_score":1.0, "hits":[ { "_index":"accounts", "_type":"person", "_id":"AV3qGfrC6jMbsbXb6k1p", "_score":1.0, "_source": { "user": "李四", "title": "工程师", "desc": "系统管理" } }, { "_index":"accounts", "_type":"person", "_id":"1", "_score":1.0, "_source": { "user" : "张三", "title" : "工程师", "desc" : "数据库管理，软件开发" } } ] } } 上面代码中，返回结果的took字段表示该操作的耗时（单位为毫秒），timed_out字段表示是否超时，hits字段表示命中的记录，里面子字段的含义如下。 total：返回记录数，本例是2条。 max_score：最高的匹配程度，本例是1.0。 hits：返回的记录组成的数组。 返回的记录中，每条记录都有一个_score字段，表示匹配的程序，默认是按照这个字段降序排列。 6.2 全文搜索 Elastic 的查询非常特别，使用自己的查询语法，要求 GET 请求带有数据体。 $ curl 'localhost:9200/accounts/person/_search' -d ' { "query" : { "match" : { "desc" : "软件" }} }' 上面代码使用Match 查询，指定的匹配条件是desc字段里面包含"软件"这个词。返回结果如下。 { "took":3, "timed_out":false, "_shards":{"total":5,"successful":5,"failed":0}, "hits":{ "total":1, "max_score":0.28582606, "hits":[ { "_index":"accounts", "_type":"person", "_id":"1", "_score":0.28582606, "_source": { "user" : "张三", "title" : "工程师", "desc" : "数据库管理，软件开发" } } ] } } Elastic 默认一次返回10条结果，可以通过size字段改变这个设置。 $ curl 'localhost:9200/accounts/person/_search' -d ' { "query" : { "match" : { "desc" : "管理" }}, "size": 1 }' 上面代码指定，每次只返回一条结果。 还可以通过from字段，指定位移。 $ curl 'localhost:9200/accounts/person/_search' -d ' { "query" : { "match" : { "desc" : "管理" }}, "from": 1, "size": 1 }' 上面代码指定，从位置1开始（默认是从位置0开始），只返回一条结果。 6.3 逻辑运算 如果有多个搜索关键字， Elastic 认为它们是or关系。 $ curl 'localhost:9200/accounts/person/_search' -d ' { "query" : { "match" : { "desc" : "软件 系统" }} }' 上面代码搜索的是软件 or 系统。 如果要执行多个关键词的and搜索，必须使用布尔查询。 $ curl 'localhost:9200/accounts/person/_search' -d ' { "query": { "bool": { "must": [ { "match": { "desc": "软件" } }, { "match": { "desc": "系统" } } ] } } }' 七、参考链接 ElasticSearch 官方手册 A Practical Introduction to Elasticsearch （完） 一、前言 在开发网站/App项目的时候，通常需要搭建搜索服务。比如，新闻类应用需要检索标题/内容，社区类应用需要检索用户/帖子。 对于简单的需求，可以使用数据库的 LIKE 模糊搜索，示例： SELECT * FROM news WHERE title LIKE '%法拉利跑车%' 可以查询到所有标题含有 "法拉利跑车" 关键词的新闻，但是这种方式有明显的弊端： 1、模糊查询性能极低，当数据量庞大的时候，往往会使数据库服务中断； 2、无法查询相关的数据，只能严格在标题中匹配关键词。 因此，需要搭建专门提供搜索功能的服务，具备分词、全文检索等高级功能。 Solr 就是这样一款搜索引擎，可以让你快速搭建适用于自己业务的搜索服务。 二、安装 到官网 http://lucene.apache.org/solr/ 下载安装包，解压并进入 Solr 目录： wget 'http://apache.website-solution.net/lucene/solr/6.2.0/solr-6.2.0.tgz' tar xvf solr-6.2.0.tgz cd solr-6.2.0 目录结构如下： Solr 6.2 目录结构 启动 Solr 服务之前，确认已经安装 Java 1.8 ： 查看 Java 版本 启动 Solr 服务： ./bin/solr start -m 1g Solr 将默认监听 8983 端口，其中 -m 1g 指定分配给 JVM 的内存为 1 G。 在浏览器中访问 Solr 管理后台： http://127.0.0.1:8983/solr/#/ Solr 管理后台 创建 Solr 应用： ./bin/solr create -c my_news 可以在 solr-6.2.0/server/solr 目录下生成 my_news 文件夹，结构如下： my_news 目录结构 同时，可以在管理后台看到 my_news： 管理后台 三、创建索引 我们将从 MySQL 数据库中导入数据到 Solr 并建立索引。 首先，需要了解 Solr 中的两个概念： 字段(field) 和 字段类型(fieldType)，配置示例如下： schema.xml 示例 field 指定一个字段的名称、是否索引/存储和字段类型。 fieldType 指定一个字段类型的名称以及在查询/索引的时候可能用到的分词插件。 将 solr-6.2.0\server\solr\my_news\conf 目录下默认的配置文件 managed-schema 重命名为 schema.xml 并加入新的 fieldType： 分词类型 在 my_news 目录下创建 lib 目录，将用到的分词插件 ik-analyzer-solr5-5.x.jar 加到 lib 目录，结构如下： my_news 目录结构 在 Solr 安装目录下重启服务： ./bin/solr restart 可以在管理后台看到新加的类型： text_ik 类型 接下来创建和我们数据库字段对应的 field：title 和 content，类型选为 text_ik： 新建字段 title 将要导入数据的 MySQL 数据库表结构： 编辑 conf/solrconfig.xml 文件，加入类库和数据库配置： 类库 dataimport config 同时新建数据库连接配置文件 conf/db-mysql-config.xml ，内容如下： 数据库配置文件 将数据库连接组件 mysql-connector-java-5.1.39-bin.jar 放到 lib 目录下，重启 Solr，访问管理后台，执行全量导入数据： 全量导入数据 创建定时更新脚本： 定时更新脚本 加入到定时任务，每5分钟增量更新一次索引： 定时任务 在 Solr 管理后台测试搜索结果： 分词搜索结果 至此，基本的搜索引擎搭建完毕，外部应用只需通过 http 协议提供查询参数，就可以获取搜索结果。 四、搜索干预 通常需要对搜索结果进行人工干预，比如编辑推荐、竞价排名或者屏蔽搜索结果。Solr 已经内置了 QueryElevationComponent 插件，可以从配置文件中获取搜索关键词对应的干预列表，并将干预结果排在搜索结果的前面。 在 solrconfig.xml 文件中，可以看到： 干预其请求配置 定义了搜索组件 elevator，应用在 /elevate 的搜索请求中，干预结果的配置文件在 solrconfig.xml 同目录下的 elevate.xml 中，干预配置示例： 重启 Solr ，当搜索 "关键词" 的时候，id 为 1和 4 的文档将出现在前面，同时 id = 3 的文档被排除在结果之外，可以看到，没有干预的时候，搜索结果为： 无干预结果 当有搜索干预的时候： 干预结果 通过配置文件干预搜索结果，虽然简单，但是每次更新都要重启 Solr 才能生效，稍显麻烦，我们可以仿照 QueryElevationComponent 类，开发自己的干预组件，例如:从 Redis 中读取干预配置。 五、中文分词 中文的搜索质量，和分词的效果息息相关，可以在 Solr 管理后台测试分词： 分词结果测试 上例可以看到，使用 IKAnalyzer分词插件，对 “北京科技大学” 分词的测试结果。当用户搜索 “北京”、“科技大学”、“科技大”、“科技”、“大学” 这些关键词的时候，都会搜索到文本内容含 “北京科技大学” 的文档。 常用的中文分词插件有 IKAnalyzer、mmseg4j和 Solr 自带的 smartcn 等，分词效果各有优劣，具体选择哪个，可以根据自己的业务场景，分别测试效果再选择。 分词插件一般都有自己的默认词库和扩展词库，默认词库包含了绝大多数常用的中文词语。如果默认词库无法满足你的需求，比如某些专业领域的词汇，可以在扩展词库中手动添加，这样分词插件就能识别新词语了。 分词插件扩展词库配置示例 分词插件还可以指定停止词库，将某些无意义的词汇剔出分词结果，比如：“的”、“哼” 等，例如： 去除无意义的词 六、总结 以上介绍了 Solr 最常用的一些功能，Solr 本身还有很多其他丰富的功能，比如分布式部署。 希望对你有所帮助。 七、附录 1、参考资料： https://wiki.apache.org/solr/ http://lucene.apache.org/solr/quickstart.html https://cwiki.apache.org/confluence/display/solr/Apache+Solr+Reference+Guide 2、上述 Demo 中用到的所有配置文件、Jar 包： https://github.com/Ceelog/OpenSchool/blob/master/my_news.zip 3、还有疑问？联系作者微博/微信 @Ceelog 搜索引擎选型整理：Elasticsearch vs Solr 本文首发于我的博客 原文链接：Elasticsearch 与 Solr 的比较 Elasticsearch简介* Elasticsearch是一个实时的分布式搜索和分析引擎。它可以帮助你用前所未有的速度去处理大规模数据。 它可以用于全文搜索，结构化搜索以及分析，当然你也可以将这三者进行组合。 Elasticsearch是一个建立在全文搜索引擎 Apache Lucene(TM) 基础上的搜索引擎，可以说Lucene是当今最先进，最高效的全功能开源搜索引擎框架。 但是Lucene只是一个框架，要充分利用它的功能，需要使用JAVA，并且在程序中集成Lucene。需要很多的学习了解，才能明白它是如何运行的，Lucene确实非常复杂。 Elasticsearch使用Lucene作为内部引擎，但是在使用它做全文搜索时，只需要使用统一开发好的API即可，而不需要了解其背后复杂的Lucene的运行原理。 当然Elasticsearch并不仅仅是Lucene这么简单，它不但包括了全文搜索功能，还可以进行以下工作: 分布式实时文件存储，并将每一个字段都编入索引，使其可以被搜索。 实时分析的分布式搜索引擎。 可以扩展到上百台服务器，处理PB级别的结构化或非结构化数据。 这么多的功能被集成到一台服务器上，你可以轻松地通过客户端或者任何你喜欢的程序语言与ES的RESTful API进行交流。 Elasticsearch的上手是非常简单的。它附带了很多非常合理的默认值，这让初学者很好地避免一上手就要面对复杂的理论， 它安装好了就可以使用了，用很小的学习成本就可以变得很有生产力。 随着越学越深入，还可以利用Elasticsearch更多高级的功能，整个引擎可以很灵活地进行配置。可以根据自身需求来定制属于自己的Elasticsearch。 使用案例： 维基百科使用Elasticsearch来进行全文搜做并高亮显示关键词，以及提供search-as-you-type、did-you-mean等搜索建议功能。 英国卫报使用Elasticsearch来处理访客日志，以便能将公众对不同文章的反应实时地反馈给各位编辑。 StackOverflow将全文搜索与地理位置和相关信息进行结合，以提供more-like-this相关问题的展现。 GitHub使用Elasticsearch来检索超过1300亿行代码。 每天，Goldman Sachs使用它来处理5TB数据的索引，还有很多投行使用它来分析股票市场的变动。 但是Elasticsearch并不只是面向大型企业的，它还帮助了很多类似DataDog以及Klout的创业公司进行了功能的扩展。 Elasticsearch的优缺点**: 优点 Elasticsearch是分布式的。不需要其他组件，分发是实时的，被叫做"Push replication"。 Elasticsearch 完全支持 Apache Lucene 的接近实时的搜索。 处理多租户（multitenancy）不需要特殊配置，而Solr则需要更多的高级设置。 Elasticsearch 采用 Gateway 的概念，使得完备份更加简单。 各节点组成对等的网络结构，某些节点出现故障时会自动分配其他节点代替其进行工作。 缺点 只有一名开发者（当前Elasticsearch GitHub组织已经不只如此，已经有了相当活跃的维护者） 还不够自动（不适合当前新的Index Warmup API） Solr简介* Solr（读作“solar”）是Apache Lucene项目的开源企业搜索平台。其主要功能包括全文检索、命中标示、分面搜索、动态聚类、数据库集成，以及富文本（如Word、PDF）的处理。Solr是高度可扩展的，并提供了分布式搜索和索引复制。Solr是最流行的企业级搜索引擎，Solr4 还增加了NoSQL支持。 Solr是用Java编写、运行在Servlet容器（如 Apache Tomcat 或Jetty）的一个独立的全文搜索服务器。 Solr采用了 Lucene Java 搜索库为核心的全文索引和搜索，并具有类似REST的HTTP/XML和JSON的API。Solr强大的外部配置功能使得无需进行Java编码，便可对其进行调整以适应多种类型的应用程序。Solr有一个插件架构，以支持更多的高级定制。 因为2010年 Apache Lucene 和 Apache Solr 项目合并，两个项目是由同一个Apache软件基金会开发团队制作实现的。提到技术或产品时，Lucene/Solr或Solr/Lucene是一样的。 Solr的优缺点 优点 Solr有一个更大、更成熟的用户、开发和贡献者社区。 支持添加多种格式的索引，如：HTML、PDF、微软 Office 系列软件格式以及 JSON、XML、CSV 等纯文本格式。 Solr比较成熟、稳定。 不考虑建索引的同时进行搜索，速度更快。 缺点 建立索引时，搜索效率下降，实时索引搜索效率不高。 Elasticsearch与Solr的比较* 当单纯的对已有数据进行搜索时，Solr更快。 Search Fesh Index While Idle 当实时建立索引时, Solr会产生io阻塞，查询性能较差, Elasticsearch具有明显的优势。 search_fresh_index_while_indexing 随着数据量的增加，Solr的搜索效率会变得更低，而Elasticsearch却没有明显的变化。 search_fresh_index_while_indexing 综上所述，Solr的架构不适合实时搜索的应用。 实际生产环境测试* 下图为将搜索引擎从Solr转到Elasticsearch以后的平均查询速度有了50倍的提升。 average_execution_time Elasticsearch 与 Solr 的比较总结 二者安装都很简单； Solr 利用 Zookeeper 进行分布式管理，而 Elasticsearch 自身带有分布式协调管理功能; Solr 支持更多格式的数据，而 Elasticsearch 仅支持json文件格式； Solr 官方提供的功能更多，而 Elasticsearch 本身更注重于核心功能，高级功能多有第三方插件提供； Solr 在传统的搜索应用中表现好于 Elasticsearch，但在处理实时搜索应用时效率明显低于 Elasticsearch。 Solr 是传统搜索应用的有力解决方案，但 Elasticsearch 更适用于新兴的实时搜索应用。 其他基于Lucene的开源搜索引擎解决方案* 直接使用Lucene 说明：Lucene 是一个 JAVA 搜索类库，它本身并不是一个完整的解决方案，需要额外的开发工作。 优点：成熟的解决方案，有很多的成功案例。apache 顶级项目，正在持续快速的进步。庞大而活跃的开发社区，大量的开发人员。它只是一个类库，有足够的定制和优化空间：经过简单定制，就可以满足绝大部分常见的需求；经过优化，可以支持 10亿+ 量级的搜索。 缺点：需要额外的开发工作。所有的扩展，分布式，可靠性等都需要自己实现；非实时，从建索引到可以搜索中间有一个时间延迟，而当前的“近实时”(Lucene Near Real Time search)搜索方案的可扩展性有待进一步完善 Katta 说明：基于 Lucene 的，支持分布式，可扩展，具有容错功能，准实时的搜索方案。 优点：开箱即用，可以与 Hadoop 配合实现分布式。具备扩展和容错机制。 缺点：只是搜索方案，建索引部分还是需要自己实现。在搜索功能上，只实现了最基本的需求。成功案例较少，项目的成熟度稍微差一些。因为需要支持分布式，对于一些复杂的查询需求，定制的难度会比较大。 Hadoop contrib/index 说明：Map/Reduce 模式的，分布式建索引方案，可以跟 Katta 配合使用。 优点：分布式建索引，具备可扩展性。 缺点：只是建索引方案，不包括搜索实现。工作在批处理模式，对实时搜索的支持不佳。 LinkedIn 的开源方案 说明：基于 Lucene 的一系列解决方案，包括 准实时搜索 zoie ，facet 搜索实现 bobo ，机器学习算法 decomposer ，摘要存储库 krati ，数据库模式包装 sensei 等等 优点：经过验证的解决方案，支持分布式，可扩展，丰富的功能实现 缺点：与 linkedin 公司的联系太紧密，可定制性比较差 Lucandra 说明：基于 Lucene，索引存在 cassandra 数据库中 优点：参考 cassandra 的优点 缺点：参考 cassandra 的缺点。另外，这只是一个 demo，没有经过大量验证 HBasene 说明：基于 Lucene，索引存在 HBase 数据库中 优点：参考 HBase 的优点 缺点：参考 HBase 的缺点。另外，在实现中，lucene terms 是存成行，但每个 term 对应的 posting lists 是以列的方式存储的。随着单个 term 的 posting lists 的增大，查询时的速度受到的影响会非常大 微信公众号【Java技术江湖】一位阿里 Java 工程师的技术小站。（关注公众号后回复”Java“即可领取 Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源） ​
2018-07-09
优秀的个人博客,低调大师

前端jsp与后端servlet传值（java web）

jsp中js使用jQuery封装好的 $.ajax(）方法与服务器进行交互 var jsonStick = this.strtoJson(); $.ajax({ type : 'post',//不起作用 要用jsonP url : 'controllerServlet',//要传输数据对象的地址 contentType : "application/x-www-form-urlencoded",//转化为form表单传值 data : { "js" : jsonStick }, //前面的js是服务端获取的ID 后面的jsonStick是处理后的json对象 cache : false, dataType : 'text',//这个关系到你能不能正确接收到servlet 响应的数据 async : false, //因为ajax默认是异步调用的，所以得到的返回值是空值，要得到值必须改成同步：async: false success : function(data) { //console.log(data); flag = data; //采用全局变量flag接收数据（data未作处理） }, error : function(msg) { //ajax请求失败后触发的方法 //弹出错误信息 console.log(msg); } }); //数据处理函数 function() { //'':this.note.name, var arr = []; var json = {}; json.note_id = this.id json.note = this.text; json.left = this.left; json.top = this.top; json.zindex = this.zIndex; if (this.sqlId == null) { this.sqlId = 0; } json.sqlId = this.sqlId; arr.push(json); var jsonStick = JSON.stringify(arr);//格式化json数据 return jsonStick; } servlet接收 处理 响应 protected void doGet（.........）{ String js = request.getParameter("js");//接收jsp传过来的数据 JSONArray json = JSONArray.fromObject(js);//对数据进行数组转化 JSONObject jsonOne = json.getJSONObject(0);//获取确定的json对象 boolean flag = true; PrintWriter out = response.getWriter(); out.print(flag);//将flag传给jsp out.close(); } jsp接收响应 并对数据进行处理 $.ajax({ type : 'post', url : 'sendServlet', cache : false, dataType : 'json', async : false, //因为ajax默认是异步调用的，所以得到的返回值是空值，要得到值必须改成同步：async: false success : function(data) { //console.log(data.result.note) for (var i in data) { console.log(data[i]) note = new Note(); note.id = data[i].note_id; note.text = data[i].note; note.timestamp = new Date().getTime(); note.left = data[i].left; note.top = data[i].top; note.zIndex = data[i].zindex; } }, error : function(msg) { //ajax请求失败后触发的方法 //弹出错误信息 console.log(msg); } }); 中间用到的jar包以及js https://pan.baidu.com/s/1XEOkM1as_10I92WAzooBuA 密码：gix8
2018-05-25
优秀的个人博客,低调大师

Python后端(一)——客户端/服务端

网址组成（四部分） 协议 http, https（https 是加密的http） 主机 g.cn zhihu.com之类的网址 端口 HTTP 协议默认是 80，因此一般不用填写 路径 下面的「/」和「/question/31838184」都是路径 http://www.zhihu.com/ http://www.zhihu.com/question/31838184 电脑通信靠IP地址，IP地址记不住就发明了域名（domain name），然后电脑自动向DNS服务器（domain name server）查询域名对应的IP地址 比如g.cn这样的网址，可以通过电脑的ping程序查出对应IP 地址 ping g.cn PING g.cn (74.125.69.160): 56 data bytes 端口是什么？ 一个比喻： 用邮局互相写信的时候，ip相当于地址（也可以看做邮编，地址是域名） 端口是收信人姓名（因为一个地址比如公司、家只有一个地址，但是却可能有很多收信人） 端口就是一个标记收信人的数字。 端口是一个16 位的数字，所以范围是 0-65535（2**16） ——HTTP协议—— 一个传输协议，协议就是双方都遵守的规范。 为什么叫超文本传输协议呢，因为收发的是文本信息。 1，浏览器（客户端）按照规定的格式发送文本数据（请求）到服务器 2，服务器解析请求，按照规定的格式返回文本数据到浏览器 3，浏览器解析得到的数据，并做相应处理 请求和返回是一样的数据格式，分为4部分： 1，请求行或者响应行 2，Header（请求的 Header 中 Host 字段是必须的，其他都是可选） 3，\r\n\r\n（连续两个换行回车符，用来分隔Header和Body） 4，Body（可选） 请求的格式，注意大小写（这是一个不包含Body的请求）： 原始数据如下 'GET / HTTP/1.1\r\nhost:g.cn\r\n\r\n' 打印出来如下 GET / HTTP/1.1 Host: g.cn 其中 1，GET 是请求方法（还有POST等，这就是个标志字符串而已） 2，/ 是请求的路径（这代表根路径） 3，HTTP/1.1 中，1.1是版本号，通用了20年 具体字符串是'GET / HTTP/1.1\r\nhost:g.cn\r\n\r\n' 返回的数据如下 HTTP/1.1 301 Moved Permanently Alternate-Protocol: 80:quic,p=0,80:quic,p=0 Cache-Control: private, max-age=2592000 Content-Length: 218 Content-Type: text/html; charset=UTF-8 Date: Tue, 07 Jul 2015 02:57:59 GMT Expires: Tue, 07 Jul 2015 02:57:59 GMT Location: http://www.google.cn/ Server: gws X-Frame-Options: SAMEORIGIN X-XSS-Protection: 1; mode=block Body部分太长，先不贴了 其中响应行（第一行）： 1，HTTP/1.1 是版本 2，301 是「状态码」，参见文末链接 3，Moved Permanently 是状态码的描述 浏览器会自己解析Header部分，然后将Body显示成网页 ——web服务器做什么—— 主要就是解析请求，发送相应的数据给客户端。 例如附件中的代码（1client.py）就是模拟浏览器发送HTTP 请求给服务器并把收到的所有信息打印出来（使用的是最底层的 socket，现阶段不必关心这种低层，web开发是上层开发） // 客户端代码实例： 1 # coding: utf-8 2 3 import socket 4 5 6 # socket 是操作系统用来进行网络通信的底层方案 7 # 简而言之, 就是发送 / 接收数据 8 9 # 创建一个 socket 对象 10 # 参数 socket.AF_INET 表示是 ipv4 协议 11 # 参数 socket.SOCK_STREAM 表示是 tcp 协议 12 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 13 # 这两个其实是默认值, 所以你可以不写, 如下 14 # s = socket.socket() 15 # s = ssl.wrap_socket(socket.socket()) 16 17 # 主机(域名或者ip)和端口 18 host = 'g.cn' 19 port = 80 20 # 用 connect 函数连接上主机, 参数是一个 tuple 21 s.connect((host, port)) 22 23 # 连接上后, 可以通过这个函数得到本机的 ip 和端口 24 ip, port = s.getsockname() 25 print('本机 ip 和 port {} {}'.format(ip, port)) 26 27 # 构造一个 HTTP 请求 28 http_request = 'GET / HTTP/1.1\r\nhost:{}\r\n\r\n'.format(host) 29 # 发送 HTTP 请求给服务器 30 # send 函数只接受 bytes 作为参数 31 # str.encode 把 str 转换为 bytes, 编码是 utf-8 32 request = http_request.encode('utf-8') 33 print('请求', request) 34 s.send(request) 35 36 # 接受服务器的响应数据 37 # 参数是长度, 这里为 1023 字节 38 # 所以这里如果服务器返回的数据中超过 1023 的部分你就得不到了 39 response = s.recv(1023) 40 41 # 输出响应的数据, bytes 类型 42 print('响应', response) 43 # 转成 str 再输出 44 print('响应的 str 格式', response.decode('utf-8')) // 服务端代码实例 1 import socket 2 3 4 # 这个程序就是一个套路程序, 套路程序没必要思考为什么会是这样 5 # 记住套路, 能用, 就够了 6 # 运行这个程序后, 浏览器打开 localhost:2000 就能访问了 7 # 8 # 服务器的 host 为空字符串, 表示接受任意 ip 地址的连接 9 # post 是端口, 这里设置为 2000, 随便选的一个数字 10 host = '' 11 port = 2000 12 13 # s 是一个 socket 实例 14 s = socket.socket() 15 # s.bind 用于绑定 16 # 注意 bind 函数的参数是一个 tuple 17 s.bind((host, port)) 18 19 20 # 用一个无限循环来处理请求 21 while True: 22 # 套路, 先要 s.listen 开始监听 23 # 注意 参数 5 的含义不必关心 24 s.listen(5) 25 # 当有客户端过来连接的时候, s.accept 函数就会返回 2 个值 26 # 分别是 连接 和 客户端 ip 地址 27 connection, address = s.accept() 28 29 # recv 可以接收客户端发送过来的数据 30 # 参数是要接收的字节数 31 # 返回值是一个 bytes 类型 32 request = connection.recv(1024) 33 34 # bytes 类型调用 decode('utf-8') 来转成一个字符串(str) 35 print('ip and request, {}\n{}'.format(address, request.decode('utf-8'))) 36 37 # b'' 表示这是一个 bytes 对象 38 response = b'<h1>Hello World!</h1>' 39 # 用 sendall 发送给客户端 40 connection.sendall(response) 41 # 发送完毕后, 关闭本次连接 42 connection.close()
2018-01-27
优秀的个人博客,低调大师

API网关帮后端服务做连接管理

当一个互联网产品业务量越来越大，她接入的客户端也会越来越多，不管客户端使用的是长连接还是短连接，对用户的连接管理必将成为一件耗资源且复杂的事情。特别对于使用HTTP短连接进行数据交互的业务，在HTTP连接维护上面，需要花费比较大的开销。 让我们来看看使用HTTP短连接来完成一次数据交互的全过程。 众所周知，HTTP是基于TCP的协议，而使用TCP进行通信前，首先需要通信双方建立TCP连接。我们来看看客户端是如何和服务器端建立连接的： 请求新的TCP连接时，客户端需要向服务器发送一个小的TCP报文(通常是40-60字节)， 这个报文设置了一个特殊的SYN标记。说明这是一个连接请求； 如果服务器接受了连接，就会对一些连接参数进行计算，并向客户端回送一个TCP报文，这个报文的SYN和ACK标记都被置位。ACK标记被置位是告诉客户端，服务器端已经
2016-11-11

资源下载

更多资源
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

时间: 2026-04-11 大小: 211.28KB 下载: 56次
Spring

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

时间: 2026-08-21 大小: 5MB 下载: 2次
Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

时间: 2026-08-21 大小: 9.84MB 下载: 40次
WebStorm

WebStorm

WebStorm 是jetbrains公司旗下一款JavaScript 开发工具。目前已经被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaScript IDE”等。与IntelliJ IDEA同源，继承了IntelliJ IDEA强大的JS部分的功能。

时间: 2025-12-13 大小: 249.54MB 下载: 22次
热门标签
DeepSeek Jdk25 OpenAi HarmonyOS6 Nacos3 SpringBoot4 SpringCloud Docker Kubernetes Service Mesh Redis Gemini3 Rocky

欢迎您来访！

登录后，您将获得更多功能！
热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273

用户登录
用户注册