一文详解微服务架构(转载)

本文将介绍微服务架构和相关的组件,介绍他们是什么以及为什么要使用微服务架构和这些组件。本文侧重于简明地表达微服务架构的全局图景,因此不会涉及具体如何使用组件等细节。

为了防止不提供原网址的转载,特在这里加上原文链接:
https://www.cnblogs.com/skabyy/p/11396571.html

要理解微服务,首先要先理解不是微服务的那些。通常跟微服务相对的是单体应用,即将所有功能都打包成在一个独立单元的应用程序。从单体应用到微服务并不是一蹴而就的,这是一个逐渐演变的过程。本文将以一个网上超市应用为例来说明这一过程。

最初的需求

几年前,小明和小皮一起创业做网上超市。小明负责程序开发,小皮负责其他事宜。当时互联网还不发达,网上超市还是蓝海。只要功能实现了就能随便赚钱。所以他们的需求很简单,只需要一个网站挂在公网,用户能够在这个网站上浏览商品、购买商品;另外还需一个管理后台,可以管理商品、用户、以及订单数据。

我们整理一下功能清单:

  • 网站
    • 用户注册、登录功能
    • 商品展示
    • 下单
  • 管理后台
    • 用户管理
    • 商品管理
    • 订单管理

由于需求简单,小明左手右手一个慢动作,网站就做好了。管理后台出于安全考虑,不和网站做在一起,小明右手左手慢动作重播,管理网站也做好了。总体架构图如下:

小明挥一挥手,找了家云服务部署上去,网站就上线了。上线后好评如潮,深受各类肥宅喜爱。小明小皮美滋滋地开始躺着收钱。

随着业务发展……

好景不长,没过几天,各类网上超市紧跟着拔地而起,对小明小皮造成了强烈的冲击。

在竞争的压力下,小明小皮决定开展一些营销手段:

  • 开展促销活动。比如元旦全场打折,春节买二送一,情人节狗粮优惠券等等。
  • 拓展渠道,新增移动端营销。除了网站外,还需要开发移动端APP,微信小程序等。
  • 精准营销。利用历史数据对用户进行分析,提供个性化服务。
  • ……

这些活动都需要程序开发的支持。小明拉了同学小红加入团队。小红负责数据分析以及移动端相关开发。小明负责促销活动相关功能的开发。

因为开发任务比较紧迫,小明小红没有好好规划整个系统的架构,随便拍了拍脑袋,决定把促销管理和数据分析放在管理后台里,微信和移动端APP另外搭建。通宵了几天后,新功能和新应用基本完工。这时架构图如下:

这一阶段存在很多不合理的地方:

  • 网站和移动端应用有很多相同业务逻辑的重复代码。
  • 数据有时候通过数据库共享,有时候通过接口调用传输。接口调用关系杂乱。
  • 单个应用为了给其他应用提供接口,渐渐地越改越大,包含了很多本来就不属于它的逻辑。应用边界模糊,功能归属混乱。
  • 管理后台在一开始的设计中保障级别较低。加入数据分析和促销管理相关功能后出现性能瓶颈,影响了其他应用。
  • 数据库表结构被多个应用依赖,无法重构和优化。
  • 所有应用都在一个数据库上操作,数据库出现性能瓶颈。特别是数据分析跑起来的时候,数据库性能急剧下降。
  • 开发、测试、部署、维护愈发困难。即使只改动一个小功能,也需要整个应用一起发布。有时候发布会不小心带上了一些未经测试的代码,或者修改了一个功能后,另一个意想不到的地方出错了。为了减轻发布可能产生的问题的影响和线上业务停顿的影响,所有应用都要在凌晨三四点执行发布。发布后为了验证应用正常运行,还得盯到第二天白天的用户高峰期……
  • 团队出现推诿扯皮现象。关于一些公用的功能应该建设在哪个应用上的问题常常要争论很久,最后要么干脆各做各的,或者随便放个地方但是都不维护。

尽管有着诸多问题,但也不能否认这一阶段的成果:快速地根据业务变化建设了系统。不过紧迫且繁重的任务容易使人陷入局部、短浅的思维方式,从而做出妥协式的决策。在这种架构中,每个人都只关注在自己的一亩三分地,缺乏全局的、长远的设计。长此以往,系统建设将会越来越困难,甚至陷入不断推翻、重建的循环。

是时候做出改变了

幸好小明和小红是有追求有理想的好青年。意识到问题后,小明和小红从琐碎的业务需求中腾出了一部分精力,开始梳理整体架构,针对问题准备着手改造。

要做改造,首先你需要有足够的精力和资源。如果你的需求方(业务人员、项目经理、上司等)很强势地一心追求需求进度,以致于你无法挪出额外的精力和资源的话,那么你可能无法做任何事……

在编程的世界中,最重要的便是抽象能力。微服务改造的过程实际上也是个抽象的过程。小明和小红整理了网上超市的业务逻辑,抽象出公用的业务能力,做成几个公共服务:

  • 用户服务
  • 商品服务
  • 促销服务
  • 订单服务
  • 数据分析服务

各个应用后台只需从这些服务获取所需的数据,从而删去了大量冗余的代码,就剩个轻薄的控制层和前端。这一阶段的架构如下:

这个阶段只是将服务分开了,数据库依然是共用的,所以一些烟囱式系统的缺点仍然存在:

  1. 数据库成为性能瓶颈,并且有单点故障的风险。
  2. 数据管理趋向混乱。即使一开始有良好的模块化设计,随着时间推移,总会有一个服务直接从数据库取另一个服务的数据的现象。
  3. 数据库表结构可能被多个服务依赖,牵一发而动全身,很难调整。

如果一直保持共用数据库的模式,则整个架构会越来越僵化,失去了微服务架构的意义。因此小明和小红一鼓作气,把数据库也拆分了。所有持久化层相互隔离,由各个服务自己负责。另外,为了提高系统的实时性,加入了消息队列机制。架构如下:

完全拆分后各个服务可以采用异构的技术。比如数据分析服务可以使用数据仓库作为持久化层,以便于高效地做一些统计计算;商品服务和促销服务访问频率比较大,因此加入了缓存机制等。

还有一种抽象出公共逻辑的方法是把这些公共逻辑做成公共的框架库。这种方法可以减少服务调用的性能损耗。但是这种方法的管理成本非常高昂,很难保证所有应用版本的一致性。

数据库拆分也有一些问题和挑战:比如说跨库级联的需求,通过服务查询数据颗粒度的粗细问题等。但是这些问题可以通过合理的设计来解决。总体来说,数据库拆分是一个利大于弊的。

