26. 应用层HTTP原理(4) —— HTTP Server（完成一个登录页面）

傷城~ 2022-11-11 06:13 126阅读 0赞

## 使用技术 ##

Cookie、session、线程池、工厂模式、html

## 实现代码 ##

首先需要在这里创建一下文件，在index.html中写入想从网页上返回的内容，这里是需要完成一个登录页面，因此html中的内容如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70]

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>登陆页面</title>
    </head>
    <body>
    
        <form method="post" action="/login">
            <div style="margin-bottom: 5px">
                <input type="text" name="username" placeholder="请输入姓名">
            </div>
            <div style="margin-bottom: 5px">
                <input type="password" name="password" placeholder="请输入密码">
            </div>
            <div style="margin-bottom: 5px">
                <input type="submit" value="登录">
            </div>
        </form>
    
    </body>
    </html>

这里也是分为三部分来写：  
**第一部分：HttpRequest**

package day0318;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.util.HashMap;
    import java.util.Map;
    
    public class HttpRequest {
        
        private String method;
        private String url;
        private String version;
        private Map<String,String> headers = new HashMap<>();
        //url中的参数和body中的参数都放到parameters这个hash表中
        private Map<String,String> parameters = new HashMap<>();
        private Map<String,String> cookies = new HashMap<>();
        private String body;
    
        public static HttpRequest build(InputStream inputStream) throws IOException {
        
            HttpRequest request = new HttpRequest();
            //此处不能把bufferedReader写道try括号中，一旦写进去就意味着bufferedReader就会被关闭，会影响到clientSocket的状态
            //等到最后正给请求处理完了再统一关闭
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            //此处的build过程就是解析请求的过程
            //1.解析首行
            String firstLine = bufferedReader.readLine();
            String[] firstLineTokens = firstLine.split(" ");
            request.method = firstLineTokens[0];
            request.url = firstLineTokens[1];
            request.version = firstLineTokens[2];
    
            //2.解析url
            int pos = request.url.indexOf("?");
            if (pos != -1){
        
                //pos表示问号的下标
                //看看有没有带问号，如果没有带问号就不用解析了
                //index.html?a=10&b=20
                String queryString = request.url.substring(pos+1);//从i+1开始取
                //切分的最终结果
                parseKV(queryString,request.parameters);
            }
    
            //3.解析header
            String line = "";
            //readLine()读到的一行内容，时会自动去掉换行符的
            while ((line = bufferedReader.readLine()) != null && line.length() !=0){
        
                //还没读完并且读到的不是空字符串
                String[] headerTokens = line.split(": ");//用冒号空格来切分
                request.headers.put(headerTokens[0],headerTokens[1]);
            }
    
            //4.解析cookie
            String cookie = request.headers.get("cookie");
            if (cookie != null){
        
                parseCookie(cookie,request.cookies);
            }
    
            //5.解析body
            if ("POST".equalsIgnoreCase(request.method)
            || "PUT".equalsIgnoreCase(request.method)){
        
                //这两种方法需要处理body，其他暂时不考虑
                //此处的 长度单位是字节
                int contentLength = Integer.parseInt(request.headers.get("Content-Length"));
                //注意体会：此处的ContentLength为100，就说明body中有100个字节，下面创建的缓冲区为100个char，相当于是两百个字节
                //缓冲区不怕长，就怕不够，这样创建的缓冲区才能保证管够
                char[] buffer = new char[contentLength];
                int length = bufferedReader.read(buffer);
                request.body = new String(buffer,0,length);
                parseKV(request.body,request.parameters);
            }
            return request;
        }
    
        private static void parseCookie(String cookie, Map<String, String> cookies) {
        
            //1.先按照&分成若干组键值对
            String[] kvTokens = cookie.split(": ");//这里不一样
            //2.针对切分结果再分别进行按照=切分，得到了键和值
            for (String kv : kvTokens){
        
                String[] result = kv.split("=");
                cookies.put(result[0],result[1]);
            }
        }
    
        private static void parseKV(String input, Map<String, String> output) {
        
            //1.先按照&分成若干组键值对
            String[] kvTokens = input.split("&");
            //2.针对切分结果再分别进行按照=切分，得到了键和值
            for (String kv : kvTokens){
        
                String[] result = kv.split("=");
                output.put(result[0],result[1]);
            }
        }
    
        public String getMethod() {
        
            return method;
        }
    
        public String getUrl() {
        
            return url;
        }
    
        public String getVersion() {
        
            return version;
        }
    
        public String getBody() {
        
            return body;
        }
    
        public String getParameter(String key){
        
            return parameters.get(key);
        }
    
        public String getHeader(String key){
        
            return headers.get(key);
        }
    
        public String geCookie(String key){
        
            return cookies.get(key);
        }
    }

