leeon

leeon 查看完整档案

北京编辑西安邮电大学  |  计算机科学与技术(卓越班) 编辑百度外卖  |  后端工程师 编辑 segmentfault.com/u/leeonfun 编辑
编辑

加油!

个人动态

leeon 发布了文章 · 2018-12-16

供应链业务MQ应用场景经验总结

写在前面:做供应链业务一年有余了,这一年里MQ帮我们解决了很多问题,在此做一些经验总结;另外,各个公司消息中间件提供的功能大同小异,最基础的推消息、下游异常重试机制应该是都具备的,本文所述也是建立在这样的能力基础上的~

场景一:削峰填谷,降低响应时间,下游异常自动重试、保证成功

举例:对库存模块而言,入库是一个增量操作,当通过了数据校验之后就理应执行成功,但入库操作常常伴有复杂的写库逻辑及乐观锁冲突,同步模型平均响应时间长,且并发条件下乐观锁冲突失败概率较大;这里就可以引入MQ,将写库操作异步处理,简要流程如下:
图片描述

需要注意的是:
1、如果有重复发消息地可能性,MQ下游需要做业务幂等,整条链路要有并发锁保护(redis实现并发悲观锁可参看文章:https://segmentfault.com/a/11...);
2、如果下游触发异常,中间件一般会自动重试(并发乐观锁冲突自动重试可解决,中间件一般会提供一直重试、重新入队、丢弃消息等模式,需根据具体场景选取,在此不再赘述);如果是非重试能够解决的异常,则需要再监控到异常后,人工介入跳过、修复、补偿;
3、示例情况是上游无写库,如果上游有写库,可能出现发消息与事务写库两个事件状态不一致的情况,一般会有三种情况:

(1)先事务写库,再发消息;当发消息失败时,写库事务已提交,无法回滚;
(2)先发消息,再事务写库;当写库失败时,消息已发送,无法回滚;
(3)写库事务中发消息,如果发消息失败,事务可以回滚,但如果发消息成功后,事务提交时失败(有这种可能),消息也无法回滚;

如果上游无法避免写库时,我们一般采用先事务写库,再发送消息,因为消息中间件作为基础服务,一般是可靠的,很小概率出现发消息失败;如果出现了,有两种处理方式:

(1)发消息失败,返回客户端失败,则需要脚本补偿,回滚上游写库;
(2)发消息失败,只报警,但返回客户端正常,则需要补偿消息;

场景二:异步处理,服务解耦
举例:每一次操作库存后都需要记录业务操作日志,每个Stock(库存服务)接口都需要在完成库存逻辑后,再调用Log(日志服务)记录操作日志;如果采用同步调用模型,Stock服务就与Log服务耦合,依赖于Log服务的实时响应结果,如果Log服务挂了,Stock服务也就挂了,这不是我们期望看到的;这里就可以引入MQ实现核心流程与非核心流程的解耦,简要流程如下:
图片描述

这样,上游只需依赖MQ,一般而言,相比下游服务,中间件是更可靠的;通过MQ的能力,如果下游出现问题,主流程不会阻塞,有更多的时间修复,且更易补偿;

场景三:多下游的发布订阅
举例:商品信息作为供应链基础数据,在几乎所有系统都有应用;如果商品信息变更,其他系统就需要接收变更信息,如何通知就是一个问题;同步通知模型会耦合所有下游服务,响应时间长,在增加或减少接收方时,上游代码还需要变更,显然不可行;这里可以采用多个consumer group订阅同一个topic消息方式,异步接收变更事件,在增加或减少接收方时,下游服务consumer group主动订阅或取消订阅商品信息变更topic即可,简要流程如下:
图片描述

查看原文

赞 0 收藏 0 评论 0

leeon 关注了专栏 · 2018-08-11

思考者浩哥

我是浩哥,希望我的思考能帮到您!

关注 113

leeon 收藏了文章 · 2018-08-11

PHP面试知识梳理

关于作者

昨天在思否上发了这篇整理,晚上10点多看到了很多赞收藏和关注,其实挺愧疚的,因为最近在找工作这篇文章并没有整理完。看到这个还挺受欢迎的,也因为新工作基本定下来了,现在的公司正常交接中,打算下周末之前把这个知识梳理整理完,感谢各位的点赞、收藏和关注,大家一起努力。

另外,我自己的博客网站在这,哈哈:https://www.linganmin.cn

算法与数据结构

BTree和B+tree

排序算法

  • 快速排序
    快速排序是十分常用的高效率的算法,其思想是:先选一个标尺,用它把整个队列过一遍筛选,以保证其左边的元素都不大于它,其右边的元素都不小与它

    function quickSort($arr){
    
      // 获取数组长度
      $length = count($arr);
    
      // 判断长度是否需要继续二分比较
      if($length <= 1){
        return $arr;
      }
    
      // 定义基准元素
      $base = $arr[0];
    
      // 定义两个空数组,用于存放和基准元素的比较后的结果
      $left = [];
      $right = [];
    
      // 遍历数组
      for ($i=1; $i < $length; $i++) { 
    
        // 和基准元素作比较
        if ($arr[$i] > $base) {
          $right[] = $arr[$i];
        }else {
          $left[] = $arr[$i];
        }
    
      }
    
      // 然后递归分别处理left和right
      $left = quickSort($left);
      $right = quickSort($right);
    
      // 合并
      return array_merge($left,[$base],$right);
      
    }
  • 冒泡排序
    思路:法如其名,就像冒泡一样,每次从数组中冒出一个最大的数
    比如:2,4,1
    第一次冒出4:2,1,4
    第二次冒出2:1,2,4

    function bubbleSort($arr){
    
      // 获取数组长度
      $length = count($arr);
    
      // 第一层循环控制冒泡轮次
      for ($i=0; $i < $length-1; $i++) { 
        
        // 内层循环控制从第0个键值和后一个键值比较,每次冒出一个最大的数
        for ($k=0; $k < $length-$i-1; $k++) { 
          if($arr[$k] > $arr[$k+1]){
            $tmp = $arr[$k+1];
            $arr[$k+1] = $arr[$k];
            $arr[$k] = $tmp;
          }
        }
      }
    
      return $arr;
    }
  • 选择排序
    思路:每次选择一个相应的元素,然后将其放到指定的位置

        function selectSort($arr){
         
          // 实现思路
          // 双重循环完成,外层控制轮数,当前的最小值,内层控制比较次数
    
          // 获取长度
          $length = count($arr);
      
          for ($i=0; $i < $length - 1; $i++) { 
            // 假设最小值的位置
            $p = $i;
      
            // 使用假设的最小值和其他值比较,找到当前的最小值
            for ($j=$i+1; $j < $length; $j++) { 
              // $arr[$p] 是已知的当前最小值
      
              // 判断当前循环值和已知最小值的比较,当发下更小的值时记录下键,并进行下一次比较
              if ($arr[$p] > $arr[$j]) {
                $p = $j; // 比假设的值更小
              }
            }
      
            // 通过内部for循环找到了当前最小值的key,并保存在$p中
            // 判断 日光当前$p 中的键和假设的最小值的键不一致增将其互换
            if ($p != $i) {
              $tmp = $arr[$p];
              $arr[$p] = $arr[$i];
              $arr[$i] = $tmp;
            }
          }
          // 返回最终结果
          return $arr;
        }

计算机网络

TCP/UDP区别

  • TCP
    TCP是一种面向连接的、可靠的、基于字节流的传输层通信协议
    TCP面向连接,提供可靠地数据服务
    TCP首部开销20字节
    TCP逻辑通信信道是全双工的可靠信道
    TCP连接只能是点到点的
  • UDP
    UDP是参考模型中一种无连接的传输层协议,提供面向事务的简单不可靠的信息传递服务
    UDP无连接,不可靠
    UDP首部开销8字节
    UDP逻辑通信信道是不可靠信道
    UDP没有拥塞机制,因此网络出现拥堵不会使源主机的发送效率降低
    UDP支持一对一,多对一,多对多的交互通信

三次握手,四次挥手,为什么是三次握手四次挥手

在TCP/IP协议中,TCP协议提供可靠的连接服务,采用三次握手建立一个连接,完成三次握手,客户端与服务器开始传送数据。
简单点说:A与B建立TCP连接时,首先A向B发送SYN(同步请求),然后B回复SYN+ACK(同步请求应答),最后A回复ACK确认,这样TCP的一次连接(三次握手)就完成了。

  • TCP三次握手

    所谓三次握手,是指简历一个TCP连接时需要客户端和服务器总共发送三个包
    三次握手的目的是连接服务器指定端口,简历TCP连接,并同步连接双方的序列号并交换TCP窗口大小信息。
    TCP三次握手图解:
    1. 第一次握手
      客户端发送一个TCP的SYN标志位置1的包,指明客户打算连接的服务器的端口,以及初始化序号,保存在包头的序列号字段里
    2. 第二次握手
      服务器发挥确认包应答,即SYN标志位和ACK标志均为1,同时将确认序号设置为客户的ISN加1,即X+1
    3. 第三次握手
      客户端再次发送确认包,SYN标识为0,ACK标识为1,并且把服务器发来的序号字段+1,放在确定字段中发送给对方,并且在数据字段写入ISN的+1

简单解释TCP三次握手:
参考:https://github.com/jawil/blog...

  • 四次挥手

    TCP的连接的拆除需要发送四个包,因此称为四次挥手。客户端或服务器均可主动发起挥手动作。
    由于TCP连接时全双工的,因此每个方向都必须单独进行关闭。这个原则是当一方完成他的数据发送任务后就能发送一个FIN来终止这个方向的连接。收到一个FIN只意味着这一方向上没有数据流动,一个TCP连接在收到一个FIN后仍能发送数据。首先进行关闭的一方将执行主动关闭,而另一方执行被动关闭。
  • 为什么是三次握手四次挥手
    这是因为服务端的LISTEN状态下的socket当收到SKY报文的简历连接的请求后,它可以把ACK和SYN放在一个报文里来发送。但关闭连接时,当收到对方的FIN报文通知时,他仅仅表示对方没有数据发送给你了,但未必你的所有数据都全部发送给对方了,所以你可以不是马上回关闭socket,即你可能还会发送一些数据给对方之后,在发送FIN报文给对方来表示你同意现在可以关闭连接了,所以这里的ACK和FIN报文多情况下都是分开发送的。

长连接和短连接

TCP在真正的读写操作之前,server和client之间必须建立一个连接,当读写操作完成后,双方不再需要这个链接时他们可能释放这个连接,连接的建立是通过三次握手,释放则需要四次挥手,所以说每个连接的建立都是需要消耗资源和时间的。

  • TCP短连接

    1. client向server发起连接请求
    2. server接到请求,双方建立连接
    3. client向server发消息
    4. server回应client
    5. 一次读写完成,此时双方任何一个都可以发起close操作
      一般都是client先发起close操作,因为一般的server不会回复完client就立即关闭连接

所以短连接一般只会在client和server间传递一次读写操作,短连接管理起来比较简单,存在的连接都是有用的连接,不需要额外的控制手段

  • 长连接

    1. client向server发起连接
    2. server接到请求后,双方建立连接
    3. client向server发送消息
    4. server回应client
    5. 一次读写完成,连接不关闭
    6. 后续读写操作
  • 长/短连接的操作过程

    1. 短连接的操作步骤:
      建立连接 -> 数据传输 -> 关闭连接
    2. 长连接的操作步骤:
      建立连接 -> 数据传输 -> (保持连接) -> 数据传输 -> 关闭连接
  • 长/短连接的优缺点

    1. 长连接可以省去较多的TCP建立和关闭操作,减少资源浪费,节省时间,对于比较频繁的请求资源的客户端比较适用于长连接
    2. 短连接对于服务器来说管理较为简单,存在的连接都是有用的连接,不需要额外的控制手段

从浏览器输入域名到展示页面都发生了什么

  • DNS域名解析
    先找本地hosts文件,检查对应域名ip的关系,有则想ip地址发送请求,没有再去找DNS服务器
  • 建立TCP连接
    拿到服务器IP后,向服务器发送求求,三次握手,建立TCP连接
    简单理解三次握手:
    客户端:您好,在家不,有你快递
    服务端:在的,送来吧
    客户端:好滴,来了
  • 发送HTTP请求
    与服务器建立连接后,就可以向服务器发起请求了。具体请求内容可以在浏览器中查看
  • 服务器处理请求
    服务器收到请求后由web服务器(Apache,Nginx)处理请求,web服务器解析用户请求,知道了需要调用那些资源文件,再通过相应的这些资源文件处理用户请求和参数,并调用数据库等,然后将结果通过web服务器返回给浏览器
  • 返回响应结果
    在响应结果中都会有一个HTTP状态码,诸如我们熟知的200、404、500等
    状态码都是由三位数字和原因短语组成,大致为五类:
    1XX 信息性状态码 接收的请求正在处理
    2XX 成功状态码 请求正常处理完毕
    3XX 重定向状态码 需要附加操作以完成请求
    4XX 客户端错误状态码 服务器也无法处理的请求
    5XX 服务器错误状态码 服务器请求处理出错
  • 关闭TCP连接
    为了避免服务器与客户端双方资源占用和消耗,当双方没有请求或者响应传递时,任意一方都可以发起关闭请求,与创建TCP连接的三次握手类似,关闭TCP连接需要4次挥手
    简单比喻为:
    客户端:哥们,我这边没有数据要传了,咱们关闭连接吧
    服务端:好的,我看看我这边还有数据不
    服务端:兄弟,我这边也没数据要传给你了,咱们可以关闭连接了
    客户端:好嘞
  • 浏览器解析HTML
  • 浏览器布局渲染

设计模式

设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

单例模式

当需要保证对象只有一个实例的时候,单例模式是非常有用的。他把创建对象的控制权交给一个单一的点上,任何时候应用程序都只会存在且仅存在一个实例。单例类不应该能在类的外部进行实例化。
一个单例类应该具备以下几个因素:

  • 必须拥有一个访问级别为private的构造函数,用于阻止类被随意实例化
  • 必须拥有一个保存类的实例的静态变量
  • 必须拥有一个访问这个实例的公共静态方法,该方法通常被命名为getInstance()
  • 必须拥有一个私有的空的clone方法,防止实例被克隆复制

简单实例:


class Single
{
    public static $_instance;

    private function __construct()
    {
    }

    private function __clone()
    {
    }

    public static function getInstance()
    {
        if (!self::$_instance) {
            self::$_instance = new self();
        }
        return self::$_instance;
    }

    public function sayHi()
    {
        echo "Hi \n";
    }
}

$single = Single::getInstance();
$single->sayHi();

工厂模式

工厂模式解决的是如何不通过new建立实例对象的方法

工厂模式是一种类,它具有为你创建对象的某些方法,你可以使用工厂类创建对象而不使用new。这样,如果你想要更改所创建的对象类型只需要更改工厂即可,使用该工厂的所有代码会自动更改。

工厂模式往往配合接口一起使用,这样应用程序就不必要知道这些被实例化的类的具体细节,只要知道工厂返回的是支持某个接口的类就可以方便的使用了。

简单举例:



/**
 * 抽象出一个人的接口
 * Interface Person
 */
interface Person
{
    public function showInfo();
}

/**
 * 一个继承于抽象人接口的学生类
 * Class Student
 */
class Student implements Person
{
    public function showInfo()
    {
        echo "这是一个学生 \n";
    }
}

/**
 * 一个继承于抽象人接口的老师类
 * Class Teacher
 */
class Teacher implements Person
{
    public function showInfo()
    {
        echo "这是一个老师 \n";
    }
}

/**
 * 人类工厂
 * Class PersonFactory
 */
class PersonFactory
{
    public static function factory($person_type)
    {
        // 将传入的类型首字母大写
        $class_name = ucfirst($person_type);

        if(class_exists($class_name)){
            return new $class_name;
        }else{
            throw  new Exception("类:$class_name 不存在",1);
        }
    }
}

// 需要一个学生
$student = PersonFactory::factory('student');
echo $student->showInfo();

// 需要一个老师的时候
$teacher = PersonFactory::factory('teacher');
echo $teacher->showInfo();

缓存相关

Redis和Memcached的区别

  • Redis和Memcache都是将数据存放在内存中,都是内存数据库。但是Memcache还可以缓存其他东西,比如图片、视频
  • Redis不只支持简单的k/v类型的数据,同时还提供list、set、hash等数据结构的存储
  • 虚拟内存,当物理内存用完时Redis可以将一些很久没有用到的value交换到磁盘
  • 过期策略,memcache在set时就指定,例如set key1 0 0 8即永不过期,redis可以通过expire设定,例如:expire name 10
  • 分布式,设定memcache集群,利用magent做一主多从;redis也可以做一主多从。
  • 存储安全,memcache挂掉后,数据没了;redis可以定期保存在磁盘(持久化)
  • 灾难恢复,memcache挂掉后数据不可恢复;redis数据丢失后可以通过aof恢复
  • redis支持数据的备份,即master-slave模式的数据备份
  • 应用场景不同:redis除了可以做nosql数据库之外,还能做消息队列、数据堆栈和数据缓存等。memcache适合于缓存sql语句、数据集、用户临时性数据、延迟查询数据和session等

redis有哪些数据结构

  • String
    字符串类型是redis最基础的数据结构,首先键是字符串类型,而且其他几种结构都是在字符串类型基础上构建的
    字符串类型实际上可以是字符串、数字、二进制(图片、音频),单最大不能超过512M
    使用场景:

    1. 缓存
      字符串最经典的使用场景,redis作为缓存层,mysql作为存储层,绝大部分请求数据都是redis中获取,由于redis具有支撑高并发特性,所以缓存通常能起到加速读写和降低后端压力的作用
    2. 计数器
      许多应用都会使用redis作为技术的基础工具,它可以实现快速技术、查询缓存的功能。
    3. 共享session
      处于负载均衡的考虑,分布式服务会将用户信息的访问均衡到不同服务器,用户刷新一次访问可讷讷个会需要重新登录,为了避免这个问题可以使用redis将用户session集中管理,在这种模式下只要保证redis的高可用和扩展性,每次获取用户更新或查询登录信息都直接从redis中集中获取
    4. 限速
      出于安全考虑,每次进行登录时让用户输入手机验证码,为了短信接口不被频繁访问,会限制用户每分钟获取验证码的频率
  • Hash
    在redis中哈希类型是指键本身又是一种键值对结构,如 value = {{field1,value1}...{fieldn,valuen}}
    使用场景:

    1. 哈希结构相对于字符串序列化缓存信息更加直观,并且在更新操作上更加便捷。
  • list
    列表类型是用来存储多个有序的字符串,列表的每个字符串成为一个元素,一个列表最多可以存储2的32次方减1个元素。在redis中,可以对列表插入(push)和弹出(pop),还可以获取指定范围的元素列表。列表是一种比较灵活的数据结构,它可以充当栈和队列的角色。
    使用场景:

    1. 消息队列
      redis的lpush+brpop命令组合就可以实现阻塞队列,生产者客户端是用lpush从列表左侧插入元素,多个消费者客户端使用brpop命令阻塞式的抢列表尾部的元素,多个客户端保证了消费的负载均衡的高可用性。
    2. 使用技巧列表

      lpush+lpop=Stack(栈)
      lpush+rpop=Queue(队列)
      lpush+ltrim=Capped Collection(有限集合)
      lpush+brpop=Message Queue(消息队列)
  • set
  • sortedset

redis是单线程的么,为什么

因为CPU并不是Redis的瓶颈,Redis的瓶颈最有可能是机器内存或者网络带宽。既然单线程容易实现,而且CPU不会成为瓶颈,那么久顺理成章的采用了单线程的方案。

当然单个Redis进程是没办法使用多核的 ,但是它来就不是非常计算密集型的服务。如果单核性能不够用,可以多开几个进程。

redis的部署方式,主从、集群

参考文章:https://segmentfault.com/a/11...

redis的哨兵模式

参考文章:https://www.cnblogs.com/xifen...

redis的持久化策略

  • RDB(快照持久化)
  • AOF(只追加文件持久化)

参考文章:https://segmentfault.com/a/11...

队列和栈的区别

  • 什么是队列?什么是栈?

    1. 队列(Queue):是限定只能在表的一端进行插入和在另一端删除操作的线性表。
    2. 栈(Stack):是限定之能在表的一端进行插入和删除操作的线性表。
  • 队列和栈的规则

    1. 队列:先进先出
    2. 栈:先进后出
  • 队列和栈的遍历数据速度

    1. 队列:基于地址指针进行遍历,而且可以从头部或者尾部进行遍历,但不能同时遍历,无需开辟空间,因为在遍历的过程中不影响数据结构,所以遍历速度要快。
    2. 栈:只能从顶部取数据,也就是说最先进入栈底的,需要遍历整个栈才能取出来,而且在遍历数据的同事需要微数据开辟临时空间,保持数据在遍历前的一致性。

PHP基础

  1. 双引号单引号区别

    • 双引号解释变量,单引号不解释变量
    • 双引号里插入单引号,其中单引号里如果有变量的话,变量解释
    • 双引号的变量名后面必须要有一个非数字、字母、下划线的特殊字符,或者用{}讲变量括起来,否则会将变量名后面的部分当做一个整体,引起语法错误
    • 能使单引号字符尽量使用单引号,单引号的效率比双引号要高
  2. GET和POST提交方式的区别

    • GET产生一个TCP数据包;POST产生两个TCP数据包;
      对于GET方式的请求,浏览器会把http header和data一并发送出去,服务器响应200(返回数据)
      对于POST,浏览器先发送header,服务器响应100 continue,浏览器再发送data,服务器响应200 ok(返回数据)。
    • GET在浏览器回退时是无害的,而POST会再次提交请求
    • GET请求会被浏览器主动cache,而POST不会,除非手动设置
    • GET请求参数会被完整保留在浏览器历史记录里,而POST中的参数不会被保留
    • GET请求只能进行url编码,而POST支持多种编码方式
    • GET比POST更不安全,因为参数直接暴露在URL上,所以不能用来传递敏感信息
  3. 如何获取客户端的真实ip
    $_SERVER['REMOTE_ADDR']或getenv('REMOTE_ADDR')
    可以使用ip2long()转成数字
  4. include和require的区别
    require是无条件包含,也就是如果一个流程里加入require,无论条件成立与否都会先执行require,当文件不存在或者无法打开的时候,会提示错误,并且会终止程序执行
    include有返回值,而require没有(可能因为如此require的速度比include快),如果被包含的文件不存在的化,那么会提示一个错误,但是程序会继续执行下去

    注意:包含文件不存在或者语法错误的时候require是致命的,而include不是

  5. AJAX的优势是什么
    ajax是异步传输技术,可以通过javascript实现,也可以通过JQuery框架实现,实现局部刷新,减轻了服务器的压力,也提高了用户体验
  6. 在程序的开发中,如何提高程序的运行效率

    • 优化SQL语句,查询语句中尽量不使用select *,用哪个字段查哪个字段;
    • 少用子查询可用表连接代替;
    • 少用模糊查询;
    • 数据表中创建索引;
    • 对程序中经常用到的数据生成缓存;
  7. SESSION与COOKIE的区别

  8. isset和empty的区别

    • isset()函数 一般用来检测变量是否设置
      若变量不存在则返回 FALSE
      若变量存在且其值为NULL,也返回 FALSE
      若变量存在且值不为NULL,则返回 TURE
    • empty()函数是检查变量是否为空
      若变量不存在则返回 TRUE
      若变量存在且其值为""、0、"0"、NULL、、FALSE、array()、var $var; 以及没有任何属性的对象,则返回 TURE
      若变量存在且值不为""、0、"0"、NULL、、FALSE、array()、var $var; 以及没有任何属性的对象,则返回 FALSE
  9. 数据库三范式

    • 第一范式:1NF是对属性的原子性约束,要求属性具有原子性,不可再分解;
    • 第二范式:2NF是对记录的惟一性约束,要求记录有惟一标识,即实体的惟一性;
    • 第三范式:3NF是对字段冗余性的约束,即任何字段不能由其他字段派生出来,它要求字段没有冗余。
  10. 主键、外键和索引的区别

    • 定义
      主键--唯一标识一条记录,不能有重复的,不允许为空
      外键--表的外键是另一表的主键, 外键可以有重复的, 可以是空值
      索引--该字段没有重复值,但可以有一个空值
    • 作用
      主键--用来保证数据完整性
      外键--用来和其他表建立联系用的
      索引--是提高查询排序的速度
    • 个数
      主键--主键只能有一个
      外键--一个表可以有多个外键
      索引--一个表可以有多个唯一索引
  11. 堆和栈的区别
    栈是编译期间就分配好的内存空间,因此你的代码中必须就栈的大小有明确的定义;
    堆是程序运行期间动态分配的内存空间,你可以根据程序的运行情况确定要分配的堆内存的大小。

PHP包管理器Composer与自动加载规范

composer学习地址:http://docs.phpcomposer.com/0...

composer.json中的自动加载映射

目前PSR-0自动加载、PSR-4自动加载、classmap生成和files引入都是被支持的,PSR-4是首推的方法,因为它提供了更大的易用性。

  • PSR-4
    PSR-4规范了如何指定文件路径从而自动加载类,同时规范了自动加载文件的位置。乍一看这是和PSR-0重复了,实际上,在功能上确实有一部分重复。区别在于,PSR-4的规范比较干净,去除了兼容PHP5.3以前版本的内容。
    PSR-4和PSR-0最大的区别是对下划线的定义不同,PSR-4中,在类名中使用下划线是没有特殊含义的,而在PSR-0的规则中,下划线或被转化为目录分隔符

    在PSR-4的键下,你可以定义命名空间和路径的映射关系,当自动加载类如Foo\\Bar\\Baz时,命名空间Foo指向一个名为src/的目录意味着自动加载器将查找名为src/Bar/Baz.php文件并引用它。

    命名空间的前缀必须以\\结尾,以避免类似前缀之间的冲突。在安装和更新期间,PSR-4引用全部组合到一个key=>value数组中,该数组可以在生成的文件vendor/composer/autoload_psr4.php中找到。

    例子:

    {
      "autoload": {
        "psr-4": {
          "App\\": "App/" // 命名空间App映射到目录App
        }
      }
    }
  • classmap
    classmap引用的所有组合,都会在安装、更新的过程中生成并存储到vendor/composer/autoload_classmap.php文件中。
    你可以使用classmap生成支持自定义加载的不遵循PSR-4规范的类库,要配置它指向的目录,以便能够准确的搜索到类文件

    例子:

    {
      "autoload": {
        "classmap": ["src/", "lib/", "Something.php"]
      }
    }
  • Files
    如果你想要明确指定,在每次请求时都要载入某些文件,那么你可以使用files字段加载。通常作为函数库的载入方式。

    例子:

    {
      "autoload": {
        "files": ["src/MyLibrary/functions"]
      }
    }

PHP框架

Laravel相关

Laravel是一套简洁、优雅的PHP Web开发框架(PHP Web Framework)。它可以让你从面条一样杂乱的代码中解脱出来;它可以帮你构建一个完美的网络APP,而且每行代码都可以简洁、富于表达力。

因为Laravel对底层的封装很深,所以你可能需要先去了解什么是依赖注入,什么是Laravel的服务容器,关于这两点我整理了下面两个链接,一个是(Symfony框架作者)写的什么是依赖注入,一个是深入研究Laravel的依赖注入容器(是我翻译的国外一大神的)

  1. 什么是依赖注入
  2. 译文深入研究Laravel的依赖注入容器

前端相关

参考复习资料

JavaScript

值传递 VS 引用传递

参考文章:数值类型vs引用类型

JavaScript有5种通过复制数值传值的数据类型:BooleannullundefindStringNumber,称之为基本数据类型
JavaScript还有三种通过引用传值的数据类型:ArrayFunctionObject,他们统称为Objects,故而称为对象。

  • 基本数据类型
    如果为一个基本数据类型变量赋值,我们可以认为变量包含这个原始值

    var x = 100;
    var y = 'abx';
    var z = null;
    var is_login = false;

    当我们使用=将这些变量赋值给其他变量时,我们把这些值拷贝给了这些新变量,他们是通过值复制的,也就是说在内存中会同时存在两个值相同的变量,并指向不同的内存空间:

    var x = 100;
    var name = 'saboran';
    
    var a = x;
    var b = name;

    值传递的好处是:当改变其中一个变量的值时并不会影响另一个变量的值。

  • 对象
    非基本数据类型的变量会保存对值(地址)的引用。该引用指向内存中对象的地址,变量实际不包含该实际值。对象创建于计算机内存中,当我们写下代码var arr = [],我们实际上是在内存中创建了一个新数组,arr中现在包含了新数组在内存中的地址。

    • 引用赋值
      当一个对象被用=赋值给另一个变量,实际上是复制过去的是那个对象在内存中的地址。对象通过引用赋值而不是直接传值,对象本身是静态不变的、唯一改变的是对象的引用地址。

作用域

参考文章:理解 JavaScript 作用域

声明提升

参考文章:JavaScript 变量声明提升

闭包

参考文档:JavaScript闭包

this

参考文章:javascript中的this作用域详解

apply、call、bind

参考文章:javascript中call()、apply()、bind()的用法终于理解

参考文章:独家解析Javascript原型继承

教程

廖雪峰的JavaScript全栈教程

参考文章

VueJS

  • VueJs双向数据绑定原理

Linux

Cors跨域

CORS的基本原理是通过设置HTTP请求和返回中header,告知浏览器该请求是合法的。这涉及到服务器端和浏览器端双方的设置:请求的发起(Http Request Header)和服务器对请求正确的响应(Http response header)。

参考文章:https://zhuanlan.zhihu.com/p/...

查看原文

leeon 收藏了文章 · 2018-08-08

[译] MYSQL索引最佳实践

近日整理文档时发现多年前的这个文档还是蛮实用的,然后在网络搜索了一下并没有相关的译文,所以决定把它翻译过来,如有不当的地方请多包涵和指正。原文地址:https://www.percona.com/files...

以下是译文:

你做了一个明智的选择

  • 理解索引对开发和dba来说都是极其重要

  • 差劲的索引对产品问题负相当大的一部分责任

  • 索引不是多么高深的问题

MySQL 索引一览表

  • 理解索引

  • 为你的应用创建最佳索引

  • 拥抱MySQL的限制

简述索引

索引有什么用

  • 为从数据库读取数据加速

  • 强制约束 (唯一索引 UNIQUE, 外键 FOREIGN KEY)

  • 没有任何索引的情况下查询页能正常运行

  • 但是那可能需要执行很长的时间

你可能听说过的索引类型

  • BTREE索引 – mysql中主要的索引类型

  • RTREE索引 – 只有MyISAM支持, 用于GIS

  • HASH 索引 – MEMORY, NDB 支持

  • BITMAP 索引 – MySQL 不支持

  • FULLTEXT 索引 – MyISAM, Innodb(MySQL 5.6以上支持)

类BTREE索引家族

  • 有很多不同的实现

    • 在可加速的操作中共享相同的属性

    • 内存相比硬盘使生活变得美好

  • B+树通常用于硬盘存储

    • 数据存储于叶子节点

B+Tree 示例

图片描述

MyISAM、Innodb索引对比

  • MyISAM

    • 数据指针指向数据文件中的物理位置

    • 所有索引都是一样的(指向物理位置))

  • Innodb

    • 主键索引 (显式或隐式) - 直接将数据存储于索引的叶子节点,而不是指针

    • 二级索引 – 保存主键索引的值作为数据指针

