HTTP 协议中的 Transfer-Encoding

Transfer-Encoding,是一个 HTTP 头部字段,字面意思是「传输编码」。实际上,HTTP 协议中还有另外一个头部与编码有关:Content-Encoding(内容编码)。Content-Encoding 通常用于对实体内容进行压缩编码,目的是优化传输,例如用 gzip 压缩文本文件,能大幅减小体积。内容编码通常是选择性的,例如 jpg / png 这类文件一般不开启,因为图片格式已经是高度压缩过的,再压一遍没什么效果不说还浪费 CPU。

而 Transfer-Encoding 则是用来改变报文格式,它不但不会减少实体内容传输大小,甚至还会使传输变大,那它的作用是什么呢?本文接下来主要就是讲这个。我们先记住一点,Content-Encoding 和 Transfer-Encoding 二者是相辅相成的,对于一个 HTTP 报文,很可能同时进行了内容编码和传输编码。

Persistent Connection

暂时把 Transfer-Encoding 放一边,我们来看 HTTP 协议中另外一个重要概念:Persistent Connection(持久连接,通俗说法长连接)。我们知道 HTTP 运行在 TCP 连接之上,自然也有着跟 TCP 一样的三次握手、慢启动等特性,为了尽可能的提高 HTTP 性能,使用持久连接就显得尤为重要了。为此,HTTP 协议引入了相应的机制。

HTTP/1.0 的持久连接机制是后来才引入的,通过 Connection: keep-alive 这个头部来实现,服务端和客户端都可以使用它告诉对方在发送完数据之后不需要断开 TCP 连接,以备后用。HTTP/1.1 则规定所有连接都必须是持久的,除非显式地在头部加上 Connection: close。所以实际上,HTTP/1.1 中 Connection 这个头部字段已经没有 keep-alive 这个取值了,但由于历史原因,很多 Web Server 和浏览器,还是保留着给 HTTP/1.1 长连接发送 Connection: keep-alive 的习惯。

浏览器重用已经打开的空闲持久连接,可以避开缓慢的三次握手,还可以避免遇上 TCP 慢启动的拥塞适应阶段,听起来十分美妙。为了深入研究持久连接的特性,我决定用 Node 写一个最简单的 Web Server 用于测试,Node 提供了http 模块用于快速创建 HTTP Web Server,但我需要更多的控制,所以用 net 模块创建了一个 TCP Server:

[code]

require(‘net’).createServer(function(sock) {
sock.on(‘data’, function(data) {
sock.write(‘HTTP/1.1 200 OK\r\n’);
sock.write(‘\r\n’);
sock.write(‘hello world!’);
sock.destroy();
});
}).listen(9090, ‘127.0.0.1’);
[/code]

启动服务后,在浏览器里访问 127.0.0.1:9090,正确输出了指定内容,一切正常。去掉 sock.destroy() 这一行,让它变成持久连接,重启服务后再访问一下。这次的结果就有点奇怪了:迟迟看不到输出,通过 Network 查看请求状态,一直是 pending。

这是因为,对于非持久连接,浏览器可以通过连接是否关闭来界定请求或响应实体的边界;而对于持久连接,这种方法显然不奏效。上例中,尽管我已经发送完所有数据,但浏览器并不知道这一点,它无法得知这个打开的连接上是否还会有新数据进来,只能傻傻地等了。

Content-Length

要解决上面这个问题,最容易想到的办法就是计算实体长度,并通过头部告诉对方。这就要用到 Content-Length 了,改造一下上面的例子:

[code]

require(‘net’).createServer(function(sock) {
sock.on(‘data’, function(data) {
sock.write(‘HTTP/1.1 200 OK\r\n’);
sock.write(‘Content-Length: 12\r\n’);
sock.write(‘\r\n’);
sock.write(‘hello world!’);
});
}).listen(9090, ‘127.0.0.1’);
[/code]

可以看到,这次发送完数据并没有关闭 TCP 连接,但浏览器能正常输出内容并结束请求,因为浏览器可以通过Content-Length 的长度信息,判断出响应实体已结束。那如果 Content-Length 和实体实际长度不一致会怎样?有兴趣的同学可以自己试试,通常如果 Content-Length 比实际长度短,会造成内容被截断;如果比实体内容长,会造成 pending。

由于 Content-Length 字段必须真实反映实体长度,但实际应用中,有些时候实体长度并没那么好获得,例如实体来自于网络文件,或者由动态语言生成。这时候要想准确获取长度,只能开一个足够大的 buffer,等内容全部生成好再计算。但这样做一方面需要更大的内存开销,另一方面也会让客户端等更久。