微服务架构还有一个技术外的好处,它使整个系统的分工更加明确,责任更加清晰,每个人专心负责为其他人提供更好的服务。在单体应用的时代,公共的业务功能经常没有明确的归属。最后要么各做各的,每个人都重新实现了一遍;要么是随机一个人(一般是能力比较强或者比较热心的人)做到他负责的应用里面。在后者的情况下,这个人在负责自己应用之外,还要额外负责给别人提供这些公共的功能——而这个功能本来是无人负责的,仅仅因为他能力较强/比较热心,就莫名地背锅(这种情况还被美其名曰能者多劳)。结果最后大家都不愿意提供公共的功能。长此以往,团队里的人渐渐变得各自为政,不再关心全局的架构设计。

从这个角度上看,使用微服务架构同时也需要组织结构做相应的调整。所以说做微服务改造需要管理者的支持。

改造完成后,小明和小红分清楚各自的锅。两人十分满意,一切就像是麦克斯韦方程组一样漂亮完美。

然而……

没有银弹

春天来了,万物复苏,又到了一年一度的购物狂欢节。眼看着日订单数量蹭蹭地上涨,小皮小明小红喜笑颜开。可惜好景不长,乐极生悲,突然嘣的一下,系统挂了。

以往单体应用,排查问题通常是看一下日志,研究错误信息和调用堆栈。而微服务架构整个应用分散成多个服务,定位故障点非常困难。小明一个台机器一台机器地查看日志,一个服务一个服务地手工调用。经过十几分钟的查找,小明终于定位到故障点:促销服务由于接收的请求量太大而停止响应了。其他服务都直接或间接地会调用促销服务,于是也跟着宕机了。在微服务架构中,一个服务故障可能会产生雪崩效用,导致整个系统故障。其实在节前,小明和小红是有做过请求量评估的。按照预计,服务器资源是足以支持节日的请求量的,所以肯定是哪里出了问题。不过形势紧急,随着每一分每一秒流逝的都是白花花的银子,因此小明也没时间排查问题,当机立断在云上新建了几台虚拟机,然后一台一台地部署新的促销服务节点。几分钟的操作后,系统总算是勉强恢复正常了。整个故障时间内估计损失了几十万的销售额,三人的心在滴血……

事后,小明简单写了个日志分析工具(量太大了,文本编辑器几乎打不开,打开了肉眼也看不过来),统计了促销服务的访问日志,发现在故障期间,商品服务由于代码问题,在某些场景下会对促销服务发起大量请求。这个问题并不复杂,小明手指抖一抖,修复了这个价值几十万的Bug。

问题是解决了,但谁也无法保证不会再发生类似的其他问题。微服务架构虽然逻辑设计上看是完美的,但就像积木搭建的华丽宫殿一样,经不起风吹草动。微服务架构虽然解决了旧问题,也引入了新的问题:

  • 微服务架构整个应用分散成多个服务,定位故障点非常困难。
  • 稳定性下降。服务数量变多导致其中一个服务出现故障的概率增大,并且一个服务故障可能导致整个系统挂掉。事实上,在大访问量的生产场景下,故障总是会出现的。
  • 服务数量非常多,部署、管理的工作量很大。
  • 开发方面:如何保证各个服务在持续开发的情况下仍然保持协同合作。
  • 测试方面:服务拆分后,几乎所有功能都会涉及多个服务。原本单个程序的测试变为服务间调用的测试。测试变得更加复杂。

小明小红痛定思痛,决心好好解决这些问题。对故障的处理一般从两方面入手,一方面尽量减少故障发生的概率,另一方面降低故障造成的影响。

监控 – 发现故障的征兆

在高并发分布式的场景下,故障经常是突然间就雪崩式爆发。所以必须建立完善的监控体系,尽可能发现故障的征兆。

微服务架构中组件繁多,各个组件所需要监控的指标不同。比如Redis缓存一般监控占用内存值、网络流量,数据库监控连接数、磁盘空间,业务服务监控并发数、响应延迟、错误率等。因此如果做一个大而全的监控系统来监控各个组件是不大现实的,而且扩展性会很差。一般的做法是让各个组件提供报告自己当前状态的接口(metrics接口),这个接口输出的数据格式应该是一致的。然后部署一个指标采集器组件,定时从这些接口获取并保持组件状态,同时提供查询服务。最后还需要一个UI,从指标采集器查询各项指标,绘制监控界面或者根据阈值发出告警。

大部分组件都不需要自己动手开发,网络上有开源组件。小明下载了RedisExporter和MySQLExporter,这两个组件分别提供了Redis缓存和MySQL数据库的指标接口。微服务则根据各个服务的业务逻辑实现自定义的指标接口。然后小明采用Prometheus作为指标采集器,Grafana配置监控界面和邮件告警。这样一套微服务监控系统就搭建起来了:

定位问题 – 链路跟踪

在微服务架构下,一个用户的请求往往涉及多个内部服务调用。为了方便定位问题,需要能够记录每个用户请求时,微服务内部产生了多少服务调用,及其调用关系。这个叫做链路跟踪。

我们用一个Istio文档里的链路跟踪例子来看看效果:

图片来自Istio文档

从图中可以看到,这是一个用户访问productpage页面的请求。在请求过程中,productpage服务顺序调用了details和reviews服务的接口。而reviews服务在响应过程中又调用了ratings的接口。整个链路跟踪的记录是一棵树:

要实现链路跟踪,每次服务调用会在HTTP的HEADERS中记录至少记录四项数据:

  • traceId:traceId标识一个用户请求的调用链路。具有相同traceId的调用属于同一条链路。
  • spanId:标识一次服务调用的ID,即链路跟踪的节点ID。
  • parentId:父节点的spanId。
  • requestTime & responseTime:请求时间和响应时间。

另外,还需要调用日志收集与存储的组件,以及展示链路调用的UI组件。

以上只是一个极简的说明,关于链路跟踪的理论依据可详见Google的Dapper

了解了理论基础后,小明选用了Dapper的一个开源实现Zipkin。然后手指一抖,写了个HTTP请求的拦截器,在每次HTTP请求时生成这些数据注入到HEADERS,同时异步发送调用日志到Zipkin的日志收集器中。这里额外提一下,HTTP请求的拦截器,可以在微服务的代码中实现,也可以使用一个网络代理组件来实现(不过这样子每个微服务都需要加一层代理)。

