网络中的进程

socket解决的是网络中进程间的通信，其首要解决的就是如何在网络中找到目标进程，这就要求进程拥有唯一性的索引，方便查找连接。

一台机器上，进程与进程之间通行，以PID作为唯一标识。但是在网络中，不同的机器，PID可能重复。

然而，网络层的IP 可以唯一标识主机，传输层的 tcp协议和端口号 则能够唯一标识主机中的进程。

因此: ip地址+协议+端口 = 网络中的一个进程

socket

就目前而言，几乎所有的应用程序都是采用socket，而现在又是网络时代，网络中进程通信是无处不在，这就是我为什么说“一切皆socket”。

socket位于应用层和传输层之间的一个抽象层，封装传输层的各种复杂操作，提供几个简单的接口供应用层调用。

socket的主要作用是实现在网络中 进程之间的通信。

服务端和客户端 统一使用 socket提供的api进行通信。

socket三次握手 （TCP）

client客户端调用 connect() 方法时，即开始进行建立tcp连接（三次握手）中的 第一次握手（阻塞等待服务端的第二次握手）。

server服务端开始调用 accept() 方法，完成 第二次握手（阻塞等待客户端的第三次握手）。

client客户端 connect() 方法收到第二次握手，进行 第三次握手 ，connect() 方法完成执行。

server服务端 accept() 方法收到第三次握手，完成执行。

通信

socket使用的 “ 打开 -> 读写 -> 关闭 ” 这种模式进行的操作。

这种模式将socket看成一个特殊的 “文件”，提供一些函数对其进行 “IO操作”。

服务端和客户端通过读取这个中间 “文件” 来进行通信。

具体的I/O操作函数有一下几种方式

• read()/write()

• recv()/send()

• readv()/writev()

• recvmsg()/sendmsg()

• recvfrom()/sendto()

node中的socket编程

node中跟socket相关的网络模块有两个：

• net

• http

net为最底层，以事件驱动机制将socket的接口进行封装，提供socket的相关操作。

http在net的基础上，基于http协议进行再一次封装，将请求分成http头和http体，提供基于request和response的基本操作。

net模块

net模块是node的原生模块，是对tcp层的封装（socket）。

提供了两个类的定义：

• net.Socket （实现node中的socket操作）

  • 事件: ‘lookup’
  • 事件: ‘connect’
  • 事件: ‘data’
  • 事件: ‘end’
  • 事件: ‘timeout’
  • 事件: ‘drain’
  • 事件: ‘error’
  • 事件: ‘close’

• net.Server （基于socket，再次封装成服务端API）

  • 事件: ‘listening’
  • 事件: ‘connection’
  • 事件: ‘close’
  • 事件: ‘error’

提供了一些基于两个类的基本操作

• net.createServer([options], [connectionListener])

• net.connect(options, [connectionListener])

• net.createConnection(options, [connectionListener])

• net.connect(port, [host], [connectListener])

• net.createConnection(port, [host], [connectListener])

• net.connect(path, [connectListener])

• net.createConnection(path, [connectListener])

服务端使用

var net = require('net');

var server = net.createServer(function(clientSocket){
    ...
})

server.listen(10000,'127.0.0.1',function(){
    console.log('监听开始')
})

客户端使用

var net = require('net');

var clientSocket = net.connect({
    port:10000,
    host:'127.0.0.1'
},function(){
    console.log('tcp连接建立成功');
})
...

其中具体的通信使用事件驱动机制。

clientSocket.on('data',function(){
    ...
})
...

http模块

http模块在net的基础上，提供针对应用层http协议的专门API。

http模块以request和response为基本操作单位，封装net.Socket，将获取到的数据data，分成请求头和请求体。

提供了五个类的定义：

• http.Server （基于net.Server的再次封装）

  • 事件: ‘request’
  • 事件: ‘connection’
  • 事件: ‘close’
  • 事件: ‘checkContinue’
  • 事件: ‘connect’
  • 事件: ‘upgrade’
  • 事件: ‘clientError’

• http.ServerResponse （基于net.Socket的再次封装）

  • 事件：’close’

• http.ClientRequest （基于net.Socket的再次封装）

  • 事件: ‘response’
  • 事件: ‘socket’
  • 事件: ‘connect’
  • 事件: ‘upgrade’
  • 事件: ‘continue’

• http.Agent

