【JAVA基础之网络编程】UDP和TCP协议以及三次握手和四次挥手的过程

🔥作者主页 ：小林同学的学习笔录

🔥mysql专栏 ：小林同学的专栏

目录

[1. 网络编程](#1. 网络编程)

[1.1 概述](#1.1 概述)

[1.2 网络编程的三要素](#1.2 网络编程的三要素)

[1.2.1 IP地址](#1.2.1 IP地址)

[1.2.2 InetAddress](#1.2.2 InetAddress)

[1.2.3 端口和协议](#1.2.3 端口和协议)

[1.3 UDP协议](#1.3 UDP协议)

[1.3.1 UDP发送数据](#1.3.1 UDP发送数据)

[1.3.2 UDP接收数据](#1.3.2 UDP接收数据)

[1.4 TCP协议](#1.4 TCP协议)

[1.4.1 TCP协议实例](#1.4.1 TCP协议实例)

[1.4.2 三次握手，四次挥手](#1.4.2 三次握手，四次挥手)

---

1. 网络编程

1.1 概述

概述：在网络通信协议下，不同计算机上运行的程序，进行数据的传输

java.net包中可以看见常见的网络应用程序API

常见的软件架构：

C/S：Client / Server 客户端 / 服务器

• 需要用户下载并安装客户端程序，在远程有一个服务器程序
• 优缺点：
  • 画面可以做的比较精美，用户体验好(不需要网络传输，数据来源于安装包)
  • 需要开发客户端，也需要开发服务端
  • 用户需要下载和更新的时候太麻烦

B/S：Browser / Server 浏览器 / 服务器

• 只需要一个浏览器，通过访问不同的网址实现操作程序，客户访问不同的服务器
• 优缺点：
  • 不需要开发客户端，只需要页面 + 服务器
  • 用户不需要下载，打开浏览器就能使用
  • 如果应用过大，用户体验将受到影响(因为数据进行网络传输效率比较低)

1.2 网络编程的三要素

IP：设备在网络中的地址，是唯一标识

端口号：应用程序在设备中的唯一标识

协议：数据在网络中的传输规则，常见的协议有UDP，TCP，HTTP，HTTPS，FTP

1.2.1 IP地址

IP地址分为两大类：

• IPv4：是给每个连接在网络上的主机分配一个32bit地址。按照TCP/IP规定，IP地址用二进制来表示，每个IP地址长32bit，也就是4个字节。例如一个采用二进制形式的IP地址是"11000000 10101000 00000001 01000010"，这么长的地址，处理起来也太费劲了。为了方便使用，IP地址经常被写成十进制的形式，中间使用符号"."分隔不同的字节。于是，上面的IP地址可以表示为"192.168.1.66"。IP地址的这种表示法叫做"点分十进制表示法"，这显然比1和0容易记忆得多，最多有2^32次方个IP

• IPv6：由于互联网的蓬勃发展，IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发紧张。为了扩大地址空间，通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制数，每一组用分号隔开，这样就解决了网络地址资源数量不够的问题，最多有2^128次方个IP、

DOS常用命令：

• ipconfig：查看本机IP地址

• ping IP地址：检查网络与目标主机是否能连通

特殊IP地址：

• 127.0.0.1：是回送地址，可以代表本机地址LocalHost，一般用来测试使用

疑问：假设192.168.1.100是我的电脑IP，那么这个IP跟127.0.0.1是一样吗？

不一样，192.168.1.100和127.0.0.1不是一样的IP地址。192.168.1.100是局域网内的私有IP地址，用于在局域网中标识设备。而127.0.0.1是本地回环地址，用于在同一台设备内部进行通信。当你的计算机尝试连接127.0.0.1时，它实际上是在尝试与自己通信，而不是与网络上的其他设备通信。
疑问：公网地址(万维网使用)和私有地址(局域网使用)的区别？

公网地址和私有地址之间的主要区别在于它们的可访问性和范围。公网地址是全球唯一的IP地址，用于在互联网上唯一标识设备和进行通信。私有地址则是在局域网内使用的地址，不会在互联网上进行路由，因此不能直接从互联网上访问。私有地址用于在局域网内部进行通信，而通过路由器进行网络地址转换（NAT），可以允许多个设备共享单个公网IP地址来访问互联网。

1.2.2 InetAddress

InetAddress 是 Java 编程语言中用于表示 IP 地址的类。它提供了一种将 IP 地址和主机名相互转换的方式。通过 InetAddress 类，可以实现网络通信中的主机名解析、IP 地址解析等功能。

成员方法：

1.2.3 端口和协议

• 端口

  • 设备上应用程序的唯一标识

• 端口号

  • 用两个字节表示的整数，它的取值范围是0~65535。其中，0~1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败

• 协议

  • 计算机网络中，连接和通信的规则被称为网络通信协议

• UDP协议

  • 用户数据报协议(User Datagram Protocol)

  • UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。

  • 由于使用UDP协议消耗系统资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输

  • 速度快，有大小限制一次最多发送64K，数据不安全，易丢失数据

  • 例如视频会议通常采用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议

• TCP协议

  • 传输控制协议 (Transmission Control Protocol)

  • TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过"三次握手"

  • 速度慢，没有大小限制，数据安全

  • 三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠

    第一次握手，客户端向服务器端发出连接请求，等待服务器确认

    第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求

    第三次握手，客户端再次向服务器端发送确认信息，确认连接

  • 完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛。例如上传文件、下载文件、浏览网页等

1.3 UDP协议

1.3.1 UDP发送数据

构造方法：

成员方法：

发送数据的步骤

• 创建发送端的Socket对象(DatagramSocket)

• 创建数据，并把数据打包(DatagramPacket)

• 调用DatagramSocket对象的方法发送数据(send)

• 关闭发送端

代码演示：

public class Send {
    public static void main(String[] args) throws IOException {
        /**
         * 创建发送端的Socket对象(DatagramSocket)
         * 创建数据，并把数据打包(DatagramPacket)
         * 调用DatagramSocket对象的方法发送数据(send)
         * 关闭发送端
         */
        //这里参数如果没有端口号,系统会自动分配一个端口号
        DatagramSocket socket = new DatagramSocket(10000);

        String str = "龙颜大怒666";
        byte[] bytes = new byte[1024];
        bytes = str.getBytes();

        DatagramPacket packet = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("127.0.0.1"),10086);
        socket.send(packet);

        socket.close();
    }
}

1.3.2 UDP接收数据

构造方法：

成员方法：

接收数据的步骤

• 创建接收端的Socket对象(DatagramSocket)

• 创建一个数据包，用于接收数据(DatagramPacket)

• 调用DatagramSocket对象的方法接收数据(receive)

• 解析数据包，并把数据在控制台显示

• 关闭接收端

代码演示：

public class Receive {
    public static void main(String[] args) throws IOException {
        /**
         * 创建接收端的Socket对象(DatagramSocket)
         * 创建一个数据包，用于接收数据(DatagramPacket)
         * 调用DatagramSocket对象的方法接收数据(receive)
         * 解析数据包，并把数据在控制台显示
         * 关闭接收端
         */

        //注意：这里的端口号一定要与发送端中的数据包端口一致,不然会收不到数据
        DatagramSocket socket = new DatagramSocket(10086);

        byte[] bytes = new byte[1024];
        DatagramPacket packet = new DatagramPacket(bytes,bytes.length);

        //这个方法会一直等待发送端发送信息过来,直到拿到数据才会取消阻塞
        socket.receive(packet);

        byte[] data = packet.getData();
        InetAddress address = packet.getAddress();
        int port = packet.getPort();
        System.out.println("数据：" + new String(data,0,packet.getLength()) + " 主机IP：" + address + " 端口号：" + port);

        socket.close();
    }
}

输出结果：

数据：龙颜大怒666 主机IP：/127.0.0.1 端口号：10000

1.4 TCP协议

1.4.1 TCP协议实例

代码演示：

public class Client {
    public static void main(String[] args) throws IOException {
        //创建socket对象
        //细节：在创建对象同时会连接服务端
        //如果连接不上代码会报错
        Socket socket = new Socket("127.0.0.1",10000);
        //创建socket的输出流通道
        OutputStream outputStream = socket.getOutputStream();
        //写入数据
        outputStream.write("你好呀".getBytes());
        //关闭资源
        socket.close();
        outputStream.close();
    }
}

public class Server {
    public static void main(String[] args) throws IOException {
        //这里的端口号要跟客户端的Socket保持一致
        ServerSocket serverSocket = new ServerSocket(10000);
        //这里会阻塞等待客户端发送信息
        Socket socKet = serverSocket.accept();
        //通过socket获取输入流通道
        InputStream inputStream = socKet.getInputStream();
        //解决中文乱码问题
        InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        int len;
        while ((len = bufferedReader.read()) != -1) {
            System.out.print((char) len);
        }
        //关闭资源
        serverSocket.close();
        socKet.close();
    }
}

1.4.2 三次握手，四次挥手

三次握手：为了确保连接的建立

四次挥手：确保连接断开，且数据处理完毕

1.5 综合练习

1.5.1 多发多送

public class Test01 {
    public static void main(String[] args) throws IOException {
        /**
         * 客户端：多次发送数据
         * 服务端：接收多次数据,并打印
         */
        Socket socket = new Socket("127.0.0.1",10002);

        OutputStream outputStream = socket.getOutputStream();
        Scanner scanner = new Scanner(System.in);

        while (true) {
            System.out.println("请输入你要发送的信息：");
            String str = scanner.nextLine();
            //用户输入886表示退出
            if("886".equals(str)){
                break;
            }
            outputStream.write(str.getBytes());
        }
        //关闭资源
        outputStream.close();
        socket.close();
    }
}




public class TestServer01 {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(10002);

        Socket socket = serverSocket.accept();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        int len;
        while((len = bufferedReader.read()) != -1){
            System.out.print((char)len);
        }
        //关闭资源
        socket.close();
        serverSocket.close();
    }
}

1.5.2 接收并反馈

public class Test02 {
    public static void main(String[] args) throws IOException {
        /**
         * 客户端：发送一条数据,接收服务端反馈的消息并打印
         * 服务端：接收数据并打印,再给客户端反馈信息
         */
        Socket socket = new Socket(InetAddress.getLocalHost(),10003);
        Scanner scanner = new Scanner(System.in);
        OutputStream os = socket.getOutputStream();

        System.out.println("请输入要发给服务端的信息：");
        String str = scanner.nextLine();
        os.write(str.getBytes());

        //细节：这里需要一个结束标记,服务端那边读取才知道结束
        socket.shutdownOutput();

        InputStreamReader isr = new InputStreamReader(socket.getInputStream());
        int len;
        while ((len = isr.read()) != -1){
            System.out.print((char)len);
        }
        
        socket.close();
    }
}



public class TestServer02 {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(10003);

        Socket socket = serverSocket.accept();

        InputStreamReader isr = new InputStreamReader(socket.getInputStream());
        int len;
        //细节：
        //read方法从连接通道读取数据
        //但是需要一个结束标记循环才会停止
        //否则,程序就会一直停在read方法这里,等待读取下面的数据
        while ((len = isr.read()) != -1){
            System.out.print((char)len);
        }

        OutputStream os = socket.getOutputStream();
        os.write("收到客户端的信息".getBytes());

        socket.close();
        serverSocket.close();
    }
}

1.5.3 上传练习

public class Test03 {
    public static void main(String[] args) throws IOException {
        /**
         * 案例需求：
         * 客户端：数据来自于本地文件，接收服务器反馈
         * 服务器：接收到的数据写入本地文件，给出反馈
         */
        Socket socket = new Socket("127.0.0.1", 10000);

        byte[] bytes = new byte[1024];
        int len;

        //这种方式效率比较低
        //FileInputStream fis = new FileInputStream("D:\\img\\0a3b3288-3446-4420-bbff-f263d0c02d8e.jpg");
        //OutputStream os = socket.getOutputStream();

        //缓存流可以降低磁盘IO次数
        BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream("source/0a3b3288-3446-4420-bbff-f263d0c02d8e.jpg"));
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());

        //发送数据
        while ((len = bis.read(bytes)) != -1){
            bos.write(bytes,0,len);
        }

        //设置结束标记
        socket.shutdownOutput();

        //接收数据
        InputStreamReader isr = new InputStreamReader(socket.getInputStream());
        while ((len = isr.read()) != -1){
            System.out.print((char)len);
        }

        socket.close();
    }
}




public class TestServer03 {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(10000);

        Socket socket = serverSocket.accept();
        InputStream is = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int len;

        //效率低
        //FileOutputStream fos = new FileOutputStream(new File("D:\\test\\a.jpg"));


        //这里需要解决文件名重复问题,导致原先的文件会被后面的覆盖,用UUID来解决
        //System.out.println(UUID.randomUUID());
        //72e165ae-98ad-4cd4-80e9-c9f86b910461,我们一般看到的效果是没有"-"的,需要处理一下
        String name = UUID.randomUUID().toString().replace("-", "");
        //BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("img\\a.jpg"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("img\\" + name + ".jpg"));

        //边读边写
        while((len = is.read(bytes)) != -1){
            bos.write(bytes,0,len);
        }

        //发送数据
        OutputStream os = socket.getOutputStream();
        os.write("收到数据啦".getBytes());

        socket.close();
        serverSocket.close();
    }
}

1.5.4 服务器改写成多线程，以及线程优化

服务器只能处理一个客户端请求，接收完一个图片之后，服务器就关闭了。

优化方案一：使用循环

弊端：第一个用户正在上传数据，第二个用户就来访问了，此时第二个用户是无法成功上传的。

所以，使用多线程改进

优化方案二：使用循环 + 多线程

每来一个用户，就开启多线程处理

public class Test04 {
    public static void main(String[] args) throws IOException {
        /**
         * 案例需求：
         * 客户端：数据来自于本地文件，接收服务器反馈
         * 服务器：接收到的数据写入本地文件，给出反馈
         */
        Socket socket = new Socket("127.0.0.1", 10000);

        byte[] bytes = new byte[1024];
        int len;

        //这种方式效率比较低
        //FileInputStream fis = new FileInputStream("D:\\img\\0a3b3288-3446-4420-bbff-f263d0c02d8e.jpg");
        //OutputStream os = socket.getOutputStream();

        //缓存流可以降低磁盘IO次数
        BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream("source/0a3b3288-3446-4420-bbff-f263d0c02d8e.jpg"));
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());

        //发送数据
        while ((len = bis.read(bytes)) != -1){
            bos.write(bytes,0,len);
        }

        //设置结束标记
        socket.shutdownOutput();

        //接收数据
        InputStreamReader isr = new InputStreamReader(socket.getInputStream());
        while ((len = isr.read()) != -1){
            System.out.print((char)len);
        }

        socket.close();
    }
}



public class TestServer04 {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(10000);
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                3,//核心线程数量
                16,//线程池总大小
                60,//空闲时间
                TimeUnit.SECONDS,//空闲时间（单位）
                new ArrayBlockingQueue<>(2),//队列
                Executors.defaultThreadFactory(),//线程工厂，让线程池如何创建线程对象
                new ThreadPoolExecutor.AbortPolicy()//阻塞队列
        );

        while (true) {
            //等待客户端连接
            Socket socket = serverSocket.accept();

            //一个用户对应一条线程
            //new Thread(new MyRunnable(socket)).start();

            //线程池进行优化
            poolExecutor.submit(new MyRunnable(socket));
        }
    }
}



public class MyRunnable implements Runnable {
    private Socket socket;

    public MyRunnable(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            InputStream is = socket.getInputStream();
            byte[] bytes = new byte[1024];
            int len;

            //效率低
            //FileOutputStream fos = new FileOutputStream(new File("D:\\test\\a.jpg"));


            //这里需要解决文件名重复问题,导致原先的文件会被后面的覆盖,用UUID来解决
            //System.out.println(UUID.randomUUID());
            //72e165ae-98ad-4cd4-80e9-c9f86b910461,我们一般看到的效果是没有"-"的,需要处理一下
            String name = UUID.randomUUID().toString().replace("-", "");
            //BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("img\\a.jpg"));
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("img\\" + name + ".jpg"));

            //边读边写
            while ((len = is.read(bytes)) != -1) {
                bos.write(bytes, 0, len);
            }

            //发送数据
            OutputStream os = socket.getOutputStream();
            os.write("上传成功".getBytes());

        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }