2. 程式人生 > >面試官說：說一說CommonJs的實現原理

面試官說：說一說CommonJs的實現原理

阿新 • • 發佈：2018-11-08
目錄 依次 java 包括 adf readfile app 階段 bar

技術分享圖片

其實剛看到這個題目的時候，我的內心是拒絕的，但是本著對科學的敬畏精神，我開始了 CommonJs 的探索之路。

來來來奉上我這幾天的心血，拿走不客氣。如有錯誤歡迎指正，共同進步。

提到CommonJs 繞不開的就是模塊化。

模塊化

模塊化是指將一個復雜的系統分解為多個模塊以方便編碼。

很久以前，開發網頁要通過命名空間的方式來組織代碼，例如 jQuery 庫將它的 API 都放在了 window.$ 下，在加載完 jQuery 後，其他模塊再通過 window.$ 去使用 jQuery。這樣做有很多問題，其中包括：

  • 命名空間沖突，兩個庫可能會使用同一個名稱，例如 Zepto(http://zepto.com) 也是放在 window.$ 下；
  • 無法合理地管理項目的依賴和版本；
  • 無法方便地控制依賴的加載順序；

當項目變大，這種方式將變得難以維護，需要用模塊化的思想來組織代碼。

一 、模塊化優點：

  1. 提升開發效率：代碼方便重用，別人開發的模塊直接拿過來就可以使用，不需要重復開發法類似的功能。

  2. 方便後期維護：代碼方便重用，別人開發的模塊直接拿過來就可以使用，不需要重復開發法類似的功能。

所以總結來說，在生產角度，模塊化開發是一種生產方式，這種方式生產效率高，維護成本低。從軟件開發角度來說，模塊化開發是一種開發模式，寫代碼的一種方式，開發效率高，方便後期維護。

二、模塊化規範

服務器端規範主要是CommonJS，node.js用的就是CommonJS規範。

　　客戶端規範主要有：AMD（異步模塊定義，推崇依賴前置）、CMD（通用模塊定義，推崇依賴就近）。AMD規範的實現主要有RequireJS，CMD規範的主要實現有SeaJS。但是SeaJS已經停止維護了，因為在ES6中已經有了模塊化的實現，隨著ES6的普及，第三方的模塊化實現將會慢慢的淘汰。

本文主要介紹的也是CommonJS,所以其他的規範請允許我無恥的忽略了，下面進入正題：

三、CommonJS

CommonJS 作為 Node.js 的規範，一直沿用至今。由於 npm 上 CommonJS 的類庫眾多，以及 CommonJS 和 ES6 之間的差異，Node.js 無法直接兼容 ES6。所以現階段 require/exports 仍然是必要且是必須的。出自 ES6 的 import/export 相對就晚了許多。被大家所熟知和使用也是 2015 年之後的事了。 這其實要感謝 babel（原來項目名叫做 6to5，後更名為 babel） 這個神一般的項目。由於有了 babel 將還未被宿主環境（各瀏覽器、Node.js）直接支持的 ES6 Module 編譯為 ES5 的 CommonJS —— 也就是 require/exports 這種寫法 —— Webpack 插上 babel-loader 這個翅膀才開始高飛，大家也才可以稱 " 我在使用 ES6！

CommonJS的核心思想是通過rquire方法來同步加載依賴的其他模塊，通過module.exports到處需要暴露的接口。

采用CommonJS導入及導出的代碼如下：

moduleA.js
//導出
 module.exports = moduleA.someFunc;
//導入
const moduleA = require(‘./moduleA‘)

1. CommonJS的簡單實現解析

分析源碼之前，先介紹require語句的內部邏輯。

1.1 require的內部邏輯

摘自

  當node遇到 require(X),按照下面的順序處理。
  
  （1）如果 X 是內置模塊（比如 require(‘http‘)）
  
       a. 返回該模塊
       b. 不再繼續執行
       
   （2）如果 X 以‘./‘ 或者 ‘../ ‘開頭
       
       a. 根據 X 所在的父模塊，確定X的絕對路徑。
       b. 將 X 當成文件，依次查找下面文件，只要其中有一個存在，就返回該文件，不再繼續執行。(也就是把 X 跟下面的幾種文件格式進行匹配，匹配到了就會依照相應的文件格式進行加載)
     
       +----------------------+
       |  .x                  |
       |  .x.js               |
       |  .x.json             |
       |  .x.node             |
       +--------------------  + 
    c.將 X 當成目錄，一次查找下面文件，只要其中有一個存在，就返回該文件，不再繼續執行。
    
       +----------------------------+
       |  .X/package.json(main字段) |
       |  .X/index.js               |
       |  .X/index.json             |
       |  .X/index.node             |
       +--------------------------- +
       
   （3）如果 X 不帶路徑
      a.根據 X 所在的父模塊，確定 X 可能的安裝目錄。
      b. 依次在每個目錄中， 將 X 當成文件名或目錄名加載
    
   （4）拋出 "not found"

技術分享圖片

require命令用於加載文件，後綴名默認為.js。

比如：

var  a = require(‘a‘);
// 等同於
var a = require(‘a.js‘);

根據參數的不同格式，require 命令去不同路徑尋找模塊文件。

總結一下加載規則如下：

（1）如果參數字符串以"/"開頭,則表示加載的是一個位於絕對路徑的模塊文件。比如，require(‘/home/user/a.js‘),將加載 /home/user/a.js

(2) 如果參數字符串以“./”開頭，則表示加載的是一個位於相對路徑（跟）

在當前腳本文件 "/Users/danlan/node-stu/user.js"
執行了 require(‘bar‘), 這屬於上面的第三種情況。Node 內部運行過程如下：

  • 首先去確定 X 的絕對路徑可能是下面這些位置，依次搜索每一個目錄。

    • /Users/danlan/node-stu/node_modules/bar

    • /Users/danlan/node_modules/bar

    • /Users/node_modules/bar

    • /node_modules/bar

  • 搜索時， Node 先將 bar 當成文件名， 依次嘗試加載下面這些文件， 只要有一個成功就返回。

    +----------------------------+
|  bar                        |
|  bar.js                     |
|  bar.json                   |
|  bar.node                   |
+--------------------------- +

  • 如果都不成功說明 bar 可能是目錄名，於是嘗試加載下面這些文件。

     +----------------------------+
 |  bar/package.json(main 字段)|
 |  bar/index.js               |
 |  bar/index.json             |
 |  bar/index.node             |
 +-----------------------------+

  • 如果所有的目錄中，都無法找到 bar 對應的文件或目錄，就拋出一個錯誤。

1.2 Module 對象

了解了內部邏輯以後，下面是簡易版源碼分析：

Node內部提供了一個 Mudule構建函數。所有模塊都是Module的實例。
require 的源碼在 Node 的 lib/module.js 文件。

function Module(id, parent){
    this.id = id;
    this.exports = {};
    this.parent = parent;
    this.filename = null;
    this.loaded = false;
    this.children = []
}
module.exports = Module;
var module = new Module(filename, parent)

上面的代碼中，Node 定義了一個構造函數 Module,所有的模塊都是 Module 的實例。可以看到，當前模塊 (module.js)也是Moudle的一個實例。

  • module.id 模塊的識別符，通常是帶有絕對路徑的模塊文件名。

  • module.filename 模塊的文件名，帶有絕對路徑。

  • module.loaded 返回一個布爾值，表示模塊是否已經完成加載。

  • module.parent 返回一個對象，表示調用該模塊的模塊。

  • module.children 返回一個數組，表示該模塊要用到的其他模塊。

  • module.exports 表示模塊對外輸出的值

每個實例都有自己的屬性。下面通過一個例子，看看這些屬性的值是什麽。新建一個腳本文件 a.js。

//a.js
console.log(‘module.id: ‘, module.id);
console.log(‘module.exports: ‘, module.exports);
console.log(‘module.parent: ‘, module.parent);
console.log(‘module.filename: ‘, module.filename);
console.log(‘module.loaded: ‘, module.loaded);
console.log(‘module.children: ‘, module.children);
console.log(‘module.paths: ‘, module.paths);

運行一下：


$ node a.js

module.id:  .
module.exports:  {}
module.parent:  null
module.filename:  /home/ruanyf/tmp/a.js
module.loaded:  false
module.children:  []
module.paths:  [ ‘/Users/danlan/workspace/node-stu/ree/node_modules‘,
  ‘/Users/danlan/workspace/node-stu/node_modules‘,
  ‘/Users/danlan/workspace/node_modules‘,
  ‘/Users/danlan/node_modules‘,
  ‘/Users/node_modules‘,
  ‘/node_modules‘ ]

可以看到，如果沒有父模塊，直接調用當前模塊， parent 屬性就是null ,id 屬性就是一個點。filename屬性是模塊的絕對路徑，path 屬性是一個數組，包含了模塊可能的位置。另外，輸出這些內容時，模塊還沒有全部加載，所以 loaded 屬性為 false。

新建一個b.js

var a = require(‘./a.js‘)

運行一下：

module.id:  /Users/danlan/workspace/node-stu/ree/a.js
module.exports:  {}
module.parent:  Module {
  id: ‘.‘,
  exports: {},
  parent: null,
  filename: ‘/Users/danlan/workspace/node-stu/ree/b.js‘,
  loaded: false,
  children:
   [ Module {
       id: ‘/Users/danlan/workspace/node-stu/ree/a.js‘,
       exports: {},
       parent: [Circular],
       filename: ‘/Users/danlan/workspace/node-stu/ree/a.js‘,
       loaded: false,
       children: [],
       paths: [Array] } ],
  paths:
   [ ‘/Users/danlan/workspace/node-stu/ree/node_modules‘,
     ‘/Users/danlan/workspace/node-stu/node_modules‘,
     ‘/Users/danlan/workspace/node_modules‘,
     ‘/Users/danlan/node_modules‘,
     ‘/Users/node_modules‘,
     ‘/node_modules‘ ] }
module.filename:  /Users/danlan/workspace/node-stu/ree/a.js
module.loaded:  false
module.children:  []
module.paths:  [ ‘/Users/danlan/workspace/node-stu/ree/node_modules‘,
  ‘/Users/danlan/workspace/node-stu/node_modules‘,
  ‘/Users/danlan/workspace/node_modules‘,
  ‘/Users/danlan/node_modules‘,
  ‘/Users/node_modules‘,
  ‘/node_modules‘ ]

這個輸出稍稍有一點多，沒關系慢慢縷一下哈，由於 a.js 被 b.js 調用，所以 parent 屬性指向 b.js 模塊，id屬性和filename 屬性一致，都是模塊的絕對路徑。

1.3 模塊實例的 require 方法

每個模塊實例都有一個 require 方法。

Module.prototype.require = function(path){
  return Module._load(path, this)  
}

由此可知，require 並不是全局命令，而是每個模塊提供的一個內部方法，也就是說，只有在模塊內部才能使用require命令，（唯一的例外是REPL 環境）。另外，require 其實內部調用 Module._load 方法。

下面來看 Module._load 的源碼。


Module._load = function(request, parent, isMain) {

  //  計算絕對路徑
  var filename = Module._resolveFilename(request, parent);

  //  第一步：如果有緩存，取出緩存
  var cachedModule = Module._cache[filename];
  if (cachedModule) {
    return cachedModule.exports;
  }
  
  // 第二步：是否為內置模塊
  if (NativeModule.exists(filename)) {
    return NativeModule.require(filename);
  }

  // 第三步：生成模塊實例，存入緩存
  var module = new Module(filename, parent);
  Module._cache[filename] = module;

  // 第四步：加載模塊
  try {
    module.load(filename);
    hadException = false;
  } finally {
    if (hadException) {
      delete Module._cache[filename];
    }
  }

  // 第五步：輸出模塊的exports屬性
  return module.exports;
};

上面的代碼中，首先解析出模塊的絕對路徑（filename），以它作為模塊的識別符。

它的內部處理流程是:

  1. 檢查 Module._cache，是否在緩存中有指定的模塊，如果模塊已經在緩存中，就從緩存取出。
  2. 如果沒有判斷是否為內置模塊，如果是內置模塊就返回內置模塊。
  3. 如果緩存之中沒有就會創建一個新的Moudle實例，將它保存到緩存中。
  4. 加載模塊
  5. 如果加載/解析過程報錯，就從緩存刪除該模塊
  6. 返回該模塊的 module.exports

因此，Module._load 的關鍵步驟是兩個。

  1. Module._resolveFilename() : 確定模塊的絕對路徑
  2. module.load():加載模塊

下面來說一下Module._resolveFilename():

1.4 模塊的絕對路徑

下面是 Module._resolveFilename() 方法的源碼。
```
Module._resolveFilename = function(request, parent) {

// 第一步：如果是內置模塊，不含路徑返回
if (NativeModule.exists(request)) {
return request;
}

// 第二步：確定所有可能的路徑
var resolvedModule = Module._resolveLookupPaths(request, parent);
var id = resolvedModule[0];
var paths = resolvedModule[1];

// 第三步：確定哪一個路徑為真
var filename = Module._findPath(request, paths);
if (!filename) {
var err = new Error("Cannot find module ‘" + request + "‘");
err.code = ‘MODULE_NOT_FOUND‘;
throw err;
}
return filename;
};

上面代碼中，在 Module.resolveFilrename 方法內部，又調用了兩個方法  Module.reqolveLookPaths()和 Module._findPath(),前者用來列出可能的路徑，後者用來確認哪一個路徑為真。

有了可能的路徑以後，下面就是 Module._findPath()的源碼，用來確定到底哪一個是正確路徑。

Module._findPath = function(request, paths) {

// 列出所有可能的後綴名：.js，.json, .node
var exts = Object.keys(Module._extensions);

// 如果是絕對路徑，就不再搜索
if (request.charAt(0) === ‘/‘) {
paths = [‘‘];
}

// 是否有後綴的目錄斜杠
var trailingSlash = (request.slice(-1) === ‘/‘);

// 第一步：如果當前路徑已在緩存中，就直接返回緩存
var cacheKey = JSON.stringify({request: request, paths: paths});
if (Module._pathCache[cacheKey]) {
return Module._pathCache[cacheKey];
}

// 第二步：依次遍歷所有路徑
for (var i = 0, PL = paths.length; i < PL; i++) {
var basePath = path.resolve(paths[i], request);
var filename;

if (!trailingSlash) {
  // 第三步：是否存在該模塊文件
  filename = tryFile(basePath);

  if (!filename && !trailingSlash) {
    // 第四步：該模塊文件加上後綴名，是否存在
    filename = tryExtensions(basePath, exts);
  }
}

// 第五步：目錄中是否存在 package.json 
if (!filename) {
  filename = tryPackage(basePath, exts);
}

if (!filename) {
  // 第六步：是否存在目錄名 + index + 後綴名 
  filename = tryExtensions(path.resolve(basePath, ‘index‘), exts);
}

// 第七步：將找到的文件路徑存入返回緩存，然後返回
if (filename) {
  Module._pathCache[cacheKey] = filename;
  return filename;
}

}

// 第八步：沒有找到文件，返回false
return false;
};

經過上面代碼，就可以找到模塊的絕對路徑了。

有時在項目代碼中，需要調用模塊的絕對路徑，那麽除了 module.filename ，Node 還提供一個 require.resolve 方法，供外部調用，用於從模塊名取到絕對路徑。

require.resolve = function(request) {
return Module._resolveFilename(request, self);
};

// 用法
require.resolve(‘a.js‘)
// 返回 /Users/danlan/workspace/node-stu/ree/a.js


### 1.5 加載模塊
他有了模塊的絕對路徑，就可以加載該模塊了。下面就是   module.load 方法的源碼。

Module.prototype.load = function (filename) {
var extension = path.extname(filename) || ‘js‘
if(!Module._extensions[extensions]) extension = ‘.js‘
Module._extensionsextension
this.loaded = true
}

上面代碼中，首先確定模塊的後綴名，不同的後綴名對應不同的加載方法。下面是.js和.json後綴名對應的處理方法。

Module._extensions[‘.js‘] = function(module, filename) {
var content = fs.readFileSync(filename, ‘utf8‘);
module._compile(stripBOM(content), filename);
};

Module._extensions[‘.json‘] = function(module, filename) {
var content = fs.readFileSync(filename, ‘utf8‘);
try {
module.exports = JSON.parse(stripBOM(content));
} catch (err) {
err.message = filename + ‘: ‘ + err.message;
throw err;
}
};

這裏只討論 js 文件的加載。首先，將模塊文件讀取成字符串，然後剝離 utf8 編碼特有的BOM文件頭，最後編譯該模塊。

module._compile 方法用於模塊的編譯。

Module.prototype._compile = function(content, filename) {
var self = this;
var args = [self.exports, require, self, filename, dirname];
return compiledWrapper.apply(self.exports, args);
};

上面的代碼基本等同於下面的形式。

(function (exports, require, module, __filename, __dirname) {
// 模塊源碼
});

```
也就是說，模塊的加載實質上就是，註入exports、require、module三個全局變量，然後執行模塊的源碼，然後將模塊的 exports 變量的值輸出。

引入一張文件查找的邏輯圖：
技術分享圖片
參考：

http://javascript.ruanyifeng.com/nodejs/module.html

https://segmentfault.com/a/1190000000733959#articleHeader5

https://www.cnblogs.com/TomXu/archive/2011/12/30/2288372.html

https://zhuanlan.zhihu.com/p/22890374

面試官說：說一說CommonJs的實現原理

相關推薦

面試官：說說一條查詢sql的執行流程和底層原理？

序章 自我介紹 我是一條sql，就是一條長長的字串，不要問我長什麼樣，因為我比較傲嬌。   額~~不是我不

面試官：請講一下Redis主從複製的功能及實現原理

摘要：Redis在主從模式下會有許多問題需要考慮，這裡寫了一些關於redis在多伺服器下的一些問題分析和總結。 Redis單節點存在單點故障問題，為了解決單點問題，一般都需要對redis配置從節點，然後使用哨兵來監聽主節點的存活狀態，如果主節點掛掉，從節點能繼續提供快取功能。主從配置結合哨兵模式能解決單點故障

Java併發（四）：volatile的實現原理 Java併發（一）：Java記憶體模型乾貨總結

synchronized是一個重量級的鎖，volatile通常被比喻成輕量級的synchronized volatile是一個變數修飾符，只能用來修飾變數。 volatile寫：當寫一個volatile變數時，JMM會把該執行緒對應的本地記憶體中的共享變數重新整理到主記憶體。 volatile讀：當讀一

面試官：給我說一下你項目中的單點登錄是如何實現的？

分享圖片 .get 監聽 rec 返回 例子 比對 .exe 功能 一、單系統登錄機制 1、http無狀態協議 web應用采用browser/server架構，http作為通信協議。http是無狀態協議，瀏覽器的每一次請求，服務器會獨立處理，不與之前或之後的請求產生關聯，這

面試官：你看過Redis資料結構底層實現嗎？

面試中，redis也是很受面試官親睞的一部分。我向在這裡講的是redis的底層資料結構，而不是你理解的五大資料結構。你有沒有想過redis底層是怎樣的資料結構呢，他們和我們java中的HashMap、List、等使用的資料結構有什麼區別呢。 1. 字串處理(string) 我們都知道redis是用C語言寫

面試官：你瞭解過Redis物件底層實現嗎

上一章我們講了Redis的底層資料結構，不瞭解的人可能會有疑問：這個和平時用的五大物件有啥關係呢？這一章我們就主要解釋他們所建立的聯絡。 看這個文章之前，如果對ziplist、skiplist、intset等資料結構不熟悉的話，建議先回顧一下上一章節：面試官：你看過Redis資料結構底層實現嗎？ 0. 五

面試官：你是如何使用JDK來實現自己的快取（支援高併發）？

需求分析 專案中經常會遇到這種場景：一份資料需要在多處共享，有些資料還有時效性，過期自動失效。比如手機驗證碼，傳送之後需要快取起來，然後處於安全性考慮，一般還要設定有效期，到期自動失效。我們怎麼實現這樣的功能呢？ 解決方案 使用現有的快取技術框架，比如redis,ehcache。優點：成熟，穩定，功能強大；

面試官：兄弟，說說 Spring Cloud 的核心架構原理吧

最近在補一些分散式系列的面試內容，提前幾個月做做準備吧，你們懂的，也跟大家分享分享。現在分散式系統基本上都是標配了，如果你現在還在

面試官：你有m個雞蛋，如何用最少的次數測出雞蛋會在哪一層碎？

假設你面前有一棟n層的大樓和m個雞蛋，假設將雞蛋從f層或更高的地方放扔下去，雞蛋才會碎，否則就不會。你需要設計一種策略來確定f的值，求最壞情況下扔雞蛋次數的最小值。 leetcode原題連結 乍一看這道題很抽象，可能有的人一看到這個題目從來沒做過，就懵逼了。其實不用慌張，再花裡胡哨的題目，最後都可以抽象成我們

面試官：這簡歷一看就是包裝過了！

在網際網路極速膨脹的社會背景下，各行各業湧入網際網路的IT民工日益增大。   早在2016年，我司釋出了Java、Ios工程師的招聘資訊，就Java工程師單個崗位而言，日收簡歷近200份，Ios日收簡歷近一千份。   沒錯，這就是當年培訓機構對Ios工程師這個崗位發起的市場討伐。而隨著近幾

面試官：CPU百分百！給你一分鐘，怎麼排查？有幾種方法？

Part0 遇到了故障怎麼辦？ 在生產上，我們會遇到各種各樣的故障，遇到了故障怎麼辦？ 不要慌，只有冷靜才是解決故障的利器。 下面以一個例子為例，在生產中碰到了CPU 100%的問題怎麼辦？ 在生產中真的碰到了CPU 100%的問題，再來看這篇文章已經遲了，還是先來模擬演練下吧。 怎麼模擬演練？ （1）查詢資

看完這一篇，再也不怕面試官問到IntentService的原理

### IntentService是什麼 在內部封裝了 Handler、訊息佇列的一個Service子類，適合在後臺執行一系列序列依次執行的耗時非同步任務，方便了我們的日常coding（普通的Service則是需要另外建立子執行緒和控制任務執行順序） ![image-20200728124918200](

【Nginx】面試官：給我講講Nginx如何實現四層負載均衡？

## 寫在前面 > 這次又被問到Nginx四層負載均衡的問題了，別慌，我們一起來細細分析這個看似簡單的問題。 > > 如果文章對你有點幫助，請關注 **冰河技術** 微信公眾號，點贊、在看、留言和轉發，大家的四連是我持續創作的最大動力。 負載均衡可以分為靜態負載均衡和動態負載均衡，接下來

面試官：說說CountDownLatch，CyclicBarrier，Semaphore的原理？

CountDownLatch CountDownLatch適用於在多執行緒的場景需要等待所有子執行緒全部執行完畢之後再做操作的場景。 舉個例子，早上部門開會，有人在上廁所，這時候需要等待所有人從廁所回來之後才能開始會議。 public class CountDownLatchTest { priva

【面經】面試官：如何以最高的效率從MySQL中隨機查詢一條記錄？

## 寫在前面 > MySQL資料庫在網際網路行業使用的比較多，有些小夥伴可能會認為MySQL資料庫比較小，儲存不了很多的資料。其實，這些小夥伴是真的不瞭解MySQL。MySQL的小不是說使用MySQL儲存的資料少，而是說其體積小，比較輕量。使用MySQL完全可以儲存千億級別的資料，這個我會在後面的文

搞定面試官：咱們從頭到尾再說一次 Java 垃圾回收

接著前幾天的兩篇文章，繼續解析JVM面試問題，送給年後想要跳槽的小夥伴 萬萬沒想到，面試中，連 ClassLoader類載入器 也能問出這麼多問題..... 萬萬沒想到，JVM記憶體區域的面試題也可以問的這麼難？ 三、GC垃圾回收 1、GC是什麼？為什麼要GC GC：垃圾收集，GC能幫助我們釋放jvm記憶體，

轉：深入Java集合學習系列：HashSet的實現原理

是否 abstract arc html 源代碼 cat param body static 0.參考文獻 深入Java集合學習系列：HashSet的實現原理 1.HashSet概述： 　　HashSet實現Set接口，由哈希表（實際上是一個HashMap實例）支持。它

【轉】Java並發編程：Synchronized及其實現原理

st2 等待 OS threads img 參考 使用 leg ble 一、Synchronized的基本使用 　　Synchronized是Java中解決並發問題的一種最常用的方法，也是最簡單的一種方法。Synchronized的作用主要有三個：（1）確保線程互斥的

Java並發（四）：volatile的實現原理

ont style tile 讀寫 flush microsoft div 圖片 println synchronized是一個重量級的鎖，volatile通常被比喻成輕量級的synchronized volatile是一個變量修飾符，只能用來修飾變量。 volatile寫

面試官：分散式事務講下 程式設計師：不清楚 然後結果就涼涼了

java、後端開發、程式設計師、分散式事務 分散式事務應該是面試官最喜歡問的題目之一 我對分散式事務的基本思路整理總結了一下，其實還有很多細節沒研究。 基礎知識準備 資料庫事務、分散式、微服務、分庫分表 資料庫事務的特性：原子性(Atomicity )、一致性( Cons