想象有这样一个场景：A 团队开发了一套组件库，B 和 C 团队都在各自的业务项目中使用了该组件库。现在 A 团队需要对某个组件进行更新（比如修改颜色），按照以往的做法，A 团队需要先发布一个新的版本，然后其他两个团队各自更新业务项目中所依赖的组件库的版本后发布上线。

有没有更快速的方法呢？比如能否做到只更新组件库，其他依赖它的项目可以自动获取到其最新的版本，即实现远程动态组件。答案是有的，Webpack 5 新增的 Module Federation 就可以实现这个需求，但是今天我们要讨论的是另外一种方法。

远程动态组件库

远程动态组件库项目结构如下所示：

复制 1.
 2├── babel.config.js
 3├── package.json
 4├── rollup.config.js
 5└── src
 6    ├── Button.js
 7    ├── Text.js

我们简单实现了两个组件 Button 和 Text：

复制 1import React from 'react'
 2
 3export default ({children}) => {
 4  return <button style={{color: 'blue'}}>{children}</button>
 5}

复制 1import React from 'react'
 2
 3export default ({children}) => {
 4  return <span style={{color: 'blue'}}>{children}</span>
 5}

我们使用 rollup 对其进行打包，之所以用 rollup 是因为其打包出来的代码非常简洁，方便我们查看，rollup 配置为：

复制 1import babel from 'rollup-plugin-babel'
 2import fs from 'fs'
 3
 4const components = fs.readdirSync('./src')
 5
 6export default components.map((filename) => {
 7  return {
 8    input: `./src/${filename}`,
 9    output: {
10      file: `dist/${filename}`,
11      format: 'cjs',
12    },
13    plugins: [babel()],
14  }
15})

打包后的结果如下所示：

复制 1.
 2├── dist
 3│   └── Button.js
 4│   └── Text.js

其中 Button.js 如下所示：

复制 1'use strict'
 2
 3var React = require('react')
 4
 5function _interopDefaultLegacy(e) {
 6  return e && typeof e === 'object' && 'default' in e ? e : {default: e}
 7}
 8
 9var React__default =  _interopDefaultLegacy(React)
10
11var Button = function (_ref) {
12  var children = _ref.children
13  return  React__default['default'].createElement(
14    'button',
15    {
16      style: {
17        color: 'blue',
18      },
19    },
20    children
21  )
22}
23
24module.exports = Button

然后我们使用 http-server 在 dist 目录下开启一个静态文件服务，则可以通过 http://localhost:8080/Button.js 获取到打包后的代码。

远程组件库介绍完毕，接下来介绍业务项目中如何使用。

接入远程组件库

我们使用 create-react-app 创建一个 React 应用，并新增一个 DynamicComponent 组件：

复制 1const DynamicComponent = ({name, children, ...props}) => {
 2  const Component = useMemo(() => {
 3    return React.lazy(async () => fetchComponent(name))
 4  }, [name])
 5
 6  return (
 7    <Suspense
 8      fallback={
 9        <div style={{alignItems: 'center', justifyContent: 'center', flex: 1}}>
10          <span style={{fontSize: 50}}>Loading...</span>
11        </div>
12      }>
13      <Component {...props}>{children}</Component>
14    </Suspense>
15  )
16}
17
18export default React.memo(DynamicComponent)

这里使用到了 React 中的 Suspense 组件和 React.lazy 方法，关于他们的用法这里不做过多解释，整个 DynamicComponent 组件的含义是远程加载目标组件，这个过程该组件会渲染传入 Suspense 参数 fallback 之中的内容，最后会使用加载成功的组件进行替换。接下来看看 fetchComponent 是如何实现的：

复制 1const fetchComponent = async (name) => {
 2  const text = await fetch(
 3    `http://127.0.0.1:8080/${name}.js?ts=${Date.now()}`
 4  ).then((a) => {
 5    if (!a.ok) {
 6      throw new Error('Network response was not ok')
 7    }
 8    return a.text()
 9  })
10  const module = getParsedModule(text, name)
11  return {default: module.exports}
12}

该方法会发起网络请求得到组件的代码，并交给 getParsedModule 去解析，最后得到模块返回。我们来看一下 getParsedModule 是怎么实现的：

复制 1const packages = {
 2  react: React,
 3}
 4
 5const getParsedModule = (code) => {
 6  let module = {
 7    exports: {},
 8  }
 9  const require = (name) => {
10    return packages[name]
11  }
12  Function('require, exports, module', code)(require, module.exports, module)
13  return module
14}

这里使用 Function 来运行传入的代码，因为打包远程组件的时候并没有将 react 库打包进去，所以这里需要实现 require 这个方法。

我们结合之前打包得到的 Button.js 来看这段代码，它其实同下面这个代码是等价的：

复制 1const packages = {
 2  react: React,
 3}
 4
 5const getParsedModule = (code, moduleName) => {
 6  let module = {
 7    exports: {},
 8  }
 9  const require = (name) => {
10    return packages[name]
11  }
12  ;((require, exports, module) => {
13    'use strict'
14
15    var React = require('react')
16
17    function _interopDefaultLegacy(e) {
18      return e && typeof e === 'object' && 'default' in e ? e : {default: e}
19    }
20
21    var React__default =  _interopDefaultLegacy(React)
22
23    var Button = function (_ref) {
24      var children = _ref.children
25      return  React__default['default'].createElement(
26        'button',
27        {
28          style: {
29            color: 'blue',
30          },
31        },
32        children
33      )
34    }
35
36    module.exports = Button
37  })(require, module.exports, module)
38  return module
39}

最后我们可以按照如下方式来使用 DynamicComponent 组件：

复制 1import DynamicComponent from './DynamicComponent'
 2
 3function App() {
 4  return (
 5    <div>
 6      <DynamicComponent name='Button'>Click Me</DynamicComponent>
 7      <DynamicComponent name='Text'>Remote Component</DynamicComponent>
 8    </div>
 9  )
10}
11
12export default App

现在我们尝试修改远程动态组件库中的组件，重新打包后就可以马上看到修改后的效果了。

本文介绍了一种实现远程动态组件的方式，不过比较简陋，事实上我们还有很多优化的空间。比如按照现在的实现方式，如果页面上面使用了两个 Button，会发起两次请求，这显然不合理。针对这个问题，我们可以通过提前加载以及模块缓存的方式来解决。