文章分类 » 后端技术

PHP数据采集程序初步应用

前言

我们在写一个Web程序的时候,总会想着把自己的网站更美观一些,功能能更多一些,有时候写一些小的工具或者加上小的插件会让我们的站点更加完善。比如万年历功能,比如我们现在要讲的天气预报功能。

当然我们没法利用专业的卫星接受数据,所以我们的天气数据来自现有的天气预报网站。利用天气预报网站提供的数据服务,我们可以写一个PHP爬虫,然后动态采集我们所需要的数据,并且在目标站点更新数据的时候,我们的程序也能做到同步更新,自动地获取数据。

下面就介绍一下如何编写一个简单的PHP数据采集程序(PHP爬虫)。

原理

给定一个网页的URL,使用PHP下载该网页并得到网页内容,然后通过正则表达式将其中我们感兴趣的数据提取出来,然后输出。

具体在这个例子中,我们要抓取的网页是 http://www.weather.com.cn/weather/101050101.shtml,我们感兴趣的是页面中的未来7天天气情况。

实现

0.获取天气预报网页的URL:

$url = "http://www.weather.com.cn/weather/101050101.shtml";
$page_content = file_get_contents($url);

在这里,file_get_contents() 函数会将 $url 指向的网页下载下来,并把网页内容作为一个字符串返回。于是,$page_content 变量中就是我们要抓取的网页的全部HTML代码了。接下来,我们要从其中抽取我们需要的数据。

1.使用正则表达式匹配符合条件的字符串

先输出 $page_content 的值,然后查看网页源代码,观察可知我们需要的字符串可以在

<!--day 1 -->
......
<!--day 7 -->

这两行的注释里找到。

使用正则表达式来取得 <!--day 1--><!--day 7--> 之间的所有内容:

eregi("<!--day 1-->(.*)<!--day 7-->",$page_content,$res);

2.补全页面中图片的路径

由于远程网页中的图片路径都是像 /m2/i/icon_weather/29x20/d01.gif 这样的相对路径,我们需要把这些路径补全,在它们前面加上 http://www.weather.com.cn

$forecast = str_replace("<img src="","<img src="http://www.weather.com.cn",$res[0]);

至此,$forecast 中就是我们需要的天气预报信息了。这个简单的PHP爬虫也就写好了。

源代码

以下是这个抓取天气预报小程序的完整源代码,其中添加了一些测量各部分程序运行时间的代码,并可以通过设置 $start$end 的值来控制抓取哪几天的信息。


$url = "http://www.weather.com.cn/weather/101050101.shtml";
$t1 = time();
    
$page_content = file_get_contents($url);
$t2 = time();

$start = 1;
$end = 3;

if ($end > 7){
    echo "超出预报能力范围,请重新设置!";
}else {
    echo "未来".($end-$start)."天哈尔滨的天气预报("
              .date('Y-m-j')."发布)";

    eregi("--day $start--(.*)--day $end--", $page_content, $res);

    $forecast = str_replace("<img src=\"",
        "<img src=\"http://www.weather.com.cn", $res[0]);
    $t3 = time();

    echo $forecast;

    echo 'First step costs '.($t2 - $t1).' ms.';
    echo 'Last step costs '.($t3 - $t2).' ms.';
}

其他应用例子

同样的思路可以尝试的有:NBA每天的比分牌、今日哈工大的新闻同步、股市行情等等。都能实现同步实时更新。暂时只想到这些,欢迎大家拍砖~

Image Credit: Excavator by Megan Brown from The Noun Project

ORM到底是用还是不用?

ORM即Object/Relation Mapping的简写,一般称作“对象关系映射”,在Web开发中最常出没于和关系型数据库交互的地方。接口、中间件、库、包,你都可以这么称呼它。

我们可以结合PHP和MySQL,从ORM的四个核心理念来认识它:

  • 简单:ORM以最基本的形式建模数据。比如ORM会将MySQL的一张表映射成一个PHP类(模型),表的字段就是这个类的成员变量
  • 精确:ORM使所有的MySQL数据表都按照统一的标准精确地映射成PHP类,使系统在代码层面保持准确统一
  • 易懂:ORM使数据库结构文档化。比如MySQL数据库就被ORM转换为了PHP程序员可以读懂的PHP类,PHP程序员可以只把注意力放在他擅长的PHP层面(当然能够熟练掌握MySQL更好)
  • 易用:ORM的避免了不规范、冗余、风格不统一的SQL语句,可以避免很多人为Bug,方便编码风格的统一和后期维护

接下来再通过一个很基本的例子来说明一下ORM的使用,还以PHP和MySQL为例。

user这个数据模型是再普遍不过的了。假设我们有一张user数据表,结构如图:

在OOP中通常我们需要写一个对应的class User来作为user数据表的数据模型:

// 声明class User
class User{
    $id;
    $name;

    function create(){/*...*/}
    function load($id){/*...*/}
}

// 使用class User
$user = new User();
$user->name = 'fancy';
$user->create();

但是通过ORM,我们可以不用去声明class User,可以直接继承ORM提供的工厂类,比如:

// 直接使用!对于熟悉MVC的亲知道这个意义之所在!
$user = new ORM('user');  // ORM都有自己的规则,这里直接使用了MySQL的表名
$user->name = 'fancy';    // MySQL的表的字段就是$user对象的成员变量
$user->save();            // 掉用ORM提供的接口函数

ORM一般都针对数据模型提供了一下常见的接口函数,比如:create(), update(), save(), load(), find(), find_all(), where()等,也就是讲sql查询全部封装成了编程语言中的函数,通过函数的链式组合生成最终的SQL语句。

所以由这些来看,ORM对于敏捷开发和团队合作开发来说,好处是非常非常大的。这里就罗列一下我想到的ORM显著的优点

  • 大大缩短了程序员的编码时间,减少甚至免除了对Model的编码
  • 良好的数据库操作接口,使编码难度降低,使团队成员的代码变得简洁易读、风格统一
  • 动态的数据表映射,在数据表结构甚至数据库发生改变时,减少了相应的代码修改
  • 减少了程序员对数据库的学习成本
  • 可以很方便地引入数据缓存之类的附加功能