链路跟踪只能定位到哪个服务出现问题,不能提供具体的错误信息。查找具体的错误信息的能力则需要由日志分析组件来提供。

分析问题 – 日志分析

日志分析组件应该在微服务兴起之前就被广泛使用了。即使单体应用架构,当访问数变大、或服务器规模增多时,日志文件的大小会膨胀到难以用文本编辑器进行访问,更糟的是它们分散在多台服务器上面。排查一个问题,需要登录到各台服务器去获取日志文件,一个一个地查找(而且打开、查找都很慢)想要的日志信息。

因此,在应用规模变大时,我们需要一个日志的“搜索引擎”。以便于能准确的找到想要的日志。另外,数据源一侧还需要收集日志的组件和展示结果的UI组件:

小明调查了一下,使用了大名鼎鼎地ELK日志分析组件。ELK是Elasticsearch、Logstash和Kibana三个组件的缩写。

  • Elasticsearch:搜索引擎,同时也是日志的存储。
  • Logstash:日志采集器,它接收日志输入,对日志进行一些预处理,然后输出到Elasticsearch。
  • Kibana:UI组件,通过Elasticsearch的API查找数据并展示给用户。

最后还有一个小问题是如何将日志发送到Logstash。一种方案是在日志输出的时候直接调用Logstash接口将日志发送过去。这样一来又(咦,为啥要用“又”)要修改代码……于是小明选用了另一种方案:日志仍然输出到文件,每个服务里再部署个Agent扫描日志文件然后输出给Logstash。

网关 – 权限控制,服务治理

拆分成微服务后,出现大量的服务,大量的接口,使得整个调用关系乱糟糟的。经常在开发过程中,写着写着,忽然想不起某个数据应该调用哪个服务。或者写歪了,调用了不该调用的服务,本来一个只读的功能结果修改了数据……

为了应对这些情况,微服务的调用需要一个把关的东西,也就是网关。在调用者和被调用者中间加一层网关,每次调用时进行权限校验。另外,网关也可以作为一个提供服务接口文档的平台。

使用网关有一个问题就是要决定在多大粒度上使用:最粗粒度的方案是整个微服务一个网关,微服务外部通过网关访问微服务,微服务内部则直接调用;最细粒度则是所有调用,不管是微服务内部调用或者来自外部的调用,都必须通过网关。折中的方案是按照业务领域将微服务分成几个区,区内直接调用,区间通过网关调用。

由于整个网上超市的服务数量还不算特别多,小明采用的最粗粒度的方案:

服务注册于发现 – 动态扩容

前面的组件,都是旨在降低故障发生的可能性。然而故障总是会发生的,所以另一个需要研究的是如何降低故障产生的影响。

最粗暴的(也是最常用的)故障处理策略就是冗余。一般来说,一个服务都会部署多个实例,这样一来能够分担压力提高性能,二来即使一个实例挂了其他实例还能响应。

冗余的一个问题是使用几个冗余?这个问题在时间轴上并没有一个切确的答案。根据服务功能、时间段的不同,需要不同数量的实例。比如在平日里,可能4个实例已经够用;而在促销活动时,流量大增,可能需要40个实例。因此冗余数量并不是一个固定的值,而是根据需要实时调整的。

一般来说新增实例的操作为:

  1. 部署新实例
  2. 将新实例注册到负载均衡或DNS上

操作只有两步,但如果注册到负载均衡或DNS的操作为人工操作的话,那事情就不简单了。想想新增40个实例后,要手工输入40个IP的感觉……

解决这个问题的方案是服务自动注册与发现。首先,需要部署一个服务发现服务,它提供所有已注册服务的地址信息的服务。DNS也算是一种服务发现服务。然后各个应用服务在启动时自动将自己注册到服务发现服务上。并且应用服务启动后会实时(定期)从服务发现服务同步各个应用服务的地址列表到本地。服务发现服务也会定期检查应用服务的健康状态,去掉不健康的实例地址。这样新增实例时只需要部署新实例,实例下线时直接关停服务即可,服务发现会自动检查服务实例的增减。

服务发现还会跟客户端负载均衡配合使用。由于应用服务已经同步服务地址列表在本地了,所以访问微服务时,可以自己决定负载策略。甚至可以在服务注册时加入一些元数据(服务版本等信息),客户端负载则根据这些元数据进行流量控制,实现A/B测试、蓝绿发布等功能。

服务发现有很多组件可以选择,比如说Zookeeper 、Eureka、Consul、Etcd等。不过小明觉得自己水平不错,想炫技,于是基于Redis自己写了一个……

熔断、服务降级、限流

熔断

当一个服务因为各种原因停止响应时,调用方通常会等待一段时间,然后超时或者收到错误返回。如果调用链路比较长,可能会导致请求堆积,整条链路占用大量资源一直在等待下游响应。所以当多次访问一个服务失败时,应熔断,标记该服务已停止工作,直接返回错误。直至该服务恢复正常后再重新建立连接。

图片来自《微服务设计

服务降级

当下游服务停止工作后,如果该服务并非核心业务,则上游服务应该降级,以保证核心业务不中断。比如网上超市下单界面有一个推荐商品凑单的功能,当推荐模块挂了后,下单功能不能一起挂掉,只需要暂时关闭推荐功能即可。

限流

一个服务挂掉后,上游服务或者用户一般会习惯性地重试访问。这导致一旦服务恢复正常,很可能因为瞬间网络流量过大又立刻挂掉,在棺材里重复着仰卧起坐。因此服务需要能够自我保护——限流。限流策略有很多,最简单的比如当单位时间内请求数过多时,丢弃多余的请求。另外,也可以考虑分区限流。仅拒绝来自产生大量请求的服务的请求。例如商品服务和订单服务都需要访问促销服务,商品服务由于代码问题发起了大量请求,促销服务则只限制来自商品服务的请求,来自订单服务的请求则正常响应。

测试

微服务架构下,测试分为三个层次:

  1. 端到端测试:覆盖整个系统,一般在用户界面机型测试。
  2. 服务测试:针对服务接口进行测试。
  3. 单元测试:针对代码单元进行测试。

三种测试从上到下实施的容易程度递增,但是测试效果递减。端到端测试最费时费力,但是通过测试后我们对系统最有信心。单元测试最容易实施,效率也最高,但是测试后不能保证整个系统没有问题。

由于端到端测试实施难度较大,一般只对核心功能做端到端测试。一旦端到端测试失败,则需要将其分解到单元测试:则分析失败原因,然后编写单元测试来重现这个问题,这样未来我们便可以更快地捕获同样的错误。

