Java阶段二Day02

文章目录

Java阶段二Day02
- SpringMVC的部分主流程
- HTTP
- - 请求Request
  - - 1：请求行
    - 2：消息头
    - 3：消息正文
  - HTTP响应Response
  - - 1：状态行
    - 2：响应头
    - 3：响应正文
- 通过版本迭代仿写SpringBoot
- - V1
  - - BirdBootApplication
    - ClieantHandler
  - V2
  - - ClientHandler
  - V3
  - - ClientHandler
  - V4
  - - ClientHandler
    - HttpServletRequest
  - 截至此版本可实现的流程图为

SpringMVC的部分主流程

在这里插入图片描述

HTTP

HTTP协议 超文本传输协议 由万维网制定(w3c)

是浏览器与服务器通讯的应用层协议，规定了浏览器与服务器之间的交互规则以及交互数据的
格式信息等。

HTTP协议对于客户端与服务端之间的交互规则有以下定义：
要求浏览器与服务端之间必须遵循一问一答的规则，即:浏览器与服务端建立TCP连接后需要
先发送一个请求(问)然后服务端接收到请求并予以处理后再发送响应(答)。注意，服务端永远
不会主动给浏览器发送信息。

HTTP要求浏览器与服务端的传输层协议必须是可靠的传输，因此是使用TCP协议作为传输层
协议的。

HTTP协议对于浏览器与服务端之间交互的数据格式，内容也有一定的要求。

浏览器给服务端发送的内容称为请求Request
服务端给浏览器发送的内容称为响应Response

请求和响应中大部分内容都是文本信息(字符串)，并且这些文本数据使用的字符集为:
ISO8859-1.这是一个欧洲的字符集，里面是不支持中文的!!!。而实际上请求和响应出现
的字符也就是英文，数字，符号。

请求Request

请求是浏览器发送给服务端的内容，HTTP协议中一个请求由三部分构成:
分别是:请求行，消息头，消息正文。消息正文部分可以没有。

1：请求行

请求行是一行字符串，以连续的两个字符(回车符和换行符)作为结束这一行的标志。
回车符:在ASC编码中2进制内容对应的整数是13.回车符通常用cr表示。
换行符:在ASC编码中2进制内容对应的整数是10.换行符通常用lf表示。
回车符和换行符实际上都是不可见字符。

请求行分为三部分：

请求方式(SP)
抽象路径(SP)
协议版本(CRLF)

注:SP是空格
GET /myweb/index.html HTTP/1.1

URL地址格式：
协议://主机地址信息/抽象路径

http://localhost:8088/TeduStore/index.html
GET /TeduStore/index.html HTTP/1.1

http://localhost:8088/index.html
GET /index.html HTTP/1.1

http://localhost:8088/reg.html
GET /reg.html HTTP/1.1

2：消息头

消息头是浏览器可以给服务端发送的一些附加信息，有的用来说明浏览器自身内容，有的
用来告知服务端交互细节，有的告知服务端消息正文详情等。

消息头由若干行组成，每行结束也是以CRLF标志。
每个消息头的格式为:消息头的名字(:SP)消息的值(CRLF)
消息头部分结束是以单独的(CRLF)标志。
例如：

Host: localhost:8088(CRLF)
Connection: keep-alive(CRLF)
Upgrade-Insecure-Requests: 1(CRLF)
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36(CRLF)
Sec-Fetch-User: ?1(CRLF)
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,/;q=0.8,application/signed-exchange;v=b3;q=0.9(CRLF)
Sec-Fetch-Site: none(CRLF)
Sec-Fetch-Mode: navigate(CRLF)
Accept-Encoding: gzip, deflate, br(CRLF)
Accept-Language: zh-CN,zh;q=0.9(CRLF)(CRLF)

3：消息正文

消息正文是2进制数据，通常是用户上传的信息，比如:在页面输入的注册信息，上传的
附件等内容。

GET /index.html HTTP/1.1(CRLF)
Host: localhost:8088(CRLF)
Connection: keep-alive
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36
Sec-Fetch-User: ?1
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,/;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
1010101101001…

