博主之前一直用的是 apache，随着网站负荷量增高，感觉 apache 稍微有点力不从心了。随着 nginx 越来越流行，而且其功能强大，博主准备采用 nginx 作为自己的服务器啦。 每当到了环境配置的时候，博主便会去网上各种搜集资料，然而感觉他们讲的都条理不一，有的地方并不符合自己的配置习惯，所以博主习惯自己配置的同时把配置过程总结一下，方便自己，也方便大家。 好，接下来我们就开始我们的环境配置之旅吧。

Nginx

1.更新源

1

sudo apt-get update

2.安装 nginx

1

sudo apt-get install nginx

3.检查是否安装成功

输入 localhost 或者远程地址，若出现 Welcome To Nginx 则证明安装成功。 如果没有看到，可以运行

1

sudo killall apache2

杀掉 apache 进程，因为可能 80 端口被占用了。

4.更改运行目录

默认的 nginx 目录是/usr/share/nginx/html，我们将其修改为/var/www，当然可以根据个人习惯灵活更改。 修改/etc/nginx/sites-available/default 文件

1

root /usr/share/nginx/html;

更改为

1

root /var/www

再将

1

index index.html index.htm;

更改为

1

index index.html index.php index.htm;

重启 nginx

1

sudo service nginx restart

我们在/var/www 目录下新建 index.html 文件，写入一些测试文字。 重新访问 localhost 或者远程地址，可以看到刚才设置的 index.html 文件中的内容，说明目录已经更改成功了。

PHP

安装 PHP 以及相关扩展。

1

sudo apt-get install php5 php5-cgi php5-mysql php5-curl php5-gd php5-idn php-pear php5-imagick php5-imap php5-mcrypt php5-memcache php5-mhash php5-ming php5-pspell php5-recode php5-snmp php5-tidy php5-xmlrpc php5-sqlite php5-xsl

执行上述指令即可。 此时有的小伙伴想要测试运行 PHP 文件了，然而很悲剧地告诉你是不可以的，因为你还没有配置 fastcgi，继续往下看。

MySQL

执行如下命令，安装 MySQL 服务端和客户端。

1

sudo apt-get install mysql-server mysql-client

在安装时可能提示你输入 root 用户的密码，设置即可。

phpMyAdmin

执行如下命令，安装 phpMyAdmin。

1

sudo apt-get install phpmyadmin

创建软连接

1

sudo ln -s /usr/share/phpmyadmin/ /var/www/phpmyadmin

我们将创建一个根目录为/var/www，链接名为 phpmyadmin 的文件，指向/usr/share/phpmyadmin

spawn-fcgi

1.安装 fastcgi

1

sudo apt-get install spawn-fcgi

2.配置 fastcgi

修改 /etc/nginx/fastcgi_params 文件，增加下面一行

1

fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;

修改/etc/php5/cgi/php.ini 文件，将下面一行取消注释

1

cgi.fix_pathinfo=1;

这样 php-cgi 方能正常使用 SCRIPT_FILENAME 这个变量 修改/etc/nginx/sites-available/default 文件，我们之前修改的目录地址是/var/www，将

1
2
3
4
5
6
7
8
9
10
11

#location ~ \.php$ {
#	fastcgi_split_path_info ^(.+\.php)(/.+)$;
#	# NOTE: You should have "cgi.fix_pathinfo = 0;" in php.ini
#
#	# With php5-cgi alone:
#	fastcgi_pass 127.0.0.1:9000;
#	# With php5-fpm:
#	fastcgi_pass unix:/var/run/php5-fpm.sock;
#	fastcgi_index index.php;
#	include fastcgi_params;
#}

修改为

1
2
3
4
5
6
7
8
9
10
11
12

location ~ \.php$ {
#	fastcgi_split_path_info ^(.+\.php)(/.+)$;
#	# NOTE: You should have "cgi.fix_pathinfo = 0;" in php.ini
#
#	# With php5-cgi alone:
	fastcgi_pass 127.0.0.1:9000;
#	# With php5-fpm:
#	fastcgi_pass unix:/var/run/php5-fpm.sock;
	fastcgi_index index.php;
	fastcgi_param SCRIPT_FILENAME /var/www$fastcgi_script_name;
	include fastcgi_params;
}

3.开启 fastcgi 进程

1

sudo /usr/bin/spawn-fcgi -a 127.0.0.1 -p 9000 -C 5 -u www-data -g www-data -f /usr/bin/php5-cgi -P /var/run/fastcgi-php.pid

参数含义如下

-f 指定调用 FastCGI 的进程的执行程序位置，根据系统上所装的 PHP 的情况具体设置 -a 绑定到地址 addr -p 绑定到端口 port -s 绑定到 unix socket 的路径 path -C 指定产生的 FastCGI 的进程数，默认为 5（仅用于 PHP） -P 指定产生的进程的 PID 文件路径 * -u 和-g FastCGI 使用什么身份（-u 用户 -g 用户组）运行，Ubuntu 下可以使用 www-data,其他的根据情况配置，如 nobody、apache 等现在可以在 web 根目录下放个探针或 php 文件测试一下了

运行结果类似如下

1

spawn-fcgi: child spawned successfully: PID: 11775

4.设置开机启动 fastcgi

修改/etc/rc.local 文件，添加下面一行

1

/usr/bin/spawn-fcgi -a 127.0.0.1 -p 9000 -C 5 -u www-data -g www-data -f /usr/bin/php5-cgi -P /var/run/fastcgi-php.pid

修改完之后，重启 nginx

1

sudo service nginx restart

我们可以在/var/www 目录下新建 index.php 文件测试运行，发现已经可以运行 PHP 文件了。

测试运行

所有配置已经完毕，现在我们输入 localhost 和 localhost/phpmyadmin 便可以轻松加愉快地访问了。 如有问题，欢迎交流。

2022 年最新 Python3 网络爬虫教程

大家好，我是崔庆才，由于爬虫技术不断迭代升级，一些旧的教程已经过时、案例已经过期，最前沿的爬虫技术比如异步、JavaScript 逆向、安卓逆向、智能解析、WebAssembly、大规模分布式、Kubernetes 等技术层出不穷，我最近新出了一套最新最全面的 Python3 网络爬虫系列教程。

博主自荐：截止 2022 年，可以将最前沿最全面的爬虫技术都涵盖的教程，如异步、JavaScript 逆向、安卓逆向、智能解析、WebAssembly、大规模分布式、Kubernetes 等，市面上目前就这一套了。

最新教程对旧的爬虫技术内容进行了全面更新，搭建了全新的案例平台进行全面讲解，保证案例稳定有效不过期。

教程请移步：

【2022 版】Python3 网络爬虫学习教程

如下为原文。

大家好，本次为大家带来的是抓取爱问知识人的问题并将问题和答案保存到数据库的方法，涉及的内容包括：

• Urllib 的用法及异常处理
• Beautiful Soup 的简单应用
• MySQLdb 的基础用法
• 正则表达式的简单应用

环境配置

在这之前，我们需要先配置一下环境，我的 Python 的版本为 2.7，需要额外安装的库有两个，一个是 Beautiful Soup，一个是 MySQLdb，在这里附上两个库的下载地址， Beautiful Soup MySQLdb 大家可以下载之后通过如下命令安装

1

python setup.py install

环境配置好之后，我们便可以开心地撸爬虫了

框架思路

首先我们随便找一个分类地址，外语学习 - 爱问知识人，打开之后可以看到一系列的问题列表。 我们在这个页面需要获取的东西有： 总的页码数，每一页的所有问题链接。 接下来我们需要遍历所有的问题，来抓取每一个详情页面，提取问题，问题内容，回答者，回答时间，回答内容。 最后，我们需要把这些内容存储到数据库中。

要点简析

其实大部分内容相信大家会了前面的内容，这里的爬虫思路已经融汇贯通了，这里就说一下一些扩展的功能

1.日志输出

日志输出，我们要输出时间和爬取的状态，比如像下面这样：

[2015-08-10 03:05:20] 113011 号问题存在其他答案 我个人认为应该是樱桃沟很美的 [2015-08-10 03:05:20] 保存到数据库,此问题的 ID 为 113011 [2015-08-10 03:05:20] 当前爬取第 2 的内容,发现一个问题 百度有一个地方，花儿带着芳香，水儿流淌奔腾是什么意思 多多帮忙哦 回答数量 1 [2015-08-10 03:05:19] 保存到数据库,此问题的 ID 为 113010

