计算机网络--http代理server的设计与实现

一、Socket编程的client和服务端的主要步骤：

Java Socket编程：对于http传输协议

client：

1、创建新的socket，绑定serverhost和port号

2、Socket创建成功后获得对应的输出流

3、将请求报文通过输出流传到server，记得flush()刷新缓存

4、创建该socket所相应的输入流，获取server的相应报文

服务端：

1、通过建立对应port的socket实现监听某port的socket请求

2、当有别的socket请求连接就開始监听socket的信息，接收到请求报文

3、依据对请求报文的解析，得到请求者的url、port还有请求信息

4、将响应信息还有必要的头部连接形成响应报文。通过socket的输出流返回给请求client

二、HTTP代理server的基本原理：

代理server，即作为真实server的一个代理端。client的请求信息不是发送的真实请求的server而是发送的代理server，此时代理server是作为一个server。之后代理server通过解析client的请求信息，再向真实server发送请求报文，获得请求的信息。此时代理server是作为一个client。

使用代理server的优点是：

1、在请求client和真实server之间加入了一层，这样就可控的对于请求的响应报文做一些限制或者是改变。比如站点过滤、钓鱼站点等使得响应到client的信息是代理server处理过的。

2、还有就是请求报文先发送到代理server。这样代理server能够设立缓存，通过对请求报文解析后代理server能够通过查找本地缓存。假设有缓存好的，而且通过向server发送是否更新的信息后得到没有改动后就能够直接从代理server将响应报文返回给client，这样降低了服务端的负载，降低了流量。

三、HTTP代理server的程序流程图：

 

 

中间代理server能够设定对请求报文和响应报文做一些改动

 

四、实现HTTP代理server的关键技术及解决方式

1、关键技术：socket编程发送和接受报文

 因为http的请求和响应报文都有特定的格式，所以一旦对于报文的格式理解错误就不能获得正确的响应，比如：对于请求报文每一行须要换行符，可是在编程的时候须要清楚理解换行符和回车符，假设在写请求报文时单单以\n作为换行组成的报文将得不到server的响应会产生400 bad request错误。

解决方式：每一行换行须要以回车符和换行符即\r \n 两个一起。这样才干得到正确的报文。在读取响应报文时也要注意会有两个符号作为一行的换行，所以在读取到\r时就表明一行已经读取完成。并且下一行之前另一个\n须要清除

2、关键技术：对于client、代理server、真正server之间的响应线程之间的正确顺序的组织；

解决方式：使用线程组织各部分之间的调度关系。代理server处于一直监听状态。当和client交互时处于server的角色，当和server交互时处于client的角色。

3、关键技术：对于请求报文信息的解析，包含正式请求的server的url、port号、host等信息的正确获取

解决方式：按行提取信息，使用字符串处理函数提取实用的信息

4、关键技术：使用缓存的代理server，须要做到保存请求报文对应的响应报文。顺序不能有差错并且信息不能有缺漏

解决方式：使用日志，在每接受一次请求的时候。将请求的完整url保存到日志中，之后一旦得到对应信息直接保存在url下方，每次通过匹配url得知其下方的响应是否是所需的。这样方便查找和改动

 

五、HTTP代理server的实验验证过程以及实验结果

1、基本功能：代理上网

 

 

2、扩展功能：屏蔽站点

 

 

 

3、扩展功能：钓鱼站点

选择搜狗可是进入的是淘宝网

 

4、扩展功能：带有缓存处理

每一次都会在日志中找是否已有对应的缓存，已有信息则向server发送时间确认报文，后决定是否使用缓存中信息

 

 

六、HTTP代理server源码（带有具体凝视）

package test;

import java.io.*;
import java.net.*;
import java.util.*;

