Java学习-第一部分-第三阶段-第一节：网络编程

网络编程

笔记目录：(https://www.cnblogs.com/wenjie2000/p/16378441.html)
网络基础

网络通信

• 概念:两台设备之间通过网络实现数据传输
  
• 网络通信:将数据通过网络从一台设备传输到另一台设备
  
• java.net包下提供了一系列的类或接口,供程序员使用，完成网络通信
  

网络

• 概念:两台或多台设备通过一定物理设备连接起来构成了网络
  
• 根据网络的覆盖范围不同，对网络进行分类:
  局域网:覆盖范围最小，仅仅覆盖一个教室或一个机房
  城域网:覆盖范围较大，可以覆盖一个城市
  广域网:覆盖范围最大，可以覆盖全国，甚至全球,万维网是广域网的代表
  

ip地址

• 概念:用于唯一标识网络中的每台计算机
  
• 查看ip地址: ipconfig
  
• ip地址的表示形式:点分十进制XX.XX.XX.XX
  
• 每一个十进制数的范围:0~255
  
• ip地址的组成=网络地址+主机地址，比如:192.168.16.69
  
• IPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议，其地址数量号称可以为全世界的每一粒沙子编上一个地址[1]。
  
• 由于IPv4最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展。IPv6的使用，不仅能解决网络地址资源数量的问题，而且也解决了多种接入设备连入互联的障碍
  

ipv4地址分类


域名

• www.baidu.com
  
• 好处:为了方便记忆，解决记ip的困难
  
• 概念:将ip地址映射成域名(这里怎么映射上,HTTP协议)
  

端口号

• 概念:用于标识计算机上某个特定的网络程序
  
• 表示形式:以整数形式,范围0~65535【0--216】
  
• 0~1024已经被占用,比如ssh 22, ftp 21, smtp 25 http 80（在网络开发中，不要使用0-1024的端口名花有主.）
  
• 常见的网络程序端口号:
  tomcat :8080
  mysql:3306
  oracle:1521
  salserver:1433
  

网络通讯协议

网络通信协议(tcp/ip)
TCP/IP (Transmission ControlProtocol/Internet Protocol)的简写.中文译名为传输控制协议/因特网互联协议,又叫网络通讯协议,这个协议是lnternet最基本的协议、Internet国际互联网络的基础,简单地说，就是由网络层的IP协议和传输层的TCP协议组成的。[示意图]

网络通讯协议

TCP和UDP

TCP协议:传输控制协议

• 使用TCP协议前,须先建立TCP连接，形成传输数据通道
  
• 传输前，采用"三次握手"方式，是可靠的
  
• TCP协议进行通信的两个应用进程:客户端、服务端
  
• 在连接中可进行大数据量的传输
  
• 传输完毕，需释放已建立的连接,效率低
  
• 举例：打电话
  

UDP协议:用户数据协议

• 将数据、源、目的封装成数据包,不需要建立连接
  
• 每个数据报的大小限制在64K内,不适合传输大量数据
  
• 因无需连接，故是不可靠的
  
• 发送数据结束时无需释放资源(因为不是面向连接的)，速度快
  
• 举例:厕所通知，发短信，QQ给某人发消息 （直接发信息，不管是否能收到）
  

InetAddress

• 获取本机InetAddress对象getLocalHost
  
• 根据指定主机名/域名获取ip地址对象getByName
  
• 获取lnetAddress对象的主机名getHostName
  
• 获取InetAddress对象的地址getHostAddress
  

1. public static void main(String[] args) throws UnknownHostException {
2.     InetAddress localHost = InetAddress.getLocalHost();
3.     System.out.println(localHost);//DESKTOP-VUTHVJ2/192.168.1.173
5.     //2．根据指定主机名或ip获取InetAddress对象
6.     InetAddress host1 = InetAddress.getByName("DESKTOP-VUTHVJ2");
7.     System.out.println("host1=" + host1); //DESKTOP-VUTHVJ2/192.168.1.173
9.     //3．根据域名返回InetAddress对象，比如 www.baidu.com对应
10.     InetAddress host2 = InetAddress.getByName("www.baidu.com");
11.     System.out.println(host2);//www.baidu.com/39.156.66.14
13.     //4，通过InetAddress对象，获取对应的地址
14.     String hostAddress = host2.getHostAddress();
15.     System.out.println(hostAddress);//39.156.66.14
17.     //5．通过InetAddress对象，获取对应的主机名/或者的域名
18.     String hostName = host2.getHostName();
19.     System.out.println(hostName);//www.baidu.com
20. }

复制代码

Socket

基本介绍

• 套接字(Socket)开发网络应用程序被广泛采用，以至于成为事实上的标准。
  
• 通信的两端都要有Socket，是两台机器间通信的端点
  
• 网络通信其实就是Socket|间的通信。
  
• Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输。
  
• 一般主动发起通信的应用程序属客户端,等待通信请求的为服务端
  

示意图

TCP网络通信编程

基本介绍

• 基于客户端服务端的网络通信
  
• 底层使用的是TCP/IP协议
  
• 应用场景举例:客户端发送数据,服务端接受并显示控制台
  
• 基于Socket的TCP编程
  

应用案例1(使用字节流)

• 编写一个服务器端,和一个客户端
  
• 服务器端在9999端口监听
  
• 客户端连接到服务器端,，发送"hello, server"，然后退出
  
• 服务器端接收到客户端发送的信息,输出,并退出
  
  服务器代码
  1. import java.io.IOException;
  2. import java.io.InputStream;
  3. import java.net.ServerSocket;
  4. import java.net.Socket;
  6. public class SocketTCP01Server {
  7.     public static void main(String[] args) throws IOException {
  8.         //思路
  9.         //1.在本机的9999端口监听，等待连接
  10.         //细节:要求在本机没有其它服务在监听9999
  11.         ServerSocket serverSocket = new ServerSocket(9999);
  12.         System.out.println("服务端，在9999端口监听，等待连接..");
  13.         //2．当没有客户端连接9999端口时，程序会阻塞，等待连接
  14.         //如果有客户端连接，则会返回Socket对象，程序继续
  15.         //细节:这个ServerSocket可以通过accept()返回多个Socket[多个客户端连接服务器的并发]
  16.         Socket socket = serverSocket.accept();
  17.         System.out.println("服务器端socket ="+socket.getClass());
  18.         //
  19.         //3．通过socket.getInputStream()读取
  20.         InputStream inputStream = socket.getInputStream();
  21.         //4.IO读取
  22.         byte[] bytes = new byte[8];
  23.         int readLen=0;
  24.         while ((readLen=inputStream.read(bytes))!=-1){
  25.             System.out.print(new String(bytes,0,readLen));
  26.         }
  27.         //5.关闭流和socket
  28.         inputStream.close();
  29.         socket.close();
  30.         serverSocket.close();
  31.         //客户端写入到数据通道的数据，显示
  32.     }
  33. }

  复制代码
  客户端代码
  1. import java.io.IOException;
  2. import java.io.OutputStream;
  3. import java.net.InetAddress;
  4. import java.net.Socket;
  6. public class SocketTCP01Client {
  7.     public static void main(String[] args) throws IOException {
  8.         //思路
  9.         //1。连接服务端(ip,端口)
  10.         //解读:连接本机的9999端口，如果连接成功，返回Socket对象
  11.         Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
  12.         System.out.println("客户端socket返回=" + socket.getClass());
  13.         //2．连接上后，生成Socket，通过socket.getOutputStream()
  14.         //得到和socket对象关联的输出流对象
  15.         OutputStream outputStream = socket.getOutputStream();
  16.         //3．通过输出流，写入数据到数据通道
  17.         outputStream.write("hello,world".getBytes());
  18.         //关闭流对象
  19.         outputStream.close();
  20.         socket.close();
  21.         System.out.println("客户端退出");
  22.     }
  23. }

  复制代码

应用案例2(使用字节流)

• 编写一个服务嚣端,和一个客户端
  
• 服务器端在9999端口监听
  
• 客户端连接到服务器端，发送"hello, server",并接收服务器端回发的"hello,client",再退出
  
• 服务器端接收到客户端发送的信息,输出，并发送"hello, client",再退出
  示意图
  
  服务器代码
  1. import java.io.IOException;
  2. import java.io.InputStream;
  3. import java.io.OutputStream;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  7. public class SocketTCP01Server {
  8.     public static void main(String[] args) throws IOException {
  9.         //思路
  10.         //1.在本机的9999端口监听，等待连接
  11.         //细节:要求在本机没有其它服务在监听9999
  12.         ServerSocket serverSocket = new ServerSocket(9999);
  13.         System.out.println("服务端，在9999端口监听，等待连接..");
  14.         //2．当没有客户端连接9999端口时，程序会阻塞，等待连接
  15.         //如果有客户端连接，则会返回Socket对象，程序继续
  16.         //细节:这个ServerSocket可以通过accept()返回多个Socket[多个客户端连接服务器的并发]
  17.         Socket socket = serverSocket.accept();
  18.         System.out.println("服务器端socket ="+socket.getClass());
  19.         //
  20.         //3．通过socket.getInputStream()读取
  21.         InputStream inputStream = socket.getInputStream();
  22.         //4.IO读取
  23.         byte[] bytes = new byte[8];
  24.         int readLen=0;
  25.         while ((readLen=inputStream.read(bytes))!=-1){
  26.             System.out.print(new String(bytes,0,readLen));
  27.         }
  28.         
  29.         OutputStream outputStream = socket.getOutputStream();
  30.         outputStream.write("hello, client".getBytes());
  31.         //设置结束标记
  32.         socket.shutdownOutput();
  34.         //5.关闭流和socket
  35.         inputStream.close();
  36.         outputStream.close();
  37.         socket.close();
  38.         serverSocket.close();
  39.         //客户端写入到数据通道的数据，显示
  40.     }
  41. }

  复制代码
  客户端代码
  1. import java.io.IOException;
  2. import java.io.InputStream;
  3. import java.io.OutputStream;
  4. import java.net.InetAddress;
  5. import java.net.Socket;
  7. public class SocketTCP01Client {
  8.     public static void main(String[] args) throws IOException {
  9.         //思路
  10.         //1。连接服务端(ip,端口)
  11.         //解读:连接本机的9999端口，如果连接成功，返回Socket对象
  12.         Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
  13.         System.out.println("客户端socket返回=" + socket.getClass());
  14.         //2．连接上后，生成Socket，通过socket.getOutputStream()
  15.         //得到和socket对象关联的输出流对象
  16.         OutputStream outputStream = socket.getOutputStream();
  17.         //3．通过输出流，写入数据到数据通道
  18.         outputStream.write("hello,server".getBytes());
  19.         //设置结束标记
  20.         socket.shutdownOutput();
  22.         InputStream inputStream = socket.getInputStream();
  23.         int readLen=0;
  24.         byte[] bytes = new byte[8];
  25.         while ((readLen=inputStream.read(bytes))!=-1){
  26.             System.out.print(new String(bytes,0,readLen));
  27.         }
  28.         //关闭流对象
  29.         inputStream.close();
  30.         outputStream.close();
  31.         socket.close();
  32.         System.out.println("客户端退出");
  34.     }
  35. }

  复制代码

应用案例3(使用字符流)

• 编写一个服务端,和一个客户端
  
• 服务端在9999端口监听
  
• 客户端连接到服务端，发送"hello, server",并接收服务端回发的"hello,client",再退出
  
• 服务端接收到客户端发送的信息,输出,并发送"hello, client",再退出
  示意图
  
  服务器端代码
  1. import java.io.*;
  2. import java.net.ServerSocket;
  3. import java.net.Socket;
  5. public class SocketTCP01Server {
  6.     public static void main(String[] args) throws IOException {
  7.         //思路
  8.         //1.在本机的9999端口监听，等待连接
  9.         //细节:要求在本机没有其它服务在监听9999
  10.         ServerSocket serverSocket = new ServerSocket(9999);
  11.         System.out.println("服务端，在9999端口监听，等待连接..");
  12.         //2．当没有客户端连接9999端口时，程序会阻塞，等待连接
  13.         //如果有客户端连接，则会返回Socket对象，程序继续
  14.         //细节:这个ServerSocket可以通过accept()返回多个Socket[多个客户端连接服务器的并发]
  15.         Socket socket = serverSocket.accept();
  16.         System.out.println("服务器端socket ="+socket.getClass());
  17.         //
  18.         //3．通过socket.getInputStream()读取
  19.         InputStream inputStream = socket.getInputStream();
  20.         //4.IO读取，使用字符流
  21.         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
  22.         String s = bufferedReader.readLine();
  23.         System.out.println(s);
  25.         //获取socket关联的输出流
  26.         OutputStream outputStream = socket.getOutputStream();
  27.         BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
  28.         bufferedWriter.write("hello, client 字符流");
  29.         bufferedWriter.newLine();//表示恢复内容结束
  30.         bufferedWriter.flush();
  33.         //5.关闭流和socket
  34.         bufferedReader.close();
  35.         bufferedWriter.close();
  36.         socket.close();
  37.         serverSocket.close();
  38.         //客户端写入到数据通道的数据，显示
  39.     }
  40. }

  复制代码
  客户端代码
  1. import java.io.*;
  2. import java.net.InetAddress;
  3. import java.net.Socket;
  5. public class SocketTCP01Client {
  6.     public static void main(String[] args) throws IOException {
  7.         //思路
  8.         //1。连接服务端(ip,端口)
  9.         //解读:连接本机的9999端口，如果连接成功，返回Socket对象
  10.         Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
  11.         System.out.println("客户端socket返回=" + socket.getClass());
  12.         //2．连接上后，生成Socket，通过socket.getOutputStream()
  13.         //得到和socket对象关联的输出流对象
  14.         OutputStream outputStream = socket.getOutputStream();
  15.         //3．通过输出流，写入数据到数据通道,使用字符流
  16.         BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
  17.         bufferedWriter.write("hello,server 字符流");
  18.         bufferedWriter.newLine();//插入一个换行符,表示写入的内容结束，注意，要求对方使用readLine()!!否者读不到结束
  19.         bufferedWriter.flush();//如果使用的字符流，需要手动刷新，否则数据不会写入数据通道
  21.         //4。获取和socket关联的输入流。读取数据(字符)，并显示
  22.         InputStream inputStream = socket.getInputStream();
  23.         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
  24.         String s = bufferedReader.readLine();
  25.         System.out.println(s);
  27.         //关闭流对象
  28.         bufferedReader.close();//关闭外层流
  29.         bufferedWriter.close();
  30.         socket.close();
  31.         System.out.println("客户端退出");
  33.     }
  34. }

  复制代码

应用案例4

• 编写一个服务端,和一个客户端
  
• 服务器端在8888端口监听
  
• 客户端连接到服务端，发送一张图片d:\qie.png
  
• 服务器端接收到客户端发送的图片，保存到src下,发送"收到图片”再退出
  
• 客户端接收到服务端发送的“收到图片”，再退出
  服务器端代码
  1. import java.io.*;
  2. import java.net.ServerSocket;
  3. import java.net.Socket;
  5. public class SocketTCP01Server {
  6.     public static void main(String[] args) throws IOException {
  8.         ServerSocket serverSocket = new ServerSocket(8888);
  9.         System.out.println("服务端，在8888端口监听，等待连接..");
  10.         Socket socket = serverSocket.accept();
  11.         System.out.println("服务器端socket =" + socket.getClass());
  12.         InputStream inputStream = socket.getInputStream();
  14.         FileOutputStream fileOutputStream = new FileOutputStream("src\\(1).png");
  15.         byte[] bytes = new byte[1024];
  16.         int readLen;
  17.         while ((readLen = inputStream.read(bytes)) != -1) {
  18.              fileOutputStream.write(bytes,0,readLen);
  19.         }
  20.         System.out.println("收到");
  22.         OutputStream outputStream = socket.getOutputStream();
  23.         OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream);
  24.         outputStreamWriter.write("收到图片");
  25.         outputStreamWriter.flush();
  26.         socket.shutdownOutput();
  28.         outputStreamWriter.close();
  29.         fileOutputStream.close();
  30.         inputStream.close();
  31.         socket.close();
  32.         serverSocket.close();
  34.         System.out.println("服务器端结束");
  35.     }
  36. }

  复制代码
  客户端代码
  1. import java.io.*;
  2. import java.net.InetAddress;
  3. import java.net.Socket;
  4. //代码还可以继续优化
  5. public class SocketTCP01Client {
  6.     public static void main(String[] args) throws IOException {
  7.         Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
  8.         System.out.println("客户端socket返回=" + socket.getClass());
  10.         FileInputStream fileInputStream = new FileInputStream("D:\\(1).png");
  11.         byte[] bytes = new byte[1024];
  12.         int len;
  13.         OutputStream outputStream = socket.getOutputStream();
  14.         while ((len = fileInputStream.read(bytes)) != -1) {
  15.             outputStream.write(bytes,0,len);
  16.         }
  17.         socket.shutdownOutput();
  19.         InputStream inputStream = socket.getInputStream();
  20.         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
  21.         System.out.println(bufferedReader.readLine());
  23.         bufferedReader.close();
  24.         outputStream.close();
  25.         fileInputStream.close();
  26.         socket.close();
  28.         System.out.println("客户端退出");
  29.     }
  30. }

  复制代码

