【Java】网络编程，你学废了吗_java网络编程可以不学吗-CSDN博客

本文链接：https://blog.csdn.net/weixin_62511863/article/details/125782179

🔥一个人走得远了，就会忘记自己为了什么而出发，希望你可以不忘初心，不要随波逐流，一直走下去🎶
🦋 欢迎关注🖱点赞👍收藏🌟留言🐾
🦄 本文由程序喵正在路上原创，CSDN首发！
💖 系列专栏：Java入门
🌠 首发时间：2022年7月16日
✅ 如果觉得博主的文章还不错的话，希望小伙伴们三连支持一下哦

阅读指南

🐠网络编程入门
1. 网络编程概述
2. 网络编程三要素
3. IP地址
4. InetAddress的使用
5. 端口
6. 协议

🐡UDP通信程序
1. UDP通信原理
2. UDP发送数据
3. UDP接收数据
4. UDP通信程序练习

🦈TCP通信程序
1. TCP通信原理
2. TCP发送数据
2. TCP接收数据
4. TCP通信程序练习

🐠网络编程入门

1. 网络编程概述

计算机网络

是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统

在这里插入图片描述
网络编程

在网络通信协议下，实现网络互连的不同计算机上运行的程序间进行数据交换

2. 网络编程三要素

IP地址

要想让网络中的计算机能够互相通信，必须为每台计算机指定一个标识号，通过这个标识号来指定要接收数据的计算机和识别发送的计算机，而 IP 地址就是这个标识号，也就是设备的标识

端口

网络的通信，本质上是两个应用程序的通信。每台计算机都有很多的应用程序，那么在网络通信时，如何区分这些应用程序呢？如果说 IP 地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的应用程序了，也就是应用程序的标识

协议

通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。常见的协议有 UDP 协议和 TCP 协议

3. IP地址

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

IP地址分为两大类

IPv4：是给每个连接在网络上的主机分配一个 32bit 地址。按照 TCP/IP 规定，IP 地址用二进制来表示，每个 IP 地址长 32bit，也就是 4 个字节。例如一个采用二进制形式的 IP 地址是 “11000000 10101000 00000001 01000010”，这么长的地址，处理起来也太费劲了。为了方便使用，IP 地址经常被写成十进制的形式，中间使用符号 “.” 分隔不同的字节。于是，上面的 IP 地址可以表示成 “192.168.1.66”。IP 地址的这种表示方法叫做 “点分十进制表示法”，这显然比 1 和 0 容易记忆得多
IPv6：由于互联网的蓬勃发展，IP 地址的需求量越来越大，但是网络地址资源有限，使得 IP 的分配越发紧张。为了扩大地址空间，通过 IPv6 重新定义地址空间，采用 128 为地址长度，每 16 个字节一组，分成 8 组十六进制数，这样就解决了网络地址资源数量不够的问题

常用命令：

ipconfig：查看本机 IP 地址
ping IP地址：检查网络是否连通

在控制台中可以使用这些命令

在这里插入图片描述

特殊IP地址：

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

4. InetAddress的使用

为了方便我们对 IP 地址的获取和操作，Java 提供了一个类 InetAddress 供我们使用

InetAddress：此类表示 Internet 协议（IP）地址

此类有几个方法需要掌握

方法名	说明
`static InetAddress getByName(String host)`	确定主机名称的 IP 地址，主机名称可以是机器名称，也可以是 IP 地址
`String getHostName()`	获取此 IP 地址的主机名
`String getHostAddress()`	返回文本显示中的 IP 地址字符串

import java.net.InetAddress;
import java.net.UnknownHostException;

public class InetAddressDemo {
    public static void main(String[] args) throws UnknownHostException {
        //确定主机名称的 IP 地址，主机名称可以是机器名称，也可以是 IP 地址
//        InetAddress address = InetAddress.getByName("LAPTOP-JFCI61C0");
        InetAddress address = InetAddress.getByName("192.168.124.5");

        //获取 IP 地址的主机名
        String name = address.getHostName();

        //返回文本显示中的 IP 地址字符串
        String ip = address.getHostAddress();

        System.out.println("主机名：" + name);
        System.out.println("IP地址：" + ip);
    }
}

在这里插入图片描述

5. 端口

端口：设备上应用程序的唯一标识

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

6. 协议

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

UDP协议

用户数据报协议（User Datagram Protocol）
UDP 是无连接通信协议，即在数据传输时，数据的发送端和接收端不建议逻辑连接。简单来说，当一台计算机向另一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端收到数据时，也不会向发送端反馈是否收到数据
由于使用 UDP 协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输
例如视频会议通常采用 UDP 协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接受结果产生太大的影响。但是在使用 UDP 协议传送数据时，由于 UDP 的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用 UDP 协议