所以，我们需要引入时间函数，然后写一个获取当前时间的函数

1
2
3
4
5
6
7
8
9

import time

#获取当前时间
def getCurrentTime(self):
    return time.strftime('[%Y-%m-%d %H:%M:%S]',time.localtime(time.time()))

#获取当前时间
def getCurrentDate(self):
    return time.strftime('%Y-%m-%d',time.localtime(time.time()))

以上分别是获取带具体时间和获取日期的函数，在输出时，我们可以在输出语句的前面调用这函数即可。 然后我们需要将缓冲区设置输出到 log 中，在程序的最前面加上这两句即可

1
2

f_handler=open('out.log', 'w')
sys.stdout=f_handler

这样，所有的 print 语句输出的内容就会保存到 out.log 文件中了。

2.页码保存

爬虫爬取过程中可能出现各种各样的错误，这样会导致爬虫的中断，如果我们重新运行爬虫，那么就会导致爬虫从头开始运行了，这样显然是不合理的。所以，我们需要把当前爬取的页面保存下来，比如可以保存到文本中，假如爬虫中断了，重新运行爬虫，读取文本文件的内容，接着爬取即可。 大家可以稍微参考一下函数的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#主函数
def main(self):
    f_handler=open('out.log', 'w')
    sys.stdout=f_handler
    page = open('page.txt', 'r')
    content = page.readline()
    start_page = int(content.strip()) - 1
    page.close()
    print self.getCurrentTime(),"开始页码",start_page
    print self.getCurrentTime(),"爬虫正在启动,开始爬取爱问知识人问题"
    self.total_num = self.getTotalPageNum()
    print self.getCurrentTime(),"获取到目录页面个数",self.total_num,"个"
    if not start_page:
        start_page = self.total_num
    for x in range(1,start_page):
        print self.getCurrentTime(),"正在抓取第",start_page-x+1,"个页面"
        try:
            self.getQuestions(start_page-x+1)
        except urllib2.URLError, e:
            if hasattr(e, "reason"):
                print self.getCurrentTime(),"某总页面内抓取或提取失败,错误原因", e.reason
        except Exception,e:
            print self.getCurrentTime(),"某总页面内抓取或提取失败,错误原因:",e
        if start_page-x+1 < start_page:
            f=open('page.txt','w')
            f.write(str(start_page-x+1))
            print self.getCurrentTime(),"写入新页码",start_page-x+1
            f.close()

这样，不管我们爬虫中途遇到什么错误，妈妈也不会担心了

3.页面处理

页面处理过程中，我们可能遇到各种各样奇葩的 HTML 代码，和上一节一样，我们沿用一个页面处理类即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

import re

#处理页面标签类
class Tool:

    #将超链接广告剔除
    removeADLink = re.compile('<div class="link_layer.*?</div>')
    #去除img标签,1-7位空格,&nbsp;
    removeImg = re.compile('<img.*?>| {1,7}|&nbsp;')
    #删除超链接标签
    removeAddr = re.compile('<a.*?>|</a>')
    #把换行的标签换为\n
    replaceLine = re.compile('<tr>|<div>|</div>|</p>')
    #将表格制表<td>替换为\t
    replaceTD= re.compile('<td>')
    #将换行符或双换行符替换为\n
    replaceBR = re.compile('<br><br>|<br>')
    #将其余标签剔除
    removeExtraTag = re.compile('<.*?>')
    #将多行空行删除
    removeNoneLine = re.compile('\n+')

    def replace(self,x):
        x = re.sub(self.removeADLink,"",x)
        x = re.sub(self.removeImg,"",x)
        x = re.sub(self.removeAddr,"",x)
        x = re.sub(self.replaceLine,"\n",x)
        x = re.sub(self.replaceTD,"\t",x)
        x = re.sub(self.replaceBR,"\n",x)
        x = re.sub(self.removeExtraTag,"",x)
        x = re.sub(self.removeNoneLine,"\n",x)
        #strip()将前后多余内容删除
        return x.strip()

我们可以用一段含有 HTML 代码的文字，经过调用 replace 方法之后，各种冗余的 HTML 代码就会处理好了。 比如我们这么一段代码：

1
2
3
4
5
6
7
8
9
10
11
12

<article class="article-content">
<h2>前言</h2>
<p>最近发现MySQL服务隔三差五就会挂掉，导致我的网站和爬虫都无法正常运作。自己的网站是基于MySQL，在做爬虫存取一些资料的时候也是基于MySQL，数据量一大了，MySQL它就有点受不了了，时不时会崩掉，虽然我自己有网站监控和邮件通知，但是好多时候还是需要我来手动连接我的服务器重新启动一下我的MySQL，这样简直太不友好了，所以，我就觉定自己写个脚本，定时监控它，如果发现它挂掉了就重启它。</p>
<p>好了，闲言碎语不多讲，开始我们的配置之旅。</p>
<p>运行环境：<strong>Ubuntu Linux 14.04</strong></p>
<h2>编写Shell脚本</h2>
<p>首先，我们要编写一个shell脚本，脚本主要执行的逻辑如下：</p>
<p>显示mysqld进程状态，如果判断进程未在运行，那么输出日志到文件，然后启动mysql服务，如果进程在运行，那么不执行任何操作，可以选择性输出监测结果。</p>
<p>可能大家对于shell脚本比较陌生，在这里推荐官方的shell脚本文档来参考一下</p>
<p><a href="http://wiki.ubuntu.org.cn/Shell%E7%BC%96%E7%A8%8B%E5%9F%BA%E7%A1%80" data-original-title="" title="">Ubuntu Shell 编程基础</a></p>
<p>shell脚本的后缀为sh，在任何位置新建一个脚本文件，我选择在 /etc/mysql 目录下新建一个 listen.sh 文件。</p>
<p>执行如下命令：</p>

经过处理后便会变成如下的样子：

1
2
3
4
5
6
7
8
9
10
11

前言
最近发现MySQL服务隔三差五就会挂掉，导致我的网站和爬虫都无法正常运作。自己的网站是基于MySQL，在做爬虫存取一些资料的时候也是基于MySQL，数据量一大了，MySQL它就有点受不了了，时不时会崩掉，虽然我自己有网站监控和邮件通知，但是好多时候还是需要我来手动连接我的服务器重新启动一下我的MySQL，这样简直太不友好了，所以，我就觉定自己写个脚本，定时监控它，如果发现它挂掉了就重启它。
好了，闲言碎语不多讲，开始我们的配置之旅。
运行环境：UbuntuLinux14.04
编写Shell脚本
首先，我们要编写一个shell脚本，脚本主要执行的逻辑如下：
显示mysqld进程状态，如果判断进程未在运行，那么输出日志到文件，然后启动mysql服务，如果进程在运行，那么不执行任何操作，可以选择性输出监测结果。
可能大家对于shell脚本比较陌生，在这里推荐官方的shell脚本文档来参考一下
UbuntuShell编程基础
shell脚本的后缀为sh，在任何位置新建一个脚本文件，我选择在/etc/mysql目录下新建一个listen.sh文件。
执行如下命令：

经过上面的处理，所有乱乱的代码都会被处理好了。

4.保存到数据库

在这里，我们想实现一个通用的方法，就是把存储的一个个内容变成字典的形式，然后执行插入语句的时候，自动构建对应的 sql 语句，插入数据。 比如我们构造如下的字典：

1
2
3
4
5
6
7
8

#构造最佳答案的字典
good_ans_dict = {
        "text": good_ans[0],
        "answerer": good_ans[1],
        "date": good_ans[2],
        "is_good": str(good_ans[3]),
        "question_id": str(insert_id)
        }

构造 sql 语句并插入到数据库的方法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#插入数据
    def insertData(self, table, my_dict):
         try:
             self.db.set_character_set('utf8')
             cols = ', '.join(my_dict.keys())
             values = '"," '.join(my_dict.values())
             sql = "INSERT INTO %s (%s) VALUES (%s)" % (table, cols, '"'+values+'"')
             try:
                 result = self.cur.execute(sql)
                 insert_id = self.db.insert_id()
                 self.db.commit()
                 #判断是否执行成功
                 if result:
                     return insert_id
                 else:
                     return 0
             except MySQLdb.Error,e:
                 #发生错误时回滚
                 self.db.rollback()
                 #主键唯一，无法插入
                 if "key 'PRIMARY'" in e.args[1]:
                     print self.getCurrentTime(),"数据已存在，未插入数据"
                 else:
                     print self.getCurrentTime(),"插入数据失败，原因 %d: %s" % (e.args[0], e.args[1])
         except MySQLdb.Error,e:
             print self.getCurrentTime(),"数据库错误，原因%d: %s" % (e.args[0], e.args[1])