服务测试的难度在于服务会经常依赖一些其他服务。这个问题可以通过Mock Server解决:

单元测试大家都很熟悉了。我们一般会编写大量的单元测试(包括回归测试)尽量覆盖所有代码。

微服务框架

指标接口、链路跟踪注入、日志引流、服务注册发现、路由规则等组件以及熔断、限流等功能都需要在应用服务上添加一些对接代码。如果让每个应用服务自己实现是非常耗时耗力的。基于DRY的原则,小明开发了一套微服务框架,将与各个组件对接的代码和另外一些公共代码抽离到框架中,所有的应用服务都统一使用这套框架进行开发。

使用微服务框架可以实现很多自定义的功能。甚至可以将程序调用堆栈信息注入到链路跟踪,实现代码级别的链路跟踪。或者输出线程池、连接池的状态信息,实时监控服务底层状态。

使用统一的微服务框架有一个比较严重的问题:框架更新成本很高。每次框架升级,都需要所有应用服务配合升级。当然,一般会使用兼容方案,留出一段并行时间等待所有应用服务升级。但是如果应用服务非常多时,升级时间可能会非常漫长。并且有一些很稳定几乎不更新的应用服务,其负责人可能会拒绝升级……因此,使用统一微服务框架需要完善的版本管理方法和开发管理规范。

另一条路 – Service Mesh

另一种抽象公共代码的方法是直接将这些代码抽象到一个反向代理组件。每个服务都额外部署这个代理组件,所有出站入站的流量都通过该组件进行处理和转发。这个组件被称为Sidecar。

Sidecar不会产生额外网络成本。Sidecar会和微服务节点部署在同一台主机上并且共用相同的虚拟网卡。所以sidecar和微服务节点的通信实际上都只是通过内存拷贝实现的。

图片来自:Pattern: Service Mesh

Sidecar只负责网络通信。还需要有个组件来统一管理所有sidecar的配置。在Service Mesh中,负责网络通信的部分叫数据平面(data plane),负责配置管理的部分叫控制平面(control plane)。数据平面和控制平面构成了Service Mesh的基本架构。

图片来自:Pattern: Service Mesh

Sevice Mesh相比于微服务框架的优点在于它不侵入代码,升级和维护更方便。它经常被诟病的则是性能问题。即使回环网络不会产生实际的网络请求,但仍然有内存拷贝的额外成本。另外有一些集中式的流量处理也会影响性能。

结束、也是开始

微服务不是架构演变的终点。往细走还有Serverless、FaaS等方向。另一方面也有人在唱合久必分分久必合,重新发现单体架构……

不管怎样,微服务架构的改造暂时告一段落了。小明满足地摸了摸日益光滑的脑袋,打算这个周末休息一下约小红喝杯咖啡。

REST与RPC区别

目录什么是REST什么是RPCREST与RPC比较REST与RPC应用场景

REST与RPC概念

什么是REST

REST是一种架构风格,指的是一组架构约束条件和原则。满足这些约束条件和原则的应用程序或设计就是 RESTful。REST规范把所有内容都视为资源,网络上一切皆资源。

REST并没有创造新的技术,组件或服务,只是使用Web的现有特征和能力。 可以完全通过HTTP协议实现,使用 HTTP 协议处理数据通信。REST架构对资源的操作包括获取、创建、修改和删除资源的操作正好对应HTTP协议提供的GET、POST、PUT和DELETE方法。

HTTP动词与REST风格CRUD对应关系:

什么是RPC

远程方法调用,就是像调用本地方法一样调用远程方法。常见RPC框架结构图:

RPC框架要做到的最基本的三件事:

1、服务端如何确定客户端要调用的函数;

在远程调用中,客户端和服务端分别维护一个【ID->函数】的对应表, ID在所有进程中都是唯一确定的。客户端在做远程过程调用时,附上这个ID,服务端通过查表,来确定客户端需要调用的函数,然后执行相应函数的代码。

2、如何进行序列化和反序列化;

客户端和服务端交互时将参数或结果转化为字节流在网络中传输,那么数据转化为字节流的或者将字节流转换成能读取的固定格式时就需要进行序列化和反序列化,序列化和反序列化的速度也会影响远程调用的效率。

3、如何进行网络传输(选择何种网络协议);

多数RPC框架选择TCP作为传输协议,也有部分选择HTTP。如gRPC使用HTTP2。不同的协议各有利弊。TCP更加高效,而HTTP在实际应用中更加的灵活。

REST与RPC比较

都是网络交互的协议规范。通常用于多个微服务之间的通信协议。

高与低是对实现两种规范框架的相对比较,但也不是绝对的,需要根据实际情况而定。

REST与RPC应用场景

REST和RPC都常用于微服务架构中。

1、HTTP相对更规范,更标准,更通用,无论哪种语言都支持http协议。如果你是对外开放API,例如开放平台,外部的编程语言多种多样,你无法拒绝对每种语言的支持,现在开源中间件,基本最先支持的几个协议都包含RESTful。

2、 RPC 框架作为架构微服务化的基础组件,它能大大降低架构微服务化的成本,提高调用方与服务提供方的研发效率,屏蔽跨进程调用函数(服务)的各类复杂细节。让调用方感觉就像调用本地函数一样调用远端函数、让服务提供方感觉就像实现一个本地函数一样来实现服务。

最后建议

REST调用及测试都很方便,RPC就显得有点繁琐,但是RPC的效率是毋庸置疑的,所以建议在多系统之间的内部调用采用RPC。对外提供的服务,Rest更加合适。

转自:程序员面试经验分享

php pack()函数详解与示例

转自网络

pack和unpack在一般的程序中还真的不容易见到,但是如果你用过很久以前的php生成excel你就会知道了。他的excel的头就是pack出来的
最近在尝试与C交互的时候又用上了这玩意,所以不得不再看看。其实就是C要求我一定要有包头。。。其实纯字符串也不错嘛。干嘛非得搞个包头呢?真纠结 .。

手册上有pack与unpack的介绍,但都是英文的。。。

  任何一款拥有socket操作能力的语言都有一个专门用于组包的函数,php也不例外!

用了很久php了却很少有机会用php进行一些二进制操作。 最近用php写一个socket客户端连接一个用C++语言开发的游戏服务端。 服务器端开发人员使用了二进制的形式来定义协议的格式。协议格式如下:

包头(2bytes)+加密(1byte)+命令码(2bytes)+帧内容