但是ORM并不是一个完美的东西,它同时也有其自身不可避免的缺点

  • 自动化进行关系数据库的映射需要消耗系统性能。其实这里的性能消耗还好啦,一般来说都可以忽略之,特别是有cacha存在的时候
  • 在处理多表联查、where条件复杂之类的查询时,ORM的语法会变得复杂且猥琐
  • 越是功能强大的ORM越是消耗内存,因为一个ORM Object会带有很多成员变量和成员函数。有一次修复bug时就遇见,使用ORM查询的时候会占用12MB的内存,而使用SQL的查询时只占用了1.7MB……

ORM就是这么一个让人又爱又恨的东西。回到我们开始的问题:“ORM到底是用还是不用?”。

Fancy个人的观点是:ORM要用!但关键部位不能用!

因为对于一般的Web应用开发来说,使用ORM确实能带来上述的诸多好处,而且在大部分情况下涉及不到ORM的不好的地方。但是在系统里面有大数据量、大运算量、复杂查询的地方,就不要用ORM。ORM的性能问题将给你带来灾难。在这些地方就可以使用纯SQL或者其他简单轻量的DB Helper库了。在详细了解ORM之后,你就可以扬长避短让ORM发挥其最大效用了。

原文链接: http://www.fancycedar.info/2013/01/orm/

PHP多进程编程初步

羡慕火影忍者里鸣人的影分身么?没错,PHP程序是可以开动影分身的!想完成任务,又觉得一个进程太慢,那么,试试用多进程来搞吧。这篇文章将会介绍一下PHP多进程的基本需求,如何创建多进程以及基本的信号控制,暂时不会告诉你如何进行进程间通信和信息共享。

1. 准备

在动手之前,请确定你用的不是M$ Windows平台(因为我没有Windows)。Linux / BSD / Unix应该都是没问题的。确认好了工作环境以后一起来看看我们需要的PHP模块是否都有。打开终端输入下面的命令:

$ php -m

这个命令检查并打印当前PHP所有开启的扩展,看一下pcntlposix是否在输出的列表中。

1.1. pcntl

如果找不到pcntl,八成是编译的时候没把这个扩展编译进去。如果你和我一样是编译安装的PHP,那么需要重新编译安装PHP。在配置的时候记得加上--enable-pcntl参数即可。

$ cd /path/to/php_source_code_dir 
$ ./configure [some other options] --enable-pcntl
$ make && make install

1.2. posix

这货一般默认就会装上,只要你编译的时候没有加上--disable-posix

2. 预备知识

在继续之前,你还需要对Linux多进程有一点了解。多进程是咋回事呢?这里可跟火影忍者里的影分身稍微有点不同。首先,鸣人从小长到大,比如16岁,咳。有一天他发动了影分身,分出了5个他。显然,这些分身也是16岁的鸣人而不是刚出生啥也不懂就会哭的婴儿(那叫克隆)。然后,不一样的地方来了:分身们变成了独立的人各自去做各自的事,互相之间不再知道其他分身和原身都做了什么(当然不会像动画片里一样积累经验给原身啦)。除非,他们互相之间有交流,不然,只有16岁之前的事情才是他们共同的记忆。

有同学说了,老大你这不坑爹呢么?我又没看过火影忍者!那你去看一遍好了……

最后,预备知识完了,就是大致了解一下主进程开出来的子进程是怎么回事。子进程的代码和主进程是完全一样的,还有一部分一样的东西就是直到发动影分身之前执行的所有内容。具体请参见《操作系统》课程。

3. 影分身之术

所以呢,没有点基础知识怎么能理解卷轴里的内容呢?打开卷轴首先看到了一个单词:fork。

3.1. fork

叉子?叉子是分岔的,一个变多个嘛!差不多就是这个意思。创建子进程就用这个命令。这里需要用到pcntl_fork()函数。(可以先简单看一下PHP手册关于这个函数的介绍。)创建一个PHP脚本:

$pid = pcntl_fork(); // 一旦调用成功,事情就变得有些不同了
if ($pid == -1) {
    die('fork failed');
} else if ($pid == 0) {
} else {
}

pcntl_fork()函数创建一个子进程,子进程和父进程唯一的区别就是PID(进程ID)和PPID(父进程ID)不同。在终端下查看进程用ps命令(问问man看ps怎么用:man ps)。当函数返回值为-1的时候,说明fork失败了。试试在if前面加一句:echo $pid . PHP_EOL;。运行你的脚本,输出可能像下面这样(结果说明子进程和父进程的代码是相同的):

67789 # 这个是父进程打印的
0     # 这个是子进程打印的

pcntl_fork()函数调用成功后,在父进程中会返回子进程的PID,而在子进程中返回的是0。所以,下面直接用if分支来控制父进程和子进程做不同的事。

3.2. 分配任务

然后我们来说说鸣人16岁那次影分身的事儿,给原身和分身分配两个简单的输出任务:

$parentPid = getmypid(); // 这就是传说中16岁之前的记忆
$pid = pcntl_fork(); // 一旦调用成功,事情就变得有些不同了
if ($pid == -1) {
    die('fork failed');
} else if ($pid == 0) {
    $mypid = getmypid(); // 用getmypid()函数获取当前进程的PID
    echo 'I am child process. My PID is ' . $mypid . ' and my father's PID is ' . $parentPid . PHP_EOL;
} else {
    echo 'Oh my god! I am a father now! My child's PID is ' . $pid . ' and mine is ' . $parentPid . PHP_EOL;
}

输出的结果可能是这样:

Oh my god! I am a father now! My child's PID is 68066 and mine is 68065
I am child process. My PID is 68066 and my father's PID is 68065

再强调一下,pcntl_fork()调用成功以后,一个程序变成了两个程序:一个程序得到的$pid变量值是0,它是子进程;另一个程序得到的$pid的值大于0,这个值是子进程的PID,它是父进程。在下面的分支语句中,由于$pid值的不同,运行了不同的代码。再次强调一下:子进程的代码和父进程的是一样的。所以就要通过分支语句给他们分配不同的任务。

3.3. 子进程回收

