http代理服务器实现（web cache）

末蓝、 2022-06-01 07:56 167阅读 0赞

> 关键词：**web cache 代理服务器 计网 计算机网络 socket http**

这个项目是计算机网络的课程项目之一，要求使用socket编程实现http代理服务器，能够同时服务两个以上客户端同时访问，允许用户自行设置工作区。而我在这里使用的是比较熟悉的Java实现。  
**如果同学们有幸搜到了这篇文章，请有限制的借鉴，毕竟课程项目的初衷就是为了让同学们在时间中巩固知识，而不是交差拿高分。**

代理服务器的机制是这样子的：它既可以作为服务器，响应来自浏览器客户端的请求，发送网页文件给浏览器客户端，同时，它也可以作为客户端，向网络中的web server发送请求来获取最新的信息。当它作为一个局域网的代理服务器时，如果它的所有缓存都为空，则局域网中所有连接它的主机的DNS请求，HTTP请求都要通过它发往外网中的DNS服务器和web服务器，它获取响应之后再进行缓存并发送回局域网中的客户端。  
它的具体实现思路如下：  
当监听到客户端发送数据报的socket后，代理服务器将提取数据报的首行，获取请求，读取缓存判断之前是否已经缓存该请求，若无，将此请求写入缓存文件。  
从请求中提取主机名和端口，与服务器新建一个socket进行会话。检查本地缓存中是否有之前的响应数据，若有，寻找其中的Last-Modified:字段，并生成一个condition GET 请求发送给服务器，如果服务器返回304 Not Modified，就将相应的本地缓存发送至浏览器，如果没有缓存或者有更新，则将新的请求转发给浏览器，并将最新的缓存写入本地缓存中。  
本地缓存的记录格式是：请求首行+响应内容。  
*注意：本程序会过滤掉无法访问的google网站和CONNECT请求*  
本程序一共由两个.java文件实现

> HttpProxy.java

import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.Scanner;
    
    public class HttpProxy {
        public static String cachePath="";
        public static OutputStream writeCache;
        public static int TIMEOUT=5000;//response time out upper bound
        public static int RETRIEVE=5;//retry connection 5 times
        public static int CONNECT_PAUSE=5000;//waiting for connection
        public static void main(String[] args) throws IOException {
            ServerSocket serverSocket;
            Socket currsoket=null;
                /** users need to setup work space */
    
                System.out.println("==============请输入缓存的存储目录，输入 d 则设置为默认目录（程序同一目录下）=================");
                Scanner scanner=new Scanner(System.in);
                cachePath=scanner.nextLine();
                if(cachePath.equals("d")){
                    cachePath="defaul_cache.txt";
                }
                /** 初始化缓存写对象 */
                writeCache=new FileOutputStream(cachePath,true);
                System.out.println("=================================== 工作目录设置完毕====================================");
    
            try {
                //设置serversocket，绑定端口8888
                serverSocket=new ServerSocket(8888);
                int i=0;
                //循环，持续监听从这个端口的所有请求
                while(true){
                    currsoket=serverSocket.accept();
                    //启动一个新的线程来处理这个请求
                    i++;
                    System.out.println("启动第"+i+"个线程");
                    new MyProxy(currsoket);
                }
            } catch (IOException e) {
                if (currsoket != null) {
                    currsoket.close();//及时关闭这个socket
                }
                e.printStackTrace();
            }
            writeCache.close();//关闭文件输出流
        }
    }

> MyProxy.java

