深刻Redux架构

时间  2020-05-14
标签 深刻 redux 架构 栏目 系统架构 繁體版
原文   原文链接

关于redux

以前写了一篇经过一个demo了解Redux，但对于redux的核心方法没有进行深刻剖析，在此从新总结学习，完整的代码看这里。(参考了React 技术栈系列教程)react

 

什么状况须要用redux？json

  • 用户的使用方式复杂redux

  • 不一样身份的用户有不一样的使用方式（好比普通用户和管理员）promise

  • 多个用户之间能够协做服务器

  • 与服务器大量交互，或者使用了WebSocketapp

  • View要从多个来源获取数据框架

简单说，若是你的UI层很是简单，没有不少互动，Redux 就是没必要要的，用了反而增长复杂性。多交互、多数据源场景就比较适合使用Redux。异步

设计思想：ide

  • Web 应用是一个状态机，视图与状态是一一对应的。函数

  • 全部的状态，保存在一个对象里面。

Redux工做流程:

首先，用户发出 Action。

store.dispatch(action);

而后，Store 自动调用 Reducer，而且传入两个参数：当前 State 和收到的 Action。 Reducer 会返回新的 State 。

let nextState = todoApp(previousState, action);

State 一旦有变化，Store 就会调用监听函数。

// 设置监听函数store.subscribe(listener);

listener能够经过store.getState()获得当前状态。若是使用的是 React，这时能够触发从新渲染 View。

function listerner() {
  let newState = store.getState();
  component.setState(newState);   
}

若是如今没理解以上流程，不要急，看完如下API就差很少能懂得Redux的核心机制了。

回到顶部(go to top)

API

Store

Store 就是保存数据的地方，你能够把它当作一个容器。整个应用只能有一个 Store。

Redux 提供createStore这个函数，用来生成 Store。

下面代码中，createStore函数接受另外一个函数做为参数，返回新生成的 Store 对象。

import { createStore } from 'redux';
const store = createStore(fn);

 

State

Store对象包含全部数据。若是想获得某个时点的数据，就要对 Store 生成快照。这种时点的数据集合，就叫作 State。

当前时刻的 State，能够经过store.getState()拿到。

import { createStore } from 'redux';
const store = createStore(fn);

const state = store.getState();

Redux 规定， 一个 State 对应一个 View。只要 State 相同，View 就相同。你知道 State，就知道 View 是什么样，反之亦然。

 

Action

State 的变化，会致使 View 的变化。可是，用户接触不到 State，只能接触到 View。因此，State 的变化必须是 View 致使的。Action 就是 View 发出的通知，表示 State 应该要发生变化了。

Action 是一个对象。其中的type属性是必须的，表示 Action 的名称。其余属性能够自由设置，社区有一个规范能够参考。

const action = {
  type: 'ADD_TODO',
  payload: 'Learn Redux'};

上面代码中，Action 的名称是ADD_TODO，它携带的信息是字符串Learn Redux。

能够这样理解，Action 描述当前发生的事情。改变 State 的惟一办法，就是使用 Action。它会运送数据到 Store。

 

Action Creator

View 要发送多少种消息，就会有多少种 Action。若是都手写，会很麻烦。能够定义一个函数来生成 Action，这个函数就叫 Action Creator。

复制代码

const ADD_TODO = '添加 TODO';function addTodo(text) {  return {
    type: ADD_TODO,
    text
  }
}

const action = addTodo('Learn Redux');

复制代码

 

store.dispatch()

store.dispatch()是 View 发出 Action 的惟一方法。

复制代码

import { createStore } from 'redux';
const store = createStore(fn);

store.dispatch({
  type: 'ADD_TODO',
  payload: 'Learn Redux'});

复制代码

上面代码中，store.dispatch接受一个 Action 对象做为参数，将它发送出去。

结合 Action Creator，这段代码能够改写以下。

store.dispatch(addTodo('Learn Redux'));

 

Reducer

Store 收到 Action 之后，必须给出一个新的 State，这样 View 才会发生变化。这种 State 的计算过程就叫作 Reducer。

Reducer 是一个函数，它接受 Action 和当前 State 做为参数，返回一个新的 State。下面是一个实际的例子

复制代码

const defaultState = 0;
const reducer = (state = defaultState, action) => {  switch (action.type) {    case 'ADD':      return state + action.payload;    default: 
      return state;
  }
};

const state = reducer(1, {
  type: 'ADD',
  payload: 2});

复制代码

上面代码中，reducer函数收到名为ADD的 Action 之后，就返回一个新的 State，做为加法的计算结果。其余运算的逻辑（好比减法），也能够根据 Action 的不一样来实现。

