前言

一般action作为一个对象传入store，reducer直接计算好state结果即可。但是，有一种常用的情况就是向服务端获取数据，这种异步操作该怎么办？

一、异步 Action

首先，当调用异步 API 时，有两个非常关键的时刻：发起请求的时刻，和接收到响应的时刻。这两个时刻都可能会更改应用的 state，比如：开始请求时需要页面展示一个loading状态，收到数据后展示新数据。所以，我需要在不同时刻 dispatch 不同类型的 action，比如开始，成功，异常的action等等。

如何把action和网络请求结合起来呢？

站在框架作者的角度，看了看action，reducer，store三个模块，想来想去决定修改包装一下store中的store.dispatch()方法，就是要在action发出后，执行reducer之前动手脚，重新包装下dispatch，在这个过程中处理异步请求。我们可能遇到如下这种情况，点击一个按钮，发送异步请求后再修改状态，也就是当action是个函数的时候：

//  点击出发asyncAdd执行
const asyncAdd = () => {
    store.dispatch((dispatch) => {
        setTimeout(() => {
            dispatch({ type: "add" })
        }, 1000);
    });
}

那么就需要引入中间件来帮我们解决这个问题。

二、中间件

接着上面，Action一般是个对象，当 Action为函数时，reducer就不好处理了，所以需要中间件处理这个返回的函数。比如，这个函数会被 Redux Thunk middleware 执行。此外，这个函数还可以 dispatch 一个action，就像 dispatch 前面定义的同步 action 一样，中间件redux-thunk究竟长什么样才能完成这个功能，又是如何使用的呢？

使用中间件

import { createStore, applyMiddleware } from "redux";
import logger from "redux-logger";
import thunk from "redux-thunk";

function reducer(currentState = 0, action) {
    switch (action.type) {
        case 'add':
            return currentState + 1
            break;
        case 'minus':
            return currentState - 1
            break;
        default:
            return currentState
            break;
    }
}
// 使用redux提供的applyMiddleware将中间件进行聚合
const store = createStore(reducer, applyMiddleware(thunk, logger));
export default store;

createStore：redux中暴露的一个方法，定义一个store对象，并定义了store的方法，如store.dispatch；
reducer：根据项目需求自己写的纯函数；
thunk：redux-thunk中间件函数；
applyMiddleware：redux中暴露的一个方法，用于引入中间件，返回一个可以对createStore进行加强的函数，我们可以称之为enhancer；

接下来的问题来了，applyMiddleware，thunk，createStore分别长什么样，是怎么一起配合的？

createStore源码如下：

import $$observable from 'symbol-observable'

import ActionTypes from './utils/actionTypes'
import isPlainObject from './utils/isPlainObject'

export default function createStore(reducer, preloadedState, enhancer) {
  if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {
    enhancer = preloadedState
    preloadedState = undefined
  }
  // enhancer应该为一个函数
  if (typeof enhancer !== 'undefined') {
    if (typeof enhancer !== 'function') {
      throw new Error('Expected the enhancer to be a function.')
    }
    //enhancer 接受 createStore 作为参数，对  createStore 的能力进行增强，并返回增强后的  createStore 。
    //  然后再将  reducer 和  preloadedState 作为参数传给增强后的  createStore ，最终得到生成的 store
    return enhancer(createStore)(reducer, preloadedState)
  }
  // reducer必须是函数
  if (typeof reducer !== 'function') {
    throw new Error('Expected the reducer to be a function.')
  }

 // 初始化参数
  let currentReducer = reducer   // 当前整个reducer
  let currentState = preloadedState   // 当前的state,也就是getState返回的值
  let currentListeners = []  // 当前的订阅store的监听器
  let nextListeners = currentListeners // 下一次的订阅
  let isDispatching = false // 是否处于 dispatch action 状态中, 默认为false

  // 这个函数用于确保currentListeners 和 nextListeners 是不同的引用
  function ensureCanMutateNextListeners() {
    if (nextListeners === currentListeners) {
      nextListeners = currentListeners.slice()
    }
  }

  // 返回state
  function getState() {
    if (isDispatching) {
      throw new Error(
        ......
      )
    }
    return currentState
  }

  // 添加订阅
  function subscribe(listener) {
  ......
    }
  }
