Comment Vue optimise les proxys de projet

Cette fois, je vais vous montrer comment Vue optimise l'agent de projet. Quelles sont les précautions pour que Vue optimise l'agent de projet. Ce qui suit est un cas pratique, jetons un coup d'œil.

La structure du projet dans le développement de projets de classe Vue est fondamentalement similaire à la méthode de génération Vue-cli. Dans cette méthode de développement, le mode le plus couramment utilisé consiste à activer l'agent pour le débogage simulé ou à distance. débogage, c'est-à-dire utiliser la configuration proxyTable définie par Vue-cli ou utiliser directement l'option proxy fournie par Webpack-dev-server. Il utilise la bibliothèque http-proxy, donc la configuration spécifique peut être consultée :

https://github.com/nodejitsu/node-http-proxy#options

En utilisant ces paramètres configurés, nous pouvons effectuer des configurations plus flexibles et obtenir de meilleurs résultats

Exigences d'utilisation

Supposons que nous développons localement actuellement Ce qui suit déclare :

• Développement local, les données utilisent le serveur fictif local

• L'interface d'autorisation utilise des données fictives locales et tous les autres utilisent le spécifié Une machine distante

• utilise des données fictives locales pour l'interface d'autorisation, et d'autres sous-interfaces de données utilisent différentes machines distantes

• Toutes les interfaces utilisent le même Machine distante

Solution

Regardons d'abord l'écriture classique de proxyTable :

proxyTable: {
 '/authui/': {
  target: target,
  changeOrigin: true
 },
 '/vendor/': {
  target: target,
  changeOrigin: true
 }
}

Le champ changeOrigin est utilisé, principalement pour changer l'en-tête de la requête. Affiner les exigences :

• Développement local : la cible pointe vers un certain port de localhost. Quant à la vérification de l'hôte, elle n'est certainement pas nécessaire

• Une partie est locale, et l'autre est une machine distante fixe : l'hôte local et les adresses distantes doivent être configurés pour la plupart. des adresses distantes doivent vérifier l'hôte

• Idem que deux, mais il y a plusieurs machines : plusieurs machines doivent être configurées manuellement

• La même machine distante, à ce stade, la machine devra peut-être être strictement vérifiée. Autrement dit, l'adresse IP doit également utiliser un nom de domaine et l'hôte du système doit être configuré avant de pouvoir être utilisé

Remarque : La différence entre l'hôte de vérification stricte et l'hôte de vérification ordinaire réside principalement dans le fait qu'en vérification stricte, l'URL demandée doit provenir du nom de domaine de la machine distante,
ne peut pas modifier directement l'implémentation de l'hôte de l'en-tête demandé, c'est-à-dire , le nom de domaine doit être configuré au niveau de l'hôte système.

Après avoir analysé les exigences spécifiques, commencez à préparer les moyens de les mettre en œuvre. La méthode de développement d'origine consiste à exécuter npm run dev Si nous devons ajouter une configuration au niveau de la ligne de commande, nous devons la définir sur la méthode npm run dev --param=paramvalue. Pour les commandes exécutées à l'aide de npm 的 script scripts,
ses paramètres ne peuvent pas être obtenus via process.env, et ils sont obtenus via process.env.npm_config_paramName
Il n'est pas très pratique d'utiliser la bibliothèque d'analyse de paramètres de ligne de commande prête à l'emploi. , mais pour éviter les ennuis, pour le moment, j'utiliserai la propre analyse de npm.

Les paramètres suivants sont requis lors du processus d'initiation de la requête :

• hôte : l'hôte qui doit être pointé lors du lancement de la requête peut être différent pour chaque machine

• port : Le port transmis par le proxy

• récepteur : L'adresse distante utilisée pour le push, y compris l'adresse IP. Pour éviter les problèmes, le. l'adresse IP n'est pas répertoriée séparément

Définissez ensuite le type personnalisé de demande de proxy pour la configuration :

• local : adresse locale, c'est-à-dire localhost

