日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側工具欄

新聞中心

這里有您想知道的互聯網營銷解決方案
Node.js服務性能翻倍的秘密（一）

前言

網站建設哪家好，找成都創(chuàng)新互聯公司！專注于網頁設計、網站建設、微信開發(fā)、微信小程序定制開發(fā)、集團企業(yè)網站建設等服務項目。為回饋新老客戶創(chuàng)新互聯還提供了安順免費建站歡迎大家使用！

用過 Node.js 開發(fā)過的同學肯定都上手過 koa，因為他簡單優(yōu)雅的寫法，再加上豐富的社區(qū)生態(tài)，而且現存的許多 Node.js 框架都是基于 koa 進行二次封裝的。但是說到性能，就不得不提到一個老牌框架：fastify ，聽名字就知道它的特性就是快，官方給出的Benchmarks甚至比 Node.js 原生的 http.Server 還要快。

Benchmarks

性能提升的關鍵

我們先看看 fastify 是如何啟動一個服務的。

 
 
 
 
    
  
  
  
  
  1. # 安裝 fastify
    2. 
  
  
  
  
  2. npm i -S fastify@3.9.1
    3. 
 
 
 
 

 
 
 
 
    
  
  
  
  
  1. // 創(chuàng)建服務實例
    2. 
  
  
  
  
  2. const fastify = require('fastify')()
    3. 
  
  
  
  
  3. 
  
  
  
  
  4. app.get('/', {
    5. 
  
  
  
  
  5.   schema: {
    6. 
  
  
  
  
  6.     response: {
    7. 
  
  
  
  
  7.       // key 為響應狀態(tài)碼
    8. 
  
  
  
  
  8.       '200': {
    9. 
  
  
  
  
  9.         type: 'object',
    10. 
  
  
  
  
  10.         properties: {
    11. 
  
  
  
  
  11.           hello: { type: 'string' }
    12. 
  
  
  
  
  12.         }
    13. 
  
  
  
  
  13.       }
    14. 
  
  
  
  
  14.     }
    15. 
  
  
  
  
  15.   }
    16. 
  
  
  
  
  16. }, async () => {
    17. 
  
  
  
  
  17.   return { hello: 'world' }
    18. 
  
  
  
  
  18. })
    19. 
  
  
  
  
  19. 
  
  
  
  
  20. // 啟動服務
    21. 
  
  
  
  
  21. ;(async () => {
    22. 
  
  
  
  
  22.   try {
    23. 
  
  
  
  
  23.     const port = 3001 // 監(jiān)聽端口
    24. 
  
  
  
  
  24.     await app.listen(port)
    25. 
  
  
  
  
  25.     console.info(`server listening on ${port}`)
    26. 
  
  
  
  
  26.   } catch (err) {
    27. 
  
  
  
  
  27.     console.error(err)
    28. 
  
  
  
  
  28.     process.exit(1)
    29. 
  
  
  
  
  29.   }
    30. 
  
  
  
  
  30. })()
    31.

