0
0

JAVA 网络编程

一、网络通信协议

1、概述

计算机网络是通过传输介质、通信设施和网络通信协议，把分散在不同地点的计算机设备互连起来的，实现资源共享和数据传输的系统。网络编程就是编写程序使互联网的两个（或多个）设备（如计算机）之间进行数据传输。Java语言对网络编程提供了良好的支持。通过其提供的接口我们可以很方便地进行网络编程。

网络通信协议是网络编程中的关键，通信双方达成的一种共识，当通信双方都遵守这样的约定，才能正确传输信息。

2、为什么协议要分层？

1、分层可以避免一个协议太过于庞大和复杂。

2、分层之后协议之间解耦合，上层协议不需要理解下层协议的细节

3、任意层次的协议的可以进行灵活的替换

3、对于参考模型的介绍

在这里我们对于TCP/IP模型进行详细的描述：

应用层：和应用程序直接打交道的协议。

传输层：负责端到端之间的传输（关注起点和终点）

网络层：负责点到点之间的传输（关注传输的路径）

数据链路层：负责相邻点之间如何具体传输。

物理层：网络通信的基础硬件措施。

面试常见：

1、对于一台主机来说，它的操作系统内核实现了从应用层到物理层
2、对于一台路由器来说，它实现了从网络层到物理层。
3、对于一台交换机来说，它实现了从数据链路层到物理层。
4、对于集线器来说，它实现的物理层。

4、TCP网络传输的基本流程

在这些基本操作中涉及到封装和分用两个操作流程。

封装的意思就是给基于数据的基础上，在数据前加上协议报头，当数据由应用层传输到传输层时，传输层会在得到的数据基础上加上传输层协议报头。 当数据由传输层到达网络层时，会继续添加网络层协议报头，也就是我们常说的IP地址。当数据由网络层传输到数据链路层时会在数据前加上数据链路层协议报头，也就是常数的MAC地址。数据链路层将数据发送给物理层时，物理层就会将这个数据转化成光电信号，通过一些硬件设备，例如网线，光纤，电磁波等传输出去。

分用的过程正好与封装相反，当物理层接收到对方发送过来的光电信号时，会将它解析成二进制的bit流，进一步得到数据链路层数据帧。 数据链路层解析数据帧，玻璃针头和针尾取出，其中的IP数据报交给网络层。网络层接收到刚才的网络层数据报，通过解析去掉网络层的协议报头。把数据交给传输层，传输层拿到传输层，数据报在进行解析，去掉传输层报头，最后将数据交给应用层，这时应用层就可以解析数据，分析出发送者是谁，接收者是谁显示到桌面上。

当发送者通过自己的主机将数据封装完成之后，会通过路由器广域网等发送到服务器。当服务器通过分用把数据拆开之后看到接收方的地址，然后服务器将数据重新封装之后，通过路由器广域网等途径发送到接收者的主机，然后接收者的主机一步一步的进行分佣，最终得到数据并且显示出来。

二、网络编程套接字（socket）

套接字（socket）是一组API，用来实现网络编程，一般是通过客户端（server）和服务器（cilent）实现的。

IP地址：用来识别互联网上一台主机的位置。

端口号：用来区分是主机上的那个应用。

在一次通信过程中涉及到五元组：源IP，目的IP，源端口，目的端口，协议类型。

JAVA中提供了两种风格：

UDP (DatagramSocket面向数据报，发送和接受数据要以数据包为单位)

TCP (ServerSocket面向字节流)

1、UDP(面向数据报)

1）UDP的服务器

  1. //UDP的服务器
  2. import java.io.IOException;
  3. import java.net.DatagramPacket;
  4. import java.net.DatagramSocket;
  5. import java.net.SocketException;
  7. public class Test01 {
  8.     //进行实例化操作
  9.     private DatagramSocket socket=null;
  10.     //端口号
  11.     public Test01(int port) throws SocketException {
  12.         socket=new DatagramSocket(port);
  13.     }
  14.     //开启服务器
  15.     public void start() throws IOException {
  16.         System.out.println("开启服务器");
  17.         while (true){
  18.             //1、读取请求并分析
  19.             DatagramPacket requstPacket=new DatagramPacket(new byte[4096],4096);
  20.             socket.receive(requstPacket);
  21.             String reques=new String(requstPacket.getData(),0,
  22.                     requstPacket.getLength()).trim();
  23.             //2、请求数据相应
  24.             String response=process(reques);
  25.             //3、把响应返回给服务器
  26.             DatagramPacket responsePacket=new DatagramPacket(response.getBytes()
  27.                     ,response.getBytes().length,requstPacket.getSocketAddress());
  28.             socket.send(responsePacket);
  30.             //日志
  31.             System.out.printf("[%s:%d] req: %s; resp:%s \n",requstPacket.getAddress().toString(),
  32.                     requstPacket.getPort(),reques,response);
  33.         }
  34.     }
  36.     private String process(String reques) {
  37.         //我们写最简单的服务器回溯
  38.         return reques;
  39.     }
  41.     public static void main(String[] args) throws IOException {
  42.         Test01 test01=new Test01(9090);
  43.         test01.start();
  44.     }
  45. }

2）UDP的客户端

  1. import java.io.IOException;
  2. import java.net.*;
  3. import java.util.Scanner;
  5. public class Test02 {
  6.     // 客户端的主要流程分成四步.
  7.     // 1. 从用户这里读取输入的数据.
  8.     // 2. 构造请求发送给服务器
  9.     // 3. 从服务器读取响应
  10.     // 4. 把响应写回给客户端.
  12.     private DatagramSocket socket = null;
  13.     private String serverIp;
  14.     private int serverPort;
  16.     // 需要在启动客户端的时候来指定需要连接哪个服务器
  17.     public Test02(String serverIp, int serverPort) throws SocketException {
  18.         this.serverIp = serverIp;
  19.         this.serverPort = serverPort;
  20.         socket = new DatagramSocket();
  21.     }
  23.     public void start() throws IOException {
  24.         Scanner scanner = new Scanner(System.in);
  25.         while (true) {
  26.             // 1. 读取用户输入的数据
  27.             System.out.print("-> ");
  28.             String request = scanner.nextLine();
  29.             if (request.equals("exit")) {
  30.                 break;
  31.             }
  32.             // 2. 构造请求发送给服务器
  33.             DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),
  34.                     request.getBytes().length, InetAddress.getByName(serverIp), serverPort);
  35.             socket.send(requestPacket);
  36.             // 3. 从服务器读取响应
  37.             DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
  38.             socket.receive(responsePacket);
  39.             String response = new String(responsePacket.getData(), 0, responsePacket.getLength()).trim();
  40.             // 4. 显示响应数据
  41.             System.out.println(response);
  42.         }
  43.     }
  45.     public static void main(String[] args) throws IOException {
  46.         Test02 client = new Test02("127.0.0.1", 9090);
  47.         // UdpEchoClient client = new UdpEchoClient("47.98.116.42", 9090);
  48.         client.start();
  49.     }
  50. }

2、TCP(面向字节流)

客户端发送的数据是按行读取（\n）

1）服务器

  1. import java.io.*;
  2. import java.net.ServerSocket;
  3. import java.net.Socket;
  4. import java.util.concurrent.ExecutorService;
  5. import java.util.concurrent.Executors;
  7. public class Test05 {
  8.     // 1. 初始化服务器
  9.     // 2. 进入主循环
  10.     //   1) 先去从内核中获取到一个 TCP 的连接
  11.     //   2) 处理这个 TCP 的连接
  12.     //     a) 读取请求并解析
  13.     //     b) 根据请求计算响应
  14.     //     c) 把响应写回给客户端
  15.     private ServerSocket serverSocket=null;
  17.     public Test05(int port) throws IOException {
  18.         //绑定端口号
  19.         serverSocket=new ServerSocket(port);
  20.     }
  22.     public void start() throws IOException {
  23.         System.out.println("服务器启动");
  24.         //创建一个线程池
  25.         ExecutorService executorService= Executors.newCachedThreadPool();
  26.         while(true){
  27.             //先从内核中获取到TCP连接
  28.             Socket clientSocket=serverSocket.accept();
  29.             //处理这个连接
  30.             //我们可以在这个地方加上一个线程池
  31.             executorService.execute(new Runnable() {
  32.                 @Override
  33.                 public void run() {
  34.                     processConnection(clientSocket);
  35.                 }
  36.             });
  37.         }
  38.     }
  40.     private void processConnection(Socket clientSocket) {
  41.         //获取地址和端口
  42.         System.out.printf("[%s:%d] 客户端上线 \n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
  43.         try(BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
  44.             BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream()))){
  45.             //长连接版本服务器
  46.             while(true){
  47.                 //读取
  48.                 String request=bufferedReader.readLine();
  49.                 //处理数据
  50.                 String response=process(request);
  51.                 //将这个返回给客户端
  52.                 bufferedWriter.write(response+"\n");
  53.                 bufferedWriter.flush();
  55.                 //写一个日志
  56.                 System.out.printf("[%s:%d] req:%s,resq:%s\n",clientSocket.getInetAddress().toString()
  57.                         ,clientSocket.getPort(),request,response);
  58.             }
  59.         } catch (IOException e) {
  60.             //e.printStackTrace();
  61.             System.out.printf("[%s:%d] 客户端下线\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
  63.         }
  64.     }
  66.     private String process(String request) {
  67.         return request;
  68.     }
  70.     public static void main(String[] args) throws IOException {
  71.         Test05 test05=new Test05(9090);
  72.         test05.start();
  73.     }
  74. }

2）客户端

  1. import java.io.*;
  2. import java.net.Socket;
  3. import java.util.Scanner;
  5. public class Test04 {
  6.     // 1. 启动客户端(一定不要绑定端口号) 和服务器建立连接
  7.     // 2. 进入主循环
  8.     //  a) 读取用户输入内容
  9.     //  b) 构造一个请求发送给服务器
  10.     //  c) 读取服务器的响应数据
  11.     //  d) 把响应数据显示到界面上.
  12.     private Socket socket=null;
  14.     public Test04(String socketIP,int socketPort) throws IOException {
  15.         socket=new Socket(socketIP,socketPort);
  16.     }
  18.     public void start(){
  19.         System.out.println("启动客户端");
  20.         Scanner scanner=new Scanner(System.in);
  21.         try(BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(socket.getInputStream()));
  22.             BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()))) {
  23.             while(true){
  24.                 System.out.print("-> ");
  25.                 String request=scanner.nextLine();
  26.                 if(request.equals("exit")){
  27.                     break;
  28.                 }
  29.                 //发送给服务器
  30.                 bufferedWriter.write(request+"\n");
  31.                 //刷新 因为写入到缓冲区中并没有写入到内核中
  32.                 bufferedWriter.flush();
  33.                 //读取服务器中的内容
  34.                 String response=bufferedReader.readLine();
  35.                 System.out.println(response);
  36.             }
  37.         } catch (IOException e) {
  38.             e.printStackTrace();
  39.         }
  40.     }
  42.     public static void main(String[] args) throws IOException {
  43.         Test04 test04=new Test04("127.0.0.1",9090);
  44.         test04.start();
  45.     }
  46. }

注意：

bufferedWriter中的write方法可能写到缓冲区中没有写入内核中，需要使用flush方法来进行刷新。

如果要多个客户端可以同时相应我们可以通过一个线程池来控制多个客户端。

三、应用层协议HPPT

hppt和hppts都是应用层协议，应用层协议大多都需要手动指定，hppt协议是基于TCP来实现的。

1、URL

当你打开一个网页的时候,会出现一个网址这个网址就是URL。

url中的服务器的ip来确定是哪一个服务器，

url中的端口号来确定是哪个进程。

url中的path来确定是哪个进程所管理的具体文件。

https://www.baidu.com/s?
cl=3
&tn=baidutop10
&fr=top1000
&wd=%E6%95%B0%E8%AF%BB%E5%8D%81%E4%B9%9D%E5%B1%8A%E5%85%AD%E4%B8%AD%E5%85%A8%E4%BC%9A%E7%B2%BE%E7%A5%9E
&rsv_idx=2
&rsv_dl=fyb_n_homepage
&sa=fyb_n_homepage
&hisfilter=1

这种键值对是特殊约定的事物。

2、抓包（Fiddler）

什么是抓包？我用一张图来描述

fiddler不会对传输数据进行加工和修改，只会讲数据截取下来让用户看到。

HPPT请求：

1）首行： 方法(GET) URL 版本号

2）协议头（header）：若干个键值对用（：）来分割

3）空行：header的结束标记

4）正文（body）：对于get来说为空，对于post来说不为空

HPPT相应：

1）首行： 版本号 状态码 状态码对应的描述信息

2）协议头（header）：若干个键值对用（：）来分割

3）空行：header的结束标记

4）正文（body）：常见的格式为html格式，部分可能存在加密的情况

3、HPPT的方法

** GET和POST的区别？**

GET一般把数据放到url中去

Post一般把数据放到body中去

4、状态码的详解

5、cookie和session的用法