• distant : machine distante spécifiée

• Autres types personnalisés : utilisés pour d'autres types qui ont été spécifiés dans le fichier de configuration

• Version originale de la requête, telle que 'http://xxx' ou configuration du type d'objet, un tel proxy ne la traitera jamais

Au besoin, nous ajoutons les paramètres suivants qui sont utilisés pour contrôler l'adresse de pointage du proxy :

1. rd : l'adresse de la machine distante

2. focus : mode strict, tous les types de proxy personnalisés Convertir vers la rd machine spécifiée, disponible uniquement lorsque le paramètre rd est présent

3. allLocal : les proxys de type personnalisé pointent tous vers local

4. host：请求发现是否使用 host，而不是 IP 地址

总结一下（序号指向前面的需求）：

• 需要使用 host 进行访问的情形：4

• 需要更改 host：除 localhost 外都需要更改

• 需要对已有类型进行转换：1: 需要将所有自定义类型都转换为 local, 2和3：什么也不转换，4：所有的自定义类型全部转换为

remote 类型

这么一看，貌似 host 是不需要的，它的存在主要是针对某些 机器可能需要使用 host 的方式，所以还是保留一下。

实现

逻辑理清了就很简单了，配置文件设置为：

module.export = {
 rd1: {
  host: 'dev1.example.com',
  port: 8838,
  receiver: 'http://1.1.1.1:8888/receiver'
 },
 rd2: {
  host: 'dev2.example.com',
  port: 8838,
  receiver: 'http://1.1.1.1:8888/receiver'
 }
}

proxyTable 配置方式

{
 proxyTable: {
  '/api1': 'remote',
  '/api2': 'rd2',
  '/auth/xx': 'local',
  '/other': 'http://example.com'
 }
}

获取 proxyTable 的代码：

// 处理 proxyTable
const releaseConfig = require('../config/release.conf.js')
const rdConfig = releaseConfig[process.env.npm_config_rd]
const isAllRemote = process.env.npm_config_focus
const useHost = isAllRemote || process.env.npm_config_host
// 是否本机开发，本机开发 remote 会指向 local
const isAllLocal = process.env.npm_config_allLocal
module.exports = function (proxy) {
 const localUrl = `http://localhost:${proxy.localProxyPort}`
 const defaultHost = proxy.defaultRdHost || 'dev-example.com'
 const localProxyPort = proxy.localProxyPort || 8787
 const finalConfig = formatReleaseConfig(releaseConfig)
 const remote = finalConfig.remote || {}
 if (process.env.npm_config_rd) {
  if (!rdConfig) {
   throw new TypeError('RD 机器名称不存在，请在 config/release.conf.js 中进行配置')
  }
  if (!remote.ip) {
   throw new Error('请配置 rd 机器的 receiver')
  }
 }
 if (isAllRemote && !rdConfig) {
  throw new TypeError('focus 只能在提供了 rd 名称后可设置')
 }
 function formatReleaseConfig (config) {
  const result = {}
  Object.keys(config).map((key) => {
   const value = config[key]
   const ipMatch = (value.receiver || '').match(/:\/\/(.*?):\d/)
   const ip = ipMatch && ipMatch[1]
   result[key] = {
    ip,
    host: value.host || defaultHost,
    port: value.port || '8391'
   }
  })
  // 设置 remote
  if (rdConfig) {
   const ipMatch = (rdConfig.receiver || '').match(/:\/\/(.*?):\d/)
   const ip = ipMatch && ipMatch[1]
   result.remote = {
    ip,
    host: rdConfig.host || defaultHost,
    port: rdConfig.port || '8391'
   }
  }
  // 设置 local
  result.local = {
   ip: 'localhost',
   host: 'localhost',
   port: localProxyPort
  }
  return result
 }
 function setProxy (proxyTable) {
  const result = {}
  Object.keys(proxyTable).forEach((api) => {
   let type = proxyTable[api]
   const isCustomType = typeof type === 'string' && !/^http/.test(type)
   if (isCustomType && type !== 'remote' && type !== 'local' && !finalConfig[type]) {
    throw new TypeError(`代理类型${type}不正确，请提供 http 或 https 类型的接口，或者指定正确的 release 机器名称`)
   }
   if (type === 'remote' && !finalConfig.remote) {
    type = 'local'
   }
   if (isCustomType) {
    if (isAllRemote && type !== 'remote') {
     type = 'remote'
    }
    if (isAllLocal && type !== 'local') {
     type = 'local'
    }
   }
   const targetConfig = finalConfig[type]
   let target = type
   if (targetConfig) {
    target = {
     target: `http://${useHost ? targetConfig.host : targetConfig.ip}:${targetConfig.port}`,
     // 使用 host 时需要转换，其他不需要转换
     headers: {
      host: `${targetConfig.host}:${targetConfig.port}`
     }
    }
   }
   result[api] = target
  })
  return result
 }
 return {
  proxyTable: setProxy(proxy.proxyTable),
  host: remote.host || defaultHost
 }
}