從上面代碼可以看出，fastify 對請求的響應體定義了一個 schema，fastify 除了可以定義響應體的 schema，還支持對如下數據定義 schema：

  1. body：當為 POST 或 PUT 方法時，校驗請求主體;
  2. query：校驗 url 的 查詢參數;
  3. params：校驗 url 參數;
  4. response：過濾并生成用于響應體的 schema。
 
 
 
 
    
  
  
  
  
  1. app.post('/user/:id', {
    2. 
  
  
  
  
  2.   schema: {
    3. 
  
  
  
  
  3.     params: {
    4. 
  
  
  
  
  4.       type: 'object',
    5. 
  
  
  
  
  5.       properties: {
    6. 
  
  
  
  
  6.        id: { type: 'number' }
    7. 
  
  
  
  
  7.       }
    8. 
  
  
  
  
  8.     },
    9. 
  
  
  
  
  9.     response: {
    10. 
  
  
  
  
  10.       // 2xx 表示 200~299 的狀態(tài)都適用此 schema
    11. 
  
  
  
  
  11.       '2xx': {
    12. 
  
  
  
  
  12.         type: 'object',
    13. 
  
  
  
  
  13.         properties: {
    14. 
  
  
  
  
  14.           id: { type: 'number' },
    15. 
  
  
  
  
  15.           name: { type: 'string' }
    16. 
  
  
  
  
  16.         }
    17. 
  
  
  
  
  17.       }
    18. 
  
  
  
  
  18.     }
    19. 
  
  
  
  
  19.   }
    20. 
  
  
  
  
  20. }, async (req) => {
    21. 
  
  
  
  
  21.   const id = req.params.id
    22. 
  
  
  
  
  22.   const userInfo = await User.findById(id)
    23. 
  
  
  
  
  23.   // Content-Type 默認為 application/json
    24. 
  
  
  
  
  24.   return userInfo
    25. 
  
  
  
  
  25. })
    26.

讓 fastify 性能提升的的秘訣在于，其返回 application/json 類型數據的時候，并沒有使用原生的 JSON.stringify，而是自己內部重新實現了一套 JSON 序列化的方法，這個 schema 就是 JSON 序列化性能翻倍的關鍵。

如何對 JSON 序列化

在探索 fastify 如何對 JSON 數據序列化之前，我們先看看 JSON.stringify 需要經過多么繁瑣的步驟，這里我們參考 Douglas Crockford (JSON 格式的創(chuàng)建者)開源的 JSON-js 中實現的 stringify 方法。

“JSON-js：https://github.com/douglascrockford/JSON-js/blob/master/json2.js

 
 
 
 
    
  
  
  
  
  1. // 只展示 JSON.stringify 核心代碼，其他代碼有所省略
    2. 
  
  
  
  
  2. if (typeof JSON !== "object") {
    3. 
  
  
  
  
  3.   JSON = {};
    4. 
  
  
  
  
  4. }
    5. 
  
  
  
  
  5. JSON.stringify = function (value) {
    6. 
  
  
  
  
  6.   return str("", {"": value})
    7. 
  
  
  
  
  7. }
    8. 
  
  
  
  
  8. function str(key, holder) {
    9. 
  
  
  
  
  9.   var value = holder[key];
    10. 
  
  
  
  
  10.   switch(typeof value) {
    11. 
  
  
  
  
  11.     case "string":
    12. 
  
  
  
  
  12.       return quote(value);
    13. 
  
  
  
  
  13.     case "number":
    14. 
  
  
  
  
  14.       return (isFinite(value)) ? String(value) : "null";
    15. 
  
  
  
  
  15.     case "boolean":
    16. 
  
  
  
  
  16.     case "null":
    17. 
  
  
  
  
  17.       return String(value);
    18. 
  
  
  
  
  18.     case "object":
    19. 
  
  
  
  
  19.       if (!value) {
    20. 
  
  
  
  
  20.         return "null";
    21. 
  
  
  
  
  21.       }
    22. 
  
  
  
  
  22.       partial = [];
    23. 
  
  
  
  
  23.       if (Object.prototype.toString.apply(value) === "[object Array]") {
    24. 
  
  
  
  
  24.         // 處理數組
    25. 
  
  
  
  
  25.         length = value.length;
    26. 
  
  
  
  
  26.         for (i = 0; i < length; i += 1) {
    27. 
  
  
  
  
  27.           // 每個元素都需要單獨處理
    28. 
  
  
  
  
  28.           partial[i] = str(i, value) || "null";
    29. 
  
  
  
  
  29.         }
    30. 
  
  
  
  
  30.         // 將 partial 轉成 ”[...]“
    31. 
  
  
  
  
  31.         v = partial.length === 0
    32. 
  
  
  
  
  32.           ? "[]"
    33. 
  
  
  
  
  33.           : "[" + partial.join(",") + "]";
    34. 
  
  
  
  
  34.         return v;
    35. 
  
  
  
  
  35.       } else {
    36. 
  
  
  
  
  36.         // 處理對象
    37. 
  
  
  
  
  37.         for (k in value) {
    38. 
  
  
  
  
  38.           if (Object.prototype.hasOwnProperty.call(value, k)) {
    39. 
  
  
  
  
  39.             v = str(k, value);
    40. 
  
  
  
  
  40.             if (v) {
    41. 
  
  
  
  
  41.               partial.push(quote(k) + ":" + v);
    42. 
  
  
  
  
  42.             }
    43. 
  
  
  
  
  43.           }
    44. 
  
  
  
  
  44.         }
    45. 
  
  
  
  
  45.         // 將 partial 轉成 "{...}"
    46. 
  
  
  
  
  46.         v = partial.length === 0
    47. 
  
  
  
  
  47.           ? "{}"
    48. 
  
  
  
  
  48.          : "{" + partial.join(",") + "}";
    49. 
  
  
  
  
  49.         return v;
    50. 
  
  
  
  
  50.       }
    51. 
  
  
  
  
  51.   }
    52. 
  
  
  
  
  52. }
    53.