我们在做 WEB 性能优化时,有一个重要的指标叫 TTFB(Time To First Byte),它代表的是从客户端发出请求到收到响应的第一个字节所花费的时间。大部分浏览器自带的 Network 面板都可以看到这个指标,越短的 TTFB 意味着用户可以越早看到页面内容,体验越好。可想而知,服务端为了计算响应实体长度而缓存所有内容,跟更短的 TTFB 理念背道而驰。但在 HTTP 报文中,实体一定要在头部之后,顺序不能颠倒,为此我们需要一个新的机制:不依赖头部的长度信息,也能知道实体的边界。

Transfer-Encoding: chunked

本文主角终于再次出现了,Transfer-Encoding 正是用来解决上面这个问题的。历史上 Transfer-Encoding 可以有多种取值,为此还引入了一个名为 TE 的头部用来协商采用何种传输编码。但是最新的 HTTP 规范里,只定义了一种传输编码:分块编码(chunked)。

分块编码相当简单,在头部加入 Transfer-Encoding: chunked 之后,就代表这个报文采用了分块编码。这时,报文中的实体需要改为用一系列分块来传输。每个分块包含十六进制的长度值和数据,长度值独占一行,长度不包括它结尾的 CRLF(\r\n),也不包括分块数据结尾的 CRLF。最后一个分块长度值必须为 0,对应的分块数据没有内容,表示实体结束。按照这个格式改造下之前的代码:

[code]

require(‘net’).createServer(function(sock) {
sock.on(‘data’, function(data) {
sock.write(‘HTTP/1.1 200 OK\r\n’);
sock.write(‘Transfer-Encoding: chunked\r\n’);
sock.write(‘\r\n’);

sock.write(‘b\r\n’);
sock.write(‘01234567890\r\n’);

sock.write(‘5\r\n’);
sock.write(‘12345\r\n’);

sock.write(‘0\r\n’);
sock.write(‘\r\n’);
});
}).listen(9090, ‘127.0.0.1’);
[/code]

上面这个例子中,我在响应头中表明接下来的实体会采用分块编码,然后输出了 11 字节的分块,接着又输出了 5 字节的分块,最后用一个 0 长度的分块表明数据已经传完了。用浏览器访问这个服务,可以得到正确结果。可以看到,通过这种简单的分块策略,很好的解决了前面提出的问题。

前面说过 Content-Encoding 和 Transfer-Encoding 二者经常会结合来用,其实就是针对 Transfer-Encoding 的分块再进行 Content-Encoding。下面是我用 telnet 请求测试页面得到的响应,就对分块内容进行了 gzip 编码:

[code]
telnet www.lvxinwei.com 80

GET /index.php HTTP/1.1
Host: www.lvxinwei.com
Accept-Encoding: gzip

HTTP/1.1 200 OK
Server: nginx
Date: Sun, 03 May 2015 17:25:23 GMT
Content-Type: text/html
Transfer-Encoding: chunked
Connection: keep-alive
Content-Encoding: gzip
[/code]

用 HTTP 抓包神器 Fiddler 也可以看到类似结果,有兴趣的同学可以自己试一下。

PHP网站速度优化

刚开始这个博客响应时间平均在200ms,不太理想,对此进行了几个优化,目前响应时间在80ms左右。

1.静态资源缓存

在Nginx上配置

[code]

location ~.*\.(jpg|png|jpeg)$ {
expires 30d;
root /var/www/wordpress;
}
location ~.*\.(js|css)?$ {
expires 1d;
root /var/www/wordpress;
}

[/code]

2.使用PHP7 开启opcache缓存,并使用内存缓存opcache字节码

[code]
zend_extension=opcache.so
opcache.enable=1
opcache.enable_cli=1
opcache.file_cache=/dev/shm
[/code]

3.合并图片,减少请求数,等HTTP2实现了,就不用单独搞这个了

MySQL 幻读分析

要理解MySQL幻读问题,就要先搞清楚InnoDB的锁的机制和隔离级别。

MySQL InnoDB事务的隔离级别有四级,默认是“可重复读”(REPEATABLE READ)。
– 未提交读(READ UNCOMMITTED)。另一个事务修改了数据,但尚未提交,而本事务中的SELECT会读到这些未被提交的数据(脏读)。
– 提交读(READ COMMITTED)。本事务读取到的是最新的数据(其他事务提交后的)。问题是,在同一个事务里,前后两次相同的SELECT会读到不同的结果(不重复读)。
– 可重复读(REPEATABLE READ)。在同一个事务里,SELECT的结果是事务开始时时间点的状态,因此,同样的SELECT操作读到的结果会是一致的。但是,会有幻读现象(稍后解释)。
– 串行化(SERIALIZABLE)。读操作会隐式获取共享锁,可以保证不同事务间的互斥。