BTREE索引能用于什么操作 ?

  • 查询所有 KEY=5 的记录 (点查询)

  • 查询所有 KEY>5 的记录 (开合间)

  • 查询所有 5<KEY<10 的记录 (闭合间)

  • 不适用于:查询KEY最后一个数字等于0的所有记录

    • 因为这不能定义为范围查询操作

字符索引

  • 这(和数值)没什么区别… 真的

    • collation是为字符串定义的排序规则

    • 如: “AAAA” < “AAAB”

  • 前缀LIKE 查询是一种特殊的范围查询

    • LIKE “ABC%” 的意思是:

    • “ABC[最小值]”<KEY<“ABC[最大值]”

    • LIKE “%ABC” 无法使用索引查询

联合索引

  • 是这样进行排序的, 比较首列,然后第二列,第三列以此类推,如:

    • KEY(col1,col2,col3)

    • (1,2,3) < (1,3,1)

  • 使用一个BTREE索引,而不是每个层级一个单独的BTREE索引

索引的开销

  • 索引是昂贵的,不要添加多余的索引

    • 多数情况下,扩展索引比添加一个新的索引要好

  • 写 - 更新索引常常是数据库写操作的主要开销

  • 读 - 需要再硬盘和内存开销空间; 查询优化中需要额外的开销

