最终版的Web（Python实现）

天啦，要考试了，要期末考试了，今天把最终版的Python搭建Web代码先写这里记下了。详细的过程先不写了。

这次是在前面的基础上重写 HTTPServer 与 BaseHTTPRequestHandler，主要利用 python 提供

的 socket 进行编程，从而实现消息的接收与相应；然后再接着引入多线程，分别处理来自客户
端的请求；最后实现根据客户端传递的参数动态生成页面的功能。

主要步骤如下：

一、 .重写 HTTPServer 与 BaseHTTPRequestHandler
Python socket 编程流程（服务器端） ：
1. 第一步是创建 socket 对象。调用 socket 构造函数。如：
socket = socket.socket( family, type )
family 参数代表地址家族， 可为 AF_INET 或 AF_UNIX。 AF_INET 家族包括 Internet
地址，AF_UNIX 家族用于同一台机器上的进程间通信。
type 参数代表套接字类型，可为 SOCK_STREAM(流套接字)和 SOCK_DGRAM(数
据报套接字)。
2. 第二步是将socket绑定到指定地址。 这是通过socket对象的bind方法来实现的：
socket.bind( address )
由 AF_INET 所创建的套接字，address 地址必须是一个双元素元组，格式是
(host,port)。host 代表主机，port 代表端口号。如果端口号正在使用、主机名不正
确或端口已被保留，bind 方法将引发 socket.error 异常。
3. 第三步是使用 socket 套接字的 listen 方法接收连接请求。
socket.listen( backlog )
backlog 指定最多允许多少个客户连接到服务器。 它的值至少为 1。 收到连接请求后，
这些请求需要排队，如果队列满，就拒绝请求。
4. 第四步是服务器套接字通过 socket 的 accept 方法等待客户请求一个连接。
connection, address = socket.accept()
调 用 accept 方法时，socket 会时入“waiting”状态。客户请求连接时，方法建立连
接并返回服务器。 accept 方法返回一个含有两个元素的 元组(connection,address)。
第一个元素 connection 是新的 socket 对象，服务器必须通过它与客户通信；第二
个元素 address 是客户的 Internet 地址。
5. 第五步是处理阶段， 服务器和客户端通过 send 和 recv 方法通信(传输 数据)。 服
务器调用 send，并采用字符串形式向客户发送信息。send 方法返回已发送的字符
个数。服务器使用 recv 方法从客户接收信息。调用 recv 时，服务器必须指定一个
整数，它对应于可通过本次方法调用来接收的最大数据量。recv 方法在接收数据时
会进入“blocked”状态，最后返回一个字符 串，用它表示收到的数据。如果发送的数
据量超过了 recv 所允许的，数据会被截短。多余的数据将缓冲于接收端。以后调用
recv 时，多余的数据会从缓冲区 删除(以及自上次调用 recv 以来，客户可能发送的
其它任何数据)。
6. 传输结束，服务器调用 socket 的 close 方法关闭连接。

整个代码块儿如下：

注释有点乱， 中英文结合。。

Test.py

# -*-coding:utf-8 -*-
import BaseHTTPServer
import os
import socket
import subprocess
import threading

from datetime import datetime

class ServerException( Exception ):
    pass

    #
    # 重写 HTTPServer 与 BaseHTTPRequestHandler，主要利用 python 提供
    # 的 socket 进行编程，从而实现消息的接收与相应；然后再接着引入多线程，分别处理来自客户
    # 端的请求；最后实现根据客户端传递的参数动态生成页面的功能。

# step1:reWrite HttpServer and BaseHTTPRequestHandler

