深刻淺出node讀書筆記

時間  2019-11-16
標籤 深刻 node 讀書 筆記 简体版
原文   原文鏈接

github地址：戳這裏javascript

簡介

目標：寫一個基於事件驅動 ，非阻塞i/o 的web服務器，以達到更高的性能。構建快速，可伸縮的網絡應用平臺php

js開發性能低，事件驅動應用html

node強制不共享任何資源的 單線程 ，單進程系統，包含十分適宜網絡的庫前端

應用：

  1. 訪問本地文件
  2. 搭建websocket服務端
  3. 鏈接數據庫
  4. web workers多進程（不處理ui）

特色：

  1. 依舊基於做用域和原型鏈
  2. 異步i/o

兩個readFile的操做最終時間爲最慢的那一個java

  1. 事件和回調函數

事件編程方式：輕量級，輕耦合，只關注事務點等優點node

  1. 單線程nginx

    特色：
    1. js與其餘線程是沒法共享任何狀態
    2. 不用像多線程同樣到處在乎狀態的同步
    3. 沒有死鎖
    4. 沒有線程上下文交換帶來的性能上的開銷
    弱點：
    1. 沒法利用多核cpu
    2. 錯誤會引發整個應用退出，應用的健壯性值得考研
    3. 大量計算佔用cpu致使沒法調用異步i/o
    4. js與ui共用一個線程，長時間執行會致使ui的渲染和響應被中斷
    解決：
    1. web workers可以建立工做線程來進行計算，以解決js大計算阻塞ui渲染的問題
    2. child_process子進程，將計算分發到各個子進程，能夠將大量計算分解掉

應用場景：

  1. i/o密集型，利用事件循環的處理能力
  2. cpu非密集型，i/o阻塞形成的性能浪費遠比cpu的影響小
  3. 分佈式應用，利用高效並行i/o，能夠高效使用數據庫

模塊機制

前言：c++

  • web 1.0 : JavaScript用於表單校驗和網頁特效，只有對bom，dom的支持git

  • web 2.0 : 提高了網頁的用戶體驗，bs應用展示出了比cs(須要裝客戶端)應用優越的地方。h5嶄露頭角github

此過程經歷了工具-組件-框架-應用的變遷

js的規範缺陷：

  1. 沒有模塊系統
  2. 標準庫較少
  3. 沒有標準接口
  4. 缺少包管理系統

commonjs模塊規範

  1. 模塊引入 require()
  2. 提供exports對象用於導出當前模塊的方法或者變量
  3. 模塊標識，就是require的參數，必須駝峯命名，相對路徑或者絕對路徑，能夠沒有後綴

同步，爲後端js指定的規範，並不徹底適合前端的應用場景

模塊實現

模塊分爲兩類：

  1. node提供的 核心模塊

已被編譯進了二進制執行文件，node啓動時就被加載進內存，因此1.2步驟能夠省略。且加載速度最快

  1. 用戶編寫的 文件模塊

動態加載，速度比核心模塊慢

優先從緩存加載

  • node緩存的是 編譯執行後的對象
  • 不論核心模塊仍是用戶模塊，對應相同模塊的二次加載都是緩存優先

在node中引入模塊要通過下面三個步驟

  1. 路徑分析

    1. 標識符分析：
      1. 核心模塊
      2. .. 或者 . 相對路勁模塊
      3. 以 / 開頭的絕對路徑模塊
      4. 非路徑形式的模塊，如自定義的 connect 模塊

    • 若是想加載與核心模塊標識符相同的模塊，必須選擇 不一樣的標識符 或者 換用路徑 的方法

    • 以 . ，.. ，/ 開頭的標識符，會將路徑轉換成真實路徑

    • 自定義模塊是最費時的

      module.paths模仿搜索路徑

      規則以下：

      1. 當前文件目錄下的node_modules
      2. 父目錄下的node_modules
      3. 沿路徑向上逐級遞歸直到根目錄下的node_modules

  2. 文件定位

    1. 文件擴展名

      • .js .node .json順序補齊

      • fs模塊同步阻塞式的判斷文件是否存在，若是是.node 和.json 文件，帶上擴展名再配合緩存能夠加快速度

    2. 目錄和包的處理

      • 若是獲得的是一個目錄，則會被當作包來處理。這時先進入包目錄，查找 package.json ，取出 main 屬性指定的文件名定位。
      • 若是找不到這個文件或者沒有 package.json , 會將 index 做爲默認文件名

  3. 編譯執行

node會新建一個模塊對象，而後根據路徑載入並編譯，對應不一樣擴展名，載入方法不一樣：

  • .js 經過 fs 同步讀取
  • .node 經過 dlopen()加載
  • .json 經過fs讀取，再 JSON.parse
  • 其他擴展名都被當作 .js

每個編譯成功的模塊都會被綁定在 Module._cache 上

編譯過程對文件內容進行頭尾包裝

// 經過vm原生模塊runInThisContext方法執行，不污染全局
(function (exports, require, module, __filename, __dirname) {
    
})
複製代碼

另外，這樣會出錯

exports = function () {
    // My class
}
複製代碼

緣由在於，exports對象是經過形參的方式傳入的，直接賦值會改變形參的做用，但並不能改變做用域外的值。

js核心模塊的編譯過程

  1. 轉存爲c/c++代碼
  2. 編譯js核心模塊

c/c++核心模塊編譯過程

  1. 內建模塊的組織方式

c++模塊主內完成核心，js主外實現封裝

性能優於腳本語言

被編譯成二進制文件，一旦node開始執行，就直接加載進緩存

  1. 內建模塊導出

依賴關係：文件模塊 <-- 核心模 塊<-- 內建模塊

包與npm

cnpm搭建私有的npm服務

包結構

  • package.json 包描述文件

    • name：包名，不容許出現空格
    • description：包簡介
    • version：版本號
    • keywords：關鍵詞數組
    • maintainers：包維護者列表，每一個維護者有name，email，web
    • dependencies：所須要的依賴包列表
    • devDependencies：只在開發時須要的依賴
    • scripts：腳本說明對象
    • main：模塊引入方法require在引入包時，會優先檢查這個字段，並將其做爲包中其他模塊的入口
    • bin：一些包做者但願包能夠做爲命令行工具，配置好bin後，經過npm install package_name -g將腳本添加到執行路徑中，以後能夠再命令行直接執行

  • bin 存放可執行二進制文件的目錄

  • lib 存放js的代碼目錄

  • doc 存放文檔

  • test 存放單元測試用例

經常使用功能

  1. 查看幫助npm help

  2. 安裝依賴包npm install --save/--save-dev express

    1. 全局安裝

    -g是講一個包安裝到全局可用的可執行命令。它根據包描述文件中的bin字段配置，將實際腳本鏈接到與node可執行文件相同的路徑下

    若是node可執行文件的位置是/usr/local/bin/node ，那麼模塊目錄就是/usr/local/lib/node_modules 。最後經過軟連接方式將bin字段配置的可執行文件連接到node的可執行目錄下

    1. 本地安裝

      換源：

      1. npm install underscore --registry=http:registry.url
      2. npm config set registry http:registry.url

  3. npm鉤子

  4. 發佈包

    1. 編寫模塊
    2. 初始化包描述文件
    3. 註冊包倉庫帳號 npm adduser
    4. 上傳包 npm publish<folder>
    5. 管理包權限

    npm owner ls <package_name>

    npm owner add <user> <package_name>

    npm owner rm <user> <package_name> 6. 分析包 npm ls

