React Redux

介绍

Flux是一种架构思想，专门解决软件的问题。它跟MVC架构是同一类东西，但是更加简单和清晰。

Redux最主要是用作应用状态的管理。简言之，Redux用一个单独的常量状态树（state对象）保存着一整个应用的状态，这个对象不能直接被改变。当一些数据变化了，一个新的对象就会被创建（使用actions和reducers），这样就可以进行数据追踪，实现时光旅行。

安装

npm i redux

一、redux介绍及设计和使用的三大原则

• state以单一对象存储在state对象中
• state只读（每次都返回一个新的对象）
• 使用纯函数reducer执行state更新

二、redux工作流

类似订阅发布模式

  componentDidMount() {
    store.subscribe(() => {//订阅
      console.log("app 中订阅", store.getState())
      this.setState({
        isShow: store.getState().show
      })
    })
  }

注意：

1. 无store.subscribe()并不会报错，并且可以定义多个store.subscribe()，每次执行store.dispatch()都会遍历所有的store.subscribe()。
2. 如果在页面上直接绑定数据{store.getState().show}会页面不会渲染，其原因不是代码错误，而是未刷新DOM元素，众所周知this.setState()可以刷新DOM。

import React, { useEffect } from 'react'
import store from './store'
export default function Six() {
  useEffect(() => {
    console.log("create")
    store.dispatch({//发布
      type: "hide"
    })
    return () => {
      console.log("destory")
      store.dispatch({
        type: "show"
      })
    }
  }, [])
  return (
    <div>Six Hello world!!!</div>
  )
}

// 1. 引入redux
// 2. createStore(reducer)
import { createStore } from "redux";
const reducer = (prevState = {
  show: true
}, action) => {
  console.log(action)
  let newState = { ...prevState }
  switch (action.type) {
    case 'hide':
      newState.show = false
      console.log("aaa")
      return newState
    case 'show':
      newState.show = true
      console.log("bbb")
      return newState
    default:
      return prevState
  }
}
const store = createStore(reducer)
export default store

**注意：**组件销毁时订阅并不会被销毁，可能会造成每次打开组件时就创建一个订阅，多个订阅执行一个功能，造成了资源的浪费所以，可以在组件销毁时接触订阅。

useEffect(() => {
    var unsubscribe = store.subscribe(() => {
      console.log("eee")
    })
    return () => {
      // 取消订阅
      unsubscribe()
    }
  }, [])

三、Redux-reducer合并

根据需要把对象reducer，拆分为多个reducer对象，例：TabberReducer、WeatherReducer，并把它们分别放在多个文件中。最后使用combinReducers()方法合并。

const TabberReducer = (prevState = {
  show: true
}, action) => {
  console.log(222)
  console.log(action)
  let newState = { ...prevState }
  switch (action.type) {
    case 'hide':
      newState.show = false
      return newState
    case 'show':
      newState.show = true
      return newState
    default:
      return prevState
  }
}
export default TabberReducer

const WeatherReducer = (prevState = {
  name: "weather"
}, action) => {
  console.log(111)
  console.log(action)
  let newState = { ...prevState }
  switch (action.type) {
    case 'rain':
      newState.name = "rain"
      return newState
    case 'snow':
      newState.name = "snow"
      return newState
    default:
      return prevState
  }
}
export default WeatherReducer

// 1. 引入redux
// 2. createStore(reducer)
import { combineReducers, createStore } from "redux";
import TabberReducer from "./reducer/TabberReducer";
import WeatherReducer from "./reducer/WeatherReducer";

const reducer = combineReducers({
  TabberReducer,
  WeatherReducer
})
const store = createStore(reducer)
export default store

**注意：**使用事项

store.getState().WeatherReducer.name // 需要加WeatherReducer

四、redux中间件

在redux里，action仅仅是携带了数据的普通js对象。action creator返回的值是这个action类型的对象。然后通过store.dispath()进行分发。同步的情况下一切都很完美，但是redux无法处理异步的情况。

那么我们就需要在action和reducer中间架起一座桥梁来处理异步。这就是middleware

1 使用redux-thunk

安装

npm i redux-thunk

(1)在文件store.js中引入并使用中间件

import { applyMiddleware, combineReducers, createStore } from "redux";
import TabberReducer from "./reducer/TabberReducer";
import WeatherReducer from "./reducer/WeatherReducer";
import CityReducer from "./reducer/CityReducer";
import reduxThunk from 'redux-thunk' // 引入中间件

const reducer = combineReducers({
  TabberReducer,
  WeatherReducer,
  CityReducer
})

const store = createStore(reducer, applyMiddleware(reduxThunk)) //使用redux自带的方法applyMiddleware()方法使用中间件

export default store

(2)使用dispatch()方法

**注意：**此次dispatch()必须接收一个函数。

store.dispatch(getCityAction())

(3)getCityAction()进行异步请求并返回一个函数

import axios from "axios"
function getCityAction() {
  return (dispatch) => {
    axios.get("./test.json").then(res => {
      console.log(res.data.user)
      dispatch({
        type: "change-list",
        value: res.data.user
      })
    })
  }
}

export default getCityAction

2 使用redux-promise

安装

npm i redux-promise

(1)在文件store.js中引入并使用中间件