TCP协议

传输控制协议（Transmission Control Protocol）
TCP 协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建议逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。在 TCP 连接中必须要明确客户端和服务器端，由客户端向服务器端发出连接请求，每次连接的创建都需要经过 “三次握手”
三次握手：TCP 协议中，，在发送数据的准备阶段，客户端和服务器之间的三次交互，以保证连接的可靠
第一次握手，客户端向服务器端发出连接请求，等待服务器确认
第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求
第三次握手，客户端再次向服务器端发送确认信息，确认连接

在这里插入图片描述

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

🐡UDP通信程序

1. UDP通信原理

UDP 协议是一种不可靠的网络协议，它在通信的两端各建立一个 Socket 对象，但是这两个 Socket 只是发送、接收数据的对象

在这里插入图片描述

Java 提供了 DatagramSocket 类作为基于 UDP 协议的 Socket

2. UDP发送数据

发送数据的步骤：

创建发送端的 Socket 对象(DatagramSocket)
创建数据，并把数据打包
调用 DatagramSocket 对象的方法发送数据
关闭发送端

记得 IP 地址要改为自己电脑的 IP 地址哦

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

public class SendDemo {
    public static void main(String[] args) throws IOException {
        //创建发送端的Socket对象
        DatagramSocket ds = new DatagramSocket();

        //创建数据，打包
        byte[] bys = "hello,udp".getBytes();
        int length = bys.length;
        InetAddress address = InetAddress.getByName("192.168.124.5");
        int port = 10086;
        DatagramPacket dp = new DatagramPacket(bys,length,address,port);

        //调用DatagramSocket对象的方法发送数据
        ds.send(dp);

        //关闭发送端
        ds.close();
    }
}

3. UDP接收数据

接收数据的步骤：

创建接收端的 Socket 对象(DatagramSocket)
创建一个数据包，用于接收数据
调用 DatagramSocket 对象的方法接收数据
解析数据包，并把数据在控制台显示
关闭接收端

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class ReceiveDemo {
    public static void main(String[] args) throws IOException {
        //创建接收端的 Socket 对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket(10086);

        //创建一个数据包，用于接收数据
        byte[] bys = new byte[1024];
        DatagramPacket dp = new DatagramPacket(bys, bys.length);

        //调用 DatagramSocket 对象的方法接收数据
        ds.receive(dp);

        //解析数据包，并把数据在控制台显示
        byte[] datas = dp.getData();
        int len = dp.getLength();
        String dataString = new String(datas,0,len);
        System.out.println("数据是：" + dataString);

        //关闭接收端
        ds.close();
    }
}

然后，我们就可以接收信息了，先运行接收端，再运行发送端，就可以在接收端的控制台看到我们在发送端发来的信息啦

注意：先运行接收端，再运行发送端

运行结果如下：

在这里插入图片描述

4. UDP通信程序练习

按照下面的要求实现程序

UDP 发送数据：数据来自于键盘录入，直到输入的数据是 886，发送数据结束
UDP 接收数据：因为接收端不知道发送端什么时候停止发送，故采用死循环接收

//发送端
import java.io.*;
import java.net.*;

public class SendDemo {
    public static void main(String[] args) throws IOException {
        //创建发送端的Socket对象
        DatagramSocket ds = new DatagramSocket();

        //自己封装键盘录入数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line;
        while ((line = br.readLine()) != null) {
            //如果输入的数据是886，发送数据结束
            if ("886".equals(line)) {
                break;
            }

            //创建数据，打包
            byte[] bys = line.getBytes();
            DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.124.5"), 12345);

            //调用DatagramSocket对象的方法发送数据
            ds.send(dp);
        }

        //关闭发送端
        ds.close();
    }
}

//接收端
import java.io.IOException;
import java.net.*;

public class ReceiveDemo {
    public static void main(String[] args) throws IOException {
        //创建接收端的 Socket 对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket(12345);

        while (true) {
            //创建一个数据包，用于接收数据
            byte[] bys = new byte[1024];
            DatagramPacket dp = new DatagramPacket(bys, bys.length);

            //调用 DatagramSocket 对象的方法接收数据
            ds.receive(dp);

            //解析数据包，并把数据在控制台显示
            System.out.println("数据是：" + new String(dp.getData(), 0, dp.getLength()));
        }
        //一直接收数据，所以不用关了
    }
}

同样是前面的步骤，先开启接收端，再开启发送端，然后在发送端的控制台输入内容，一回车，接收端就能立马收到信息

