Vuex源码分析(转)

当我们用vue在开发的过程中，经常会遇到以下问题

多个vue组件共享状态

Vue组件间的通讯

在项目不复杂的时候，我们会利用全局事件bus的方式解决,但随着复杂度的提升，用这种方式将会使得代码难以维护，因此vue官网推荐了一种更好用的解决方案Vuex。

Vuex是什么

Vuex 是一个专为 Vue.js 应用程序开发的状态管理模式。它采用集中式存储管理应用的所有组件的状态，并以相应的规则保证状态以一种可预测的方式发生变化。说直白一点，vuex就是把组件的共享状态抽取出来，以一个全局单例模式管理的数据仓库，里面提供了对应用的数据存储和对数据的操作，维护整个应用的公共数据。

看源代码之前，我们看一下vuex的使用方法

/***code例子*****/

/**

 *  store.js文件

 *  创建store对象，配置state、action、mutation以及getter

 *

 **/

import Vue from 'vue'

import Vuex from 'vuex'

//注册插件

Vue.use(Vuex)

//创建store仓库

export default new Vuex.Store({

  state: {

    count: 0

  },

  mutations: {

    increment (state) {

      state.count++

    }

  },

  actions: {

    increment (context) {

      context.commit('increment')

    }

  }

})

/**

 *  vue-index.js文件

 *

 *

 **/

import Vue from 'vue'

import App from './../pages/app.vue'

import store from './store.js'

//将store挂载到根组件

new Vue({

  el: '#root',

  router,

  store,

  render: h => h(App)

})

//app.vue

export default {

  computed: {

  },

  methods: {

    increment (obj) {

    //组件中调用increment方法

      this.$store.dispatch('increment', obj)

    }

  }

}

整个vuex的使用步骤如下：

1、安装vuex插件

2、创建store状态管理仓库

3、将store注入到vue组件

4、使用dispatch调用action方法

框架核心流程

在分析源代码之前，我们先来看一下整个vuex的运行流程，下面这张图是官方文档中提供的核心思想图

Vue Components：Vue组件。HTML页面上，负责接收用户操作等交互行为，执行dispatch方法触发对应action进行回应。

dispatch：操作行为触发方法，是唯一能执行action的方法。

actions：操作行为处理模块。负责处理Vue Components接收到的所有交互行为。包含同步/异步操作，支持多个同名方法，按照注册的顺序依次触发。向后台API请求的操作就在这个模块中进行，包括触发其他action以及提交mutation的操作。

commit：状态改变提交操作方法。对mutation进行提交，是唯一能执行mutation的方法。

mutations：状态改变操作方法。是Vuex修改state的唯一推荐方法

state：页面状态管理容器对象。集中存储Vue components中data对象的零散数据，全局唯一，以进行统一的状态管理。页面显示所需的数据从该对象中进行读取，利用Vue的细粒度数据响应机制来进行高效的状态更新。

整体流程：

用户在组件上的交互触发的action，action通过调用（commit）mutations的方法去改变state的状态，而state由于加入了vue的数据响应机制，会导致对应的vue组件更新视图，完成整个状态更新。

目录结构

源代码分析前，首先我们看一下目录结构

module

module-collection.js：创建模块树

Module.js：创建模块

plugins

devtool.js：开发环境工具插件，针对chorme安装 vue-tool 插件

logger.js：state状态改变日志查询

helpers.js：提供mapSate,mapMutations,mapActions,mapGetters 等操作api函数

index.js

index.exm.js：都是入口文件

mixin.js：混入方法，提供将store 仓库挂载到每个vue实例的方法

store.js：整个代码核心，创建store对象

util.js：工具类

Vuex的安装

Vue 通过Vue.use(Vuex)安装vuex, use通过调用vuex对象的install方法将vuex载入，我们看一下install方法的实现：

let Vue // 安装的时候增加vue对象，避免引入vue包

//安装插件

