实现代理设置proxy

用户在哪些情况下是需要设置网络代理呢？

1. 内网上不了外网，需要连接能上外网的内网电脑做代理，就能上外网；多个电脑共享上外网，就要用代理； 
2.有些网页被封，通过国外的代理就能看到这被封的网站；
3.想隐藏真实IP；

4. 想加快访问网站速度，在网络出现拥挤或故障时，可通过代理服务器访问目的网站。比如A要访问C网站，但A到C网络出现问题，可以通过绕道，假设B是代理服务器，A可通过B， 再由B到C。

我们app的大多数用户情况是第一种.我们参考qq和chrome的插件switchysharp设置代理的方式来设计的界面

我们的项目是基于node-webkit技术进行开发的。

对于浏览器直接发送的请求设置代理可以直接设置chrome.proxy

                 if (proxy.proxyType == 0) {//不使用代理
                     chrome.proxy.settings.set({ 'value': { 'mode': 'direct' } }, function (e) { console.log(e) });
                 } else if (proxy.proxyType == 1) {//使用http代理
                     chrome.proxy.settings.set({ 'value': { 'mode': 'fixed_servers', rules: { singleProxy: { scheme: 'http', host: proxy.host, port: proxy.port }, bypassList: null } } }, function (e) { console.log(e) });
                 } else if (proxy.proxyType == 2) {//使用socks代理，可以支持版本4或者5
                     chrome.proxy.settings.set({ 'value': { 'mode': 'fixed_servers', rules: { singleProxy: { scheme: 'socks' + proxy.ver, host: proxy.host, port: proxy.port }, bypassList: null } } }, function (e) { console.log(e) });
                 } else if (proxy.proxyType == 3) {//使用系统代理
                     chrome.proxy.settings.set({ 'value': { 'mode': 'system' } }, function (e) { console.log(e) });

而程序内部使用nodejs发送的请求需要在发送请求时通过option进行配置，才能走代理网络

          var options = {
                 hostname: Common.Config.addrInfo.openApi,
                 path: '/api/Author/Article/Collected?skip=' + skip + ' & rows=' + this.pageSize,
                 method : "GET";
                 headers: {
                     'Accept' : "application/json",
                     'Authorization': 'Bearer ' + index.userInfo.token
                 }
             };

             var req = require('http').request(HttpUtil.setProxy(options), function (res) {
                 var err = HttpUtil.resStatus(options, res);
                 clearTimeout(timeoutEventId);
                 if (err) {
                     callback(err);
                     return;
                 }
                 var resData = [];
                 res.setEncoding('utf8');
                 res.on('data', function (chunk) {
                     resData.push(chunk);
                 }).on("end", function () {
                     callback(null, resData.join(""));
                 });
             });
             req.on('error', function (e) {
                 clearTimeout(timeoutEventId);
                 callback(HttpUtil.reqStatus(options, e));
                 req.end();
             });
             req.on('timeout', function (e) {
                 clearTimeout(timeoutEventId);
                 callback(HttpUtil.reqStatus(options, e));
             });
             req.end();
         }
     static setProxy(options) {//设置代理信息
             if (this.proxy) {
                 if (this.proxy.proxyType == 1 || (this.proxy.proxyType == 3 && this.proxy.host && this.proxy.sysProxyType == "PROXY")) {
                     options.path = "http://" + options.hostname + options.path;
                     options.hostname = null;
                     options.host = this.proxy.host;
                     options.port = this.proxy.port;
                 } else if (this.proxy.proxyType == 2 || (this.proxy.proxyType == 3 && this.proxy.host && this.proxy.sysProxyType == "SOCKS")) {
                     try {
                         if (!this.SocksProxyAgent)
                             this.SocksProxyAgent = require('socks-proxy-agent');//引用socks代理配置模块
                     } catch (e) {
                         this.SocksProxyAgent = null;
                     }
                     if (this.SocksProxyAgent) {
                         var agent = new this.SocksProxyAgent("socks" + this.proxy.ver + "://" + this.proxy.host + ":" + this.proxy.port);
                         options.agent = agent;
                     }
                 }
             }
             return options;
         }           

但是经过实践证明这个方法解决不了很多网络代理用户请求我们服务器接口失败的问题。

我们又找到了request模块，经过在有问题的电脑上进行测试这个模块是可以访问成功的。

          var options1 = {
                 url: 'http://openapi.axeslide.com/api/TemplateTypes',
                 proxy: "http://10.22.138.21:8080",
                 headers: {
                     'User-Agent': 'request',
                     'Authorization': 'Bearer ' + index.userInfo.token,
                     'Accept' :"application/json"
                 }
             };
             this.request.get(options1, function (error, response, body) {
                 if (!error && response.statusCode == 200) {
                     console.log(response,body,"ok")
                 } else {
                     console.log(response,error, "err")
                 }
             })