四个级别逐渐增强,每个级别解决一个问题。

  • 脏读,最容易理解。另一个事务修改了数据,但尚未提交,而本事务中的SELECT会读到这些未被提交的数据。
  • 不重复读。解决了脏读后,会遇到,同一个事务执行过程中,另外一个事务提交了新数据,因此本事务先后两次读到的数据结果会不一致。
  • 幻读。解决了不重复读,保证了同一个事务里,查询的结果都是事务开始时的状态(一致性)。但是,如果另一个事务同时提交了新数据,本事务再更新时,就会“惊奇的”发现了这些新数据,貌似之前读到的数据是“鬼影”一样的幻觉。
    下面开始实验,首先看你数据库的隔离级别
    75F8E42D-4898-487F-B253-34BB58259294
    下面开始重复读实验
    1E1AD02F-E846-48C3-AEED-EC6687FEDAA5
    可以看到,左边的事物,查不到ID为5的行,却插不进去,因为这个事物开始的时候,ID为5是不存在的。这就产生了幻读。
    怎么解决呢?
    3E007E0A-8380-4901-ABBE-58AA99F10BCA
    用了for update,这样右边的插入就卡住了,需要等待左边的提交成功后才行。
    但是这种会锁表,不知道有没有更好的方法。
    参考资料
    http://tech.meituan.com/innodb-lock.html

SwitchyOmega插件的使用

好多小伙伴使用Shadow穿墙后就使用默认的设置,这样很麻烦,尤其是在公司使用内网的情况下,来回切换,我就简单说下如何设置。

首先Shadow 启动后会在本地建立一个1080的端口,用于代理。只要设置socket5代理用这个端口就行了,所以我们大可以关掉软件自带的代理模式,保持清爽,设置如下,取消勾选启用系统代理。

AB5001AC-0E4F-4DB3-9C75-3F92BE7DD055

然后安装Chrome浏览器,安装SwitchyOmega插件 去应用商店下载或在https://github.com/FelisCatus/SwitchyOmega/releases 下载

然后开始设置了。

首先设置一个模式,使用Shadow代理,选择新建情景模式,设置如下

641f6412121e5c4b4a8106d621e897b4

设置好后就可以设置自动代理了,选择自动切换,设置如下:

 

00E69715-7B5A-42A7-9608-F6705BA97E02

Autoproxy 链接为

https://raw.githubusercontent.com/calfzhou/autoproxy-gfwlist/master/gfwlist.txt

然后就可以愉快的上网了。

CAFD1AB5-0422-48CE-BCE8-8EFEC74436AD

遇到不能翻墙的网站,别着急,选择右上角的那个图标,设置如下

C699E952-A991-4F32-9B74-DDEC0EC6AECB

3A01272F-25FF-41E2-B53A-4A01654277BF

然后这个网站以后访问就走代理了。

很方便吧。

Python 装饰器和 functools 模块

什么是装饰器?

在 Python 语言里第一次看到装饰器不免让人想到设计模式中的装饰模式——动态地给一个对象添加一些额外的职责,就增加功能来说,装饰模式比生成子类更为灵活。
好吧,Python 中的装饰器显然和装饰模式毫无关系。那 Python 中的装饰器到底是什么呢?
简而言之,装饰器提供了一种方法,在函数和类定义语句的末尾插入自动运行代码。Python 中有两种装饰器:函数装饰器和类装饰器。

函数装饰器

简单的装饰器例子:

[code]
def decorator(F): # 装饰器函数定义
print "I’m decorator"
return F

@decorator
def foo():
print ‘Hello World!’
# 上面等价于 foo = decorator(foo)

foo()
"""
I’m decorator
Hello World!
"""

decorator(foo)() # 所以这里的输出与 foo() 相同
"""
I’m decorator
Hello World!
"""
[/code]



从上面运行后结果看出,装饰器就是一个能够返回可调用对象(函数)的可调用对象(函数)。
具有封闭作用域的装饰器

[code]
def decorator(func): # 装饰器函数
print ‘in decorator’
def wrapper(*args):
print ‘in decorator wrapper’
wrapper._calls += 1
print "calls = %d" % (wrapper._calls)
func(*args)
wrapper._calls = 0
return wrapper

@decorator
def foo(x, y):
print "x = %d, y = %d" % (x, y)

foo(1, 2) # 第一次调用
"""
in decorator
in decorator wrapper
calls = 1
x = 1, y = 2
"""

