用Java開發代理服務器

時間 2019-11-29

標籤 java 開發代理服務器欄目 Java 简体版

原文原文鏈接

基礎知識

無論以哪一種方式應用代理服務器，其監控HTTP傳輸的過程老是以下：java

步驟一：內部的瀏覽器發送請求給代理服務器。請求的第一行包含了目標URL。
步驟二：代理服務器讀取該URL，並把請求轉發給合適的目標服務器。
步驟三：代理服務器接收來自Internet目標機器的應答，把應答轉發給合適的內部瀏覽器。

例如，假設有一個企業的僱員試圖訪問www.cn.ibm.com網站。若是沒有代理服務器，僱員的瀏覽器打開的Socket通向運行這個網站的Web服務器，從Web服務器返回的數據也直接傳遞給僱員的瀏覽器。若是瀏覽器被配置成使用代理服務器，則請求首先到達代理服務器；隨後，代理服務器從請求的第一行提取目標URL，打開一個通向www.cn.ibm.com的Socket。當www.cn.ibm.com返回應答時，代理服務器把應答轉發給僱員的瀏覽器。瀏覽器

固然，代理服務器並不是只適用於企業環境。做爲一個開發者，擁有一個本身的代理服務器是一件很不錯的事情。例如，咱們能夠用代理服務器來分析瀏覽器和Web服務器的交互過程。測試和解決Web應用中存在的問題時，這種功能是頗有用的。咱們甚至還能夠同時使用多個代理服務器（大多數代理服務器容許多個服務器連接在一塊兒使用）。例如，咱們能夠有一個企業的代理服務器，再加上一個用Java編寫的代理服務器，用來調試應用程序。但應該注意的是，代理服務器鏈上的每個服務器都會對性能產生必定的影響。服務器

回頁首網絡

設計規劃

正如其名字所示，代理服務器只不過是一種特殊的服務器。和大多數服務器同樣，若是要處理多個請求，代理服務器應該使用線程。下面是一個代理服務器的基本規劃：socket

等待來自客戶（Web瀏覽器）的請求。
啓動一個新的線程，以處理客戶鏈接請求。
讀取瀏覽器請求的第一行（該行內容包含了請求的目標URL）。
分析請求的第一行內容，獲得目標服務器的名字和端口。
打開一個通向目標服務器（或下一個代理服務器，如合適的話）的Socket。
把請求的第一行發送到輸出Socket。
把請求的剩餘部分發送到輸出Socket。
把目標Web服務器返回的數據發送給發出請求的瀏覽器。

固然，若是考慮細節的話，狀況會更復雜一些。實際上，這裏主要有兩個問題要考慮：第一，從Socket按行讀取數據最適合進一步處理，但這會產生性能瓶頸；第二，兩個Socket之間的鏈接必需高效。有幾種方法能夠實現這兩個目標，但每一種方法都有各自的代價。例如，若是要在數據進入的時候進行過濾，這些數據最好按行讀取；然而，大多數時候，當數據到達代理服務器時，當即把它轉發出去更適合高效這一要求。另外，數據的發送和接收也可使用多個獨立的線程，但大量地建立和拆除線程也會帶來性能問題。所以，對於每個請求，咱們將用一個線程處理數據的接收和發送，同時在數據到達代理服務器時，儘量快速地把它轉發出去。函數

回頁首工具

實例

在用Java編寫這個代理服務器的過程當中，注意可重用性是很重要的。由於這樣的話，當咱們想要在另外一個工程中以不一樣的方式處理瀏覽器請求時，能夠方便地重用該代理服務器。固然，咱們必須注意靈活性和效率之間的平衡。性能

圖一顯示了本文代理服務器實例（HttpProxy.java）的輸出界面，當瀏覽器訪問http://www-900.ibm.com/cn/時，代理服務器向默認日誌設備（即標準輸出設備屏幕）輸出瀏覽器請求的URL。圖二顯示了SubHttpProxy的輸出。SubHttpProxy是HttpProxy的一個簡單擴展。測試

圖一

圖二

爲了構造代理服務器，我從Thread基類派生出了HttpProxy類（文章正文中出現的代碼是該類的一些片段，完整的代碼請從本文最後下載）。HttpProxy類包含了一些用來定製代理服務器行爲的屬性，參見Listing 1和表一。網站

【Listing 1】
/*************************************
 * 一個基礎的代理服務器類
 *************************************
 */