cookie可以将登录认证后的用户信息保存在本地浏览器上，当后面每次发送http请求时，都会附带上这个信息，就不需要每次都重新验证用户。

但是这样明文传输cookie可能会泄密在这个前提下我们引入session来保存数据

在服务器登录成功时，我们把用户保存到一个hash表中，同时生成一个key（sessionid），把sessionid写回到这个cookie中去，当后续访问时，只需要在通过sessionid访问服务器中就行了。

6、基本实现http协议的代码

  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import java.io.InputStreamReader;
  5. import java.util.HashMap;
  6. import java.util.Map;
  8. public class HttpRequset {
  9.     private String method;//方法
  10.     private String url;//url
  11.     private String version;//版本号
  12.     //协议头
  13.     private Map<String,String> headers=new HashMap<>();
  14.     //url中和body中的内容放在这里
  15.     private Map<String,String> parameters=new HashMap<>();
  16.     //cookie中的类容解析
  17.     private Map<String,String> cookies=new HashMap<>();
  19.     private String body;//body
  21.     //用工厂模式来写
  22.     public static HttpRequset build(InputStream inputStream) throws IOException {
  23.         HttpRequset requset=new HttpRequset();
  25.         BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(inputStream));
  27.         //1、解析首行
  28.         String firstline=bufferedReader.readLine();
  29.         String[] fiestlines=firstline.split(" "); //第一行是通过空格来区分的
  30.         requset.method=fiestlines[0];
  31.         requset.url=fiestlines[1];
  32.         requset.version=fiestlines[2];
  33.         //2、将首行中的url中的元素提取出来
  34.         int pre=requset.url.indexOf("?");//如果没有就返回-1
  35.         if(pre!=-1){
  36.             String qureyString=requset.url.substring(pre+1);
  37.             parseKV(qureyString,requset.parameters);
  38.         }
  39.         //3、将headers中的内容解析出来
  40.         String line="";
  41.         while((line=bufferedReader.readLine())!=null && line.getBytes().length!=0){
  42.             String[] lines=line.split(": ");
  43.             requset.headers.put(lines[0],lines[1]);
  44.         }
  45.         //4、解析cookie中的内容
  46.         String cookie=requset.headers.get("Cookie");
  47.         if(cookie!=null){
  48.             parseCookie(cookie,requset.cookies);
  49.         }
  50.         //5、body中的内容
  51.         if("POST".equalsIgnoreCase(requset.method) || "PUT".equalsIgnoreCase(requset.method)){
  52.             //我们首先要知道body的长度
  53.             int length=Integer.parseInt(requset.headers.get("Content-Length"));
  54.             //建立一个缓冲区
  55.             char[] buffer=new char[length];
  56.             int len=bufferedReader.read(buffer);
  57.             requset.body=new String(buffer,0,len);
  59.             parseKV(requset.body,requset.parameters);
  60.         }
  62.         return requset;
  63.     }
  65.     private static void parseCookie(String cookie, Map<String, String> cookies) {
  66.         String[] line=cookie.split("; ");
  67.         for(String s:line){
  68.             String[] lines=s.split("=");
  69.             cookies.put(lines[0],lines[1]);
  70.         }
  71.     }
  73.     private static void parseKV(String qureyString, Map<String, String> parameters) {
  74.         String[] line=qureyString.split("&");
  75.         for (String s:line){
  76.             String[] lines=s.split("=");
  77.             parameters.put(lines[0],lines[1]);
  78.         }
  79.     }
  81.     public String getMethod() {
  82.         return method;
  83.     }
  85.     public String getUrl() {
  86.         return url;
  87.     }
  89.     public String getVersion() {
  90.         return version;
  91.     }
  93.     public String getBody() {
  94.         return body;
  95.     }
  97.     public String getHeaders(String key){
  98.         return headers.get(key);
  99.     }
  101.     public String getParameters(String key){
  102.         return parameters.get(key);
  103.     }
  105.     public String getCooies(String key){
  106.         return cookies.get(key);
  107.     }
  108. }
  1. import java.io.BufferedWriter;
  2. import java.io.IOException;
  3. import java.io.OutputStream;
  4. import java.io.OutputStreamWriter;
  5. import java.util.HashMap;
  6. import java.util.Map;
  8. public class HttpResponse {
  9.     private String version="HTTP/1.1";//版本号
  10.     private int status;//验证信息
  11.     private String message;//状态信息
  12.     //header中的内容
  13.     private Map<String,String> headers=new HashMap<>();
  14.     //body中的内容
  15.     private StringBuffer body=new StringBuffer();
  16.     private OutputStream outputStream=null;
  17.     //工厂模式
  18.     public static HttpResponse build(OutputStream outputStream){
  19.         HttpResponse response=new HttpResponse();
  20.         response.outputStream=outputStream;
  21.         return response;
  22.     }
  24.     public void setVersion(String version) {
  25.         this.version = version;
  26.     }
  28.     public void setStatus(int status) {
  29.         this.status = status;
  30.     }
  32.     public void setMessage(String message) {
  33.         this.message = message;
  34.     }
  36.     public void setHeaders(String key,String value){
  37.         this.headers.put(key,value);
  38.     }
  40.     public void setBody(String val){
  41.         this.body.append(val);
  42.     }
  44.     public void fush() throws IOException {
  45.         BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(outputStream));
  46.         //写第一行
  47.         bufferedWriter.write(version+" "+status+" "+message+"\n");
  48.         //将文件信息放入header中写入
  49.         headers.put("Content-Length",body.toString().getBytes().length+"");
  50.         //将header中的类容写入
  51.         for(Map.Entry<String,String> entry:headers.entrySet()){
  52.             bufferedWriter.write(entry.getKey()+": "+entry.getValue()+"\n");
  53.         }
  54.         //
  55.         bufferedWriter.write("\n");
  56.         //将body中的数据放入
  57.         bufferedWriter.write(body.toString());
  58.         //将数据刷新
  59.         bufferedWriter.flush();
  60.     }
  61. }
  1. <html>
  2. <head>
  3.     <meta charset="utf-8">
  4. </head>
  5. <body>
  6. <form method="post" action="/login">
  7.     <div style="margin-bottom: 5px">
  8.         <input type="text" name="username" placeholder="请输入姓名">
  9.     </div>
  10.     <div style="margin-bottom: 5px">
  11.         <input type="text" name="password" placeholder="请输入密码">
  12.     </div>
  13.     <div>
  14.         <input type="submit" value="登录">
  15.     </div>
  16. </form>
  17. </body>
  18. </html>
  1. import Test05.HttpServerV3;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.InputStreamReader;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;
  9. import java.util.HashMap;
  10. import java.util.Map;
  11. import java.util.UUID;
  12. import java.util.concurrent.ExecutorService;
  13. import java.util.concurrent.Executors;
  15. public class HttpServerV4 {
  16.     static class User{
  17.         //保存的相关信息
  18.         public String userName;
  19.         public int age;
  20.         public String school;
  21.     }
  22.     private ServerSocket socket=null;
  24.     //我们通过session会话
  25.     private Map<String,User> session=new HashMap<>();
  27.     public HttpServerV4(int port) throws IOException {
  28.         this.socket = new ServerSocket(port);
  29.     }
  31.     public void start() throws IOException {
  32.         System.out.println("系统启动");
  33.         ExecutorService executorService= Executors.newCachedThreadPool();
  34.         while(true){
  35.             Socket cliensocket=socket.accept();
  36.             executorService.execute(new Runnable() {
  37.                 @Override
  38.                 public void run() {
  39.                     process(cliensocket);
  40.                 }
  41.             });
  42.         }
  43.     }
  45.     private void process(Socket cliensocket) {
  46.         try {
  47.             //读取请求
  48.             HttpResponse response=HttpResponse.build(cliensocket.getOutputStream());
  49.             HttpRequset requset=HttpRequset.build(cliensocket.getInputStream());
  51.             //response.setHeaders("Set-Cookie","YYX=qwe");
  52.             //计算相应
  53.             if("GET".equalsIgnoreCase(requset.getMethod())){
  54.                 doGet(requset,response);
  55.             }else if("Post".equalsIgnoreCase(requset.getMethod())){
  56.                 doPost(requset,response);
  57.             }else{
  58.                 response.setStatus(405);
  59.                 response.setMessage("Method Not Allowed");
  60.             }
  61.             //写入
  62.             response.fush();
  63.         } catch (IOException e) {
  64.             e.printStackTrace();
  65.         }finally {
  66.             try {
  67.                 cliensocket.close();
  68.             } catch (IOException e) {
  69.                 e.printStackTrace();
  70.             }
  71.         }
  72.     }
  74.     private void doPost(HttpRequset requset, HttpResponse response) {
  75.         //2\
  76.         if(requset.getUrl().startsWith("/login")){
  77.             String user=requset.getParameters("username");
  78.             String pass=requset.getParameters("password");
  79.             /*System.out.println(user+":"+pass);*/
  80.             if("yyx".equals(user) && "2001".equals(pass)){
  81.                 //通过
  83.                 response.setStatus(403);
  84.                 response.setMessage("Forbidden");
  85.                 //要写不然返回的不是utf-8的编码格式
  86.                 response.setHeaders("Content-Type","text/html; charset=utf-8");
  88.                 //response.setHeaders("Set-Cookie","userName=YYX");
  90.                 String sessionId= UUID.randomUUID().toString();
  91.                 User user01=new User();
  92.                 user01.userName="杨亚轩";
  93.                 user01.age=18;
  94.                 user01.school="武昌工学院";
  95.                 session.put(sessionId,user01);
  96.                 response.setHeaders("Set-Cookie","sessionId="+sessionId);
  98.                 response.setBody("<html>");
  99.                 response.setBody("验证成功！");
  100.                 response.setBody("</html>");
  101.             }else {
  102.                 //没有通过
  103.                 response.setStatus(403);
  104.                 response.setMessage("Forbidden");
  105.                 //要写不然返回的不是utf-8的编码格式
  106.                 response.setHeaders("Content-Type","text/html; charset=utf-8");
  107.                 response.setBody("<html>");
  108.                 response.setBody("验证失败！");
  109.                 response.setBody("</html>");
  110.             }
  111.         }
  113.     }
  115.     private void doGet(HttpRequset requset, HttpResponse response) throws IOException {
  116.         //1\
  117.         if(requset.getUrl().startsWith("/index.html")){
  118.             String sessionId=requset.getCooies("sessionId");
  119.             User user=session.get(sessionId);
  120.             if (sessionId==null || user==null) {
  121.                 //当前情况下用户没有登录
  122.                 response.setStatus(200);
  123.                 response.setMessage("OK");
  124.                 response.setHeaders("Content-Type","text/html; charset=utf-8");
  125.                 InputStream inputStream=HttpServerV3.class.getClassLoader().getResourceAsStream("index.html");
  126.                 BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(inputStream));
  128.                 String str="";
  129.                 while((str=bufferedReader.readLine())!=null){
  130.                     response.setBody(str+"\n");
  131.                 }
  132.                 bufferedReader.close();
  133.             }else{
  134.                 //已经登录就不需要再登录的
  135.                 response.setStatus(200);
  136.                 response.setMessage("OK");
  137.                 response.setHeaders("Content-Type","text/html; charset=utf-8");
  138.                 response.setBody("<html>");
  139.                 response.setBody("该用户已经登录了");
  140.                 response.setBody("</html>");
  141.             }
  142.         }
  143.     }
  145.     public static void main(String[] args) throws IOException {
  146.         HttpServerV4 httpServerV4=new HttpServerV4(9090);
  147.         httpServerV4.start();
  148.     }
  149. }