索引成本的影响

  • 长主键索引(Innodb)
    – 使所有相应的二级索引 变得更长、更慢

  • “随机”主键索引(Innodb)
    – 插入导致大量的页面分割

  • 越长的索引通常越慢

  • Index with insertion in random order
    – SHA1(‘password’)

  • 低区分度的索引是低劣的
    – 在性别字段建的索引

  • 相关索引是不太昂贵的
    – insert_time与自增id是相关的

Innodb表的索引

  • 数据按主键聚集

    • 选择最佳的字段作为主键

    • 比如评论表 – (POST_ID,COMMENT_ID) 是作为主键的不错选择,使得单个post的评论聚在一起

  • 或者 “打包” 单个 BIGINT(字段)

  • 主键隐式地附加到所有索引中

    • KEY (A) 实质上是 KEY (A,ID)

  • 覆盖索引,有利于排序

MySQL是如何使用索引的

  • 查询

  • 排序

  • 避免读取数据(只读取索引)

  • 其他专门的优化

使用索引进行查询

  • SELECT * FROM EMPLOYEES WHERE
    LAST_NAME=“Smith”

    • 这是典型的索引 KEY(LAST_NAME)

  • 可以使用复合索引

    • SELECT * FROM EMPLOYEES WHERE
      LAST_NAME=“Smith” AND DEPT=“Accounting”

    • 将会使用索引 KEY(DEPT,LAST_NAME)

复合索引比较复杂

  • Index (A,B,C) - 字段顺序问题

  • 下列情形将会使用索引进行查询(全条件)

    • A>5

    • A=5 AND B>6

    • A=5 AND B=6 AND C=7

    • A=5 AND B IN (2,3) AND C>5

  • 下列条件将不会使用索引

    • B>5 – 条件没有B字段前的A

    • B=6 AND C=7 - 条件没有B、C字段前的A

  • 以下情形使用索引的一部分

    • A>5 AND B=2 - 第一个字段A的范围查询,导致只用上了索引中A字段的部分

    • A=5 AND B>6 AND C=2 - B字段的范围范围查询,导致只使用了索引中A和B两个字段的部分

MySQL优化器的第一法则

  • 在复合索引中,MySQL在遇到返回查询(<,>,
    BETWEEN)时,将停止中止剩余部分(索引)的使用;但是使用IN(…)的"范围查询"则可以继续往右使用索引(的更多部分)

所用索引进行排序

  • SELECT * FROM PLAYERS ORDER BY SCORE
    DESC LIMIT 10

    • 将使用索引 KEY(SCORE)

    • 不使用索引将进行非常昂贵的“filesort”操作(external
      sort)

  • 常常使用组合索引进行查询

    • SELECT * FROM PLAYERS WHERE COUNTRY=“US”
      ORDER BY SCORE DESC LIMIT 10

    • 最佳选择是 KEY(COUNTRY,SCORE)

高效排序的联合索引

  • 变得更加受限!

  • KEY(A,B)

  • 以下情形将会使用索引进行排序

    • ORDER BY A - 对索引首字段进行排序

    • A=5 ORDER BY B - 对第一个字段进行点查询,对第二个字段进行排序

    • ORDER BY A DESC, B DESC - 对两个字段进行相同的顺序进行排序

    • A>5 ORDER BY A - 对首字段进行范围查询,并对首字段进行排序

  • 以下情形将不使用索引进行排序

    • ORDER BY B - 对第二个字段进行排序(未使用首字段)

    • A>5 ORDER BY B – 对首字段进行范围查询,对第二个字段进行排序

    • A IN(1,2) ORDER BY B - 对首字段进行IN查询,对第二个字段进行排序

    • ORDER BY A ASC, B DESC - 对两个字段进行不同顺序的排序

MySQL使用索引排序的规则

  • 不能对两个字段进行不同顺序的排序

  • 对非ORDER BY部分的字段只能使用点查询(=)
    – 在这种情形下,IN()也不行

避免读取数据(只读取索引)

  • “覆盖索引”
    – 这里指 适用于特定查询的索引,而不是一种索引的类型

  • 只读取索引,而不去读取数据

    • SELECT STATUS FROM ORDERS WHERE
      CUSTOMER_ID=123

    • KEY(CUSTOMER_ID,STATUS)

  • 索引通常比数据本身要小

  • (索引)读取起来更有次序
    – 读取数据指针通常是随机的