import java.net.*;
import java.io.*;
public class HttpProxy extends Thread {
    static public int CONNECT_RETRIES=5;
    static public int CONNECT_PAUSE=5;
    static public int TIME-OUT=50;
    static public int BUFSIZ=1024;
    static public boolean logging = false;
    static public OutputStream log=null;
    // 傳入數據用的Socket
    protected Socket socket;
    // 上級代理服務器，可選
    static private String parent=null;
    static private int parentPort=-1;
    static public void setParentProxy(String name, int pport) {
        parent=name;
        parentPort=pport;
    }
    // 在給定Socket上建立一個代理線程。
    public HttpProxy(Socket s) { socket=s; start(); }
    public void writeLog(int c, boolean browser) throws IOException {
        log.write(c);
    }
    public void writeLog(byte[] bytes,int offset,
             int len, boolean browser) throws IOException {
        for (int i=0;i<len;i++) writeLog((int)bytes[offset+i],browser);
    }
    // 默認狀況下，日誌信息輸出到
    // 標準輸出設備，
    // 派生類能夠覆蓋它
    public String processHostName(String url, String host, int port, Socket sock) {
        java.text.DateFormat cal=java.text.DateFormat.getDateTimeInstance();
        System.out.println(cal.format(new java.util.Date()) + " - " +
              url + " " + sock.getInetAddress()+"<BR>");
        return host;
    }

#dbdbdb

表一
變量/方法	說明
CONNECT_RETRIES	在放棄以前嘗試鏈接遠程主機的次數。
CONNECT_PAUSE	在兩次鏈接嘗試之間的暫停時間。
TIME-OUT	等待Socket輸入的等待時間。
BUFSIZ	Socket輸入的緩衝大小。
logging	是否要求代理服務器在日誌中記錄全部已傳輸的數據（true表示「是」）。
log	一個OutputStream對象，默認日誌例程將向該OutputStream對象輸出日誌信息。
setParentProxy	用來把一個代理服務器連接到另外一個代理服務器（須要指定另外一個服務器的名稱和端口）。

當代理服務器鏈接到Web服務器以後，我用一個簡單的循環在兩個Socket之間傳遞數據。這裏可能出現一個問題，即若是沒有可操做的數據，調用read方法可能致使程序阻塞，從而掛起程序。爲防止出現這個問題，我用setSoTimeout方法設置了Socket的超時時間（參見Listing 2）。這樣，若是某個Socket不可用，另外一個仍舊有機會進行處理，我沒必要建立一個新的線程。

【Listing 2】
    // 執行操做的線程
    public void run() {
    String line;
    String host;
    int port=80;
        Socket outbound=null;
    try {
        socket.setSoTimeout(TIMEOUT);
        InputStream is=socket.getInputStream();
        OutputStream os=null;
        try {
        // 獲取請求行的內容
        line="";
        host="";
        int state=0;
        boolean space;
        while (true) {
            int c=is.read();
            if (c==-1) break;
            if (logging) writeLog(c,true);
            space=Character.isWhitespace((char)c); 
            switch (state) {
            case 0:
            if (space) continue; 
                state=1;
            case 1:
            if (space) {
                state=2;
                continue;
            }
            line=line+(char)c;
            break;
            case 2:
            if (space) continue; // 跳過多個空白字符
                  state=3;
            case 3:
            if (space) {
                state=4;
               // 只分析主機名稱部分
                String host0=host;
                int n;
                n=host.indexOf("//");
                if (n!=-1) host=host.substring(n+2);
                n=host.indexOf('/');
                if (n!=-1) host=host.substring(0,n);
                // 分析可能存在的端口號
                n=host.indexOf(":");
                if (n!=-1) { 
                port=Integer.parseInt(host.substring(n+1));
                host=host.substring(0,n);
                }
                host=processHostName(host0,host,port,socket);
                if (parent!=null) {
                host=parent;
                port=parentPort;
                }
                int retry=CONNECT_RETRIES;
                while (retry--!=0) {
                try {
                    outbound=new Socket(host,port);
                    break;
                } catch (Exception e) { }
                // 等待
                Thread.sleep(CONNECT_PAUSE);
                }
                if (outbound==null) break;
                outbound.setSoTimeout(TIMEOUT);
                os=outbound.getOutputStream();
                os.write(line.getBytes());
                os.write(' ');
                os.write(host0.getBytes());
                os.write(' ');
                pipe(is,outbound.getInputStream(),os,socket.getOutputStream());
                break;
            }
            host=host+(char)c;
            break;
            }
        }
        }
        catch (IOException e) { }
    } catch (Exception e) { }
    finally {
            try { socket.close();} catch (Exception e1) {}
            try { outbound.close();} catch (Exception e2) {}
       }
    }

和全部線程對象同樣，HttpProxy類的主要工做在run方法內完成（見Listing 2）。run方法實現了一個簡單的狀態機，從Web瀏覽器每次一個讀取字符，持續這個過程直至有足夠的信息找出目標Web服務器。而後，run打開一個通向該Web服務器的Socket（若是有多個代理服務器被連接在一塊兒，則run方法打開一個通向鏈裏面下一個代理服務器的Socket）。打開Socket以後，run先把部分的請求寫入Socket，而後調用pipe方法。pipe方法直接在兩個Socket之間以最快的速度執行讀寫操做。

若是數據規模很大，另外建立一個線程可能具備更高的效率；然而，當數據規模較小時，建立新線程所須要的開銷會抵消它帶來的好處。

Listing 3顯示了一個很簡單的main方法，能夠用來測試HttpProxy類。大部分的工做由一個靜態的startProxy方法完成（見Listing 4）。這個方法用到了一種特殊的技術，容許一個靜態成員建立HttpProxy類（或HttpProxy類的子類）的實例。它的基本思想是：把一個Class對象傳遞給startProxy類；而後，startProxy方法利用映像API（Reflection API）和getDeclaredConstructor方法肯定該Class對象的哪個構造函數接受一個Socket參數；最後，startProxy方法調用newInstance方法建立該Class對象。

【Listing 3】
// 測試用的簡單main方法
static public void main(String args[]) {
    System.out.println("在端口808啓動代理服務器\n");
    HttpProxy.log=System.out;
    HttpProxy.logging=false;
    HttpProxy.startProxy(808,HttpProxy.class);
  }
}