export function install(_Vue) {

    //Vue已经被初始化，说明已经安装过，给出提示

    if (Vue) {

        if (process.env.NODE_ENV !== 'production') {

            console.error(

                '[vuex] already installed. Vue.use(Vuex) should be called only once.'

            )

        }

        return

    }

    Vue = _Vue

        //安装vuex

    applyMixin(Vue)

}

// 自动安装模块

if (typeof window !== 'undefined' && window.Vue) {

    install(window.Vue)

}

这里用了一个比较巧的方法，vue作为参数传入vuex，所以我们不用通过导入vue，代码打包的时候就不会将vue包含进来。

来看下applyMixin方法内部代码

const version = Number(Vue.version.split('.')[0])

    //2.0以上用混入

if (version >= 2) {

    Vue.mixin({ beforeCreate: vuexInit })

} else {

    // override init and inject vuex init procedure

    // for 1.x backwards compatibility.

    //重写init方法

    const _init = Vue.prototype._init

    Vue.prototype._init = function(options = {}) {

        options.init = options.init ? [vuexInit].concat(options.init) :

            vuexInit

        _init.call(this, options)

    }

}

  function vuexInit() {

    const options = this.$options

        // store 注入

    if (options.store) { //根组件

        this.$store = typeof options.store === 'function' ?

            options.store() : //模块重用

            options.store

    } else if (options.parent && options.parent.$store) { //其他非根组件注入,向上传递$store，保证任何组件都可以访问到

        this.$store = options.parent.$store

    }

}

根据不同版本，2.x.x以上版本，使用 hook 的形式进行注入，或使用封装并替换Vue对象原型的_init方法，实现注入。

将初始化Vue根组件时传入的store设置到this对象的$store属性上，子组件从其父组件引用$store属性，层层嵌套进行设置。在任意组件中执行 this.$store 都能找到装载的那个store对象

接下来我们来看状态管理库的创建

我们从构造函数一步一步分析

ModuleCollection构建

if (process.env.NODE_ENV !== 'production') {

        assert(Vue, `must call Vue.use(Vuex) before creating a store instance.`) //没有vue对象说明没有注入

        assert(typeof Promise !== 'undefined', `vuex requires a Promise polyfill in this browser.`)

        assert(this instanceof Store, `Store must be called with the new operator.`)

    }

    const {

        plugins = [], //这个选项暴露出每次 mutation 的钩子。Vuex 插件就是一个函数，它接收 store 作为唯一参数

            strict = false //严格模式下，无论何时发生了状态变更且不是由 mutation 函数引起的，将会抛出错误

    } = options

    let {

        state = {} //状态

    } = options

    if (typeof state === 'function') {

        state = state() //状态复用，使用一个函数来声明模块状态

    }

    // store internal state

    this._committing = false //是否在提交状态

    this._actions = Object.create(null) //action对象存储

    this._mutations = Object.create(null) //mutation对象存储

    this._wrappedGetters = Object.create(null) //装后的getters集合对象

    this._modules = new ModuleCollection(options) //封装module集合对象

    this._modulesNamespaceMap = Object.create(null) //创建命名空间

    this._subscribers = []

    this._watcherVM = new Vue() //vue实例，Vue组件用于watch监视变化，相当于bus

首先对执行环境做判断，vuex必须已经安装并且支持Promise语法，接下来对输入的参数进行简单的处理以及创建一些属性，用于后续操作，其中有一步操作this._modules = new ModuleCollection(options)，对传入的options进行处理，生成模块集合。来看一下ModuleCollection的操作

constructor(rawRootModule) {

    // register root module (Vuex.Store options)

    //注册根模块

    this.register([], rawRootModule, false)

}