一个进程可以bind多个端口号

但是一个端口号不能被多个进程bind

四、传输层协议TCP和UDP

1、UDP协议的理解

对于UDP来说它有三个非常重要的特性

1）无连接（不需要建立连接就可以通信）

2）不可靠（接收方是否接受到消息发送方不知道）

3）面向数据报（以DatagramPacket为单位进行传输）

UDP的协议格式：

2、TCP传输协议

对于TCP来说它有三个非常重要的特性

1）有连接（需要建立连接就可以通信）

2）可靠（接收方是否接受到消息发送方知道）

3）面向字节流

TCP的协议格式：

TCP的报头是变长（报头长度在4的基础上*4）

3、TCP的十个特性

1、确认应答（核心）

当主机a向主机B发送数据的时候，主机B会向主机a发送一种应答报文ack，当主机a接收到由主机B发来的ack时，那么就能确定主机a发送过去的数据被主机B接收。

当主机a发送的数据为1到100时，那么主机B返回的确认应答为101，接下来数据就要从101开始发送。

2、超时重传

确认应答是比较理想的情况，数据在传输过程中有很大的概率丢包。

当出现丢包状况时有两种可能，第1种就是主机a发送的请求丢失，第2种情况就是主机B发送的ack丢失，当发送一条数据后，TCP内部就会自动生成一个定时器，当一定的时间没有收到ack，那么就会触发定时器触发重传。如果是ack丢了，那么TCP会在内部进行数据去重。