class HttpServer:
    def __init__(self, serverAddr, RequestHandler):
        self.serverAddr = serverAddr
        self.requestHandler = RequestHandler

    def serve_forever(self):
        #    1. create socket object(对象), call socket create function
        server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        # 1family=AF_INET,type=SOCK_STREAM
        server_sock.bind(self.serverAddr)
        # 2. call socket bind, aim to bind socket to pointed address
        # address must be a two-elements yuanzu, style is (host, port)
        # host stands for port number. if port number is in using        #、host name is wrong or port number has been saved, bind way will
        # bring socket.error yi chang
        server_sock.listen(10)
        # 3.  using socket‘s listen way to receive connect request
        # listen parament backlog=10:point allow no more than 10 clients
        # can connect to server. its value at least is 1. when received
        # request, those requests need pai dui,if list full, then refuse request

        while True:
            print ‘waiting for connection...‘
            clientsock, addr = server_sock.accept()
            # 4. server socket wait for client to request a connection
            # when call accept() function, socket will come into "wating"
            # states. when client request connection,function create
            # connection and return server..
            # accept function return with two elements
            # (connection, address)., the first connection is new socket‘s
            # object, server must through it to tong xin with client.
            # the second element address is clients‘ Internet address
            print ‘received from :‘, addr
            thread = threading.Thread(target=self.startThread, args=(clientsock, addr,))
            thread.setDaemon(True)
            thread.start()
            # handler = RequestHandler(clientsock, addr,self)

        server_sock.close()

    def startThread(self, clientsock, addr):
        handler = RequestHandler(clientsock, addr, self)

class HttpRequestHandler:
    bufsize = 1024

    def __init__(self, clientsock, addr):
        self.cliensock = clientsock
        self.client_address = addr
        self.date_time_string = datetime.now()
        self.analyze() # http head part analyze

    def analyze(self):
        # receive dates, bufsize points to read dates num one time
        """

        :type self: object

        """
        data = self.cliensock.recv(self.bufsize)
        # print‘receive ------->%s\n%s‘ %(datetime.now(), data)

        # chrome sometimes will send two request consist, tne second is null, reason is unknow
        if data.repalce(" ", "") == "":
            print "data is null"
            return
        data = data.split(‘\r\n‘)
        # first line is "GET/something.html?a=1&b=2 HTTP/1.1
        firstLine = data[0]
        arr = firstLine.split(‘ ‘)
        self.command = arr[0]
        self.protocol = arr[2]
        if ‘?‘ in arr[1]:
            # path put absolute way
            self.path, self.paramStr = arr[1].spilt(‘?‘)
        else:
            self.path = arr[1]
            self.paramStr = None

            # put the remain of head information in heades‘s dictionary in the way of key value
            # Accept-Language : zh - cn
            # Connection : Keep - Alive
            # Host : Localhost
            # Accept - Encoding : gzip, deflate
            self.headers = {}
            for line in data[1:]:
                if ‘:‘ in line:
                    key, value = line.split(‘:‘, 1)
                    self.headers[key] = value

                    # call function to deal with, this function has come in the first
            self.do_GET()
            # time.sleep(30)
            # when this function receive data, first feng li data
            # char string as th rule of ‘\r\n‘
            # then ti qu first line, that is "GET/something.html?a=1&b=2 HTTP/1.1
            # then analyze it , put it to the variable

    # path

    http_response = "HTTP/1.1"

    def send_response(self, status):
        if status == 200:
            self.http_response += "200" + " " + "OK"
        elif status == 404:
            self.http_response += "400" + " " + "Not Found"
        self.http_response += ‘\r\n‘

    # "Content_Type", "text/html"
    # "Content-Length", Length

    def send_heade(self, key, value):
        self.http_response += str(key) + ": " + str(value) + ‘\r\n‘

    def end_headers(self):
        self.http_response += ‘\r\n‘

    def write(self, page):
        self.http_response += str(page)
        self.clientsock.send(self.http_response)
        self.cliensock.close()

        # those functions are pin zhuang http_response char string
        # as the rule of response head style

class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
    """dealt with and return page"""
    # page model
    Page = ‘‘‘
    <html>
    <body>
    <table border=2s>
   <tr> <td>Header</td> <td>Value</td> </tr>