從上面的代碼可以看出，進行 JSON 對象序列化時，需要遍歷所有的數組與對象，逐一進行類型的判斷，并對所有的 key 加上 ""，而且這里還不包括一些特殊字符的 encode 操作。但是，如果有了 schema 之后，這些情況會變得簡單很多。fastify 官方將 JSON 的序列化單獨成了一個倉庫：fast-json-stringify，后期還引入了 ajv 來進行校驗，這里為了更容易看懂代碼，選擇看比較早期的版本：0.1.0，邏輯比較簡單，便于理解。

“fast-json-stringify@0.1.0：https://github.com/fastify/fast-json-stringify/blob/v0.1.0/index.js

 
 
 
 
    
  
  
  
  
  1. function $Null (i) {
    2. 
  
  
  
  
  2.   return 'null'
    3. 
  
  
  
  
  3. }
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. function $Number (i) {
    6. 
  
  
  
  
  6.   var num = Number(i)
    7. 
  
  
  
  
  7.   if (isNaN(num)) {
    8. 
  
  
  
  
  8.     return 'null'
    9. 
  
  
  
  
  9.   } else {
    10. 
  
  
  
  
  10.     return String(num)
    11. 
  
  
  
  
  11.   }
    12. 
  
  
  
  
  12. }
    13. 
  
  
  
  
  13. 
  
  
  
  
  14. function $String (i) {
    15. 
  
  
  
  
  15.   return '"' + i + '"'
    16. 
  
  
  
  
  16. }
    17. 
  
  
  
  
  17. 
  
  
  
  
  18. function buildObject (schema, code, name) {
    19. 
  
  
  
  
  19.   // 序列化對象 ...
    20. 
  
  
  
  
  20. }
    21. 
  
  
  
  
  21. 
  
  
  
  
  22. function buildArray (schema, code, name) {
    23. 
  
  
  
  
  23.   // 序列化數組 ...
    24. 
  
  
  
  
  24. }
    25. 
  
  
  
  
  25. 
  
  
  
  
  26. function build (schema) {
    27. 
  
  
  
  
  27.   var code = `
    28. 
  
  
  
  
  28.     'use strict'
    29. 
  
  
  
  
  29. 
  
  
  
  
  30.     ${$String.toString()}
    31. 
  
  
  
  
  31.     ${$Number.toString()}
    32. 
  
  
  
  
  32.     ${$Null.toString()}
    33. 
  
  
  
  
  33.   `
    34. 
  
  
  
  
  34.   var main
    35. 
  
  
  
  
  35. 
  
  
  
  
  36.   code = buildObject(schema, code, '$main')
    37. 
  
  
  
  
  37. 
  
  
  
  
  38.   code += `
    39. 
  
  
  
  
  39.     ;
    40. 
  
  
  
  
  40.     return $main
    41. 
  
  
  
  
  41.   `
    42. 
  
  
  
  
  42. 
  
  
  
  
  43.   return (new Function(code))()
    44. 
  
  
  
  
  44. }
    45. 
  
  
  
  
  45. 
  
  
  
  
  46. module.exports = build
    47.