这里我们只需要传入那个字典，便会构建出对应字典键值和键名的 sql 语句，完成插入。

5.PHP 读取日志

我们将运行结果输出到了日志里，那么怎么查看日志呢？很简单，在这里提供两种方法 方法一： PHP 倒序输出所有日志内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<html>
    <head>
        <meta charset="utf-8">
        <meta http-equiv="refresh" content = "5">
    </head>
    <body>
        <?php
            $fp = file("out.log");
            if ($fp) {
                for($i = count($fp) - 1;$i >= 0; $i --)
                echo $fp[$i]."<br>";
            }
        ?>
    </body>
</html>

此方法可以看到所有的输入日志，但是如果日志太大了，那么就会报耗费内存太大，无法输出。为此我们就有了第二种方法，利用 linux 命令，输出后十行内容。 方法二：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<html>
    <head>
        <meta charset="utf-8">
        <meta http-equiv="refresh" content = "5">
    </head>
    <body>
		<?php
			$ph = popen('tail -n 100 out.log','r');
			while($r = fgets($ph)){
				echo $r."<br>";
			}
			pclose($ph);
		?>
	</body>
</html>

上面两种方法都是 5 秒刷新一次网页来查看最新的日志。

源代码放送

好了，闲言碎语不多讲，直接上源码了

1

spider.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187

# -*- coding:utf-8 -*-

import urllib
import urllib2
import re
import time
import types
import page
import mysql
import sys
from bs4 import BeautifulSoup

class Spider:

    #初始化
    def __init__(self):
        self.page_num = 1
        self.total_num = None
        self.page_spider = page.Page()
        self.mysql = mysql.Mysql()

    #获取当前时间
    def getCurrentTime(self):
        return time.strftime('[%Y-%m-%d %H:%M:%S]',time.localtime(time.time()))

    #获取当前时间
    def getCurrentDate(self):
        return time.strftime('%Y-%m-%d',time.localtime(time.time()))

    #通过网页的页码数来构建网页的URL
    def getPageURLByNum(self, page_num):
        page_url = "http://iask.sina.com.cn/c/978-all-" + str(page_num) + ".html"
        return page_url


    #通过传入网页页码来获取网页的HTML
    def getPageByNum(self, page_num):
        request = urllib2.Request(self.getPageURLByNum(page_num))
        try:
            response = urllib2.urlopen(request)
        except urllib2.URLError, e:
            if hasattr(e, "code"):
                print self.getCurrentTime(),"获取页面失败,错误代号", e.code
                return None
            if hasattr(e, "reason"):
                print self.getCurrentTime(),"获取页面失败,原因", e.reason
                return None
        else:
            page =  response.read().decode("utf-8")
            return page

    #获取所有的页码数
    def getTotalPageNum(self):
        print self.getCurrentTime(),"正在获取目录页面个数,请稍候"
        page = self.getPageByNum(1)
        #匹配所有的页码数,\u4e0b\u4e00\u9875是下一页的UTF8编码
        pattern = re.compile(u'<span class="more".*?>.*?<span.*?<a href.*?class="">(.*?)</a>\s*<a.*?\u4e0b\u4e00\u9875</a>', re.S)
        match = re.search(pattern, page)
        if match:
            return match.group(1)
        else:
            print self.getCurrentTime(),"获取总页码失败"

    #分析问题的代码,得到问题的提问者,问题内容,回答个数,提问时间
    def getQuestionInfo(self, question):
        if not type(question) is types.StringType:
            question = str(question)
        #print question
        pattern = re.compile(u'<span.*?question-face.*?>.*?<img.*?alt="(.*?)".*?</span>.*?<a href="(.*?)".*?>(.*?)</a>.*?answer_num.*?>(\d*).*?</span>.*?answer_time.*?>(.*?)</span>', re.S)
        match = re.search(pattern, question)
        if match:
            #获得提问者
            author = match.group(1)
            #问题链接
            href = match.group(2)
            #问题详情
            text = match.group(3)
            #回答个数
            ans_num = match.group(4)
            #回答时间
            time = match.group(5)
            time_pattern = re.compile('\d{4}\-\d{2}\-\d{2}', re.S)
            time_match = re.search(time_pattern, time)
            if not time_match:
                time = self.getCurrentDate()
            return [author, href, text, ans_num, time]
        else:
            return None

    #获取全部问题
    def getQuestions(self, page_num):
        #获得目录页面的HTML
        page = self.getPageByNum(page_num)
        soup = BeautifulSoup(page)
        #分析获得所有问题
        questions = soup.select("div.question_list ul li")
        #遍历每一个问题
        for question in questions:
            #获得问题的详情
            info = self.getQuestionInfo(question)
            if info:
                #得到问题的URL
                url = "http://iask.sina.com.cn/" + info[1]
                #通过URL来获取问题的最佳答案和其他答案
                ans = self.page_spider.getAnswer(url)
                print self.getCurrentTime(),"当前爬取第",page_num,"的内容,发现一个问题",info[2],"回答数量",info[3]
                #构造问题的字典,插入问题
                ques_dict = {
                            "text": info[2],
                            "questioner": info[0],
                            "date": info[4],
                            "ans_num": info[3],
                            "url": url
                            }
                #获得插入的问题的自增ID
                insert_id = self.mysql.insertData("iask_questions",ques_dict)
                #得到最佳答案
                good_ans = ans[0]
                print self.getCurrentTime(),"保存到数据库,此问题的ID为",insert_id
                #如果存在最佳答案,那么就插入
                if good_ans:
                    print self.getCurrentTime(),insert_id,"号问题存在最佳答案",good_ans[0]
                    #构造最佳答案的字典
                    good_ans_dict = {
                            "text": good_ans[0],
                            "answerer": good_ans[1],
                            "date": good_ans[2],
                            "is_good": str(good_ans[3]),
                            "question_id": str(insert_id)
                            }
                    #插入最佳答案
                    if self.mysql.insertData("iask_answers",good_ans_dict):
                        print self.getCurrentTime(),"保存最佳答案成功"
                    else:
                        print self.getCurrentTime(),"保存最佳答案失败"
                #获得其他答案
                other_anses = ans[1]
                #遍历每一个其他答案
                for other_ans in other_anses:
                    #如果答案存在
                    if other_ans:
                        print self.getCurrentTime(),insert_id,"号问题存在其他答案",other_ans[0]
                        #构造其他答案的字典
                        other_ans_dict = {
                                "text": other_ans[0],
                                "answerer": other_ans[1],
                                "date": other_ans[2],
                                "is_good": str(other_ans[3]),
                                "question_id": str(insert_id)
                                }
                        #插入这个答案
                        if self.mysql.insertData("iask_answers",other_ans_dict):
                            print self.getCurrentTime(),"保存其他答案成功"
                        else:
                            print self.getCurrentTime(),"保存其他答案失败"

    #主函数
    def main(self):
        f_handler=open('out.log', 'w')
        sys.stdout=f_handler
        page = open('page.txt', 'r')
        content = page.readline()
        start_page = int(content.strip()) - 1
        page.close()
        print self.getCurrentTime(),"开始页码",start_page
        print self.getCurrentTime(),"爬虫正在启动,开始爬取爱问知识人问题"
        self.total_num = self.getTotalPageNum()
        print self.getCurrentTime(),"获取到目录页面个数",self.total_num,"个"
        if not start_page:
            start_page = self.total_num
        for x in range(1,start_page):
            print self.getCurrentTime(),"正在抓取第",start_page-x+1,"个页面"
            try:
                self.getQuestions(start_page-x+1)
            except urllib2.URLError, e:
                if hasattr(e, "reason"):
                    print self.getCurrentTime(),"某总页面内抓取或提取失败,错误原因", e.reason
            except Exception,e:
                print self.getCurrentTime(),"某总页面内抓取或提取失败,错误原因:",e
            if start_page-x+1 < start_page:
                f=open('page.txt','w')
                f.write(str(start_page-x+1))
                print self.getCurrentTime(),"写入新页码",start_page-x+1
                f.close()