<tr> <td>Date</td><td> and time</td> <td>{date_time}</td> </tr>
<tr> <td>Client host</td> <td>{client_host}</td> </tr>
<tr> <td>Client port</td> <td>{client_port}</td> </tr>
<tr> <td>Command</td> <td>{command}</td> </tr>
<tr> <td>Path</td> <td>{path}</td> </tr>
</table>
</body>
    </html>
    ‘‘‘
    Error_Page = """    <html>
    <body>
    <h1>Error accessing {path}</h1>
    <p>{msg}</p>
    </body>
    </html>
    """

    def handle_error(self, msg):
        content = self.Error_Page.format( path=self.path, msg=msg )
        self.send_content( content, 404 )

    def handle_file(self, full_path):
        # 处理 python 脚本
        if full_path.endswith(‘.py‘):
            # data 为脚本运行后的返回值
            data = subprocess.check_output([‘python‘, full_path, self.paramStr] )
            self.send_content(data)
            return
        try:
            with open(full_path, ‘rb‘) as reader:
                content = reader.read()
            self.send_content(content)
        except IOError as msg:
            msg = "‘{0}‘ cannot be read: {1}".format(self.path, msg )
            self.handle_error(msg)

    # deal with a request
    def do_GET(self):
        # type: () -> object
        try:
            full_path = os.getcwd() + self.path

            if not os.path.exists(full_path):
                raise ServerException("‘{0}‘ not found".format( self.path ) )
            elif os.path.isfile(full_path):
                self.handle_file(full_path)
                # 访问根路径
            elif os.path.isdir(full_path):
                # fullPath = os.path.join(fullPath, "index.html")
                full_path += "index.html"
                if os.path.isfile(full_path):
                    self.handle_file(full_path )
                else:
                    raise ServerException( "‘{0}‘ not found".format( self.path ) )
            else:
                raise ServerException( "Unknown object ‘{0}‘".format( self.path ) )
        except Exception as msg:
            self.handle_error(msg)

    @property
    def create_page(self):
        values = {
            ‘date_time‘: self.date_time_string( ),
            ‘client_host‘: self.client_address[0],
            ‘client_port‘: self.client_address[1],
            ‘command‘: self.command,
            ‘path‘: self.path
        }
        page = self.Page.format( **values )
        return page
        pass

    def send_content(self, content, status=200):
        self.send_response(status)

        self.send_header("Content-type", "text/html" )
        self.send_header("Content-Length", str( len( content ) ) )
        self.end_headers()
        # self.wfile.write(self.create_page)
        self.wfile.write(content)
        # self.write(page)
        pass

if __name__ == ‘__main__‘:
    serverAddr = (‘localhost‘, 5555)
    server = HttpServer(serverAddr, RequestHandler )
    server.serve_forever()

calc.py

import sys

paramStr = sys.argv[1]
paramArr = paramStr.split(‘&‘)
paramDict = {}
for param in paramArr:
    key, value = param.split(‘=‘)
    paramDict[key] = value

print ‘‘‘<html>
<body>
<p>a + b = {0}</p>
</body>
</html>‘‘‘.format((int(paramDict[‘a‘]) + int(paramDict[‘b‘])))

　　index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>index</title>
</head>
<body>
   <h1>Index Page </h1>
   <p>I love Python, to be honest</p>

<table border=2s>
   <tr> <td>Header</td> <td>Value</td> </tr>
<tr> <td>Date</td><td> and time</td> <td>{date_time}</td> </tr>
<tr> <td>Client host</td> <td>{client_host}</td> </tr>
<tr> <td>Client port</td> <td>{client_port}</td> </tr>
<tr> <td>Command</td> <td>{command}</td> </tr>
<tr> <td>Path</td> <td>{path}</td> </tr>
</table>

<p>please input first number:</p>
<input>
<br>
<p>please input second number:</p>
<input>

<button>add</button>
</body>
</html>

　运行效果如图：

好好准备期末考了。。。。