在这里插入图片描述
你也可以来个骚操作，开启多个发送端，接收端是可以接收到多个发送端的信息

按照下列步骤操作即可

菜单栏的 Run ➔ Edit Configurations ➔ Modify options ➔ Allow multiple instances

在这里插入图片描述

🦈TCP通信程序

1. TCP通信原理

TCP 通信协议是一种可靠的网络协议，它在通信的两端各建立一个 Socket 对象，从而在通信的两端形成网络虚拟链路，一旦建立了虚拟的网络链路，两端的程序就可以通过虚拟链路进行通信

在这里插入图片描述
Java 对基于 TCP 协议的网络提供了良好的封装，使用 Socket 对象来代表两端的通信端口，并通过 Socket 产生 IO 流来进行网络通信

Java 为客户端提供了 Socket 类，，为服务器端提供了 ServerSocket 类

2. TCP发送数据

发送数据的步骤：

创建客户端的 Socket 对象（Socket）
获取输出流，写数据
释放资源

import java.io.*;
import java.net.*;

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端的 Socket 对象（Socket）,下面两种方式都可以
        //Socket(InetAddress address, int port) 创建流套接字并将其连接到指定IP地址的指定端口号
//        Socket s = new Socket(InetAddress.getByName("192.168.124.5"), 10000);
        //Socket(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号
        Socket s = new Socket("192.168.124.5", 10000);

        //获取输出流，写数据
        //OutputStream getOutputStream() 返回此套接字的输出流
        OutputStream os = s.getOutputStream();
        os.write("hello,tcp,我来了".getBytes());

        //释放资源
        s.close();
    }
}

在这里插入图片描述

运行程序后，我们会发现报错 “Connection refused : connect"，这是为什么呢？

因为 TCP 每次连接的创建都需要经过 “三次握手”

2. TCP接收数据

接收数据的步骤：

创建服务器端的 Socket 对象（ServerSocket）
获取输入流，读数据，并把数据显示在控制台
释放资源

import java.io.*;
import java.net.*;

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器端的 Socket 对象（ServerSocket）
        //ServerSocket(int port) 创建绑定到指定端口的服务器套接字
        ServerSocket ss = new ServerSocket(10000);

        //Socket accept() 侦听要连接到此套接字并接受它
        Socket s = ss.accept();

        //获取输入流，读数据，并把数据显示在控制台
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys, 0, len);
        System.out.println("数据是：" + data);

        //释放资源
        ss.close();
    }
}

在这里插入图片描述

4. TCP通信程序练习

练习1

客户端：发送数据，接受服务器反馈
服务器端：接受数据，给出反馈

//客户端
import java.io.*;
import java.net.*;

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端的 Socket 对象（Socket）
        Socket s = new Socket("192.168.124.5", 10000);

        //获取输出流，写数据
        OutputStream os = s.getOutputStream();
        os.write("hello,tcp,我来了".getBytes());

        //接受服务器反馈
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys, 0, len);
        System.out.println("客户端：" + data);

        //释放资源
        s.close();
    }
}

//服务器端
import java.io.*;
import java.net.*;

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器端的 Socket 对象（ServerSocket）
        ServerSocket ss = new ServerSocket(10000);

        //监听客户端连接，返回一个Socket对象
        Socket s = ss.accept();

        //获取输入流，读数据，并把数据显示在控制台
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys, 0, len);
        System.out.println("服务器：" + data);

        //给出反馈
        OutputStream os = s.getOutputStream();
        os.write("数据已经收到".getBytes());

        //释放资源
        ss.close();
    }
}

在这里插入图片描述

练习2

客户端：数据来自于键盘录入，直到输入的数据是 886，发送数据结束
服务器端：接收到数据并在控制台输出

//客户端
import java.io.*;
import java.net.*;

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端的 Socket 对象（Socket）
        Socket s = new Socket("192.168.124.5", 10000);

        //数据来自于键盘录入，直到输入的数据是 886，发送数据结束
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //封装输出流对象
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

        String line;
        while ((line = br.readLine()) != null) {
            if ("886".equals(line)) {
                break;
            }

            //写数据
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        s.close();
    }
}

//服务器端
import java.io.*;
import java.net.*;

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器端的 Socket 对象（ServerSocket）
        ServerSocket ss = new ServerSocket(10000);

        //监听客户端连接，返回一个Socket对象
        Socket s = ss.accept();

        //获取输入流，读数据，并把数据显示在控制台
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }

        //释放资源
        ss.close();
    }
}

操作步骤与前面一样

练习3

客户端：数据来自于键盘录入，直到输入的数据是 886，发送数据结束
服务器端：接收到的数据写入文本文件中

客户端代码与练习 2 一致