Min/Max的优化

  • 索引可以帮助优化 MIN()/MAX() 这类的统计函数
    – 但只包含以下这些:

  • SELECT MAX(ID) FROM TBL;

  • SELECT MAX(SALARY) FROM EMPLOYEE
    GROUP BY DEPT_ID

    • 将受益于 KEY(DEPT_ID,SALARY)

    • “Using index for group-by”

联表查询中索引的使用

  • MySQL 使用 “嵌套循环(Nested Loops)”进行联表查询

    • SELECT * FROM POSTS,COMMENTS WHERE
      AUTHOR=“Peter” AND COMMENTS.POST_ID=POSTS.ID

    • 扫描表POSTS查询所有复合条件的 posts

    • 循环posts 在表COMMENTS 中查找 每个post的所有comments

  • 使每个关联的表(关联字段)都使用上索引显得非常的重要

  • 索引只有在被查询的字段上是必要的
    – POSTS.ID字段的索引再本次查询中是用不上的

  • 重新设计不能很好的所有索引的联合查询吧

使用多索引

  • MySQL可以使用超过1个索引

    • “索引合并”

  • SELECT * FROM TBL WHERE A=5 AND B=6
    – 可以分别使用索引 KEY(A)和 KEY(B)

    • 索引 KEY(A,B) 是更好的选择

  • SELECT * FROM TBL WHERE A=5 OR B=6
    – 两个索引同时分别被使用

    • 索引 KEY(A,B) 在这个查询中无法使用

前缀索引

  • 你可以在字段最左前缀建立索引

    • ALTER TABLE TITLE ADD KEY(TITLE(20));

    • 需要对BLOB/TEXT类型的字段建立索引

    • 能显著的减少空间使用

    • 不能用于覆盖索引

    • 选择前缀长度成为一个问题

选择前缀长度

  • 前缀应该有足够的区分度

    • 比较distinct前缀、distinct整个字段的值

mysql> select count(distinct(title)) total,count(distinct(left(title,10))) p10,count(distinct(left(title,20))) p20 from title;

totalp10p20
998335624949960894

1 row in set (44.19 sec)

  • 检查异常值

    • 确保不会有很多记录使用相同的前缀

使用最多的Title
mysql> select count(*) cnt, title tl from title group by tl order by cnt desc limit 3;

cnttl
136The Wedding
129Lost and Found
112Horror Marathon

3 rows in set (27.49 sec)

使用最多的Title 前缀
mysql> select count(*) cnt, left(title,20) tl from title group by tl order by cnt desc limit 3;

cnttl
184Wetten, dass..? aus
136The Wedding
129Lost and Found

3 rows in set (33.23 sec)

MySQL如何选择使用哪个索引的?

  • 每次查询动态选择
    – 查询文本中常量很重要

  • 评估需要查询的行数
    对给定的索引,在表中进行"dive"

  • 如果(dive)不可行时,使用 “Cardinality” 进行统计
    – 这是进行 ANALYZE TABLE时 更新的

更多关于索引的选择

  • 并不只是最小化扫描行数

  • 很多其他的heuristics(尝试) and hacks
    – 对Innodb来说主键是很重要的

    • 覆盖索引效益

    • Full table scan is faster, all being equal(这句不是太明白)

    • 我们也可以使用索引进行排序

  • 须知

    • 验证MYSQL实际使用的执行计划

    • 注意是可以根据常量和数据动态改变的

使用EXPLAIN

  • EXPLAIN 是一个很好的工具,可以看到MYSQL将如何进行查询

    mysql> explain select max(season_nr) from title group by production_year;

idselect_typetabletypepossible_keyskeykey_lenrefrowsExtra
1SIMPLEtitlerangeNULLproduction_year5NULL201Using index for group-by

1 row in set (0.01 sec)

MySQL Explain 101

  • “type” 从好到差排序如下:
    – system,const,eq_ref,ref,range,index,ALL

  • 注意 “rows” – 更大的数值意味着更慢的查询

  • 检查 “key_len” – 显示索引的哪些部分真实使用到了

  • 留意"Extra"

    • Using Index - 好

    • Using Filesort, Using Temporary - 差

索引策略

  • 为你的关键性能查询集建立索引
    – 整体取审视他们,而不是一个个看

  • 最好所有的查询条件和联表条件都使用索引
    – 起码区分度最高的部分是

  • 一般来说,可以的话,扩展索引,而不是创建新的索引

  • 修改时记得验证对性能的影响

索引策略示例

  • 按能支持更多查询的顺序建立索引

    • SELECT * FROM TBL WHERE A=5 AND B=6

    • SELECT * FROM TBL WHERE A>5 AND B=6
      – 对两个查询来说 KEY(B,A) 是更好的选择

  • 把所有都是点查询的字段放到索引的首位

  • 不要添加非性能关键查询的索引
    – 太多的索引会使MYSQL慢下来

Trick #1: 枚举范围

  • KEY (A,B)

  • SELECT * FROM TBL WHERE A BETWEEN 2
    AND 4 AND B=5

    • 将只使用索引的第一个字段部分

  • SELECT * FROM TBL WHERE A IN (2,3,4) AND
    B=5

    • 索引的两个字段部分都使用

Trick #2: 添加一个假的条件

  • KEY (GENDER,CITY)

  • SELECT * FROM PEOPLE WHERE CITY=“NEW
    YORK”

    • 完全用不上索引

  • SELECT * FROM PEOPLE WHERE GENDER IN
    (“M”,”F”) AND CITY=“NEW YORK”

    • 将用上索引

    • 这个Trick在低区别度的字段上可以很好的使用

    • Gender, Status, Boolean Types etc

Trick #3: 虚实Filesort

  • KEY(A,B)

  • SELECT * FROM TBL WHERE A IN (1,2) ORDER BY
    B LIMIT 5;

    • 无法使用索引进行排序

  • (SELECT FROM TBL WHERE A=1 ORDER BY B LIMIT 5) UNION ALL (SELECT FROM TBL WHERE A=2 ORDER BY B LIMIT 5) ORDER BY B LIMIT 5;

    • 将会用上索引,而“filesort”只用于对不超过10行记录

作者的ppt发出来后,很多人向他咨询相关问题,另外专门做了回复,oschina已经有对回复进行了翻译:
http://www.oschina.net/transl...

查看原文

leeon 赞了文章 · 2018-08-08

[译] MYSQL索引最佳实践

近日整理文档时发现多年前的这个文档还是蛮实用的,然后在网络搜索了一下并没有相关的译文,所以决定把它翻译过来,如有不当的地方请多包涵和指正。原文地址:https://www.percona.com/files...

以下是译文:

你做了一个明智的选择

  • 理解索引对开发和dba来说都是极其重要

  • 差劲的索引对产品问题负相当大的一部分责任

  • 索引不是多么高深的问题

MySQL 索引一览表

  • 理解索引

  • 为你的应用创建最佳索引

  • 拥抱MySQL的限制

简述索引

索引有什么用

  • 为从数据库读取数据加速

  • 强制约束 (唯一索引 UNIQUE, 外键 FOREIGN KEY)

  • 没有任何索引的情况下查询页能正常运行

  • 但是那可能需要执行很长的时间

你可能听说过的索引类型

  • BTREE索引 – mysql中主要的索引类型

  • RTREE索引 – 只有MyISAM支持, 用于GIS

  • HASH 索引 – MEMORY, NDB 支持

  • BITMAP 索引 – MySQL 不支持

  • FULLTEXT 索引 – MyISAM, Innodb(MySQL 5.6以上支持)

类BTREE索引家族

  • 有很多不同的实现

    • 在可加速的操作中共享相同的属性

    • 内存相比硬盘使生活变得美好

  • B+树通常用于硬盘存储

    • 数据存储于叶子节点

B+Tree 示例

图片描述

MyISAM、Innodb索引对比

  • MyISAM

    • 数据指针指向数据文件中的物理位置

    • 所有索引都是一样的(指向物理位置))

  • Innodb

    • 主键索引 (显式或隐式) - 直接将数据存储于索引的叶子节点,而不是指针

    • 二级索引 – 保存主键索引的值作为数据指针

BTREE索引能用于什么操作 ?

  • 查询所有 KEY=5 的记录 (点查询)

  • 查询所有 KEY>5 的记录 (开合间)

  • 查询所有 5<KEY<10 的记录 (闭合间)

  • 不适用于:查询KEY最后一个数字等于0的所有记录

    • 因为这不能定义为范围查询操作

字符索引

  • 这(和数值)没什么区别… 真的

    • collation是为字符串定义的排序规则

    • 如: “AAAA” < “AAAB”

  • 前缀LIKE 查询是一种特殊的范围查询

    • LIKE “ABC%” 的意思是:

    • “ABC[最小值]”<KEY<“ABC[最大值]”

    • LIKE “%ABC” 无法使用索引查询

联合索引

  • 是这样进行排序的, 比较首列,然后第二列,第三列以此类推,如:

    • KEY(col1,col2,col3)

    • (1,2,3) < (1,3,1)

  • 使用一个BTREE索引,而不是每个层级一个单独的BTREE索引

索引的开销

  • 索引是昂贵的,不要添加多余的索引

    • 多数情况下,扩展索引比添加一个新的索引要好

  • 写 - 更新索引常常是数据库写操作的主要开销

  • 读 - 需要再硬盘和内存开销空间; 查询优化中需要额外的开销

索引成本的影响

  • 长主键索引(Innodb)
    – 使所有相应的二级索引 变得更长、更慢

  • “随机”主键索引(Innodb)
    – 插入导致大量的页面分割

  • 越长的索引通常越慢

  • Index with insertion in random order
    – SHA1(‘password’)

  • 低区分度的索引是低劣的
    – 在性别字段建的索引

  • 相关索引是不太昂贵的
    – insert_time与自增id是相关的

Innodb表的索引

  • 数据按主键聚集

    • 选择最佳的字段作为主键

    • 比如评论表 – (POST_ID,COMMENT_ID) 是作为主键的不错选择,使得单个post的评论聚在一起

  • 或者 “打包” 单个 BIGINT(字段)

  • 主键隐式地附加到所有索引中

    • KEY (A) 实质上是 KEY (A,ID)

  • 覆盖索引,有利于排序

MySQL是如何使用索引的

  • 查询

  • 排序

  • 避免读取数据(只读取索引)

  • 其他专门的优化

使用索引进行查询

  • SELECT * FROM EMPLOYEES WHERE
    LAST_NAME=“Smith”

    • 这是典型的索引 KEY(LAST_NAME)

  • 可以使用复合索引

    • SELECT * FROM EMPLOYEES WHERE
      LAST_NAME=“Smith” AND DEPT=“Accounting”

    • 将会使用索引 KEY(DEPT,LAST_NAME)

复合索引比较复杂

  • Index (A,B,C) - 字段顺序问题

  • 下列情形将会使用索引进行查询(全条件)

    • A>5

    • A=5 AND B>6

    • A=5 AND B=6 AND C=7

    • A=5 AND B IN (2,3) AND C>5

  • 下列条件将不会使用索引

    • B>5 – 条件没有B字段前的A

    • B=6 AND C=7 - 条件没有B、C字段前的A

  • 以下情形使用索引的一部分

    • A>5 AND B=2 - 第一个字段A的范围查询,导致只用上了索引中A字段的部分

    • A=5 AND B>6 AND C=2 - B字段的范围范围查询,导致只使用了索引中A和B两个字段的部分

MySQL优化器的第一法则

  • 在复合索引中,MySQL在遇到返回查询(<,>,
    BETWEEN)时,将停止中止剩余部分(索引)的使用;但是使用IN(…)的"范围查询"则可以继续往右使用索引(的更多部分)

所用索引进行排序

  • SELECT * FROM PLAYERS ORDER BY SCORE
    DESC LIMIT 10

    • 将使用索引 KEY(SCORE)

    • 不使用索引将进行非常昂贵的“filesort”操作(external
      sort)

  • 常常使用组合索引进行查询

    • SELECT * FROM PLAYERS WHERE COUNTRY=“US”
      ORDER BY SCORE DESC LIMIT 10

    • 最佳选择是 KEY(COUNTRY,SCORE)

