devbox
小惠珠哦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

vue3.0对服务端进行渲染_vue3服务端渲染

作者：小惠珠哦 | 2024-06-24 07:09:11

赞

踩

vue3服务端渲染

vue3.0支持服务端渲染。Vue支持将组件在服务端直接渲染成HTML字符串，作为服务端响应返回给浏览器，最后在浏览器端将静态的HTML“激活”(hydrate) 为能够交互的客户端应用。一个由服务端渲染的Vue应用可以被认为是“同构的” 或“通用的，因为应用的大部分代码同时运行在服务端和客户端。vue用服务端渲染的优势：更快的首屏加载、统一的心智模型、更好的SEO。

 

vue支持服务端渲染(SSR)。

Vue.js 是一个用于构建客户端应用的框架。默认情况下，Vue 组件的职责是在浏览器中生成和操作 DOM。然而，Vue 也支持将组件在服务端直接渲染成 HTML 字符串，作为服务端响应返回给浏览器，最后在浏览器端将静态的 HTML“激活”(hydrate) 为能够交互的客户端应用。

一个由服务端渲染的 Vue.js 应用也可以被认为是“同构的”(Isomorphic) 或“通用的”(Universal)，因为应用的大部分代码同时运行在服务端和客户端。

为什么要用服务端渲染 (SSR)？

与客户端的单页应用 (SPA) 相比，SSR 的优势主要在于：

  • 更快的首屏加载：这一点在慢网速或者运行缓慢的设备上尤为重要。服务端渲染的 HTML 无需等到所有的 JavaScript 都下载并执行完成之后才显示，所以你的用户将会更快地看到完整渲染的页面。除此之外，数据获取过程在首次访问时在服务端完成，相比于从客户端获取，可能有更快的数据库连接。这通常可以带来更高的核心 Web 指标评分、更好的用户体验，而对于那些“首屏加载速度与转化率直接相关”的应用来说，这点可能至关重要。

 

  • 统一的心智模型：你可以使用相同的语言以及相同的声明式、面向组件的心智模型来开发整个应用，而不需要在后端模板系统和前端框架之间来回切换。

  • 更好的 SEO：搜索引擎爬虫可以直接看到完全渲染的页面。

使用 SSR 时还有一些权衡之处需要考量：

  • 开发中的限制。浏览器端特定的代码只能在某些生命周期钩子中使用；一些外部库可能需要特殊处理才能在服务端渲染的应用中运行。

  • 更多的与构建配置和部署相关的要求。服务端渲染的应用需要一个能让 Node.js 服务器运行的环境，不像完全静态的 SPA 那样可以部署在任意的静态文件服务器上。

  • 更高的服务端负载。在 Node.js 中渲染一个完整的应用要比仅仅托管静态文件更加占用 CPU 资源，因此如果你预期有高流量，请为相应的服务器负载做好准备，并采用合理的缓存策略。

服务端渲染 (SSR) vs. 静态站点生成（SSG）

静态站点生成 (Static-Site Generation，缩写为 SSG)，也被称为预渲染，是另一种流行的构建快速网站的技术。如果用服务端渲染一个页面所需的数据对每个用户来说都是相同的，那么我们可以只渲染一次，提前在构建过程中完成，而不是每次请求进来都重新渲染页面。预渲染的页面生成后作为静态 HTML 文件被服务器托管。

SSG 保留了和 SSR 应用相同的性能表现：它带来了优秀的首屏加载性能。同时，它比 SSR 应用的花销更小，也更容易部署，因为它输出的是静态 HTML 和资源文件。这里的关键词是静态：SSG 仅可以用于消费静态数据的页面，即数据在构建期间就是已知的，并且在多次部署期间不会改变。每当数据变化时，都需要重新部署。

如果你调研 SSR 只是为了优化为数不多的营销页面的 SEO (例如 /、/about 和 /contact 等)，那么你可能需要 SSG 而不是 SSR。SSG 也非常适合构建基于内容的网站，比如文档站点或者博客。事实上，你现在正在阅读的这个网站就是使用 VitePress 静态生成的，它是一个由 Vue 驱动的静态站点生成器。

Hello World

