Node做中转服务器，转发接口

2019年08月16日，建议使用nginx做转发。毕竟nginx更擅长。

转发代码段：

server {
    listen       80;
    server_name   xxx.xxx.cn;
    location  ~* /eureka {
            rewrite /eureka/(.*) /$1 break;
            rewrite /eureka /$1 break;
            proxy_pass http://172.16.49.229:8001;
    }
    location  ~* /admin {
            rewrite /admin/(.*) /$1 break;
            rewrite /admin /$1 break;
            proxy_pass http://172.16.49.229:8001;
    }
    location  ~* /crm {
            rewrite /crm/(.*) /$1 break;
            rewrite /crm /$1 break;
            proxy_pass http://172.16.49.229:8001;
    }
    location  ~* /config-server {
            rewrite /config-server/(.*) /$1 break;
            rewrite /config-server /$1 break;
            proxy_pass http://172.16.49.229:8001;
    }

}

2018年04月11日，转发修改。支持文件下载。

返回值处理代码修改！所有返回值以文件流的方式接收，支持附件下载和普通数据。你的框架要是可以直接访问访问文件服务器，那就直连了，要是像我一样，文件服务器在内网，只有前端服务器开了内网，那你就得和我一样，做文件下载转发，欢迎您，提供更好方案！

  var body = '';
            var req = http.request(opt, function (res) {
                res.setEncoding('binary');  //二进制binary 
                res.on('data', function (data) {
                    body += data;
                }).on('end', function () {
                    response.writeHead(200, res.headers);
                    response.write(body, "binary");
                    response.end();
                });
            }).on('error', function (e) {
                response.end('内部错误，请联系管理员！MSG:' + e);
                console.log("error: " + e.message);
            })

查询各种资料，和整理网上一哥们不完整的接口。做成，可以使用的转发服务！ 

由于项目在做前后端分离，牵扯跨域和夸协议问题，临时抱佛脚，选择用nodejs做中转，我想应该好多人都用它。但是做普通的表单转发没啥问题，当处理附件上传转发时，各种蛋疼，已解决！

1.项目比较特殊，后台拥有两个平台，一个java一个donet，比较鸡肋，具体什么原因就不解释了。

2.刚开始没有转发文件的操作，就做的很简单，用户传过来啥就，拦截到，进行转发，一切都很ok！

3.当遇到文件转发时，就很麻烦。我的思路，将用户上传的文件存到node服务器。使用formidable  。

通过npm安装：

npm install formidable@latest

　　使用它进行文件转存，保存到临时目录得到文件信息。

再通过文件包重组。进行上传。注意此处上传必须遵循w3c上传文件表单标准，具体自己查资料。

其实思路很简单，但是实际操作起来还是挺麻烦，我中间也趟了好多坑，也是自己node不成熟，毕竟只是用来做中转！

  

直接上代码吧：看代码还是清晰： 

server.js,用于启动服务并转发。

var http = require("http");
var url = require("url");
var fs = require('fs');
const querystring = require("querystring");
var path = require('path');
var formidable = require('formidable'),
    os = require('os'),
    util = require('util');

var config = require('./config').types; //

var netServerUrlFlag = require('./config').netServerUrlFlag;
var netServerhost = require('./config').netServerhost;
var netServerport = require('./config').netServerport;

var javaServerUrlFlag = require('./config').javaServerUrlFlag;
var javaServerhost = require('./config').javaServerhost;
var javaServerport = require('./config').javaServerport;

var fileServerUrlFlag = require('./config').fileServerUrlFlag;

var webapp = require('./config').webapp;
var PORT = require('./config').webport;
/**
 * 上传文件
 * @param files     经过formidable处理过的文件
 * @param req        httpRequest对象
 * @param postData    额外提交的数据
 */