register(path, rawModule, runtime = true) {

    if (process.env.NODE_ENV !== 'production') {

        assertRawModule(path, rawModule)

    }

    //生成模块对象

    const newModule = new Module(rawModule, runtime)

    if (path.length === 0) {

        this.root = newModule //根模块

    } else {

        //子元素把关系添加到父元素，形式关系树

        const parent = this.get(path.slice(0, -1))

        parent.addChild(path[path.length - 1], newModule)

    }

    // 注册嵌套的模块

    if (rawModule.modules) {

        forEachValue(rawModule.modules, (rawChildModule, key) => {

            this.register(path.concat(key), rawChildModule, runtime)

                //this.register(['cart',{cartmodules},runtime])

        })

    }

}

ModuleCollection主要将传入的options对象整个构造为一个module对象，并循环调用 this.register([key], rawModule, false) 为其中的modules属性进行模块注册，使其都成为module对象，最后options对象被构造成一个完整的状态树。ModuleCollection类还提供了modules的更替功能

modules属性中每一个模块都是一个模块对象，而传入的option会被当成是整个状态树的根模块。

我们接下来看一下了解一下module对象

    constructor(rawModule, runtime) {

        this.runtime = runtime //运行时间

        this._children = Object.create(null) //children子模块

        this._rawModule = rawModule //模块内容

        const rawState = rawModule.state //模块状态

        this.state = (typeof rawState === 'function' ? rawState() : rawState) || {} //state

    }

对象是对传入的每一个module参数进行封装，添加了存储的子模块，已达到状态树的构建目的，同时提供一些基本操作的方法。

我们来看一下官网提供的购物车的例子构建完的moduleCollection对象

这个利用树形结构，清晰地表达出了整个数据仓库数据的关系，moduleCollection将成为后期数据和操作重新组织和查找基础。

dispatch和commit函数设置

回到store的构造函数

const store = this

const { dispatch, commit } = this

//dispatch 方法

this.dispatch = function boundDispatch(type, payload) {

        return dispatch.call(store, type, payload)

    }

    //commit 方法

this.commit = function boundCommit(type, payload, options) {

    return commit.call(store, type, payload, options)

}

封装dispatch 和commit方法，具体实现如下：

commit(_type, _payload, _options) {

        // check object-style commit

        const {

            type,

            payload,

            options

        } = unifyObjectStyle(_type, _payload, _options)

        const mutation = { type, payload }

        const entry = this._mutations[type] //变化有没有注册这个类型  commit导致mutation

        if (!entry) {

            if (process.env.NODE_ENV !== 'production') {

                console.error(`[vuex] unknown mutation type: ${type}`)

            }

            return

        }

        //处理commit

        this._withCommit(() => {

            entry.forEach(function commitIterator(handler) {

                handler(payload) //mutation操作

            })

        })

        // 订阅者函数遍历执行，传入当前的mutation对象和当前的state

        this._subscribers.forEach(sub => sub(mutation, this.state))

        //新版本silent去掉了

        if (

            process.env.NODE_ENV !== 'production' &&

            options && options.silent

        ) {

            console.warn(

                `[vuex] mutation type: ${type}. Silent option has been removed. ` +

                'Use the filter functionality in the vue-devtools'

            )

        }

    }

    //触发action

dispatch(_type, _payload) {

    // check object-style dispatch

    const {

        type,

        payload

    } = unifyObjectStyle(_type, _payload)

    const entry = this._actions[type] //触发action配置表

    if (!entry) {

        if (process.env.NODE_ENV !== 'production') {

            console.error(`[vuex] unknown action type: ${type}`)

        }

        return

    }

    return entry.length > 1 ?

        Promise.all(entry.map(handler => handler(payload))) :

        entry[0](payload)

}

dispatch的功能是触发并传递一些参数（payload）给对应type的action。Dispatch提供了两种方法的调用：

所以使用了unifyObjectStyle对传入的参数做了统一化处理。接着找到对应type的action,并逐个执行。