fast-json-stringify 對外暴露一個 build 方法，該方法接受一個 schema，返回一個函數($main)，用于將 schema 對應的對象進行序列化，具體使用方式如下：

 
 
 
 
    
  
  
  
  
  1. const build = require('fast-json-stringify')
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. const stringify = build({
    4. 
  
  
  
  
  4.   type: 'object',
    5. 
  
  
  
  
  5.   properties: {
    6. 
  
  
  
  
  6.     id: { type: 'number' },
    7. 
  
  
  
  
  7.     name: { type: 'string' }
    8. 
  
  
  
  
  8.   }
    9. 
  
  
  
  
  9. })
    10. 
  
  
  
  
  10. console.log(stringify)
    11. 
  
  
  
  
  11. 
  
  
  
  
  12. const objString = stringify({
    13. 
  
  
  
  
  13.   id: 1, name: 'shenfq'
    14. 
  
  
  
  
  14. })
    15. 
  
  
  
  
  15. console.log(objString) // {"id":1,"name":"shenfq"}
    16.

經過 build 構造后，返回的序列化方法如下：

 
 
 
 
    
  
  
  
  
  1. function $String (i) {
    2. 
  
  
  
  
  2.   return '"' + i + '"'
    3. 
  
  
  
  
  3. }
    4. 
  
  
  
  
  4. function $Number (i) {
    5. 
  
  
  
  
  5.   var num = Number(i)
    6. 
  
  
  
  
  6.   if (isNaN(num)) {
    7. 
  
  
  
  
  7.     return 'null'
    8. 
  
  
  
  
  8.   } else {
    9. 
  
  
  
  
  9.     return String(num)
    10. 
  
  
  
  
  10.   }
    11. 
  
  
  
  
  11. }
    12. 
  
  
  
  
  12. function $Null (i) {
    13. 
  
  
  
  
  13.   return 'null'
    14. 
  
  
  
  
  14. }
    15. 
  
  
  
  
  15. // 序列化方法
    16. 
  
  
  
  
  16. function $main (obj) {
    17. 
  
  
  
  
  17.   var json = '{'
    18. 
  
  
  
  
  18. 
  
  
  
  
  19.   json += '"id":'
    20. 
  
  
  
  
  20. 
  
  
  
  
  21.   json += $Number(obj.id)
    22. 
  
  
  
  
  22.   json += ','
    23. 
  
  
  
  
  23.   json += '"name":'
    24. 
  
  
  
  
  24. 
  
  
  
  
  25.   json += $String(obj.name)
    26. 
  
  
  
  
  26. 
  
  
  
  
  27.   json += '}'
    28. 
  
  
  
  
  28.   return json
    29. 
  
  
  
  
  29. }
    30.