3、连接管理

a）建立连接（三次握手）

三次握手涉及到SYN同步报文段当主机a发送SYN同步报文段，尝试与主机B发生连接，当主机B收到，来自主机a的SYN后，会向主机a发送SYN和ACK。当主机A收到，来自主机B的数据后，会向主机B发送一个ACK。

注意：

如果三次握手仅只握两次，那么有一方接收不到信号就不能正常工作。如果三次握手握手四次，可以但是会降低传输效率。

几个重要的状态：

LISTEN：表示服务器已经准备好了，可以接受客户端的消息了。

SYN-SEND/SYN-RCVD: 建立连接的中间过程，如果建立连接顺利这两个状态一瞬间就会消失。

ESTABLISHED:连接建立完成验证的双方都有发送和接收能力，这时就可以开始传输正文了。

b）断开连接（四次挥手）

四次挥手主机A向主机B发送FIN，主机B收到由主机A发来的FIN后就会立即发送ACK，当应用程序代码处理完积压的数据后，主机B才会发送FIN给主机A，主机A接收到由主机B发来的信息返回ACK。

注意：

当出现延时应答时，四次挥手就会变成三次挥手。

CLOSE_WAIT：四次挥手挥到一半就不挥了，主要原因是因为接受方没有调用close方法，会导致4次挥手只回了两次而没有正确的关闭连接。