模塊考察點

  1. 良好的測試
  2. 良好的文檔
  3. 良好的測試覆蓋率
  4. 良好的編碼規範
  5. 更多條件

先後端共用模塊

node模塊引入幾乎都是同步的，但若是前端模塊也採用同步的方式來引入，用戶體驗會形成問題

AMD規範

須要用define來明肯定義一個模塊，而在node實現中是隱式包裝的。

全部的依賴，經過形參傳遞到依賴模塊內容中

define(['dep1', 'dep2'], function (dep1, dep2) {
    return function () {}   
})
複製代碼

目的是做用域隔離

內容須要返回的方式實現導出

define(function () {
    var exports = {};
    exports.sayHello = function () {
        ...
    }
    return exports
    
})
複製代碼

CMD規範

更接近commonjs規範

define(function (require, exports, module) {
    // ...
})
複製代碼

require，exports, module經過形參傳遞給模塊。

兼容多種模塊規範

;(function (name, definition) {
    var hasDefine = typeof define === 'function';
    var hasExports = typeof module !== 'undefined' && module.exports;
    if (hasDefine) { // AMD或者CMD
        define(definition);  
    } else if(hasExports) { // 定義爲普通模塊
        module.exports = definition()
    } else {
        this[name] = definition()
    }
})('hello', function () {
  var hello = function () {}  
  return hello
})
複製代碼

異步i/o

  • node面向網絡而設計

  • 利用單線程，原理多線程死鎖，狀態同步問題

  • 利用異步i/o，讓單線程原理阻塞，更好的利用cpu

  • 內核在進行文件i/o的操做時，經過文件描述符進行管理，文件描述符相似於應用程序與系統內核之間的憑證。

  • 阻塞i/o形成cpu等待浪費，非阻塞卻要 輪詢 去確認是否徹底完成數據獲取

  • 理想非阻塞異步i/o：發起非阻塞調用後，能夠直接處理下一個任務，只需i/o完成後經過信號或回調將數據傳遞給應用程序

  • 顯示的異步i/o：經過讓部分線程進行阻塞i/p或者非阻塞i/o加輪詢技術來完成數據獲取，讓一個線程進行計算處理，經過線程之間的通訊將i/o獲得的數據進行傳遞

爲何要異步i/o

  1. 用戶體驗

    若是是同步，js執行ui渲染和響應將處於停滯狀態

    採用異步，在下載資源期間，js和ui的執行都不會處於等待狀態

    採用異步方式所花時間爲max(m, n)

  2. 資源分配

    • 單線程串行依次執行

    缺點：

    單線程同步編程模型會由於阻塞i/o致使性能差，

    • 多線程並行完成

    缺點：

    代價在於建立線程和執行期線程上下文切換的開銷較大

    多線程常面臨鎖，狀態同步問題

    優勢：

    可是能有效提高cpu利用率

node的異步i/o

模型基本要素：事件循環，觀察者，請求對象，i/o線程池

node自身實際上是多線程的，只是i/o線程使用的cpu較少

  1. 事件循環
  2. 觀察者

每一個事件循環中有一個或者多個觀察者

  1. 請求對象

異步i/o過程當中的重要中間產物，全部的狀態都保存在這個對象中，包括送入線程池等待執行以及i/o操做完畢後的回調處理

  1. 執行回調

非i/o得異步api

  1. 定時器，setTimeout和setInterval

建立的定時器會被插入到定時器觀察者內部的一個紅黑樹中

每次Tick執行時，會從紅黑樹中迭代取出定時器對象，檢查是否超過定時時間。若是超過，就造成一個時間，它的回調函數將當即執行

時間複雜度O(lg(n)) 2. process.nextTick

將回調函數放入隊列，在下一輪Tick時取出執行

時間複雜度 0(1)

事件驅動與高性能服務器

服務器模型：

  • 同步式。一次只能處理一個請求，其餘請求都在等待
  • 每進程/每請求。爲每一個請求啓動一個進程，這樣能夠處理多個請求，可是系統資源只有那麼多，因此不具有擴展性
  • 每線程/每請求。爲每一個請求啓動一個線程來處理。當大併發請你去到來時，內存將用光。

node高性能：

  • node經過實踐驅動的方式處理請求，無須爲每個請求建立額外的對應線程
  • 省掉建立和銷燬線程的開銷。
  • 線程少，上線文切換的代價少

異步編程

函數式編程

  1. 高階函數，將函數做爲輸入或返回值
  2. 偏函數，建立一個調用另一部分--參數或變量已預置的函數---的函數的用法。
var toString = Object.prototype.toString;
var isType = function (type) {
    return function (obj) {
        return toString.call(obj) == '[object' + type + ']'
    }
}
var isFunction = isType('Function')
複製代碼

優點

  1. 基於事件驅動的非阻塞i/o模型
  2. 使cpu與i/o並不相互依賴等待
  3. 並行帶來的想象空間更大，延展開來是分佈式和雲

難點

  1. 異常處理

異步i/o提交請求和處理結果兩個階段中間，有事件循環的調度。異步方法則一般在提交請求後當即返回，由於一場並不必定發生在這個階段，因此try/catch在這裏無效

try/catch對於callback執行時拋出的異常無能爲力

  1. 回調煉獄
  2. 阻塞代碼，因爲沒有sleep，用setTimeout代替
  3. 多線程編程：web workers和child_process
  4. 異步轉同步

異步編程解決方案

  1. 事件發佈/訂閱模式

    1. 繼承events模塊
    var events = require('events');
function Stream () {
    events.EventEmitter.call(this)
}
util.inherits(Stream, events.EventEmitter)
複製代碼

    1. 利用事件隊列解決雪崩問題，once方法

    2. 多異步之間的寫做方案

      1. 利用哨兵變量
      2. EventProxy

  2. Promise/Deferred

    1. Promise/A

      • 只有三種狀態：rejected，fullfiled, rejected

      • 只能未完成到完成，或者失敗，不能逆反

      • 狀態不能更改

  3. 流程控制庫

    1. 尾觸發和next
    2. async的parallel，waterful等方法
    3. step
    4. wind

內存控制

  • js在瀏覽器的應用場景，因爲運行時間短，隨着進程的推出，內存會釋放，幾乎沒有內存管理的額必要

  • 內存控制正式在海量請求和長時間運行的前提下進行探討的。

  • 在服務器端，資源寸土寸金

  • 對於性能敏感的服務器端程序，內存管理的好壞，垃圾回收情況的優良，影響很大

js引擎V8（虛擬機）

內存限制