// 分发action
  function dispatch(action) {
    ......
  }

  //这个函数主要用于 reducer 的热替换，用的少
  function replaceReducer(nextReducer) {
    if (typeof nextReducer !== 'function') {
      throw new Error('Expected the nextReducer to be a function.')
    }
    // 替换reducer
    currentReducer = nextReducer
    // 重新进行初始化
    dispatch({ type: ActionTypes.REPLACE })
  }

  // 没有研究，暂且放着，它是不直接暴露给开发者的，提供了给其他一些像观察者模式库的交互操作。
  function observable() {
    ......
  }

  // 创建一个store时的默认state
  // 用于填充初始的状态树
  dispatch({ type: ActionTypes.INIT })

  return {
    dispatch,
    subscribe,
    getState,
    replaceReducer,
    [$$observable]: observable
  }
}

上面代码先不管其他的，就看这一句： return enhancer(createStore)(reducer, preloadedState)；我们知道enhancer是applyMiddleware(thunk, promise, logger)返回的增强函数，这个函数可以处理createStore，enhancer(createStore)得到的是一个已经被加强了的createStore，这个加强了的createStore函数可以接收一些参数来创建store，包装dispatch，并返回store。

applyMiddleware源码如下：

export default function applyMiddleware(...middlewares) {
  return createStore => (...args) => {
    // 利用传入的createStore和reducer和创建一个store
    const store = createStore(...args)
    let dispatch = () => {
      throw new Error(
      )
    }
    const middlewareAPI = {
      getState: store.getState,
      dispatch: (...args) => dispatch(...args)
    }
    // 让每个 middleware 带着 middlewareAPI 这个参数分别执行一遍
    const chain = middlewares.map(middleware => middleware(middlewareAPI))
    // 接着 compose 将 chain 中的所有匿名函数，组装成一个新的函数，即新的 dispatch
    dispatch = compose(...chain)(store.dispatch)
    return {
      ...store,
      dispatch
    }
  }
}

这里又出现了一个compose，我们来看看它有什么用？

compose 源码如下：

compose 可以接受一组函数参数，将这一组函数从右到左一层层嵌套，然后返回一个组合函数。

export default function compose(...funcs) {
  if (funcs.length === 0) {
    return arg => arg
  }

  if (funcs.length === 1) {
    return funcs[0]
  }

  return funcs.reduce((a, b) => (...args) => a(b(...args)))
}

上面代码中...funcs对应了一组函数序列，是个解构赋值的写法，funcs代表一个函数数组，数组方法reduce进行数组遍历迭代，将数组前两项a,b组合成一个组合函数,使b函数执行完返回的值能作为a函数的参数，以此类推。例如：

compose(funcA, funcB, funcC)

得到的是：

(...args) =>funcA(funcB(funcC(...args)))

此时再与applyMiddleware源码联系在一起看，这个...args参数就是store.dispatch，其用意在于，先将其传给funcC就行改造，改造完成后将改造后的dispatch方法传给funcB,以此类推，目的在于可以后一个中间件可以接着处理前一个中间件改造后的dispatch。

中间件redux-thunk：

function createThunkMiddleware(extraArgument) {
  return ({ dispatch, getState }) => next => action => {
    if (typeof action === 'function') {
      return action(dispatch, getState, extraArgument);
    }
    return next(action);
  };
}
const thunk = createThunkMiddleware();
thunk.withExtraArgument = createThunkMiddleware;
export default thunk;

上面代码，next代表下一个中间件函数，action代表上面Action Creator返回的那个函数。 redux-thunk 中间件的功能也很简单，createThunkMiddleware返回一个函数，这个函数检查参数 action 的类型，如果是函数的话，就执行这个 action 函数，并把 dispatch, getState, extraArgument 作为参数传递进去，否则就调用 next 让下一个中间件继续处理 action 。