徹底揭祕keep-alive原理

一、前言

原文連結：github.com/qi...

本文介紹的內容包括：

• 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元件，那麼由元件樹渲染成的DOM樹自然也不會有keep-alive相關的節點了。

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原始碼