React Suspense 解决了什么 - 图1

本文介绍与 Suspense 在三种情景下使用方法，并结合源码进行相应解析。欢迎关注个人博客。

Code Spliting

在 16.6 版本之前，code-spliting 通常是由第三方库来完成的，比如 react-loadble(核心思路为: 高阶组件 + webpack dynamic import), 在 16.6 版本中提供了 Suspense 和 lazy 这两个钩子, 因此在之后的版本中便可以使用其来实现 Code Spliting。

目前阶段, 服务端渲染中的 code-spliting 还是得使用 react-loadable, 可查阅 React.lazy, 暂时先不探讨原因。

Code Spliting 在 React 中的使用方法是在 Suspense 组件中使用 <LazyComponent> 组件:

  1. import { Suspense, lazy } from 'react'
  3. const DemoA = lazy(() => import('./demo/a'))
  4. const DemoB = lazy(() => import('./demo/b'))
  6. <Suspense>
  7.   <NavLink to="/demoA">DemoA</NavLink>
  8.   <NavLink to="/demoB">DemoB</NavLink>
  10.   <Router>
  11.     <DemoA path="/demoA" />
  12.     <DemoB path="/demoB" />
  13.   </Router>
  14. </Suspense>

源码中 lazy 将传入的参数封装成一个 LazyComponent

  1. function lazy(ctor) {
  2.   return {
  3.     $$typeof: REACT_LAZY_TYPE, // 相关类型
  4.     _ctor: ctor,
  5.     _status: -1,   // dynamic import 的状态
  6.     _result: null, // 存放加载文件的资源
  7.   };
  8. }