高效排序的联合索引

  • 变得更加受限!

  • KEY(A,B)

  • 以下情形将会使用索引进行排序

    • ORDER BY A - 对索引首字段进行排序

    • A=5 ORDER BY B - 对第一个字段进行点查询,对第二个字段进行排序

    • ORDER BY A DESC, B DESC - 对两个字段进行相同的顺序进行排序

    • A>5 ORDER BY A - 对首字段进行范围查询,并对首字段进行排序

  • 以下情形将不使用索引进行排序

    • ORDER BY B - 对第二个字段进行排序(未使用首字段)

    • A>5 ORDER BY B – 对首字段进行范围查询,对第二个字段进行排序

    • A IN(1,2) ORDER BY B - 对首字段进行IN查询,对第二个字段进行排序

    • ORDER BY A ASC, B DESC - 对两个字段进行不同顺序的排序

MySQL使用索引排序的规则

  • 不能对两个字段进行不同顺序的排序

  • 对非ORDER BY部分的字段只能使用点查询(=)
    – 在这种情形下,IN()也不行

避免读取数据(只读取索引)

  • “覆盖索引”
    – 这里指 适用于特定查询的索引,而不是一种索引的类型

  • 只读取索引,而不去读取数据

    • SELECT STATUS FROM ORDERS WHERE
      CUSTOMER_ID=123

    • KEY(CUSTOMER_ID,STATUS)

  • 索引通常比数据本身要小

  • (索引)读取起来更有次序
    – 读取数据指针通常是随机的

Min/Max的优化

  • 索引可以帮助优化 MIN()/MAX() 这类的统计函数
    – 但只包含以下这些:

  • SELECT MAX(ID) FROM TBL;

  • SELECT MAX(SALARY) FROM EMPLOYEE
    GROUP BY DEPT_ID

    • 将受益于 KEY(DEPT_ID,SALARY)

    • “Using index for group-by”

联表查询中索引的使用

  • MySQL 使用 “嵌套循环(Nested Loops)”进行联表查询

    • SELECT * FROM POSTS,COMMENTS WHERE
      AUTHOR=“Peter” AND COMMENTS.POST_ID=POSTS.ID

    • 扫描表POSTS查询所有复合条件的 posts

    • 循环posts 在表COMMENTS 中查找 每个post的所有comments

  • 使每个关联的表(关联字段)都使用上索引显得非常的重要

  • 索引只有在被查询的字段上是必要的
    – POSTS.ID字段的索引再本次查询中是用不上的

  • 重新设计不能很好的所有索引的联合查询吧

使用多索引

  • MySQL可以使用超过1个索引

    • “索引合并”

  • SELECT * FROM TBL WHERE A=5 AND B=6
    – 可以分别使用索引 KEY(A)和 KEY(B)

    • 索引 KEY(A,B) 是更好的选择

  • SELECT * FROM TBL WHERE A=5 OR B=6
    – 两个索引同时分别被使用

    • 索引 KEY(A,B) 在这个查询中无法使用

前缀索引

  • 你可以在字段最左前缀建立索引

    • ALTER TABLE TITLE ADD KEY(TITLE(20));

    • 需要对BLOB/TEXT类型的字段建立索引

    • 能显著的减少空间使用

    • 不能用于覆盖索引

    • 选择前缀长度成为一个问题

选择前缀长度

  • 前缀应该有足够的区分度

    • 比较distinct前缀、distinct整个字段的值

mysql> select count(distinct(title)) total,count(distinct(left(title,10))) p10,count(distinct(left(title,20))) p20 from title;

totalp10p20
998335624949960894

1 row in set (44.19 sec)

  • 检查异常值

    • 确保不会有很多记录使用相同的前缀

使用最多的Title
mysql> select count(*) cnt, title tl from title group by tl order by cnt desc limit 3;

cnttl
136The Wedding
129Lost and Found
112Horror Marathon

3 rows in set (27.49 sec)

使用最多的Title 前缀
mysql> select count(*) cnt, left(title,20) tl from title group by tl order by cnt desc limit 3;

cnttl
184Wetten, dass..? aus
136The Wedding
129Lost and Found

3 rows in set (33.23 sec)

MySQL如何选择使用哪个索引的?

  • 每次查询动态选择
    – 查询文本中常量很重要

  • 评估需要查询的行数
    对给定的索引,在表中进行"dive"

  • 如果(dive)不可行时,使用 “Cardinality” 进行统计
    – 这是进行 ANALYZE TABLE时 更新的

更多关于索引的选择

  • 并不只是最小化扫描行数

  • 很多其他的heuristics(尝试) and hacks
    – 对Innodb来说主键是很重要的

    • 覆盖索引效益

    • Full table scan is faster, all being equal(这句不是太明白)

    • 我们也可以使用索引进行排序

  • 须知

    • 验证MYSQL实际使用的执行计划

    • 注意是可以根据常量和数据动态改变的

使用EXPLAIN

  • EXPLAIN 是一个很好的工具,可以看到MYSQL将如何进行查询

    mysql> explain select max(season_nr) from title group by production_year;

idselect_typetabletypepossible_keyskeykey_lenrefrowsExtra
1SIMPLEtitlerangeNULLproduction_year5NULL201Using index for group-by

1 row in set (0.01 sec)

MySQL Explain 101

  • “type” 从好到差排序如下:
    – system,const,eq_ref,ref,range,index,ALL

  • 注意 “rows” – 更大的数值意味着更慢的查询

  • 检查 “key_len” – 显示索引的哪些部分真实使用到了

  • 留意"Extra"

    • Using Index - 好

    • Using Filesort, Using Temporary - 差

索引策略

  • 为你的关键性能查询集建立索引
    – 整体取审视他们,而不是一个个看

  • 最好所有的查询条件和联表条件都使用索引
    – 起码区分度最高的部分是

  • 一般来说,可以的话,扩展索引,而不是创建新的索引

  • 修改时记得验证对性能的影响

索引策略示例

  • 按能支持更多查询的顺序建立索引

    • SELECT * FROM TBL WHERE A=5 AND B=6

    • SELECT * FROM TBL WHERE A>5 AND B=6
      – 对两个查询来说 KEY(B,A) 是更好的选择

  • 把所有都是点查询的字段放到索引的首位

  • 不要添加非性能关键查询的索引
    – 太多的索引会使MYSQL慢下来

Trick #1: 枚举范围

  • KEY (A,B)

  • SELECT * FROM TBL WHERE A BETWEEN 2
    AND 4 AND B=5

    • 将只使用索引的第一个字段部分

  • SELECT * FROM TBL WHERE A IN (2,3,4) AND
    B=5

    • 索引的两个字段部分都使用

Trick #2: 添加一个假的条件

  • KEY (GENDER,CITY)

  • SELECT * FROM PEOPLE WHERE CITY=“NEW
    YORK”

    • 完全用不上索引

  • SELECT * FROM PEOPLE WHERE GENDER IN
    (“M”,”F”) AND CITY=“NEW YORK”

    • 将用上索引

    • 这个Trick在低区别度的字段上可以很好的使用

    • Gender, Status, Boolean Types etc

Trick #3: 虚实Filesort

  • KEY(A,B)

  • SELECT * FROM TBL WHERE A IN (1,2) ORDER BY
    B LIMIT 5;

    • 无法使用索引进行排序

  • (SELECT FROM TBL WHERE A=1 ORDER BY B LIMIT 5) UNION ALL (SELECT FROM TBL WHERE A=2 ORDER BY B LIMIT 5) ORDER BY B LIMIT 5;

    • 将会用上索引,而“filesort”只用于对不超过10行记录

作者的ppt发出来后,很多人向他咨询相关问题,另外专门做了回复,oschina已经有对回复进行了翻译:
http://www.oschina.net/transl...

查看原文

赞 29 收藏 206 评论 5

leeon 关注了专栏 · 2018-08-08

PHP 开发之旅

分享PHP编程的实践经验, 不限于PHP

关注 56

leeon 关注了用户 · 2018-07-29

entner @entner

青年 ---------------

-关注前沿、实时更新、接近生活、积淀经验、保持健康

flag:开源 MVC
to: 让小白们了解一般的mvc框架(如:laravel、thinkphp)的实现原理 我们自己也能写~

关注 134

leeon 赞了文章 · 2018-06-21

你应该知道Go语言的几个优势

要说起GO语言的优势,我们就得从GO语言的历史讲起了……

本文由腾讯技术工程官方号发表在腾讯云+社区

2007年,受够了C++煎熬的Google首席软件工程师Rob Pike纠集Robert Griesemer和Ken Thompson两位牛人,决定创造一种新语言来取代C++, 这就是Golang。出现在21世纪的GO语言,虽然不能如愿对C++取而代之,但是其近C的执行性能和近解析型语言的开发效率以及近乎于完美的编译速度,已经风靡全球。特别是在云项目中,大部分都使用了Golang来开发,不得不说,Golang早已深入人心。而对于一个没有历史负担的新项目,Golang或许就是个不二的选择。

被称为GO语言之父的Rob Pike说,你是否同意GO语言,取决于你是认可少就是多,还是少就是少(Less is more or less is less)。Rob Pike以一种非常朴素的方式,概括了GO语言的整个设计哲学--将简单、实用体现得淋漓尽致。

很多人将GO语言称为21世纪的C语言,因为GO不仅拥有C的简洁和性能,而且还很好的提供了21世纪互联网环境下服务端开发的各种实用特性,让开发者在语言级别就可以方便的得到自己想要的东西。

发展历史

2007年9月,Rob Pike在Google分布式编译平台上进行C++编译,在漫长的等待过程中,他和Robert Griesemer探讨了程序设计语言的一些关键性问题,他们认为,简化编程语言相比于在臃肿的语言上不断增加新特性,会是更大的进步。随后他们在编译结束之前说服了身边的Ken Thompson,觉得有必要为此做一些事情。几天后,他们发起了一个叫Golang的项目,将它作为自由时间的实验项目。

2008年5月 Google发现了GO语言的巨大潜力,得到了Google的全力支持,这些人开始全职投入GO语言的设计和开发。

2009年11月 GO语言第一个版本发布。2012年3月 第一个正式版本Go1.0发布。

2015年8月 go1.5发布,这个版本被认为是历史性的。完全移除C语言部分,使用GO编译GO,少量代码使用汇编实现。另外,他们请来了内存管理方面的权威专家Rick Hudson,对GC进行了重新设计,支持并发GC,解决了一直以来广为诟病的GC时延(STW)问题。并且在此后的版本中,又对GC做了更进一步的优化。到go1.8时,相同业务场景下的GC时延已经可以从go1.1的数秒,控制在1ms以内。GC问题的解决,可以说GO语言在服务端开发方面,几乎抹平了所有的弱点。

在GO语言的版本迭代过程中,语言特性基本上没有太大的变化,基本上维持在GO1.1的基准上,并且官方承诺,新版本对老版本下开发的代码完全兼容。事实上,GO开发团队在新增语言特性上显得非常谨慎,而在稳定性、编译速度、执行效率以及GC性能等方面进行了持续不断的优化。

开发团队

img

GO语言的开发阵营可以说是空前强大,主要成员中不乏计算机软件界的历史性人物,对计算机软件的发展影响深远。Ken Thompson,来自贝尔实验室,设计了B语言,创立了Unix操作系统(最初使用B语言实现),随后在Unix开发过程中,又和Dennis Ritchie一同设计了C语言,继而使用C语言重构了Unix操作系统。Dennis Ritchie和Ken Thompson被称为Unix和C语言之父,并在1983年共同被授以图灵奖,以表彰他们对计算机软件发展所作的杰出贡献。Rob Pike,同样来自贝尔实验室,Unix小组重要成员,发明了Limbo语言,并且和Ken Thompson共同设计了UTF-8编码,《Unix编程环境》、《编程实践》作者之一。

可以说,GO语言背靠Google这棵大树,又不乏牛人坐镇,是名副其实的“牛二代”。

img

大名鼎鼎的Docker,完全用GO实现,业界最为火爆的容器编排管理系统kubernetes,完全用GO实现,之后的Docker Swarm,完全用GO实现。除此之外,还有各种有名的项目如etcd/consul/flannel等等,均使用GO实现。有人说,GO语言之所以出名,是赶上了云时代,但为什么不能换种说法,也是GO语言促使了云的发展?

除了云项目外,还有像今日头条、UBER这样的公司,他们也使用GO语言对自己的业务进行了彻底的重构。

GO语言关键特性

