浅浅的说http-proxy-middleware

var proxy = httpProxy.createProxyServer({})
logger.info('[HPM] Proxy created:', config.context, ' -> ', proxyOptions.target)

var pathRewriter = PathRewriter.create(proxyOptions.pathRewrite) // returns undefined when "pathRewrite" is not provided

// attach handler to http-proxy events
handlers.init(proxy, proxyOptions)

// log errors for debug purpose
proxy.on('error', logError)

// https://github.com/chimurai/http-proxy-middleware/issues/19
// expose function to upgrade externally
middleware.upgrade = wsUpgradeDebounced

return middleware

function middleware(req, res, next) {
    if (shouldProxy(config.context, req)) {
        var activeProxyOptions = prepareProxyRequest(req)
        proxy.web(req, res, activeProxyOptions)
    } else {
        next()
    }

    if (proxyOptions.ws === true) {
        // use initial request to access the server object to subscribe to http upgrade event
        catchUpgradeRequest(req.connection.server)
    }
}

function ProxyServer(options) {
    EE3.call(this);

    options = options || {};
    options.prependPath = options.prependPath === false ? false : true;

    this.web = this.proxyRequest = createRightProxy('web')(options);
    this.ws = this.proxyWebsocketRequest = createRightProxy('ws')(options);
    this.options = options;

    this.webPasses = Object.keys(web).map(function (pass) {
        return web[pass];
    });

    this.wsPasses = Object.keys(ws).map(function (pass) {
        return ws[pass];
    });

    this.on('error', this.onError, this);

}

function createRightProxy(type) {

    return function (options) {
        return function (req, res /*, [head], [opts] */) {
            var passes = (type === 'ws') ? this.wsPasses : this.webPasses,
                args = [].slice.call(arguments),
                cntr = args.length - 1,
                head, cbl;

            /* optional args parse begin */
            if (typeof args[cntr] === 'function') {
                cbl = args[cntr];

                cntr--;
            }

            var requestOptions = options;
            if (
                !(args[cntr] instanceof Buffer) &&
                args[cntr] !== res
            ) {
                //Copy global options
                requestOptions = extend({}, options);
                //Overwrite with request options
                extend(requestOptions, args[cntr]);

                cntr--;
            }

            if (args[cntr] instanceof Buffer) {
                head = args[cntr];
            }

            /* optional args parse end */

            ['target', 'forward'].forEach(function (e) {
                if (typeof requestOptions[e] === 'string')
                    requestOptions[e] = parse_url(requestOptions[e]);
            });

            if (!requestOptions.target && !requestOptions.forward) {
                return this.emit('error', new Error('Must provide a proper URL as target'));
            }

            for (var i = 0; i < passes.length; i++) {
                /**
                 * Call of passes functions
                 * pass(req, res, options, head)
                 *
                 * In WebSockets case the `res` variable
                 * refer to the connection socket
                 * pass(req, socket, options, head)
                 */
                if (passes[i](req, res, requestOptions, head, this, cbl)) { // passes can return a truthy value to halt the loop
                    break;
                }
            }
        };
    };
}

stream: function stream(req, res, options, _, server, clb) {

     // And we begin!
     server.emit('start', req, res, options.target || options.forward);

     var agents = options.followRedirects ? followRedirects : nativeAgents;
     var http = agents.http;
     var https = agents.https;

     if (options.forward) {
         // If forward enable, so just pipe the request
         var forwardReq = (options.forward.protocol === 'https:' ? https : http).request(
             common.setupOutgoing(options.ssl || {}, options, req, 'forward')
         );

         // error handler (e.g. ECONNRESET, ECONNREFUSED)
         // Handle errors on incoming request as well as it makes sense to
         var forwardError = createErrorHandler(forwardReq, options.forward);
         req.on('error', forwardError);
         forwardReq.on('error', forwardError);

         (options.buffer || req).pipe(forwardReq);
         if (!options.target) { return res.end(); }
     }

     // Request initalization
     var proxyReq = (options.target.protocol === 'https:' ? https : http).request(
         common.setupOutgoing(options.ssl || {}, options, req)
     );

     // Enable developers to modify the proxyReq before headers are sent
     proxyReq.on('socket', function (socket) {
         if (server) { server.emit('proxyReq', proxyReq, req, res, options); }
     });

     // allow outgoing socket to timeout so that we could
     // show an error page at the initial request
     if (options.proxyTimeout) {
         proxyReq.setTimeout(options.proxyTimeout, function () {
             proxyReq.abort();
         });
     }

     // Ensure we abort proxy if request is aborted
     req.on('aborted', function () {
         proxyReq.abort();
     });

     // handle errors in proxy and incoming request, just like for forward proxy
     var proxyError = createErrorHandler(proxyReq, options.target);
     req.on('error', proxyError);
     proxyReq.on('error', proxyError);

     function createErrorHandler(proxyReq, url) {
         return function proxyError(err) {
             if (req.socket.destroyed && err.code === 'ECONNRESET') {
                 server.emit('econnreset', err, req, res, url);
                 return proxyReq.abort();
             }

             if (clb) {
                 clb(err, req, res, url);
             } else {
                 server.emit('error', err, req, res, url);
             }
         }
     }

     (options.buffer || req).pipe(proxyReq);

     proxyReq.on('response', function (proxyRes) {
         if (server) { server.emit('proxyRes', proxyRes, req, res); }

         if (!res.headersSent && !options.selfHandleResponse) {
             for (var i = 0; i < web_o.length; i++) {
                 if (web_o[i](req, res, proxyRes, options)) { break; }
             }
         }

         if (!res.finished) {
             // Allow us to listen when the proxy has completed
             proxyRes.on('end', function () {
                 if (server) server.emit('end', req, res, proxyRes);
             });
             // We pipe to the response unless its expected to be handled by the user
             if (!options.selfHandleResponse) proxyRes.pipe(res);
         } else {
             if (server) server.emit('end', req, res, proxyRes);
         }
     });
 }