commit方法和dispatch方法大同小异，但是比dispatch复杂一点。每次调用都要对订阅者遍历执行，这个操作的原因后面再解析。同时每次执行mutation方法集合时，都要调用函数_withCommit方法。

_withCommit是一个代理方法，所有触发mutation的进行state修改的操作都经过它，由此来统一管理监控state状态的修改。实现代码如下。

    _withCommit(fn) {

        const committing = this._committing

        this._committing = true

        fn()

        this._committing = committing

    }

每次提交前保存当前commit状态，然后置为true后进行本次操作，操作完成后再还原本次修改之前的状态。我们上面说过mutation是Vuex修改state的唯一推荐方法。这样设置的作用有利于状态的跟踪，state的修改来自于mutation。那是如何跟踪的呢？我们看下面一段代码：

function enableStrictMode(store) {

    store._vm.$watch(function() { return this._data.$$state }, () => {

        if (process.env.NODE_ENV !== 'production') {

            //如果不是通过commit函数，提示

            assert(store._committing, `Do not mutate vuex store state outside mutation handlers.`)

        }

    }, { deep: true, sync: true })

}

这里通过vue $watch 方法监控每一次data的变化，如果在开发环境并且committing为false的话，则表明不是通过mutation操作状态变化，提示非法。同时这也解释了官网要求mutation必须为同步操作state。因为如果异步的话，异步函数调用完成后committing已经还原状态，而回调函数还没调用，$watch还没有接收到data的变化，当回调成功时，committing已经被置为false，不利于状态的跟踪。

模块的安装

接下来，构造函数进行模块的安装

// init root module. 初始化根模块

// this also recursively registers all sub-modules 递归所有子模块

// and collects all module getters inside this._wrappedGetters 把所有的getters对象都收集到Getter里面

installModule(this, state, [], this._modules.root)

我们看一下installModule的具体内容

function installModule(store, rootState, path, module, hot) {

    const isRoot = !path.length //是否为根元素

    const namespace = store._modules.getNamespace(path) //命名空间

    // register in namespace map 如果是命名空间模块，推送到map对象里面

    if (module.namespaced) {

        store._modulesNamespaceMap[namespace] = module

    }

    // set state

    //将模块的state添加到state链中，是的可以按照 state.moduleName 访问

    if (!isRoot && !hot) {

        const parentState = getNestedState(rootState, path.slice(0, -1))

        const moduleName = path[path.length - 1]

        store._withCommit(() => {

            //确保属性被创建后也是响应式的

            Vue.set(parentState, moduleName, module.state)

        })

    }

    //模块上下文

    /*local {

        dispatch,

        commit,

        getters,

        state

    }

    */

    const local = module.context = makeLocalContext(store, namespace, path)

        // 注册对应模块的mutation，供state修改使用

    module.forEachMutation((mutation, key) => {

            const namespacedType = namespace + key

            registerMutation(store, namespacedType, mutation, local)

        })

        // 注册对应模块的action，供数据操作、提交mutation等异步操作使用

    module.forEachAction((action, key) => {

            const namespacedType = namespace + key

            registerAction(store, namespacedType, action, local)

        })

        // 注册对应模块的getters，供state读取使用

    module.forEachGetter((getter, key) => {

        const namespacedType = namespace + key

        registerGetter(store, namespacedType, getter, local)

    })

}

判断是否是根目录，以及是否设置了命名空间，若存在则在namespace中进行module的存储，在不是根组件且不是 hot 条件的情况下，通过getNestedState方法拿到该module父级的state，拿到其所在moduleName，调用 Vue.set(parentState, moduleName, module.state) 方法将其state设置到父级state对象的moduleName属性中，由此实现该模块的state注册。这里建立了一条可观测的data数据链。

接下来定义local变量和module.context的值，执行makeLocalContext方法，为该module设置局部的 dispatch、commit方法以及getters和state，为的是在局部的模块内调用模块定义的action和mutation。也就是官网提供的这种调用方式