foo(2, 3) # 第二次调用
"""
in decorator wrapper
calls = 2
x = 2, y = 3
"""
[/code]

可以看出第一次调用 foo(1, 2) 时,相当于

[code]
foo = decorator(foo)
foo(1, 2)
[/code]

第二次调用 foo(2, 3) 时 foo 已经为 decorator(foo) 的返回值了
再看看一个装饰器类来实现的:

[code]
class decorator: # 一个装饰器类
def __init__(self, func):
print ‘in decorator __init__’
self.func = func
self.calls = 0
def __call__(self, *args):
print ‘in decorator __call__’
self.calls += 1
print "calls = %d" % (self.calls)
self.func(*args)

@decorator
def foo(x, y):
print "x = %d, y = %d" % (x, y)

foo(1, 2) # 第一次调用
"""
in decorator __init__
in decorator __call__
calls = 1
x = 1, y = 2
"""

foo(2, 3) # 第二次调用
"""
in decorator __call__
calls = 2
x = 2, y = 3
"""
[/code]

装饰器参数

[code]
def decorator_wrapper(a, b):
print ‘in decorator_wrapper’
print "a = %d, b = %d" % (a, b)
def decorator(func):
print ‘in decorator’
def wrapper(*args):
print ‘in wrapper’
func(*args)
return wrapper
return decorator

@decorator_wrapper(1, 2) # 这里先回执行 decorator_wrapper(1, 2), 返回 decorator 相当于 @decorator
def foo(word):
print word

foo(‘Hello World!’)
"""
in decorator_wrapper
a = 1, b = 2
in decorator
in wrapper
Hello World!
[/code]

functools 模块

functools 模块中有三个主要的函数 partial(), update_wrapper() 和 wraps(), 下面我们分别来看一下吧。
partial(func[,args][, *keywords])
看源码时发现这个函数不是用 python 写的,而是用 C 写的,但是帮助文档中给出了用 python 实现的代码,如下:

[code]
def partial(func, *args, **keywords):
def newfunc(*fargs, **fkeywords):
newkeywords = keywords.copy()
newkeywords.update(fkeywords)
return func(*(args + fargs), **newkeywords)
newfunc.func = func
newfunc.args = args
newfunc.keywords = keywords
return newfunc
[/code]

OK,可能一下子没看明白,那么继续往下看,看一下是怎么用的。我们知道 python 中有个 int([x[,base]]) 函数,作用是把字符串转换为一个普通的整型。如果要把所有输入的二进制数转为整型,那么就要这样写 int(’11’, base=2)。这样写起来貌似不太方便,那么我们就能用 partial 来实现值传递一个参数就能转换二进制数转为整型的方法。

[code]
from functools import partial
int2 = partial(int, base=2)
print int2(’11’) # 3
print int2(‘101′) # 5
from functools import partial
int2 = partial(int, base=2)
print int2(’11’) # 3
print int2(‘101’) # 5
[/code]

update_wrapper(wrapper, wrapped[, assigned][, updated])
看这个函数的源代码发现,它就是把被封装的函数的 module, name, doc 和 dict 复制到封装的函数中去,源码如下,很简单的几句:

[code]
WRAPPER_ASSIGNMENTS = (‘__module__’, ‘__name__’, ‘__doc__’)
WRAPPER_UPDATES = (‘__dict__’,)
def update_wrapper(wrapper,wrapped, assigned = WRAPPER_ASSIGNMENTS,updated = WRAPPER_UPDATES):
for attr in assigned:
setattr(wrapper, attr, getattr(wrapped, attr))
for attr in updated:
getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
return wrapper
[/code]

具体如何用我们可以往下看一下。

[code]
def wraps(wrapped,assigned = WRAPPER_ASSIGNMENTS,updated = WRAPPER_UPDATES):
return partial(update_wrapper, wrapped=wrapped,assigned=assigned, updated=updated)

[/code]

好,接下来看一下是如何使用的,这才恍然大悟,一直在很多开源项目的代码中看到如下使用。

[code]
from functools import wraps
def my_decorator(f):
@wraps(f)
def wrapper(*args, **kwds):
print ‘Calling decorated function’
return f(*args, **kwds)
return wrapper

@my_decorator
def example():
"""这里是文档注释"""
print ‘Called example function’

example()

# 下面是输出
"""
Calling decorated function
Called example function
"""
print example.__name__ # ‘example’
print example.__doc__ # ‘这里是文档注释’
[/code]
其它参考链接

  • http://www.wklken.me/posts/2013/08/18/python-extra-functools.html
  • http://coolshell.cn/articles/11265.html