GO语言之所以厉害,是因为它在服务端的开发中,总能抓住程序员的痛点,以最直接、简单、高效、稳定的方式来解决问题。这里我们并不会深入讨论GO语言的具体语法,只会将语言中关键的、对简化编程具有重要意义的方面介绍给大家,跟随大师们的脚步,体验GO的设计哲学。

GO语言的关键特性主要包括以下几方面:

  • 并发与协程
  • 基于消息传递的通信方式
  • 丰富实用的内置数据类型
  • 函数多返回值
  • defer机制
  • 反射(reflect)
  • 高性能HTTP Server
  • 工程管理
  • 编程规范

img

在当今这个多核时代,并发编程的意义不言而喻。当然,很多语言都支持多线程、多进程编程,但遗憾的是,实现和控制起来并不是那么令人感觉轻松和愉悦。Golang不同的是,语言级别支持协程(goroutine)并发(协程又称微线程,比线程更轻量、开销更小,性能更高),操作起来非常简单,语言级别提供关键字(go)用于启动协程,并且在同一台机器上可以启动成千上万个协程。

对比JAVA的多线程和GO的协程实现,明显更直接、简单。这就是GO的魅力所在,以简单、高效的方式解决问题,关键字go,或许就是GO语言最重要的标志。

基于消息传递的通信方式

img

在异步的并发编程过程中,只能方便、快速的启动协程还不够。协程之间的消息通信,也是非常重要的一环,否则,各个协程就会成为脱缰的野马而无法控制。在GO语言中,使用基于消息传递的通信方式(而不是大多数语言所使用的基于共享内存的通信方式)进行协程间通信,并且将消息管道(channel)作为基本的数据类型,使用类型关键字(chan)进行定义,并发操作时线程安全。这点在语言的实现上,也具有革命性。可见,GO语言本身并非简单得没有底线,恰恰他们会将最实用、最有利于解决问题的能力,以最简单、直接的形式提供给用户。

Channel并不仅仅只是用于简单的消息通信,还可以引申出很多非常实用,而实现起来又非常方便的功能。比如,实现TCP连接池、限流等等,而这些在其它语言中实现起来并不轻松,但GO语言可以轻易做到。

img

GO语言作为编译型语言,在数据类型上也支持得非常全面,除了传统的整型、浮点型、字符型、数组、结构等类型外。从实用性上考虑,也对字符串类型、切片类型(可变长数组)、字典类型、复数类型、错误类型、管道类型、甚至任意类型(Interface{})进行了原生支持,并且用起来非常方便。比如字符串、切片类型,操作简便性几乎和python类似。

另外,将错误类型(error)作为基本的数据类型,并且在语言级别不再支持try…catch的用法,这应该算是一个非常大胆的革命性创举,也难怪很多人吐槽GO语言不伦不类。但是跳出传统的观念,GO的开发者认为在编程过程中,要保证程序的健壮性和稳定性,对异常的精确化处理是非常重要的,只有在每一个逻辑处理完成后,明确的告知上层调用,是否有异常,并由上层调用明确、及时的对异常进行处理,这样才可以高程度的保证程序的健壮性和稳定性。虽然这样做会在编程过程中出现大量的对error结果的判断,但是这无疑也增强了开发者对异常处理的警惕度。而实践证明,只要严格按GO推荐的风格编码,想写出不健壮的代码,都很难。当然,前提是你不排斥它,认可它。

img

在语言中支持函数多返回值,并不是什么新鲜事,Python就是其中之一。允许函数返回多个值,在某些场景下,可以有效的简化编程。GO语言推荐的编程风格,是函数返回的最后一个参数为error类型(只要逻辑体中可能出现异常),这样,在语言级别支持多返回值,就很有必要了。

Defer延迟处理机制

img

在GO语言中,提供关键字defer,可以通过该关键字指定需要延迟执行的逻辑体,即在函数体return前或出现panic时执行。这种机制非常适合善后逻辑处理,比如可以尽早避免可能出现的资源泄漏问题。

可以说,defer是继goroutine和channel之后的另一个非常重要、实用的语言特性,对defer的引入,在很大程度上可以简化编程,并且在语言描述上显得更为自然,极大的增强了代码的可读性。

img

Golang作为强类型的编译型语言,灵活性上自然不如解析型语言。比如像PHP,弱类型,并且可以直接对一个字符串变量的内容进行new操作,而在编译型语言中,这显然不太可能。但是,Golang提供了Any类型(interface{})和强大的类型反射(reflect)能力,二者相结合,开发的灵活性上已经很接近解析型语言。在逻辑的动态调用方面,实现起来仍然非常简单。既然如此,那么像PHP这种解析型语言相比于GO,优势在那里呢?就我个人而言,写了近10年的PHP,实现过开发框架、基础类库以及各种公共组件,虽然执行性能不足,但是开发效率有余;而当遇上Golang,这些优势似乎不那么明显了。

img

作为出现在互联网时代的服务端语言,面向用户服务的能力必不可少。GO在语言级别自带HTTP/TCP/UDP高性能服务器,基于协程并发,为业务开发提供最直接有效的能力支持。要在GO语言中实现一个高性能的HTTP Server,只需要几行代码即可完成,非常简单。

img

在GO语言中,有一套标准的工程管理规范,只要按照这个规范进行项目开发,之后的事情(比如包管理、编译等等)都将变得非常的简单。

在GO项目下,存在两个关键目录,一个是src目录,用于存放所有的.go源码文件;一个是bin目录,用于存在编译后的二进制文件。在src目录下,除了main主包所在的目录外,其它所有的目录名称与直接目录下所对应的包名保持对应,否则编译无法通过。这样,GO编译器就可以从main包所在的目录开始,完全使用目录结构和包名来推导工程结构以及构建顺序,避免像C++一样,引入一个额外的Makefile文件。

在GO的编译过程中,我们唯一要做的就是将GO项目路径赋值给一个叫GOPATH的环境变量,让编译器知道将要编译的GO项目所在的位置。然后进入bin目录下,执行go build {主包所在的目录名},即可秒级完成工程编译。编译后的二进制文件,可以推到同类OS上直接运行,没有任何环境依赖。

img

GO语言的编程规范强制集成在语言中,比如明确规定花括号摆放位置,强制要求一行一句,不允许导入没有使用的包,不允许定义没有使用的变量,提供gofmt工具强制格式化代码等等。奇怪的是,这些也引起了很多程序员的不满,有人发表GO语言的XX条罪状,里面就不乏对编程规范的指责。要知道,从工程管理的角度,任何一个开发团队都会对特定语言制定特定的编程规范,特别像Google这样的公司,更是如此。GO的设计者们认为,与其将规范写在文档里,还不如强制集成在语言里,这样更直接,更有利用团队协作和工程管理。

API快速开发框架实践

编程语言是一个工具,它会告诉我们能做什么,而怎么做会更好,同样值得去探讨。这部分会介绍用GO语言实现的一个开发框架,以及几个公共组件。当然,框架和公共组件,其它语言也完全可以实现,而这里所关注的是成本问题。除此之外,抛开GO语言本身不说,我们也希望可以让大家从介绍的几个组件中,得到一些解决问题的思路,那就是通过某种方式,去解决一个面上的问题,而非一味的写代码,最终却只是解决点上的问题。如果你认可这种方式,相信下面的内容也许会影响你之后的项目开发方式,从根本上提高开发效率。

我们为什么选择GO语言

选择GO语言,主要是基于两方面的考虑

  1. 执行性能 缩短API的响应时长,解决批量请求访问超时的问题。在Uwork的业务场景下,一次API批量请求,往往会涉及对另外接口服务的多次调用,而在之前的PHP实现模式下,要做到并行调用是非常困难的,串行处理却不能从根本上提高处理性能。而GO语言不一样,通过协程可以方便的实现API的并行处理,达到处理效率的最大化。 依赖Golang的高性能HTTP Server,提升系统吞吐能力,由PHP的数百级别提升到数千里甚至过万级别。
  2. 开发效率 GO语言使用起来简单、代码描述效率高、编码规范统一、上手快。 通过少量的代码,即可实现框架的标准化,并以统一的规范快速构建API业务逻辑。 能快速的构建各种通用组件和公共类库,进一步提升开发效率,实现特定场景下的功能量产。

img

很多人在学习一门新语言或开启一个新项目时,都会习惯性的是网上找一个认为合适的开源框架来开始自己的项目开发之旅。这样并没有什么不好,但是个人觉得,了解它内部的实现对我们会更有帮助。或许大家已经注意到了,所说的MVC框架,其本质上就是对请求路径进行解析,然后根据请求路径段,路由到相应的控制器(C)上,再由控制器进一步调用数据逻辑(M),拿到数据后,渲染视图(V),返回用户。在整个过程中,核心点在于逻辑的动态调用。

不过,对API框架的实现相对于WEB页面框架的实现,会更简单,因为它并不涉及视图的渲染,只需要将数据结果以协议的方式返回给用户即可。

使用GO语言实现一套完整的MVC开发框架,是非常容易的,集成HTTP Server的同时,整个框架的核心代码不会超过300行,从这里可以实际感受到GO的语言描述效率之高(如果有兴趣,可以参考Uwork开源项目seine)。

也有人说,在GO语言中,就没有框架可言,言外之意是说,引入一个重型的开源框架,必要性并不大,相反还可能把简单的东西复杂化。

img

在实际项目开发过程中,只有高效的开发语言还不够,要想进一步将开发效率扩大化,不断的沉淀公共基础库是必不可少的,以便将通用的基础逻辑进一步抽象和复用。

除此之外,通用组件能力是实现功能量产的根本,对开发效率会是质的提升。组件化的开发模式会帮忙我们将问题的解决能力从一个点上提升到一个面上。以下会重点介绍几个通用组件的实现,有了它们的存在,才能真正的解放程序员的生产力。而这些强有力的公共组件在Golang中实现起来并不复杂。同时,结合Golang的并发处理能力,相比于PHP的版本实现,执行效率也会有质的提升。这是组件能力和语言效率的完美结合。

img

通用列表组件用于所有可能的二维数据源(如MySQL/MongoDB/ES等等)的数据查询场景,从一个面上解决了数据查询问题。在Uwork项目开发中,被大量使用,实现数据查询接口和页面查询列表的量产开发。它以一个JSON配置文件为中心,来实现对通用数据源的查询,并将查询结果以API或页面的形式自动返回给用户。整个过程中几乎没有代码开发,而唯一要做的只是以一种统一的规范编写配置文件(而不是代码),真正实现了对数据查询需求的功能量产。

img

以上是通用列表组件的构建过程,要实现这样一个功能强大的通用组件,是不是会给人一种可望而不可及的感觉?其实并非如此,只要理清了它的整个过程,将构建思路融入Golang中,并不是一件复杂的事情。在我们的项目中,整个组件的实现,只用了不到700行Go代码,就解决了一系列的数据查询问题。另外,通过Golang的并发特性,实现字段处理器的并行执行,进一步的提高了组件的执行效率。可以说,通用列表和Golang的融合,是性能和效率的完美结合。

img

通用表单组件主要用于对数据库的增、删、改场景。该组件在Uwork的项目开发中,也有广泛的应用,与通用列表类似,以一个JSON配置文件为中心,来完成对数据表数据的增、删、改操作。特别是近期完成的部件级SDB管理平台,通过通用表单实现了对整个系统的数据维护,通过高度抽象化,做到了业务的无代码化生产。

img

以上是通用表单的完整构建过程,而对于这个一个组件的实现,我们用了不到1000行的GO代码,就解决了对数据表数据维护整个面上的问题。

img

GO语言本身支持协程并发,协程非常轻量,可以快速启动成千上万个协程工作单元。如果对协程任务的数量控制不当,最后的结果很可能适得其反,从而对外部或本身的服务造成不必要的压力。协程池可以在一定程度上控制执行单元的数量,保证执行的安全性。而在Golang中要实现这样一个协程池,是非常简单的,只需要对channel和goroutine稍加封装,就可以完成,整个构建过程不到80行代码。

img

在API开发过程中,数据校验永远是必不可或缺的一个环节。如果只是简单的数据校验,几行代码也许就完成了,可是当遇上复杂的数据校验时,很可能几百行的代码量也未必能完成,特别是遇到递归类型的数据校验,那简直就是一个噩梦。

数据校验组件,可以通过一种数据模板的配置方式,使用特定的逻辑来完成通用校验,开发者只需要配置好相应的数据模板,进行简单的调用,即可完成整个校验过程。而对于这样一个通用性的数据校验组件,在GO语言中只用了不到700行的代码量就完成了整个构建。