public class MyHttpProxy extends Thread {
	public static int CONNECT_RETRIES = 5; // 尝试与目标主机连接次数
	public static int CONNECT_PAUSE = 5; // 每次建立连接的间隔时间
	public static int TIMEOUT = 8000; // 每次尝试连接的最大时间
	public static int BUFSIZ = 1024; // 缓冲区最大字节数
	public static boolean logging = false; // 是否记录日志
	public static OutputStream log_S = null; // 日志输出流
	public static OutputStream log_C = null; // 日志输出流
	public static OutputStream log_D = null; // 响应报文日志
	public static int count = -1;
	public static List<String> requestInfo = new ArrayList<String>();
	public static List<String> cacheInfo;
	Socket ssocket = null;
	// cis为client输入流。sis为目标主机输入流
	InputStream cis = null, sis = null;
	BufferedReader cbr = null, sbr = null; // 转化为字符流读取便于比較
	// cos为client输出流。sos为目标主机输出流
	OutputStream cos = null, sos = null;
	PrintWriter cpw = null, spw = null;// 转化为字符流
	String buffer = ""; // 读取请求头
	String URL = ""; // 读取请求URL
	String host = ""; // 读取目标主机host
	int port = 80; // 默认端口80
	String findUrl = "";//在缓存中查找的url
	// 与client相连的Socket
	protected Socket csocket;