HTTP响应Response

响应是服务端发送给客户端的内容。一个响应包含三部分:状态行，响应头，响应正文

1：状态行

状态行是一行字符串(CRLF结尾)，并且状态行由三部分组成，格式为:
protocol(SP)statusCode(SP)statusReason(CRLF)
协议版本(SP)状态代码(SP)状态描述(CRLF)
例如:
HTTP/1.1 200 OK

状态代码是一个3位数字，分为5类：

1xx:保留
2xx:成功，表示处理成功，并正常响应
3xx:重定向，表示处理成功，但是需要浏览器进一步请求
4xx:客户端错误，表示客户端请求错误导致服务端无法处理
5xx:服务端错误，表示服务端处理请求过程出现了错误

具体的数字在HTTP协议手册中有相关的定义，可参阅。
状态描述手册中根据不同的状态代码有参考值，也可以自行定义。通常使用参考值即可。

2：响应头

响应头与请求中的消息头格式一致，表示的是服务端发送给客户端的附加信息。

3：响应正文

2进制数据部分，包含的通常是客户端实际请求的资源内容。

响应的大致内容：

HTTP/1.1 404 NotFound(CRLF)
Content-Type: text/html(CRLF)
Content-Length: 2546(CRLF)(CRLF)
1011101010101010101…

这里的两个响应头：
Content-Type是用来告知浏览器响应正文中的内容是什么类型的数据(图片，页面等等)
不同的类型对应的值是不同的，比如：

文件类型	Content-Type对应的值
html	text/html
css	text/css
js	application/javascript
png	image/png
gif	image/gif
jpg	image/jpeg

MIME
Content-Length是用来告知浏览器响应正文的长度，单位是字节。

浏览器接收正文前会根据上述两个响应头来得知长度和类型从而读取出来做对应的处理以
显示给用户看。

通过版本迭代仿写SpringBoot

V1

初始版本

BirdBootApplication

package com.birdboot.core;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 主启动类
 */
public class BirdBootApplication {
    private ServerSocket serverSocket;