1.包头的内容是记录帧内容的长度;
2. 加密:0表示不加密,1表示加密;
3. 命令码为服务端命令识别符号;

一开始不了解php原来有pack可以来组装二进制包, 走了弯路,让服务端开发人员用C语言帮忙开发了的几个内存操作函数,按照协议规则返回二进制包,然后我将这几个方法编译成一组扩展函数供php使用。

话归正题,本文是介绍如何使用pack和unpack这两个方法的。php官方手册举例太少,不能很容易理解,特别是那些格式化参数的使用。

转摘的参数中文说明:

pack/unpack 的摸板字符字符 含义
a 一个填充空的字节串
A 一个填充空格的字节串
b 一个位串,在每个字节里位的顺序都是升序
B 一个位串,在每个字节里位的顺序都是降序
c 一个有符号 char(8位整数)值
C 一个无符号 char(8位整数)值;关于 Unicode 参阅 U
d 本机格式的双精度浮点数
f 本机格式的单精度浮点数
h 一个十六进制串,低四位在前
H 一个十六进制串,高四位在前
i 一个有符号整数值,本机格式
I 一个无符号整数值,本机格式
l 一个有符号长整形,总是 32 位
L 一个无符号长整形,总是 32 位
n 一个 16位短整形,“网络”字节序(大头在前)
N 一个 32 位短整形,“网络”字节序(大头在前)
p 一个指向空结尾的字串的指针
P 一个指向定长字串的指针
q 一个有符号四倍(64位整数)值
Q 一个无符号四倍(64位整数)值
s 一个有符号短整数值,总是 16 位
S 一个无符号短整数值,总是 16 位,字节序跟机器芯片有关
u 一个无编码的字串
U 一个 Unicode 字符数字
v 一个“VAX”字节序(小头在前)的 16 位短整数
V 一个“VAX”字节序(小头在前)的 32 位短整数
w 一个 BER 压缩的整数
x 一个空字节(向前忽略一个字节)
X 备份一个字节
Z 一个空结束的(和空填充的)字节串
@ 用空字节填充绝对位置


string pack ( string $format [, mixed $args [, mixed $…]] )

一些规则:
1.每个字母后面都可以跟着一个数字,表示 count(计数),如果 count 是一个 * 表示剩下的所有东西。
2.如果你提供的参数比 $format 要求的少,pack 假设缺的都是空值。如果你提供的参数比 $format 要求的多,那么多余的参数被忽略。

下面还是用例子来说明用法会容易理解一点:

PHP代码
  1. 关于Pack:
  2. 下面的第一部分把数字值包装成字节:
  3. $out = pack(“CCCC”, 65, 66, 67, 68);      # $out 等于”ABCD”  
  4. $out = pack(“C4”, 65, 66, 67, 68);         # 一样的东西  
  5. 下面的对 Unicode 的循环字母做同样的事情:
  6.  $foo = pack(“U4”, 0x24b6, 0x24b7, 0x24b8, 0x24b9);  
  7. 下面的做类似的事情,增加了一些空:
  8. $out = pack(“CCxxCC”, 65, 66, 67, 68);      # $out 等于 “AB\0\0CD”  
  9. 打包你的短整数并不意味着你就可移植了:
  10. $out = pack(“s2”, 1, 2);          
  11. # 在小头在前的机器上是 “\1\0\2\0”  
  12. # 在大头在前的机器上是 “\0\1\0\2”  
  13. 在二进制和十六进制包装上,count 指的是位或者半字节的数量,而不是生成的字节数量:  
  14.   $out = pack(“B32”, “…”);  
  15.     $out = pack(“H8”, “5065726c”);         # 都生成“Perl”  
  16. a 域里的长度只应用于一个字串:
  17.   $out = pack(“a4”, “abcd”, “x”, “y”, “z”);      # “abcd”  
  18. 要绕开这个限制,使用多倍声明:
  19.   $out = pack(“aaaa”,    “abcd”, “x”, “y”, “z”);   # “axyz”  
  20.    $out = pack(“a” x 4,   “abcd”, “x”, “y”, “z”);   # “axyz”  
  21. a 格式做空填充:
  22.   $out = pack(“a14”, “abcdefg”);         # ” abcdefg\0\0\0\0\0\0″  
  23. 关于unpack:
  24. array unpack ( string $format, string $data )  
  25. $data = “010000020007”;  
  26. unpack(“Sint1/Cchar1/Sint2/Cchar2”,$data);  
  27. ## array(‘int1’=>1, ‘char1’=>’0’,’int2’=>2,’char2’=>7);  
  28. 最后本文开头讲到的协议使用pack/unpack 举例程序代码为 :
  29. $lastact   = pack(‘SCSa32a32’,0x0040, 0x00, 0x0006, $username, $passwd );  
  30. unpack(‘Sint1/Cchar1/Sint2/Cchar2/’,$lastmessage);  

学习资料:
http://blog.csdn.net/jojobb3138688/archive/2007/05/07/1598609.aspx

我上面的内容来自于:http://blog.sina.com.cn/s/blog_3eba8f1c0100nq9r.html,我现在已经顺利的使用完了。黑黑
还有的参考资料:
http://bbs.phpchina.com/thread-104492-1-1.html
http://hi.baidu.com/chinetman/item/f78a71d847e7d638e2108fda

epoll讲解

转自知乎

首先我们来定义流的概念,一个流可以是文件,socket,pipe等等可以进行I/O操作的内核对象。
    不管是文件,还是套接字,还是管道,我们都可以把他们看作流。
    之后我们来讨论I/O的操作,通过read,我们可以从流中读入数据;通过write,我们可以往流写入数据。现在假定一个情形,我们需要从流中读数据,但是流中还没有数据,(典型的例子为,客户端要从socket读如数据,但是服务器还没有把数据传回来),这时候该怎么办?
阻塞:阻塞是个什么概念呢?比如某个时候你在等快递,但是你不知道快递什么时候过来,而且你没有别的事可以干(或者说接下来的事要等快递来了才能做);那么你可以去睡觉了,因为你知道快递把货送来时一定会给你打个电话(假定一定能叫醒你)。
非阻塞忙轮询:接着上面等快递的例子,如果用忙轮询的方法,那么你需要知道快递员的手机号,然后每分钟给他挂个电话:“你到了没?”
    很明显一般人不会用第二种做法,不仅显很无脑,浪费话费不说,还占用了快递员大量的时间。
    大部分程序也不会用第二种做法,因为第一种方法经济而简单,经济是指消耗很少的CPU时间,如果线程睡眠了,就掉出了系统的调度队列,暂时不会去瓜分CPU宝贵的时间片了。
    为了了解阻塞是如何进行的,我们来讨论缓冲区,以及内核缓冲区,最终把I/O事件解释清楚。缓冲区的引入是为了减少频繁I/O操作而引起频繁的系统调用(你知道它很慢的),当你操作一个流时,更多的是以缓冲区为单位进行操作,这是相对于用户空间而言。对于内核来说,也需要缓冲区。