编程题

• 编写客户端程序和服务器端程序
  
• 客户端可以输入一个音乐文件名，比如高山流水,服务端收到音乐名后，可以给客户端返回这个音乐文件，如果服务器没有这个文件，返回一个默认的音乐即可.
  
• 客户端收到文件后，保存到本地d:\\
  
• 提示:该程序可以使用StreamUtils.java
  本质:其实就是指定下载文件的应用.结合文件上传来做。
  服务器端 代码
  1. import java.io.*;
  2. import java.net.*;
  4. //服务器端
  5. public class B {
  6.     public static void main(String[] args) throws IOException {
  7.         ServerSocket serverSocket = new ServerSocket(9000);
  8.         Socket socket = serverSocket.accept();
  9.         InputStream inputStream = socket.getInputStream();
  11.         byte[] bytes = new byte[1024];
  12.         int bytesLen;
  13.         String s="";
  14.         while ((bytesLen=inputStream.read(bytes))!=-1){
  15.             s+=new String(bytes,0,bytesLen);
  16.         }
  18.         File file = new File("src\",s);
  19.         System.out.println("文件名：" +file.getPath());
  20.         BufferedInputStream bufferedInputStream;
  21.         if (file.exists()) {
  22.             System.out.println("找到文件");
  23.             bufferedInputStream= new BufferedInputStream(new FileInputStream(file));
  24.         }else {
  25.             System.out.println("未找到该文件");
  26.             bufferedInputStream= new BufferedInputStream(new FileInputStream("src\\22.mp4"));
  27.         }
  29.         ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
  30.         while ((bytesLen=bufferedInputStream.read(bytes))!=-1){
  31.             byteArrayOutputStream.write(bytes,0,bytesLen);
  32.         }
  33.         BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(socket.getOutputStream());
  34.         bytes = byteArrayOutputStream.toByteArray();
  35.         bufferedOutputStream.write(bytes);
  36.         bufferedOutputStream.flush();
  37.         socket.shutdownOutput();
  39.         bufferedOutputStream.close();
  40.         bufferedInputStream.close();
  41.         socket.close();
  42.         serverSocket.close();
  43.     }
  44. }

  复制代码
  客户端 代码
  1. import java.io.*;
  2. import java.net.InetAddress;
  3. import java.net.Socket;
  4. import java.util.Scanner;
  7. //客户端
  8. public class A {
  9.     public static void main(String[] args) throws IOException {
  10.         Socket socket = new Socket(InetAddress.getLocalHost(), 9000);
  11.         OutputStream outputStream = socket.getOutputStream();
  13.         System.out.println("请输入文件名：");
  14.         Scanner scanner = new Scanner(System.in);
  15.         String s = scanner.next();
  16.         outputStream.write(s.getBytes());
  17.         socket.shutdownOutput();
  18.         System.out.println("等待中");
  20.         BufferedInputStream bufferedInputStream = new BufferedInputStream(socket.getInputStream());
  21.         ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
  22.         byte[] bytes = new byte[1024];
  23.         int bytesLen;
  24.         while ((bytesLen=bufferedInputStream.read(bytes))!=-1){
  25.             byteArrayOutputStream.write(bytes,0,bytesLen);
  26.         }
  27.         BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("d:\"+s));
  28.         bufferedOutputStream.write(byteArrayOutputStream.toByteArray());
  30.         bufferedOutputStream.close();
  31.         byteArrayOutputStream.close();
  32.         bufferedInputStream.close();
  33.         outputStream.close();
  34.         socket.close();
  35.     }
  36. }

  复制代码

netstat 指令

• netstat -an可以查看当前主机网络情况，包括端口监听情况和网络连接情况(netstat -anb 可以看到哪个程序在使用这些端口)
  
• netstat -an | more可以分页显示
  
• 要求在dos控制台下执行
  

说明:
(1) Listening表示某个端口在监听
(2)如果有一个外部程序(客户端)连接到该端口，就会显示一条连接信息.
(3)可以输入ctrl +c退出指令
TCP网络通讯不为人知的秘密

• 当客户端连接到服务端后，实际上客户端也是通过一个端口和服务端进行通讯的，这
  个端口是TCP/IP来分配的，是不确定的。
  
• 程序验证
  

UDP编程

基本介绍

• 类 DatagramSocket和 DatagramPacket实现了基于UDP协议网络程序。
  
• UDP数据报通过数据报套接字DatagramSocket发送和接收，系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。
  
• DatagramPacket 对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号。
  
• UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接
  

基本流程

• 核心的两个类/对象DatagramSocket与DatagramPacket
  
• 建立发送端，接收端
  
• 建立数据包
  
• 调用DatagramSocket的发送、接收方法5.关闭DatagramSocket
  

应用案例

• 编写一个接收端A,和一个发送端B
  
• 接收端A在9999端口等待接收数据(receive)
  
• 发送端B向接收端A发送数据"hello，明天吃火锅~"
  
• 接收端A接收到发送端B发送的数据，回复"好的,明天见",再退出
  
• 发送端接收回复的数据，再退出
  

A端口 代码

1. import java.io.IOException;
2. import java.net.DatagramPacket;
3. import java.net.DatagramSocket;
4. import java.net.InetAddress;
6. public class A {
7.     public static void main(String[] args) throws IOException {
8.         //1。创建一个DatagramSocket对象，准备在9999接收数据
9.         DatagramSocket socket = new DatagramSocket(9999);
10.         //2。构建一个DatagramPacket 对象，准备接收数据
11.         //在前面讲解UDP协议时，一个数据包最大64k
12.         byte[] buf = new byte[1024];
13.         DatagramPacket packet = new DatagramPacket(buf, buf.length);
14.         //3．调用接收方法，将通过网络传输的DatagramPacket对象
15.         // 填充到 packet对象
16.         //提示:当有数据包发送到本机的9999端口时，就会接收到数据
17.         // 如果没有数据包发送到本机的9999端口，就会阻塞等待。
18.         System.out.println("接收端A等待接收数据..");
19.         socket.receive(packet);
21.         //4。可以把packet进行拆包，取出数据，并显示。
22.         int length = packet.getLength();//实际接收到的数据字节长度
23.         byte[] data = packet.getData();//接收到数据
24.         String s = new String(data, 0, length);
25.         System.out.println(s);
27.         data="好的,明天见".getBytes();
28.         DatagramPacket packet1 = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.1.173"), 9998);
29.         socket.send(packet1);
31.         socket.close();
33.         System.out.println("A退出");
34.     }
35. }

复制代码

B端口代码

1. import java.io.IOException;
2. import java.net.*;
4. public class B {
5.     public static void main(String[] args) throws IOException {
6.         //1.创建DatagramSocket对象，准备在9998端口接收数据
7.         DatagramSocket socket = new DatagramSocket(9998);
8.         //2．将需要发送的数据，封装到DatagramPacket对象
9.         byte[] data="hello，明天吃火锅~".getBytes();
10.         //说明:封装的DatagramPacket对象 data 内容字节数组，data.length ，主机(IP)，端口
11.         DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.1.173"), 9999);
12.         socket.send(packet);
14.         System.out.println("接收端B等待回复数据..");
15.         byte[] buf = new byte[1024];
16.         packet = new DatagramPacket(buf, buf.length);
17.         socket.receive(packet);
19.         //4。可以把packet进行拆包，取出数据，并显示。
20.         int length = packet.getLength();//实际接收到的数据字节长度
21.         data = packet.getData();//接收到数据
22.         String s = new String(data, 0, length);
23.         System.out.println(s);
25.         //关闭资源
26.         socket.close();
27.         System.out.println("B退出");
29.     }
30. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！