可以看到，有 schema 做支撐，序列化的邏輯瞬間變得無比簡單，最后得到的 JSON 字符串只保留需要的屬性，簡潔高效。我們回過頭再看看 buildObject 是如何生成 $main 內的代碼的：

 
 
 
 
    
  
  
  
  
  1. function buildObject (schema, code, name) {
    2. 
  
  
  
  
  2.   // 構造一個函數
    3. 
  
  
  
  
  3.   code += `
    4. 
  
  
  
  
  4.     function ${name} (obj) {
    5. 
  
  
  
  
  5.       var json = '{'
    6. 
  
  
  
  
  6.   `
    7. 
  
  
  
  
  7.   var laterCode = ''
    8. 
  
  
  
  
  8.   // 遍歷 schema 的屬性
    9. 
  
  
  
  
  9.   const { properties } = schema
    10. 
  
  
  
  
  10.   Object.keys(properties).forEach((key, i, a) => {
    11. 
  
  
  
  
  11.     // key 需要加上雙引號
    12. 
  
  
  
  
  12.     code += `
    13. 
  
  
  
  
  13.       json += '${$String(key)}:'
    14. 
  
  
  
  
  14.     `
    15. 
  
  
  
  
  15.     // 通過 nested 轉化 value
    16. 
  
  
  
  
  16.     const value = properties[key]
    17. 
  
  
  
  
  17.     const result = nested(laterCode, name, `.${key}`, value)
    18. 
  
  
  
  
  18. 
  
  
  
  
  19.     code += result.code
    20. 
  
  
  
  
  20.     laterCode = result.laterCode
    21. 
  
  
  
  
  21. 
  
  
  
  
  22.     if (i < a.length - 1) {
    23. 
  
  
  
  
  23.       code += 'json += \',\''
    24. 
  
  
  
  
  24.     }
    25. 
  
  
  
  
  25.   })
    26. 
  
  
  
  
  26. 
  
  
  
  
  27.   code += `
    28. 
  
  
  
  
  28.       json += '}'
    29. 
  
  
  
  
  29.       return json
    30. 
  
  
  
  
  30.     }
    31. 
  
  
  
  
  31.   `
    32. 
  
  
  
  
  32. 
  
  
  
  
  33.   code += laterCode
    34. 
  
  
  
  
  34. 
  
  
  
  
  35.   return code
    36. 
  
  
  
  
  36. }
    37. 
  
  
  
  
  37. 
  
  
  
  
  38. function nested (laterCode, name, key, schema) {
    39. 
  
  
  
  
  39.   var code = ''
    40. 
  
  
  
  
  40.   var funcName
    41. 
  
  
  
  
  41.   // 判斷 value 的類型，不同類型進行不同的處理
    42. 
  
  
  
  
  42.   const type = schema.type
    43. 
  
  
  
  
  43.   switch (type) {
    44. 
  
  
  
  
  44.     case 'null':
    45. 
  
  
  
  
  45.       code += `
    46. 
  
  
  
  
  46.       json += $Null()
    47. 
  
  
  
  
  47.       `
    48. 
  
  
  
  
  48.       break
    49. 
  
  
  
  
  49.     case 'string':
    50. 
  
  
  
  
  50.       code += `
    51. 
  
  
  
  
  51.       json += $String(obj${key})
    52. 
  
  
  
  
  52.       `
    53. 
  
  
  
  
  53.       break
    54. 
  
  
  
  
  54.     case 'number':
    55. 
  
  
  
  
  55.     case 'integer':
    56. 
  
  
  
  
  56.       code += `
    57. 
  
  
  
  
  57.       json += $Number(obj${key})
    58. 
  
  
  
  
  58.       `
    59. 
  
  
  
  
  59.       break
    60. 
  
  
  
  
  60.     case 'object':
    61. 
  
  
  
  
  61.       // 如果 value 為一個對象，需要一個新的方法進行構造
    62. 
  
  
  
  
  62.       funcName = (name + key).replace(/[-.\[\]]/g, '')
    63. 
  
  
  
  
  63.       laterCode = buildObject(schema, laterCode, funcName)
    64. 
  
  
  
  
  64.       code += `
    65. 
  
  
  
  
  65.         json += ${funcName}(obj${key})
    66. 
  
  
  
  
  66.       `
    67. 
  
  
  
  
  67.       break
    68. 
  
  
  
  
  68.     case 'array':
    69. 
  
  
  
  
  69.       funcName = (name + key).replace(/[-.\[\]]/g, '')
    70. 
  
  
  
  
  70.       laterCode = buildArray(schema, laterCode, funcName)
    71. 
  
  
  
  
  71.       code += `
    72. 
  
  
  
  
  72.         json += ${funcName}(obj${key})
    73. 
  
  
  
  
  73.       `
    74. 
  
  
  
  
  74.       break
    75. 
  
  
  
  
  75.     default:
    76. 
  
  
  
  
  76.       throw new Error(`${type} unsupported`)
    77. 
  
  
  
  
  77.   }
    78. 
  
  
  
  
  78. 
  
  
  
  
  79.   return {
    80. 
  
  
  
  
  80.     code,
    81. 
  
  
  
  
  81.     laterCode
    82. 
  
  
  
  
  82.   }
    83. 
  
  
  
  
  83. }
    84.