准备在行动中体验服务端渲染吧。服务端渲染(即SSR)听起来很复杂，不过一个简单的Node脚本只需要3步就可以实现这个功能:

  1. // 步骤 1:创建一个Vue实例
  2. var Vue = require('vue')
  3. var app = new Vue({
  4.   render: function (h) {
  5.     return h('p', 'hello world')
  6.   }
  7. })
  8. // 步骤 2: 创建一个渲染器
  9. var renderer = require('vue-server-renderer').createRenderer()
  10. // 步骤 3: 将 Vue实例 渲染成 HTML
  11. renderer.renderToString(app, function (error, html) {
  12.   if (error) throw error
  13.   console.log(html)
  14.   // => <p server-rendered="true">hello world</p>
  15. })

 

这并不困难。当然这个示例比大部分应用都简单，来探讨这些功能怎样运作

通过Express Web服务器实现简单的服务端渲染

如果没有一个Web服务器，很难说是服务端渲染，所以我们来补充它。我们将构建一个非常简单的服务端渲染应用，只用ES5，也不带其他构建步骤或Vue插件。

启动一个应用告诉用户他们在一个页面上花了多少时间。

  1. new Vue({
  2.   template: '<div>你已经在这花了 {{ counter }} 秒。</div>',
  3.   data: {
  4.     counter: 0
  5.   },
  6.   created: function () {
  7.     var vm = this
  8.     setInterval(function () {
  9.       vm.counter += 1
  10.     }, 1000)
  11.   }
  12. })

 

为了适应服务端渲染，我们需要进行一些修改，让它可以在浏览器和Node中渲染：

  • 在浏览器中，将我们的应用实例添加到全局上下文（ window）上,我们可以安装它。

  • 在Node中，导出一个工厂函数让我们可以为每个请求创建应用实例。

实现这个需要一点模板：

  1. // assets/app.js
  2. (function () { 'use strict'
  3.   var createApp = function () {
  4.     // ---------------------
  5.     // 开始常用的应用代码
  6.     // ---------------------
  7.     // 主要的Vue实例必须返回，并且有一个根节点在id "app"上，这样客户端可以加载它。
  8.     return new Vue({
  9.       template: '<div id="app">你已经在这花了 {{ counter }} 秒。</div>',
  10.       data: {
  11.         counter: 0
  12.       },
  13.       created: function () {
  14.         var vm = this
  15.         setInterval(function () {
  16.           vm.counter += 1
  17.         }, 1000)
  18.       }
  19.     })
  20.     // -------------------
  21.     // 结束常用的应用代码
  22.     // -------------------
  23.   }
  24.   if (typeof module !== 'undefined' && module.exports) {
  25.     module.exports = createApp
  26.   } else {
  27.     this.app = createApp()
  28.   }
  29. }).call(this)

 现在有了应用代码，接着加一个 html文件。

  1. <!-- index.html -->
  2. <!DOCTYPE html>
  3. <html>
  4. <head>
  5.   <title>My Vue App</title>
  6.   <script src="/assets/vue.js"></script>
  7. </head>
  8. <body>
  9.   <div id="app"></div>
  10.   <script src="/assets/app.js"></script>
  11.   <script>app.$mount('#app')</script>
  12. </body>
  13. </html>

 

主要引用assets文件夹中我们先前创建的app.js，以及vue.js文件，我们就有了一个可以运行的单页面应用

然后为了实现服务端渲染，在服务端需要加一个步骤。

  1. // server.js
  2. 'use strict'
  3. var fs = require('fs')
  4. var path = require('path')
  5. // 定义全局的Vue为了服务端的app.js
  6. global.Vue = require('vue')
  7. // 获取HTML布局
  8. var layout = fs.readFileSync('./index.html', 'utf8')
  9. // 创建一个渲染器
  10. var renderer = require('vue-server-renderer').createRenderer()
  11. // 创建一个Express服务器
  12. var express = require('express')
  13. var server = express()
  14. // 部署静态文件夹为 "assets"文件夹
  15. server.use('/assets', express.static(
  16.   path.resolve(__dirname, 'assets')
  17. ))
  18. // 处理所有的Get请求
  19. server.get('*', function (request, response) {
  20.   // 渲染我们的Vue应用为一个字符串
  21.   renderer.renderToString(
  22.     // 创建一个应用实例
  23.     require('./assets/app')(),
  24.     // 处理渲染结果
  25.     function (error, html) {
  26.       // 如果渲染时发生了错误
  27.       if (error) {
  28.         // 打印错误到控制台
  29.         console.error(error)
  30.         // 告诉客户端错误
  31.         return response
  32.           .status(500)
  33.           .send('Server Error')
  34.       }
  35.       // 发送布局和HTML文件
  36.       response.send(layout.replace('<div id="app"></div>', html))
  37.     }
  38.   )
  39. })
  40. // 监听5000端口
  41. server.listen(5000, function (error) {
  42.   if (error) throw error
  43.   console.log('Server is running at localhost:5000')
  44. })

 这样就完成了。整个示例，克隆下来深度实验。一旦它在本地运行时，你可以通过在页面右击选择页面资源（或类似操作）确认服务选渲染真的运行了。可以在body中看到：