spider = Spider()
spider.main()

1

page.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

# -*- coding:utf-8 -*-
import urllib
import urllib2
import re
import time
import types
import tool
from bs4 import BeautifulSoup

#抓取分析某一问题和答案
class Page:

    def __init__(self):
        self.tool = tool.Tool()

    #获取当前时间
    def getCurrentDate(self):
        return time.strftime('%Y-%m-%d',time.localtime(time.time()))

    #获取当前时间
    def getCurrentTime(self):
        return time.strftime('[%Y-%m-%d %H:%M:%S]',time.localtime(time.time()))

    #通过页面的URL来获取页面的代码
    def getPageByURL(self, url):
        try:
            request = urllib2.Request(url)
            response = urllib2.urlopen(request)
            return response.read().decode("utf-8")
        except urllib2.URLError, e:
            if hasattr(e, "code"):
                print self.getCurrentTime(),"获取问题页面失败,错误代号", e.code
                return None
            if hasattr(e, "reason"):
                print self.getCurrentTime(),"获取问题页面失败,原因", e.reason
                return None


    #传入一个List,返回它的标签里的内容,如果为空返回None
    def getText(self, html):
        if not type(html) is types.StringType:
            html = str(html)
        #提取出<pre>标签里的内容
        pattern = re.compile('<pre.*?>(.*?)</pre>', re.S)
        match = re.search(pattern, html)
        #如果匹配成功
        if match:
            return match.group(1)
        else:
            return None

    #传入最佳答案的HTML,分析出回答者和回答时间
    def getGoodAnswerInfo(self, html):
        pattern = re.compile('"answer_tip.*?<a.*?>(.*?)</a>.*?<span class="time.*?>.*?\|(.*?)</span>', re.S)
        match = re.search(pattern, html)
        #如果匹配,返回回答者和回答时间
        if match:
            time = match.group(2)
            time_pattern = re.compile('\d{2}\-\d{2}\-\d{2}', re.S)
            time_match = re.search(time_pattern, time)
            if not time_match:
                time = self.getCurrentDate()
            else:
                time = "20"+time
            return [match.group(1),time]
        else:
            return [None,None]

    #获得最佳答案
    def getGoodAnswer(self, page):
        soup = BeautifulSoup(page)
        text = soup.select("div.good_point div.answer_text pre")
        if len(text) > 0:
            #获得最佳答案的内容
            ansText = self.getText(str(text[0]))
            ansText = self.tool.replace(ansText)
            #获得最佳答案的回答者信息
            info = soup.select("div.good_point div.answer_tip")
            ansInfo = self.getGoodAnswerInfo(str(info[0]))
            #将三者组合成一个List
            answer = [ansText, ansInfo[0], ansInfo[1],1]
            return answer
        else:
            #如果不存在最佳答案,那么就返回空
            return None

    #传入回答者HTML,分析出回答者,回答时间
    def getOtherAnswerInfo(self, html):
        if not type(html) is types.StringType:
            html = str(html)
        pattern = re.compile('"author_name.*?>(.*?)</a>.*?answer_t">(.*?)</span>', re.S)
        match = re.search(pattern, html)
        #获得每一个回答的回答者信息和回答时间
        if match:
            time = match.group(2)
            time_pattern = re.compile('\d{2}\-\d{2}\-\d{2}', re.S)
            time_match = re.search(time_pattern, time)
            if not time_match:
                time = self.getCurrentDate()
            else:
                time = "20"+time
            return [match.group(1),time]
        else:
            return [None,None]


    #获得其他答案
    def getOtherAnswers(self, page):
        soup = BeautifulSoup(page)
        results =  soup.select("div.question_box li.clearfix .answer_info")
        #所有答案,包含好多个List,每个List包含了回答内容,回答者,回答时间
        answers = []
        for result in results:
            #获得回答内容
            ansSoup = BeautifulSoup(str(result))
            text = ansSoup.select(".answer_txt span pre")
            ansText = self.getText(str(text[0]))
            ansText = self.tool.replace(ansText)
            #获得回答者和回答时间
            info = ansSoup.select(".answer_tj")
            ansInfo = self.getOtherAnswerInfo(info[0])
            #将三者组合成一个List
            answer = [ansText, ansInfo[0], ansInfo[1],0]
            #加入到answers
            answers.append(answer)
        return answers

     #主函数
    def getAnswer(self, url):
        if not url:
            url = "http://iask.sina.com.cn/b/gQiuSNCMV.html"
        page = self.getPageByURL(url)
        good_ans = self.getGoodAnswer(page)
        other_ans = self.getOtherAnswers(page)
        return [good_ans,other_ans]


page = Page()
page.getAnswer(None)

1

tool.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#-*- coding:utf-8 -*-
import re

#处理页面标签类
class Tool:

    #将超链接广告剔除
    removeADLink = re.compile('<div class="link_layer.*?</div>')
    #去除img标签,1-7位空格,&nbsp;
    removeImg = re.compile('<img.*?>| {1,7}|&nbsp;')
    #删除超链接标签
    removeAddr = re.compile('<a.*?>|</a>')
    #把换行的标签换为\n
    replaceLine = re.compile('<tr>|<div>|</div>|</p>')
    #将表格制表<td>替换为\t
    replaceTD= re.compile('<td>')
    #将换行符或双换行符替换为\n
    replaceBR = re.compile('<br><br>|<br>')
    #将其余标签剔除
    removeExtraTag = re.compile('<.*?>')
    #将多行空行删除
    removeNoneLine = re.compile('\n+')

    def replace(self,x):
        x = re.sub(self.removeADLink,"",x)
        x = re.sub(self.removeImg,"",x)
        x = re.sub(self.removeAddr,"",x)
        x = re.sub(self.replaceLine,"\n",x)
        x = re.sub(self.replaceTD,"\t",x)
        x = re.sub(self.replaceBR,"\n",x)
        x = re.sub(self.removeExtraTag,"",x)
        x = re.sub(self.removeNoneLine,"\n",x)
        #strip()将前后多余内容删除
        return x.strip()

1

mysql.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

# -*- coding:utf-8 -*-


import MySQLdb
import time

class Mysql:

    #获取当前时间
    def getCurrentTime(self):
        return time.strftime('[%Y-%m-%d %H:%M:%S]',time.localtime(time.time()))

    #数据库初始化
    def __init__(self):
        try:
            self.db = MySQLdb.connect('ip','username','password','db_name')
            self.cur = self.db.cursor()
        except MySQLdb.Error,e:
             print self.getCurrentTime(),"连接数据库错误，原因%d: %s" % (e.args[0], e.args[1])

    #插入数据
    def insertData(self, table, my_dict):
         try:
             self.db.set_character_set('utf8')
             cols = ', '.join(my_dict.keys())
             values = '"," '.join(my_dict.values())
             sql = "INSERT INTO %s (%s) VALUES (%s)" % (table, cols, '"'+values+'"')
             try:
                 result = self.cur.execute(sql)
                 insert_id = self.db.insert_id()
                 self.db.commit()
                 #判断是否执行成功
                 if result:
                     return insert_id
                 else:
                     return 0
             except MySQLdb.Error,e:
                 #发生错误时回滚
                 self.db.rollback()
                 #主键唯一，无法插入
                 if "key 'PRIMARY'" in e.args[1]:
                     print self.getCurrentTime(),"数据已存在，未插入数据"
                 else:
                     print self.getCurrentTime(),"插入数据失败，原因 %d: %s" % (e.args[0], e.args[1])
         except MySQLdb.Error,e:
             print self.getCurrentTime(),"数据库错误，原因%d: %s" % (e.args[0], e.args[1])

数据库建表 SQL 如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

CREATE TABLE IF NOT EXISTS `iask_answers` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '自增ID',
  `text` text NOT NULL COMMENT '回答内容',
  `question_id` int(18) NOT NULL COMMENT '问题ID',
  `answerer` varchar(255) NOT NULL COMMENT '回答者',
  `date` varchar(255) NOT NULL COMMENT '回答时间',
  `is_good` int(11) NOT NULL COMMENT '是否是最佳答案',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8;

CREATE TABLE IF NOT EXISTS `iask_questions` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '问题ID',
  `text` text NOT NULL COMMENT '问题内容',
  `questioner` varchar(255) NOT NULL COMMENT '提问者',
  `date` date NOT NULL COMMENT '提问时间',
  `ans_num` int(11) NOT NULL COMMENT '回答数量',
  `url` varchar(255) NOT NULL COMMENT '问题链接',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8;

