import java.io.*;
import java.net.*;
/**
* 这个类实现了一个简单的单线程的代理服务器
*/
public class SimpleProxyServer {
/** 主函数解析参数并把参数传递给runServer */
public static void main(String[] args) throws IOException {
try {
// 检查参数的个数
if (args.length != 3)
throw new IllegalArgumentException("Wrong number of args.");
// 获得命令行参数: 我们要代理的主机和端口
String host = args[0];
int remoteport = Integer.parseInt(args[1]);
int localport = Integer.parseInt(args[2]);
// 显示开始信息
System.out.println("Starting proxy for " + host + ":" +
remoteport + " on port " + localport);
// 开始运行这个服务器
runServer(host, remoteport, localport); // 永不返回
}
catch (Exception e) {
System.err.println(e);
System.err.println("Usage: java SimpleProxyServer " +
"<host> <remoteport> <localport>");
}
}
/**
* 这个方法运行一个单线程的代理服务器，它在指定的本地端口上
* 代理一个主机上的远程端口。它用不返回。
*/
public static void runServer(String host, int remoteport, int localport)
throws IOException {
// 创建一个ServerSocket来监听连接
ServerSocket ss = new ServerSocket(localport);
// 为客户端到服务器和服务器到客户端创建缓冲区
// 我们指定缓冲区为final，使它能够在下面的匿名类中能够被使用
// 注意在每个方向上交换量上的假定
final byte[] request = new byte[1024];
byte[] reply = new byte[4096];
// 这是一个用不返回的服务器，故进入一个无限循环
while(true) {
// 保持与客户端和与服务器连接的socket的变量
Socket client = null, server = null;
try {
// 等待一个本地端口的连接
client = ss.accept();
// 获取客户流，把他们定义成final使得他们在下面的匿名
// 类中能够被使用
final InputStream from_client = client.getInputStream();
final OutputStream to_client = client.getOutputStream();
// 建立一个与真实服务器的连接
// 如果我们不能连上服务器，发送一个错误给客户端
// 取消连接，等待下次连接
try { server = new Socket(host, remoteport); }
catch (IOException e) {
PrintWriter out = new PrintWriter(to_client);
out.print("Proxy server cannot connect to " + host + ":"+
remoteport + ":\n" + e + "\n");
out.flush();
client.close();
continue;
}
// 获得服务器的流
final InputStream from_server = server.getInputStream();
final OutputStream to_server = server.getOutputStream();
// 创建一个线程读取客户端的请求，把请求传递给服务器，我们不得不
// 使用一个独立的线程，因为请求和响应是异步的
Thread t = new Thread() {
public void run() {
int bytes_read;
try {
while((bytes_read=from_client.read(request))!=-1) {
to_server.write(request, 0, bytes_read);
to_server.flush();
}
}
catch (IOException e) {}
// 客户端关闭了同我们的连接，那么也就关闭了我们与服务器的
// 连接。这将造成主线程中服务器与客户端之间的循环退出
try {to_server.close();} catch (IOException e) {}
}
};
// 开始客户端到服务器请求线程的运行
t.start();
// 同时，在主线程中，读取服务器的响应，并把它们传递给客户端。这将
// 与上面提到的客户端到服务器的请求线程并行执行
int bytes_read;
try {
while((bytes_read = from_server.read(reply)) != -1) {
to_client.write(reply, 0, bytes_read);
to_client.flush();
}
}
catch(IOException e) {}
// 服务器关闭同我们的连接，那么我们关闭与客户端的连接
// 这将使另外一个线程退出
to_client.close();
}
catch (IOException e) { System.err.println(e); }
finally { // 不管发生什么关闭线程
try {
if (server != null) server.close();
if (client != null) client.close();
}
catch(IOException e) {}
}
}
}
}