刚刚有man ps么?一般我习惯用ps aux加上grep命令来查找运行着的后台进程。其中有一列STAT,标识了每个进程的运行状态。这里,我们关注状态Z僵尸(Zombie)。当子进程比父进程先退出,而父进程没对其做任何处理的时候,子进程将会变成僵尸进程。Oops,又跟火影里的影分身不一样了。鸣人的影分身被干死了以后就自动消失了,但是这里的子进程分身死了话还留着一个空壳在,直到父进程回收它。僵尸进程虽然不占什么内存,但是很碍眼,院子里一堆躺着的僵尸怎么都觉得怪怪的。(别忘了它们还占用着PID)

一般来说,在父进程结束之前回收挂掉的子进程就可以了。在pcntl扩展里面有一个pcntl_wait()函数,它会将父进程挂起,直到有一个子进程退出为止。如果有一个子进程变成了僵尸的话,它会立即返回。所有的子进程都要回收,所以多等等也没关系啦!

3.4. 父进程先挂了

如果父进程先挂了怎么办?会发生什么?什么也不会发生,子进程依旧还在运行。但是这个时候,子进程会被交给1号进程,1号进程成为了这些子进程的继父。1号进程会很好地处理这些进程的资源,当它们结束时1号进程会自动回收资源。所以,另一种处理僵尸进程的临时办法是关闭它们的父进程。

4. 信号

一般多进程的事儿讲到上面就完了,可是信号在系统中确实是一个非常重要的东西。信号就是信号灯,点亮一个信号灯,程序就会做出反应。这个你一定用过,比如说在终端下运行某个程序,等了半天也没什么反应,可能你会按 Ctrl+C 来关闭这个程序。实际上,这里就是通过键盘向程序发送了一个中断的信号:SIGINT。有时候进程失去响应了还会执行kill [PID]命令,未加任何其他参数的话,程序会接收到一个SIGTERM信号。程序收到上面两个信号的时候,默认都会结束执行,那么是否有可能改变这种默认行为呢?必须能啊!

4.1. 注册信号

人是活的程序也是活的,只不过程序需要遵循人制定的规则来运行。现在开始给信号重新设定规则,这里用到的函数是pcntl_signal()(继续之前为啥不先查查PHP手册呢?)。下面这段程序将给SIGINT重新定义行为,注意看好:

// 定义一个处理器,接收到SIGINT信号后只输出一行信息
function signalHandler($signal) {
    if ($signal == SIGINT) {
        echo 'signal received' . PHP_EOL;
    }
}
// 信号注册:当接收到SIGINT信号时,调用signalHandler()函数
pcntl_signal(SIGINT, 'signalHandler');
while (true) {
    sleep(1);
    // do something
    pcntl_signal_dispatch(); // 接收到信号时,调用注册的signalHandler()
}

执行一下,随时按下 Ctrl+C 看看会发生什么事。

4.2. 信号分发

说明一下:pcntl_signal()函数仅仅是注册信号和它的处理方法,真正接收到信号并调用其处理方法的是pcntl_signal_dispatch()函数。试试把// do something替换成下面这段代码:

for ($i = 0; $i < 1000000; $i++) {
    echo $i . PHP_EOL;
    usleep(100000);
}

在终端下执行这个脚本,当它不停输出数字的时候尝试按下 Ctrl+C 。看看程序有什么响应?嗯……什么都没有,除了屏幕可能多了个^C以外,程序一直在不停地输出数字。因为程序一直没有执行到pcntl_signal_dispatch(),所以就并没有调用signalHandler(),所以就没有输出signal received

4.3. 版本问题

如果认真看了PHP文档,会发现pcntl_signal_dispatch()这个函数是PHP 5.3以上才支持的,如果你的PHP版本大于5.3,建议使用这个方法调用信号处理器。5.3以下的版本需要在注册信号之前加一句:declare(ticks = 1);表示每执行一条低级指令,就检查一次信号,如果检测到注册的信号,就调用其信号处理器。想想就挺不爽的,干嘛一直都检查?还是在我们指定的地方检查一下就好。

4.4. 感受僵尸进程