实际应用中，Reducer 函数不用像上面这样手动调用，store.dispatch方法会触发 Reducer 的自动执行。为此，Store 须要知道 Reducer 函数，作法就是在生成 Store 的时候，将 Reducer 传入createStore方法。

import { createStore } from 'redux';
const store = createStore(reducer);

上面代码中，createStore接受 Reducer 做为参数，生成一个新的 Store。之后每当store.dispatch发送过来一个新的 Action，就会自动调用 Reducer，获得新的 State。

 

store.subscribe()

Store 容许使用store.subscribe方法设置监听函数，一旦 State 发生变化，就自动执行这个函数。

import { createStore } from 'redux';
const store = createStore(reducer);

store.subscribe(listener);

显然，只要把 View 的更新函数（对于 React 项目，就是组件的render方法或setState方法）放入listen，就会实现 View 的自动渲染。

store.subscribe方法返回一个函数，调用这个函数就能够解除监听。

let unsubscribe = store.subscribe(() =>
  console.log(store.getState())
);

unsubscribe();

回到顶部(go to top)

中间件与异步操做

一个关键问题没有解决：异步操做怎么办？Action 发出之后，Reducer 当即算出 State，这叫作同步；Action 发出之后，过一段时间再执行 Reducer，这就是异步。

怎么才能 Reducer 在异步操做结束后自动执行呢？这就要用到新的工具：中间件（middleware）。

为了理解中间件，让咱们站在框架做者的角度思考问题：若是要添加功能，你会在哪一个环节添加？

（1）Reducer：纯函数，只承担计算 State 的功能，不合适承担其余功能，也承担不了，由于理论上，纯函数不能进行读写操做。

（2）View：与 State 一一对应，能够看做 State 的视觉层，也不合适承担其余功能。

（3）Action：存放数据的对象，即消息的载体，只能被别人操做，本身不能进行任何操做。

想来想去，只有发送 Action 的这个步骤，即store.dispatch()方法，能够添加功能。

中间件的用法

本文不涉及如何编写中间件，由于经常使用的中间件都有现成的，只要引用别人写好的模块便可。好比，上一节的日志中间件，就有现成的redux-logger模块。这里只介绍怎么使用中间件。

复制代码

import { applyMiddleware, createStore } from 'redux';
import createLogger from 'redux-logger';
const logger = createLogger();

const store = createStore(
  reducer,
  applyMiddleware(logger)
);

复制代码

上面代码中，redux-logger提供一个生成器createLogger，能够生成日志中间件logger。而后，将它放在applyMiddleware方法之中，传入createStore方法，就完成了store.dispatch()的功能加强。

这里有两点须要注意：

（1）createStore方法能够接受整个应用的初始状态做为参数，那样的话，applyMiddleware就是第三个参数了。

const store = createStore(
  reducer,
  initial_state,
  applyMiddleware(logger)
);

（2）中间件的次序有讲究。

const store = createStore(
  reducer,
  applyMiddleware(thunk, promise, logger)
);

上面代码中，applyMiddleware方法的三个参数，就是三个中间件。有的中间件有次序要求，使用前要查一下文档。好比，logger就必定要放在最后，不然输出结果会不正确。

回到顶部(go to top)

异步操做的基本思路

理解了中间件之后，就能够处理异步操做了。

同步操做只要发出一种 Action 便可，异步操做的差异是它要发出三种 Action。

  • 操做发起时的 Action

  • 操做成功时的 Action

  • 操做失败时的 Action

以向服务器取出数据为例，三种 Action 能够有两种不一样的写法。

复制代码

// 写法一：名称相同，参数不一样{ type: 'FETCH_POSTS' }
{ type: 'FETCH_POSTS', status: 'error', error: 'Oops' }
{ type: 'FETCH_POSTS', status: 'success', response: { ... } }// 写法二：名称不一样{ type: 'FETCH_POSTS_REQUEST' }
{ type: 'FETCH_POSTS_FAILURE', error: 'Oops' }
{ type: 'FETCH_POSTS_SUCCESS', response: { ... } }

复制代码

除了 Action 种类不一样，异步操做的 State 也要进行改造，反映不一样的操做状态。下面是 State 的一个例子。

复制代码

let state = {  // ... 
  isFetching: true,
  didInvalidate: true,
  lastUpdated: 'xxxxxxx'};

复制代码

上面代码中，State 的属性isFetching表示是否在抓取数据。didInvalidate表示数据是否过期，lastUpdated表示上一次更新时间。

如今，整个异步操做的思路就很清楚了。

  • 操做开始时，送出一个 Action，触发 State 更新为"正在操做"状态，View 从新渲染

  • 操做结束后，再送出一个 Action，触发 State 更新为"操做结束"状态，View 再一次从新渲染

