一、網路通信協議

1、概述

2、為什么協議要分層？

3、對于參考模型的介紹

4、TCP網路傳輸的基本流程

二、網路編程套接字（socket）

1、UDP(面向資料報)

2、TCP(面向位元組流)

三、應用層協議HPPT

1、URL

2、抓包（Fiddler）

3、HPPT的方法

4、狀態碼的詳解

5、cookie和session的用法

6、基本實作http協議的代碼

四、傳輸層協議TCP和UDP

1、UDP協議的理解

2、TCP傳輸協議

3、TCP的十個特性

4、TCP和UDP之間的對比

五、網路層傳輸協議IP

1、地址管理

2、網段劃分

3、路由選擇

六、資料鏈路層和應用層（以太網協議和DNS協議）

1、以太網協議

2、DNS協議

一、網路通信協議

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的服務器

//UDP的服務器
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class Test01 {
    //進行實體化操作
    private DatagramSocket socket=null;
    //埠號
    public Test01(int port) throws SocketException {
        socket=new DatagramSocket(port);
    }
    //開啟服務器
    public void start() throws IOException {
        System.out.println("開啟服務器");
        while (true){
            //1、讀取請求并分析
            DatagramPacket requstPacket=new DatagramPacket(new byte[4096],4096);
            socket.receive(requstPacket);
            String reques=new String(requstPacket.getData(),0,
                    requstPacket.getLength()).trim();
            //2、請求資料相應
            String response=process(reques);
            //3、把回應回傳給服務器
            DatagramPacket responsePacket=new DatagramPacket(response.getBytes()
                    ,response.getBytes().length,requstPacket.getSocketAddress());
            socket.send(responsePacket);

            //日志
            System.out.printf("[%s:%d] req: %s; resp:%s \n",requstPacket.getAddress().toString(),
                    requstPacket.getPort(),reques,response);
        }
    }

    private String process(String reques) {
        //我們寫最簡單的服務器回溯
        return reques;
    }

    public static void main(String[] args) throws IOException {
        Test01 test01=new Test01(9090);
        test01.start();
    }
}

2）UDP的客戶端

import java.io.IOException;
import java.net.*;
import java.util.Scanner;

public class Test02 {
    // 客戶端的主要流程分成四步.
    // 1. 從用戶這里讀取輸入的資料.
    // 2. 構造請求發送給服務器
    // 3. 從服務器讀取回應
    // 4. 把回應寫回給客戶端.

    private DatagramSocket socket = null;
    private String serverIp;
    private int serverPort;

    // 需要在啟動客戶端的時候來指定需要連接哪個服務器
    public Test02(String serverIp, int serverPort) throws SocketException {
        this.serverIp = serverIp;
        this.serverPort = serverPort;
        socket = new DatagramSocket();
    }

    public void start() throws IOException {
        Scanner scanner = new Scanner(System.in);
        while (true) {
            // 1. 讀取用戶輸入的資料
            System.out.print("-> ");
            String request = scanner.nextLine();
            if (request.equals("exit")) {
                break;
            }
            // 2. 構造請求發送給服務器
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),
                    request.getBytes().length, InetAddress.getByName(serverIp), serverPort);
            socket.send(requestPacket);
            // 3. 從服務器讀取回應
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(), 0, responsePacket.getLength()).trim();
            // 4. 顯示回應資料
            System.out.println(response);
        }
    }

    public static void main(String[] args) throws IOException {
        Test02 client = new Test02("127.0.0.1", 9090);
        // UdpEchoClient client = new UdpEchoClient("47.98.116.42", 9090);
        client.start();
    }
}

2、TCP(面向位元組流)

客戶端發送的資料是按行讀取（\n）

1）服務器

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test05 {
    // 1. 初始化服務器
    // 2. 進入主回圈
    //   1) 先去從內核中獲取到一個 TCP 的連接
    //   2) 處理這個 TCP 的連接
    //     a) 讀取請求并決議
    //     b) 根據請求計算回應
    //     c) 把回應寫回給客戶端
    private ServerSocket serverSocket=null;

    public Test05(int port) throws IOException {
        //系結埠號
        serverSocket=new ServerSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服務器啟動");
        //創建一個執行緒池
        ExecutorService executorService= Executors.newCachedThreadPool();
        while(true){
            //先從內核中獲取到TCP連接
            Socket clientSocket=serverSocket.accept();
            //處理這個連接
            //我們可以在這個地方加上一個執行緒池
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    processConnection(clientSocket);
                }
            });
        }
    }

    private void processConnection(Socket clientSocket) {
        //獲取地址和埠
        System.out.printf("[%s:%d] 客戶端上線 \n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
        try(BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream()))){
            //長連接版本服務器
            while(true){
                //讀取
                String request=bufferedReader.readLine();
                //處理資料
                String response=process(request);
                //將這個回傳給客戶端
                bufferedWriter.write(response+"\n");
                bufferedWriter.flush();

                //寫一個日志
                System.out.printf("[%s:%d] req:%s,resq:%s\n",clientSocket.getInetAddress().toString()
                        ,clientSocket.getPort(),request,response);
            }
        } catch (IOException e) {
            //e.printStackTrace();
            System.out.printf("[%s:%d] 客戶端下線\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());

        }
    }

    private String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        Test05 test05=new Test05(9090);
        test05.start();
    }
}