TIME_WAIT：谁主动断开连接，谁就会进入这个状态。这时主机已经完成了4次挥手的过程，但是不能立即释放连接要等待一段时间之后。再彻底释放连接。

4、滑动窗口

滑动窗口的本质是节省了时间，当窗口为n时，n份数据传输的时间变成了一份时间，n份应答的时间也重叠成一份时间。

当滑动窗口出现丢包问题时间：

1）ACK丢了

出现这种情况不需要进行处理，当接收方接受到6001时，就会自动默认前面的数据发送过来，这时窗口直接滑动。

2）数据丢失

这种情况下，接下来发送的ACK都会是丢失的那个数据的开始，当收到三个后开始重传，成功后ACK就变成相应的，窗口向后滑动。

5、流量控制

窗口不能无线大，传输速率过快会让接收方处理不来，当处理方没有空间时，就会停止发送，这时主机a就会发送一个窗口探测，通过主机B的不断更新，从而得知主机a是否继续发送数据。

流量控制本质上就是根据接收方的处理能力来反向横置发送能力。根据接受缓冲区的剩余空间大小，来约制发送方的滑动窗口大小。

6、拥塞控制

拥塞控制是在不断变化的，最终的窗口大小取决于拥塞窗口和流量控制窗口的最小值。

可以根据网络状态进行及时的调整。

7、延时应答

目的是在流量控制的基础上，返回一个合理但是比较大的窗口。

**延时应答就是让ack延时发送一点（延时应答的时间不回超过超时重传的时间） **

8、捎带应答

ACK和Resp本来不能同时相应，但是由于捎带应答就可以把两个操作合并。

**9、粘包问题 **

当数据进行读取的时候，读取的内容可能和想象的内容有差异，面向字节流传输都会出现这个问题。

解决方法：

我们通过应用层协议本身来区分出包和包之间的边界。（使用分割符、明确包的长度）

10、保活机制

1、进程崩溃时，TCP连接就会进行正常的四次挥手。

2、主机关机时，关机会强制杀死进程，杀死进程就是四次挥手。

3、主机断电：

a）接收方断电，对端尝试发送消息ACK没有接受（超时重传，到达一定次数重置连接，放弃连接）

b）发送方断电，对端尝试接受消息（在空闲时间会传输心跳包，当心跳包没有相应就会自动放弃）

4、TCP和UDP之间的对比

1、TCP适用于要求可靠性的场景。（外网通信网络环境复杂的地方，udp丢包概率大，可以考虑TCP）。

2、Udp适用于对于可靠性要求没有那么高，但是需要很高的传输效率的场景，如机房等地方。

3、Udp能够实现广播，但是TCP只能1对1进行传输。

4、对于游戏这种领域，udp和TCP都不能传输。、

五、网络层传输协议IP

网络层解决两个问题：（地址管理和路由选择）

报头长度是在改变的。（不需要手动分包）