redux-thunk中间件

异步操做至少要送出两个 Action：用户触发第一个 Action，这个跟同步操做同样，没有问题；如何才能在操做结束时，系统自动送出第二个 Action 呢？

奥妙就在 Action Creator 之中。

复制代码

class AsyncApp extends Component {
  componentDidMount() {
    const { dispatch, selectedPost } = this.props
    dispatch(fetchPosts(selectedPost))
  }// ...

复制代码

上面代码是一个异步组件的例子。加载成功后（componentDidMount方法），它送出了（dispatch方法）一个 Action，向服务器要求数据 fetchPosts(selectedSubreddit)。这里的fetchPosts就是 Action Creator。

下面就是fetchPosts的代码，关键之处就在里面。

复制代码

const fetchPosts = postTitle => (dispatch, getState) => {
  dispatch(requestPosts(postTitle));  return fetch(`/some/API/${postTitle}.json`)
    .then(response => response.json())
    .then(json => dispatch(receivePosts(postTitle, json)));
  };
};// 使用方法一store.dispatch(fetchPosts('reactjs'));// 使用方法二store.dispatch(fetchPosts('reactjs')).then(() =>
  console.log(store.getState())
);

复制代码

上面代码中，fetchPosts是一个Action Creator（动做生成器），返回一个函数。这个函数执行后，先发出一个Action（requestPosts(postTitle)），而后进行异步操做。拿到结果后，先将结果转成 JSON 格式，而后再发出一个 Action（ receivePosts(postTitle, json)）。

上面代码中，有几个地方须要注意。

（1）fetchPosts返回了一个函数，而普通的 Action Creator 默认返回一个对象。

（2）返回的函数的参数是dispatch和getState这两个 Redux 方法，普通的 Action Creator 的参数是 Action 的内容。

（3）在返回的函数之中，先发出一个 Action（requestPosts(postTitle)），表示操做开始。

（4）异步操做结束以后，再发出一个 Action（receivePosts(postTitle, json)），表示操做结束。

这样的处理，就解决了自动发送第二个 Action 的问题。可是，又带来了一个新的问题，Action 是由store.dispatch方法发送的。而store.dispatch方法正常状况下，参数只能是对象，不能是函数。

这时，就要使用中间件redux-thunk。

复制代码

import { createStore, applyMiddleware } from 'redux';
import thunk from 'redux-thunk';
import reducer from './reducers';// Note: this API requires redux@>=3.1.0const store = createStore(
  reducer,
  applyMiddleware(thunk)
);

复制代码

上面代码使用redux-thunk中间件，改造store.dispatch，使得后者能够接受函数做为参数。

所以，异步操做的第一种解决方案就是，写出一个返回函数的 Action Creator，而后使用redux-thunk中间件改造store.dispatch。

回到顶部(go to top)

React-Redux的用法

为了方便使用，Redux 的做者封装了一个 React 专用的库 React-Redux，本文主要介绍它。

这个库是能够选用的。实际项目中，你应该权衡一下，是直接使用 Redux，仍是使用 React-Redux。后者虽然提供了便利，可是须要掌握额外的 API，而且要遵照它的组件拆分规范。

React-Redux 将全部组件分红两大类：UI 组件（presentational component）和容器组件（container component）。

UI组件

UI 组件有如下几个特征。

  • 只负责 UI 的呈现，不带有任何业务逻辑

  • 没有状态（即不使用this.state这个变量）

  • 全部数据都由参数（this.props）提供

  • 不使用任何 Redux 的 API

下面就是一个 UI 组件的例子。

const Title =
  value => <h1>{value}</h1>;

由于不含有状态，UI 组件又称为"纯组件"，即它纯函数同样，纯粹由参数决定它的值。

容器组件

容器组件的特征偏偏相反。

  • 负责管理数据和业务逻辑，不负责 UI 的呈现

  • 带有内部状态

  • 使用 Redux 的 API

总之，只要记住一句话就能够了：UI 组件负责 UI 的呈现，容器组件负责管理数据和逻辑。

你可能会问，若是一个组件既有 UI 又有业务逻辑，那怎么办？回答是，将它拆分红下面的结构：外面是一个容器组件，里面包了一个UI 组件。前者负责与外部的通讯，将数据传给后者，由后者渲染出视图。

React-Redux 规定，全部的 UI 组件都由用户提供，容器组件则是由 React-Redux 自动生成。也就是说，用户负责视觉层，状态管理则是所有交给它。

 

connect()

React-Redux 提供connect方法，用于从 UI 组件生成容器组件。connect的意思，就是将这两种组件连起来。

