# Redux之浅析中间件|原理篇

> 本文深入解析Redux中间件的原理、作用及其在Redux数据流中的应用，帮助开发者理解如何通过中间件扩展Redux功能，实现异步操作、日志记录等高级用法。

- 原文：https://feinterview.poetries.top/docs/principle-docs/react/05-Redux%E4%B9%8B%E6%B5%85%E6%9E%90%E4%B8%AD%E9%97%B4%E4%BB%B6
- 来源：前端进阶之旅（feinterview.poetries.top）
- 更新：2026.10.09

---

<!-- principle-learning-suite:start -->
<div class="article-learning-label">文章学习导航</div>

<div class="article-learning-label">面试总览</div>

- 中间件包装 `dispatch`，归约函数保持纯净
- `store => next => action` 分开取得能力与输入
- `next` 去下一层，`dispatch` 重走整条链
- 拦截、变换和继续都要明确契约
- 保留返回值，避免意外吞错与重复派发

**`Redux` 中间件是在动作到达状态计算前后加一层处理。** 每层拿到存储能力和下游派发函数，可以记录日志、执行函数动作或继续传递普通动作。调用 `next(action)` 才沿当前链往后走，用 `dispatch` 则通常从链头重新进入。写中间件时要同时关注动作、返回值和异常，漏传会丢更新，重复传则可能把一次操作执行多遍。