假设有一个管道,进程A为管道的写入方,B为管道的读出方。
假设一开始内核缓冲区是空的,B作为读出方,被阻塞着。然后首先A往管道写入,这时候内核缓冲区由空的状态变到非空状态,内核就会产生一个事件告诉B该醒来了,这个事件姑且称之为“缓冲区非空”。
    但是“缓冲区非空”事件通知B后,B却还没有读出数据;且内核许诺了不能把写入管道中的数据丢掉这个时候,A写入的数据会滞留在内核缓冲区中,如果内核也缓冲区满了,B仍未开始读数据,最终内核缓冲区会被填满,这个时候会产生一个I/O事件,告诉进程A,你该等等(阻塞)了,我们把这个事件定义为“缓冲区满”。
假设后来B终于开始读数据了,于是内核的缓冲区空了出来,这时候内核会告诉A,内核缓冲区有空位了,你可以从长眠中醒来了,继续写数据了,我们把这个事件叫做“缓冲区非满”
    也许事件Y1已经通知了A,但是A也没有数据写入了,而B继续读出数据,知道内核缓冲区空了。这个时候内核就告诉B,你需要阻塞了!,我们把这个时间定为“缓冲区空”。
这四个情形涵盖了四个I/O事件,缓冲区满,缓冲区空,缓冲区非空,缓冲区非满(注都是说的内核缓冲区,且这四个术语都是我生造的,仅为解释其原理而造)。这四个I/O事件是进行阻塞同步的根本。(如果不能理解“同步”是什么概念,请学习操作系统的锁,信号量,条件变量等任务同步方面的相关知识)。
    然后我们来说说阻塞I/O的缺点。但是阻塞I/O模式下,一个线程只能处理一个流的I/O事件。如果想要同时处理多个流,要么多进程(fork),要么多线程(pthread_create),很不幸这两种方法效率都不高。
    于是再来考虑非阻塞忙轮询的I/O方式,我们发现我们可以同时处理多个流了(把一个流从阻塞模式切换到非阻塞模式再此不予讨论):
while true {
for i in stream[]; {
if i has data
read until unavailable
}
}
    我们只要不停的把所有流从头到尾问一遍,又从头开始。这样就可以处理多个流了,但这样的做法显然不好,因为如果所有的流都没有数据,那么只会白白浪费CPU。这里要补充一点,阻塞模式下,内核对于I/O事件的处理是阻塞或者唤醒,而非阻塞模式下则把I/O事件交给其他对象(后文介绍的select以及epoll)处理甚至直接忽略。
    为了避免CPU空转,可以引进了一个代理(一开始有一位叫做select的代理,后来又有一位叫做poll的代理,不过两者的本质是一样的)。这个代理比较厉害,可以同时观察许多流的I/O事件,在空闲的时候,会把当前线程阻塞掉,当有一个或多个流有I/O事件时,就从阻塞态中醒来,于是我们的程序就会轮询一遍所有的流(于是我们可以把“忙”字去掉了)。代码长这样:
while true {
select(streams[])
for i in streams[] {
if i has data
read until unavailable
}
}
    于是,如果没有I/O事件产生,我们的程序就会阻塞在select处。但是依然有个问题,我们从select那里仅仅知道了,有I/O事件发生了,但却并不知道是那几个流(可能有一个,多个,甚至全部),我们只能无差别轮询所有流,找出能读出数据,或者写入数据的流,对他们进行操作。
    但是使用select,我们有O(n)的无差别轮询复杂度,同时处理的流越多,没一次无差别轮询时间就越长。再次
说了这么多,终于能好好解释epoll了
    epoll可以理解为event poll,不同于忙轮询和无差别轮询,epoll之会把哪个流发生了怎样的I/O事件通知我们。此时我们对这些流的操作都是有意义的。(复杂度降低到了O(1))
    在讨论epoll的实现细节之前,先把epoll的相关操作列出:
epoll_create 创建一个epoll对象,一般epollfd = epoll_create()
epoll_ctl (epoll_add/epoll_del的合体),往epoll对象中增加/删除某一个流的某一个事件
比如
epoll_ctl(epollfd, EPOLL_CTL_ADD, socket, EPOLLIN);//注册缓冲区非空事件,即有数据流入
epoll_ctl(epollfd, EPOLL_CTL_DEL, socket, EPOLLOUT);//注册缓冲区非满事件,即流可以被写入
epoll_wait(epollfd,…)等待直到注册的事件发生
(注:当对一个非阻塞流的读写发生缓冲区满或缓冲区空,write/read会返回-1,并设置errno=EAGAIN。而epoll只关心缓冲区非满和缓冲区非空事件)。
一个epoll模式的代码大概的样子是:
while true {
active_stream[] = epoll_wait(epollfd)
for i in active_stream[] {
read or write till
}
}
    限于篇幅,我只说这么多,以揭示原理性的东西,至于epoll的使用细节,请参考man和google,实现细节,请参阅linux kernel source。

chsh 查看和修改当前登录的Shell

chsh 命令本身并不复杂,它的功能比较单一,就是负责查看(显示)和修改我们系统的登录 Shell。想修改登录 Shell,首先要知道我们的系统安装了哪些 Shell。这里有两种方法可以查看。

方法一:(mac 下不行)

[roc@roclinux ~]$ chsh -l
/bin/sh
/bin/bash
/sbin/nologin
/bin/zsh

方法二:(mac下可以)

[roc@roclinux ~]$ cat /etc/shells
/bin/sh
/bin/bash
/sbin/nologin
/bin/zsh
mac:
maxianwideMBP57:home maxianwei$ cat /etc/shells
# List of acceptable shells for chpass(1).
# Ftpd will not allow users to connect who are not using
# one of these shells.

/bin/bash
/bin/csh
/bin/ksh
/bin/sh
/bin/tcsh
/bin/zsh

其实chsh -l命令本质上也是去查看 /etc/shells 文件。

查看当前正在使用的 Shell