在node中經過js使用內存時，只能使用部分，沒法直接操做大內存對象

64位系統下約爲1.4GB，32位系統下約爲0.7GB

node中使用js對象，都是經過V8來進行分配和管理的

對象分配

js對象經過堆來分配

當在代碼中生命變量並賦值時，所使用對象的內存就分配在堆中。若是已申請的堆空閒內存不夠分配新的對象，將繼續申請堆內存，直到堆得大小超過V8的限制爲止

V8爲什麼限制堆得大小：表層緣由是起初爲瀏覽器而設計，限制值已經綽綽有餘。深層緣由是V8的垃圾回收機制的限制，作一次非增量式的垃圾回收時間花銷大

垃圾回收機制

V8垃圾回收策略主要基 分代式垃圾回收機制

垃圾回收算法：

  1. V8的內存分帶

將內存分爲 新生代 和 老生代

新生代中的對象爲存活時間較短的對象，老生代的對象爲存活時間較長或常駐內存的對象

  1. Scavenge算法

    • 具體實現主要採用Cheney算法

    • 採用複製的方式實現垃圾回收算法。

    • 將堆內存一分爲二。每一份空間成爲semispace。處於閒置狀態的稱爲To空間，處於使用狀態的稱爲From空間。

    • 當開始進行垃圾回收時，會檢查From空間的存活對象，這些存活對象會被複制到To空間。非存活對象佔用空間會被釋放

    • 缺點：用空間換時間

    • 當一個對象通過屢次複製依然存活時，被認爲是生命週期較長的對象。被移到老生代中。稱爲晉升

    • 對象晉升的條件：

      1. 一個對象經歷過Scavenge回收

      經過檢查它的內存地址來判斷。若是經歷過了，從From複製到老生代

      1. To空間的內存佔用比超過限制25%

缺點：1. 存活對象較多時，複製存活對象的效率低。 2. 浪費通常空間

  1. Mark-Sweep（標記清除）

    • 遍歷堆中的全部對象，標記存活對象。在清除階段只清除沒有被標記的對象。
    • 標記清除後 內存空間出現不連續 的狀態，若是須要分配一個大對象，就沒法完成

  2. Mark-Compat（標記整理）

    • 對象在標記爲死亡後，整理過程當中，將活着的對象往一端移動。完成後，直接清理掉邊界外的內存

    • 在空間不足以對重新生代晉升過來的對象進行分配時才使用

  3. Incremental Marking

    • 上述基本算法都須要將應用邏輯暫停下來，執行完垃圾回收後再恢復，這種行爲成爲 全停頓
    • 全堆垃圾回收的標記，清理，整理等動做形成停頓
    • 將一口氣完成的標記改成增量標記，拆分紅許多小「步進」

  4. 延遲清理和增量清理

  5. 並行標記和並行清理

小結：

  • web服務器的會話實現，通常經過內存來存儲，但在訪問了大的到時候會致使老生代中的存活對象驟增，不盡形成清理/整理過程費時，還會形成內存緊張，甚至溢出

查看垃圾回收日誌

node --trace_gc -e "..."

能夠了解垃圾回收的運行情況，找出哪些階段比較費時

node --prof xx.js

會在該目錄下生成v8.log文件，獲得性能分析數據

node --prof-process isolate-0x103001200-v8.log

因爲日誌文件不具有可讀性，故這樣能夠統計日誌信息

高效使用內存

  1. 做用域

    • 函數調用，被調用時建立對應做用域，執行結束後做用域摧毀。
    var foo = function () {
    var local = {};
}
foo();
複製代碼

    內存回收過程：只被局部變量引用的對象存活週期較短，會被分配在新生代的From空間，在做用域釋放後，局部變量local失效，引用的對象會在下次垃圾回收時被釋放

    • with
    • 全局做用域

標識符查找：

js在執行時回去找該變量在哪裏定義，在當前做用域沒有查到，將會向上級的做用域裏查找，直到查到爲止

做用域鏈：

根據在內部函數能夠訪問外部函數變量的這種機制，用鏈式查找決定哪些數據能被內部函數訪問。

執行環境：

js爲每個執行環境關聯了一個變量對象。環境中定義的全部變量和函數都保存在這個對象中。

變量的主動釋放：

全局變量，直到進程退出才釋放。引用的對象常駐內存（老生代）。

能夠用delete操做和從新賦值（null或者undefined）

  1. 閉包

實現外部做用域訪問內部做用域中變量的方法

做用域中產生的內存佔用不會獲得釋放。除非再也不有引用，纔會逐步釋放

內存指標

進程的內存一部分是rss，其他部分在交換區或者文件系統中

$ node
> process.memoryUsage()
{
    rss:  // 常駐內存
    heapTotal: // 總申請的內存量
    heapUsed:  // 使用中的內存量
}
 
> os.totalmem()  // 總內存
> os.freemem()  // 閒置內存
複製代碼

Buffer對象並不是經過V8分配，沒有堆內存的大小閒置

小結：受V8的垃圾回收限制的主要是V8堆內存

內存泄漏

哪怕一字節的內存泄漏也會形成堆積，垃圾回收過程當中將會耗費更多時間進行對象描述，應用響應緩慢，直到進程內存溢出，應用奔潰

緣由：

  1. 緩存

緩存中存儲的鍵越多，長期存活對象也就越多，常駐在老生代

普通對象無過時策略

var cached = {};
function get (key) {
    if (cached[key]) {
        return cached[key]
    } else {
        
    }
}
function set (key, value) {
    cached[key] = value;
}
複製代碼

解決：

  • 緩存限制策略

    超過數量，先進先出的方式進行淘汰

    設計模塊時，應添加清空隊列的相應接口

  • 緩存的解決方案

    進程間沒法共享內存

    1. 將緩存轉移到外部，減小常駐內存的對象的數量，讓垃圾回收更高效
    2. 進程之間能夠共享緩存
  1. 隊列消費不及時

隊列消費速度低於生產速度，將會造成堆積。而js相關做用域也不會獲得釋放，內存佔用不會回落，從而出現內存泄漏

解決方案：

  • 表層：換用消費速度更高的技術
  • 深度：監控隊列的長度
  • 任意異步調用都應該包含超時機制
  1. 做用域未釋放

大內存應用

node中大多數模塊都有stream應用。因爲V8內存限制，採用流實現對大文件的操做

若是不須要進行字符串層面的操做，則不須要V8來處理，嘗試進行純粹的Buffer操做

Buffer

特色

  1. Buffer 類的實例相似於 整數數組 ，但 Buffer 的大小是固定的、且在 V8 堆外分配物理內存
  2. Buffer 的大小在被建立時肯定，且沒法調整。
  3. 性能相關部分由c++實現，非性能相關由js實現

內存分配

  • 在node的c++層面實現內存的申請，在js中分配內存
  • 使用slab分配機制
    • 預先申請，過後分配
    • slab狀態：
      1. full，徹底分配狀態
      2. partial，沒有分配誒狀態
      3. empty，沒有被分配狀態
    • 同一個slab可能分配給多個buffer對象
    • 分配大Buffer對象，直接由c++層面提供的內存，而無需細膩的分配操做

