一、前言

本文介绍的内容包括：

keep-alive用法：动态组件&vue-router
keep-alive源码解析
keep-alive组件及其包裹组件的钩子
keep-alive组件及其包裹组件的渲染

二、keep-alive介绍与应用

2.1 keep-alive是什么

keep-alive是一个抽象组件：它自身不会渲染一个DOM元素，也不会出现在父组件链中；使用keep-alive包裹动态组件时，会缓存不活动的组件实例，而不是销毁它们。

一个场景

用户在某个列表页面选择筛选条件过滤出一份数据列表，由列表页面进入数据详情页面，再返回该列表页面，我们希望：列表页面可以保留用户的筛选（或选中）状态。
keep-alive就是用来解决这种场景。当然keep-alive不仅仅是能够保存页面/组件的状态这么简单，它还可以避免组件反复创建和渲染，有效提升系统性能。总的来说，keep-alive用于保存组件的渲染状态。

keep-alive用法

在动态组件中的应用

<keep-alive :include="whiteList" :exclude="blackList" :max="amount"><component :is="currentComponent"></component>
</keep-alive>

在vue-router中的应用

<keep-alive :include="whiteList" :exclude="blackList" :max="amount"><router-view></router-view>
</keep-alive>

include定义缓存白名单，keep-alive会缓存命中的组件；exclude定义缓存黑名单，被命中的组件将不会被缓存；max定义缓存组件上限，超出上限使用LRU的策略置换缓存数据。

内存管理的一种页面置换算法，对于在内存中但又不用的数据块（内存块）叫做LRU，操作系统会根据哪些数据属于LRU而将其移出内存而腾出空间来加载另外的数据。

三、源码剖析

keep-alive.js内部还定义了一些工具函数，我们按住不动，先看它对外暴露的对象

// src/core/components/keep-alive.js
export default {name: 'keep-alive',abstract: true, // 判断当前组件虚拟dom是否渲染成真实dom的关键props: {include: patternTypes, // 缓存白名单exclude: patternTypes, // 缓存黑名单max: [String, Number] // 缓存的组件},created() {this.cache = Object.create(null) // 缓存虚拟domthis.keys = [] // 缓存的虚拟dom的键集合},destroyed() {for (const key in this.cache) {// 删除所有的缓存pruneCacheEntry(this.cache, key, this.keys)}},mounted() {// 实时监听黑白名单的变动this.$watch('include', val => {pruneCache(this, name => matched(val, name))})this.$watch('exclude', val => {pruneCache(this, name => !matches(val, name))})},render() {// 先省略...}
}

可以看出，与我们定义组件的过程一样，先是设置组件名为keep-alive，其次定义了一个abstract属性，值为true。这个属性在vue的官方教程并未提及，却至关重要，后面的渲染过程会用到。props属性定义了keep-alive组件支持的全部参数。

keep-alive在它生命周期内定义了三个钩子函数：

created
初始化两个对象分别缓存VNode(虚拟DOM)和VNode对应的键集合
destroyed
删除this.cache中缓存的VNode实例。我们留意到，这不是简单地将this.cache置为null，而是遍历调用pruneCacheEntry函数删除。