    public BirdBootApplication(){
        try {
            System.out.println("正在启动服务端...");
            serverSocket = new ServerSocket(8088);
            System.out.println("服务端启动完毕!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void start(){
        try {
            System.out.println("等待客户端链接...");
            Socket socket = serverSocket.accept();
            System.out.println("一个客户端链接了!");
            //启动一个线程处理该客户端交互
            ClientHandler handler = new ClientHandler(socket);
            Thread t = new Thread(handler);
            t.start();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    public static void main(String[] args) {
        BirdBootApplication application = new BirdBootApplication();
        application.start();
    }
}

ClieantHandler

package com.birdboot.core;

import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;

/**
 * 该线程任务负责与指定的客户端进行HTTP交互
 * HTTP协议要求浏览器与服务端采取"一问一答"的模式。对此，这里的处理流程分为三步:
 * 1:解析请求
 * 2:处理请求
 * 3:发送响应
 */
public class ClientHandler implements Runnable{
    private Socket socket;
    public ClientHandler(Socket socket){
        this.socket = socket;
    }

    public void run() {
        try {
            InputStream in = socket.getInputStream();
            int d;
            while((d = in.read())!=-1){
                System.out.print((char)d);
            }


        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

V2

解析请求
HTTP协议要求客户端连接后会发送一个请求,每个请求由三部分构成:
请求行消息头消息正文

首先请求行和消息头有一个共同的特点:都是以CRLF结尾的一行字符串.
因此先实现读取一行字符串的操作,测试将请求行读取出来并进行解析.之后可以再利用这个
操作完成消息头的读取并解析.

实现：
在ClientHandler中完成读取一行字符串的操作

ClientHandler

package com.birdboot.core;

import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;

public class ClientHandler implements Runnable{
    private Socket socket;
    public ClientHandler(Socket socket){
        this.socket = socket;
    }

    public void run() {
        try {
            InputStream in = socket.getInputStream();
            int d;
            char pre='a',cur='a';//pre表示上次读取的字符，cur表示本次读取的字符
            StringBuilder builder = new StringBuilder();//保存读取后的所有字符
            while((d = in.read())!=-1){
                cur = (char)d;//本次读取的字符
                if(pre==13 && cur==10){//是否连续读取到了回车+换行
                    break;
                }
                builder.append(cur);//将本次读取的字符拼接
                pre=cur;//在进行下次读取前，将本次读取的字符保存到"上次读取的字符"中
            }
            String line = builder.toString().trim();
            System.out.println("请求行:"+line);

            //请求行相关信息
            String method;//请求方式
            String uri;//抽象路径
            String protocol;//协议版本
            //将请求行按照空格("\s"在正则表达式中表示一个空白字符，包含空格)拆分为三部分
            String[] data = line.split("\\s");
            method = data[0];
            uri = data[1];
            protocol = data[2];

            System.out.println("method:"+method);
            System.out.println("uri:"+uri);
            System.out.println("protocol:"+protocol);



        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

V3

继续解析请求
上一个版本完成了解析请求行的操作，继续使用该操作完成解析消息头

实现：

在ClientHandler中定义方法：readLine，用于将读取一行字符串的操作重用
将解析请求行中读取第一行内容的操作改为调用readLine
继续利用readLine读取消息头并保存每个消息头

ClientHandler

package com.birdboot.core;

import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;


public class ClientHandler implements Runnable{
    private Socket socket;
    public ClientHandler(Socket socket){
        this.socket = socket;
    }

    public void run() {
        try {
            //1 解析请求
            //1.1解析请求行
            String line = readLine();
            System.out.println("请求行:"+line);
            //请求行相关信息
            String method;//请求方式
            String uri;//抽象路径
            String protocol;//协议版本
            //将请求行按照空格("\s"在正则表达式中表示一个空白字符，包含空格)拆分为三部分
            String[] data = line.split("\\s");
            method = data[0];
            uri = data[1];
            protocol = data[2];

            System.out.println("method:"+method);
            System.out.println("uri:"+uri);
            System.out.println("protocol:"+protocol);

            //1.2解析消息头
            //消息头相关信息 key:消息头名字  value:消息头对应的值
            Map<String,String> headers = new HashMap<>();
            while(true) {
                line = readLine();
                if(line.isEmpty()){//如果读取到了空行
                    break;
                }
                System.out.println("消息头:" + line);
                data = line.split(":\\s");
                headers.put(data[0],data[1]);
            }
            System.out.println("headers:"+headers);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * 通过socket获取的输入流读取客户端发送过来的一行字符串
     * @return
     */
    private String readLine() throws IOException {//通常被重用的代码不自己处理异常
        //对一个socket实例调用多次getInputStream()返回的始终是同一条输入流。而输出流也是如此
        InputStream in = socket.getInputStream();
        int d;
        char pre='a',cur='a';//pre表示上次读取的字符，cur表示本次读取的字符
        StringBuilder builder = new StringBuilder();//保存读取后的所有字符
        while((d = in.read())!=-1){
            cur = (char)d;//本次读取的字符
            if(pre==13 && cur==10){//是否连续读取到了回车+换行
                break;
            }
            builder.append(cur);//将本次读取的字符拼接
            pre=cur;//在进行下次读取前，将本次读取的字符保存到"上次读取的字符"中
        }
        return builder.toString().trim();
    }

}

V4

重构
进行功能个拆分，将ClientHandler中第一个环节解析请求的细节拆分出去，使得
ClientHandler仅关心处理一次HTTP交互的流程控制

实现：

新建一个包:com.birdboot.http

在http包下新建类:HttpServletRequest 请求对象

使用这个类的每一个实例表示客户端发送过来的一个HTTP请求

在HttpServletRequest的构造方法中完成解析请求的工作

ClientHandler第一步解析请求只需要实例化一个HttpServletRequest即可

ClientHandler

package com.birdboot.core;

import com.birdboot.http.HttpServletRequest;

import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;

public class ClientHandler implements Runnable{
    private Socket socket;
    public ClientHandler(Socket socket){
        this.socket = socket;
    }
    public void run() {
        try {
            //1 解析请求
            //V4:将解析请求的细节移动到request构造器中进行
            HttpServletRequest request = new HttpServletRequest(socket);
            //获取请求的抽象路径
            String path = request.getUri();
            System.out.println(path);

        } catch (IOException e) {
            e.printStackTrace();
       }
    }
}

HttpServletRequest

package com.birdboot.http;

import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;

/**
 * V4:新增内容
 * 请求对象
 * 该类的每一个实例用于表示浏览器发送过来的一个HTTP请求
 * HTTP协议要求请求的格式由三部分构成:请求行，消息头，消息正文
 */
public class HttpServletRequest {
    private Socket socket;
    //请求行相关信息
    private String method;//请求方式
    private String uri;//抽象路径
    private String protocol;//协议版本

    //消息头相关信息 key:消息头名字  value:消息头对应的值
    private Map<String,String> headers = new HashMap<>();


    public HttpServletRequest(Socket socket) throws IOException {
        this.socket = socket;

        //1.1解析请求行
        parseRequestLine();
//        String line = readLine();
//        System.out.println("请求行:"+line);
//
//        //将请求行按照空格("\s"在正则表达式中表示一个空白字符，包含空格)拆分为三部分
//        String[] data = line.split("\\s");
//        method = data[0];
//        uri = data[1];
//        protocol = data[2];
//
//        System.out.println("method:"+method);
//        System.out.println("uri:"+uri);
//        System.out.println("protocol:"+protocol);

        //1.2解析消息头
        parseHeaders();
//        while(true) {
//            line = readLine();
//            if(line.isEmpty()){//如果读取到了空行
//                break;
//            }
//            System.out.println("消息头:" + line);
//            data = line.split(":\\s");
//            headers.put(data[0],data[1]);
//        }
//        System.out.println("headers:"+headers);

        //1.3解析消息正文
        parseContent();
    }
    //解析请求行
    private void parseRequestLine() throws IOException {
        String line = readLine();
        System.out.println("请求行:"+line);

        //将请求行按照空格("\s"在正则表达式中表示一个空白字符，包含空格)拆分为三部分
        String[] data = line.split("\\s");
        method = data[0];
        uri = data[1];
        protocol = data[2];

        System.out.println("method:"+method);
        System.out.println("uri:"+uri);
        System.out.println("protocol:"+protocol);
    }
    //解析消息头
    private void parseHeaders() throws IOException {
        while(true) {
            String line = readLine();
            if(line.isEmpty()){//如果读取到了空行
                break;
            }
            System.out.println("消息头:" + line);
            String[] data = line.split(":\\s");
            headers.put(data[0],data[1]);
        }
        System.out.println("headers:"+headers);
    }
    //解析消息正文
    private void parseContent(){}



    /**
     * 通过socket获取的输入流读取客户端发送过来的一行字符串
     * @return
     */
    private String readLine() throws IOException {//通常被重用的代码不自己处理异常
        //对一个socket实例调用多次getInputStream()返回的始终是同一条输入流。而输出流也是如此
        InputStream in = socket.getInputStream();
        int d;
        char pre='a',cur='a';//pre表示上次读取的字符，cur表示本次读取的字符
        StringBuilder builder = new StringBuilder();//保存读取后的所有字符
        while((d = in.read())!=-1){
            cur = (char)d;//本次读取的字符
            if(pre==13 && cur==10){//是否连续读取到了回车+换行
                break;
            }
            builder.append(cur);//将本次读取的字符拼接
            pre=cur;//在进行下次读取前，将本次读取的字符保存到"上次读取的字符"中
        }
        return builder.toString().trim();
    }

    public String getMethod() {
        return method;
    }

    public String getUri() {
        return uri;
    }

    public String getProtocol() {
        return protocol;
    }

    /**
     * 根据给定的消息头的名字获取对应消息头的值
     * @param name
     * @return
     */
    public String getHeader(String name) {
        return headers.get(name);
    }
}