2）客戶端

import java.io.*;
import java.net.Socket;
import java.util.Scanner;

public class Test04 {
    // 1. 啟動客戶端(一定不要系結埠號) 和服務器建立連接
    // 2. 進入主回圈
    //  a) 讀取用戶輸入內容
    //  b) 構造一個請求發送給服務器
    //  c) 讀取服務器的回應資料
    //  d) 把回應資料顯示到界面上.
    private Socket socket=null;

    public Test04(String socketIP,int socketPort) throws IOException {
        socket=new Socket(socketIP,socketPort);
    }

    public void start(){
        System.out.println("啟動客戶端");
        Scanner scanner=new Scanner(System.in);
        try(BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(socket.getInputStream()));
            BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()))) {
            while(true){
                System.out.print("-> ");
                String request=scanner.nextLine();
                if(request.equals("exit")){
                    break;
                }
                //發送給服務器
                bufferedWriter.write(request+"\n");
                //重繪 因為寫入到緩沖區中并沒有寫入到內核中
                bufferedWriter.flush();
                //讀取服務器中的內容
                String response=bufferedReader.readLine();
                System.out.println(response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws IOException {
        Test04 test04=new Test04("127.0.0.1",9090);
        test04.start();
    }
}

注意：

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協議的代碼

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 HttpRequset {
    private String method;//方法
    private String url;//url
    private String version;//版本號
    //協議頭
    private Map<String,String> headers=new HashMap<>();
    //url中和body中的內容放在這里
    private Map<String,String> parameters=new HashMap<>();
    //cookie中的類容決議
    private Map<String,String> cookies=new HashMap<>();

    private String body;//body

    //用工廠模式來寫
    public static HttpRequset build(InputStream inputStream) throws IOException {
        HttpRequset requset=new HttpRequset();

        BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(inputStream));

        //1、決議首行
        String firstline=bufferedReader.readLine();
        String[] fiestlines=firstline.split(" "); //第一行是通過空格來區分的
        requset.method=fiestlines[0];
        requset.url=fiestlines[1];
        requset.version=fiestlines[2];
        //2、將首行中的url中的元素提取出來
        int pre=requset.url.indexOf("?");//如果沒有就回傳-1
        if(pre!=-1){
            String qureyString=requset.url.substring(pre+1);
            parseKV(qureyString,requset.parameters);
        }
        //3、將headers中的內容決議出來
        String line="";
        while((line=bufferedReader.readLine())!=null && line.getBytes().length!=0){
            String[] lines=line.split(": ");
            requset.headers.put(lines[0],lines[1]);
        }
        //4、決議cookie中的內容
        String cookie=requset.headers.get("Cookie");
        if(cookie!=null){
            parseCookie(cookie,requset.cookies);
        }
        //5、body中的內容
        if("POST".equalsIgnoreCase(requset.method) || "PUT".equalsIgnoreCase(requset.method)){
            //我們首先要知道body的長度
            int length=Integer.parseInt(requset.headers.get("Content-Length"));
            //建立一個緩沖區
            char[] buffer=new char[length];
            int len=bufferedReader.read(buffer);
            requset.body=new String(buffer,0,len);

            parseKV(requset.body,requset.parameters);
        }

        return requset;
    }

    private static void parseCookie(String cookie, Map<String, String> cookies) {
        String[] line=cookie.split("; ");
        for(String s:line){
            String[] lines=s.split("=");
            cookies.put(lines[0],lines[1]);
        }
    }

    private static void parseKV(String qureyString, Map<String, String> parameters) {
        String[] line=qureyString.split("&");
        for (String s:line){
            String[] lines=s.split("=");
            parameters.put(lines[0],lines[1]);
        }
    }

    public String getMethod() {
        return method;
    }

    public String getUrl() {
        return url;
    }

    public String getVersion() {
        return version;
    }

    public String getBody() {
        return body;
    }

    public String getHeaders(String key){
        return headers.get(key);
    }

    public String getParameters(String key){
        return parameters.get(key);
    }

    public String getCooies(String key){
        return cookies.get(key);
    }
}

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;//狀態資訊
    //header中的內容
    private Map<String,String> headers=new HashMap<>();
    //body中的內容
    private StringBuffer body=new StringBuffer();
    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){
        this.headers.put(key,value);
    }

    public void setBody(String val){
        this.body.append(val);
    }

    public void fush() throws IOException {
        BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(outputStream));
        //寫第一行
        bufferedWriter.write(version+" "+status+" "+message+"\n");
        //將檔案資訊放入header中寫入
        headers.put("Content-Length",body.toString().getBytes().length+"");
        //將header中的類容寫入
        for(Map.Entry<String,String> entry:headers.entrySet()){
            bufferedWriter.write(entry.getKey()+": "+entry.getValue()+"\n");
        }
        //
        bufferedWriter.write("\n");
        //將body中的資料放入
        bufferedWriter.write(body.toString());
        //將資料重繪
        bufferedWriter.flush();
    }
}

