實現代理設置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;
};