亂碼

  1. 緩衝器的大小取決於傳遞給流構造函數的 highWaterMark 選項
const fs = require('fs');
var reader = fs.createReadStream('./text.md', {highWaterMark: 11});
var data = ''
reader.on('data', function (chunk) {
	data += chunk
})
reader.on('end', function () {
	console.log(data)
})
複製代碼
  1. buffer對象的長度爲11，可讀流要讀取不少次才能完成完整的讀取
  2. 寬字節字符串可能存在被截斷的狀況。

解決亂碼

  1. 設置編碼
var reader = fs.createReadStream('./text.md', {highWaterMark: 11});
render.setEncoding('utf8')
複製代碼

setEncoding的時候，可讀流對象在內部設置了一個decoder對象。每次data事件都經過該decoder對象進行Buffer到字符串的解碼。

decoder的對象會暫時存儲，buffer讀取的剩餘字節

  1. 將小buffer對象合併
const fs = require('fs');
var reader = fs.createReadStream('./text.md', {highWaterMark: 11});

var chunks = [];
var size = 0;
reader.on('data', function (chunk) {
	chunks.push(chunk);
	size += chunk.length;
})
reader.on('end', function () {
	var buf = Buffer.concat(chunks, size);
	console.log(buf.toString())
})
複製代碼

Buffer與性能

  • 經過預先轉換靜態內容爲Buffer對象，能夠有效地減小cpu的重複使用，節省服務器資源
  • highWaterMark值的大小與讀取速度的關係：該值越大，讀取速度越快

網絡編程

前言

在web領域，大多數的編程語言須要專門的web服務器做爲容器，如ASP、ASP.NET須要IIS做爲服務器，PHP須要打在Apache或Nginx環境等，JSP須要Tomcat服務器等。但對於Node而言，只須要幾行代碼便可構建服務器，無需額外的容器。

構建TCP服務

  • TCP

    • 面向鏈接的協議
    • 建立會話的過程，服務端和客戶端分別提供一個套接字，共同造成鏈接。
    • 若是客戶端要與另外一個TCP服務通訊，須要另建立一個套接字來完成鏈接

  • 建立TCP服務器端

const net = require('net');
let server = net.createServer();
server.on('connection', function (socket) {
    console.log('connection')
}) 
server.listen(8000)
複製代碼
  • TCP服務的事件
    • 服務器事件
      1. listening，在調用server.listen綁定端口或者Domain Socket後出發
      2. connection，每一個客戶端套接字鏈接到服務器端時觸發，簡潔寫法爲經過net.createServer，最後一個參數傳遞
      3. close，當服務器關閉時觸發。server.close後，服務器將中止接受新的套接字鏈接
      4. error，當服務器發生異常時觸發
    • 鏈接事件
      1. data，當一端調用write發送數據時，另外一端會觸發data事件
      2. end，當任意一端發送FIN數據時觸發
      3. connect，用於客戶端，當套接字與服務的鏈接成功時觸發
      4. drain，當任意一端調用write發送數據時，當前這段會觸發者事件
      5. error
      6. close，當套接字徹底關閉時，觸發
      7. timeout，當鏈接被閒置時觸發

構建UDP服務

UDP不是面向鏈接的。

一個套接字能夠與多個UDP服務通訊，它雖然提供面向事務的簡單不可靠信息傳輸服務，在網絡差的狀況下存在丟包嚴重的問題

優勢：無鏈接，資源消耗低，處理快速且靈活

應用：音頻，視頻，dns服務

  • 建立UDP
const dgram = require('dgram');
const server = dgram.createSocket('udp4')
server.on('error', (err) => {
  console.log(`服務器異常：\n${err.stack}`);
  server.close();
});

server.on('message', (msg, rinfo) => {
  console.log(`服務器收到：${msg} 來自 ${rinfo.address}:${rinfo.port}`);
});

server.on('listening', () => {
  const address = server.address();
  console.log(`服務器監聽 ${address.address}:${address.port}`);
});
server.bind(1000)
複製代碼
  • UDP套接字事件
    • message，當UDP套接字偵聽網卡端口後，接收到消息時觸發該事件
    • listening
    • close
    • error

HTTP

特色:

  1. 基於請求響應式，以一問一答的方式實現服務，雖然基於TCP會話，可是自己卻並沒有會話的特色
  2. 瀏覽器，實際上是一個HTTP的代理，用戶的行爲將會經過它轉化爲HTTP請求報文發送給服務端，服務端處理請求後，發送響應報文給代理，代理在解析報文後，將用戶須要的內容呈如今界面上。
  3. TCP服務以connection爲單位進行服務，HTTP服務以request爲單位進行服務。http是將connection到request進行了封裝
  4. 一旦開始了數據發送，writeHead和setHeader將再也不生效。