<html>
<head>
    <meta charset="utf-8">
</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="text" name="password" placeholder="請輸入密碼">
    </div>
    <div>
        <input type="submit" value="登錄">
    </div>
</form>
</body>
</html>

import Test05.HttpServerV3;

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.Map;
import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class HttpServerV4 {
    static class User{
        //保存的相關資訊
        public String userName;
        public int age;
        public String school;
    }
    private ServerSocket socket=null;

    //我們通過session會話
    private Map<String,User> session=new HashMap<>();

    public HttpServerV4(int port) throws IOException {
        this.socket = new ServerSocket(port);
    }

    public void start() throws IOException {
        System.out.println("系統啟動");
        ExecutorService executorService= Executors.newCachedThreadPool();
        while(true){
            Socket cliensocket=socket.accept();
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    process(cliensocket);
                }
            });
        }
    }

    private void process(Socket cliensocket) {
        try {
            //讀取請求
            HttpResponse response=HttpResponse.build(cliensocket.getOutputStream());
            HttpRequset requset=HttpRequset.build(cliensocket.getInputStream());

            //response.setHeaders("Set-Cookie","YYX=qwe");
            //計算相應
            if("GET".equalsIgnoreCase(requset.getMethod())){
                doGet(requset,response);
            }else if("Post".equalsIgnoreCase(requset.getMethod())){
                doPost(requset,response);
            }else{
                response.setStatus(405);
                response.setMessage("Method Not Allowed");
            }
            //寫入
            response.fush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                cliensocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private void doPost(HttpRequset requset, HttpResponse response) {
        //2\
        if(requset.getUrl().startsWith("/login")){
            String user=requset.getParameters("username");
            String pass=requset.getParameters("password");
            /*System.out.println(user+":"+pass);*/
            if("yyx".equals(user) && "2001".equals(pass)){
                //通過

                response.setStatus(403);
                response.setMessage("Forbidden");
                //要寫不然回傳的不是utf-8的編碼格式
                response.setHeaders("Content-Type","text/html; charset=utf-8");

                //response.setHeaders("Set-Cookie","userName=YYX");

                String sessionId= UUID.randomUUID().toString();
                User user01=new User();
                user01.userName="楊亞軒";
                user01.age=18;
                user01.school="武昌工學院";
                session.put(sessionId,user01);
                response.setHeaders("Set-Cookie","sessionId="+sessionId);

                response.setBody("<html>");
                response.setBody("驗證成功！");
                response.setBody("</html>");
            }else {
                //沒有通過
                response.setStatus(403);
                response.setMessage("Forbidden");
                //要寫不然回傳的不是utf-8的編碼格式
                response.setHeaders("Content-Type","text/html; charset=utf-8");
                response.setBody("<html>");
                response.setBody("驗證失敗！");
                response.setBody("</html>");
            }
        }

    }

    private void doGet(HttpRequset requset, HttpResponse response) throws IOException {
        //1\
        if(requset.getUrl().startsWith("/index.html")){
            String sessionId=requset.getCooies("sessionId");
            User user=session.get(sessionId);
            if (sessionId==null || user==null) {
                //當前情況下用戶沒有登錄
                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));

                String str="";
                while((str=bufferedReader.readLine())!=null){
                    response.setBody(str+"\n");
                }
                bufferedReader.close();
            }else{
                //已經登錄就不需要再登錄的
                response.setStatus(200);
                response.setMessage("OK");
                response.setHeaders("Content-Type","text/html; charset=utf-8");
                response.setBody("<html>");
                response.setBody("該用戶已經登錄了");
                response.setBody("</html>");
            }
        }
    }

    public static void main(String[] args) throws IOException {
        HttpServerV4 httpServerV4=new HttpServerV4(9090);
        httpServerV4.start();
    }
}

一個行程可以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 新的一年祝大家越來越好哈哈哈哈！！！！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/400552.html

標籤：java

上一篇：我的2021年總結，從大專生到本科生。

下一篇：MySQL 事務

JAVA 網路編程

一、網路通信協議

1、概述

2、為什么協議要分層？

3、對于參考模型的介紹

4、TCP網路傳輸的基本流程

二、網路編程套接字（socket）

1、UDP(面向資料報)

2、TCP(面向位元組流)

三、應用層協議HPPT

1、URL

2、抓包（Fiddler）

3、HPPT的方法

4、狀態碼的詳解

5、cookie和session的用法

6、基本實作http協議的代碼

四、傳輸層協議TCP和UDP

1、UDP協議的理解

2、TCP傳輸協議

3、TCP的十個特性

4、TCP和UDP之間的對比

五、網路層傳輸協議IP

1、地址管理

2、網段劃分

3、路由選擇

六、資料鏈路層和應用層（以太網協議和DNS協議）

1、以太網協議

2、DNS協議