<div id="app" server-rendered="true">You have been here for 0 seconds&period;</div>

 代替:

<div id="app"></div>

流式响应

Vue还支持流式渲染，优先选择适用于支持流的Web服务器。允许HTML一边生成一般写入相应流，而不是在最后一次全部写入。其结果是请求服务速度更快，没有缺点！

为了使上一节应用代码适用流式渲染，可以简单的替换 server.get('*',...)为下面的代码：

  1. // 拆分布局成两段HTML
  2. var layoutSections = layout.split('<div id="app"></div>')
  3. var preAppHTML = layoutSections[0]
  4. var postAppHTML = layoutSections[1]
  5. // 处理所有的Get请求
  6. server.get('*', function (request, response) {
  7.   // 渲染我们的Vue实例作为流
  8.   var stream = renderer.renderToStream(require('./assets/app')())
  9.   // 将预先的HTML写入响应
  10.   response.write(preAppHTML)
  11.   // 每当新的块被渲染
  12.   stream.on('data', function (chunk) {
  13.     // 将块写入响应
  14.     response.write(chunk)
  15.   })
  16.  
  17.   // 当所有的块被渲染完成
  18.   stream.on('end', function () {
  19.     // 将post-app HTML写入响应
  20.     response.end(postAppHTML)
  21.   })
  22.   // 当渲染时发生错误
  23.   stream.on('error', function (error) {
  24.     // 打印错误到控制台
  25.     console.error(error)
  26.     // 告诉客服端发生了错误
  27.     return response
  28.       .status(500)
  29.       .send('Server Error')
  30.   })
  31. })

 

这不比之前的版本复杂，甚至这对你来说都不是个新概念。我们做了：

  • 建立流

  • 在应用响应前写入HTML

  • 在可获得时将应用HTML写入响应

  • 在响应最后写入HTML

  • 处理任何错误

组件缓存

Vue的服务端渲染默认非常快，但是你可以通过缓存渲染好的组件进一步提高性能。这被认为是一种先进的功能，但是，如果缓存了错误的组件（或者正确的组件带有错误的内容）将导致应用渲染出错。特别注意：

不应该缓存组件包含子组件依赖全局状态（例如来自vuex的状态）。如果这么做，子组件（事实上是整个子树）也会被缓存。所以要特别注意带有slots片段或者子组件的情况。

设置

在警告情况之外的，我们可以用下面的方法缓存组件。

首先，你需要提供给渲染器一个 缓存对象。这有个简单的示例使用 lru-cache

  1. var createRenderer = require('vue-server-renderer').createRenderer
  2. var lru = require('lru-cache')
  3. var renderer = createRenderer({
  4.   cache: lru(1000)
  5. })

 

这将缓存高达1000个独立的渲染。对于更进一步缓存到内容中的配置，看lru-cache设置

然后对于你想缓存的组件，你可以为他们提供：

  • 一个唯一的名字

  • 一个 serverCacheKey函数，返回一个唯一的组件作用域

例如:

  1. Vue.component({
  2.   name: 'list-item',
  3.   template: '<li>{{ item.name }}</li>',
  4.   props: ['item'],
  5.   serverCacheKey: function (props) {
  6.     return props.item.type + '::' + props.item.id
  7.   }
  8. })

 

缓存的理想组件

任何纯组件可以被安全缓存 - 这是保证给任何组件传递一样的数据产生相同的HTML。这些场景的例子包括：

  • 静态的组件 (例如 总是尝试一样的HTML,所以 serverCacheKey 函数可以被返回 true)

  • 列表组件（当有大量列表，缓存他们可以改善性能）

  • 通用UI组件 (例如 buttons, alerts, 等等 - 至少他们通过props获取数据而不是 slots或者子组件)

说明：

现在，应该理解服务端渲染背后的基本概念了。但是，构建过程、路由、Vuex每一个都有自己的注意事项。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小惠珠哦/article/detail/752000
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号