使用一个环境变量,就可以查看到当前正在使用的 Shell 啦:

[roc@roclinux ~]$ echo $SHELL
/bin/bash

maxianwideMBP57:home maxianwei$ echo $SHELL
/bin/bash

注意:SHELL一定要大写。可以看到,我们目前使用的 Shell 是 bash。

听说 zsh 不错,于是我们就通过在命令行执行 zsh 命令切换到了 zsh 环境。可是,为什么查看当前 Shell 类型仍然是 /bin/bash 呢?

[roc@roclinux ~]$ zsh
[roc@roclinux]~% echo $SHELL
/bin/bash
[roc@roclinux]~%

请注意,我们虽然执行了 zsh,但是所谓“当前的 Shell”是一个大环境的概念,是针对一个已登录的用户而言的。而我们执行 zsh 只是启动了一个 zsh 的解释器程序而已,并没有改变大环境。如果想改变“当前的 Shell”,那么还是要求助于 chsh 才可以。

将 Shell 环境真正切换到 zsh

[roc@roclinux ~]$ chsh -s /bin/zsh
Changing shell for roc.
Password:
Shell changed.

使用 chsh 命令的-s选项就可以修改登录的 Shell 了。

如果我们这时候满怀欣喜地执行 echo $SHELL,就会发现然输出的仍是 /bin/bash。这是因为 chsh 改变的是我们登录 Shell 的配置,我们必须退出再重新登录 Shell,才可以完全投入到 zsh 的怀抱。

真是一波三折,退出并重新登录后,终于看到了我们想要的 /bin/zsh 了:

[roc@roclinux]~% echo $SHELL
/bin/zsh

chsh -s 到底修改了哪里

chsh -s其实修改的就是 /etc/passwd 文件中和我们所登录的用户名相对应的那一行。现在我们来查看一下:

[roc@roclinux]~% cat /etc/passwd|grep ^roc
roc:x:1001:1001::/home/roc:/bin/zsh

可以发现,输出内容的最后部分已经变成了 /bin/zsh 了。重启系统的时候,Linux 就会读取这一命令来启动新的 Shell。

好了,我们要恢复正常的工作环境,把 Shell 修改回我们熟悉的 /bin/bash 了:

[roc@roclinux]~% chsh -s /bin/bash
Changing Shell for roc.
Password:
Shell changed.

linux 查找删除指定日期文件

find ./ -maxdepth 1 -name “a*” -mtime +2 -exec rm -rfv {} \;

参考:

https://www.cnblogs.com/tianruixue/p/5845070.html

https://www.cnblogs.com/wuning/p/11778348.html

 

php 按固定大小裁剪图片,居中裁剪哦

N年之前网上搜的一个方法,做了下修改
function image_resize($src_file, $dst_file , $new_width , $new_height) {
   if($new_width <1 || $new_height <1) {
      echo "params width or height error !";
      exit();
   }
   if(!file_exists($src_file)) {
      echo $src_file . " is not exists !";
      exit();
   }
   // 图像类型
   $type=exif_imagetype($src_file);
   $support_type=array(IMAGETYPE_JPEG , IMAGETYPE_PNG , IMAGETYPE_GIF);
   if(!in_array($type, $support_type,true)) {
      echo "this type of image does not support! only support jpg , gif or png";
      exit();
   }
   //Load image
   switch($type) {
      case IMAGETYPE_JPEG :
         $src_img=imagecreatefromjpeg($src_file);
         break;
      case IMAGETYPE_PNG :
         $src_img=imagecreatefrompng($src_file);
         break;
      case IMAGETYPE_GIF :
         $src_img=imagecreatefromgif($src_file);
         break;
      default:
         echo "Load image error!";
         exit();
   }
   //原图信息
   $w = imagesx($src_img);
   $h = imagesy($src_img);
   $ratio_w=1.0 * $new_width / $w;
   $ratio_h=1.0 * $new_height / $h;
   $ratio=1.0;
   // 生成的图像的高宽比原来的都小,或都大 ,原则是 取大比例放大,取大比例缩小(缩小的比例就比较小了)
   if( ($ratio_w < 1 && $ratio_h < 1) || ($ratio_w > 1 && $ratio_h > 1)) {
      if($ratio_w < $ratio_h) {
         $ratio = $ratio_h ; // 情况一,宽度的比例比高度方向的小,按照高度的比例标准来裁剪或放大
      }else {
         $ratio = $ratio_w ;
      }
      // 定义一个中间的临时图像,该图像的宽高比 正好满足目标要求
      $inter_w = (int)($new_width / $ratio);
      $inter_h = (int) ($new_height / $ratio);
      $inter_img = imagecreatetruecolor($inter_w , $inter_h);
      $src_x = 0;
      $src_y = 0;
      //echo $inter_w.'|'.$inter_h;
      if($h > $inter_h){
         $src_y = (int)(($h - $inter_h)/2);
      }
      if($w > $inter_w){
         $src_x = (int)(($w - $inter_w)/2);
      }
      
      imagecopy($inter_img, $src_img, 0,0,$src_x,$src_y,$inter_w,$inter_h);
      // 生成一个以最大边长度为大小的是目标图像$ratio比例的临时图像
      // 定义一个新的图像
      $new_img=imagecreatetruecolor($new_width,$new_height);
      //echo $inter_w.'|'.$inter_h;
      //exit;
      imagecopyresampled($new_img,$inter_img,0,0,0,0,$new_width,$new_height,$inter_w,$inter_h);
      switch($type) {
         case IMAGETYPE_JPEG :
            imagejpeg($new_img, $dst_file,100); // 存储图像
            break;
         case IMAGETYPE_PNG :
            imagepng($new_img,$dst_file,100);
            break;
         case IMAGETYPE_GIF :
            imagegif($new_img,$dst_file,100);
            break;
         default:
            break;
      }
   } // end if 1
   else{
      $ratio=$ratio_h>$ratio_w? $ratio_h : $ratio_w; //取比例大的那个值
      // 定义一个中间的大图像,该图像的高或宽和目标图像相等,然后对原图放大
      $inter_w=(int)($w * $ratio);
      $inter_h=(int) ($h * $ratio);
      $inter_img=imagecreatetruecolor($inter_w , $inter_h);
      //将原图缩放比例后裁剪
      imagecopyresampled($inter_img,$src_img,0,0,0,0,$inter_w,$inter_h,$w,$h);
      // 定义一个新的图像
      $new_img=imagecreatetruecolor($new_width,$new_height);
      imagecopy($new_img, $inter_img, 0,0,0,0,$new_width,$new_height);
      switch($type) {
         case IMAGETYPE_JPEG :
            imagejpeg($new_img, $dst_file,100); // 存储图像
            break;
         case IMAGETYPE_PNG :
            imagepng($new_img,$dst_file,100);
            break;
         case IMAGETYPE_GIF :
            imagegif($new_img,$dst_file,100);
            break;
         default:
            break;
      }
   }
}