import java.io.*;
    import java.net.Socket;
    import java.net.SocketException;
    import java.net.SocketTimeoutException;
    import java.util.ArrayList;
    import java.util.StringTokenizer;
    import java.util.Vector;
    
    public class MyProxy extends Thread {
    
        Socket socket ;//这个socket是这个线程与浏览器的socket
    
        String targetHost=null;
        String targetPort;
        InputStream inputStream_client;//这个输入流用来读取浏览器发过来的请求
        OutputStream outputStream_client;//这个输出流用来将数据发送到浏览器
        PrintWriter outPrintWriter_client;//这个writer用来向浏览器写入数据
        BufferedReader bufferedReader_client;//这个缓冲用来缓存浏览器的请求
    
        Socket accessSocket;//这个socket用来向网站连接
    
        InputStream inputStream_Web;//这个输入流用来读取从网站发回的响应
        OutputStream outputStream_Web;//这个输出流用来向网站发送请求
        PrintWriter outPrintWriter_Web;//这个writer用来向网站发送请求
        BufferedReader bufferedReader_web;//这个缓冲用来缓存想网站发送的请求
    
        String cacheFilePath;
        File file=null;
        FileInputStream fileInputStream;
        String url="";
        ArrayList<String>cache;
        int cache_url_index=-1;
        boolean has_cache_no_timestamp=false;
    
        public MyProxy(Socket inputSocket) throws IOException {
            socket=inputSocket;
            /** 创建一个文件对象 */
            file=new File(HttpProxy.cachePath);
            if (!file.exists()){//文件不存在则新建一个文件
                file.createNewFile();
            }
    
            fileInputStream=new FileInputStream(HttpProxy.cachePath);
    
            System.out.print("代理服务器启动\n");
            System.out.print("获取的socket来自"+inputSocket.getInetAddress()+":"+inputSocket.getPort()+"\n");
    
            inputStream_client=socket.getInputStream();//创建从浏览器获取请求的输入流
            bufferedReader_client=new BufferedReader(new InputStreamReader(inputStream_client));
            outputStream_client=socket.getOutputStream();//创建向浏览器发送响应的流
            outPrintWriter_client=new PrintWriter(outputStream_client);
            /** 读取缓存 */
            cache=readCache(fileInputStream);
            System.out.println("读到的缓存有"+cache.size()+"行");
    
            start();//启动本线程
        }
        public void run() {
            try {
                socket.setSoTimeout(HttpProxy.TIMEOUT);//设置最大等待时间，超过则自动断开连接
                String buffer;
                //debug
                System.out.println("从浏览器读取第一行....");
                buffer = bufferedReader_client.readLine();//从浏览器读取第一行请求
                System.out.println(buffer);
    
    
                /** 提取 url */
                url=getURL(buffer);
                /** 过滤一些杂乱的请求，比如Google的和一些后台的CONNECT请求还有QQ管家的监听 */
                if(buffer.contains("CONNECT")||buffer.contains("google")||buffer.contains("c.gj.qq.com")){
                    System.out.println("请求"+buffer+"已被过滤");
                    return ;//退出run()方法，该线程就自动结束
                }
    
                /** 将请求写入缓存文件,如果缓存中已经有相同的请求，就不再写入了 */
                boolean has_in_cache_already=false;
                for(String iter:cache){
                    if (iter.equals(buffer)) {
                        has_in_cache_already = true;
                        break;
                    }
                }
                if (has_in_cache_already==false){
                    String temp = buffer + "\r\n";
                    write_cache(temp.getBytes(), 0, temp.length());
                }
    
                /** 提取主机和端口 */
                String[] HostandPort=new String[2];
                if (buffer!=null)
                 HostandPort= findHostandPort(buffer);
                targetHost = HostandPort[0];
                targetPort = HostandPort[1];
    
                System.out.println("提取的主机名:" + targetHost + " 提取的端口号: " + targetPort);
    
                /** 尝试与目标主机连接 */
                int retry = HttpProxy.RETRIEVE;
                while (retry-- != 0 && (targetHost != null)) {
                    try {
                        accessSocket = new Socket(targetHost, Integer.parseInt(targetPort));
                        break;
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    Thread.sleep(HttpProxy.CONNECT_PAUSE);//等待
                }
                if (accessSocket != null) {//成功建立连接
                    //debug
                    System.out.println("请求将发送至:" + targetHost);
                    accessSocket.setSoTimeout(HttpProxy.TIMEOUT);
                    inputStream_Web = accessSocket.getInputStream();//获取网站返回的响应
                    bufferedReader_web = new BufferedReader(new InputStreamReader(inputStream_Web));
                    outPrintWriter_Web = new PrintWriter(accessSocket.getOutputStream());//准备好向网站发送请求
    
    
                     /** 如果缓存文件为空 */
                    if (cache.size()==0) {
                        /** 将请求直接发往网站，并获取响应，记录响应至缓存 */
                        sendRequestToInternet(buffer);
                        transmitResponseToClient();
                    } else {//缓存文件不为空，寻找之前有没有缓存过该请求
                        String modifyTime;
                        String info="";
                        modifyTime=findModifyTime(cache,buffer);//提取modifytime
                        System.out.println("提取到的modifytime："+modifyTime);
                        if (modifyTime!=null||has_cache_no_timestamp){
                            /** 如果缓存的内容里面该请求是没有Last-Modify属性的，就不用向服务器查询If-Modify了，否则向服务器查询If-Modify */
                            if (!has_cache_no_timestamp){
                                buffer += "\r\n";
                                outPrintWriter_Web.write(buffer);
                                System.out.print("向服务器发送确认修改时间请求:\n" + buffer);
                                String str1 = "Host: " + targetHost + "\r\n";
                                outPrintWriter_Web.write(str1);
                                String str = "If-modified-since: " + modifyTime
                                        + "\r\n";
                                outPrintWriter_Web.write(str);
                                outPrintWriter_Web.write("\r\n");
                                outPrintWriter_Web.flush();
                                System.out.print(str1);
                                System.out.print(str);
    
                                 info= bufferedReader_web.readLine();
                                System.out.println("服务器发回的信息是：" + info);
                            }
    
                            if (info.contains("Not Modified")||has_cache_no_timestamp) {//如果服务器给回的响应是304 Not Modified，就将缓存的数据直接发送给浏览器
                                int contentindex = 0;
                                String temp_response="";
                                System.out.println("使用缓存数据");
                                if (cache_url_index!=-1)
                                for (int i=cache_url_index+1;i<cache.size();i++){
                                    if (cache.get(i).contains("http://"))
                                        break;
                                    temp_response+=cache.get(i);
                                    temp_response+="\r\n";
    
                                }
                                System.out.println("使用缓存：\n"+temp_response);
                                outputStream_client.write(temp_response.getBytes(),0,temp_response.getBytes().length);
                                outputStream_client.write("\r\n".getBytes(),0,"\r\n".getBytes().length);
                                outputStream_client.flush();
                            } else {
                                /** 服务器返回的不是304 Not Modified的话，就将服务器的响应直接转发到浏览器并记录缓存就好了 */
                                System.out.println("有更新，使用新的数据");
                                transmitResponseToClient();
                            }
                        }else{
                            /**缓存中没有找到之前的记录，直接将请求发送给网站，并接收响应，将响应写入缓存 */
                            sendRequestToInternet(buffer);
                            transmitResponseToClient();
                        }
    
                    }
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    
        /**
         *将请求发送给网站
         * @param buffer 请求的第一行报文
         * @throws IOException
         */
        private void sendRequestToInternet(String buffer) throws IOException {
            while(!buffer.equals("")){
                buffer+="\r\n";
                outPrintWriter_Web.write(buffer);
                System.out.print("发送请求:"+buffer+"\n");
                buffer=bufferedReader_client.readLine();
            }
            outPrintWriter_Web.write("\r\n");
            outPrintWriter_Web.flush();
        }
    
        /**
         * 提取主机名和端口
         * @param content 待提取的报文，这是请求的第一行
         * @return
         */
        private String[] findHostandPort(String content){
            String host=null;
            String port=null;
            String[] result=new String[2];
            int index;
            int portIndex;
            String temp;
    
            StringTokenizer stringTokenizer=new StringTokenizer(content);
            stringTokenizer.nextToken();//丢弃第一个字串 这是请求类型 比如GET POST
            temp=stringTokenizer.nextToken();//这个字串里面有主机名和端口
    
            host=temp.substring(temp.indexOf("//")+2);//比如 http://news.sina.com.cn/gov/2017-12-13/doc-ifypsqiz3904275.shtml -> news.sina.com.cn/gov/2017-12-13/doc-ifypsqiz3904275.shtml
            index=host.indexOf("/");
            if (index!=-1){
                host=host.substring(0,index);//比如 news.sina.com.cn/gov/2017-12-13/doc-ifypsqiz3904275.shtml -> news.sina.com.cn
                portIndex=host.indexOf(":");
                if (portIndex!=-1){
                    port=host.substring(portIndex+1);//比如 www.ghostlwb.com:8080 -> 8080
                    host=host.substring(0,portIndex);
                }else{//没有找到端口号，则加上默认端口号80
                    port="80";
                }
            }
            result[0]=host;
            result[1]=port;
            return result;
        }
    
        /**
         * 提取URL
         * @param firstline 请求报文的第一行
         * @return
         */
        private String getURL(String firstline){
            StringTokenizer stringTokenizer=new StringTokenizer(firstline);
            stringTokenizer.nextToken();
            return stringTokenizer.nextToken();
        }
    
        /**
         * 这个函数做三件事：从网站接收响应，发送给浏览器，并将响应写入缓存
         * @throws IOException
         */
        private void transmitResponseToClient() throws IOException {
    
            byte[] bytes=new byte[2048];
            int length=0;
    
            while(true){
                if((length=inputStream_Web.read(bytes))>0){
                    outputStream_client.write(bytes,0,length);
                    String show_response=new String(bytes,0,bytes.length);
                    System.out.println("服务器发回的消息是:\n---\n"+show_response+"\n---");
                    write_cache(bytes,0,length);
                    write_cache("\r\n".getBytes(),0,2);
                    continue;
                }
                break;
            }
    
            outPrintWriter_client.write("\r\n");
            outPrintWriter_client.flush();
        }
    
        /**
         * 从文件中读取缓存内容，按行读取
         * @param fileInputStream
         * @return
         */
        private ArrayList<String> readCache(FileInputStream fileInputStream){
            ArrayList<String> result=new ArrayList<>();
            String temp;
            BufferedReader br=new BufferedReader(new InputStreamReader(fileInputStream));
            try {
                while((temp=br.readLine())!=null){
                    result.add(temp);
                }
    
            } catch (IOException e) {
                e.printStackTrace();
            }
            return result;
        }
    
        /**
         * 将内容写入缓存，这两段代码参考网上的
         * @param c
         * @throws IOException
         */
        private void write_cache(int c) throws IOException {
                HttpProxy.writeCache.write((char) c);
        }
    
        private void write_cache(byte[] bytes, int offset, int len)
                throws IOException {
            for (int i = 0; i < len; i++)
                write_cache((int) bytes[offset + i]);
        }
    
        /**
         * 提取modifytime
         * @param cache_temp
         * @param request
         * @return
         */
        private String findModifyTime(ArrayList<String> cache_temp,String request){
            String LastModifiTime=null;
            int startSearching=0;
            has_cache_no_timestamp=false;
    
            System.out.println("将要比对的URL是"+request);
            for(int i=0;i<cache_temp.size();i++){
    
                if (cache_temp.get(i).equals(request)){
                    startSearching=i;
                    cache_url_index=i;
                    for(int j=startSearching+1;j<cache_temp.size();j++){
                        if(cache_temp.get(j).contains("http://"))
                            break;
                        if (cache_temp.get(j).contains("Last-Modified:")){
                            LastModifiTime=cacheFilePath.substring(cache_temp.get(j).indexOf("Last-Modified:"));
                            return LastModifiTime;
                        }
                        if (cache_temp.get(j).contains("<html>")){
                            has_cache_no_timestamp=true;
                            return LastModifiTime;
                        }
                    }
                }
            }
    
            return LastModifiTime;
        }
    
    }

程序中都有十分详细的中文注释，如果有不明白的地方，欢迎在下面评论交流