http-proxy-middleware 完全指南:一行配置搞定 Node.js 反向代理(Express / Connect / Next.js 通用中间件)

  • 后端
  • API网关

【免费下载链接】http-proxy-middleware

:zap: The one-liner node.js http-proxy (httpxy) middleware for connect, express, next.js and more

项目地址: https://gitcode.com/gh_mirrors/ht/http-proxy-middleware
点击查看 免费下载

本文以 http-proxy-middleware v4.x 官方 README 为主线,系统讲解如何通过 createProxyMiddleware() 一行式配置,为 connect、express、next.js、hono 等 Node.js 服务接入反向代理:涵盖 pathFilter、pathRewrite、router、plugins 等核心选项、WebSocket 代理、请求/响应拦截改写、IPv6 兼容与调试技巧,并结合本仓库源码说明底层实现原理。读完本文,你将能够独立完成从"简单单目标代理"到"多目标路由 + 路径重写 + 请求体修复 + 响应体篡改"的完整实战配置。

当前仓库对应 v4.x 版本线(package.json 中版本号为 4.2.0),底层由 httpxy(http-proxy 的持续维护版本)驱动,额外提供 debug、is-glob、is-plain-obj、micromatch 等依赖支撑路径匹配与插件机制。需要注意的是,本库要求 Node.js ^22.15.0 || ^24.0.0 || >=26.0.0。

安装

npm install --save-dev http-proxy-middleware

安装后即可在任意支持中间件(middleware)模式的 Node.js 服务中引入使用。

基本用法

核心 API 只有一个:createProxyMiddleware(config)。调用后返回一个标准的中间件函数(RequestHandler),可直接挂载到服务器路由栈中使用。

import { createProxyMiddleware } from 'http-proxy-middleware';

const apiProxy = createProxyMiddleware({
  target: 'http://www.example.org',
  changeOrigin: true,
});

// 'apiProxy' 现在可以直接作为中间件使用