用法

用法中需要配置两种指向：系统 host 和浏览器代理 Host。
之所以要两种 host, 本质上是因为接口使用的域名
和我们的本地访问的域名是相同的，同一域名无法指向两个地址，所以相当于对浏览器端进行了拦截。
系统 host 推荐使用 switchHost 进行切换，浏览器推荐使用 whistle 进行切换。

本地开发

host 配置：无
whistle 配置：默认的域名

127.0.0.1 dev.example.com

启动命令：

npm run dev
npm run dev --allLocal

注： 此时 proxyTable 中配置的 remote 全部转换为 local，在 allLocal 参数时将所有自定义类型转换为 local

本地 + 1 台远程

host 配置：无
whistle 配置：默认的域名
127.0.0.1 dev1.example.com
127.0.0.1 dev2.example.com

启动命令：

npm run dev --rd=rd1
npm run dev --rd=rd1 --host

注： --host 表示使用访问使用 host 而非 ip，使用时需要 host 地址

本地 + n 台远程

host 配置：无

whistle 配置：默认的域名

127.0.0.1 dev1.example.com

127.0.0.1 dev2.example.com

{
 proxyTable: {
  '/api1': 'rd1',
  '/api2': 'rd2',
  '/auth/xx': 'local',
  '/other': 'http://example.com'
 }
}

proxyTable 配置：

启动命令：

npm run dev

远程 1 台机器

host 配置：

1.1.1.1 dev1.example.com
1.1.1.1 dev2.example.com

whistle 配置：默认的域名

127.0.0.1 dev1.example.com
127.0.0.1 dev2.example.com

启动命令：

npm run dev --rd=rd1 --focus

组件优化

vue 的组件化深受大家喜爱，到底组件拆到什么程度算是合理，还要因项目大小而异，小型项目可以简单几个组件搞定，甚至不用 vuex，axios 等等，如果规模较大就要细分组件，越细越好，包括布局的封装，按钮，表单，提示框，轮播等，推荐看下 Element 组件库的代码，没时间写这么详细可以直接用 Element 库，分几点进行优化

•组件有明确含义，只处理类似的业务。复用性越高越好，配置性越强越好。

•自己封装组件还是遵循配置 props 细化的规则。

•组件分类，我习惯性的按照三类划分，page、page-item 和 layout，page 是路由控制的部分，page-item 属于 page 里各个布局块如 banner、side 等等，layout 里放置多个页面至少出现两次的组件，如 icon, scrollTop 等

总结

细挖需求，可能还有更简单的方式，在大部分情况下能够减少代码修改，是 webpack 配置型的实现吧。当然，方式并不完美，尤其在 mac 下，居然不能支持 --rd xx 这种形式，可以有类似的库吧，后续可以做为深入的内容。

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

js中el表达式怎样做出非空判断

VUE对ElTableColumn进行扩展

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!