function uploadFile(files, req, postData) {
    var boundaryKey = Math.random().toString(16);
    var endData = '
----' + boundaryKey + '--';
    var filesLength = 0, content;

    // 初始数据，把post过来的数据都携带上去
    content = (function (obj) {
        var rslt = [];
        Object.keys(obj).forEach(function (key) {
            arr = ['
----' + boundaryKey + '
'];
            arr.push('Content-Disposition: form-data; name="' + obj[key][0] + '"

');
            arr.push(obj[key][1]);
            rslt.push(arr.join(''));
        });
        return rslt.join('');
    })(postData); 

    // 组装数据
    Object.keys(files).forEach(function (key) {
        if (!files.hasOwnProperty(key)) {
            delete files.key;
            return;
        }
        content += '
----' + boundaryKey + '
' +
            'Content-Type: application/octet-stream
' +
            'Content-Disposition: form-data; name="' + files[key][0] + '"; ' +
            'filename="' + files[key][1].name + '"; 
' +
            'Content-Transfer-Encoding: binary

';
        files[key].contentBinary = new Buffer(content, 'utf-8');;
        filesLength += files[key].contentBinary.length + fs.statSync(files[key][1].path).size;
    });
    req.setHeader('Content-Type', 'multipart/form-data; boundary=--' + boundaryKey);
    req.setHeader('Content-Length', filesLength + Buffer.byteLength(endData));

    // 执行上传
    var allFiles = Object.keys(files);
    var fileNum = allFiles.length;
    var uploadedCount = 0;
    allFiles.forEach(function (key) {
        req.write(files[key].contentBinary);
        console.log("files[key].path:" + files[key][1].path);
        var fileStream = fs.createReadStream(files[key][1].path, { bufferSize: 4 * 1024 });
        fileStream.on('end', function () {
            // 上传成功一个文件之后，把临时文件删了
            fs.unlink(files[key][1].path);
            uploadedCount++;
            if (uploadedCount == fileNum) {
                // 如果已经是最后一个文件，那就正常结束
                req.end(endData);
            }
        });
        fileStream.pipe(req, { end: false });
    });
}
var server = http.createServer(function (request, response) {
    var clientUrl = request.url;
    var url_parts = url.parse(clientUrl); //解析路径
    var pathname = url_parts.pathname;

    var sreq = request;
    var sres = response;
    // .net 转发请求
    if (pathname.match(netServerUrlFlag) != null) {
        var clientUrl2 = clientUrl.replace("/" + netServerUrlFlag, '');
        console.log(".net转发请求......" + clientUrl2);
        var pramsJson = '';
        sreq.on("data", function (data) {
            pramsJson += data;
        }).on("end", function () {
            var contenttype = request.headers['content-type'];
            if (contenttype == undefined || contenttype == null || contenttype == '') {
                var opt = {
                    host: netServerhost, //跨域访问的主机ip
                    port: netServerport,
                    path: clientUrl2,
                    method: request.method,
                    headers: {
                        'Content-Length': Buffer.byteLength(pramsJson)
                    }
                }
            } else {
                var opt = {
                    host: netServerhost, //跨域访问的主机ip
                    port: netServerport,
                    path: clientUrl2,
                    method: request.method,
                    headers: {
                        'Content-Type': request.headers['content-type'],
                        'Content-Length': Buffer.byteLength(pramsJson)
                    }
                }
            }
            console.log('method', opt.method);

            var body = '';
            var req = http.request(opt, function (res) {
                res.on('data', function (data) {
                    body += data;
                }).on('end', function () {
                    response.write(body);
                    response.end();
                });
            }).on('error', function (e) {
                response.end('内部错误，请联系管理员！MSG:' + e);
                console.log("error: " + e.message);
            })
            req.write(pramsJson);
            req.end();
        })

    } else
        // java 转发请求
        if (pathname.match(javaServerUrlFlag) != null) {
            response.setHeader("Content-type", "text/plain;charset=UTF-8");

            var clientUrl2 = clientUrl.replace("/" + javaServerUrlFlag, '');
            console.log(".java转发请求......http://" + javaServerhost + ":" + javaServerport + "" + clientUrl2);
            var prams = '';
            sreq.on("data", function (data) {
                prams += data;
            }).on("end", function () {
                console.log("client pramsJson>>>>>" + prams);
                const postData = prams;
                console.log("client pramsJson>>>>>" + postData);
                var contenttype = request.headers['content-type'];
                if (contenttype == undefined || contenttype == null || contenttype == '') {
                    var opt = {
                        host: javaServerhost, //跨域访问的主机ip
                        port: javaServerport,
                        path: "/hrrp" + clientUrl2,
                        method: request.method,
                        headers: {
                            'Content-Length': Buffer.byteLength(postData)
                        }
                    }
                } else {
                    var opt = {
                        host: javaServerhost, //跨域访问的主机ip
                        port: javaServerport,
                        path: "/hrrp" + clientUrl2,
                        method: request.method,
                        headers: {
                            'Content-Type': request.headers['content-type'],
                            'Content-Length': Buffer.byteLength(postData)
                        }
                    }
                }
                var body = '';

                console.log('method', opt.method);
                var req = http.request(opt, function (res) {
                    //console.log("response: " + res.statusCode);
                    res.on('data', function (data) {
                        body += data;
                    }).on('end', function () {
                        response.write(body);
                        response.end();
                        //console.log("end:>>>>>>>" + body);
                    });
                }).on('error', function (e) {
                    response.end('内部错误，请联系管理员！MSG:' + e);
                    console.log("error: " + e.message);
                })

                req.write(postData);
                req.end();


            })
        } else if (pathname.match(fileServerUrlFlag) != null) {
            //文件拦截保存到本地
            var form = new formidable.IncomingForm(),
                files = [],
                fields = [];
            form.uploadDir = os.tmpdir();
            form.on('field', function (field, value) {
                console.log(field, value);
                fields.push([field, value]);
            }).on('file', function (field, file) {
                console.log(field, file);
                files.push([field, file]);
            }).on('end', function () {
                //
                var clientUrl2 = clientUrl.replace("/" + fileServerUrlFlag, '');
                var opt = {
                    host: netServerhost, //跨域访问的主机ip
                    port: netServerport,
                    path: clientUrl2,
                    method: request.method
                }
                var body = '';
                var req = http.request(opt, function (res) {
                    res.on('data', function (data) {
                        body += data;
                    }).on('end', function () {
                        response.write(body);
                        response.end();
                    });
                }).on('error', function (e) {
                    response.end('内部错误，请联系管理员！MSG:' + e);
                    console.log("error: " + e.message);
                })
                //文件上传
                uploadFile(files, req, fields);
            });
            form.parse(sreq);
        }
        else {
            var realPath = path.join(webapp, pathname); //这里设置自己的文件名称;
            var ext = path.extname(realPath);
            ext = ext ? ext.slice(1) : 'unknown';
            fs.exists(realPath, function (exists) {
                //console.log("file is exists："+exists+" file path: " + realPath + "");
                if (!exists) {
                    response.writeHead(404, {
                        'Content-Type': 'text/plain'
                    });

                    response.write("This request URL " + pathname + " was not found on this server.");
                    response.end();
                } else {
                    fs.readFile(realPath, "binary", function (err, file) {
                        if (err) {
                            response.writeHead(500, {
                                'Content-Type': 'text/plain'
                            });
                            //response.end(err);
                            response.end("内部错误，请联系管理员");
                        } else {
                            var contentType = config[ext] || "text/plain";
                            response.writeHead(200, {
                                'Content-Type': contentType
                            });
                            response.write(file, "binary");
                            response.end();
                        }
                    });
                }
            });

        }
});
server.listen(PORT);
console.log("Server runing at port: " + PORT + ".");

config.js，用于配置。

exports.types = {
  "css": "text/css",
  "gif": "image/gif",
  "html": "text/html",
  "htm": "text/html",
  "ico": "image/x-icon",
  "jpeg": "image/jpeg",
  "jpg": "image/jpeg",
  "js": "text/javascript",
  "json": "application/json",
  "pdf": "application/pdf",
  "png": "image/png",
  "svg": "image/svg+xml",
  "swf": "application/x-shockwave-flash",
  "tiff": "image/tiff",
  "txt": "text/plain",
  "wav": "audio/x-wav",
  "wma": "audio/x-ms-wma",
  "wmv": "video/x-ms-wmv",
  "xml": "text/xml"
};

exports.netServerUrlFlag = "NETSERVER";
exports.netServerhost = "";
exports.netServerport = "";

exports.javaServerUrlFlag = "JAVASERVER";
exports.javaServerhost = ""; //转发的地址
exports.javaServerport = "";//转发的端口

exports.fileServerUrlFlag="FileUpload";
exports.webapp = "public";//项目目录

exports.webport = "82";  //项目启动端口