遍历目录

function dirList($dir_path = '') {
	if(is_dir($dir_path)) {
		$dirs = opendir($dir_path);
		if($dirs) {
			while(($file = readdir($dirs)) !== false) {
				if($file !== '.' && $file !== '..') {

					if(is_dir($dir_path.'/'.$file)) {
		
						//echo $dir_path . '/' . $file . '
';
						dirList($dir_path . '/' . $file);
					} else {
					
						echo $dir_path . '/' . $file . '
';
					}
				}
			}
			closedir($dirs);
		}
	} else {
		echo '目录不存在!';
	}
}

系统小命令1

系统排查:
last -F -x 查看重启等时间

cat /var/log/messages |more 查看对应日志
uptime 系统运行时间

查看目录或子目录:

df -h 命令查看整个硬盘的大小 ,-h表示人可读的
du -d 1 -h 命令查看当前目录下所有文件夹的大小 -d 指深度,后面加一个数值

全球十大搜索引擎

本文来自网络

最近打算系统学习SEO了,哈哈

互联网时代的发展一直都在悄无声息的进行, 21 世纪初期,我们认为网址导航能够成为最佳的流量入口,可是在几年之后,最大的两个网址导航Hao123 和 265 上网导航被两家搜索引擎公司百度和Google收购了,从此流量入口从网址导航变成了搜索引擎。

虽说现在的流量入口渐渐从搜索引擎向人工智能发展,但是在人工智能普及之前,搜索引擎依然是网民进入互联网入口的第一选择,除了我们所熟知的Google和百度之外,其实全球还有很多不错的搜索引擎,只不过这些搜索引擎大多在国外比较受欢迎,但如果你懂英语的话,这些搜索引擎也许会让你有以外的收获!

1.Google

虽说Google离开中国很长时间了,但不得不承认,Google依然是全球最大的搜索引擎,我们所说的“大”是按照搜索引擎的用户和访问量来划分的,Google的月独立访客大约 18 亿,是目前用户规模最大的搜索引擎。

从 2010 年 3 月Google关闭在中国的搜索服务开始,到现在已经过去七年了,虽然目前Google的一些服务在中国还可以使用,但很多人依然在期待着Google搜索能够重回中国,而Google似乎也在为这一天努力着。

2.Bing

没错,排名第二位的不是百度,而是微软旗下的搜索引擎——Bing,由于搜索UI界面非常美观,因此也被称为“Google最好的替代者”。

Bing的月独立访客相比Google来说差很多,仅 5 亿,但和其他搜索引擎相比,这是最大的数值了。

3.Yahoo!

最早的Yahoo!是一家网址导航网站,但随后推出的搜索引擎也获得了不小的市场份额,月独立访客达到4. 9 亿,但是在 2014 年 9 月,Yahoo!宣布关闭搜索引擎Yahoo Directory等服务。

值得一提的是,Yahoo!的创始人有两位,其中一位是来自中国台湾、祖籍湖北的杨致远,由于Yahoo!的成功,他也被称为“世纪网络第一人”。

4.百度

终于轮到全球最大的中文搜索引擎——百度,作为中国最大的搜索引擎,百度的月独立访客量达到了4. 8 亿,随着在搜索引擎中的成功,百度逐渐拓展到地图、金融、音乐、团购等多个领域,成为一家互联网综合公司。

虽然近些年 360 的好搜和搜狗逐渐抢夺了一些市场份额,但大部分人最习惯的还是“百度一下,你就知道”,近些年百度也可以寻求转型,宣布正式成为一家AI人工智能公司,百度CEO李彦宏更是在今年展示了自家的百度无人驾驶汽车上路行驶的技术。

5.Ask

相信上网比较早的网友都见过这家搜索引擎的网站或标识,只不过当初可能不知道这是什么,其实这是一款国外的搜索引擎,在国外的市场中还是比较有名的,虽然规模没有Google那么大,但不得不说Ask是一款很有特色的搜索引擎,月独立访客也达到了 3 亿。

和传统搜索引擎的庞大数据库不同,Ask搜索引擎的数据库中存储的都是问题对应的答案,当用户在Ask搜索某个问题的时候,搜索结果会显示问题的答案,可以理解为是一款问答类搜索引擎。

6.Aol

Aol搜索引擎应该算是Google旗下的一个分支,因为它的搜索技术是由Google提供的,但实际上,它是美国在线旗下的一家搜索引擎网站,月独立访客量大约有 2 亿人。

Aol的搜索服务侧重于新闻、股市行情以及本地地图等信息,和Google、Yahoo!的庞大搜索数据库也是有很大区别的。

7.DuckDuckGo

这家搜索引擎应该知道的人不是很多了,我们在使用百度、Google搜索一些信息之后,总会发现一些放置了百度联盟、Google联盟广告位的网站中,那些广告位总会显示我们刚刚搜索过的相关产品广告,但这款DuckDuckGo搜索引擎的特殊之处就在于不会追踪用户搜索信息。

不过毕竟Google和百度现在已经不是单纯的搜索引擎了,而这家搜索引擎应该只是一家纯粹的搜索引擎,并没有追求用户信息的必要,对于注重隐私的用户来说,不失为一个很好的选择。

8.WolframAlpha

WolframAlpha也不是传统意义上的搜索引擎,它的功能与Ask搜索引擎相似,不过它比较侧重“理科”,例如对于数据分析、某个城市的相关数据、城市人口等数据计算方面的搜索引擎。

9.Yandex

Yandex是俄罗斯朋友们的一款搜索引擎,这家搜索引擎创建于 1997 年,目前是俄罗斯最大的搜索引擎,它的功能也已经从单一的搜索引擎功能渗透到了网络支付、社交、网站运维与托管等周边服务。

10.WebCrawler

WebCrawler属于一家元搜索引擎,它的功能主要是将Google的搜索结果、Yahoo!的搜索结果以及其他搜索引擎的搜索结果统一显示在一个页面中,帮助用户完成同一个搜索关键词在不同搜索引擎中的搜索结果对比。

我还是习惯用百度和谷歌。