res.writeHead(()
res.write() // 發送數據
res.end()
複製代碼

  • http服務端事件

    • connection，在http請求前，創建tcp時觸發
    • request，當請求數據發送到服務端，在解析出http請求頭後觸發
    • close，當tcp鏈接斷開
    • checkContinue，和request事件互斥。當客戶端在發送較大數據的時候，並不會將數據直接發送，而是先發送一個頭部帶Expect：100-continue的請求到服務器，這是服務器會觸發checkContinue
    • connect, 當客戶端發起CONNECT請求時觸發，而發起CONNECT請求一般在http代理時出現。
    • upgrade，當客戶端要求升級鏈接的協議時，須要和服務端協商
    • clientError，鏈接的客戶端觸發error事件，傳遞到服務端

  • http客戶端

示例：

var req = http.request(options, function (res) {
    res.setEncoding('utf8');
    res.on('data', function (chunk) {
        console.log（chunk）
    })
})
複製代碼
  • http代理

在keepalive的狀況下，一個底層會話鏈接能夠屢次用於請求。爲了重用tcp鏈接，能夠用http.globalAgent客戶端代理對象

默認狀況下，經過ClientRequest對象對同一個服務器發起的http請求最多能夠建立五個鏈接

如需改變，可在options中傳遞agent選項

var agent = new http.Agent({
    maxSockets: 10
})
var options = {
    hostname： '127.0.0.1',
    port: 1334,
    path: '/',
    method: 'GET',
    agent： agent
}
複製代碼
  • http客戶端事件
    • response：客戶端在請求後獲得服務端響應時觸發
    • socket：當底層鏈接池中創建的鏈接分配給當前請求對象時觸發
    • connect: 當客戶端向瀏覽器發起CONNECT請求時，若是服務器端響應了200狀態碼，客戶端會觸發該事件
    • upgrade，客戶端向服務器發起upgrade請求時，若是服務端響應了101 switching protocol狀態
    • continue，客戶端向服務端發起Expect：100-continue以試圖發送大數據量

websocket服務

特色：

  1. 基於事件編程模型（事件驅動）
  2. 長鏈接
  3. 更接近於傳輸層協議，分爲握手（由http完成）和數據傳輸兩部分

好處:

  1. 客戶端與服務端只創建一個TCP鏈接，可使用更少的鏈接
  2. websocket服務端能夠推送數據到客戶端，比http請求響應模式更靈活，更高效
  3. 更輕量級的協議頭，減小數據傳送量

構建過程

  1. 握手
  2. 數據傳輸

握手完成後，再也不進行http交互，客戶端的onopen將會觸發執行

當客戶端調用send發送數據時，服務端觸發onmessage事件；當服務端調用send發送數據時，客戶端觸發message事件。

當send發送一條數據時，協議可能將這個數據封裝爲一幀或多幀數據，而後逐幀發送

網絡安全

  1. tls/ssl

交換公鑰過程當中，可能遇到中間人攻擊，因此應引入數字證書來認證。

建立私鑰：

openssl genrsa -out ryans-key.pem 2048

生成csr

openssl req -new -sha256 -key ryans-key.pem -out ryans-csr.pem

生成自簽名證書

openssl x509 -req -in ryans-csr.pem -signkey ryans-key.pem -out ryans-cert.pem

驗證:

const https = require('https');
const fs = require('fs');
const options = {
	key: fs.readFileSync('./ryans-key.pem'),
	cert: fs.readFileSync('./ryans-cert.pem')
}
https.createServer(options, function (req, res) {
	res.writeHead(200);
	res.end('hello world')
}).listen(2000)
複製代碼

-k忽略掉證書的驗證

curl -k https://localhost:2000

構建web應用

基礎功能

請求方法

HTTP_Parser在解析請求報文的時候，將報文頭抽取出來，設置爲req.method。有諸如：GET, POST, HEAD, PUT, DELETE, OPTIONS, TRACE, CONNECT

路徑解析

路徑部分存在於報文的第一行的第二部分，如：

GET /path?foo=bar HTTP/1.1

HTTP_Parser將其解析爲req.url, 通常而言，完整的url地址以下

http://user:pass@host.com:8080/p/a/t/h?query=string#hash

這裏hash部分會被丟棄，不會存在於報文的任何地方, 下列的url對象不是報文中的，故有hash

解析出來的url對象

Url {
  protocol: 'https:',
  slashes: true,
  auth: 'user:pass',
  host: 'sub.host.com:8080',
  port: '8080',
  hostname: 'sub.host.com',
  hash: '#hash',
  search: '?query=string',
  query: 'query=string',
  pathname: '/p/a/t/h',
  path: '/p/a/t/h?query=string',
  href: 'https://user:pass@sub.host.com:8080/p/a/t/h?query=string#hash' }
複製代碼

查詢字符串

查詢字符串，若是鍵出現屢次，那麼它的值會是一個數組

foo=bar&foo=baz
複製代碼
var query = url.parse(req.url, true).query;
{
    foo: ['bar', 'baz']
}
複製代碼

cookie

cookie處理：

  1. 服務器向客戶端發送cookie
  2. 瀏覽器將cookie保存
  3. 以後每次瀏覽器都會將cookie發向服務器端

Set-Cookie: name=vale; Path=/;Expires=Sun, 23-Apr-23 09:01:35 GMT; Domain=.domain.com;

path表示cookie影響路徑，表示服務器目錄下的子html都能訪問

expires和max-age表示過時時間，一個是絕對時間，一個是相對時間

httpOnly告知瀏覽器不能經過document.cookie獲取

secure爲true表示在https纔有效

domain:子域名訪問父域名

**性能影響：**大多數cookie並不須要每次都用上，由於這會形成帶寬的部分浪費

解決:

  1. 減小cookie體積，設置path和domain
  2. 爲不須要cookie的組件換個域名
  3. 減小dns查詢

session

session的數據只保留在服務器端，客戶端沒法修改。

應用：

  1. 基於cookie來實現用戶和數據的映射

將口令放在cookie中，口令一旦被褚昂愛，就丟失映射關係。一般session的有效期一般短，過時就將數據刪除

一旦服務器檢查到用戶請求cookie中沒有攜帶session_id，它會爲之生成一個值，這個值是惟一且不重複的值，並設定超時時間。若是過時就從新生成，若是沒有過時，就更新超時時間

var sessions = {};
var key = 'session_id';
var EXPIRES = 20*60*1000;
var generate  = function () {
	var session = {};
	session.id = (new Date().getTime()) + Math.random();
	session.cookie = {
		expire: (new Date()).getTime() + EXPIRES
	}
	sessions[session.id] = session
}

function (req, res) {
	var id = req.cookies[key];
	if (!id) {
		req.session = generate();
	} else {
		var session = sessions[id];
		if (session) {
			if (session.cookie.expire > new Date().getTime()) {
				session.cookie.expire = new Date().getTime() + EXPIRES;
				req.session = session;
			} else {
				delete sessions[id];
				req.session = generate();
			}
		} else {
			req.session = generate();
		}
	}
}
複製代碼
  1. 經過檢查字符串來實現瀏覽器端和服務器端數據的對應

原理：檢查查詢字符串，若是沒有值，會生成新的帶值的url

var getURL = function (_url, key, value) {
	var obj = url.parse(_url, true);
	obj.query[key] = value;
	return url.format(obj);
}

function (req, res) {
	var redirect = function (url) {
		res.setHeader('Location', url);
		res.writeHead(302);
		res.end();
	}
	var id = req.query[key];
	if (!id) {
		var session = generate();
		redirect(getURL(req.url), key, session.id);
	} else {
		var session = sessions[id];
		if (session) {
			if (session.cookie.expire > new Date().getTime()) {
				session.cookie.expire = new Date().getTime() + EXPIRES;
				req.session = session;
				handle(req, res);
			} else {
				delete sessions[id];
				var session = generate();
				redirect(getURL(req.url), key, session.id)
			}
		} else {
			var session = generate();
			redirect(getURL(req.url), key, session.id)
		}
	}
}
複製代碼

隱患

因爲session存儲在sessions對象中，故在內存中，若數據量加大，會引發垃圾回收的頻繁掃描，引發性能問題。

爲了利用多核cpu而啓動多個進程，用戶請求的鏈接將可能隨意分配到各個進程中，node的進程與進程之間不能直接共享內存，用戶的session可能會引發錯亂

解決方案

將session集中化，將可能分散在多個進程裏的數據，統一轉移到集中數據存儲中。目前經常使用工具是redis，memcached。node無需在內部維護數據對象。

問題: 會引發網絡訪問

session與安全

  1. 將口令經過私鑰加密，使得僞造的成本較高

緩存

  1. 添加expires或者cache-control到報文頭中
  2. 配置etags
  3. 讓ajax可緩存

設置last-modified

var handle = function (req, res) {
	fs.stat(filename, function (err, stat) {
		var lastModified = stat.mtime.toUTCString();
		if (lastModified === req.headers['if-modified-since']) {
			res.writeHead(304, 'Not Modified');
			res.end()
		} else {
			fs.readFile(filename, function (err, file) {
				var lastModified = stat.mtime.toUTCString();
				res.setHeader('Last-modified', lastModified);
				res.writeHead(200, 'ok');
				res.end(file);
			})
		}
	})
}
複製代碼

缺陷：

  1. 文件的時間戳改動但內容不必定改動
  2. 時間戳只能精確到秒級別

設置etag

var getHash = function (str) {
	var shasum = crypto.createHash('sha1');
	return shasum.update(str).digest('base64');
}

var handle = function (req, res) {
	fs.readFile(filename, function (err, file) {
		var hash = getHash(file);
		var noneMatch = req['if-none-match'];
		if (hash === noneMath) {
			res.writeHead(304, "Not Modified");
			res.end()
		} else {	
			res.setHeader("ETag", hash);
			res.writeHead(200, "ok");
			res.end(file);
		}
	})
}
複製代碼

強制緩存

var handle = function (req, res) {
	fs.readFile(filename, function (err, file) {
		res.setHeader("Cache-Control", "max-age=" + 10*365*24*60*60*1000);
		res.writeHead(200, "ok");
		res.end(file);
	})
}
複製代碼

用expires可能致使瀏覽器端與服務器端時間不一樣步帶來的不一致性問題

清除緩存

瀏覽器是根據url進行緩存，那麼一旦內容有所更新時，咱們就讓瀏覽器發起新的url請求，使得新內容可以被客戶端更新。

數據上傳

var hasBody = function (req) {
	return 'transfer-encoding' in req.headers || 'content-length' in req.headers;
}

function (req, res) {
	if (hasBody(req)) {
		var buffers = [];
		req.on('data', functino (chunk) {
			buffers.push(chunk);
		})
		req.on('end', function () {
			req.rawBody = Buffer.concat(buffers).toString(); // 拼接buffer
			handle(req, res);
		})
	} else {
		handle(req, res);
	}
}
複製代碼

處理json格式

// application/json;charset=utf-8;
var mime = function (req) {
	var str = req.headers['content-type'] || '';
	return str.split(';')[0]
}

var handle = function (req, res) {
	if (mime(req) === 'application/json') {
		try {
			req.body = JSON.parse(req.rawBody);
		} catch(e) {
			res.writeHead(400);
			res.end("Invalid JSON");
			return 
		}
	}
	todo(req, res)
}
複製代碼

處理xml文件

var xml2js = require('xml2.js');
var handle = function (req, res) {
	if (mime(req) === 'appliction/xml') {
		xml2js.parseString(req.rawBody, function (err, xml) {
			if (err) {
				res.writeHead(400);
				res.end('Invalid XML');
				return;
			}
			req.body = xml;
			todo(req, res);
		})
	}
}
複製代碼

圖片上傳

var formidable = require('formidable'),
    http = require('http'),
    util = require('util'),
    fs = require('fs');

http.createServer(function(req, res) {
  if (req.url == '/upload' && req.method.toLowerCase() == 'post') {
    // parse a file upload
    var form = new formidable.IncomingForm();
    form.parse(req, function(err, fields, files) {
    	fs.renameSync(files.upload.path,"./tmp/text.jpeg"); // 另存圖片
		res.writeHead(200, {'content-type': 'text/plain'});
		res.write('received upload:\n\n');
		res.end(util.inspect({fields: fields, files: files}));
    });

    return;
  }

  if (req.url == '/')

  // show a file upload form
  res.writeHead(200, {'content-type': 'text/html'});
  res.end(
    '<form action="/upload" enctype="multipart/form-data" method="post">'+
    '<input type="text" name="title"><br>'+
    '<input type="file" name="upload" multiple="multiple"><br>'+
    '<input type="submit" value="Upload">'+
    '</form>'
  );
}).listen(8080);
複製代碼

數據上傳與安全

  1. 內存限制

在解析表單，json和xml部分，咱們採起的策略是先保存用戶提交的全部數據，而後再解析處理，最後才傳遞給業務邏輯。

弊端：數據量大，佔內存

解決方案：

  1. 限制上傳內容的大小，一旦超過限制中止接收數據，並相應400狀態碼
  2. 經過流式解析，將數據導向到磁盤中，node只保存文件路徑等小數據

限制大小方案代碼：

var bytes = 1024;
function (req, res) {
	var received = 0;
	var len = req.headers['content-length'] ? parseInt(req.headers['content-length'], 10) : null;
	if (len && len > bytes) {
		res.writeHead(413);
		res.end();
		return;
	}

	req.on('data', function (chunk) {
		received += chunk.length;
		if (received > bytes) {
			req.destroy();
		}
	})
	handle(req, res);
}
複製代碼
  1. csrf
var generateRandom = function (len) {
	return crypto.randomBytes(Math.ceil(len*3/4)).toString('base64').slice(0, len);
}

var token = req.session._csrf || (req.session._crsf = generateRandom(24));

// 作頁面渲染的時候服務器端渲染這個_csrf
複製代碼
function (req, res) {
    var token = req.session._csrf || (req.session._csrf = generateRandom(24));
    var _csrf = req.body._csrf;
    if (token !== _csrf) {
        res.writeHead(413);
        res.end("禁止訪問");
    } else {
        handle(req, res);
    }
    
}
複製代碼

路由解析

文件路徑型

  1. 靜態文件，其url的路徑與網站目錄的路徑一致，無需轉換。
  2. 動態文件，根據路徑執行動態腳本，原理: web服務器根據url路徑找到對應的文件，如index.asp或者index.php。根據後綴尋找腳本的解析器，並傳入http請求的上下文。然而node中無需按這種方式

mvc工做模式

  1. 路由解析，根據url尋找到對應的控制器和行爲
  2. 行爲調用相關的模型，進行數據操做
  3. 數據操做結束後，調用視圖和相關數據進行頁面渲染，輸出到客戶端

手工映射

自由映射，從入口程序中判斷url，而後執行對應的邏輯。

匹配的時候，可以正則匹配

天然映射

/controller/action/param1/param2/param3

按約定去找controllers目錄下的user文件，將其require出來，調用這個文件模塊的setting方法，其他的參數直接傳遞到這個方法中

RESTful(representational state transfer)

須要區分請求方法

一個地址表明了一個資源，對這個資源的操做，主要體如今http請求方法上，不是體如今url上

設計：

POST,GET,PUT,DELETE

POST /user/add?username=jack
GET /user/remove？username=jack
複製代碼

中間件

含義:指底層封裝細節，爲上層提供更方便服務的意義，爲咱們封裝全部http請求細節處理的中間件

中間件性能

  1. 編寫高效的中間件

緩存須要重複計算的結果，避免沒必要要的計算。

  1. 合理使用路由，是的沒必要要的中間件不參與請求處理過程

頁面渲染

內容響應

響應頭中的content-*字段十分重要。

示例

Content-Encoding:gzip
Content-Length:21170
Content-Type:text/javascript;charfset=utf-8
複製代碼

客戶端在接收到後，經過gzip來解碼報文體重的內容，用長度校驗報文體內容是否正確，而後在以字符集utf-8將解碼後的腳本插入到文檔節點中

  1. MIME

application/json, application/xml, application/pdf

  1. 附件下載

背景：不管響應的內容是什麼MIME，只須要彈出並下載它

Content-Disposition

判斷是應該將報文數據當作及時瀏覽的內容，仍是可下載的附件。

inline // 內容只需查看
attachment // 數據能夠存爲附件
複製代碼

還能指定保存時使用的文件名

Content-Disposition:attachment;filename="filename.txt"

響應附件api

res.sendfile = (filepath) => {
	fs.stat(filepath, (err, stat) => {
		let stream = fs.createReadStream(filepath);
		res.setHeader("Content-Type", mime.lookup(filepath));
		res.setHeader("Content-length", stat.size);
		res.setHeader("Content-Disposition", 'attachment;filename="'+ path.basename(filepath) +'"')
		res.writeHead(200);
		stream.pipe(res);
	})
}
複製代碼
  1. 響應json
res.json = function (json) {
    res.setHeader("Content-Type", "application/json");
    res.writeHead(200);
    res.end(JSON.stringify(json))
}
複製代碼
  1. 響應跳轉
res.redirect = function (url) {
    res.setHeader('Location', url);
    res.writeHead(200);
    res.end('redirect to' + url)
}
複製代碼

視圖渲染

res.render = function (view, data) {
    res.setHeader("Content-Type", "text/html");
    res.writeHead(200);
    var html = render(view, data);
    res.end(html)
}
複製代碼

模板要素：

  1. 模板語言
  2. 包含模板語言的模板文件
  3. 擁有動態數據的數據對象
  4. 模板引擎
    1. 語法分解
    2. 處理表達式
    3. 生成待執行的語句
    4. 與數據一塊兒執行，生成最終字符串
  5. 模板安全，防止xss，就是轉譯
function render (str, data) {
    var tpl = str.replace(/<%=([\s\S]+?)%>/g, function (match, code) {
        return "' + obj." + code + "+ '";
    })
    tpl = "var tpl = '" + tpl + "'\nreturn tpl;";
    var compiled = new Function('obj', tpl);
    return compiled(data);
}
複製代碼

集成文件系統

fs.readFile('file/path', 'utf8', function (err, txt) {
    if(err) {
        res.writeHead(500, {'Content-Type': 'text/html'});
        res.end('模板文件錯誤');
        return;
    }
    res.writeHead(200, {"Content-Type": "text/html"});
    var html = render(compile(text), data);
    res.end(html);
})
複製代碼

這樣作每次都須要讀取模板文件，所以可設置cache={}

模板性能

  1. 緩存模板文件
  2. 緩存文件編譯後的函數

進程

一個進程只能利用一個核，如何充分利用多核cpu服務器

單線程上拋出的異常沒有被捕獲，如何保證進程的健壯性和穩定性

石器時代：同步

一次只爲一個請求服務

青銅時代：複製進程

經過進程的賦值同時服務更多的請求和用戶。進程賦值會致使內存浪費

白銀時代：多線程

一個線程服務一個請求，線程相對於進程的開銷要小，線程之間能夠共享數據，內存浪費問題獲得解決

可是線程上線文切換會產生時間消耗

黃金時代：事件驅動

解決高併發問題

單線程避免沒必要要的內存開銷和上下文切換

php爲每一個請求都簡歷獨立的上下文

多線程架構

master.js實現進程的複製

let fork = require('child_process').fork;

let cpus = require('os').cpus();

for (let i = 0; i < cpus.length; i++) {
	fork('./worker.js');
}
複製代碼

worker.js

const http = require('http');
http.createServer((req, res) => {
	res.writeHead(200, {"Content-Type": "text/plain"});
	res.end('hello')
}).listen(parseInt(Math.random()*10000), '127.0.0.1')
複製代碼

ps aux | grep worker.js查看進程的數量

lejunjie          3306   0.0  0.0  4267752    868 s001  S+   11:18上午   0:00.00 grep worker.js
lejunjie          3171   0.0  0.3  4893888  21656 s000  S+   11:18上午   0:00.13 /Users/lejunjie/.nvm/versions/node/v8.11.1/bin/node ./worker.js
lejunjie          3170   0.0  0.3  4893888  21632 s000  S+   11:18上午   0:00.13 /Users/lejunjie/.nvm/versions/node/v8.11.1/bin/node ./worker.js
lejunjie          3169   0.0  0.3  4893888  21708 s000  S+   11:18上午   0:00.13 /Users/lejunjie/.nvm/versions/node/v8.11.1/bin/node ./worker.js
lejunjie          3168   0.0  0.3  4893888  21664 s000  S+   11:18上午   0:00.13 /Users/lejunjie/.nvm/versions/node/v8.11.1/bin/node ./worker.js
複製代碼

經過fork複製的進程都是一個獨立的進程，啓動多個進程只是爲了充分將cpu資源利用起來，而不是爲了解決併發問題

建立子進程

  1. spawn，啓動一個子進程來執行命令

cp.spawn('node', ['worker.js']);

  1. exec,情動一個子進程來執行命令

sp.exec('node worker.js', () => {})

  1. execFile

啓動一個子進程來執行可執行文件

  1. fork

建立node子進程只須要指定要執行的javascript文件模塊

進程間通訊

主線程與工做線程之間經過onmessage和postMessage進行通訊，子進程對象則由send方法實現主進程向子進程發送數據

parent.js

var cp = require('child_process');

var n = cp.fork('./child.js');
n.on('message', function (data) {
	console.log('parent data: ' + data.name);
})
n.send({name: 'parent'})
複製代碼

child.js

process.on('message', function (data) {
	console.log('child: ' + data.name);
})
process.send({name: 'child'})
複製代碼

結果

child: parent
parent data: child
複製代碼

ipc進程間通訊（inter-process communication）

node中實現ipc通道的是管道技術，具體由libuv提供

父進程在實際建立子進程以前，會建立ipc通道並監聽它，而後才真正建立子進程，並經過環境變量告訴子進程這個ipc通道的文件描述符。

雙向通訊，在系統內核中完成通訊，不用通過實際的網絡層

句柄傳送

多個進程監聽經過端口會拋出EADDRINUSE異常，這是端口被佔用的狀況。能夠經過代理，在代理進程上作適當的負載均衡，使得每一個子進程能夠較爲均衡地執行任務。可是代理進程鏈接到工做進程的過程須要用掉兩個文件描述符

句柄是一種能夠用來標識資源的應用，他的內部包含了只想對象的文件描述符。好比句柄能夠用來表示一個服務器端socket對象，一個客戶端socket對象，一個udp套接字，一個管道等。

發送句柄使得主進程接收到socket請求後，將這個socket直接發給工做進程，而不是從新與工做進程之間創建新的socket鏈接來轉發數據。解決文件描述符的浪費問題

parent.js

const cp = require('child_process');
var child1 = cp.fork('./child.js');
var child2 = cp.fork('./child.js');

var server = require('net').createServer();
server.on('connection', (socket) => {
	socket.end('handled by parent');
})
server.listen(1338, () => {
	child1.send('server', server);
	child2.send('server', server);
})
複製代碼

child.js

process.on('message', (m, server) => {
	if (m === 'server') {
		server.on('connection', function (socket) {
			socket.end('handled by child , pid is' + process.pid);
		})
	}
})
複製代碼

讓請求都由子進程處理

parent

const cp = require('child_process');
var child1 = cp.fork('./child.js');
var child2 = cp.fork('./child.js');

var server = require('net').createServer();
server.on('connection', (socket) => {
	socket.end('handled by parent');
})
server.listen(1338, () => {
	child1.send('server', server);
	child2.send('server', server);
	server.close();
})
複製代碼

child

var http = require('http');
var server = http.createServer((req, res) => {
	res.writeHead(200, {"Content-Type": "text/plain"});
	res.end("handled by child, pid is" + process.pid);
})
process.on('message', (m, tcp) => {
	if (m === 'server') {
		tcp.on('connection', function (socket) {
			server.emit('connection', socket);
		})
	}
})
複製代碼

多個子進程能夠同時監聽相同端口，再沒有EADDRINUSE異常發生

總結：

  1. 發送到ipc管道的實際是要發送的句柄文件描述符
  2. 鏈接了ipc通道的子進程能夠讀取到父進程發來的消息，將字符串還原成對象，纔出發message時間將消息體傳遞給應用層使用
  3. 並不是任意類型的句柄都能在進程之間傳遞，除非有完整的發送和還原的過程
  4. 多個進程監聽同個端口不引發EADDRINUSE異常的緣由

獨立啓動的進程中，tcp服務器端socket套接字的文件描述符並不相同，致使監聽到相同的端口時會拋出異常

多個應用監聽相同端口時，文件描述符同一時間只能被某一個進程所用，因此是搶佔式的

進程事件

  1. error，當子進程沒法被複制建立，沒法被殺死，沒法發送消息時觸發
  2. exit，子進程退出時觸發
  3. close，在子進程的標準輸入輸出終止時觸發該事件
  4. disconnect，在父進程或子進程中調用disconnect方法時觸發

自動重啓

進程退出時，讓全部工做進程退出。子進程退出時從新create

const cp = require('child_process');

var server = require('net').createServer();

var cpus = require('os').cpus();
var workers = {};
function create () {
	var worker = cp.fork('./child.js');
	worker.on('exit', function () {
		console.log('worker: ' + worker.pid + 'exited');
	})
	worker.send('server', server);
	workers[worker.pid] = worker;
	console.log('create worker pid: ' + worker.pid);
}
for (var i = 0; i < cpus.length; i++) {
	create();
}

process.on('exit', function () {
	for (var pid in workers) {
		workers[pid].kill();
	}
})
複製代碼

在極端狀況下，全部工做進程都中止接受新的鏈接，全出在等待退出的狀態。但在等進程徹底退出才重啓的過程當中，全部新來的請求可能存在沒有工做進程爲新用戶服務的情景，這會丟掉大部分請求

所以可在子進程中監聽uncaughtException，而後發送自殺信號

process.on('uncaughtException', function (err) {
    process.send({act: 'suicide'});
    worker.close(function () {
        process.exit(1);
    })
})
複製代碼

負載均衡

node默認提供的機制是採用操做系統的搶佔式策略。

新的策略是輪叫調度。工做方式是由主進程接受鏈接，將其一次分發給工做進程。

狀態共享

在多個進程之間共享數據

  1. 第三方數據存儲

實現同步：子進程向第三方進行定時輪訓

  1. 主動通知

主動通知子進程，輪訓。

cluster模塊

要建立單機node集羣，因爲有許多細節須要處理，因而引入cluster，解決多核cpu的利用率問題

const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
  console.log(`主進程 ${process.pid} 正在運行`);

  // 衍生工做進程。
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
  cluster.on('listening', () => {
    console.log('listening')
  })
  cluster.on('exit', (worker, code, signal) => {
    console.log(`工做進程 ${worker.process.pid} 已退出`);
  });
} else {
  // 工做進程能夠共享任何 TCP 鏈接。
  // 在本例子中，共享的是一個 HTTP 服務器。
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end('你好世界\n');
  }).listen(8000);
  console.log(`工做進程 ${process.pid} 已啓動`);
}
process.on('exit', () => {
  console.log('exit')
})
複製代碼