4位版本号(version): 指定IP协议的版本, 对于IPv4来说, 就是4.
4位头部长度(header length): IP头部的长度是多少个32bit, 也就是 length * 4 的字节数. 4bit表示最大的数字是15, 因此IP头部最大长度是60字节.
8位服务类型(Type Of Service): 3位优先权字段(已经弃用), 4位TOS字段, 和1位保留字段(必须置为0). 4位TOS分别表示: 最小延时, 最大吞吐量, 最高可靠性, 最小成本. 这四者相互冲突, 只能选择一个. 对于ssh/telnet这样的应用程序, 最小延时比较重要; 对于ftp这样的程序, 最大吞吐量比较重要.
16位总长度(total length): IP数据报整体占多少个字节.
16位标识(id): 唯一的标识主机发送的报文. 如果IP报文在数据链路层被分片了, 那么每一个片里面的这个id都是相同的.
3位标志字段: 第一位保留(保留的意思是现在不用, 但是还没想好说不定以后要用到). 第二位置为1表示禁止分片, 这时候如果报文长度超过MTU, IP模块就会丢弃报文. 第三位表示"更多分片", 如果分片了的话, 最后一个分片置为1, 其他是0. 类似于一个结束标记.
13位分片偏移(framegament offset): 是分片相对于原始IP报文开始处的偏移. 其实就是在表示当前分片在原报文中处在哪个位置. 实际偏移的字节数是这个值 * 8 得到的. 因此, 除了最后一个报文之外, 其他报文的长度必须是8的整数倍(否则报文就不连续了).
8位生存时间(Time To Live, TTL): 数据报到达目的地的最大报文跳数. 一般是64. 每次经过一个路由, TTL -=1, 一直减到0还没到达, 那么就丢弃了. 这个字段主要是用来防止出现路由循环
8位协议: 表示上层协议的类型
16位头部校验和: 使用CRC进行校验, 来鉴别头部是否损坏.
32位源地址和32位目标地址: 表示发送端和接收端

1、地址管理

地址管理就是给每个主机一个单独的身份标识。

我们有两种方法：

1）动态分配IP地址：联网就分配不联网就不分配。

2）NAT机制，网络转换机制，允许局域网中的IP地址可以重复，使用一个外网IP来代表同一批局域网内部设备，一般由路由器负责。

** 在局域网内我们通过端口号来区分。**

2、网段划分

网段划分就是将一个IP地址划分成网络号和主机号两个部分。

1、同一个局域网内部的设备，网络号相同主机号不同

2、两个相邻的局域网，网络号不能相同。

1）将IP地址划分成ABCDEF五给类别。

** 2、使用子网掩码的方法来划分。**

子网掩码和IP地址按位与就可以得到网络号

例如：

IPV4地址：192.168.0.16 子网掩码：255.255.255.0

网络号：192.168.0.0

相邻两个局域网之间的网络号是不一样的

主机号为.1的叫做网关，也就是当前局域网的路由器

局域网内部IP：

*10.，前八位是网络号

172.16.~172.31.，前12位是网络号

192.168.*,前16位是网络号

这些IP称为私有IP，其他的称为全局IP。

3、路由选择

当一个包从我的电脑出发，他会首先查看我的电脑认不认识这个目的IP，如果不认识就会发给我电脑所连接的路由器，有我电脑连接的路由器，认不认识这个目的IP如果认识就会传输过去，如果不认识再把数据交给光猫，如果光猫也不认识，那么就会继续交给上级路由器。

路由表：（和上面所说的差不多）

当有一个IP数据达到路由器的时候，路由器就会检查，看目的IP所属的网站在路由表中有哪些对应的选项，如果没有就会走默认选项。

目的IP & 子网掩码再路由表中查找。

六、数据链路层和应用层（以太网协议和DNS协议）

1、以太网协议

数据链路层负责两个相邻设备之间的传输

以太网协议覆盖了数据链路层和物理层。

**面试常见： **

已经有IP的情况下为什么还有MAC地址？

1、源mac会随着设备的不同而改变而源IP不会变

2、mac地址和IP地址是独立发明从来的

2、DNS协议

DNS协议是一套系统（由于IP地址不好记，DNS系统会将域名自动翻译成IP地址）

浏览器的请求可能直接达到cdn服务器就直接返回了。当cdn服务器上没有时，就会在反向代理服务器缓存中查找，如果反向代理服务器中也没有，就需要访问百度的应用服务器。

2022.1.1 新的一年祝大家越来越好哈哈哈哈！！！！

标签： 网络 java 网络协议
本文转载自: https://blog.csdn.net/ashfiqa/article/details/122253751
版权归原作者 now just do it 所有， 如有侵权，请联系我们删除。
登录后发布评论

“JAVA 网络编程”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？