	public MyHttpProxy(Socket cs) {
		try {
			csocket = cs;
			cis = csocket.getInputStream(); // 代理server作为server接受client的请求
			cbr = new BufferedReader(new InputStreamReader(cis));
			cos = csocket.getOutputStream(); // 代理server作为server向client发出响应
			cpw = new PrintWriter(cos);
			start();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void writeLog(int c, int browser) throws IOException {
		if (browser == 1)
			log_C.write((char) c);
		else if (browser == 2)
			log_S.write((char) c);
		else
			log_D.write((char) c);
	}

	public void writeLog(byte[] bytes, int offset, int len, int browser)
			throws IOException {
		for (int i = 0; i < len; i++)
			writeLog((int) bytes[offset + i], browser);
	}

	public void run() {  
			try { 
				csocket.setSoTimeout(TIMEOUT);
				System.out.println("到了读取第一行");
				buffer = cbr.readLine(); // 获取首部行
				System.out.println("buffer:" + buffer);

				URL = getRequestURL(buffer);
				System.out.println(URL);
				if(URL.equals("http://www.sogou.com/")){
					URL = "http://www.taobao.com/";
					buffer = "GET "+URL+" HTTP/1.1"; 
					requestInfo.add("Accept: text/html, application/xhtml+xml, */*"); 
					requestInfo.add("Accept-Language: zh-Hans-CN,zh-Hans;q=0.8,en-US;q=0.5,en;q=0.3"); 
					requestInfo.add("User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.2; WOW64; Trident/6.0)");
					requestInfo.add("Accept-Encoding: gzip, deflate");
					requestInfo.add("Proxy-Connection: Keep-Alive");
					requestInfo.add("DNT: 1");
					requestInfo.add("Host: www.taobao.com");
					requestInfo.add("Cookie: thw=cn; isg=0BC4B5EFD7C7FCFEB73317770EA7F3F5; l=AeVoHE44ZTsle7DjpW8fBSV7pbSl-2U7; cna=GCHeDZQAVwkCAdvZ9Apwg8rH; t=1a1386bec550ab78d1aaf5ad5b90e044; mt=ci%3D-1_0; _med=dw:1366&dh:768&pw:1366&ph:768&ist:0");
				}
				else if(URL.equals("http://www.qq.com/")) {
					URL = "";
				}
				int n;
				// 抽取host
				n = URL.indexOf("//");
				if (n != -1)
					host = URL.substring(n + 2); // www.baidu.com/
				n = host.indexOf('/');
				if (n != -1)
					host = host.substring(0, n);// www.baidu.com
				n = URL.indexOf('?
');
				if(n != -1)
					findUrl = URL.substring(0,n);
				else findUrl = URL;

				// 分析可能存在的端口号
				n = host.indexOf(':');
				if (n != -1) {
					port = Integer.parseInt(host.substring(n + 1));
					host = host.substring(0, n);
				}
				int retry = CONNECT_RETRIES;
				while (retry-- != 0 && !host.equals("")) {
					try {
						System.out.println("端口号：" + port + "主机：" + host);
						System.out.println("第一行是 " + retry + ":" + buffer);
						ssocket = new Socket(host, port); // 尝试建立与目标主机的连接
						break;
					} catch (Exception e) {
						e.printStackTrace();
					}
					// 等待
					Thread.sleep(CONNECT_PAUSE);
				}
				if (ssocket != null) {
					ssocket.setSoTimeout(TIMEOUT);
					sis = ssocket.getInputStream(); // 代理server作为client接受响应
					sbr = new BufferedReader(new InputStreamReader(sis));
					sos = ssocket.getOutputStream(); // 代理server作为client发出请求
					spw = new PrintWriter(sos);
					
					String modifTime = findCache(findUrl);// 在缓存中寻找是否之前已经缓存过这个url的信息
					System.out.println("上一次改动的时间为：" + modifTime);//
					writeLog(buffer.getBytes(), 0, buffer.length(), 1);
					writeLog(buffer.getBytes(), 0, buffer.length(), 3);
					writeLog("\r\n".getBytes(), 0, 2, 3);
					// 之前没有缓存
					if (modifTime == null) {
						while (!buffer.equals("")) {
							buffer += "\r\n"; 
							if(buffer.contains("www.taobao.com")) { //屏蔽人人网，假设是淘宝就发送淘宝的报文
								int k = 0;
								while(requestInfo.size() - k > 0) {
									spw.write(buffer);
									buffer = requestInfo.get(k++);
									buffer += "\r\n";
								}
								break;
							}
							else{ 
								spw.write(buffer); 
							writeLog(buffer.getBytes(), 0, buffer.length(), 1);
							System.out.print("向server发送请求："+buffer);
							buffer = cbr.readLine();
							}
						}
						spw.write("\r\n");
						writeLog("\r\n".getBytes(), 0, 2, 1);
						spw.flush();
						// 读取server的响应信息
						int length;
						byte bytes[] = new byte[BUFSIZ];
						while (true) {
							try {
								if ((length = sis.read(bytes)) > 0) { // 读取client的请求转给server
									cos.write(bytes, 0, length);
									if (logging) {
										writeLog(bytes, 0, length, 1);
										writeLog(bytes,0,length,3);
									}
								} else if (length < 0)
									break;
							} catch (SocketTimeoutException e) {
							} catch (InterruptedIOException e) {
								System.out.println("\nRequest Exception:");
								e.printStackTrace();
							}
						} 
						if(count == 0) {
							System.out.println(cbr.readLine());
						}
						cpw.write("\r\n");
						writeLog("\r\n".getBytes(), 0, 2, 3);
						writeLog("\r\n".getBytes(), 0, 2, 2);
						cpw.flush();
					} else {
						buffer += "\r\n";
						spw.write(buffer);
						System.out.print("向server发送确认改动时间请求:"+buffer);
						String str1 = "Host: " + host + "\r\n";
						spw.write(str1);
						String str = "If-modified-since: " + modifTime
								+ "\r\n";
						spw.write(str);
						spw.write("\r\n");
						spw.flush();
						System.out.print(str1);
						System.out.print(str);

						String info = sbr.readLine();
						System.out.println("server发回的信息是："+info);
						if (info.contains("Not Modified")) {
							int j = 0;
							System.out.println("使用缓存中的数据");
							while (j < cacheInfo.size()) {
								info = cacheInfo.get(j++);
								info += "\r\n";
								System.out.print(info);
								cpw.write(info);
							}
							cpw.write("\r\n");
							cpw.flush();
						} else {
							System.out.println("有更新，使用新的数据");
							while (!info.equals("")) {
								info += "\r\n";
								System.out.print("新的数据是：" + info);
								cpw.write(info);
								info = sbr.readLine();
							}
							cpw.write("\r\n");
							cpw.flush();
						}
					}
				}
			} catch (Exception e) {
				e.printStackTrace();
			} 
	}

	public String getRequestURL(String buffer) {
		String[] tokens = buffer.split(" ");
		String URL = "";
		if (tokens[0].equals("GET"))
			for (int index = 0; index < tokens.length; index++) {
				if (tokens[index].startsWith("http://")) {
					URL = tokens[index];
					break;
				}
			}
		return URL;
	}

	public void pipe(InputStream cis, InputStream sis, OutputStream sos,
			OutputStream cos) {
		try {
			int length;
			byte bytes[] = new byte[BUFSIZ];
			while (true) {
				try {
					if ((length = cis.read(bytes)) > 0) { // 读取client的请求转给server
						sos.write(bytes, 0, length);
						if (logging)
							writeLog(bytes, 0, length, 1);
					} else if (length < 0)
						break;
				} catch (SocketTimeoutException e) {
				} catch (InterruptedIOException e) {
					System.out.println("\nRequest Exception:");
					e.printStackTrace();
				}
				try {
					if ((length = sis.read(bytes)) > 0) {// 接受server的响应回传给请求的client
						cos.write(bytes, 0, length); // 由于是按字节读取，所以将回车和换行符也传递过去了
						if (logging) {
							writeLog(bytes, 0, length, 1);
							writeLog(bytes, 0, length, 3);
						}
					}
				} catch (SocketTimeoutException e) {
				} catch (InterruptedIOException e) {
					System.out.println("\nResponse Exception:");
					e.printStackTrace();
				}
			}
		} catch (Exception e0) {
			System.out.println("Pipe异常: " + e0);
		}
	}

	public static void startProxy(int port, Class clobj) {
		try {
			ServerSocket 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();
					System.out.println("启动线程："+count++);
					cons.newInstance(arg); // 创建HttpProxy或其派生类的实例
				} catch (Exception e) {
					Socket esock = (Socket) arg[0];
					try {
						esock.close();
					} catch (Exception ec) {
					}
				}
			}
		} catch (IOException e) {
			System.out.println("\nStartProxy Exception:");
			e.printStackTrace();
		}
	}

	// 測试用的简单main方法
	static public void main(String args[]) throws FileNotFoundException {
		System.out.println("在端口8888启动代理server\n");
		OutputStream file_S = new FileOutputStream(new File("log_s.txt"));
		OutputStream file_C = new FileOutputStream(new File("log_c.txt"));
		OutputStream file_D = new FileOutputStream("log_d.txt",true);
		MyHttpProxy.log_S = file_S;
		MyHttpProxy.log_C = file_C;
		MyHttpProxy.log_D = file_D; // 直接存储相关URl相应的响应报文
		MyHttpProxy.logging = true;
		MyHttpProxy.startProxy(8888, MyHttpProxy.class);
	}

	public String findCache(String head) {
		cacheInfo = new ArrayList<String>();
		String resul = null;
		int count = 0;
		try {
			// 直接在存有url和相应信息的文件里查找
			InputStream file_D = new FileInputStream("log_d.txt");
			String info = "";
			while (true) {
				int c = file_D.read();
				if (c == -1)
					break; // -1为结尾标志
				if (c == '\r') {
					file_D.read();
					break;// 读入每一行数据
				}
				if (c == '\n')
					break;
				info = info + (char) c;
			}
			System.out.println("第一次得到：" + info);
			System.out.println("要找的是：" + head);
			int m = 0;
			while ((m = file_D.read()) != -1 && info!=null) {
				//System.out.println("在寻找："+info);
				// 找到同样的，那么它以下的就是响应信息。找上次改动的时间
				if (info.contains(head)) {
					String info1;
					do {
						System.out.println("找到同样的了：" + info);
						info1 = "";
						if(m!='\r' && m != '\n')
							info1 += (char) m;
						while (true) { 
							m = file_D.read();
							if (m == -1)
								break;
							if (m == '\r') {
								file_D.read(); 
								break;
							}
							if (m == '\n') { 
								break; 
							}
							info1 += (char) m;
						}
						System.out.println("info1是："+info1);
						if (info1.contains("Last-Modified:")) {
							resul = info1.substring(16); 
						} 
						cacheInfo.add(info1);
						if(info1.equals("")){ 
							System.out.print("我是空");
							return resul;
						} 
					} while (!info1.equals("") && info1 != null && m != -1);
				}
				info = "";
				while (true) { 
					if (m == -1)
						break;
					if (m == '\r') {
						file_D.read();
						break;
					}
					if (m == '\n')
						break;
					info += (char) m;
					m = file_D.read();
				}
			}
		} catch (FileNotFoundException e) { 
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}

		return resul;
	}

}