// src/core/components/keep-alive.js
function pruneCacheEntry (cache: VNodeCache,key: string,keys: Array<string>,current?: VNode
) {const cached = cache[key]if (cached && (!current || cached.tag !== current.tag)) {cached.componentInstance.$destroyed() // 执行组件的destroy钩子函数}cache[key] = nullremove(keys, key)
}

删除缓存的VNode还要对应组件实例的destory钩子函数

mounted
在mounted这个钩子中对include和exclude参数进行监听，然后实时地更新（删除）this.cache对象数据。pruneCache函数的核心也是去调用pruneCacheEntry

function pruneCache (keepAliveInstance: any, filter: Function) {const { cache, keys, _vnode } = keepAliveInstancefor (const key in cache) {const cachedNode: ?VNode = cache[key]if (cachedNode) {const name: ?string = getComponentName(cachedNode.componentOptions)if (name && !filter(name)) {pruneCacheEntry(cache, key, keys, _vnode)}}}
}

render

render () {const slot = this.$slots.defalutconst vnode: VNode = getFirstComponentChild(slot) // 找到第一个子组件对象const componentOptions : ?VNodeComponentOptions = vnode && vnode.componentOptionsif (componentOptions) { // 存在组件参数// check patternconst name: ?string = getComponentName(componentOptions) // 组件名const { include, exclude } = thisif (// 条件匹配// not included（include && (!name || !matches(include, name))）||// excluded(exclude && name && matches(exclude, name))) {return vnode}const { cache, keys } = this// 定义组件的缓存keyconst key: ?string = vnode.key === null ? componentOptions.Ctor.cid + (componentOptions.tag ? `::${componentOptions.tag}` : '') : vnode.keyif (cache[key]) { // 已经缓存过该组件vnode.componentInstance = cache[key].componentInstanceremove(keys, key)keys.push(key) // 调整key排序} else {cache[key] = vnode //缓存组件对象keys.push(key)if (this.max && keys.length > parseInt(this.max)) {//超过缓存数限制，将第一个删除pruneCacheEntry(cahce, keys[0], keys, this._vnode)}}vnode.data.keepAlive = true //渲染和执行被包裹组件的钩子函数需要用到}return vnode || (slot && slot[0])
}

第一步：获取keep-alive包裹着的第一个子组件对象及其组件名；
第二步：根据设定的黑白名单（如果有）进行条件匹配，决定是否缓存。不匹配，直接返回组件实例（VNode），否则执行第三步；
第三步：根据组件ID和tag生成缓存Key，并在缓存对象中查找是否已缓存过该组件实例。如果存在，直接取出缓存值并更新该key在this.keys中的位置（更新key的位置是实现LRU置换策略的关键），否则执行第四步；
第四步：在this.cache对象中存储该组件实例并保存key值，之后检查缓存的实例数量是否超过max设置值，超过则根据LRU置换策略删除最近最久未使用的实例（即是下标为0的那个key）;
第五步：最后并且很重要，将该组件实例的keepAlive属性值设置为true。

四、重头戏：渲染

4.1 Vue的渲染过程

借助一张图看下Vue渲染的整个过程：

Vue的渲染是从图中render阶段开始的，但keep-alive的渲染是在patch阶段，这是构建组件树（虚拟DOM树），并将VNode转换成真正DOM节点的过程。
简单描述从render到patch的过程
我们从最简单的new Vue开始：

import App from './App.vue'new Vue({render: h => h(App)
}).$mount('#app')

Vue在渲染的时候先调用原型上的_render函数将组件对象转化成一个VNode实例；而_render是通过调用createElement和createEmptyVNode两个函数进行转化；
createElement的转化过程会根据不同的情形选择new VNode或者调用createComponent函数做VNode实例化；

完成VNode实例化后，这时候Vue调用原型上的_update函数把VNode渲染成真实DOM，这个过程又是通过调用patch函数完成的（这就是patch阶段了）
用一张图表达：

4.2 keep-alive组件的渲染

我们用过keep-alive都知道，它不会生成真正的DOM节点，这是怎么做到的？

// src/core/instance/lifecycle.js
export function initLifecycle (vm: Component) {const options= vm.$options// 找到第一个非abstract父组件实例let parent = options.parentif (parent && !options.abstract) {while (parent.$options.abstract && parent.$parent) {parent = parent.$parent}parent.$children.push(vm)}vm.$parent = parent// ...
}

Vue在初始化生命周期的时候，为组件实例建立父子关系会根据abstract属性决定是否忽略某个组件。在keep-alive中，设置了abstract:true，那Vue就会跳过该组件实例。

最后构建的组件树中就不会包含keep-alive组件，那么由组件树渲染成的DOM树自然也不会有keep-alive相关的节点了。

keep-alive包裹的组件是如何使用缓存的？
在patch阶段，会执行createComponent函数：

// src/core/vdom/patch.js
function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {let i = vnode.dataif (isDef(i)) {const isReactivated = isDef(vnode.componentInstance) && i.keepAliveif (isDef(i = i.hook) && isDef(i = i.init)) {i(vnode, false)}if (isDef(vnode.componentInstance)) {initComponent(vnode, insertedVnodeQueue)insert(parentElem, vnode.elem, refElem) // 将缓存的DOM(vnode.elem) 插入父元素中if (isTrue(isReactivated)) {reactivateComponent(vnode, insertedVnodeQueue, parentEle, refElm)}return true}}
}

在首次加载被包裹组建时，由keep-alive.js中的render函数可知，vnode.componentInstance的值是undfined，keepAlive的值是true，因为keep-alive组件作为父组件，它的render函数会先于被包裹组件执行；那么只执行到i(vnode,false)，后面的逻辑不执行；
再次访问被包裹组件时，vnode.componentInstance的值就是已经缓存的组件实例，那么会执行insert(parentElm, vnode.elm, refElm)逻辑，这样就直接把上一次的DOM插入到父元素中。

五、不可忽视：钩子函数

5.1 只执行一次的钩子

一般的组件，每一次加载都会有完整的生命周期，即生命周期里面对于的钩子函数都会被触发，为什么被keep-alive包裹的组件却不是呢？
被缓存的组件实例会为其设置keepAlive= true，而在初始化组件钩子函数中：

// src/core/vdom/create-component.js
const componentVNodeHooks = {init (vnode: VNodeWithData, hydrating: boolean): ?boolean{if (vnode.componentInstance &&       !vnode.componentInstance._isDestroyed &&vnode.data.keepAlive) {// keep-alive components, treat as a patchconst mountedNode:any = vnodecomponentVNodeHooks.prepatch(mountedNode, mountedNode)} else {const child = vnode.componentInstance = createComponentInstanceForVnode (vnode, activeInstance)}}
}

可以看出，当vnode.componentInstance和keepAlive同时为true时，不再进入$mount过程，那mounted之前的所有钩子函数（beforeCreate、created、mounted）都不再执行。

5.2 可重复的activated

在patch的阶段，最后会执行invokeInsertHook函数，而这个函数就是去调用组件实例（VNode）自身的insert钩子：

// src/core/vdom/patch.js
function invokeInsertHook (vnode, queue, initial) {if (isTrue(initial) && isDef(vnode.parent)) {vnode.parent.data,pendingInsert = queue} else {for(let i =0; i<queue.length; ++i) {queue[i].data.hook.insert(queue[i]) // 调用VNode自身的insert钩子函数}}
}

再看insert钩子：

const componentVNodeHooks = {// init()insert (vnode: MountedComponentVNode) {const { context, componentInstance } = vnodeif (!componentInstance._isMounted) {componentInstance._isMounted = truecallHook(componentInstance, 'mounted')}if (vnode.data.keepAlive) {if (context._isMounted) {queueActivatedComponent(componentInstance)} else {activateChildComponent(componentInstance, true/* direct */)}}// ...}
}

在这个钩子里面，调用了activateChildComponent函数递归地去执行所有子组件的activated钩子函数：

// src/core/instance/lifecycle.js
export function activateChildComponent (vm: Component, direct?: boolean) {if (direct) {vm._directInactive = falseif (isInInactiveTree(vm)) {return}} else if (vm._directInactive) {return}if (vm._inactive || vm._inactive === null) {vm._inactive = falsefor (let i = 0; i < vm.$children.length; i++) {activateChildComponent(vm.$children[i])}callHook(vm, 'activated')}
}

相反地，deactivated钩子函数也是一样的原理，在组件实例（VNode）的destroy钩子函数中调用deactivateChildComponent函数。

vue中的keep-alive实现原理相关推荐

Vue中的scoped的实现原理以及scoped穿透的用法
本篇文章给大家带来的内容是关于Vue中的scoped的实现原理以及scoped穿透的用法(附代码),有一定的参考价值,有需要的朋友可以参考一下,希望对你有所帮助. 1.什么是scoped 在Vue文件 ...
Vue中的基础过渡动画原理解析
前言在日常开发中动画是必不可少的一部分不仅能让元素直接的切换显得更加自然同时也能极大的增强用户体验因此在Vue之中也提供了非常强大的关于动画这方面的支持 Vue不仅支持用CSS来写一些过渡 ...
Vue中Css的scoped的原理
当style标签拥有scoped属性的时候,它的css样式只会作用在当前组件也就是说scoped可以使得组件之间的样式互相隔离,互不影响如果一个项目中的左右组件style标签都加上scoped就相 ...
vue中实现双向数据绑定原理,使用了Object.defineproperty()方法,方法简单
在vue中双向数据绑定原理,我们一般都是用v-model来实现的 ,但一般在面试话会问到其实现的原理, 方法比较简单,就是利用了es5中的一个方法.Object.defineproperty(),它有 ...
vue中的v-model原理，与组件自定义v-model
VUE中的v-model可以实现双向绑定,但是原理是什么呢?往下看看吧根据官方文档的解释,v-model其实是一个语法糖,它会自动的在元素或者组件上面解析为 :value="" ...
vue指令写在html中的原理,详解Vue中的MVVM原理和实现方法
对Vue中的MVVM原理解析和实现首先你对Vue需要有一定的了解,知道MVVM.这样才能更有助于你顺利的完成下面原理的阅读学习和编写下面由我阿巴阿巴的详细走一遍Vue中MVVM原理的实现,这篇文章大家 ...
[vue] 你知道vue中key的原理吗？说说你对它的理解
[vue] 你知道vue中key的原理吗?说说你对它的理解 key的作用主要是为了高效的更新虚拟DOM; 如果没有唯一的key, 数据更新时, 相同节点更新前后无法准确一一对应起来,会导致更新效率降低 ...
c# mvvm模式获取当前窗口_对Vue中的MVVM原理解析和实现
首先你对Vue需要有一定的了解,知道MVVM.这样才能更有助于你顺利的完成下面原理的阅读学习和编写下面由我阿巴阿巴的详细走一遍Vue中MVVM原理的实现,这篇文章大家可以学习到: 1.Vue数据双向 ...
Vue中Object和Array数据变化侦测原理
在学完Vue.js框架,完成了一个SPA项目后,一直想抽时间找本讲解Vue.js内部实现原理的书来看看,经过多方打听之后,我最后选择了<深入浅出Vue.js>这本书.然而惭愧的是,这本书已 ...
关于Vue中$nextTick的作用及实现原理(Vue进阶)
Hello,大家好,最近找工作的路途依然艰难,但是要一直保持对技术的热爱!今天继续跟大家探索一下Vue进阶的内容,这次研究一下Vue的全局API中的$nextTick,这是一个很常用,也是经典的API ...

vue中的keep-alive实现原理