【Listing 4】
static public void startProxy(int port,Class clobj) {
  ServerSocket ssock;
  Socket sock;
  try {
      ssock=new ServerSocket(port);
      while (true) {
          Class [] sarg = new Class[1];
          Object [] arg= new Object[1];
          sarg[0]=Socket.class;
          try {
              java.lang.reflect.Constructor cons = clobj.getDeclaredConstructor(sarg);
              arg[0]=ssock.accept();
              cons.newInstance(arg); // 建立HttpProxy或其派生類的實例
          } catch (Exception e) { 
              Socket esock = (Socket)arg[0];
              try { esock.close(); } catch (Exception ec) {}
          }
      }
  } catch (IOException e) {
  }
}

利用這種技術，咱們能夠在不建立startProxy方法定製版本的狀況下，擴展HttpProxy類。要獲得給定類的Class對象，只需在正常的名字後面加上.class（若是有某個對象的一個實例，則代之以調用getClass方法）。因爲咱們把Class對象傳遞給了startProxy方法，因此建立HttpProxy的派生類時，就沒必要再特地去修改startProxy。（下載代碼中包含了一個派生獲得的簡單代理服務器）。

回頁首

結束語

利用派生類定製或調整代理服務器的行爲有兩種途徑：修改主機的名字，或者捕獲全部經過代理服務器的數據。processHostName方法容許代理服務器分析和修改主機名字。若是啓用了日誌記錄，代理服務器爲每個經過服務器的字符調用writeLog方法。如何處理這些信息徹底由咱們本身決定――能夠把它寫入日誌文件，能夠把它輸出到控制檯，或進行任何其餘知足咱們要求的處理。writeLog輸出中的一個Boolean標記指示出數據是來自瀏覽器仍是Web主機。

和許多工具同樣，代理服務器自己並不存在好或者壞的問題，關鍵在於如何使用它們。代理服務器可能被用於侵犯隱私，但也能夠阻隔偷窺者和保護網絡。即便代理服務器和瀏覽器不在同一臺機器上，我也樂意把代理服務器當作是一種擴展瀏覽器功能的途徑。例如，在把數據發送給瀏覽器以前，能夠用代理服務器壓縮數據；將來的代理服務器甚至還可能把頁面從一種語言翻譯成另外一種語言……可能性永無止境。