观察 readLazyComponentType 后可以发现 dynamic import 本身类似 Promise 的执行机制, 也具有 Pending、Resolved、Rejected 三种状态, 这就比较好理解为什么 LazyComponent 组件需要放在 Suspense 中执行了(Suspense 中提供了相关的捕获机制, 下文会进行模拟实现`), 相关源码如下:

  1. function readLazyComponentType(lazyComponent) {
  2.   const status = lazyComponent._status;
  3.   const result = lazyComponent._result;
  4.   switch (status) {
  5.     case Resolved: { // Resolve 时，呈现相应资源
  6.       const Component = result;
  7.       return Component;
  8.     }
  9.     case Rejected: { // Rejected 时，throw 相应 error
  10.       const error = result;
  11.       throw error;
  12.     }
  13.     case Pending: {  // Pending 时, throw 相应 thenable
  14.       const thenable = result;
  15.       throw thenable;
  16.     }
  17.     default: { // 第一次执行走这里
  18.       lazyComponent._status = Pending;
  19.       const ctor = lazyComponent._ctor;
  20.       const thenable = ctor(); // 可以看到和 Promise 类似的机制
  21.       thenable.then(
  22.         moduleObject => {
  23.           if (lazyComponent._status === Pending) {
  24.             const defaultExport = moduleObject.default;
  25.             lazyComponent._status = Resolved;
  26.             lazyComponent._result = defaultExport;
  27.           }
  28.         },
  29.         error => {
  30.           if (lazyComponent._status === Pending) {
  31.             lazyComponent._status = Rejected;
  32.             lazyComponent._result = error;
  33.           }
  34.         },
  35.       );
  36.       // Handle synchronous thenables.
  37.       switch (lazyComponent._status) {
  38.         case Resolved:
  39.           return lazyComponent._result;
  40.         case Rejected:
  41.           throw lazyComponent._result;
  42.       }
  43.       lazyComponent._result = thenable;
  44.       throw thenable;
  45.     }
  46.   }
  47. }

Async Data Fetching

为了解决获取的数据在不同时刻进行展现的问题(在 suspenseDemo 中有相应演示), Suspense 给出了解决方案。

下面放两段代码，可以从中直观地感受在 Suspense 中使用 Async Data Fetching 带来的便利。

  • 一般进行数据获取的代码如下:
  1. export default class Demo extends Component {
  2.   state = {
  3.     data: null,
  4.   };
  6.   componentDidMount() {
  7.     fetchAPI(`/api/demo/${this.props.id}`).then((data) => {
  8.       this.setState({ data });
  9.     });
  10.   }
  12.   render() {
  13.     const { data } = this.state;
  15.     if (data == null) {
  16.       return <Spinner />;
  17.     }
  19.     const { name } = data;
  21.     return (
  22.       <div>{name}</div>
  23.     );
  24.   }
  25. }
  • 在 Suspense 中进行数据获取的代码如下:
  1. const resource = unstable_createResource((id) => {
  2.   return fetchAPI(`/api/demo`)
  3. })
  5. function Demo {
  6.   const data = resource.read(this.props.id)
  8.   const { name } = data;
  10.   return (
  11.     <div>{name}</div>
  12.   );
  13. }

可以看到在 Suspense 中进行数据获取的代码量相比正常的进行数据获取的代码少了将近一半！少了哪些地方呢?

  • 减少了 loading 状态的维护(在最外层的 Suspense 中统一维护子组件的 loading)
  • 减少了不必要的生命周期的书写

总结: 如何在 Suspense 中使用 Data Fetching

当前 Suspense 的使用分为三个部分:

第一步: 用 Suspens 组件包裹子组件

  1. import { Suspense } from 'react'
  3. <Suspense fallback={<Loading />}>
  4.   <ChildComponent>
  5. </Suspense>

第二步: 在子组件中使用 unstable_createResource:

  1. import { unstable_createResource } from 'react-cache'
  3. const resource = unstable_createResource((id) => {
  4.   return fetch(`/demo/${id}`)
  5. })

第三步: 在 Component 中使用第一步创建的 resource:

  1. const data = resource.read('demo')

相关思路解读

来看下源码中 unstable_createResource 的部分会比较清晰:

  1. export function unstable_createResource(fetch, maybeHashInput) {
  2.   const resource = {
  3.     read(input) {
  4.       ...
  5.       const result = accessResult(resource, fetch, input, key);
  6.       switch (result.status) {
  7.         case Pending: {
  8.           const suspender = result.value;
  9.           throw suspender;
  10.         }
  11.         case Resolved: {
  12.           const value = result.value;
  13.           return value;
  14.         }
  15.         case Rejected: {
  16.           const error = result.value;
  17.           throw error;
  18.         }
  19.         default:
  20.           // Should be unreachable
  21.           return (undefined: any);
  22.       }
  23.     },
  24.   };
  25.   return resource;
  26. }

结合该部分源码, 进行如下推测:

  1. 第一次请求没有缓存, 子组件 throw 一个 thenable 对象, Suspense 组件内的 componentDidCatch 捕获之, 此时展示 Loading 组件;
  2. 当 Promise 态的对象变为完成态后, 页面刷新此时 resource.read() 获取到相应完成态的值;
  3. 之后如果相同参数的请求, 则走 LRU 缓存算法, 跳过 Loading 组件返回结果(缓存算法见后记);

官方作者是说法如下:

React Suspense 解决了什么 - 图2

所以说法大致相同, 下面实现一个简单版的 Suspense:

  1. class Suspense extends React.Component {
  2.   state = {
  3.     promise: null
  4.   }
  6.   componentDidCatch(e) {
  7.     if (e instanceof Promise) {
  8.       this.setState({
  9.         promise: e
  10.       }, () => {
  11.         e.then(() => {
  12.           this.setState({
  13.             promise: null
  14.           })
  15.         })
  16.       })
  17.     }
  18.   }
  20.   render() {
  21.     const { fallback, children } = this.props
  22.     const { promise } = this.state
  23.     return <>
  24.       { promise ? fallback : children }
  25.     </>
  26.   }
  27. }

进行如下调用

  1. <Suspense fallback={<div>loading...</div>}>
  2.   <PromiseThrower />
  3. </Suspense>
  5. let cache = "";
  6. let returnData = cache;
  7. const fetch = () =>
  8.   new Promise(resolve => {
  9.     setTimeout(() => {
  10.       resolve("数据加载完毕");
  11.     }, 2000);
  12.   });
  14. class PromiseThrower extends React.Component {
  15.   getData = () => {
  16.     const getData = fetch();
  18.     getData.then(data => {
  19.       returnData = data;
  20.     });
  21.     if (returnData === cache) {
  22.       throw getData;
  23.     }
  24.     return returnData;
  25.   };
  27.   render() {
  28.     return <>{this.getData()}</>;
  29.   }
  30. }

React Suspense 解决了什么 - 图3

效果调试可以点击这里, 在 16.6 版本之后, componentDidCatch 只能捕获 commit phase 的异常。所以在 16.6 版本之后实现的 <PromiseThrower> 又有一些差异(即将 throw thenable 移到 componentDidMount 中进行)。

ConcurrentMode + Suspense

当网速足够快, 数据立马就获取到了，此时页面存在的 Loading 按钮就显得有些多余了。(在 suspenseDemo 中有相应演示), Suspense 在 Concurrent Mode 下给出了相应的解决方案, 其提供了 maxDuration 参数。用法如下:

  1. <Suspense maxDuration={500} fallback={<Loading />}>
  2.   ...
  3. </Suspense>

该 Demo 的效果为当获取数据的时间大于(是否包含等于还没确认) 500 毫秒, 显示自定义的 <Loading /> 组件, 当获取数据的时间小于 500 毫秒, 略过 <Loading> 组件直接展示用户的数据。相关源码。

需要注意的是 maxDuration 属性只有在 Concurrent Mode 下才生效, 可参考源码中的注释。在 Sync 模式下, maxDuration 始终为 0。

后记: 缓存算法

  • LRU 算法: Least Recently Used 最近最少使用算法(根据时间);
  • LFU 算法: Least Frequently Used 最近最少使用算法(根据次数);

漫画：什么是 LRU 算法

若数据的长度限定是 3, 访问顺序为 set(2,2),set(1,1),get(2),get(1),get(2),set(3,3),set(4,4), 则根据 LRU 算法删除的是 (1, 1), 根据 LFU 算法删除的是 (3, 3)。

react-cache 采用的是 LRU 算法。

相关资料