-
Java网络编程1
Java网络编程1
网络相关概念
把java网络编程的基础知识学习完之后，我们才会更加了解那些高性能的网络框架像neety它为什么要这样设计？才能把知识掌握的更加清晰。
网络通信
1）概念：两台设备之间，通过网络，实现数据传输。
2）网络通信：将数据，通过网络，从一台设备传输到另一台设备。
3）java.net 包下：提供了一系列的类 & 接口。供程序员调用，完成网络通信。
网络的相关概念
1）概念：两台或多台设备，通过一定物理设备，连接起来，构成了网络。
2）根据网络的覆盖范围不同，对网络进行分类：- 局域网：覆盖范围最小，仅仅覆盖一个教室或一个机房
- 城域网：覆盖范围较大，可以覆盖一个城市
- 广域网：覆盖范围最大，可以覆盖全国，甚至全球，万维网是广域网的代表
3）网络编程目的：直接或间接的通过网络协议，与其他的计算机实现数据交换，进行通讯。
4）网络编程中有两个主要的问题：
-1：如何准确的定位网络上，一台或多台主机；定位主机上特定的应用。
-2：找到主机后，如何高效的进行数据传输。
IP地址
1）ip 地址：
-1：概念：用于唯一标识网络中间每台（计算机/主机），这样一个主机如果想要给另外一个主机发送内容，它就能通过ip地址找到这个主机，ip地址好比是身份证号。
-2：查看 ip 地址：ipconfig
-3：ip 地址的表示形式：xx.xx.xx.xx（范围：0～255）
-4：ip 地址组成：网络地址 + 主机地址（如：192.168.12.29），192.168.12代表的是网络地址，而后面的29代表的是主机地址。
-5：IPv4 网路资源地址有限，IPv6 是代替 IPv4 的下一代 IP 通信协议
-6：IPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议，其地址数量号称可以为全世界的每一粒沙子编上一个地址。
-7：由于IPv4最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展。IPv6的使用，不仅能解决网络地址资源数量的问题，而且也解决了多种接入设备连入互联网的障碍。
2）IPv4 地址分类，如下图：
3）端口号：
-1：概念：用于标识 计算机上某个特定的网络程序。
-2：表示形式：0 - 65535。【 2个字节表示 （2^16-1=65535）】
-3：0-1024：已经被占用。
-4：端口号：IP 地址与端口号，组合得出一个网络套接字：Socket。到这里我们必须要知道几个点，如下图：
- 第一个点是我们做网络编程就必须要知道对方的地址，如果不知道对方的ip地址，我们根本没办法把我们的数据发给对方。
- ip地址分为IPv4和IPv6两类，IPv4它是用4个字节表示的一个ip地址，而IPv6它是用16个字节表示的一个ip地址。
域名和端口号
域名
1）比如百度的域名是www.baidu.com
2）好处：为了方便记忆，解决记忆ip的困难
3）概念：将ip地址映射成域名，这里怎么映射上，HTTP协议端口号
1）概念：用于表示计算机上某个特定的网络程序。我们如果想要访问远程主机上的某个程序，首先必须要知道这个主机的ip地址，从而我们才能找到这个主机在哪里。但是一个主机上有很多个服务，具体我们怎么才能知道找的是哪个程序呢？可以通过端口号，因为主机上面每一个程序都会独占一个端口号，并且端口号不会重复。
2）表示形式：以整数形式，端口范围0~65535。
3）0~1024已经被占用，比如ssh 22，ftp 21，smtp 25，http 80；
4）常见的网络程序端口号：tomcat 8080，mysql 3306，oracle 1521，sqlserver 1433。网络通讯协议
1）协议（tcp/ip）
TCP/IP（Transmission Control Protocol/Internet Protocol）的简写。中文名为传输控制协议/因特网互联协议，又叫网络通讯协议、这个协议是Internet最基本的协议、Internet国际互联网络的基础，简单来说，就是由网络层的IP协议和传输层的TCP协议组成的。2）示意图，如下图：
上图中的解释：网络之间传输的数据是遵循TCP/IP协议的，发送到对方主机的时候的数据都是以太网帧，对方主机也遵循TCP/IP协议，它读取数据的时候会一层一层的拆包，最终得到用户数据。
TCP和UDP
1）TCP协议（传输控制协议）- 使用TCP协议前，须先建立TCP连接，形成传输数据通道；
- 传输前，采用“三次握手”方式，确认是可靠的；
- TCP协议进行通信的两个应用进程：客户端、服务端；
- 在连接中可进行大数据量的传输；
- 传输完毕，需释放已建立的连接（如果不释放连接就会出问题，就好比别人和你打电话，打完了之后没有挂电话，那就会出问题了，因为别人就给你打不进来了），效率低。
2）UDP协议（用户数据协议）
- 将数据、源、目的封装成数据包，不需要建立连接；
- 每个数据报的大小限制在64K内，不适合传输大量数据；
- 因无需连接，故是不可靠的；
- 发送数据结束时无需释放资源（因为不是面向连接的，就像别人给你发短信，好多个人都能同时给你发），速度快；
- 举例：测试通知：发短信。如下图：
InetAddress类
相关方法
- 获取本机InetAddress对象 getLocalHost；
- 根据指定主机名/域名获取IP地址对象，getByName；
- 获取InetAddress对象的主机名 getHostName；
- 获取InetAddress对象的地址 getHostAddress。
应用案例
/** * @author xuan * @create 2023/10/12 */ public class API { public static void main(String[] args) throws UnknownHostException { //1.获取本机的InetAddress对象 InetAddress localHost = InetAddress.getLocalHost(); System.out.println(localHost);//SKUSER-ICQOUU76/10.40.4.215 (前面是主机名，后面是主机ip地址) //2. 根据指定主机名（主机名也可以理解成是域名） 获取 InetAddress对象 InetAddress host1 = InetAddress.getByName("SKUSER-ICQOUU76"); System.out.println(host1);//SKUSER-ICQOUU76/10.40.4.215 (前面是主机名或域名，后面是主机ip地址) //3. 根据域名返回 InetAddress对象, 比如 www.baidu.com 对应 InetAddress host2 = InetAddress.getByName("www.baidu.com"); System.out.println(host2);//www.baidu.com/180.101.50.188 //4. 通过 InetAddress 对象，获取对应的ip地址 String hostAddress = host2.getHostAddress();//IP 180.101.50.188 System.out.println("host2 对应的ip = " + hostAddress);//180.101.50.188 //5. 通过 InetAddress 对象，获取对应的主机名/也可以说是域名 String hostName = host2.getHostName(); System.out.println("host2对应的主机名/也可以说是域名=" + hostName); // www.baidu.com } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
输出结果如下图：
Socket套接字
基本介绍
1）套接字（Socket）开发网络应用程序被广泛采用，以至于成为事实上的标准；
2）通讯的两端都要有Socket，是两台机器之间的通讯端点；
3）网络通信其实就是Socket间的通信；
4）Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输；
5）一般主动发起通信的应用程序属于客户端，等待通信请求的为服务端。
如下图：
注意：既然现在是客户端和服务端通信，那么它们之间一定是已经建立好了连接，它们之间的数据传输是在它们的连接通道里面传输的。
客户端想要给服务器端发消息要怎么办？首先客户端会把想要发的消息放到Socket里面，然后通过Socket里面的输出流socket.getOutputStream()把想要发送的数据放到数据通道里面。而对于服务器来说，它这个时候想要读取来自客户端发送的数据，那么会调用服务端的Socket对象的输入流对象也即是socket.getInputStream()，输入流对象可以从数据通道里面读取数据。这个流程就是客户端和服务端通过Socket对象来传输数据的流程。TCP网络通信编程
1）基本介绍- 基于客户端-服务端的网络通信；
- 底层使用的是TCP/IP协议；
- 应用场景举例：客户端发送数据，服务端接受并显示控制台；
- 基于Sockte的TCP编程。
应用案例1
首先看一下要求，如下图：
服务端和客户端的代码如下：
//Client类 /** * 客户端，发送 "hello, server" 给服务端 */ public class SocketTCP01Client { public static void main(String[] args) throws IOException { //思路 //1. 连接服务端 (ip , 端口） //解读: 连接本机的 9999端口, 如果连接成功，返回Socket对象 Socket socket = new Socket(InetAddress.getLocalHost(), 9999); System.out.println("客户端 socket返回=" + socket.getClass()); //2. 连接上后，生成Socket, 通过socket.getOutputStream() // 得到 和 socket对象关联的输出流对象 OutputStream outputStream = socket.getOutputStream(); //3. 通过输出流，写入数据到 数据通道 outputStream.write("hello, server".getBytes()); //4. 关闭流对象和socket, 必须关闭 outputStream.close(); socket.close(); System.out.println("客户端退出....."); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
//Server类 /** * 服务端 */ public class SocketTCP01Server { public static void main(String[] args) throws IOException { //思路 //1. 在本机 的9999端口监听, 等待连接 // 细节: 要求在本机没有其它服务在监听9999 // 细节：这个 ServerSocket 可以通过 accept() 返回多个Socket[多个客户端连接服务器的并发] ServerSocket serverSocket = new ServerSocket(9999); System.out.println("服务端，在9999端口监听，等待连接.."); //2. 当没有客户端连接9999端口时，程序会 阻塞, 等待连接 // 如果有客户端连接，则会返回Socket对象，程序继续 Socket socket = serverSocket.accept(); System.out.println("服务端 socket =" + socket.getClass()); // //3. 通过socket.getInputStream() 读取客户端写入到数据通道的数据, 显示 InputStream inputStream = socket.getInputStream(); //4. IO读取 byte[] buf = new byte[1024]; int readLen = 0; while ((readLen = inputStream.read(buf)) != -1) { System.out.println(new String(buf, 0, readLen));//根据读取到的实际长度，显示内容. } //5.关闭流和socket inputStream.close(); socket.close(); serverSocket.close();//关闭 } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
应用实例2
要求如下图：
服务端客户端代码如下：//Client类 /** * 客户端，发送 "hello, server" 给服务端 */ @SuppressWarnings({"all"}) public class SocketTCP02Client { public static void main(String[] args) throws IOException { //思路 //1. 连接服务端 (ip , 端口） //解读: 连接本机的 9999端口, 如果连接成功，返回Socket对象 Socket socket = new Socket(InetAddress.getLocalHost(), 9999); System.out.println("客户端 socket返回=" + socket.getClass()); //2. 连接上后，生成Socket, 通过socket.getOutputStream() // 得到 和 socket对象关联的输出流对象 OutputStream outputStream = socket.getOutputStream(); //3. 通过输出流，写入数据到 数据通道 outputStream.write("hello, server".getBytes()); // 设置结束标记 socket.shutdownOutput(); //4. 获取和socket关联的输入流. 读取数据(字节)，并显示 InputStream inputStream = socket.getInputStream(); byte[] buf = new byte[1024]; int readLen = 0; while ((readLen = inputStream.read(buf)) != -1) { System.out.println(new String(buf, 0, readLen)); } //5. 关闭流对象和socket, 必须关闭 inputStream.close(); outputStream.close(); socket.close(); System.out.println("客户端退出....."); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
//Server类 //** * 服务端 */ @SuppressWarnings({"all"}) public class SocketTCP02Server { public static void main(String[] args) throws IOException { //思路 //1. 在本机 的9999端口监听, 等待连接 // 细节: 要求在本机没有其它服务在监听9999 // 细节：这个 ServerSocket 可以通过 accept() 返回多个Socket[多个客户端连接服务器的并发] ServerSocket serverSocket = new ServerSocket(9999); System.out.println("服务端，在9999端口监听，等待连接.."); //2. 当没有客户端连接9999端口时，程序会 阻塞, 等待连接 // 如果有客户端连接，则会返回Socket对象，程序继续 Socket socket = serverSocket.accept(); System.out.println("服务端 socket =" + socket.getClass()); // //3. 通过socket.getInputStream() 读取客户端写入到数据通道的数据, 显示 InputStream inputStream = socket.getInputStream(); //4. IO读取 byte[] buf = new byte[1024]; int readLen = 0; while ((readLen = inputStream.read(buf)) != -1) { System.out.println(new String(buf, 0, readLen));//根据读取到的实际长度，显示内容. } //5. 获取socket相关联的输出流 OutputStream outputStream = socket.getOutputStream(); outputStream.write("hello, client".getBytes()); // 设置结束标记 socket.shutdownOutput(); //6.关闭流和socket outputStream.close(); inputStream.close(); socket.close(); serverSocket.close();//关闭 } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
服务器会发生阻塞的两个地方：第一个地方是等待客户端连接的时候，服务器会发生阻塞；第二个地方是获取客户端的传输数据也就是获取输入流的时候会发生阻塞；如下图：
同理客户端在通过Socket对象获取输入流对象的时候，如果此时服务端还没有传输给客户端数据，那么客户端也会在这个地方发生阻塞，如下图：
还有一个需要注意的点，一个很隐秘的，很可能会出现的bug，就是无论是在服务器端还是在客户端，在符合条件的输出流的后面，都需要加上一个结束标记socket.shutdownOutput()，从而告诉另一方我已经发送完了，否则另一方会一直阻塞在读取输入流的地方，如下图：
netstat指令- netstat -an 可以查看当前主机网络情况，包括端口监听情况和网络连接情况；
- netstat -an | more 可以分页显示；
- 要求在dos控制台下执行win + r；
说明：
1）Listening 表示某个端口在监听；
2）如果由一个外部程序（客户端）连接到该端口，就会显示一条连接信息；
3）可以输入ctrl + c 退出指令；
其中本地地址表示的是本地开启的程序端口号，可以理解成在这个端口号上跑着一个程序，而Listening表示我们正在监听这个端口号；而外部地址可以理解成外部一个主机对应的端口号的那个程序连接了我们本地程序的端口号。
比如我们现在在9999端口号上面启动一个程序，看一下dos命令行窗口的效果，如下图：
可以发现我们这里就多了一条监听记录，这里就表示我们本地主机上面的9999端口号上面启动了一个程序，并且目前对9999端口号处于监听状态；并且目前没有外部主机连接我们本地主机9999端口号上面的这个程序。TCP的注意事项
当客户端连接到服务端后，实际上客户端也是通过一个端口和服务端进行通讯的，这个端口是TCP/IP来分配的。比如说我们现在启动一个端口是9999的服务器程序，现在没有客户端连接，我们在cmd命令行窗口输入netstat -an指令可以发现，如下图：
后面我们用一个客户端连接我们端口号是9999的已经启动的服务器，客户端端口号会多一个9999端口号的服务器的连接，如下图：
UDP网络通信编程
基本介绍
基本流程
示意图
应用案例
//ReceiverA类 /** * UDP接收端 */ public class UDPReceiverA { public static void main(String[] args) throws IOException { //1. 创建一个 DatagramSocket 对象，准备在9999接收数据 DatagramSocket socket = new DatagramSocket(9999); //2. 构建一个 DatagramPacket 对象，准备接收数据 // 在前面讲解UDP 协议时，老师说过一个数据包最大 64k byte[] buf = new byte[1024]; DatagramPacket packet = new DatagramPacket(buf, buf.length); //3. 调用 接收方法, 将通过网络传输的 DatagramPacket 对象 // 填充到 packet对象 //老师提示: 当有数据包发送到 本机的9999端口时，就会接收到数据 // 如果没有数据包发送到 本机的9999端口, 就会阻塞等待. System.out.println("接收端A 等待接收数据.."); socket.receive(packet); //4. 可以把packet 进行拆包，取出数据，并显示. int length = packet.getLength();//实际接收到的数据字节长度 byte[] data = packet.getData();//接收到数据 String s = new String(data, 0, length); System.out.println(s); //===回复信息给B端 //将需要发送的数据，封装到 DatagramPacket对象 data = "好的, 明天见".getBytes(); //说明: 封装的 DatagramPacket对象 data 内容字节数组 , data.length , 主机(IP) , 端口 packet = new DatagramPacket(data, data.length, InetAddress.getLocalHost(), 9998); socket.send(packet);//发送 //5. 关闭资源 socket.close(); System.out.println("A端退出..."); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
//UDPSenderB类 /** * 发送端B ====> 也可以接收数据 */ @SuppressWarnings({"all"}) public class UDPSenderB { public static void main(String[] args) throws IOException { //1.创建 DatagramSocket 对象，准备在9998端口 接收数据 DatagramSocket socket = new DatagramSocket(9998); //2. 将需要发送的数据，封装到 DatagramPacket对象 byte[] data = "hello 明天吃火锅~".getBytes(); // //说明: 封装的 DatagramPacket对象 data 内容字节数组 , data.length , 主机(IP) , 端口 DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getLocalHost(), 9999); socket.send(packet); //3.=== 接收从A端回复的信息 //(1) 构建一个 DatagramPacket 对象，准备接收数据 // 在前面讲解UDP 协议时，老师说过一个数据包最大 64k byte[] buf = new byte[1024]; packet = new DatagramPacket(buf, buf.length); //(2) 调用 接收方法, 将通过网络传输的 DatagramPacket 对象 // 填充到 packet对象 //老师提示: 当有数据包发送到 本机的9998端口时，就会接收到数据 // 如果没有数据包发送到 本机的9998端口, 就会阻塞等待. socket.receive(packet); //(3) 可以把packet 进行拆包，取出数据，并显示. int length = packet.getLength();//实际接收到的数据字节长度 data = packet.getData();//接收到数据 String s = new String(data, 0, length); System.out.println(s); //关闭资源 socket.close(); System.out.println("B端退出"); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
-
相关阅读:
身份证照片怎么弄成200k以内？三个方法轻松搞定！
【前端精进之路】JS篇：第4期 作用域
AWS SAA C003 Test --EBS snapshot
【SpringCloud学习笔记】Elasticsearch
VBA 浏览文件夹对话框调用的几种方法
Spring中的面试题01
dp练习2
面试必知的9个性能测试指标，你完全了解吗？
开源大数据工具整理
理解 Vue.js 中的 immediate: true
- 原文地址：https://blog.csdn.net/qq_45950109/article/details/133784505