Vue源碼解析，keep-alive是如何實現緩存的？

時間  2021-08-12
標籤 node react 緩存 性能優化 dom ide 函數 性能 優化 this 欄目 React 简体版
原文   原文鏈接

前言

在性能優化上，最多見的手段就是緩存。對須要常常訪問的資源進行緩存，減小請求或者是初始化的過程，從而下降時間或內存的消耗。Vue 爲咱們提供了緩存組件 keep-alive，它可用於路由級別或組件級別的緩存。node

但其中的緩存原理你是否瞭解，組件緩存渲染又是如何工做。那麼本文就來解析 keep-alive 的原理。react

LRU策略

在使用 keep-alive 時，能夠添加 prop 屬性 include、exclude、max 容許組件有條件的緩存。既然有限制條件，舊的組件須要刪除緩存，新的組件就須要加入到最新緩存，那麼要如何制定對應的策略？緩存

LRU（Least recently used，最近最少使用）策略根據數據的歷史訪問記錄來進行淘汰數據。LRU 策略的設計原則是，若是一個數據在最近一段時間沒有被訪問到，那麼在未來它被訪問的可能性也很小。也就是說，當限定的空間已存滿數據時，應當把最久沒有被訪問到的數據淘汰。性能優化

  1. 如今緩存最大隻容許存3個組件，ABC三個組件依次進入緩存，沒有任何問題
  2. 當D組件被訪問時，內存空間不足，A是最先進入也是最舊的組件，因此A組件從緩存中刪除，D組件加入到最新的位置
  3. 當B組件被再次訪問時，因爲B還在緩存中，B移動到最新的位置，其餘組件相應的日後一位
  4. 當E組件被訪問時，內存空間不足，C變成最久未使用的組件，C組件從緩存中刪除，E組件加入到最新的位置

keep-alive 緩存機制即是根據LRU策略來設置緩存組件新鮮度，將好久未訪問的組件從緩存中刪除。瞭解完緩存機制，接下來進入源碼，看看keep-alive組件是如何實現的。dom

組件實現原理

// 源碼位置：src/core/components/keep-alive.js
export default {
  name: 'keep-alive',
  abstract: true,
  props: {
    include: patternTypes,
    exclude: patternTypes,
    max: [String, Number]
  },
  created () {
    this.cache = Object.create(null)
    this.keys = []
  },
  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 () {
    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
        // 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)
      } 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])
  }
}

kepp-alive 實際是一個抽象組件，只對包裹的子組件作處理，並不會和子組件創建父子關係，也不會做爲節點渲染到頁面上。在組件開頭就設置 abstract 爲 true，表明該組件是一個抽象組件。ide

// 源碼位置： src/core/instance/lifecycle.js
export function initLifecycle (vm: Component) {
  const options = vm.$options

  // locate first non-abstract parent
  let parent = options.parent
  if (parent && !options.abstract) {
    while (parent.$options.abstract && parent.$parent) {
      parent = parent.$parent
    }
    parent.$children.push(vm)
  }
  vm.$parent = parent
  // ...
}

那麼抽象組件是如何忽略這層關係的呢？在初始化階段會調用 initLifecycle，裏面判斷父級是否爲抽象組件，若是是抽象組件，就選取抽象組件的上一級做爲父級，忽略與抽象組件和子組件之間的層級關係。函數

回到 keep-alive 組件，組件是沒有編寫
template 模板，而是由 render 函數決定渲染結果。性能

const slot = this.$slots.default
const vnode: VNode = getFirstComponentChild(slot)

若是 keep-alive 存在多個子元素，keep-alive 要求同時只有一個子元素被渲染。因此在開頭會獲取插槽內的子元素，調用 getFirstComponentChild 獲取到第一個子元素的 VNode。優化

// 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
}

function matches (pattern: string | RegExp | Array, name: string): boolean {
  if (Array.isArray(pattern)) {
    return pattern.indexOf(name) > -1
  } else if (typeof pattern === 'string') {
    return pattern.split(',').indexOf(name) > -1
  } else if (isRegExp(pattern)) {
    return pattern.test(name)
  }
  return false
}

接着判斷當前組件是否符合緩存條件，組件名與include不匹配或與exclude匹配都會直接退出並返回 VNode，不走緩存機制。this

const { cache, keys } = this
const key: ?string = vnode.key == null
  // 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)
} 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

匹配條件經過會進入緩存機制的邏輯，若是命中緩存，從 cache 中獲取緩存的實例設置到當前的組件上，並調整 key 的位置將其放到最後。若是沒命中緩存，將當前 VNode 緩存起來，並加入當前組件的 key。若是緩存組件的數量超出 max 的值，即緩存空間不足，則調用 pruneCacheEntry 將最舊的組件從緩存中刪除，即 keys[0] 的組件。以後將組件的 keepAlive 標記爲 true，表示它是被緩存的組件。