**第二部分：HttpResponse**

package day0318;
    
    import java.io.BufferedWriter;
    import java.io.IOException;
    import java.io.OutputStream;
    import java.io.OutputStreamWriter;
    import java.util.HashMap;
    import java.util.Map;
    
    public class HttpResponse {
        
        private String version = "HTTP/1.1";
        private int status; //状态码
        private String message; //状态码描述信息
        private Map<String,String> headers = new HashMap<>();
        private StringBuilder body = new StringBuilder();
        //当代码需要把响应写回客户端的时候，就往这个OutputStream里面写就好了
        private OutputStream outputStream = null;
    
        //工厂方法
        public static HttpResponse build(OutputStream outputStream){
        
            HttpResponse response = new HttpResponse();
            response.outputStream = outputStream;
            return response;
        }
    
        public void setVersion(String version) {
        
            this.version = version;
        }
    
        public void setStatus(int status) {
        
            this.status = status;
        }
    
        public void setMessage(String message) {
        
            this.message = message;
        }
    
        public void setHeaders(String key, String value) {
        
            headers.put(key,value);
        }
    
        public void writeBody(String content) {
        
            body.append(content);
        }
    
        //以上的设置属性操作都是在内存中搞得，还需要一个专门的方法，把这些属性按照HTTP协议，都写到Socket中
        public void flush() throws IOException {
        
            BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
            bufferedWriter.write(version+" "+status+ " "+message+"\n");
            headers.put("Content-Length",body.toString().getBytes().length+"");
            for (Map.Entry<String,String> entry : headers.entrySet()){
        
                bufferedWriter.write(entry.getKey()+": "+entry.getValue()+"\n");
            }
            bufferedWriter.write("\n");
            bufferedWriter.write(body.toString());
            bufferedWriter.flush();
        }
    }

**第三部分：HttpServerV3**