小结

img

在实际项目开发过程中,对开发效率提升最大的,无疑是符合系统业务场景的公共组件能力,这点也正好应证了Rob Pike那句话(Less is lessor Less is more),真正的高效率开发,是配置化的,并不需要写太多的代码,甚至根本就不需要写代码,即可完成逻辑实现,而这种方式对于后期的维护成本也是最优的,因为做到了高度的统一。

GO的语言描述效率毋庸置疑,对上述所有公共组件的实现,均未超过1000行代码,就解决了某个面上的问题。

(以上的部分代码已经在Uwork开源项目seine中提供)

性能评测

压力测试环境说明:

  • 服务运行机器:单台空闲B6,24核CPU、64G内存。
  • PHP API环境:Nginx+PHP-FPM,CI框架。其中Nginx启动10个子进程,每个子进程最大接收1024个连接,php-fpm使用static模式,启动2000个常驻子进程。
  • Golang API环境:使用go1.8.6编译,直接拉起Golang API Server进程(HttpServer),不考虑调优。
  • 客户发起请求测试程序:使用Golang编写,协程并发,运行在独立的另外一台空闲B6上,24核CPU,64G内存,依次在1-2000个不同级别(并发数步长为50)的并发上分别请求20000次。

压力测试结果对比

img

在Golang API框架中,当并发数>50时,处理QPS在6.5w/s附近波动。表现稳定,压力测试过程无报错。

Nginx+php-fpm,只在index.php中输出exit('ok'),当并发数>50时,处理QPS在1w/s附近波动。表现稳定,压力测试过程无报错。

Nginx+php-fpm+CI框架中,逻辑执行到具体业务逻辑点,输出exit('ok'),当并发数>50时,处理QPS在750/s附近波动。并且表现不稳定,压力测试过程中随着并发数的增大,错误量随之增加。

通过压力测试可以发现,Golang和PHP在执行性能上,并没有什么可比性;而使用Golang实现的HTTP API框架,空载时单机性能QPS达到6.5w/s,还是非常令人满意的。

开发过程中需要注意的点

以下是在实际开发过程中遇到的一些问题,仅供参考:

异常处理统一使用error,不要使用panic/recover来模拟throw…catch,最初我是这么做的,后来发现这完全是自以为是的做法。

原生的error过于简单,而在实际的API开发过程中,不同的异常情况需要附带不同的返回码,基于此,有必要对error再进行一层封装。

任何协程逻辑执行体,逻辑最开始处必须要有defer recover()异常恢复处理,否则goroutine内出现的panic,将导致整个进程宕掉,需要避免部分逻辑BUG造成全局影响。

在Golang中,变量(chan类型除外)的操作是非线程安全的,也包括像int这样的基本类型,因此并发操作全局变量时一定要考虑加锁,特别是对map的并发操作。

所有对map键值的获取,都应该判断存在性,最好是对同类操作进行统一封装,避免出现不必要的运行时异常。

定义slice数据类型时,尽量预设长度,避免内部出现不必要的数据重组。


此文已由作者授权腾讯云+社区发布,原文链接:https://cloud.tencent.com/dev...

欢迎大家前往腾讯云+社区或关注云加社区微信公众号(QcloudCommunity),第一时间获取更多海量技术实践干货哦~

查看原文

赞 157 收藏 126 评论 4

leeon 收藏了文章 · 2018-06-21

你应该知道Go语言的几个优势

要说起GO语言的优势,我们就得从GO语言的历史讲起了……

本文由腾讯技术工程官方号发表在腾讯云+社区

2007年,受够了C++煎熬的Google首席软件工程师Rob Pike纠集Robert Griesemer和Ken Thompson两位牛人,决定创造一种新语言来取代C++, 这就是Golang。出现在21世纪的GO语言,虽然不能如愿对C++取而代之,但是其近C的执行性能和近解析型语言的开发效率以及近乎于完美的编译速度,已经风靡全球。特别是在云项目中,大部分都使用了Golang来开发,不得不说,Golang早已深入人心。而对于一个没有历史负担的新项目,Golang或许就是个不二的选择。

被称为GO语言之父的Rob Pike说,你是否同意GO语言,取决于你是认可少就是多,还是少就是少(Less is more or less is less)。Rob Pike以一种非常朴素的方式,概括了GO语言的整个设计哲学--将简单、实用体现得淋漓尽致。

很多人将GO语言称为21世纪的C语言,因为GO不仅拥有C的简洁和性能,而且还很好的提供了21世纪互联网环境下服务端开发的各种实用特性,让开发者在语言级别就可以方便的得到自己想要的东西。

发展历史

2007年9月,Rob Pike在Google分布式编译平台上进行C++编译,在漫长的等待过程中,他和Robert Griesemer探讨了程序设计语言的一些关键性问题,他们认为,简化编程语言相比于在臃肿的语言上不断增加新特性,会是更大的进步。随后他们在编译结束之前说服了身边的Ken Thompson,觉得有必要为此做一些事情。几天后,他们发起了一个叫Golang的项目,将它作为自由时间的实验项目。

2008年5月 Google发现了GO语言的巨大潜力,得到了Google的全力支持,这些人开始全职投入GO语言的设计和开发。

2009年11月 GO语言第一个版本发布。2012年3月 第一个正式版本Go1.0发布。

2015年8月 go1.5发布,这个版本被认为是历史性的。完全移除C语言部分,使用GO编译GO,少量代码使用汇编实现。另外,他们请来了内存管理方面的权威专家Rick Hudson,对GC进行了重新设计,支持并发GC,解决了一直以来广为诟病的GC时延(STW)问题。并且在此后的版本中,又对GC做了更进一步的优化。到go1.8时,相同业务场景下的GC时延已经可以从go1.1的数秒,控制在1ms以内。GC问题的解决,可以说GO语言在服务端开发方面,几乎抹平了所有的弱点。

在GO语言的版本迭代过程中,语言特性基本上没有太大的变化,基本上维持在GO1.1的基准上,并且官方承诺,新版本对老版本下开发的代码完全兼容。事实上,GO开发团队在新增语言特性上显得非常谨慎,而在稳定性、编译速度、执行效率以及GC性能等方面进行了持续不断的优化。

开发团队

img

GO语言的开发阵营可以说是空前强大,主要成员中不乏计算机软件界的历史性人物,对计算机软件的发展影响深远。Ken Thompson,来自贝尔实验室,设计了B语言,创立了Unix操作系统(最初使用B语言实现),随后在Unix开发过程中,又和Dennis Ritchie一同设计了C语言,继而使用C语言重构了Unix操作系统。Dennis Ritchie和Ken Thompson被称为Unix和C语言之父,并在1983年共同被授以图灵奖,以表彰他们对计算机软件发展所作的杰出贡献。Rob Pike,同样来自贝尔实验室,Unix小组重要成员,发明了Limbo语言,并且和Ken Thompson共同设计了UTF-8编码,《Unix编程环境》、《编程实践》作者之一。

可以说,GO语言背靠Google这棵大树,又不乏牛人坐镇,是名副其实的“牛二代”。

img

大名鼎鼎的Docker,完全用GO实现,业界最为火爆的容器编排管理系统kubernetes,完全用GO实现,之后的Docker Swarm,完全用GO实现。除此之外,还有各种有名的项目如etcd/consul/flannel等等,均使用GO实现。有人说,GO语言之所以出名,是赶上了云时代,但为什么不能换种说法,也是GO语言促使了云的发展?

除了云项目外,还有像今日头条、UBER这样的公司,他们也使用GO语言对自己的业务进行了彻底的重构。

GO语言关键特性

GO语言之所以厉害,是因为它在服务端的开发中,总能抓住程序员的痛点,以最直接、简单、高效、稳定的方式来解决问题。这里我们并不会深入讨论GO语言的具体语法,只会将语言中关键的、对简化编程具有重要意义的方面介绍给大家,跟随大师们的脚步,体验GO的设计哲学。

GO语言的关键特性主要包括以下几方面:

  • 并发与协程
  • 基于消息传递的通信方式
  • 丰富实用的内置数据类型
  • 函数多返回值
  • defer机制
  • 反射(reflect)
  • 高性能HTTP Server
  • 工程管理
  • 编程规范

img

在当今这个多核时代,并发编程的意义不言而喻。当然,很多语言都支持多线程、多进程编程,但遗憾的是,实现和控制起来并不是那么令人感觉轻松和愉悦。Golang不同的是,语言级别支持协程(goroutine)并发(协程又称微线程,比线程更轻量、开销更小,性能更高),操作起来非常简单,语言级别提供关键字(go)用于启动协程,并且在同一台机器上可以启动成千上万个协程。

对比JAVA的多线程和GO的协程实现,明显更直接、简单。这就是GO的魅力所在,以简单、高效的方式解决问题,关键字go,或许就是GO语言最重要的标志。

基于消息传递的通信方式

img

在异步的并发编程过程中,只能方便、快速的启动协程还不够。协程之间的消息通信,也是非常重要的一环,否则,各个协程就会成为脱缰的野马而无法控制。在GO语言中,使用基于消息传递的通信方式(而不是大多数语言所使用的基于共享内存的通信方式)进行协程间通信,并且将消息管道(channel)作为基本的数据类型,使用类型关键字(chan)进行定义,并发操作时线程安全。这点在语言的实现上,也具有革命性。可见,GO语言本身并非简单得没有底线,恰恰他们会将最实用、最有利于解决问题的能力,以最简单、直接的形式提供给用户。

Channel并不仅仅只是用于简单的消息通信,还可以引申出很多非常实用,而实现起来又非常方便的功能。比如,实现TCP连接池、限流等等,而这些在其它语言中实现起来并不轻松,但GO语言可以轻易做到。

img

GO语言作为编译型语言,在数据类型上也支持得非常全面,除了传统的整型、浮点型、字符型、数组、结构等类型外。从实用性上考虑,也对字符串类型、切片类型(可变长数组)、字典类型、复数类型、错误类型、管道类型、甚至任意类型(Interface{})进行了原生支持,并且用起来非常方便。比如字符串、切片类型,操作简便性几乎和python类似。

另外,将错误类型(error)作为基本的数据类型,并且在语言级别不再支持try…catch的用法,这应该算是一个非常大胆的革命性创举,也难怪很多人吐槽GO语言不伦不类。但是跳出传统的观念,GO的开发者认为在编程过程中,要保证程序的健壮性和稳定性,对异常的精确化处理是非常重要的,只有在每一个逻辑处理完成后,明确的告知上层调用,是否有异常,并由上层调用明确、及时的对异常进行处理,这样才可以高程度的保证程序的健壮性和稳定性。虽然这样做会在编程过程中出现大量的对error结果的判断,但是这无疑也增强了开发者对异常处理的警惕度。而实践证明,只要严格按GO推荐的风格编码,想写出不健壮的代码,都很难。当然,前提是你不排斥它,认可它。

img

在语言中支持函数多返回值,并不是什么新鲜事,Python就是其中之一。允许函数返回多个值,在某些场景下,可以有效的简化编程。GO语言推荐的编程风格,是函数返回的最后一个参数为error类型(只要逻辑体中可能出现异常),这样,在语言级别支持多返回值,就很有必要了。

Defer延迟处理机制

img

在GO语言中,提供关键字defer,可以通过该关键字指定需要延迟执行的逻辑体,即在函数体return前或出现panic时执行。这种机制非常适合善后逻辑处理,比如可以尽早避免可能出现的资源泄漏问题。

可以说,defer是继goroutine和channel之后的另一个非常重要、实用的语言特性,对defer的引入,在很大程度上可以简化编程,并且在语言描述上显得更为自然,极大的增强了代码的可读性。

img

Golang作为强类型的编译型语言,灵活性上自然不如解析型语言。比如像PHP,弱类型,并且可以直接对一个字符串变量的内容进行new操作,而在编译型语言中,这显然不太可能。但是,Golang提供了Any类型(interface{})和强大的类型反射(reflect)能力,二者相结合,开发的灵活性上已经很接近解析型语言。在逻辑的动态调用方面,实现起来仍然非常简单。既然如此,那么像PHP这种解析型语言相比于GO,优势在那里呢?就我个人而言,写了近10年的PHP,实现过开发框架、基础类库以及各种公共组件,虽然执行性能不足,但是开发效率有余;而当遇上Golang,这些优势似乎不那么明显了。

img