**版本校准：** 本文若分析 `ReactDOM.render`、旧生命周期或栈调和，应把它视为理解架构演进的历史路径。`React 19` 已移除 `ReactDOM.render`，当前客户端入口使用 `createRoot`；并发渲染也必须区分可中断的渲染阶段与同步提交阶段。迁移前对照 [React 19 官方升级指南](https://react.dev/blog/2024/04/25/react-19-upgrade-guide)。
<!-- principle-learning-suite:end -->

## 一、前言

- 在`redux`里，`middleware`是发送`action`和`action`到达`reducer`之间的第三方扩展，也就是中间层。也可以这样说，`middleware`是架在`action`和`store`之间的一座桥梁
- 在`redux`里，`action`仅仅是携带了数据的普通`js`对象

> `Reducer` 拆分可以使组件获取其最小属性(`state`)，而不需要整个`Store`。中间件则可以在`Action Creator` 返回最终可供 `dispatch` 调用的 `action` 之前处理各种事情，如异步`API`调用、日志记录等，是扩展 `Redux` 功能的一种推荐方式

- `Redux` 提供了 `applyMiddleware(...middlewares)` 来将中间件应用到 `createStore`。`applyMiddleware` 会返回一个函数，该函数接收原来的 `creatStore` 作为参数，返回一个应用了 `middlewares` 的增强后的 `creatStore`

```
export default function applyMiddleware(...middlewares) {
  return (createStore) => (reducer, preloadedState, enhancer) => {
    //接收createStore参数
    var store = createStore(reducer, preloadedState, enhancer)
    var dispatch = store.dispatch
    var chain = []

    //传递给中间件的参数
    var middlewareAPI = {
      getState: store.getState,
      dispatch: (action) => dispatch(action)
    }

    //注册中间件调用链
    chain = middlewares.map(middleware => middleware(middlewareAPI))
    dispatch = compose(...chain)(store.dispatch)

    //返回经middlewares增强后的createStore
    return {
      ...store,
      dispatch
    }
  }
}
```

> 未应用中间价之前，创建 `store` 的方式如下

```
import {createStore} from 'redux';
import reducers from './reducers/index';

export let store = createStore(reducers);
```

> 应用中间价之后，创建 `store`的方式如下

```
import {createStore，applyMiddleware} from 'redux';
import reducers from './reducers/index';

let createStoreWithMiddleware = applyMiddleware(...middleware)(createStore);
export let store = createStoreWithMiddleware(reducers);
```

## 二、为什么要引入middleware

- `action creator`返回的值是这个`action`类型的对象。然后通过`store.dispatch()`进行分发

```
action ---> dispatcher ---> reducers
```

> 如果遇到异步情况，比如点击一个按钮，希望2秒之后更新视图，显示消息“Hi”。我们可能这么写`ActionCreator`

```
var asyncSayActionCreator = function (message) {
    setTimeout(function () {
        return {
            type: 'SAY',
            message
        }
    }, 2000)
}
```

> 这会报错，因为这个`asyncSayActionCreator`返回的不是一个`action`，而是一个`function`。这个返回值无法被`reducer`识别

- 也就是说，正常来说，`action`返回的是一个对象，而不是一个函数。如果返回函数，会出现错误
- 　而异步操作呢，需要`action`的返回值是一个函数。那么咋办呢，所以需要引入中间件`middleware`,它在中间起到了桥梁的作用，让`action`的返回值可以是一个函数，从而传到`reducer`那里。也就是说，中间件是用在`action`发起之后，`reducer`接收到之前的这个时间段
- 也可以这么说，`Middleware` 主要是负责改变`Store`中的`dispatch`方法，从而能处理不同类型的 `action` 输入，得到最终的 `Javascript Plain Object` 形式的 `action` 对象

> 因此，上面那个`ActionCreator`就可以改写为这样：因为`action`的返回值是一个函数

```
var asyncSayActionCreator = function (message) {
    return function (dispatch) {
        setTimeout(function () {
            dispatch({
                type: 'SAY',
                message
            })
        }, 2000)
    }
}
```

![img](https://s.poetries.top/gitee/2019/10/466.png)

- 上图表达的是 `redux` 中一个简单的同步数据流动的场景，点击`button` 后，在回调中 `dispatch` 一个 `action`，`reducer` 收到`action` 后，更新 `state` 并通知 `view` 重新渲染

![img](https://s.poetries.top/gitee/2019/10/467.png)

- 上面这张图展示了应用

  ```
  middleware
  ```

   

  后

   

  ```
  redux
  ```

   

  处理事件的逻辑，每一个

   

  ```
  middleware
  ```

   

  处理一个相对独立的业务需求，通过串联不同的

   

  ```
  middleware
  ```

  ，实现变化多样的的功能。那么问题来了：

  - `middleware` 怎么写？
  - `redux`是如何让 `middlewares` 串联并跑起来的？

## 三、中间件是如何工作的

> ```
> Middleware`的中间件有很多，不过我的这个案例只引用了其中的一个，那就是`redux-thunk
> ```

- `redux-thunk`源码如下

```
export default function thunkMiddleware({ dispatch, getState }) {
  return next => action =>
    typeof action === 'function' ?
      action(dispatch, getState) :
      next(action);
}
```

> 意思是如果`action`是一个函数，执行这个`action`函数，如果不是函数，执行`next`函数

## 四、自定义中间件

> 中间件的签名如下

```
({ getState, dispatch }) => next => action
```

> 根据`applyMiddleware` 源码，每个中间件接收 `getState & dispatch`作为参数，并返回一个函数，该函数会被传入下一个中间件的 dispatch 方法，并返回一个接收 `action` 的新函数

- 应用多个中间件时，中间件调用链中任何一个缺少 `next(action)` 的调用，都会导致`action` 执行失败

```
function callTraceMiddleware ({dispatch,getState}){
    return next=> action =>{
        console.trace();
        return next(action);
    }
}
```

- 然后在调用中间件部分添加中间件

```
const createStoreWithMiddleware = applyMiddleware(
  thunkMiddleware,
  loggerMiddleware,
  callTraceMiddleware
)(createStore);
```

> `redux`的`middleware`是对`action`进行扩展处理，这样丰富了应用需求

<!-- principle-followup:start -->
- **日志要打印更新前后状态，放在哪里？**

  在调用 `next(action)` 前后分别读取状态，并返回下游结果。前提是下游对该动作按同步约定完成状态计算。

- **中间件里直接再派发同一个动作，会怎样？**

  它可能从链头重新经过自己，造成无限递归。继续当前动作通常用 `next`，另派动作也要设计好触发条件。

- **不关心的动作要怎么处理？**

  直接返回 `next(action)`。中间件只处理自己的职责范围，其他动作继续走后面的链。

- **改一下动作对象再往后传，有什么隐患？**

  上游日志或其他持有者可能看到被悄悄修改的内容。需要变换时创建明确的新对象，保持动作含义和调试记录可理解。

<!-- principle-followup:end -->