package day0318;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.HashMap;
    import java.util.UUID;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     * 1.让服务器支持返回一个静态的html文件
     * 2.解析处理cookie，把cookie处理成键值对保存好
     * 3.解析body，把body中的数据成键值对结构
     * 4.完成一个登录功能，session的简单实现
     */
    public class HttpServerV3 {
        
        static class User{
        
            //保存用户的相关信息
            public String userName;
            public int age;
            public String school;
        }
    
        private ServerSocket serverSocket = null;
    
        //session 会话，指的是同一个用户的一组访问服务操作，归类到一起，就是一个会话
        //每个键值对就是一个会话
        private HashMap<String,User> sessions = new HashMap<String, User>();
    
        public HttpServerV3(int port) throws IOException {
        
            serverSocket = new ServerSocket(port);
        }
    
        public void start() throws IOException {
        
            System.out.println("服务器启动");
            ExecutorService executorService = Executors.newCachedThreadPool();
    
            while (true){
        
                //1.获取连接
                Socket clientSocket = serverSocket.accept();
                executorService.execute(new Runnable() {
        
                    @Override
                    public void run() {
        
                        //2.处理连接(采用短连接)
                        try {
        
                            process(clientSocket);
                        } catch (IOException e) {
        
                            e.printStackTrace();
                        }
                    }
                });
            }
        }
    
        public void process(Socket clientSocket) throws IOException {
        
            try {
        
                //1.读取并解析请求
                HttpRequest request = HttpRequest.build(clientSocket.getInputStream());
                HttpResponse response = HttpResponse.build(clientSocket.getOutputStream());
                response.setHeaders("Content-Type", "text.html");
    
                //2.根据请求计算相应
                //此处按照不同的HTTP方法拆分成多个不同的逻辑
                if ("GET".equalsIgnoreCase(request.getMethod())){
        
                    doGet(request,response);
                }else if ("POST".equalsIgnoreCase(request.getMethod())){
        
                    doPost(request,response);
                }else {
        
                    response.setStatus(405);
                    response.setMessage("Method Not Allowed");
                }
    
                //3.把响应写回到客户端
                response.flush();
    
            } catch (IOException | NullPointerException e) {
        
                e.printStackTrace();
            }finally {
        
                clientSocket.close();
            }
        }
    
    
    
        private void doGet(HttpRequest request, HttpResponse response) throws IOException {
        
            //1.能够支持返回一个HTML文件
            if (request.getUrl().startsWith("/index.html")){
        
                String sessionId = request.geCookie("sessionId");
                User user = sessions.get(sessionId);
                if (sessionId == null || user == null) {
        
                    //说明当前用户尚未登陆，就返回一个登陆页面
    
                    //这种情况下，就让代码读取一个index.html这样的文件
                    //此时可以自己来约定路径
    
                    //把这个文件内容写入到响应的body中
                    response.setStatus(200);
                    response.setMessage("OK");
                    response.setHeaders("Content-Type","text/html; charset=utf-8");
    
                    InputStream inputStream = HttpServerV3.class.getClassLoader().getResourceAsStream("index.html");
                    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
                    //HttpServerV3.class: 获取到一个类的类对象
                    //getClassLoader()： 获取到当前类的“类加载器”，
                    //一个类想要工作，需要先由JVM把这个类的.class文件找到，然后读取内容，加载到内存中（类加载过程）
                    //.getResourceAsStream("index.html"): 根据文件名，在Resources目录中找到对应的文件并打开
                    //返回这个文件的InputStream对象
    
                    //按行读取
                    String line = null;
                    while ((line = bufferedReader.readLine()) != null){
        
                        response.writeBody(line+"\n");
                    }
                    bufferedReader.close();
                }else {
        
                    //已经登陆了，就不需要再登陆了
                    response.setStatus(200);
                    response.setMessage("OK");
                    response.setHeaders("Content-Type","text/html; charset=utf-8");
                    response.writeBody("<html>");
                    response.writeBody("<div>您已经登录了无需再次登录，用户名为："+user.userName+"</div>");
                    response.writeBody("<div>"+user.age+"</div>");
                    response.writeBody("<div>"+user.school+"</div>");
                    response.writeBody("</html>");
                }
            }
        }
    
        private void doPost(HttpRequest request, HttpResponse response) {
        
            //2.实现一个/login的处理
            if (request.getUrl().startsWith("/login")){
        
                //读取用户提交的用户名和密码
                String userName = request.getParameter("username");
                String password = request.getParameter("password");
    //            System.out.println("username: "+userName);
    //            System.out.println("password: "+password);
                //验证用户名密码是否正确
                if ("dqy".equals(userName) && "123".equals(password)){
        
                    //登陆成功
                    response.setStatus(200);
                    response.setMessage("OK");
                    response.setHeaders("Content-Type","text/html; charset=utf-8");
                    //原来登陆成功是给浏览器写了一个cookie，cookie中保存的是用户名
                   // response.setHeaders("Set-Cookie","userName="+userName);
    
                    String sessionId = UUID.randomUUID().toString();//会生成一个随机字符串，能保证每次调用这个方法生成的字符串都不一样
                    //此时身份信息保存在服务器中，就不会再有泄露的问题了，
                    //给浏览器返回cookie中包含sessionId即可
                    User user = new User();
                    user.userName = "dqy";
                    user.age = 20;
                    user.school = "大学";
                    sessions.put(sessionId,user);
                    response.setHeaders("Set-Cookie","sessionId="+sessionId);
    
                    //在响应中添加一个cookie，浏览器就会自动存储这个cookie
                    response.writeBody("<html>");
                    response.writeBody("<div>欢迎您!"+userName+"</div>");
                    response.writeBody("</html>");
                }else {
        
                    //登陆失败
                    response.setStatus(403);
                    response.setMessage("Forbidden");
                    response.setHeaders("Content-Type","text/html; charset=utf-8");
                    response.writeBody("<html>");
                    response.writeBody("<div>登陆失败</div>");
                    response.writeBody("</html>");
                }
            }
        }
    
        public static void main(String[] args) throws IOException {
        
            HttpServerV3 serverV3 = new HttpServerV3(9090);
            serverV3.start();
        }
    }

## 成果展示 ##

启动服务器  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70 1]

就会看到登录页面  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70 2]  
输入用户名和密码之后，能看到：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70 3]

此时就登陆成功了

抓包并且可以看到session字段  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70 4]  
![!\[在这里插入图片描述\](https://img-blog.csdnimg.cn/20210319210531492.png?x-oss-process=image/watermark,type\_ZmFuZ3poZW5naGVpdGk,shadow\_10,text\_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5,size\_16,color\_FFFFFF,t\_70][https_img-blog.csdnimg.cn_20210319210531492.png_x-oss-process_image_watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70]

在浏览器中可以看到多了一个Cookie  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70 5]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70]: /images/20221022/a9f554b43b2a4accba7e72edced427dc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70 1]: /images/20221022/9f3b4f92fe054d0ab0553533747eb244.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70 2]: /images/20221022/f5c3f3e10b6747ae89cefc0bc5fab7b7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70 3]: /images/20221022/b76acf6db3ef46ac9fc18e8ca9582d5d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70 4]: /images/20221022/e552f7e1094a449a9ccf5e6b05d82acb.png
[https_img-blog.csdnimg.cn_20210319210531492.png_x-oss-process_image_watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70]: /images/20221022/94d5e18bd33245e9b6bf667715d42dd6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70 5]: /images/20221022/edeeef42cc4744819ad326beaad19d42.png