function pruneCacheEntry (
  cache: VNodeCache,
  key: string,
  keys: Array,
  current?: VNode
) {
  const cached = cache[key]
  if (cached && (!current || cached.tag !== current.tag)) {
    cached.componentInstance.$destroy()
  }
  cache[key] = null
  remove(keys, key)
}

pruneCacheEntry 負責將組件從緩存中刪除，它會調用組件 $destroy 方法銷燬組件實例，緩存組件置空，並移除對應的 key。

mounted () {
  this.$watch('include', val => {
    pruneCache(this, name => matches(val, name))
  })
  this.$watch('exclude', val => {
    pruneCache(this, name => !matches(val, name))
  })
}

function pruneCache (keepAliveInstance: any, filter: Function) {
  const { cache, keys, _vnode } = keepAliveInstance
  for (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)
      }
    }
  }
}

keep-alive 在 mounted 會監聽 include 和 exclude 的變化，屬性發生改變時調整緩存和 keys 的順序，最終調用的也是 pruneCacheEntry。

小結：cache 用於緩存組件，keys 存儲組件的 key，根據LRU策略來調整緩存組件。keep-alive 的 render 中最後會返回組件的 VNode，所以咱們也能夠得出一個結論，keep-alive 並不是真的不會渲染，而是渲染的對象是包裹的子組件。

組件渲染流程

舒適提示：這部份內容須要對 render 和 patch 過程有了解

渲染過程最主要的兩個過程就是 render 和 patch，在 render 以前還會有模板編譯，render 函數就是模板編譯後的產物，它負責構建 VNode 樹，構建好的 VNode 會傳遞給 patch，patch 根據 VNode 的關係生成真實dom節點樹。

這張圖描述了 Vue 視圖渲染的流程：

VNode構建完成後，最終會被轉換成真實dom，而 patch 是必經的過程。爲了更好的理解組件渲染的過程，假設 keep-alive 包括的組件有A和B兩個組件，默認展現A組件。

初始化渲染

組件在 patch 過程是會執行 createComponent 來掛載組件的，A組件也不例外。

// 源碼位置：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 */)
    }
    // after calling the init hook, if the vnode is a child component
    // it should've created a child instance and mounted it. the child
    // component also has set the placeholder vnode's elm.
    // in that case we can just return the element and be done.
    if (isDef(vnode.componentInstance)) {
      initComponent(vnode, insertedVnodeQueue)
      insert(parentElm, vnode.elm, refElm)
      if (isTrue(isReactivated)) {
        reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm)
      }
      return true
    }
  }
}

isReactivated 標識組件是否從新激活。在初始化渲染時，A組件尚未初始化構造完成，componentInstance 仍是 undefined。而A組件的 keepAlive 是 true，由於 keep-alive 做爲父級包裹組件，會先於A組件掛載，也就是 kepp-alive 會先執行 render 的過程，A組件被緩存起來，以後對插槽內第一個組件（A組件）的 keepAlive 賦值爲 true，不記得這個過程請看上面組件實現的代碼。因此此時的 isReactivated 是 false。

接着會調用 init 函數進行組件初始化，它是組件的一個鉤子函數：

// 源碼位置：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)
    }
  },
  // ...
}

createComponentInstanceForVnode 內會 new Vue 構造組件實例並賦值到 componentInstance，隨後調用 $mount 掛載組件。

回 createComponent，繼續走下面的邏輯：

if (isDef(vnode.componentInstance)) {
  initComponent(vnode, insertedVnodeQueue)
  insert(parentElm, vnode.elm, refElm)
  if (isTrue(isReactivated)) {
    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm)
  }
  return true
}

調用 initComponent 將 vnode.elm 賦值爲真實dom，而後調用 insert 將組件的真實dom插入到父元素中。

因此在初始化渲染中，keep-alive 將A組件緩存起來，而後正常的渲染A組件。

緩存渲染

當切換到B組件，再切換回A組件時，A組件命中緩存被從新激活。

再次經歷 patch 過程，keep-alive 是根據插槽獲取當前的組件，那麼插槽的內容又是如何更新實現緩存?

const isRealElement = isDef(oldVnode.nodeType)
if (!isRealElement && sameVnode(oldVnode, vnode)) {
  // patch existing root node
  patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly)
}

非初始化渲染時，patch 會調用 patchVnode 對比新舊節點。

