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

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

- 原文：https://feinterview.poetries.top/docs/principle-docs/react/08-%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>

- 中间件在派发边界组合处理能力
- `next` 继续当前链，`dispatch` 从入口再派发
- 函数动作需要专门中间件执行
- 顺序决定看到的动作形态与前后状态
- 继续传递时返回下游结果

**中间件是在动作进入状态计算前后插入可组合的处理层。** 日志、异步编排和动作校验都可以放在这里，归约函数继续只做状态计算。每层决定拦截还是调用 `next` 继续，顺序则决定日志看到函数动作还是最终普通动作。编写时不要只关心动作有没有到达，还要保留返回值与异常传播，避免调用方失去等待异步完成的能力。

**版本校准：** 原理文章中的代码代表特定实现与写作时间。应用到当前项目时，应先确认浏览器、框架或工具的主版本，再区分稳定的规范语义、可变化的内部实现和项目自身约束。
<!-- 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`

```javascript
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` 的方式如下

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

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

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

```javascript
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()`进行分发

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

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

```javascript
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`的返回值是一个函数

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

![](https://s.poetries.top/images/20210427115937.png)

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

![](https://s.poetries.top/images/20210427115946.png)

- 上面这张图展示了应用` middleware` 后 `redux` 处理事件的逻辑，每一个 `middleware` 处理一个相对独立的业务需求，通过串联不同的 `middleware`，实现变化多样的的功能。那么问题来了：
  - `middleware` 怎么写？
  - `redux `是如何让 `middlewares` 串联并跑起来的？

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

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

- `redux-thunk`源码如下

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

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

## 四、自定义中间件

> 中间件的签名如下

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

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

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

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

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

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

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

<!-- principle-followup:start -->
- **日志中间件放在函数中间件前后，有区别吗？**

  有，放在前面可能看到函数动作，放在后面通常只看到继续传递的普通动作。按需要记录的边界安排顺序。

- **只想记录，不想改变行为，最小实现注意什么？**

  记录后返回 `next(action)`，不要额外派发或吞掉异常。这样下游处理与返回契约尽量保持原状。

- **中间件为什么分成三层函数？**

  各层分别接收存储能力、下一层函数和当前动作。前两层在组装链时确定，最内层在每次派发时执行。

- **忘了放行一个不认识的动作，会怎样？**

  后续链和归约函数收不到它，界面就可能没有预期更新。不属于当前中间件职责的动作通常直接继续传递。

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