Java阶段二Day02

最新推荐文章于 2024-05-19 21:34:53 发布
最新推荐文章于 2024-05-19 21:34:53 发布
阅读量489 收藏
点赞数 1
分类专栏： # 开发篇 文章标签： java http 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65777087/article/details/130213518
版权

Java阶段二Day02

文章目录

SpringMVC的部分主流程

在这里插入图片描述

HTTP

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

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

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

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

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

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

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

请求Request

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

1：请求行

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

请求行分为三部分：

  1. 请求方式(SP)

  2. 抽象路径(SP)

  3. 协议版本(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对应的值
htmltext/html
csstext/css
jsapplication/javascript
pngimage/png
gifimage/gif
jpgimage/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

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

实现：

  1. 在ClientHandler中定义方法：readLine，用于将读取一行字符串的操作重用
  2. 将解析请求行中读取第一行内容的操作改为调用readLine
  3. 继续利用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交互的流程控制

实现：

  1. 新建一个包:com.birdboot.http

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

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

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

  4. 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);
    }
}

截至此版本可实现的流程图为

在这里插入图片描述

今天你学Java了吗
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
收藏网址
u011569805的专栏
11-05 77万+
It will be read and overwritten.      DO NOT EDIT! --> Bookmarks Bookmarks     书签栏             桌面支持中心         从 IE 中导入                     桌面支持中心             入职                    
JAVA学习数据库阶段day02
weixin_62527159的博客
01-01 554
JAVA学习数据库阶段day02
Java基础_第二阶段_day17每日作业卷1
08-08
每日作业卷Java基础第二阶段第17天基础加强_XML传智播客.黑马程序员关卡1训练案例1训练描述：【讲义1.1.2：XML的作用】请写出XML的两个重要作用：
Java基础_第二阶段_day17每日作业卷答案1
08-08
Java基础_第二阶段_day17每日作业卷答案1
Java基础_第二阶段-day16每日作业卷1
08-08
每日作业卷Java基础第二阶段第16天基础加强_注解_类加载器_动态代理传智播客.黑马程序员关卡1训练案例1训练描述：【讲义1.1：JUnit介绍】请使用一句话
Java基础_第二阶段-day18每日作业卷1
08-08
每日作业卷Java基础第二阶段第18天BeanUtils工具类、综合案例传智播客.黑马程序员关卡1训练案例1训练描述：【讲义第一章：BeanUtils工具类】请
Java阶段二Day13
今天你学Java了吗
05-06 856
今天是学习Java阶段二的第十三天，从今天开始进行SSM框架的学习，首先就是认识Spring，然后对Spring的两大基本特性loC和AOP中的loC进行讲解练习
Java阶段三Day03
今天你学Java了吗
05-24 762
今天是学习Java阶段三的第三天，学习JS的一些知识，回顾了基础的如关系符、循环语句、条件语句等知识，了解了BOM和DOM，学习了前端设计模式
Java阶段四Day06
今天你学Java了吗
06-16 740
今天是学习Java阶段四的第六天，讲解了关于配置响应中消除Null的属性、配置跨域、和学习运用formData可以不用在请求中添加@ResquestBody注解
Java阶段二Day04
今天你学Java了吗
04-19 2037
今天是学习Java阶段二的第四天，接着迭代版本，仿写SpringBoot，实现了静态页面的加载，及控制层业务的实现
Java基础_第二阶段-day18每日作业卷答案1
08-08
每日作业卷Java基础第二阶段第18天BeanUtils工具类、综合案例传智播客.黑马程序员关卡1训练案例1训练描述：【讲义第一章：BeanUtils工具类】请
html5 连连看小游戏
iteye_19211的博客
07-07 1万+
[color=darkred]首先，html页面为：[/color] 连连看 var _canvas = null; var _canvasCtx=null; var _img=null; var _gameTimer=null; var lineTimer=null; var startTime=null;...
hxyx4xyzindex php vo,webshell/php/oi.php.txt at da33d92ba83c1f8d44e15957022ed4a03423a699 · tennc/web...
热门推荐
weixin_31163455的博客
03-26 22万+
eval("?>".gzuncompress(base64_decode("eJzsvXtbG0eyOPz/eZ7zHZqJYkuxEALbuYAhwYBjToxhAa83P+BVRpqRNEHSKDMjLsn6u79V1feeHkmQZE/2POvd2Jq+VFdXd1dXV1dVv/p2Opz+9399ttwfLMjif7DDyU0YJVHKNtrtb1jpDxaM4n4yietP82H...
uniapp 保存base64图片
weixin_43899650的博客
12-14 1万+
uniapp 保存base64图片 base64 微信小程序
jar包增量更新分析
junlaiyan的专栏
05-16 303
借助jdeps分析出jar包的增量文件
java实现拼图小游戏
monkey108的博客
05-16 665
本文主要提供用java实现的拼图小游戏源代码。
分布式锁2-Zookeeper分布式锁实战
最新发布
qq_43676797的博客
05-19 148
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
命令执行漏洞（二）
XLbb的博客
05-15 932
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 272
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
java 读取.day文件
06-08
3. 如果您希望使用Java读取.day文件，可以尝试使用Java的IO类和字节流来读取二进制数据，并根据.day文件的格式和结构解析其中的内容。这需要您对.day文件的格式和结构有一定的了解和理解。 综上所述，读取.day文件...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

今天你学Java了吗

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值