// 源碼位置：src/core/vdom/patch.js
function patchVnode (
  oldVnode,
  vnode,
  insertedVnodeQueue,
  ownerArray,
  index,
  removeOnly
) {
  // ...
  let i
  const data = vnode.data
  if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
    i(oldVnode, vnode)
  }
  // ...
}

patchVnode 內會調用鉤子函數 prepatch。

// 源碼位置： src/core/vdom/create-component.js
prepatch (oldVnode: MountedComponentVNode, vnode: MountedComponentVNode) {
  const options = vnode.componentOptions
  const child = vnode.componentInstance = oldVnode.componentInstance
  updateChildComponent(
    child,
    options.propsData, // updated props
    options.listeners, // updated listeners
    vnode, // new parent vnode
    options.children // new children
  )
},

updateChildComponent 就是更新的關鍵方法，它裏面主要是更新實例的一些屬性：

// 源碼位置：src/core/instance/lifecycle.js
export function updateChildComponent (
  vm: Component,
  propsData: ?Object,
  listeners: ?Object,
  parentVnode: MountedComponentVNode,
  renderChildren: ?Array) {
  // ...

  // Any static slot children from the parent may have changed during parent's
  // update. Dynamic scoped slots may also have changed. In such cases, a forced
  // update is necessary to ensure correctness.
  const needsForceUpdate = !!(
    renderChildren ||               // has new static slots
    vm.$options._renderChildren ||  // has old static slots
    hasDynamicScopedSlot
  )
  
  // ...
  
  // resolve slots + force update if has children
  if (needsForceUpdate) {
    vm.$slots = resolveSlots(renderChildren, parentVnode.context)
    vm.$forceUpdate()
  }
}

Vue.prototype.$forceUpdate = function () {
  const vm: Component = this
  if (vm._watcher) {
    // 這裏最終會執行 vm._update(vm._render)
    vm._watcher.update()
  }
}

從註釋中能夠看到 needsForceUpdate 是有插槽纔會爲 true，keep-alive 符合條件。首先調用 resolveSlots 更新 keep-alive 的插槽，而後調用 $forceUpdate 讓 keep-alive 從新渲染，再走一遍 render。由於A組件在初始化已經緩存了，keep-alive 直接返回緩存好的A組件 VNode。VNode 準備好後，又來到了 patch 階段。

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 */)
    }
    // after calling the init hook, if the vnode is a child component
    // it should've created a child instance and mounted it. the child
    // component also has set the placeholder vnode's elm.
    // in that case we can just return the element and be done.
    if (isDef(vnode.componentInstance)) {
      initComponent(vnode, insertedVnodeQueue)
      insert(parentElm, vnode.elm, refElm)
      if (isTrue(isReactivated)) {
        reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm)
      }
      return true
    }
  }
}

A組件再次經歷 createComponent 的過程，調用 init。

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)
    }
  },
}

這時將再也不走 $mount 的邏輯，只調用 prepatch 更新實例屬性。因此在緩存組件被激活時，不會執行 created 和 mounted 的生命週期函數。

回到 createComponent，此時的 isReactivated 爲 true，調用 reactivateComponent:

function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
  let i
  // hack for #4339: a reactivated component with inner transition
  // does not trigger because the inner node's created hooks are not called
  // again. It's not ideal to involve module-specific logic in here but
  // there doesn't seem to be a better way to do it.
  let innerNode = vnode
  while (innerNode.componentInstance) {
    innerNode = innerNode.componentInstance._vnode
    if (isDef(i = innerNode.data) && isDef(i = i.transition)) {
      for (i = 0; i < cbs.activate.length; ++i) {
        cbs.activate[i](emptyNode, innerNode)
      }
      insertedVnodeQueue.push(innerNode)
      break
    }
  }
  // unlike a newly created component,
  // a reactivated keep-alive component doesn't insert itself
  insert(parentElm, vnode.elm, refElm)
}

最後調用 insert 插入組件的dom節點，至此緩存渲染流程完成。

小結：組件首次渲染時，keep-alive 會將組件緩存起來。等到緩存渲染時，keep-alive 會更新插槽內容，以後 $forceUpdate 從新渲染。這樣在 render 時就獲取到最新的組件，若是命中緩存則從緩存中返回 VNode。

總結

keep-alive 組件是抽象組件，在對應父子關係時會跳過抽象組件，它只對包裹的子組件作處理，主要是根據LRU策略緩存組件 VNode，最後在 render 時返回子組件的 VNode。緩存渲染過程會更新 keep-alive 插槽，從新再 render 一次，從緩存中讀取以前的組件 VNode 實現狀態緩存。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程