// 1. 引入redux
// 2. createStore(reducer)
import { applyMiddleware, combineReducers, createStore } from "redux";
import TabberReducer from "./reducer/TabberReducer";
import WeatherReducer from "./reducer/WeatherReducer";
import CityReducer from "./reducer/CityReducer";
import reduxThunk from 'redux-thunk'
import reduxPromise from 'redux-promise'

const reducer = combineReducers({
  TabberReducer,
  WeatherReducer,
  CityReducer
})

const store = createStore(reducer, applyMiddleware(reduxThunk, reduxPromise))

export default store

(2)异步请求函数改为

import axios from "axios"
function getUserAction() {
  return axios.get("./test.json").then(res => {
    console.log(res.data.user)
    return {
      type: "change-list",
      value: res.data.user
    }
  })
}

export default getUserAction

五、redux开发者工具

下载地址

https://github.com/zalmoxisus/redux-devtools-extension

配置文件

// 1. 引入redux
// 2. createStore(reducer)
import { applyMiddleware, combineReducers, createStore, compose } from "redux";// 导入createStore和compose
import TabberReducer from "./reducer/TabberReducer";
import WeatherReducer from "./reducer/WeatherReducer";
import CityReducer from "./reducer/CityReducer";
import reduxThunk from 'redux-thunk'
import reduxPromise from 'redux-promise'

const reducer = combineReducers({
  TabberReducer,
  WeatherReducer,
  CityReducer
})
const composeEnhancers = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose; // 增加这条语句

const store = createStore(reducer, composeEnhancers(applyMiddleware(reduxThunk, reduxPromise))) // 使用composeEnhancers包裹applyMiddleware

export default store

六、react-redux

安装

npm i react-redux

1 index.js代码

import React from "react";
import ReactDOM from "react-dom";
import { Provider } from "react-redux";//导入Provider
import App from './view/Five/App'
import './index.scss'
import store from './view/Five/store'//导入store，在跟组件中导入后，其他所有组件都无需再导入

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

2 使用connect

connect()可接收两个参数，（将来给孩子传的属性，将来给孩子传的回调函数）

可发现不再需要订阅

import React, { Component } from 'react'
import { connect } from 'react-redux'
import IndexRouter from './IndexRouter'

import Tabber from './tabber'
class App extends Component {
  state = {
    isShow: true
  }
  componentDidMount() {
    console.log(this.props)//一号输出结果
  }
  render() {
    return (
      <div>
        <IndexRouter>
          {this.state.isShow ? <Tabber></Tabber> : ""}
        </IndexRouter>
      </div>
    )
  }
}
export default connect((state) => {
  console.log(state)//二号输出结果
  return {
    a: 1,
    b: 1
  }
})(App)

一号输出结果

二号输出结果

import React, { useEffect } from 'react'
import { connect } from 'react-redux'
function Six(props) {
  let { show, hide, match } = props
  useEffect(() => {
    console.log("create")
    console.log(props) // 三号输出
    hide()
    return () => {
      console.log("destory")
      show()
    }
  }, [show, hide, match.params.myid])
  return (
    <div>Six Hello world!!!</div>
  )
}
export default connect(null, {
  hide() {
    return {
      type: "hide",
    }
  },
  show() {
    return {
      type: "show"
    }
  }
})(Six)

三号输出结果

（1）HOC与context通信在react-redux底层中的应用

1. connect是HOC，高阶组件
2. Provider组件，可以让容器组件拿到state，使用了context

（2）高阶组件构建与应用

HOC不仅仅是一个方法，确切说应该是一个组件工厂，获取低阶组件，生成高阶组件。

1. 代码复用，代码模块化
2. 增删改props
3. 渲染劫持

七、redux-persist

地址

https://github.com/rt2zz/redux-persist

安装

npm i redux-persist

（1）配置store.js文件

// 1. 引入redux
// 2. createStore(reducer)
import { applyMiddleware, combineReducers, createStore, compose } from "redux";
import TabberReducer from "./reducer/TabberReducer";
import WeatherReducer from "./reducer/WeatherReducer";
import CityReducer from "./reducer/CityReducer";
import reduxThunk from 'redux-thunk'
import reduxPromise from 'redux-promise'
import { persistStore, persistReducer } from 'redux-persist' // 导入
import storage from 'redux-persist/lib/storage' // defaults to localStorage for web
// 导入
const persistConfig = {
  key: 'rain',
  storage,
  whitelist: ['TabberReducer']// 白名单
}

const reducer = combineReducers({
  TabberReducer,
  WeatherReducer,
  CityReducer
})

const persistedReducer = persistReducer(persistConfig, reducer)

const composeEnhancers = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose;

const store = createStore(persistedReducer, composeEnhancers(applyMiddleware(reduxThunk, reduxPromise)))

let persistor = persistStore(store)

export { store, persistor }// 导出 store 和 persistor

（2）配置根组件

import React from "react";
import ReactDOM from "react-dom";
import { Provider } from "react-redux";
import App from './view/Five/App'
import './index.scss'
import { store, persistor } from './view/Five/store' // 导入
import { PersistGate } from "redux-persist/integration/react"; // 导入

// 使用PersistGate包裹
ReactDOM.render(
  <Provider store={store}>
    <PersistGate loading={null} persistor={persistor}>
      <App />
    </PersistGate>
  </Provider>
  , document.getElementById("root"))

运行结果发现，网页自动把store内容存在了网页的Local Storage中

未配置白名单效果：

配置白名单后效果：

还可以配置黑名单