运行的时候执行如下命令即可

1

nohup python spider.py &

代码写的不好，仅供大家学习参考使用，如有问题，欢迎留言交流。

运行结果查看

我们把 PHP 文件和 log 文件放在同一目录下，运行 PHP 文件，便可以看到如下的内容： 小伙伴们赶快试一下吧。

前言

最近发现 MySQL 服务隔三差五就会挂掉，导致我的网站和爬虫都无法正常运作。自己的网站是基于 MySQL，在做爬虫存取一些资料的时候也是基于 MySQL，数据量一大了，MySQL 它就有点受不了了，时不时会崩掉，虽然我自己有网站监控和邮件通知，但是好多时候还是需要我来手动连接我的服务器重新启动一下我的 MySQL，这样简直太不友好了，所以，我就觉定自己写个脚本，定时监控它，如果发现它挂掉了就重启它。 好了，闲言碎语不多讲，开始我们的配置之旅。 运行环境：Ubuntu Linux 14.04

编写 Shell 脚本

首先，我们要编写一个 shell 脚本，脚本主要执行的逻辑如下： 显示 mysqld 进程状态，如果判断进程未在运行，那么输出日志到文件，然后启动 mysql 服务，如果进程在运行，那么不执行任何操作，可以选择性输出监测结果。 可能大家对于 shell 脚本比较陌生，在这里推荐官方的 shell 脚本文档来参考一下 Ubuntu Shell 编程基础 shell 脚本的后缀为 sh，在任何位置新建一个脚本文件，我选择在 /etc/mysql 目录下新建一个 listen.sh 文件。 执行如下命令：

1
2
3

cd /etc/mysql
touch listen.sh
vi listen.sh

进入到 vi 中，我们添加如下脚本内容：

1
2
3
4
5
6
7
8
9

#!/bin/bash
pgrep mysqld &> /dev/null
if [ $? -gt 0 ]
then
echo "`date` mysql is stop"
service mysql start
else
echo "`date` mysql running"
fi

其中 pgrep mysqld 是监测 mysqld 服务的运行状态，&> /dev/null 是将其结果输出到空文件，也就是不保存输出信息 $? 是拿到上一条命令的运行结果，-gt 0 是判断是否大于 0，后面则是输出时间到日志文件，然后启动 mysql，否则不启动 mysql 保存好了，那么我们执行如下的命令，来测试一下。 贴心的命令文字版本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

root@iZ28uogb3laZ:/etc/mysql# vi listen.sh
root@iZ28uogb3laZ:/etc/mysql# pgrep mysqld
3359
root@iZ28uogb3laZ:/etc/mysql# chmod 777 listen.sh
root@iZ28uogb3laZ:/etc/mysql# ./listen.sh
Sun Aug 16 16:44:58 CST 2015 mysql running
root@iZ28uogb3laZ:/etc/mysql# sudo service mysql stop
mysql stop/waiting
root@iZ28uogb3laZ:/etc/mysql# ./listen.sh
Sun Aug 16 16:45:17 CST 2015 mysql is stop
mysql start/running, process 4084
root@iZ28uogb3laZ:/etc/mysql# ./listen.sh
Sun Aug 16 16:45:24 CST 2015 mysql running
root@iZ28uogb3laZ:/etc/mysql#

嗯，编辑完了.sh 文件之后，我们首先要对其进行授权，增加可执行的权限。

1

sudo chmod 777 listen.sh

然后运行脚本测试一下，显示 mysql 正在运行。把 mysql 关掉，运行脚本，便会检测到 mysql 已关闭，然后重新启动了 mysql，再次运行，便会发现 mysql 正常运行了。 注：这里我比较纳闷 shell 脚本中 pgrep mysqld 的返回结果是什么。为什么它大于 0 便代表 mysql 服务挂掉了呢？感觉逻辑有点是相反的，不过实测可用有效。如果大家明白为什么，非常希望您可以给我一个解释。

修改日志输出

好，接下来我们把输出的内容保存到日志里。修改脚本文件如下

1
2
3
4
5
6
7
8
9

#!/bin/bash
pgrep mysqld &> /dev/null
if [ $? -gt 0 ]
then
echo "`date` mysql is stop" >> /var/log/mysql_listen.log
service mysql start
else
echo "`date` mysql running" >> /var/log/mysql_listen.log
fi

这样，每执行一次脚本，输出结果都会被保存到 /var/log/mysql_listen.log 中了。

添加定时任务

好了，脚本可以顺利执行了，那么我们就需要定时调用一下这个脚本来运行了，我们需要用到 cron。 首先我们需要编辑一下 corn 调度表格，命令如下：

1

crontab -e

如果你是第一次编辑这个，他会让你选择文件打开方式，随便选一个数字就好了。 比如我们用 GNU 打开的，我们就在它的最后一行添加下面的一句话即可。 、 文字版本：

1

*/5 * * * * /etc/mysql/mysql_listen.sh

/5 代表五分钟执行一次，后面的四个点依次代表了，小时，日，月，星期。如果想要时间长一些，比如一小时调度一次，那就设置一下后面第一个*就好了。 好，保存一下，重启 cron 服务。

1

service cron restart

嗯，调度任务已经添加进去了，这样，每五分钟系统就会调用一下刚才写的那个脚本。 过一段时间，我们来看一下运行效果，嗯，监控跑的很顺利呐。 文字版本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Sun Aug 16 15:39:12 CST 2015 mysql running
Sun Aug 16 15:40:01 CST 2015 mysql running
Sun Aug 16 15:45:02 CST 2015 mysql running
Sun Aug 16 15:50:01 CST 2015 mysql running
Sun Aug 16 15:55:01 CST 2015 mysql running
Sun Aug 16 16:00:01 CST 2015 mysql running
Sun Aug 16 16:05:01 CST 2015 mysql running
Sun Aug 16 16:10:01 CST 2015 mysql running
Sun Aug 16 16:15:01 CST 2015 mysql running
Sun Aug 16 16:20:01 CST 2015 mysql running
Sun Aug 16 16:25:01 CST 2015 mysql running
Sun Aug 16 16:30:01 CST 2015 mysql running
Sun Aug 16 16:35:01 CST 2015 mysql running
Sun Aug 16 16:40:01 CST 2015 mysql running
Sun Aug 16 16:51:04 CST 2015 mysql running

哈哈，是不是五分钟监测了一次呢？大功告成。

后记

这样，我们就实现了五分钟定时检测 MySQL 进程服务，妈妈再也不用担心我的网站会宕掉啦。 如有问题，欢迎留言交流，谢谢啦。

最近在准备C语言的上级考试，之前对C接触不多，在练习过程中把一些小知识点记录下来。

1.字符串的截取

利用strncpy函数，传入三个参数，分别为目标字符串，起始位置，长度。 例如将日期字符串转化为数字，如20120112

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main() {

    char date1[20],date2[20];
    scanf("%s",&date1);
    scanf("%s",&date2);
    char temp[4];
    int year1 = atoi(strncpy(temp,date1,4));
    int year2 = atoi(strncpy(temp,date2,4));
    printf("year1:%d\n",year1);
    printf("year2:%d\n",year2);
    char temp2[2];
    int month1 = atoi(strncpy(temp2,date1+4,2));
    int month2 = atoi(strncpy(temp2,date2+4,2));
    printf("month1:%d\n",month1);
    printf("month2:%d\n",month2);
    int day1 = atoi(strncpy(temp2,date1+6,2));
    int day2 = atoi(strncpy(temp2,date2+6,2));
    printf("day1:%d\n",day1);
    printf("day2:%d\n",day2);
    return 0;

}

以上便实现了输入一个日期然后对其进行分割的操作。

2.二维数组的动态声明

利用malloc可以实现数组的动态声明

1
2
3
4
5
6
7
8
9

int **a;
    a = (int **)malloc(2*sizeof(int *));
    int i,j;
    for (i = 0; i < 2; i ++) {
        a[i] = (int *)malloc(3*sizeof(int));
        for (j = 0; j < 3; j++) {
            scanf("%d",&a[i][j]);
        }
    }

以上便实现了动态数组的分配，利用scanf为数组赋值

3.二维数组的声明和初始化

头文件

1

#include <memory.h>

初始化和测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14