但是不管是之前的方式还是现在的request模板，在使用socks代理时，接收的数据量超过一定值时返回就会出现问题，然后把之前的socks-proxy-agent

又换了socks5-http-client做测试解决了该问题。

现在说一下测试工具，fiddler和node搭建的socks代理服务器

fiddler相信对大家来对并不陌生，先打开fiddler options选项，然后配置下代理信息，主要是端口号，这里可以设置是否设置成系统代理，设置之后需要重新启动fiddler，如果浏览器配置成走9999 所有的请求fiddler都会抓取到。

搭建socks代理可以从网上找现成的代码，node搭建的。大家也可以下载 http://files.cnblogs.com/files/fangsmile/socks5.zip ，下载后运行node proxy

下面附一段switchysharp的实现代码：

 ProxyPlugin.setProxy = function (proxyMode, proxyString, proxyExceptions, proxyConfigUrl) {
     if (ProxyPlugin.disabled) return 0;
     var config;
     ProxyPlugin.proxyMode = Settings.setValue('proxyMode', proxyMode);
     ProxyPlugin.proxyServer = Settings.setValue('proxyServer', proxyString);
     ProxyPlugin.proxyExceptions = Settings.setValue('proxyExceptions', proxyExceptions);
     ProxyPlugin.proxyConfigUrl = Settings.setValue('proxyConfigUrl', proxyConfigUrl);
     switch (proxyMode) {
         case 'system':
             config = {mode:"system"};
             break;
         case 'direct':
             config = {mode:"direct"};
             break;
         case 'manual':
             var tmpbypassList = [];
             var proxyExceptionsList = ProxyPlugin.proxyExceptions.split(';');
             var proxyExceptionListLength = proxyExceptionsList.length;
             for (var i = 0; i < proxyExceptionListLength; i++) {
                 tmpbypassList.push(proxyExceptionsList[i].trim())
             }
             proxyExceptionsList = null;
             var profile = ProfileManager.parseProxyString(proxyString);
             if (profile.useSameProxy) {
                 config = {
                     mode:"fixed_servers",
                     rules:{
                         singleProxy:ProxyPlugin._parseProxy(profile.proxyHttp),
                         bypassList:tmpbypassList
                     }
                 };
             }
             else {
                 var socksProxyString;
                 if (profile.proxySocks && !profile.proxyHttp && !profile.proxyFtp && !profile.proxyHttps) {
                     socksProxyString = profile.socksVersion == 4 ? 'socks=' + profile.proxySocks : 'socks5=' + profile.proxySocks;
                     config = {
                         mode:"fixed_servers",
                         rules:{
                             singleProxy:ProxyPlugin._parseProxy(socksProxyString),
                             bypassList:tmpbypassList
                         }
                     }

                 }
                 else {
                     config = {
                         mode:"fixed_servers",
                         rules:{
                             bypassList:tmpbypassList
                         }
                     };
                     if (profile.proxySocks) {
                         socksProxyString = profile.socksVersion == 4 ? 'socks=' + profile.proxySocks : 'socks5=' + profile.proxySocks;
                         config.rules.fallbackProxy = ProxyPlugin._parseProxy(socksProxyString);
                     }
                     if (profile.proxyHttp)
                         config.rules.proxyForHttp = ProxyPlugin._parseProxy(profile.proxyHttp);
                     if (profile.proxyFtp)
                         config.rules.proxyForFtp = ProxyPlugin._parseProxy(profile.proxyFtp);
                     if (profile.proxyHttps)
                         config.rules.proxyForHttps = ProxyPlugin._parseProxy(profile.proxyHttps);
                 }
             }
             tmpbypassList = null;
             break;
         case 'auto':
             if (ProxyPlugin.proxyConfigUrl == memoryPath) {
                 config = {
                     mode:"pac_script",
                     pacScript:{
                         data:Settings.getValue('pacScriptData', '')
                     }
                 };
                 Settings.setValue('pacScriptData', '');
             }
             else {
                 config = {
                     mode:"pac_script",
                     pacScript:{
                         url:ProxyPlugin.proxyConfigUrl
                     }
                 }
             }
             break;
     }
     ProxyPlugin.mute = true;
     ProxyPlugin._proxy.settings.set({'value':config}, function () {
         ProxyPlugin.mute = false;
         if (ProxyPlugin.setProxyCallback != undefined) {
             ProxyPlugin.setProxyCallback();
             ProxyPlugin.setProxyCallback = undefined;
         }
     });
     profile = null;
     config = null;
     return 0;
 };