两个最基础的选项:

  • options.target:目标主机地址(协议 + 主机,例如 http://www.example.org)。
  • options.changeOrigin:为基于名称的虚拟主机站点(name-based virtual hosting)而设,置为 true 时会把请求的 Host 头改写为目标地址的主机名。

Express 服务器示例

// 引入依赖
import express from 'express';
import { createProxyMiddleware } from 'http-proxy-middleware';

const app = express();

// 创建代理
/** @type {import('http-proxy-middleware').RequestHandler<import('express').Request, import('express').Response>} */
const exampleProxy = createProxyMiddleware({
  target: 'http://www.example.org/api', // 目标主机,且与代理保持相同的基础路径
  changeOrigin: true, // 虚拟主机站点需要
});

// 挂载到 Web 服务器
app.use('/api', exampleProxy);
app.listen(3000);

这是仓库中 examples/express/index.js 的真实写法:代理 http://jsonplaceholder.typicode.com/users,挂载在 /users 路由上,同时通过 logger: console 输出代理日志,并在 SIGINT/SIGTERM 时优雅关闭服务器。

使用 app.use(path, proxy) 挂载

如果希望利用服务器 app.use 的 path 参数来匹配请求,再配合 pathFilter 选项做进一步的包含/排除:

app.use(
  createProxyMiddleware({
    target: 'http://www.example.org/api',
    changeOrigin: true,
    pathFilter: '/api/proxy-only-this-path',
  }),
);

注意 pathFilter 匹配的是 request.url 的路径部分;在 Express 中,这个路径是相对代理挂载点的路径。

从源码结构看,createProxyMiddleware 只是 src/factory.ts 里对 HttpProxyMiddleware 类的封装——new HttpProxyMiddleware(options) 构造出中间件后原样返回。真正的工作流程在 src/http-proxy-middleware.ts 的 middleware 函数中:先判断 shouldProxy() 是否命中过滤条件,命中则依次执行"准备阶段(router + pathRewrite)"和"代理阶段(proxy.web())",未命中则直接调用 next() 放行。

选项详解

http-proxy-middleware 专属选项如下,它们会与底层 httpxy 的全部选项合并生效(完整类型定义见 src/types.ts)。

pathFilter(string、[]string、glob、[]glob、function)

用于收窄"哪些请求应该被代理"。过滤时使用的 path 是 request.url 的路径名(在 Express 中是相对代理挂载点的路径)。

  • 单一路径匹配

    • createProxyMiddleware({...}):不配置 pathFilter 时匹配任意路径,所有请求都会被代理。
    • createProxyMiddleware({ pathFilter: '/api', ...}):匹配以 /api 开头的路径。
  • 多路径匹配

    • createProxyMiddleware({ pathFilter: ['/api', '/ajax', '/someotherpath'], ...})
  • 通配符(glob)匹配

    需要细粒度控制时可以使用通配符匹配,glob 模式由 micromatch 完成(is-glob 用于识别 glob 语法,参见 src/path-filter.ts):

    • pathFilter: '**':匹配任意路径,所有请求都会被代理。
    • pathFilter: '**/*.html':匹配所有以 .html 结尾的路径。
    • pathFilter: '/*.html':匹配路径根目录(path-absolute)下直接一级的 .html。
    • pathFilter: '/api/**/*.html':匹配 /api 路径下所有以 .html 结尾的请求。
    • pathFilter: ['/api/**', '/ajax/**']:组合多个模式。
    • pathFilter: ['/api/**', '!**/bad.json']:排除模式。

    注意:多路径匹配中,不能把普通字符串路径和通配符路径混用。源码会在检测到混合时抛出 HPM_INVALID_PATH_FILTER_ARRAY_CONFIG 错误,提示期望 ["/api", "/ajax"] 或 ["/api/**", "!**.html"] 这样的纯同类型数组。

  • 自定义匹配函数

    需要完全控制时,可以提供一个函数决定哪些请求需要代理:

    /**
     * @return {Boolean}
     */
    const pathFilter = function (path, req) {
      return path.match('^/api') && req.method === 'GET';
    };
    
    const apiProxy = createProxyMiddleware({
      target: 'http://www.example.org',
      pathFilter: pathFilter,
    });
    

    函数签名在 src/types.ts 中定义为 (pathname: string, req) => boolean | string | RegExpMatchArray | null,返回值会被 Boolean() 化后决定是否代理。更复杂的过滤场景可参考 recipes/pathFilter.md。

pathRewrite(object/function)

重写发送给目标服务器的 URL 路径。对象的 key 会被当作 RegExp 来匹配路径。

// 重写路径
pathRewrite: {'^/old/api' : '/new/api'}

// 移除路径
pathRewrite: {'^/remove/api' : ''}

// 添加基础路径
pathRewrite: {'^/' : '/basepath/'}

// 自定义重写
pathRewrite: function (path, req, res, options) { return path.replace('/api', '/base/api') }

// 自定义重写,返回 Promise
pathRewrite: async function (path, req, res, options) {
  const should_add_something = await httpRequestToDecideSomething(path);
  if (should_add_something) path += "something";
  return path;
}

// 注意:在 WebSocket 升级流程中 res 为 undefined

实现细节(src/path-rewriter.ts):对象配置会被 parsePathRewriteRules() 逐条编译为 { regex: new RegExp(key), value } 规则并缓存;匹配时按对象声明顺序遍历,只应用第一条命中的规则然后 break。函数配置则直接作为重写函数使用。自 v4.1.0 起,自定义函数额外获得 res 与 options 两个参数。

router(object/function)

为特定请求重新定向 option.target。

// 使用 `host` 和/或 `path` 匹配请求。首个匹配生效。
// 配置的顺序很重要。
router: {
    'integration.localhost:3000' : 'http://127.0.0.1:8001',  // 仅 host
    'staging.localhost:3000'     : 'http://127.0.0.1:8002',  // 仅 host
    'localhost:3000/api'         : 'http://127.0.0.1:8003',  // host + path
    '/rest'                      : 'http://127.0.0.1:8004'   // 仅 path
}

// 自定义 router 函数(返回字符串 target)
router: function(req, res, options) {
    return 'http://127.0.0.1:8004';
}

// 自定义 router 函数(返回 target 对象)
router: function(req, res, options) {
    return {
        protocol: 'https:', // 冒号是必需的
        host: '127.0.0.1',
        port: 8004
    };
}

// 异步 router 函数,返回 Promise
router: async function(req, res, options) {
    const url = await doSomeIO();
    return url;
}

// 注意:在 WebSocket 升级流程中 res 为 undefined

底层匹配逻辑见 src/router.ts:对象形式会遍历键表,键含 / 时按"仅路径前缀匹配"或"host + 路径前缀精确匹配"(host 必须完全相等且路径以 key 开头)处理;纯 host 键则要求与 req.headers.host 完全相等。首个命中即 break,因此配置顺序决定优先级。函数形式直接 await router(req, res, config) 获取目标。

plugins(Array)

通过插件机制访问内部 httpxy 代理服务器实例,定制行为:

const simpleRequestLogger = (proxyServer, options) => {
  proxyServer.on('proxyReq', (proxyReq, req, res) => {
    console.log(`[HPM] [${req.method}] ${req.url}`); // 输出:[HPM] GET /users
  });
},

const config = {
  target: `http://example.org`,
  changeOrigin: true,
  plugins: [simpleRequestLogger],
};

插件函数签名在 src/types.ts 中定义为 (proxyServer, options) => void。加载顺序见 src/get-plugins.ts:默认插件数组 + 用户插件数组按序注册,用户插件排在内置插件之后。

ejectPlugins(boolean)默认值:false

如果对预配置的内置插件不满意,可以设置 ejectPlugins: true 将它们全部弹出,完全自行掌控。

注意:弹出后要自行注册错误处理,防止服务器崩溃。

// 弹出默认插件,再手动加回来
import {
  debugProxyErrorsPlugin, // 订阅代理错误,防止服务器崩溃
  errorResponsePlugin, // 代理出错时返回 5xx 响应
  loggerPlugin, // 把代理事件记录到 logger(如 console)
  proxyEventsPlugin, // 实现 "on:" 选项
} from 'http-proxy-middleware';

createProxyMiddleware({
  target: `http://example.org`,
  changeOrigin: true,
  ejectPlugins: true,
  plugins: [debugProxyErrorsPlugin, loggerPlugin, errorResponsePlugin, proxyEventsPlugin],
});

结合 src/get-plugins.ts 可知默认加载的插件是 debugProxyErrorsPlugin、proxyEventsPlugin、loggerPlugin,外加一个 errorResponsePlugin——且当你在 on.error 中自备了错误处理函数时,内置的 errorResponsePlugin 会被自动跳过,避免双重处理。

definePlugin 辅助函数

用于创建你自己的 http-proxy-middleware 插件(默认插件也都是用 definePlugin 创建的):

import { createProxyMiddleware, definePlugin } from 'http-proxy-middleware';

const myPlugin = definePlugin((proxyServer, options) => {
  // 插件实现
});

// 配置并使用插件
createProxyMiddleware({
  target: `http://example.org`,
  plugins: [myPlugin],
});

definePlugin 本身只是一个类型安全的恒等包装(src/plugins/define-plugin.ts),作用是让插件作者获得完整的 Plugin<TReq, TRes> 类型推导与文档标注。

logger(Object)

配置日志对象,输出 http-proxy-middleware 的运行信息,支持 console、winston、pino、bunyan、log4js 等。

内部只使用 info、warn、error 三个方法,以兼容不同日志库。若使用 winston,需要开启字符串插值(string interpolation)。

createProxyMiddleware({
  logger: console,
});

日志类型定义见 src/types.ts:Pick<Console, 'info' | 'warn' | 'error'>。更多细节可参考 recipes/logger.md。

httpxy 事件

通过 on 选项订阅 httpxy 代理服务器事件:

createProxyMiddleware({
  target: 'http://www.example.org',
  on: {
    proxyReq: (proxyReq, req, res) => {
      /* 处理 proxyReq */
    },
    proxyRes: (proxyRes, req, res) => {
      /* 处理 proxyRes */
    },
    error: (err, req, res) => {
      /* 处理 error */
    },
  },
});
  • option.on.error:函数,订阅 httpxy 的 error 事件做自定义错误处理。

    function onError(err, req, res, target) {
      res.writeHead(500, {
        'Content-Type': 'text/plain',
      });
      res.end('Something went wrong. And we are reporting a custom error message.');
    }
    
  • option.on.proxyRes:函数,订阅 httpxy 的 proxyRes 事件。

    function onProxyRes(proxyRes, req, res) {
      proxyRes.headers['x-added'] = 'foobar'; // 给响应添加新头
      delete proxyRes.headers['x-removed']; // 移除响应头
    }
    
  • option.on.proxyReq:函数,订阅 httpxy 的 proxyReq 事件。

    function onProxyReq(proxyReq, req, res) {
      // 给请求添加自定义头
      proxyReq.setHeader('x-added', 'foobar');
      // 或在这里记录 req
    }
    
  • option.on.proxyReqWs:函数,订阅 httpxy 的 proxyReqWs 事件。

    function onProxyReqWs(proxyReq, req, socket, options, head) {
      // 添加自定义头
      proxyReq.setHeader('X-Special-Proxy-Header', 'foobar');
    }
    
  • option.on.open:函数,订阅 httpxy 的 open 事件。

    function onOpen(proxySocket) {
      // 在这里监听来自目标服务器的消息
      proxySocket.on('data', hybridParseAndLogMessage);
    }
    
  • option.on.close:函数,订阅 httpxy 的 close 事件。

    function onClose(res, socket, head) {
      // 查看断开的 WebSocket 连接
      console.log('Client disconnected');
    }
    

完整事件签名见 src/types.ts 的 OnProxyEvent:除上述事件外,还支持 start、end、econnreset。需要说明的是,httpxy 基于 Promise 的 proxy.web() 在发生网络错误时不会自动 emit error,因此在 src/http-proxy-middleware.ts 中代理层捕获异常后会手动调用 this.proxy.emit('error', ...) 并调用 next(err)——这正是 on.error 与错误插件能兜底崩溃的原因。

httpxy 选项

以下选项由底层 httpxy 库提供,http-proxy-middleware 会原样透传:

  • option.target:url 字符串,交由 url 模块解析。

  • option.forward:url 字符串,交由 url 模块解析。

  • option.agent:传给 http(s).request 的对象(对应 Node 的 https agent 与 http agent)。

  • option.ssl:传给 https.createServer() 的对象。

  • option.ws:true/false,是否代理 WebSocket。

  • option.xfwd:true/false,是否追加 x-forward 系列头。

  • option.secure:true/false,是否校验 SSL 证书。

  • option.toProxy:true/false,将绝对 URL 作为 path 传递(用于向"代理的代理"转发)。

  • option.prependPath:true/false,默认 true,是否把 target 的路径前缀加到代理路径之前。

  • option.ignorePath:true/false,默认 false,是否忽略传入请求的代理路径(如需保留需手动补 /)。

  • option.localAddress:本地网卡接口字符串,用于绑定出站连接。

  • option.changeOrigin:true/false,默认 false,将 Host 头改写为目标 URL 的主机。

  • option.preserveHeaderKeyCase:true/false,默认 false,是否保留响应头 key 的大小写。

  • option.auth:Basic 认证,如 'user:password',用于计算 Authorization 头。

  • option.hostRewrite:重写 301/302/307/308 重定向中的 location 主机名。

  • option.autoRewrite:根据请求的 host/port 重写重定向 location 的 host/port。默认 false。

  • option.protocolRewrite:把重定向 location 的协议改写为 'http' 或 'https'。默认 null。

  • option.cookieDomainRewrite:重写 set-cookie 头的 domain。可选值:

    • false(默认):禁用 cookie 重写
    • 字符串:新域名,例如 cookieDomainRewrite: "new.domain";设为 "" 可移除 domain
    • 对象:域名到新域名的映射,"*" 匹配所有域名。例如保留一个域名不变、改写一个域名、移除其余域名:
    cookieDomainRewrite: {
      "unchanged.domain": "unchanged.domain",
      "old.domain": "new.domain",
      "*": ""
    }
    
  • option.cookiePathRewrite:重写 set-cookie 头的 path。可选值:

    • false(默认):禁用 cookie 重写
    • 字符串:新路径,例如 cookiePathRewrite: "/newPath/";设为 "" 移除 path,设为 "/" 置为根路径
    • 对象:路径到新路径的映射,"*" 匹配所有路径。例如保留一个路径不变、改写一个路径、移除其余路径:
    cookiePathRewrite: {
      "/unchanged.path/": "/unchanged.path/",
      "/old.path/": "/new.path/",
      "*": ""
    }
    
  • option.headers:对象,追加请求头(例如 {host:'www.example.org'})。

  • option.proxyTimeout:代理在未收到目标响应时的超时时间(毫秒)。

  • option.timeout:传入请求的超时时间(毫秒)。

  • option.followRedirects:true/false,默认 false,是否跟随重定向。

  • option.selfHandleResponse:true/false,设为 true 时不会执行任何 webOutgoing 处理流程,需要你自行监听 proxyRes 事件并负责返回响应。

  • option.buffer:作为请求体发送的数据流。若你有一些中间件在代理前消费了请求流(例如把请求体读进了 req.rawbody 字段),可以把它重新放回 buffer:

    import { createProxyServer } from 'httpxy';
    import streamify from 'stream-array';
    
    const proxy = createProxyServer();
    
    export default function proxyWithBody(req, res, next) {
      proxy.web(
        req,
        res,
        {
          target: 'http://127.0.0.1:4003/',
          buffer: streamify(req.rawBody),
        },
        next,
      );
    }
    

WebSocket

启用方式很简单:设置 ws: true 并配置目标。

// 简洁 API
createProxyMiddleware({ pathFilter: '/', target: 'http://echo.websocket.org', ws: true });

更多示例见 recipes/websocket.md。从源码看,WebSocket 代理依赖首次 HTTP 请求拿到 server 对象后自动订阅 upgrade 事件(src/http-proxy-middleware.ts 的 catchUpgradeRequest),命中 pathFilter 后调用 proxy.ws(req, socket, activeProxyOptions, head)(同文件 handleUpgrade,第 142-155 行)。测试覆盖见 test/e2e/websocket.spec.ts。

外部 WebSocket 升级(External WebSocket upgrade)

在上面的例子中,http-proxy-middleware 依赖一个初始的 HTTP 请求来监听 HTTP upgrade 事件。如果需要在没有初始 HTTP 请求的情况下代理 WebSocket,可以手动订阅服务器的 HTTP upgrade 事件。

另外注意:当同一个中间件实例被挂载到多个服务器且使用 ws: true 时,每个服务器都需要先有一次初始 HTTP 请求,升级事件才会被自动订阅。

const wsProxy = createProxyMiddleware({ target: 'ws://echo.websocket.org', changeOrigin: true });

const app = express();
app.use(wsProxy);

const server = app.listen(3000);
server.on('upgrade', wsProxy.upgrade); // <-- 订阅 http 'upgrade' 事件

wsProxy.upgrade 是中间件对象上暴露的方法(类型见 src/types.ts 的 RequestHandler.upgrade)。它的实现会先通过 req.socket.server 找到所属服务器,若该服务器尚未被自动订阅过,就手动执行 handleUpgrade(src/http-proxy-middleware.ts)。

拦截并修改请求

通过 createProxyMiddleware 中定义 on.proxyReq 来拦截来自下游的请求。

修复 POST 请求:

使用预置的请求拦截器 fixRequestBody,可以修复在 bodyParser 先于本中间件执行时,POST 请求体无法被代理的问题。

import { createProxyMiddleware, fixRequestBody } from 'http-proxy-middleware';

const proxy = createProxyMiddleware({
  on: {
    // bodyParser 使用时修复 POST 请求
    proxyReq: fixRequestBody,
  },
});

修改 POST 请求:

import bodyParser from 'body-parser';
import { createProxyMiddleware, fixRequestBody } from 'http-proxy-middleware';

app.use(bodyParser.json());

app.use(
  '/api',
  createProxyMiddleware({
    target: 'http://www.example.org',
    changeOrigin: true,
    on: {
      proxyReq: (proxyReq, req) => {
        if (req.method !== 'POST' || !req.body) {
          return;
        }

        // 修改已解析的请求体
        req.body.injected = 'server-only';

        // 把修改后的请求体写回被代理的请求
        fixRequestBody(proxyReq, req);
      },
    },
  }),
);

fixRequestBody 的底层实现(src/handlers/fix-request-body.ts)会按 Content-Type 分支处理:application/json 走 JSON.stringify、application/x-www-form-urlencoded 走 querystring.stringify、multipart/form-data 走专用的 stringify-form-data 工具、text/plain 原样写入;同时会检测 Content-Encoding(br/deflate/gzip/zstd)自动重新压缩,并同步更新 Content-Length。另一种替代方案是把 http-proxy-middleware 放在 bodyParser 之前,这样请求体尚未被消费,无需修复。

拦截并修改响应

使用 responseInterceptor 拦截上游响应(记得设置 selfHandleResponse: true)。

采用 brotli、gzip、deflate 压缩的响应会被自动解压,然后以 buffer 形式返回给你操作。

有了 buffer,响应操作就不限于文本响应(html/css/js 等),图像流式处理同样可行。

注意:responseInterceptor 会禁用目标响应的流式传输(改为整体缓冲)。

示例:

import { createProxyMiddleware, responseInterceptor } from 'http-proxy-middleware';

const proxy = createProxyMiddleware({
  /**
   * 重要:避免 res.end 被自动调用
   **/
  selfHandleResponse: true, // res.end() 将由 responseInterceptor() 内部调用

  /**
   * 拦截响应,把 'Hello' 替换成 'Goodbye'
   **/
  on: {
    proxyRes: responseInterceptor(async (responseBuffer, proxyRes, req, res) => {
      const response = responseBuffer.toString('utf8'); // 把 buffer 转成字符串
      return response.replace('Hello', 'Goodbye'); // 修改响应并返回结果
    }),
  },
});

更多拦截示例可参考 recipes/response-interceptor.md(其中包含图片响应的操作示例)与 examples/response-interceptor/index.js,相关测试见 test/e2e/response-interceptor.spec.ts。

Node.js 17+:localhost 与 IPv6 的 ECONNREFUSED 问题

Node.js 17 起 DNS 解析不再优先 IPv4 而是 IPv4/IPv6 并重:无法保证 localhost 解析为 127.0.0.1——它也可能解析为 ::1(或其他 IP)。

如果目标服务器只监听 IPv4,代理指向 localhost 时一旦解析到 ::1(IPv6)就会连接失败。解决方案:

  • 把 target: "http://localhost" 改为 target: "http://127.0.0.1"(IPv4)。
  • 让目标服务器同时支持 IPv6 连接。
  • 运行 node 时加参数 node index.js --dns-result-order=ipv4first(不推荐)。

额外说明:未指定的 IPv6 主机 http://[::]:port 会被归一化为回环地址 ::1 以访问本地监听器(归一化逻辑见 src/utils/ipv6.ts,在 prepareProxyRequest 中通过 normalizeIPv6LiteralTargets 应用,参考 src/http-proxy-middleware.ts)。

注:有一种叫 "Happy Eyeballs" 的机制,会同时并行连接 IPv4 和 IPv6——Node.js 并不具备,但这也解释了为什么例如 curl 可以连接成功。相关测试见 test/e2e/ipv6.spec.ts 与 test/unit/utils/ipv6.spec.ts。

调试

设置 DEBUG 环境变量即可开启调试日志。

DEBUG=http-proxy-middleware* node server.js

$ http-proxy-middleware proxy created +0ms
$ http-proxy-middleware proxying request to target: 'http://www.example.org' +359ms

调试输出基于 debug 包实现(src/debug.ts),且核心类在代理创建、插件注册、路径重写、服务器升级事件订阅、优雅关闭等关键节点均有 debug 日志埋点(见 src/http-proxy-middleware.ts 内多处 debug(...) 调用),排查问题时非常有价值。

可运行的示例

仓库提供了大量可直接运行体验的示例(examples 目录):

常用配方(Recipes)

仓库的 recipes 目录针对常见使用场景提供了即取即用的配方文档,建议按需查阅:

兼容服务器

http-proxy-middleware 是标准 (req, res, next) 中间件形态,兼容以下服务器(示例见 recipes/servers.md):

  • connect、express、hono、next.js
  • fastify、browser-sync、lite-server、polka
  • grunt-contrib-connect、grunt-browser-sync、gulp-connect、gulp-webserver

其中 Next.js 与 Hono 场景还提供了独立入口:exports 中额外导出了 ./hono 子路径(见 package.json),对应源码为 src/index-hono.ts 与 src/factory-hono.ts,Hono 集成测试见 test/e2e/hono.spec.ts。

结语

http-proxy-middleware 的核心价值在于把"反向代理"压缩成一行配置:createProxyMiddleware({ target, changeOrigin }) 即得到一个可直接挂载的中间件。在此基础上,pathFilter 精确控制代理范围、pathRewrite 改写路径、router 按 host/path 动态选择目标、plugins 与 on 事件深度定制行为、fixRequestBody 与 responseInterceptor 双向修改请求/响应体、ws: true 一行启用 WebSocket 代理——配合 DEBUG 调试与丰富的示例/配方,足以覆盖绝大多数 Node.js 网关与前后端分离场景。项目遵循 MIT 协议开源,完整变更记录见 CHANGELOG.md。

  • 后端
  • API网关

【免费下载链接】http-proxy-middleware

:zap: The one-liner node.js http-proxy (httpxy) middleware for connect, express, next.js and more

项目地址: https://gitcode.com/gh_mirrors/ht/http-proxy-middleware
点击查看 免费下载

创作声明:本文部分内容由AI辅助生成(AIGC),仅供参考

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值