其實就是對 type 為 "object" 的 properties 進行一次遍歷，然后針對 value 不同的類型進行二次處理，如果碰到新的對象，會構造一個新的函數進行處理。

 
 
 
 
    
  
  
  
  
  1. // 如果包含子對象
    2. 
  
  
  
  
  2. const stringify = build({
    3. 
  
  
  
  
  3.   type: 'object',
    4. 
  
  
  
  
  4.   properties: {
    5. 
  
  
  
  
  5.     id: { type: 'number' },
    6. 
  
  
  
  
  6.     info: {
    7. 
  
  
  
  
  7.       type: 'object',
    8. 
  
  
  
  
  8.       properties: {
    9. 
  
  
  
  
  9.         age: { type: 'number' },
    10. 
  
  
  
  
  10.         name: { type: 'string' },
    11. 
  
  
  
  
  11.       }
    12. 
  
  
  
  
  12.     }
    13. 
  
  
  
  
  13.   }
    14. 
  
  
  
  
  14. })
    15. 
  
  
  
  
  15. 
  
  
  
  
  16. console.log(stringify.toString())
    17. 
 
 
 
 

 
 
 
 
    
  
  
  
  
  1. function $main (obj) {
    2. 
  
  
  
  
  2.   var json = '{'
    3. 
  
  
  
  
  3. 
  
  
  
  
  4.   json += '"id":'
    5. 
  
  
  
  
  5. 
  
  
  
  
  6.   json += $Number(obj.id)
    7. 
  
  
  
  
  7.   json += ','
    8. 
  
  
  
  
  8.   json += '"info":'
    9. 
  
  
  
  
  9. 
  
  
  
  
  10.   json += $maininfo(obj.info)
    11. 
  
  
  
  
  11. 
  
  
  
  
  12.   json += '}'
    13. 
  
  
  
  
  13.   return json
    14. 
  
  
  
  
  14. }
    15. 
  
  
  
  
  15. 
  
  
  
  
  16. // 子對象會通過另一個函數處理
    17. 
  
  
  
  
  17. function $maininfo (obj) {
    18. 
  
  
  
  
  18.   var json = '{'
    19. 
  
  
  
  
  19. 
  
  
  
  
  20.   json += '"age":'
    21. 
  
  
  
  
  21. 
  
  
  
  
  22.   json += $Number(obj.age)
    23. 
  
  
  
  
  23.   json += ','
    24. 
  
  
  
  
  24.   json += '"name":'
    25. 
  
  
  
  
  25. 
  
  
  
  
  26.   json += $String(obj.name)
    27. 
  
  
  
  
  27. 
  
  
  
  
  28.   json += '}'
    29. 
  
  
  
  
  29.   return json
    30. 
  
  
  
  
  30. }
    31.

 總結

當然，fastify 之所以號稱自己快，內部還有一些其他的優(yōu)化方法，例如，在路由庫的實現上使用了 Radix Tree 、對上下文對象可進行復用(使用 middie 庫)。本文只是介紹了其中的一種體現最重要明顯優(yōu)化思路，希望大家閱讀之后能有所收獲。


當前題目：Node.js服務性能翻倍的秘密（一）
鏈接URL：http://www.5511xx.com/article/dpssegj.html