定义local环境后，循环注册我们在options中配置的action以及mutation等，这种注册操作都是大同小异，我们来看一下注册mutation的步骤：

/***registerMutation***/

function registerMutation(store, type, handler, local) {

    const entry = store._mutations[type] || (store._mutations[type] = [])

        //重新封装调用函数

    entry.push(function wrappedMutationHandler(payload) {

        handler.call(store, local.state, payload)

    })

}

type作为id，把对应的值函数封装后存储在数组里面，然后作为store._mutations的属性。store._mutations收集了我们传入的所有mutation函数

action和getter的注册也是同理的，只是action handler比mutation handler以及getter wrapper多拿到dispatch和commit操作方法，因此action可以进行dispatch action和commit mutation操作。

注册完了根组件的actions、mutations以及getters后，递归调用自身，为子组件注册其state，actions、mutations以及getters等。

/***子模块代码****/

  module.forEachChild((child, key) => {

        installModule(store, rootState, path.concat(key), child, hot)

    })

/***子模块代码end****/

Store._vm组件安装

执行完各module的install后，执行resetStoreVM方法，进行store组件的初始化。

resetStoreVM(this, state)

 function resetStoreVM(store, state, hot) {

    const oldVm = store._vm

    // bind store public getters

    store.getters = {}

    const wrappedGetters = store._wrappedGetters

    const computed = {}

        // 循环所有处理过的getters，并新建computed对象进行存储，通过Object.defineProperty方法为getters对象建立属性，

        //使得我们通过this.$store.getters.xxxgetter能够访问到该getters

    forEachValue(wrappedGetters, (fn, key) => {

        // use computed to leverage its lazy-caching mechanism

        computed[key] = () => fn(store)

        Object.defineProperty(store.getters, key, {

            get: () => store._vm[key],

            enumerable: true // for local getters

        })

    })

    // use a Vue instance to store the state tree

    // suppress warnings just in case the user has added

    // some funky global mixins

    const silent = Vue.config.silent

    Vue.config.silent = true

        // 设置新的storeVm，将当前初始化的state以及getters作为computed属性（刚刚遍历生成的）

    store._vm = new Vue({

        data: {

            $$state: state //相当于总线

        },

        computed

    })

    Vue.config.silent = silent

    // enable strict mode for new vm

    // 该方法对state执行$watch以禁止从mutation外部修改state

    if (store.strict) {

        enableStrictMode(store)

    }

    // 若不是初始化过程执行的该方法，将旧的组件state设置为null，

    //强制更新所有监听者(watchers)，待更新生效，DOM更新完成后，执行vm组件的destroy方法进行销毁，减少内存的占用

    if (oldVm) {

        if (hot) {

            // dispatch changes in all subscribed watchers

            // to force getter re-evaluation for hot reloading.

            store._withCommit(() => {

                oldVm._data.$$state = null

            })

        }

        Vue.nextTick(() => oldVm.$destroy())

    }

}

resetStoreVm方法创建了当前store实例的_vm组件，至此store就创建完毕了

plugin注入

最后执行plugin插件

//打印变化前后的值

plugins.forEach(plugin => plugin(this))

//如果配置了开发者工具

if (Vue.config.devtools) {

    devtoolPlugin(this)

}

Plugins.foreach 默认执行了createlogger方法，我们来看createLogger的实现代码：