现在我们回到子进程回收的问题上(差点忘了= =")。当你的一个子进程挂了(或者说是结束了),但是父进程还在运行中并且可能很长一段时间不会退出。一个僵尸进程从此站起来了!这时,保护伞公司(内核)发现它的地盘里出现了一个僵尸,这个僵尸是谁儿子呢?看一下PPID就知道了。然后,内核给PPID这个进程(也就是僵尸进程的父进程)发送一个信号:SIGCHLD。然后,你知道怎么在父进程中回收这个子进程了么?提示一下,用pcntl_wait()函数。

4.5. 发送信号

希望刚刚有认真man过kill命令。它其实就是向进程发送信号,在PHP中也可以调用posix_kill()函数来达到相同的效果。有了它就可以在父进程中控制其他子进程的运行了。比如在父进程结束之前关闭所有子进程,那么fork的时候在父进程记录所有子进程的PID,父进程结束之前依次给子进程发送结束信号即可。

5. 实践

PHP的多进程跟C还是挺像的,搞明白了以后用其他语言写的话也大同小异差不多都是这么个情况。如果有空的话,尝试写一个小程序,切身体会一下个中滋味:

  1. 16岁的鸣人发送影分身,分出5个分身
  2. 每个分身随机生存10到30秒,每秒都输出点什么
  3. 保证原身能感受到分身的结束,然后开动另一个分身,保证最多有5个分身
  4. 不使用nohup,让原身在终端关闭后依旧能够运行
  5. 把分身数量(5)写进一个配置文件里,当给原身发送信号(可以考虑用SIGUSR1SIGUSR2)时,原身读取配置文件并更新允许的分身最大数量
  6. 如果分身多了,关闭几个;如果少了,再分出来几个

提示

  1. while循环保证进程运行,注意sleep以免100%的CPU占用
  2. 运行进程的终端被关闭时,程序会收到一个SIGHUP信号
  3. 可以用parse_ini_file()函数解析INI配置文件

Shell脚本: 自动检测最快的Ubuntu软件源

每次装好Ubuntu,对于大多数用户来说,首先要做的事就是手动修改/etc/apt/sources.list文件,将里面的官方软件源地址更换为自己学校或者公司的软件源。当我们更换一个工作环境后,可能伴随着又要替换旧的软件源地址。

笔者觉得这样每次手动更改软件源是一件及其麻烦重复的劳动,于是编写了一个自动更新最快软件源的脚本,从此一劳永逸。

原理

最直观的想法就是:对各个软件源进行测速,选出最快的那个,之后将其替换为新的软件源。

那么如何对各个软件源测速呢?有两种方法:

一、用ping命令 测量其平均响应时间 选出响应时间最短的那个 二、用wget命令 测量下载一个文件的总时间 选出耗时最少的那个

那么这两种方法有什么区别呢?我们该用哪个呢?

前者选出的是响应时间最优的,后者选出的是下载速度最快的。我们都知道软件源的作用是供客户端下载更新软件,所以当然是后者的方法更为准确,但笔者最终选择了前者作为测速方案,因为前者的用户体验更好且代码简单易懂。设想,如果我们采用后者,那么需要从每个软件源下载一个文件,并且这个文件不能太小,否则无法区分他们的速度,那么一个显而易见的情况是脚本需要运行较长的时间。

虽然存在某些软件源可能响应时间很短,而下载速度却很慢的情况,但经过笔者的多次实验,发现这样的情况并不常见。

实现

首先测试用户网络状态

利用

local speed=`ping -W1 -c1 www.baidu.com 2> /dev/null | grep "^rtt" |  cut -d '/' -f5`

取出其平均响应时间 如果speed == “” 则说明网络不通,提示用户,且退出程序。 否则,说明网络正常,继续执行。

检测软件源列表文件是否存在

test -f $SOURCES_MIRRORS_FILE

若不存在,提示用户,且退出程序。

对每个软件源地址进行测速

在测速之前清空上次运行的测速结果文件,之后将每个软件源的测速结果(源地址 平均响应时间)写入测速结果文件

对测速结果进行排序

sort -k 2 -n -o $MIRRORS_SPEED_FILE $MIRRORS_SPEED_FILE

对每行记录 按照平均响应时间升序排列

选出最快的软件源

head -n 1 $MIRRORS_SPEED_FILE | cut -d ' ' -f1 `

通过取已排序列表中的第一条,选出最快的软件源

询问用户是否要使用该软件源

用户确认后,先对用户之前的软件源进行备份,然后再替换。

脚本源代码

最新版本:https://github.com/KJlmfe/soEasyUbuntu/tree/master/getfastmirror

#!/bin/bash

#Program:
#    This program gets the fastest ubuntu software sources from SOURCES_MIRRORS_FILE
#    and backup && update /etc/apt/sources.list

#Author:  KJlmfe    www.freepanda.me

#History:
#    2012/12/6    KJlmfe    First release


VERSION="precise"  # precise is code of Ubuntu 12.04 if your ubuntu is not 12.04 please change
TEST_NETCONNECT_HOST="www.baidu.com"
SOURCES_MIRRORS_FILE="sources_mirrors.list"    
MIRRORS_SPEED_FILE="mirrors_speed.list"

function get_ping_speed()    #return average ping $1 time
{
    local speed=`ping -W1 -c1 $1 2> /dev/null | grep "^rtt" |  cut -d '/' -f5`
    echo $speed
}

function test_mirror_speed()    #
{
    rm $MIRRORS_SPEED_FILE 2> /dev/null; touch $MIRRORS_SPEED_FILE
    
     cat $SOURCES_MIRRORS_FILE | while read mirror
    do
        if [ "$mirror" != "" ]; then
            echo -e "Ping $mirror c"
            local mirror_host=`echo $mirror | cut -d '/' -f3`    #change mirror_url to host
    
            local speed=$(get_ping_speed $mirror_host)
    
            if [ "$speed" != "" ]; then
                echo "Time is $speed"
                echo "$mirror $speed" >> $MIRRORS_SPEED_FILE
            else
                echo "Connected failed."
            fi
        fi
    done
}

function get_fast_mirror()
{
    sort -k 2 -n -o $MIRRORS_SPEED_FILE $MIRRORS_SPEED_FILE
    local fast_mirror=`head -n 1 $MIRRORS_SPEED_FILE | cut -d ' ' -f1`
    echo $fast_mirror
}

function backup_sources()
{
    echo -e "Backup your sources.list.n"
    sudo mv /etc/apt/sources.list /etc/apt/sources.list.`date +%F-%R:%S`
}

function update_sources()
{
    local COMP="main restricted universe multiverse"
    local mirror="$1"
    local tmp=$(mktemp) 

    echo "deb $mirror $VERSION $COMP" >> $tmp
    echo "deb $mirror $VERSION-updates $COMP" >> $tmp
    echo "deb $mirror $VERSION-backports $COMP" >> $tmp 
    echo "deb $mirror $VERSION-security $COMP" >> $tmp
    echo "deb $mirror $VERSION-proposed $COMP" >> $tmp

    echo "deb-src $mirror $VERSION $COMP" >> $tmp 
    echo "deb-src $mirror $VERSION-updates $COMP" >> $tmp 
    echo "deb-src $mirror $VERSION-backports $COMP" >> $tmp 
    echo "deb-src $mirror $VERSION-security $COMP" >> $tmp 
    echo "deb-src $mirror $VERSION-proposed $COMP" >> $tmp

    sudo mv "$tmp" /etc/apt/sources.list
    echo -e "Your sources has been updated, and maybe you want to run "sudo apt-get update" now.n";
}

echo -e "nTesting the network connection.nPlease wait...   c"

if [ "$(get_ping_speed $TEST_NETCONNECT_HOST)" == "" ]; then
    echo -e "Network is bad.nPlease check your network."; exit 1
else
    echo -e "Network is good.n"
    test -f $SOURCES_MIRRORS_FILE

    if [ "$?" != "0" ]; then  
        echo -e "$SOURCES_MIRRORS_FILE is not exist.n"; exit 2
    else
        test_mirror_speed
        fast_mirror=$(get_fast_mirror)

        if [ "$fast_mirror" == "" ]; then
            echo -e "Can't find the fastest software sources. Please check your $SOURCES_MIRRORS_FILEn"
            exit 0
        fi

        echo -e "n$fast_mirror is the fastest software sources. Do you want to use it? [y/n] c"    
        read choice

        if [ "$choice" != "y" ]; then
            exit 0
        fi

        backup_sources
        update_sources $fast_mirror
    fi
fi

exit 0 

图片来自: DigiDreamGrafix.com

PHP实现文件下载断点续传

如果我们的网站提供文件下载的服务,那么通常我们都希望下载可以断点续传(Resumable Download),也就是说用户可以暂停下载,并在未来的某个时间从暂停处继续下载,而不必重新下载整个文件。

通常情况下,Web服务器(如Apache)会默认开启对断点续传的支持。因此,如果直接通过Web服务器来提供文件的下载,可以不必做特别的配置,即可享受到断点续传的好处。由于这些文件直接通过Web服务器来提供下载,后端脚本无法对这个下载过程进行控制。这对于仅提供公开、静态文件的网站来说不是问题,但对于需要提供私有、动态文件的网站来说,直接通过Web服务器来提供下载就无法满足需求了。这时,就需要在编写后台脚本程序时,加入对断点续传的支持。

本文将以PHP为例,简要介绍实现文件下载断点续传的方法。

原理

断点续传的原理还是比较直观的。

HTTP协议规定了如何传输某个资源的一部分,而不是全部。比如,有一个文件的大小是1000字节,浏览器可以只请求该文件的前300个字节,或者只请求第500到第1000个字节。通过这种方式,就可以不必在一次请求中传输某个资源的全部内容,而是发起多次请求,每次仅请求其中的一部分内容。等所有这些请求都返回之后,再把得到的内容一块一块的拼接起来得到完整的资源。

实现断点续传就是要利用HTTP协议的上述特性。当用户暂停下载的时候,浏览器会记录已经下载到什么位置,当用户在未来某一时间恢复下载时,就可以从上次暂停的位置继续下载,而不必从头开始。

实现

由于部分传输不是强制的,服务器可以支持也可以不支持,所以,我们需要在程序中告诉浏览器,它请求的资源是否支持部分传输。这可以通过设置HTTP的 Accept-Ranges 响应头信息来实现。PHP代码如下:

header('Accept-Ranges: bytes');

Accept-Ranges: bytes 告诉浏览器,该资源支持以字节为单位的部分传输。这个响应头需要附加在支持部分传输的所有资源上。

当接受到一个请求时,我们需要从浏览器的请求中提取浏览器具体是在请求资源的哪一个部分。这个信息是通过 Range 请求头来传递的。在PHP中,它被存储在$_SERVER['HTTP_RANGE']中。我们需要检查这个变量是否定义了,如果定义了,则使用该值,否则,就将range设为整个资源。

$range = "0-". ($content_length-1);
if(isset($_SERVER['HTTP_RANGE'])){
    $range = $_SERVER['HTTP_RANGE'];
}

接下来,就需要分析 $range 的值,来决定返回资源的哪一部分内容。可能的取值示例:

100-200 // 第100到第200字节
500-    // 第500字节到文件末尾
-1000   // 最后的1000个字节

这里需要注意,得到一个Range之后,你需要对它的取值进行检验,包括:

  1. 开始位置非负
  2. 结束位置需要大于开始位置
  3. 开始位置需要小于文件长度减一 (因为这里的位置索引是从0开始的)
  4. 若结束位置大于文件长度减一,则需要把它的值设置为文件长度减一

如果Range的取值不合法,则需要终止程序并告知浏览器:

header('HTTP/1.1 416 Requested Range Not Satisfiable');

为了保持文章简洁,具体的校验代码这里就不提供了。下面假定你已经校验了Range的取值,并得到了 $start$end 两个变量,分别表示开始位置和结束位置。

接下来要做的就是把文件的对应部分的内容发送给浏览器。不过要注意的是,这里涉及到需要发送多个HTTP响应头信息,具体如下:

header('HTTP/1.1 206 Partial Content');
header('Accept-Ranges: bytes');
header("Content-Range: bytes $start-$end/$filesize");
$length = $end - $start + 1;
header("Content-Length: $length");

/* 输出文件的指定部分 */

这里的$length需要注意一下,它的取值是本次传输的内容的长度,而不是整个文件的长度。另外需要注意的一点是,这里的HTTP状态码是206,不是200。

总结

文件下载的断点续传实际上是利用了HTTP协议中对传输部分文件的支持。而HTTP协议的这一特性不仅可以用于实现断点续传,客户端程序也可以利用它来实现多线程下载。

在实现断点续传的过程中,需要注意正确设置各种HTTP头信息。错误的头信息将导致用户下载到的文件损坏,无法使用。

参考资料

MySQL存储引擎MyISAM与InnoDB的优劣

使用MySQL当然会接触到MySQL的存储引擎,在新建数据库和新建数据表的时候都会看到。

MySQL默认的存储引擎是MyISAM,其他常用的就是InnoDB了。

至于到底用哪种存储引擎比较好?这个问题是没有定论的,需要根据你的需求和环境来衡量。所以对这两种引擎的概念、原理、异同和各自的优劣点有了详细的了解之后,再根据自己的情况选择起来就容易多了。

MyISAM InnoDB
存储结构 每张表被存放在三个文件:
  1. frm-表格定义
  2. MYD(MYData)-数据文件
  3. MYI(MYIndex)-索引文件
所有的表都保存在同一个数据文件中(也可能是多个文件,或者是独立的表空间文件),InnoDB表的大小只受限于操作系统文件的大小,一般为2GB
存储空间 MyISAM可被压缩,存储空间较小 InnoDB的表需要更多的内存和存储,它会在主内存中建立其专用的缓冲池用于高速缓冲数据和索引
可移植性、备份及恢复 由于MyISAM的数据是以文件的形式存储,所以在跨平台的数据转移中会很方便。在备份和恢复时可单独针对某个表进行操作 免费的方案可以是拷贝数据文件、备份 binlog,或者用 mysqldump,在数据量达到几十G的时候就相对痛苦了
事务安全 不支持 每次查询具有原子性 支持 具有事务(commit)、回滚(rollback)和崩溃修复能力(crash recovery capabilities)的事务安全(transaction-safe (ACID compliant))型表
AUTO_INCREMENT MyISAM表可以和其他字段一起建立联合索引 InnoDB中必须包含只有该字段的索引
SELECT MyISAM更优
INSERT InnoDB更优
UPDATE InnoDB更优
DELETE InnoDB更优 它不会重新建立表,而是一行一行的删除
COUNT without WHERE MyISAM更优。因为MyISAM保存了表的具体行数 InnoDB没有保存表的具体行数,需要逐行扫描统计,就很慢了
COUNT with WHERE 一样 一样,InnoDB也会锁表
只支持表锁 支持表锁、行锁 行锁大幅度提高了多用户并发操作的新能。但是InnoDB的行锁,只是在WHERE的主键是有效的,非主键的WHERE都会锁全表的
外键 不支持 支持
FULLTEXT全文索引 支持 不支持 可以通过使用Sphinx从InnoDB中获得全文索引,会慢一点

总的来说,MyISAM和InnoDB各有优劣,各有各的使用环境。

但是InnoDB的设计目标是处理大容量数据库系统,它的CPU利用率是其它基于磁盘的关系数据库引擎所不能比的。

我觉得使用InnoDB可以应对更为复杂的情况,特别是对并发的处理要比MyISAM高效。同时结合memcache也可以缓存SELECT来减少SELECT查询,从而提高整体性能。

用PHP Session和Javascript实现文件上传进度条

Web应用中常需要提供文件上传的功能。典型的场景包括用户头像上传、相册图片上传等。当需要上传的文件比较大的时候,提供一个显示上传进度的进度条就很有必要了。

在PHP 5.4以前,实现这样的进度条并不容易,主要有三种方法:

  1. 使用Flash, Java, ActiveX
  2. 使用PHP的APC扩展
  3. 使用HTML5的File API

第一种方法依赖第三方的浏览器插件,通用性不足,且易带来安全隐患。不过由于Flash的使用比较广泛,因此还是有很多网站使用Flash作为解决方案。

第二种方法的不足在于,它需要安装PHP的APC扩展库,要求用户能够控制服务器端的配置。另外,如果安装APC仅仅是为了实现一个上传进度条,那么显然有点杀鸡用牛刀的意思。

第三种方法应该是最为理想的方法,不需要服务器端的支持,仅在浏览器端使用Javascript即可。但是由于HTML5标准尚未确立,各浏览器厂商的支持也不相同,所以暂时这种方法还难以普及。

PHP 5.4中引入的基于session的上传进度监视功能(session.upload_progress),它提供了一个服务器端的上传进度监视解决方案。升级到PHP 5.4之后,可以不必安装APC扩展,仅使用原生PHP和前端的Javascript即可实现上传进度条。

下面我们就详细介绍一下 PHP 5.4 的这个 session.upload_progress 新特性。

原理介绍

当浏览器向服务器端上传一个文件时,PHP将会把此次文件上传的详细信息(如上传时间、上传进度等)存储在session当中。然后,随着上传的进行,周期性的更新session中的信息。这样,浏览器端就可以使用Ajax周期性的请求一个服务器端脚本,由该脚本返回session中的进度信息;浏览器端的Javascript即可根据这些信息显示/更新进度条了。

那么,文件上传信息具体是如何存储的?我们要如何访问它呢?下面我们来详细说明。

PHP 5.4 中引入了一些配置项(在php.ini中进行设置)

session.upload_progress.enabled = "1"
session.upload_progress.cleanup = "1"
session.upload_progress.prefix = "upload_progress_"
session.upload_progress.name = "PHP_SESSION_UPLOAD_PROGRESS"
session.upload_progress.freq = "1%"
session.upload_progress.min_freq = "1"

其中enabled控制upload_progress功能的开启与否,默认开启;cleanup 则设置当文件上传的请求提交完成后,是否清除session的相关信息,默认开启。

prefixname 两项用来设置进度信息在session中存储的变量名/键名。关于这两项的详细使用见下文。

freqmin_freq 两项用来设置服务器端对进度信息的更新频率。合理的设置这两项可以减轻服务器的负担。

在上传文件的表单中,需要为该次上传设置一个标识符,并在接下来的过程中使用该标识符来引用进度信息。具体的,在上传表单中需要有一个隐藏的input,它的name属性为php.ini中 session.upload_progress.name 的值;它的值为一个由你自己定义的标识符。如下:

<input type="hidden"
    name="<?php echo ini_get('session.upload_progress.name'); ?>"
    value="test" />

接到文件上传的表单后,PHP会在$_SESSION变量中新建键,键名是一个将session.upload_progress.prefix的值与上面你自定义的标识符连接后得到的字符串,可以这样得到:

$name = ini_get('session.upload_progress.name');
$key = ini_get('session.upload_progress.prefix') . $_POST[$name];

$_SESSION[$key]; // 这里就是此次文件上传的进度信息了

$_SESSION[$key]这个变量的结构是这样的:

$_SESSION["upload_progress_test"] = array(
 "start_time" => 1234567890,   // 开始时间
 "content_length" => 57343257, // POST请求的总数据长度
 "bytes_processed" => 453489,  // 已收到的数据长度
 "done" => false,              // 请求是否完成 true表示完成,false未完成

 // 单个文件的信息
 "files" => array(
  0 => array( ... ),
  // 同一请求中可包含多个文件
  1 => array( ... ),
 )
);

这样,我们就可以使用其中的 content_lengthbytes_processed 两项来得到进度百分比。

程序示例

原理介绍完了,下面我们来完整的实现一个基于PHP和Javascript的文件上传进度条。

本示例的代码仓库: Github: pureweber/samples/php-upload-progress

上传表单

首先,来编写我们的上传表单页面 index.php,代码如下:

<form id="upload-form"
    action="upload.php" method="POST" enctype="multipart/form-data"
    style="margin:15px 0" target="hidden_iframe">

        <input type="hidden" name="" value="test" />
        <p><input type="file" name="file1" /></p> 
        <p><input type="submit" value="Upload" /></p>
</form>     

<iframe id="hidden_iframe" name="hidden_iframe" src="about:blank" style="display:none;"></iframe>

<div id="progress" class="progress" style="margin-bottom:15px;display:none;">
        <div class="bar" style="width:0%;"></div>
        <div class="label">0%</div>
</div>

注意表单中的session.upload_progress.name隐藏项,值设置为了test。表单中仅有一个文件上传input,如果需要,你可以添加多个。

这里需要特别注意一下表单的target属性,这里设置指向了一个当前页面中的iframe。这一点很关键,通过设置target属性,让表单提交后的页面显示在iframe中,从而避免当前的页面跳转。因为我们还得在当前页面显示进度条呢。

#progress 这个div是用来显示进度条的。

注意 别忘了在index.php的最开始加上session_start()

处理上传的文件

表单的action指向upload.php,我们在upload.php中处理上传的文件,将它转存到当前目录。这里与通常情况下的上传处理没有区别。

if(is_uploaded_file($_FILES['file1']['tmp_name'])){
        move_uploaded_file($_FILES['file1']['tmp_name'], "./{$_FILES['file1']['name']}");
}
?>

Ajax获取进度信息

这一步是关键,我们需要建立一个 progress.php 文件,用来读取session中的进度信息; 然后我们在 index.php 中增加Javascript代码,向 progress.php 发起Ajax请求,然后根据获得的进度信息更新进度条。

progress.php 的代码如下:

session_start();

$i = ini_get('session.upload_progress.name');

$key = ini_get("session.upload_progress.prefix") . $_GET[$i];

if (!empty($_SESSION[$key])) {
        $current = $_SESSION[$key]["bytes_processed"];
        $total = $_SESSION[$key]["content_length"];
        echo $current < $total ? ceil($current / $total * 100) : 100;
}else{
        echo 100;
}
?>

在这里我们获得$_SESSION变量中的进度信息,然后输出一个进度百分比。

index.php 中,我们将如下代码添加到页面底部 (为简便,这里使用jQuery):

function fetch_progress(){
        $.get('progress.php',{ '' : 'test'}, function(data){
                var progress = parseInt(data);

                $('#progress .label').html(progress + '%');
                $('#progress .bar').css('width', progress + '%');

                if(progress < 100){
                        setTimeout('fetch_progress()', 100);
                }else{
            $('#progress .label').html('完成!');
        }
        }, 'html');
}

$('#upload-form').submit(function(){
        $('#progress').show();
        setTimeout('fetch_progress()', 100);
});

#upload-form被提交时,我们把进度条显示出来,然后反复调用 fetch_progress() 获得进度信息,并更新进度条,直到文件上传完毕,显示'完成!'

Done!

完整代码见: Github: pureweber/samples/php-upload-progress

注意事项

input标签的位置

name为session.upload_progress.name的input标签一定要放在文件input <input type="file" /> 的前面。

取消上传

通过设置 $_SESSION[$key]['cancel_upload'] = true 可取消当次上传。但仅能取消正在上传的文件和尚未开始的文件。已经上传成功的文件不会被删除。

setTimeout vs. setInterval

应该通过 setTimeout() 来调用 fetch_progress(),这样可以确保一次请求返回之后才开始下一次请求。如果使用 setInterval() 则不能保证这一点,有可能导致进度条出现'不进反退'。

参考资料

配图来自: dingatx

Session原理简述

Session存在的意义,估计每个用做web开发的人都是了解的,就为了解决HTTP是个无状态协议所带来的问题,不多说了。这里主要想说的是服务端与客户端是如何利用session进行交互的。

Session工作的大体流程

先看下面这幅流程图:

Session工作流程

当用户第一次访问站点时,PHP会用session_start()函数为用户创建一个session ID,这就是针对这个用户的唯一标识,每一个访问的用户都会得到一个自己独有的session ID,这个session ID会存放在响应头里的cookie中,之后发送给客户端。这样客户端就会拥有一个该站点给他的session ID。

当用户第二次访问该站点时,浏览器会带着本地存放的cookie(里面存有上次得到的session ID)随着请求一起发送到服务器,服务端接到请求后会检测是否有session ID,如果有就会找到响应的session文件,把其中的信息读取出来;如果没有就跟第一次一样再创建个新的。

通常站点的退出功能,实际上就是调用一下session_destroy()函数(也有可能更复杂些),把该用户的session文件删除,再把用户的cookie清除。这样客户端和服务端就算没有联系了。

图中的红框部分就是一次完整的HTTP请求,因为HTTP是无状态的,所以一次请求完成后客户端和服务端就不再有任何关系了,谁也不认识谁。但由于一些需要(如保持登录状态等),必须让服务端和客户端保持联系,session ID就成了这种联系的媒介了。

客户端的工作

通过上面的分析我们可以知道session实际上是依赖与cookie的,当用户访问某一站点时,浏览器会根据用户访问的站点自动搜索可用的cookie,如果有可用的就随着请求一起发送到了服务端。每次接收到服务端的响应时又会更新本地的cookie信息。

当然也可以用GET方式来传递session ID,但不推荐用GET,这样不安全。

服务端的工作

由上面的流程图可以看到,服务端实际上是把产生的一些数据存放在了session文件中,该文件的名字就是”sess“加上session ID,这些文件的存放位置就是phpinfo()查到的session.savepath值。

session-id

由上图我们可以很清楚的看到,服务端和客户端保存着同样的session ID信息,这就是两者保持联系的钥匙。

Session的反面影响

有好处必然也有坏处,session带来的最主要问题就是对性能的影响,可以想象一下,对于一个千万用户级的web站点,如果每个用户都保存session文件,那每次用户访问光寻找相应的session文件就要耗掉不少系统资源的。所以这时就要对session的存储做一些自定义的设定了,如分目录或哈希等等。除了保存到session文件,也可以抛弃PHP自带的session功能,自己实现session,将session信息存放到数据库当中,这样做最好对数据库进行一下缓存的设置了,不然对上千万的数据进行太频繁的检索,也是蛮耗资源的。

Session的清除

客户端和服务端的这种联系必然是需要有时间的规定的,所以需要定期清除session。这个问题就需要在两方面考虑了,一个是清除服务端session文件,一个是清除客户端的cookie信息,因为两者都各保存着一半的信息。

PHP GC进程可以扫描session存放目录清除session文件,但这个进程是特别耗资源的,所以PHP默认是1%的几率在一个sessioin启动时去清理一次过期的sesssion,所以并不是说一个用户session过期了,他对应的session文件就马上被清除,99%的几率是没被清除的。这就需要我们程序员自己动手了。可以在session信息中存放一个过期时间,值为用户最后一次访问的时间。当用户一访问,就用当前时间减去上次访问时间看是否超时,如果超时了就删除相应session文件,并设置cookie的Expires属性为负值,使其客户端的cookie信息也过期,这样浏览器就自动把它删掉了。

PHP的相关Session常用函数

  • session_start() : 启动session,这个没什么说的了。根据session ID打开session文件,如果没有session ID就创建一个ID和对应的session文件
  • $SESSION[]数组 : 存放用户信息的全局数组,session文件中除了存放$SESSION中的数据实际也会存放其他的信息,如id等
  • sessionunset() : 清空$SESSION数组,它是把数组里的值清空了,而$SESSION这个变量还是存在的,和unset($SESSION)是完全不同的概念
  • sessioncommit() : 提交session数据并结束session,把$SESSION数据写到文件里并结束session,实际上当一个页面执行结束后,php会自动执行与这个函数相同的操作。所以这个函数也很少能用上
  • session_destroy() : 注销session,这个就是关闭session并删除掉相应的session文件了。切断了客户端和服务端的联系。

参考资料

消息推送系统——(一)概念与原理

这里我们从系统结构的层面来看消息推送系统(Push Server)的基本原理。

首先需要了解几个基本的概念:

HTTP长连接

翻译自http keep-alive connection和http persistent connection,又叫http connection reuse,网上也有反过来翻译成http long connection。

下面这个图来自wikipedia,讲解了http长连接是在一个TCP连接的基础之上,发送多个HTTP请求以及接收多个HTTP响应,这是为了避免每一次请求都去打开一个新的连接。在HTTP 1.1标准中,所有的请求都认为是长连接。

HTTP长连接图解

在这里的消息推送系统中,HTTP长连接的作用就是向服务器发送请求,然后一直等待服务器的返回数据。这就相当于客户端在“监听”服务器了,可以随时接收来自服务器的消息。OK,lolita is ready to be pushed!

同步与异步

同步:IO操作将导致请求进程阻塞,直到IO操作完成。也就是说客户端在发送请求后,必须得在服务端有回应后才发送下一个请求。

异步:IO操作不导致请求进程阻塞。也就是说客户端在发送请求后,不必等待服务端的回应就可以发送下一个请求。

同步与异步说的是客户端与服务器端之间的一种通信方式。

阻塞与非阻塞

阻塞:服务器端的线程或者进程没有处理完数据的时候,不会返回,线程或者进程回被挂起,不再响应其他请求。

非阻塞:服务器端在没有处理完的时候,会立即返回,不会挂起线程或者进程,可以继续响应其他请求。

阻塞与非阻塞说的是服务器端对请求的处理方式。

在消息推送系统中,客户端+服务器端一起,使用的是异步非阻塞。

消息推送系统(Push Server)的结构和原理

好了,接下来是就是消息推送系统(Push Server)的结构和原理了:

push-server-1

  1. 客户端发出一个http长连接请求,然后等待服务器的响应。这个请求是异步的,所以客户端可以继续工作,比如发起其他ajax请求等等。这个时候客户端就是一个待推倒的小萝莉了。
  2. 服务器接到请求之后,并不立即发送出数据,而是hold住这个connecton。这个处理是非阻塞的,所以服务器可以继续处理其他请求。
  3. 在某个时刻,比如服务器有新数据了,服务器再主动把这个消息推送出去,即通过之前建立好的连接将数据推送给客户端。
  4. 客户端收到返回。这个时候就可以处理数据,然后再次发起新的长连接。

基本原理就是这么简单。

但是在具体实现的时候,还有很多细节要处理,需要一些其他的技术。

下一篇会讲解客户端Javascript的实现,主要内容是HTTP长连接的建立和CORS在不同浏览器下的实现。

参考资料

原文链接

消息推送系统——(零)推倒萝莉之术

当一个初学Web开发的童鞋,产生让服务器“主动”给浏览器客户端发送数据的想法的时候,比他入门稍早的同学会说:

“这是Web!只能由浏览器发起请求,然后得到服务器返回的数据。”

可能接触得更多的童鞋会说:

“除非你用Javascript轮询/心跳,不断请求服务器看有没有新的数据。但是用户多了服务器会受不了。”

都没错。

但主动推送数据非是不可实现的。聪明的先驱们已经找到了更优的解决方案,那就是利用http长连接来实现消息推送系统。

消息推送系统又叫服务器推、Comet技术、Push Server、Server Push等等。它们的含义大同小异,只是从不同场景中得来的不同的称呼而已,具体可以google。我个人比较喜欢Push Server这个名称,很形象——用来向客户端push消息的这么一个server,就叫Push Server。

消息推送系统是一个很有魔力的技术,它实现了攻受的颠倒和权力的反转。服务器不用再傻乎乎地等待着客户端的请求才能发送最新的数据,而是占据了主动,当有新数据的时候,服务器可以立即主动地将数据push给相关的客户端。

想一想,这个时候,你就可以push消息指挥客户端的Javascript做任何事,所有用户的页面都是你的线控木偶了。话说萝莉有三宝,轻音柔体易推倒。Web相比传统软件来说,也算是轻音柔体的萝莉了,而这里的Push Server,也就是推倒萝莉之术了:P 。

推倒萝莉之后,可以做什么呢?当然是很fancy的事情了:

  • 在线好友列表
  • 在线聊天(聊天室、点对点,多人聊天)
  • 即时通知
  • 统计、监控在线用户
  • 实时内容更新

这里要讲的Push Server,是由Javascript + Python(Tornado) + Memcache实现的。但文章中会着重介绍实现原理,而非具体的代码。

Push Server主要包含以下几个方面:

  • http长连接
  • Javascript 的 CORS (The Cross-Origin Resource Sharing)与跨浏览器实现
  • 服务器异步响应
  • 客户端的链接与断开
  • 性能何如

后面的文章会慢慢解来。

原文链接