• http.IncomingMessage

服务端使用

var http = require('http');

var server = http.createServer(function(request,response){
    ...
})

// 或者

var server = new http.Server();
server.on('request',function(request,response){
    ...
})

server.listen(10000,'127.0.0.1',function(){
    console.log('监听开始')
})

客户端使用

var http = require('http');

var request = http.request({
    host : '127.0.0.1',
    method : 'GET',
    path: '/'
    ..
})

request.on('response',function(response){
    ...
})

url模块

url模块常常配合http模块，对url进行处理。

                               url.parse(string).query
                                           |
           url.parse(string).pathname      |
                       |                   |
                       |                   |
                     ------ -------------------
http://localhost:8888/start?foo=bar&hello=world
                                ---       -----
                                 |          |
                                 |          |
              querystring(string)["foo"]    |
                                            |
                         querystring(string)["hello"]

通过url模块，可以创建一个路由机制

var http = require('http');
var url = require('url');
var querystring = require('querystring');

var routeHandle = {};

routeHandle['/'] = function(response){
    ...
}

routeHandle['/upload'] = function(response){
    ...
}


http.createServer(function(request,response){

    var pathname = url.parse(request.url).pathname;

    route(routeHandle,pathname,request,response);

}).listen(10000,'127.0.0.1');



function route(handle,pathname,request,response){
    if (typeof handle[pathname] === 'function') {
        handle[pathname](response);
    } else {
        console.log("该路由没有处理器： " + pathname);
    }
}

静态文件处理

一个完整的http服务器，除了几个特定的url路径处理之外（即后台action），还应该对静态文件请求做处理。

var http = require('http');
var url = require('url');
var path = require('path');
var fs = require('fs');

var MIME = {

  "css": "text/css",

  "gif": "image/gif",

  "html": "text/html",

  "ico": "image/x-icon",

  "jpeg": "image/jpeg",

  "jpg": "image/jpeg",

  "js": "text/javascript",

  "json": "application/json",

  "pdf": "application/pdf",

  "png": "image/png",

  "svg": "image/svg+xml",

  "swf": "application/x-shockwave-flash",

  "tiff": "image/tiff",

  "txt": "text/plain",

  "wav": "audio/x-wav",

  "wma": "audio/x-ms-wma",

  "wmv": "video/x-ms-wmv",

  "xml": "text/xml"

}

...

function route(handle,pathname,request,response){
    // path.extname(relPath) 获取文件后缀名
    if(path.extname(pathname)){
        // 静态文件 处理
        doStaticFile(pathname,response);
    }
    else{
        // action 处理
        ...
    }
}

function doStaticFile(relPath,response){

    fs.exists(relPath,function(exists){
        if(!exists){
            response.writeHead(404, {'Content-Type': 'text/plain'});

            response.write("请求的路径不存在：" + relPath);

            response.end();
        }else{
            fs.readFile(relPath,'binary',function(err,file){
                if(err){
                    // 服务器异常
                    response.writeHead(500, {'Content-Type': 'text/plain'});

                    response.end();
                }else{
                    // 返回静态文件
                    var suffix = path.extname(realPath);

                    // 由于extname返回值包含”.”，所以通过slice方法来剔除掉”.”
                    var mime = MIME[suffix.slice(1)] || 'text/plain';

                    response.writeHead(200, {'Content-Type': mime});

                    response.write(file, "binary");

                    response.end();
                }
            })
        }
    })

}

http.createServer(function(request,response){

    var pathname = url.parse(request.url).pathname;

    route(routeHandle,pathname,request,response);

}).listen(10000,'127.0.0.1');

这里就基本实现了一个http服务器，但在静态文件的处理上还有所欠缺。

对于静态资源的请求，每次都是通过读取文件，当请求过多时，会损坏硬盘IO。

因此需要使用缓存,从而减轻硬盘的IO损坏。

参考博文：

• 简单理解Socket - Samaritans - 博客园

• Socket通信原理和实践 - 张勤一 - 博客频道 - CSDN.NET

• 深入浅出NodeJS——数据通信，NET模块运行机制 | 小胡子哥的个人网站

• net模块中文API

• http模块中文API

• 详解Node.js的http模块之http模块概述 - IT笔录

• Http模块 – JavaScript 标准参考教程（alpha）

• 用NodeJS打造你的静态文件服务器 - CNode技术社区