网络编程使用代理服务器

接下来都是我对HTTP代理服务器的理解。

HTTP代理服务（proxy server） 器就是客户端也是服务端，是一个事务处理的中间人，就像下图所展示的一样，

图片来源于《HTTP权威指南》

代理服务器的作用有很多，例如：儿童过滤器、文档访问控制、安全防火墙、web缓存等等。

以下，我用最基础的代码写一个简易的HTTP代理服务器，最后还有相关的解说，有助于更容易理解HTTP代理服务器的机制。

package testproxy;
import java.lang.reflect.Constructor;
import java.net.*;
import java.io.*;
public class TextHttpProxy extends Thread {

    //操作实现代理服务器的类
    static public int RETRIES = 5;
    //在放弃之前尝试连接远程主机的次数
    static public int PAUSE = 5;
    //在两次连接尝试之间的暂停时间
    static public int TIMEOUT = 50;
    //等待Socket输入的等待时间
    static public int BUFSIZ = 1024;
    //输入的缓冲大小
    static public boolean logging = false;
    //是否要求代理服务器在日志中记录所有已传输的数据
    static public OutputStream log = null;
    //默认日志例程将向该OutputStream对象输出日志信息
    protected Socket socket;
    // 传入数据用的Socket
    static private String parent = null;
    //上级代理服务器
    static private int parentPort = -1;
    //  用来把一个代理服务器链接到另一个代理服务器（需要指定另一个服务器的名称和端口）。  
    static public void setParentProxy(String name, int port) {

        parent = name;
        parentPort = port;

    }
    public TextHttpProxy(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 printLog(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() + "\n");
        return host;

    }
    public void run() {

        // 执行操作的线程
        String line;
        String host;
        int port = 80;
        //默认端口为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 = printLog(host0, host, port, socket);
                            //获得网站域名

                            if (parent != null) {

                                host = parent;
                                port = parentPort;

                            }
                            int retry = RETRIES;
                            while (retry-- != 0) {

                                try {

                                    outbound = new Socket(host, port);
                                    //创建连接对象，通向目标服务器
                                    break;

                                } catch (Exception e) {

                                    System.out.println("无法创建连接："+e.getMessage());

                                }
                                Thread.sleep(PAUSE);
                                //设置线程等待

                            }
                            if (outbound == null)
                                break;
                            outbound.setSoTimeout(TIMEOUT);
                            //设置超时时间，防止read方法导致的组赛
                            os = outbound.getOutputStream();
                            //获得输出流对象
                            os.write(line.getBytes());
                            //将信息写入流
                            os.write(' ');
                            os.write(host0.getBytes());
                            //将信息写入流
                            os.write(' ');
                            writeInfo(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) {

            }
        }
    }
    void writeInfo(InputStream is0, InputStream is1, OutputStream os0,
            OutputStream os1) throws IOException {

        //读取流中信息写入日志
        try {

            int ir;
            byte bytes[] = new byte[BUFSIZ];
            //创建字节数组，大小：1024
            //也是定影socket缓冲区的大小
            while (true) {

                try {

                    if ((ir = is0.read(bytes)) > 0) {

                        //判断读取输入流的信息
                        os0.write(bytes, 0, ir);
                        //将读取的数据写入输出流对象中

                        if (logging)
                            writeLog(bytes, 0, ir, true);
                        //写入日志

                    } else if (ir < 0)
                        //读取完毕
                        break;
                } catch (InterruptedIOException e) {

                    //捕获中断IO流异常

                }
                try {

                    if ((ir = is1.read(bytes)) > 0) {

                        //判断读取输入流的信息
                        os1.write(bytes, 0, ir);
                        //将读取的数据写入输出流对象中
                        if (logging)
                            writeLog(bytes, 0, ir, false);
                        //写入日志

                    } else if (ir < 0)
                        //读取完毕
                        break;

                } catch (InterruptedIOException e) {

                    //捕获中断IO流异常

                }
            }
        } catch (Exception e0) {

            //捕获异常
        }
    }


    static public void proxyStart(int port, Class<TextHttpProxy> clobj) {

        ServerSocket serverSocket;
        try {

            serverSocket = new ServerSocket(port);
            //根据端口创建服务器端Socket对象
            while (true) {

                Class[] objClass = new Class[1];
                //创建类数组，大小为1
                Object[] obj = new Object[1];
                //创建对象数组，大小为1
                objClass[0] = Socket.class;
                //添加Socket类
                try {

                    Constructor cons = clobj.getDeclaredConstructor(objClass);
                    //创建代理服务器实例
                    obj[0] = serverSocket.accept();
                    //挂起等待客户的请求
                    cons.newInstance(obj); 
                    // 创建TextHttpProxy或其派生类的实例  创建传入类

                } catch (Exception e) {

                    Socket socket = (Socket) obj[0];
                    //对象强制转换
                    try {

                        socket.close();
                        //释放资源

                    } catch (Exception ec) {

                    }

                }

            }

        } catch (IOException e) {

        }
    }
    static public void main(String args[]) {

        System.out.println("HTTP代理服务器已经成功启动！");
        TextHttpProxy.log = System.out;
        //日志信息输出到控制台
        TextHttpProxy.logging = false;
        TextHttpProxy.proxyStart(9080, TextHttpProxy.class);

        //调用方法
    }

}

代码解说：

开启一个服务器Socket 监听指定端口的请求，同时，代理服务器挂起等待客户端的请求。服务器的Socket监听到连接请求时，则开启一个新的线程处理这个连接请求，服务器的Socket 再次进入监听状态。
在连接线程时，代理服务器接受来自客户端的请求，并执行操作的线程，设置超时时间，解析客户端Host头域里面的值，获取目标web服务器地址，分析可能存在的端口号，建立socket将请求发送到远程服务器，然后将响应报文转发回原socket。最后把 socket 关闭，线程销毁。

写一个简单的main方法来进行代理服务器测试，并将日志信息显示在控制台。

代码解说图：

以下图片是测试效果：

使用firefox浏览器，手动设置代理服务器

运行代码，开启代理服务器，输入HTTP协议的URI,如图

能进入这个网站，说明你的代理成功了！

在控制台会输出以下信息

在这个实现HTTP代理服务器的过程中，socket 是非常重要的，它也叫做套接字。如下是它的作用：

socket （套接字）之间的连接过程分为三个步骤：服务器监听，客户端请求，连接确认。

服务器监听：服务器端套接字并不定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态，等待客户端的连接请求。

客户端请求：指客户端的套接字提出连接请求，要连接的目标是服务器端的套接字。为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器端套接字的地址和端口号，然后就向服务器端套接字提出连接请求。

连接确认：当服务器端套接字监听到或者说接收到客户端套接字的连接请求时，就响应客户端套接字的请求，建立一个新的线程，把服务器端套接字的描述发给客户端，一旦客户端确认了此描述，双方就正式建立连接。而服务器端套接字继续处于监听状态，继续接收其他客户端套接字的连接请求。

如果不太懂HTTP和socket之间的联系，那就用传说中的比喻来说说：HTTP是轿车，提供了封装或者显示数据的具体形式；Socket是发动机，提供了网络通信的能力。

如果以后懂得更多，会及时补充~