彻底揭秘keep-alive原理(小结)

一、前言

原文链接：

本文介绍的内容包括：

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

二、keep-alive介绍与应用

2.1 keep-alive是什么

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

2.2 一个场景

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

2.3 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的策略置换缓存数据。

三、源码剖析

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) // 缓存虚拟dom
  this.keys = [] // 缓存的虚拟dom的健集合
 },

 destroyed () {
  for (const key in this.cache) { // 删除所有的缓存
   prunecacheentry(this.cache, key, this.keys)
  }
 },

 mounted () {
  // 实时监听黑白名单的变动
  this.$watch('include', val => {
   prunecache(this, name => matches(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.$destroy() // 执行组件的destory钩子函数
 }
 cache[key] = null
 remove(keys, key)
}

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

mounted

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

render

 // src/core/components/keep-alive.js
 render () {
  const slot = this.$slots.default
  const vnode: vnode = getfirstcomponentchild(slot) // 找到第一个子组件对象
  const componentoptions: ?vnodecomponentoptions = vnode && vnode.componentoptions
  if (componentoptions) { // 存在组件参数
   // check pattern
   const name: ?string = getcomponentname(componentoptions) // 组件名
   const { include, exclude } = this
   if ( // 条件匹配
    // not included
    (include && (!name || !matches(include, name))) ||
    // excluded
    (exclude && name && matches(exclude, name))
   ) {
    return vnode
   }

   const { cache, keys } = this
   const key: ?string = vnode.key == null // 定义组件的缓存key
    // same constructor may get registered as different local components
    // so cid alone is not enough (#3269)
    ? componentoptions.ctor.cid + (componentoptions.tag ? `::${componentoptions.tag}` : '')
    : vnode.key
   if (cache[key]) { // 已经缓存过该组件
    vnode.componentinstance = cache[key].componentinstance
    // make current key freshest
    remove(keys, key)
    keys.push(key) // 调整key排序
   } else {
    cache[key] = vnode // 缓存组件对象
    keys.push(key)
    // prune oldest entry
    if (this.max && keys.length > parseint(this.max)) { // 超过缓存数限制，将第一个删除
     prunecacheentry(cache, 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__ 函数完成的（这就是pacth阶段了）

用一张图表达：

 

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.parent
 if (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包裹的组件是如何使用缓存的？

在 patch 阶段，会执行 createcomponent 函数：

// src/core/vdom/patch.js
function createcomponent (vnode, insertedvnodequeue, parentelm, refelm) {
  let i = vnode.data
  if (isdef(i)) {
   const isreactivated = isdef(vnode.componentinstance) && i.keepalive
   if (isdef(i = i.hook) && isdef(i = i.init)) {
    i(vnode, false /* hydrating */)
   }

   if (isdef(vnode.componentinstance)) {
    initcomponent(vnode, insertedvnodequeue)
    insert(parentelm, vnode.elm, refelm) // 将缓存的dom（vnode.elm）插入父元素中
    if (istrue(isreactivated)) {
     reactivatecomponent(vnode, insertedvnodequeue, parentelm, refelm)
    }
    return true
   }
  }
 }

在首次加载被包裹组件时，由 keep-alive.js 中的 render 函数可知， vnode.componentinstance 的值是 undefined ， keepalive 的值是 true ，因为keep-alive组件作为父组件，它的 render 函数会先于被包裹组件执行；那么就只执行到 i(vnode, false /* hydrating */) ，后面的逻辑不再执行；

再次访问被包裹组件时， 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
  ) {
   // kept-alive components, treat as a patch
   const mountednode: any = vnode // work around flow
   componentvnodehooks.prepatch(mountednode, mountednode)
  } else {
   const child = vnode.componentinstance = createcomponentinstanceforvnode(
    vnode,
    activeinstance
   )
   child.$mount(hydrating ? vnode.elm : undefined, hydrating)
  }
 }
 // ...
}

可以看出，当 vnode.componentinstance 和 keepalive 同时为truly值时，不再进入 $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 钩子：

// src/core/vdom/create-component.js
const componentvnodehooks = {
 // init()
 insert (vnode: mountedcomponentvnode) {
  const { context, componentinstance } = vnode
  if (!componentinstance._ismounted) {
   componentinstance._ismounted = true
   callhook(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 = false
  if (isininactivetree(vm)) {
   return
  }
 } else if (vm._directinactive) {
  return
 }
 if (vm._inactive || vm._inactive === null) {
  vm._inactive = false
  for (let i = 0; i < vm.$children.length; i++) {
   activatechildcomponent(vm.$children[i])
  }
  callhook(vm, 'activated')
 }
}

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

参考

 vue技术揭秘|keep-alive

vue源码

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。