原理：cluster模塊就是child_process和net模塊的組合應用。在fork子進程時，將socket的文件描述符發送給工做進程。經過so_reuseaddr端口重用，從而實現多個子進程共享端口。

產品化

項目工程化

項目的組織能力

  1. 目錄結構
  2. 構建工具
  3. 編碼規範
  4. 代碼審查

部署流程

代碼流程--》stage普通測試環境--》pre-release預發佈環境--》product實際生產環境

部署操做

node file.js以啓動應用，會站住一個命令行窗口，窗口退出進程也退出

nohup node app.js & 不掛斷進程的方式

bash腳本， 解決進程id不容易查找的問題。重啓，中斷，啓動

性能

動靜分離：

讓node只處理動態請求，將靜態文件引導到專業的靜態文件服務器。用nginx或者專業的cdn來處理

cdn緩存，將文件放在離用戶儘量近的服務器

對靜態請求使用不一樣的域名或者多個域名還能消除掉沒必要要的cookie傳輸和瀏覽器對下載線程數的限制

啓用緩存

提高服務速度，避免沒必要要的計算

多進程架構

讀寫分離

對數據庫進行主從設計，這樣讀取數據操做再也不受到寫入的影響，下降了性能的影響。

日誌

寫到磁盤上

數據庫寫入要經歷鎖表，日誌等操做，若是大量訪問會排隊，進而內存泄露。

  1. 訪問日誌
  2. 異常日誌

監控報警

監控

  1. 日誌監控

經過監控異常日誌文件的變更，將新增的異常按異常類型和數量反應出來。

監控訪問日誌，體現業務qps值，pv/uv，預知訪問高峯

  1. 響應時間

在nginx類的反向代理上監控

經過應用自行產生的訪問日誌來監控

  1. 進程監控

檢查操做系統中運行的應用進程數，對於採用多進程架構的web應用，就須要檢查工做進程的數量，若是低於預估值，就應當發出報警

  1. 磁盤監控

監控磁盤的用量，設置警惕值

  1. 內存監控

健康的內存是有升有降的

  1. cpu佔用監控

cpu分爲內核態，用戶態，iowait等。

用戶態佔用高: 服務器上應用大量cpu開銷

內核態佔用高：服務器花費大量時間進程調度或者系統調用。

  1. cpu load監控（cpu平均負載）

描述操做系統當前的繁忙程度

指標太高，在node中可能體如今用子進程模塊反覆啓動新的進程

  1. i/o負載

反應磁盤讀寫狀況

  1. 網絡監控

流入流量和流出流量

  1. 應用狀態監控

  2. dns監控

報警的實現

  1. 郵件報警
  2. 短信報警
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程