作为出现在互联网时代的服务端语言,面向用户服务的能力必不可少。GO在语言级别自带HTTP/TCP/UDP高性能服务器,基于协程并发,为业务开发提供最直接有效的能力支持。要在GO语言中实现一个高性能的HTTP Server,只需要几行代码即可完成,非常简单。

img

在GO语言中,有一套标准的工程管理规范,只要按照这个规范进行项目开发,之后的事情(比如包管理、编译等等)都将变得非常的简单。

在GO项目下,存在两个关键目录,一个是src目录,用于存放所有的.go源码文件;一个是bin目录,用于存在编译后的二进制文件。在src目录下,除了main主包所在的目录外,其它所有的目录名称与直接目录下所对应的包名保持对应,否则编译无法通过。这样,GO编译器就可以从main包所在的目录开始,完全使用目录结构和包名来推导工程结构以及构建顺序,避免像C++一样,引入一个额外的Makefile文件。

在GO的编译过程中,我们唯一要做的就是将GO项目路径赋值给一个叫GOPATH的环境变量,让编译器知道将要编译的GO项目所在的位置。然后进入bin目录下,执行go build {主包所在的目录名},即可秒级完成工程编译。编译后的二进制文件,可以推到同类OS上直接运行,没有任何环境依赖。

img

GO语言的编程规范强制集成在语言中,比如明确规定花括号摆放位置,强制要求一行一句,不允许导入没有使用的包,不允许定义没有使用的变量,提供gofmt工具强制格式化代码等等。奇怪的是,这些也引起了很多程序员的不满,有人发表GO语言的XX条罪状,里面就不乏对编程规范的指责。要知道,从工程管理的角度,任何一个开发团队都会对特定语言制定特定的编程规范,特别像Google这样的公司,更是如此。GO的设计者们认为,与其将规范写在文档里,还不如强制集成在语言里,这样更直接,更有利用团队协作和工程管理。

API快速开发框架实践

编程语言是一个工具,它会告诉我们能做什么,而怎么做会更好,同样值得去探讨。这部分会介绍用GO语言实现的一个开发框架,以及几个公共组件。当然,框架和公共组件,其它语言也完全可以实现,而这里所关注的是成本问题。除此之外,抛开GO语言本身不说,我们也希望可以让大家从介绍的几个组件中,得到一些解决问题的思路,那就是通过某种方式,去解决一个面上的问题,而非一味的写代码,最终却只是解决点上的问题。如果你认可这种方式,相信下面的内容也许会影响你之后的项目开发方式,从根本上提高开发效率。

我们为什么选择GO语言

选择GO语言,主要是基于两方面的考虑

  1. 执行性能 缩短API的响应时长,解决批量请求访问超时的问题。在Uwork的业务场景下,一次API批量请求,往往会涉及对另外接口服务的多次调用,而在之前的PHP实现模式下,要做到并行调用是非常困难的,串行处理却不能从根本上提高处理性能。而GO语言不一样,通过协程可以方便的实现API的并行处理,达到处理效率的最大化。 依赖Golang的高性能HTTP Server,提升系统吞吐能力,由PHP的数百级别提升到数千里甚至过万级别。
  2. 开发效率 GO语言使用起来简单、代码描述效率高、编码规范统一、上手快。 通过少量的代码,即可实现框架的标准化,并以统一的规范快速构建API业务逻辑。 能快速的构建各种通用组件和公共类库,进一步提升开发效率,实现特定场景下的功能量产。

img

很多人在学习一门新语言或开启一个新项目时,都会习惯性的是网上找一个认为合适的开源框架来开始自己的项目开发之旅。这样并没有什么不好,但是个人觉得,了解它内部的实现对我们会更有帮助。或许大家已经注意到了,所说的MVC框架,其本质上就是对请求路径进行解析,然后根据请求路径段,路由到相应的控制器(C)上,再由控制器进一步调用数据逻辑(M),拿到数据后,渲染视图(V),返回用户。在整个过程中,核心点在于逻辑的动态调用。

不过,对API框架的实现相对于WEB页面框架的实现,会更简单,因为它并不涉及视图的渲染,只需要将数据结果以协议的方式返回给用户即可。

使用GO语言实现一套完整的MVC开发框架,是非常容易的,集成HTTP Server的同时,整个框架的核心代码不会超过300行,从这里可以实际感受到GO的语言描述效率之高(如果有兴趣,可以参考Uwork开源项目seine)。

也有人说,在GO语言中,就没有框架可言,言外之意是说,引入一个重型的开源框架,必要性并不大,相反还可能把简单的东西复杂化。

img

在实际项目开发过程中,只有高效的开发语言还不够,要想进一步将开发效率扩大化,不断的沉淀公共基础库是必不可少的,以便将通用的基础逻辑进一步抽象和复用。

除此之外,通用组件能力是实现功能量产的根本,对开发效率会是质的提升。组件化的开发模式会帮忙我们将问题的解决能力从一个点上提升到一个面上。以下会重点介绍几个通用组件的实现,有了它们的存在,才能真正的解放程序员的生产力。而这些强有力的公共组件在Golang中实现起来并不复杂。同时,结合Golang的并发处理能力,相比于PHP的版本实现,执行效率也会有质的提升。这是组件能力和语言效率的完美结合。

img

通用列表组件用于所有可能的二维数据源(如MySQL/MongoDB/ES等等)的数据查询场景,从一个面上解决了数据查询问题。在Uwork项目开发中,被大量使用,实现数据查询接口和页面查询列表的量产开发。它以一个JSON配置文件为中心,来实现对通用数据源的查询,并将查询结果以API或页面的形式自动返回给用户。整个过程中几乎没有代码开发,而唯一要做的只是以一种统一的规范编写配置文件(而不是代码),真正实现了对数据查询需求的功能量产。

img

以上是通用列表组件的构建过程,要实现这样一个功能强大的通用组件,是不是会给人一种可望而不可及的感觉?其实并非如此,只要理清了它的整个过程,将构建思路融入Golang中,并不是一件复杂的事情。在我们的项目中,整个组件的实现,只用了不到700行Go代码,就解决了一系列的数据查询问题。另外,通过Golang的并发特性,实现字段处理器的并行执行,进一步的提高了组件的执行效率。可以说,通用列表和Golang的融合,是性能和效率的完美结合。

img

通用表单组件主要用于对数据库的增、删、改场景。该组件在Uwork的项目开发中,也有广泛的应用,与通用列表类似,以一个JSON配置文件为中心,来完成对数据表数据的增、删、改操作。特别是近期完成的部件级SDB管理平台,通过通用表单实现了对整个系统的数据维护,通过高度抽象化,做到了业务的无代码化生产。

img

以上是通用表单的完整构建过程,而对于这个一个组件的实现,我们用了不到1000行的GO代码,就解决了对数据表数据维护整个面上的问题。

img

GO语言本身支持协程并发,协程非常轻量,可以快速启动成千上万个协程工作单元。如果对协程任务的数量控制不当,最后的结果很可能适得其反,从而对外部或本身的服务造成不必要的压力。协程池可以在一定程度上控制执行单元的数量,保证执行的安全性。而在Golang中要实现这样一个协程池,是非常简单的,只需要对channel和goroutine稍加封装,就可以完成,整个构建过程不到80行代码。

img

在API开发过程中,数据校验永远是必不可或缺的一个环节。如果只是简单的数据校验,几行代码也许就完成了,可是当遇上复杂的数据校验时,很可能几百行的代码量也未必能完成,特别是遇到递归类型的数据校验,那简直就是一个噩梦。

数据校验组件,可以通过一种数据模板的配置方式,使用特定的逻辑来完成通用校验,开发者只需要配置好相应的数据模板,进行简单的调用,即可完成整个校验过程。而对于这样一个通用性的数据校验组件,在GO语言中只用了不到700行的代码量就完成了整个构建。

小结

img

在实际项目开发过程中,对开发效率提升最大的,无疑是符合系统业务场景的公共组件能力,这点也正好应证了Rob Pike那句话(Less is lessor Less is more),真正的高效率开发,是配置化的,并不需要写太多的代码,甚至根本就不需要写代码,即可完成逻辑实现,而这种方式对于后期的维护成本也是最优的,因为做到了高度的统一。

GO的语言描述效率毋庸置疑,对上述所有公共组件的实现,均未超过1000行代码,就解决了某个面上的问题。

(以上的部分代码已经在Uwork开源项目seine中提供)

性能评测

压力测试环境说明:

  • 服务运行机器:单台空闲B6,24核CPU、64G内存。
  • PHP API环境:Nginx+PHP-FPM,CI框架。其中Nginx启动10个子进程,每个子进程最大接收1024个连接,php-fpm使用static模式,启动2000个常驻子进程。
  • Golang API环境:使用go1.8.6编译,直接拉起Golang API Server进程(HttpServer),不考虑调优。
  • 客户发起请求测试程序:使用Golang编写,协程并发,运行在独立的另外一台空闲B6上,24核CPU,64G内存,依次在1-2000个不同级别(并发数步长为50)的并发上分别请求20000次。

压力测试结果对比

img

在Golang API框架中,当并发数>50时,处理QPS在6.5w/s附近波动。表现稳定,压力测试过程无报错。

Nginx+php-fpm,只在index.php中输出exit('ok'),当并发数>50时,处理QPS在1w/s附近波动。表现稳定,压力测试过程无报错。

Nginx+php-fpm+CI框架中,逻辑执行到具体业务逻辑点,输出exit('ok'),当并发数>50时,处理QPS在750/s附近波动。并且表现不稳定,压力测试过程中随着并发数的增大,错误量随之增加。

通过压力测试可以发现,Golang和PHP在执行性能上,并没有什么可比性;而使用Golang实现的HTTP API框架,空载时单机性能QPS达到6.5w/s,还是非常令人满意的。

开发过程中需要注意的点

以下是在实际开发过程中遇到的一些问题,仅供参考:

异常处理统一使用error,不要使用panic/recover来模拟throw…catch,最初我是这么做的,后来发现这完全是自以为是的做法。

原生的error过于简单,而在实际的API开发过程中,不同的异常情况需要附带不同的返回码,基于此,有必要对error再进行一层封装。

任何协程逻辑执行体,逻辑最开始处必须要有defer recover()异常恢复处理,否则goroutine内出现的panic,将导致整个进程宕掉,需要避免部分逻辑BUG造成全局影响。

在Golang中,变量(chan类型除外)的操作是非线程安全的,也包括像int这样的基本类型,因此并发操作全局变量时一定要考虑加锁,特别是对map的并发操作。

所有对map键值的获取,都应该判断存在性,最好是对同类操作进行统一封装,避免出现不必要的运行时异常。

定义slice数据类型时,尽量预设长度,避免内部出现不必要的数据重组。


此文已由作者授权腾讯云+社区发布,原文链接:https://cloud.tencent.com/dev...

欢迎大家前往腾讯云+社区或关注云加社区微信公众号(QcloudCommunity),第一时间获取更多海量技术实践干货哦~

查看原文

leeon 发布了文章 · 2018-06-21

正则匹配所有括号中的内容&PHP实现

正则表达式:(?<=【)[^】]+
注:以匹配中文括号中内容为例,如果匹配非中文括号,则需要在括号前增加转义符

PHP实现示例:

<?php
        $strSubject = "abc【111】abc【222】abc【333】abc";
        $strPattern = "/(?<=【)[^】]+/";
        $arrMatches = [];
        preg_match_all($strPattern, $strSubject, $arrMatches);

        var_dump($arrMatches);

执行结果:

~ » php mytest/test_preg.php                                                                                                                                                                  iwaimai@bogon
array(1) {
  [0]=>
  array(3) {
    [0]=>
    string(3) "111"
    [1]=>
    string(3) "222"
    [2]=>
    string(3) "333"
  }
}

解析:
1、(?<=【)
第一个表达式是一个『非获取匹配』,即匹配括号,但并不获取括号;

clipboard.png

2、[^】]+
第二个表达式中[]匹配单个字符,^】代表除了的字符,+是限定符代表匹配前面子表达式一次或多次,即匹配除了的连续多个字符;

组合起来即实现了预期效果~

查看原文

赞 2 收藏 4 评论 0

认证与成就

  • 获得 82 次点赞
  • 获得 2 枚徽章 获得 0 枚金徽章, 获得 0 枚银徽章, 获得 2 枚铜徽章

擅长技能
编辑

开源项目 & 著作
编辑

(゚∀゚ )
暂时没有

注册于 2018-03-14
个人主页被 781 人浏览