int result[2][2];
    for (i = 0; i < 2; i ++) {
        for (j = 0; j < 2; j++) {
            printf("%d ",result[i][j]);
        }
        printf("\n");
    }
    memset(result,0,sizeof(int)*4);
    for (i = 0; i < 2; i ++) {
        for (j = 0; j < 2; j++) {
            printf("%d ",result[i][j]);
        }
        printf("\n");
    }

结果

1
2
3
4

4196944 0 
4195696 0 
0 0 
0 0

上述是数组的非动态声明

4.快速排序

假设要排序的数组是A[1]……A[N]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。一趟快速排序的算法是： 1）设置两个变量I、J，排序开始的时候 I=0，J=N-1； 2）以第一个数组元素作为关键数据，赋值给X，即X=A[0]； 3）从J开始向前搜索，即由后开始向前搜索，找到第一个小于X的值，两者交换； 4）从I开始向后搜索，即由前开始向后搜索，找到第一个大于X的值，两者交换； 5）重复第3、4步，直到I=J； 例如：待排序的数组A的值分别是：（初始关键数据X：=49） A[0] A[1] A[2] A[3] A[4] A[5] A[6] 49 38 65 97 76 13 27 进行第一次交换后： 27 38 65 97 76 13 49 ( 按照算法的第三步从后面开始找 ） 进行第二次交换后： 27 38 49 97 76 13 65 ( 按照算法的第四步从前面开始找>X的值，65>49,两者交换，此时I=3 ) 进行第三次交换后： 27 38 13 97 76 49 65 ( 按照算法的第五步将又一次执行算法的第三步从后开始找） 进行第四次交换后： 27 38 13 49 76 97 65 ( 按照算法的第四步从前面开始找大于X的值，97>49,两者交换，此时J=4 ) 此时再执行第三不的时候就发现I=J，从而结束一躺快速排序，那么经过一躺快速排序之后： 27 38 13 49 76 97 65 即所有大于49的数全部在49的后面，所有小于49的数全部在49的前面。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#include <stdio.h>

void quiksort(int a[],int low,int high)
{
    int i = low;
    int j = high;  
    int temp = a[i]; 
  
    if( low < high)
    {          
        while(i < j) 
        {
            while((a[j] >= temp) && (i < j))
            { 
                j--; 
            }
            a[i] = a[j];
            while((a[i] <= temp) && (i < j))
            {
                i++; 
            }  
            a[j]= a[i];
        }
        a[i] = temp;
        quiksort(a,low,i-1);
        quiksort(a,j+1,high);
    }
    else
    {
        return;
    }
}
 
int main()
{
    int arr[5] = {23,1,21,4,19};
    quiksort(arr,0,4);
    int i;
    for(i=0;i<5;i++)
    {
        printf("%d ",arr[i]);
    }
    printf("\n");
    return 0;
}

快速排序代码如上

5.字符串拷贝

小例子如下

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(){
	char str[20] = "hello";
	char *a = "world";
	strcpy(str,a);
	printf("%s",str);
	printf("\n");
	system("pause");
	return 0;
}

运行结果：world，即把后者完全覆盖前者。

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(){
	char *str = new char[6];
	char *a = "world";
	strcpy(str,a);
	printf("%s", str);
	printf("\n");
	system("pause");
	return 0;
}

运行结果一致 某一长度的字符串截取

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(){
	char *str = new char[6];
	char *a = "world";
	strncpy(str,a+1,5);
	printf("%s", str);
	printf("\n");
	system("pause");
	return 0;
}

运行结果：orld

6.字符串的拼接

小例子如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(){
	char str[20] = "hello ";
	char *a = "world";
	char *x = strcat(str,a);
	printf("%s\n", x);
	printf("%s\n", x);
	printf("\n");
	system("pause");
	return 0;
}

运行结果： hello world hello world 此函数既返回结果，又将目标字符串赋值

7.字符串查找匹配

例子如下

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(){
	char str[20] = "hello ";
	char *x = strchr(str,'e');
	printf("%d\n", x - str);
	printf("%s\n",x);
	printf("\n");
	system("pause");
	return 0;
}

运行结果： 1 ello

8.字符串比较

例子如下

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(){
	char str[20] = "hello ";
	char str2[20] = "hello2";
	int x = strcmp(str, str2);
	printf("%d\n",x);
	printf("\n");
	system("pause");
	return 0;
}

运行结果-1 忽略大小写

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(){
	char str[20] = "hello";
	char str2[20] = "Hello";
	int x = stricmp(str, str2);
	printf("%d\n",x);
	printf("\n");
	system("pause");
	return 0;
}

运行结果0

9.字符串分割

示例如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main() 
{
      char test1[] = "feng,ke,wei";  
	  char x[3][30];
      char *p;  
      p = strtok(test1, ",");
	  int count = 0;
      while (p) {   
		printf("%s\n", p);   
		strcpy(x[count],p);
		count++;
		p = strtok(NULL, ",");     
      }    
	  for (int i = 0; i<count; i ++) {
		printf("%s ", x[i]);
	  }
	  system("pause");
      return 0;
 }

运行结果 feng ke wei feng ke wei

10.格式化输出几位小数

例如

1

printf("%.5f",18.223);

则是输出5位小数 又如

1

printf("%5.1f",1.2345);

则是控制总位数为5，小数点后为1位，不够的在前面补空格

本节任务

本次我们需要完成的任务是 完成两台主机通过中间主机的数据通信（网络层）

• 增加基于IP地址的转发功能
• 增加网络层封装

其实最主要的就是基于IP地址的转发功能，网络层的封装其实我们在初级功能中就已经做好了。

原理

首先，实验的思路是A通过中间主机B向C发送数据。那么B则作为一个路由器，B要监听两个网卡，一个网卡发来的数据通过另一个网卡发出去。 示意图如下： A————->B1===B2——————>C 从图上可以看出，B主机的两个网卡数据互通，A和B1则处于一个局域网内，B2和C处于另一个局域网内。 就比如这样，现在室友A在用有线上网，我的电脑B也在用有线上网，我们的有线处在同一局域网，我的电脑B同时散着一个无线网，我的手机C又连接到了这个无线上。 那么要实现A到C的数据传送，即模拟室友A要发送数据到我的手机C，那么流程则是这样的： 室友A在有线局域网发送数据到我的网卡B1，B1将数据通过网卡B2转发到无线局域网，通过无线局域网到达我的手机C。 A的发送要构建一个帧，目的MAC地址为B1,目的IP为C。B则要开启两个网卡，B1监听接收数据，B2网卡则要用ARP协议扫描所在无线局域网内的IP和MAC,B获取到了A发来的帧之后，解析它的IP地址和MAC地址，匹配刚才扫描得到的IP和MAC对应表，将源MAC换成B2网卡MAC，目的MAC换成C的MAC，IP不变，数据data不变。构建新帧之后发送出去。 好啦，思路大体就是这样。

实战

需要三个程序，一个是发送，一个路由，一个接收。所以一共三个程序要同时运行起来执行。 以上是我的大体思路，如有错误，还请指正。现已用代码实现完毕。 代码暂不公开，只提供部分重点代码解析：

一、发送端

其实发送端和初级功能的发送差不多 个人编写的交互流程如下：

1
2
3
4
5
6
7
8
9
10
11
12
13

IP地址:121.250.216.221   MAC地址:3c970e4b56d6con:127

-------------------------------------------
IP地址:121.250.216.227   MAC地址:089e01b948f4con:128

-------------------------------------------
IP地址:121.250.216.228   MAC地址:10bf48705aeecon:129

获取MAC地址完毕,请输入你要发送对方的IP地址:
192.168.1.3
请输入你要发送的内容:
im cqc
要发送的内容:im cqc

具体代码不再解析，同上一篇初级功能。

二、路由端

首先要开启两个网卡，声明两个网卡对象和处理器

1
2

pcap_if_t  *d,*d2;					//选中的网络适配器
pcap_t *adhandle,*adhandle2;           //捕捉实例,是pcap_open返回的对象,adhandle是用来发送数据，adhandle2是用来接收数据

一个用来接收一个用来发送，这里定义了adhandle是用来发送，adhandle2是用来接收数据。 那么打开适配器就在main方法中，提前打开两个网卡

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

int num;
	printf("请输入你要转发数据的网卡代号:\n");
	//让用户选择选择哪个适配器进行转发
	scanf_s("%d",&num);

	//跳转到选中的适配器
	for(d=alldevs, i=0; i< num-1 ; d=d->next, i++);

	//运行到此处说明用户的输入是合法的，找到发送数据网卡
	if((adhandle = pcap_open(d->name,		//设备名称
													65535,       //存放数据包的内容长度
													PCAP_OPENFLAG_PROMISCUOUS,  //混杂模式
													1000,           //超时时间
													NULL,          //远程验证
													errbuf         //错误缓冲
													)) == NULL){
    //打开适配器失败,打印错误并释放适配器列表
	fprintf(stderr,"\nUnable to open the adapter. %s is not supported by WinPcap\n", d->name);
    // 释放设备列表 
    pcap_freealldevs(alldevs);
    return -1;
	}

	int num2;
	printf("请输入你要接收数据的网卡代号:");
	//让用户选择用哪个网卡来收数据
	scanf_s("%d",&num2);
	//用户输入的数字超出合理范围


	//跳转到选中的适配器
	for(d2=alldevs, i=0; i< num2-1 ; d2=d2->next, i++);

	//运行到此处说明用户的输入是合法的
	if((adhandle2 = pcap_open(d2->name,		//设备名称
													65535,       //存放数据包的内容长度
													PCAP_OPENFLAG_PROMISCUOUS,  //混杂模式
													1000,           //超时时间
													NULL,          //远程验证
													errbuf         //错误缓冲
													)) == NULL){
    //打开适配器失败,打印错误并释放适配器列表
	fprintf(stderr,"\nUnable to open the adapter. %s is not supported by WinPcap\n", d2->name);

接下来用用于发送的handle处理器来扫描它的局域网IP，获得局域网内的MAC地址，记录在一个表中,存放IP和MAC的对应关系。 这个表可以用结构体数组来保存，比如可以这样:

1
2
3
4

struct ip_mac_list{
	IpAddress ip;
	unsigned char mac[6];
};

1

ip_mac_list  list[256];                       //存储IP和MAC地址的对应表

那么以上便是准备工作，我们完成了两个网卡的打开，发送网卡扫描获取局域网MAC，接下来便是最重要的监听加转发。 那么这个怎办？那就开一个新线程。 让我们声明一个新的路由线程。

1

DWORD WINAPI RouteThread(LPVOID lpParameter);

那么线程要接收进来什么参数呢？ 首先必须要的是两个网卡处理器，在main方法中已经做好初始化的adhandle和adhandle2，另外还有alldevs，可以持有这个指针来释放设备列表，出现错误时释放资源并退出。 初级功能中声明过了 struct sparam sp; struct gparam gp; 这两个就是发送ARP线程和接收ARP线程中的两个参数，那么仿照这个功能，我们定义一个新的结构体

1
2
3
4
5

struct rparam{
	pcap_t *adhandle_rec;
	pcap_t *adhandle_send;
	pcap_if_t  * alldevs;       //所有网络适配器
};

在main方法中把它来初始化赋值

1
2
3

rp.adhandle_send = adhandle;
	rp.adhandle_rec = adhandle2;
	rp.alldevs = alldevs;

当做参数传入这个线程

1
2

routethread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) RouteThread, &rp,
			0, NULL);

其中第四个参数就是传递了这个结构体进去。注意这个语句最好不要直接放在main方法中直接调用，可以在全部获取完MAC地址之后再开启这个线程。 那么接下来就说一下这个线程都干了些什么，只简略说一下核心部分。 首先开启了这个线程之后会一直都在执行，那么就可以加入

1

while((res = pcap_next_ex(adhandle2,&header,&pkt_data))>=0)

这样的while判断语句来一直监听数据包的接收，然后解析数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

ethernet =  (EthernetHeader *)(pkt_data);
			for(int i=0;i<6;i++){
				sou_mac[i] = ethernet->SourMAC[i];
			}
			for(int i=0;i<6;i++){
				des_mac[i] = ethernet->DestMAC[i];
			}
			// 获得IP数据包头部的位置
			ip = (IpHeader *) (pkt_data +14);    //14为以太网帧头部长度
			//获得TCP头部的位置
			ip_len = (ip->Version_HLen & 0xf) *4;
			tcp = (TcpHeader *)((u_char *)ip+ip_len);
			data = (char *)((u_char *)tcp+20);
			printf("data:%s\n",data);
			printf("ip:");
			printf("%d.%d.%d.%d -> %d.%d.%d.%d\n",
					ip->SourceAddr.byte1,
					ip->SourceAddr.byte2,
					ip->SourceAddr.byte3,
					ip->SourceAddr.byte4,
				    ip->DestinationAddr.byte1,
				    ip->DestinationAddr.byte2,
				    ip->DestinationAddr.byte3,
				    ip->DestinationAddr.byte4);
			 printf("sou_mac:%02x-%02x-%02x-%02x-%02x-%02x\n", sou_mac[0], sou_mac[1], sou_mac[2],
			    sou_mac[3], sou_mac[4], sou_mac[5]);
			printf("des_mac:%02x-%02x-%02x-%02x-%02x-%02x\n", des_mac[0], des_mac[1], des_mac[2],
			    des_mac[3], des_mac[4], des_mac[5]);

然后接下来每接收到一个数据，就进行构建新的帧转发出去，目的MAC先匹配list表，如果list没有找到，那么我让他指定了一个mac，比如广播MAC。源MAC地址则赋值网卡的MAC地址。 注意，传统以太网中数据长度为45-1500，那么我在构建前把解析出的data作了下判断长度再构建，因为我已经把sendbuffer声明为一个固定长度了，为了防止越界，我先进行一个长度判断。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

//以下开始构建帧发送
		//首先判断data最大值小于1500
		if(strlen(data)<1500){
			//目的MAC
			BYTE send_destmac[6];
			bool findMac = false;
			for(int c = 0;c<con;c++){
				if(ip->DestinationAddr.byte1 ==  list[c].ip.byte1&&
					ip->DestinationAddr.byte2 == list[c].ip.byte2&&
					ip->DestinationAddr.byte3 == list[c].ip.byte3&&
					ip->DestinationAddr.byte4 == list[c].ip.byte4)
				{
					printf("Find its MAC!\n");
					findMac = true;
					send_destmac[0] = list[c].mac[0];   
					send_destmac[1] = list[c].mac[1];
					send_destmac[2] = list[c].mac[2];
					send_destmac[3] = list[c].mac[3];
					send_destmac[4] = list[c].mac[4];
					send_destmac[5] = list[c].mac[5];
				}
			}
			if(!findMac){
				send_destmac[0] = 0xff;   
				send_destmac[1] = 0xff;   
				send_destmac[2] = 0xff;   
				send_destmac[3] = 0xff;   
				send_destmac[4] = 0xff;   
				send_destmac[5] = 0xff;   
			}
			printf("destmac:%02x-%02x-%02x-%02x-%02x-%02x\n",
				send_destmac[0],send_destmac[1],send_destmac[2],
				send_destmac[3],send_destmac[4],send_destmac[5]
				);
			memcpy(send_ethernet.DestMAC, send_destmac, 6);
			//源MAC地址
			BYTE send_hostmac[6];
			//源MAC地址
			send_hostmac[0] = local_mac[0];     //赋值本地MAC地址
			send_hostmac[1] = local_mac[1];
			send_hostmac[2] = local_mac[2];
			send_hostmac[3] = local_mac[3];
			send_hostmac[4] = local_mac[4];
			send_hostmac[5] = local_mac[5];
			//赋值源MAC地址
			memcpy(send_ethernet.SourMAC, send_hostmac, 6);
			send_ethernet.EthType = htons(0x0800);
			//赋值SendBuffer
			memcpy(&SendBuffer, &send_ethernet, sizeof(struct EthernetHeader));

以上只是赋值了帧头，至于IP头，TCP头，数据的赋值就参照初级功能的来赋值吧，不要忘了校验和的检验。好，大体上就是这样，接受来数据包并转发出去的原理就是这样。

三、接收

不用多改，就是初级功能中的接收，在此写一写小小的优化措施，防止接收到过多的数据帧而造成不断乱蹦，导致你看不到接收的东西。 在打印的时候加一个过滤就好了。部分代码如下： 在main方法中提示用户输入要接收的IP地址

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

printf("请输入要接收的IP地址,输入0.0.0.0代表全部接收,请输入\n");
	bool receiveAll = false;
	u_int ip1,ip2,ip3,ip4;
	bool legal = false;
	while(!legal){
		scanf_s("%d.%d.%d.%d",&ip1,&ip2,&ip3,&ip4);
		if(ip1==0&&ip2==0&&ip3==0&&ip4==0){
			receiveAll = true;
			legal = true;
			break;
		}
		if(ip1<0||ip1>255||ip2<0||ip2>255||ip3<0||ip3>255||ip4<1||ip4>254){
			legal = false;
			printf("对不起,IP输入不合法,请重新输入:\n");
		}else{
			legal = true;
		}
	}

打印时的判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

if(receiveAll||(ip->SourceAddr.byte1==ip1&&
					ip->SourceAddr.byte2==ip2&&
					ip->SourceAddr.byte3==ip3&&
					ip->SourceAddr.byte4==ip4)){
					printf("%d.%d.%d.%d.%d -> %d.%d.%d.%d.%d\n",
					ip->SourceAddr.byte1,
					ip->SourceAddr.byte2,
					ip->SourceAddr.byte3,
					ip->SourceAddr.byte4,
				    sport,
				    ip->DestinationAddr.byte1,
				    ip->DestinationAddr.byte2,
				    ip->DestinationAddr.byte3,
				    ip->DestinationAddr.byte4,
				    dport);
			    printf("sou_mac:%02x-%02x-%02x-%02x-%02x-%02x\n", sou_mac[0], sou_mac[1], sou_mac[2],
			    sou_mac[3], sou_mac[4], sou_mac[5]);
				printf("des_mac:%02x-%02x-%02x-%02x-%02x-%02x\n", des_mac[0], des_mac[1], des_mac[2],
			    des_mac[3], des_mac[4], des_mac[5]);
				printf("%s\n",data);
				printf("-----------------------------------------------------\n");
			}

好，代码就先放送这么多，具体的实现只要有了思路我相信肯定不难，如有问题，欢迎与我交流。

学习文档

这里我们直接进入正题吧，关于Winpcap的基础知识讲解这里就不再赘述了。在这里给大家提供一些学习网址 Winpcap网络编程及通信教程Winpcap中文技术文档

学习内容

• 获取设备列表
• 获取已安装设备的高级信息
• 打开适配器并捕获数据包
• 不用回调方法捕获数据包
• 过滤数据包
• 分析数据包
• 处理脱机堆文件
• 发送数据包
• 收集并统计网络流量

这些内容，在上述两个链接中均已经有了比较详细的讲解，希望对大家有帮助。

两台主机通信实战

完成两台主机之间的数据通信（数据链路层）

• 仿真ARP协议获得网段内主机的MAC表
• 使用帧完成两台主机的通信（Hello! I’m …)

首先我们要理解ARP是干嘛的，ARP主要作用就是通过IP地址来获取MAC地址。那么怎样获取呢？本机向局域网内主机发送ARP包，ARP包内包含了目的IP，源IP，目的MAC，源MAC，其中目的MAC地址为广播地址,FF-FF-FF-FF-FF-FF,即向局域网内所有主机发送一个ARP请求，那么其他主机收到这个请求之后则会向请求来源返回一个数据包。在这个返回的数据包中包含了自身的MAC地址。那么本机收到这些返回的数据包进行解析之后便会得到局域网内所有主机的MAC地址了.. 编程开始： 新建一个C++项目，配好环境，引入Winpcap相关的库，这些不再赘述。 头文件引入

1
2
3
4
5

#define HAVE_REMOTE
#define WPCAP
#include <stdio.h>
#include <stdlib.h>
#include <pcap.h>

在main函数中首先声明一系列变量如下

1
2
3

char *ip_addr;                                    //IP地址
char *ip_netmask;                             //子网掩码
unsigned char *ip_mac;          //本机MAC地址

为这三个变量分配地址空间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

ip_addr = (char *) malloc(sizeof(char) * 16); //申请内存存放IP地址
	if (ip_addr == NULL)
	{
		printf("申请内存存放IP地址失败!\n");
		return -1;
	}
	ip_netmask = (char *) malloc(sizeof(char) * 16); //申请内存存放NETMASK地址
	if (ip_netmask == NULL)
	{
		printf("申请内存存放NETMASK地址失败!\n");
		return -1;
	}
	ip_mac = (unsigned char *) malloc(sizeof(unsigned char) * 6); //申请内存存放MAC地址
	if (ip_mac == NULL)
	{
		printf("申请内存存放MAC地址失败!\n");
		return -1;
	}

接下来就是烂大街的程序,获取适配器列表并选中相应的适配器,注释已经在代码中了,如果还有不明白的请参照前几次的讲解。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

//获取本地适配器列表
	if(pcap_findalldevs_ex(PCAP_SRC_IF_STRING,NULL,&alldevs,errbuf) == -1){
		//结果为-1代表出现获取适配器列表失败
		fprintf(stderr,"Error in pcap_findalldevs_ex:\n",errbuf);
		//exit(0)代表正常退出,exit(other)为非正常退出,这个值会传给操作系统
		exit(1);
	}
	

	for(d = alldevs;d !=NULL;d = d->next){
		printf("-----------------------------------------------------------------\nnumber:%d\nname:%s\n",++i,d->name);
		if(d->description){
			//打印适配器的描述信息
			printf("description:%s\n",d->description);
		}else{
			//适配器不存在描述信息
			printf("description:%s","no description\n");
		}
		//打印本地环回地址
		 printf("\tLoopback: %s\n",(d->flags & PCAP_IF_LOOPBACK)?"yes":"no");
		 /**
		 pcap_addr *  next     指向下一个地址的指针
		 sockaddr *  addr       IP地址
		 sockaddr *  netmask  子网掩码
		 sockaddr *  broadaddr   广播地址
		 sockaddr *  dstaddr        目的地址
		 */
		 pcap_addr_t *a;       //网络适配器的地址用来存储变量
		 for(a = d->addresses;a;a = a->next){
			 //sa_family代表了地址的类型,是IPV4地址类型还是IPV6地址类型
			 switch (a->addr->sa_family)
			 {
				 case AF_INET:  //代表IPV4类型地址
					 printf("Address Family Name:AF_INET\n");
					 if(a->addr){
						 //->的优先级等同于括号,高于强制类型转换,因为addr为sockaddr类型，对其进行操作须转换为sockaddr_in类型
						 printf("Address:%s\n",iptos(((struct sockaddr_in *)a->addr)->sin_addr.s_addr));
					 }
					if (a->netmask){
						 printf("\tNetmask: %s\n",iptos(((struct sockaddr_in *)a->netmask)->sin_addr.s_addr));
					}
					if (a->broadaddr){
						   printf("\tBroadcast Address: %s\n",iptos(((struct sockaddr_in *)a->broadaddr)->sin_addr.s_addr));
					 }
					 if (a->dstaddr){
						   printf("\tDestination Address: %s\n",iptos(((struct sockaddr_in *)a->dstaddr)->sin_addr.s_addr));
					 }
        			 break;
				 case AF_INET6: //代表IPV6类型地址
					 printf("Address Family Name:AF_INET6\n");
					 printf("this is an IPV6 address\n");
					 break;
				 default:
					 break;
			 }
		 }
	}
	//i为0代表上述循环未进入,即没有找到适配器,可能的原因为Winpcap没有安装导致未扫描到
	if(i == 0){
		printf("interface not found,please check winpcap installation");
	}

	int num;
	printf("Enter the interface number(1-%d):",i);
	//让用户选择选择哪个适配器进行抓包
	scanf_s("%d",&num);
	printf("\n");

	//用户输入的数字超出合理范围
	if(num<1||num>i){
		printf("number out of range\n");
		pcap_freealldevs(alldevs);
		return -1;
	}
	//跳转到选中的适配器
	for(d=alldevs, i=0; i< num-1 ; d=d->next, i++);

	//运行到此处说明用户的输入是合法的
	if((adhandle = pcap_open(d->name,		//设备名称
														65535,       //存放数据包的内容长度
														PCAP_OPENFLAG_PROMISCUOUS,  //混杂模式
														1000,           //超时时间
														NULL,          //远程验证
														errbuf         //错误缓冲
														)) == NULL){
        //打开适配器失败,打印错误并释放适配器列表
		fprintf(stderr,"\nUnable to open the adapter. %s is not supported by WinPcap\n", d->name);
        // 释放设备列表 
        pcap_freealldevs(alldevs);
        return -1;
	}