export default function createLogger({

    collapsed = true,

    filter = (mutation, stateBefore, stateAfter) => true,

    transformer = state => state,

    mutationTransformer = mut => mut

} = {}) {

    return store => {

        let prevState = deepCopy(store.state)

        store.subscribe((mutation, state) => {

            if (typeof console === 'undefined') {

                return

            }

            const nextState = deepCopy(state)

            if (filter(mutation, prevState, nextState)) {

                const time = new Date()

                const formattedTime = ` @ ${pad(time.getHours(), 2)}:${pad(time.getMinutes(), 2)}:${pad(time.getSeconds(), 2)}.${pad(time.getMilliseconds(), 3)}`

                const formattedMutation = mutationTransformer(mutation)

                const message = `mutation ${mutation.type}${formattedTime}`

                const startMessage = collapsed ?

                    console.groupCollapsed :

                    console.group

                // render

                try {

                    startMessage.call(console, message)

                } catch (e) {

                    console.log(message)

                }

                console.log('%c prev state', 'color: #9E9E9E; font-weight: bold', transformer(prevState))

                console.log('%c mutation', 'color: #03A9F4; font-weight: bold', formattedMutation)

                console.log('%c next state', 'color: #4CAF50; font-weight: bold', transformer(nextState))

                try {

                    console.groupEnd()

                } catch (e) {

                    console.log('—— log end ——')

                }

            }

            prevState = nextState

        })

    }

}

createLogger通过store.subscribe将方法添加到订阅，待触发的时候调用。这里通过前后state状态的打印对比，跟踪状态变更。

devtoolPlugin则是对vue-tool控制台信息的添加监控

mapSate,mapMutations,mapActions,mapGetters函数实现

Vuex还提供了mapSate,mapMutations,mapActions,mapGetters辅助函数来帮助我们生成计算属性和对应方法。下面用mapMutations为例来分析一下实现过程

首先看调用的方式：

import { mapMutations } from 'vuex'

export default {

  // ...

  methods: {

    ...mapMutations([

      'increment', // 将 `this.increment()` 映射为 `this.$store.commit('increment')`

      // `mapMutations` 也支持载荷：

      'incrementBy' // 将 `this.incrementBy(amount)` 映射为 `this.$store.commit('incrementBy', amount)`

    ]),

    ...mapMutations({

      add: 'increment' // 将 `this.add()` 映射为 `this.$store.commit('increment')`

    }),

    ...mapMutations('some/nested/module', [  //在模块some/nested/module查看

    'foo', //将 `this.increment()` 映射为 `this.$store.commit('some/nested/module/foo')`

    'bar'

  ])

  }

}

看一下源代码：

export const mapMutations = normalizeNamespace((namespace, mutations) => {

const res = {}

normalizeMap(mutations).forEach(({ key, val }) => {

    val = namespace + val

    res[key] = function mappedMutation(...args) {

        if (namespace && !getModuleByNamespace(this.$store, 'mapMutations', namespace)) {

            return

        }

        return this.$store.commit.apply(this.$store, [val].concat(args))

    }

})

return res

})

  //返回对象数组 key-value

function normalizeMap(map) {

    return Array.isArray(map) ?

        map.map(key => ({ key, val: key })) :

        Object.keys(map).map(key => ({ key, val: map[key] }))

}

//处理命名空间参数问题

function normalizeNamespace(fn) {

    return (namespace, map) => {

        if (typeof namespace !== 'string') {

            map = namespace

            namespace = ''

        } else if (namespace.charAt(namespace.length - 1) !== '/') {

            namespace += '/'

        }

        return fn(namespace, map)

    }

}

//通过命名空间找模块

function getModuleByNamespace(store, helper, namespace) {

    const module = store._modulesNamespaceMap[namespace]

    if (process.env.NODE_ENV !== 'production' && !module) {

        console.error(`[vuex] module namespace not found in ${helper}(): ${namespace}`)

    }

    return module

}

其实就是用normalizeNamespace和normalizeMap去统一化参数，生成key-value的对象组，然后对函数惊醒封装，调用commit方法。

至此，整个vuex的源码核心就分析完成。源码中还有一些工具函数类似registerModule、unregisterModule、hotUpdate、watch以及subscribe等，这些方法都是对上面代码行为的封装调用，然后暴露出来的接口，都比较容易理解。

链接：https://www.cnblogs.com/caizhenbo/p/7380200.html

巴特西

Vuex源码分析(转)

最新文章

热门文章