//服务器端
import java.io.*;
import java.net.*;

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器端的 Socket 对象（ServerSocket）
        ServerSocket ss = new ServerSocket(10000);

        //监听客户端连接，返回一个Socket对象
        Socket s = ss.accept();

        //获取输入流，读数据，并把数据显示在控制台
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        //把数据写入文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\IDEA\\idea_Demo\\test.txt"));

        String line;
        while ((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        bw.close();
        ss.close();
    }
}

在这里插入图片描述

运行后，在客户端的控制台输入数据，当输出 ”886“ 退出后，会自动生成一个文本文件，内容就是你在控制台所输入的文本

如果运行出错，请检查文件路径是否正确

练习4

客户端：数据来自于文本文件
服务器端：接收到的数据写入文本文件

//客户端
import java.io.*;
import java.net.*;

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端的 Socket 对象（Socket）
        Socket s = new Socket("192.168.124.5", 10000);

        //封装文本文件的数据
        BufferedReader br = new BufferedReader(new FileReader("D:\\IDEA\\idea_Demo\\demo.txt"));
        //封装输出流对象
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

        String line;
        while ((line = br.readLine()) != null) {
            //写数据
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        br.close();
        s.close();
    }
}

服务器端代码与练习 3 一致

运行程序后，会出现一个 test.txt 文本文件，文件内容和 demo.txt 文件一模一样

在这里插入图片描述

练习5

客户端：数据来自于文本文件，接收服务器反馈
服务器端：接收到的数据写入文本文件，给出反馈
出现问题：服务器端程序一直等待
原因：读数据的方法是阻塞式的
解决方法：使用 shutdownOutput() 方法

//客户端
import java.io.*;
import java.net.*;

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端的 Socket 对象（Socket）
        Socket s = new Socket("192.168.124.5", 10000);

        //封装文本文件的数据
        BufferedReader br = new BufferedReader(new FileReader("D:\\IDEA\\idea_Demo\\网络编程\\InetAddressDemo.java"));
        //封装输出流对象
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

        String line;
        while ((line = br.readLine()) != null) {
            //写数据
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //public void shutdownOutput()  读取完毕标记
        s.shutdownOutput();

        //接收反馈
        BufferedReader brClient = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String data = brClient.readLine();
        System.out.println("服务器反馈：" + data);

        //释放资源
        br.close();
        s.close();
    }
}

//服务器端
import java.io.*;
import java.net.*;

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器端的 Socket 对象（ServerSocket）
        ServerSocket ss = new ServerSocket(10000);

        //监听客户端连接，返回一个Socket对象
        Socket s = ss.accept();

        //获取输入流，读数据，并把数据显示在控制台
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        //把数据写入文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\IDEA\\idea_Demo\\Copy.java"));

        String line;
        while ((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //给出反馈
        BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        bwServer.write("文件上传成功");
        bwServer.newLine();
        bwServer.flush();

        //释放资源
        bw.close();
        ss.close();
    }
}

运行后发现，多出了一个 Copy.java 的文件，里面有一个类 InetAddressDemo

练习6

客户端：数据来自于文本文件，接收服务器反馈
服务器端：接收到的数据写入文件，给出反馈，代码用线程进行封装，为每一个客户端开启一个线程

客户端与练习 5 一致

//服务器端线程类
import java.io.*;
import java.net.*;

public class ServerThread implements Runnable {
    private Socket s;

    public ServerThread(Socket s) {
        this.s = s;
    }

    @Override
    public void run() {
        //接收数据写到文本文件
        try {
            //获取输入流，读数据，并把数据显示在控制台
            BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));

            //把数据写入文件
            //解决文件名称冲突问题
            int count = 0;
            File file = new File("D:\\IDEA\\idea_Demo\\Copy[" + count + "].java");

            while (file.exists()) {
                count++;
                file = new File("D:\\IDEA\\idea_Demo\\Copy[" + count + "].java");
            }

            BufferedWriter bw = new BufferedWriter(new FileWriter(file));

            String line;
            while ((line = br.readLine()) != null) {
                bw.write(line);
                bw.newLine();
                bw.flush();
            }

            //给出反馈
            BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
            bwServer.write("文件上传成功");
            bwServer.newLine();
            bwServer.flush();

            //释放资源
            s.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

//服务器端
import java.io.*;
import java.net.*;

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器端的 Socket 对象（ServerSocket）
        ServerSocket ss = new ServerSocket(10000);

        //监听客户端连接，返回一个Socket对象
        Socket s = ss.accept();

        //为每一个客户端开启一个线程
        new Thread(new ServerThread(s)).start();

        //释放资源
        ss.close();
    }
}