connect方法的完整 API 以下。

复制代码

import { connect } from 'react-redux'const VisibleTodoList = connect(
  mapStateToProps,
  mapDispatchToProps
)(TodoList)

复制代码

上面代码中，TodoList是 UI 组件，VisibleTodoList就是由 React-Redux 经过connect方法自动生成的容器组件。connect方法接受两个参数：mapStateToProps和mapDispatchToProps。它们定义了 UI 组件的业务逻辑。前者负责输入逻辑，即将state映射到 UI 组件的参数（props），后者负责输出逻辑，即将用户对 UI 组件的操做映射成 Action。

 

mapStateToProps

mapStateToProps是一个函数。它的做用就是像它的名字那样，创建一个从（外部的）state对象到（UI 组件的）props对象的映射关系。

做为函数，mapStateToProps执行后应该返回一个对象，里面的每个键值对就是一个映射。请看下面的例子。

const mapStateToProps = (state) => {  return {
    todos: getVisibleTodos(state.todos, state.visibilityFilter)
  }
}

上面代码中，mapStateToProps是一个函数，它接受state做为参数，返回一个对象。这个对象有一个todos属性，表明 UI 组件的同名参数，后面的getVisibleTodos也是一个函数，能够从state算出 todos 的值。

下面就是getVisibleTodos的一个例子，用来算出todos。

复制代码

const getVisibleTodos = (todos, filter) => {  switch (filter) {    case 'SHOW_ALL':      return todos    case 'SHOW_COMPLETED':      return todos.filter(t => t.completed)    case 'SHOW_ACTIVE':      return todos.filter(t => !t.completed)    default:      throw new Error('Unknown filter: ' + filter)
  }
}

复制代码

mapStateToProps会订阅 Store，每当state更新的时候，就会自动执行，从新计算 UI 组件的参数，从而触发 UI 组件的从新渲染。

mapStateToProps的第一个参数老是state对象，还可使用第二个参数，表明容器组件的props对象。

复制代码

// 容器组件的代码//    <FilterLink filter="SHOW_ALL">//      All//    </FilterLink>const mapStateToProps = (state, ownProps) => {  return {
    active: ownProps.filter === state.visibilityFilter
  }
}

复制代码

使用ownProps做为参数后，若是容器组件的参数发生变化，也会引起 UI 组件从新渲染。

connect方法能够省略mapStateToProps参数，那样的话，UI 组件就不会订阅Store，就是说 Store 的更新不会引发 UI 组件的更新。

 

mapDispatchToProps()

mapDispatchToProps是connect函数的第二个参数，用来创建 UI 组件的参数到store.dispatch方法的映射。也就是说，它定义了哪些用户的操做应该看成 Action，传给 Store。它能够是一个函数，也能够是一个对象。

若是mapDispatchToProps是一个函数，会获得dispatch和ownProps（容器组件的props对象）两个参数。

复制代码

const mapDispatchToProps = (
  dispatch,
  ownProps
) => {  return {
    onClick: () => {
      dispatch({
        type: 'SET_VISIBILITY_FILTER',
        filter: ownProps.filter
      });
    }
  };
}

复制代码

从上面代码能够看到，mapDispatchToProps做为函数，应该返回一个对象，该对象的每一个键值对都是一个映射，定义了 UI 组件的参数怎样发出 Action。

若是mapDispatchToProps是一个对象，它的每一个键名也是对应 UI 组件的同名参数，键值应该是一个函数，会被看成 Action creator ，返回的 Action 会由 Redux 自动发出。举例来讲，上面的mapDispatchToProps写成对象就是下面这样。

复制代码

const mapDispatchToProps = {
  onClick: (filter) => {
    type: 'SET_VISIBILITY_FILTER',
    filter: filter
  };
}

复制代码

 

<Provider>组件

connect方法生成容器组件之后，须要让容器组件拿到state对象，才能生成 UI 组件的参数。React-Redux 提供Provider组件，可让容器组件拿到state。

复制代码

import { Provider } from 'react-redux'import { createStore } from 'redux'import todoApp from './reducers'import App from './components/App'let store = createStore(todoApp);

render(  <Provider store={store}>
    <App />
  </Provider>,
  document.getElementById('root')
)

复制代码

上面代码中，Provider在根组件外面包了一层，这样一来，App的全部子组件就默认均可以拿到state了。

React-Router路由库

使用React-Router的项目，与其余项目没有不一样之处，也是使用Provider在Router外面包一层，毕竟Provider的惟一功能就是传入store对象。

复制代码

const Root = ({ store }) => (  <Provider store={store}>
    <Router>
      <Route path="/" component={App} />
    </Router>
  </Provider>
);

复制代码

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程