Java --> 网络编程

端口号

 1 import java.net.InetAddress;
 2 
 3 public class InetAddressDemo {
 4     public static void main(String[] args) throws Exception{
 5         InetAddress localHost = InetAddress.getLocalHost();
 6         System.out.println(localHost); //重写了toString
 7         System.out.println(localHost.getHostName());
 8         System.out.println(localHost.getHostAddress());
 9 
10         System.out.println("---------------------------");
11 
12         //获取域名ip对象
13         InetAddress localHost2 = InetAddress.getByName("www.baidu.com");
14         System.out.println(localHost2);
15         System.out.println(localHost2.getHostName());
16         System.out.println(localHost2.getHostAddress());
17 
18         System.out.println("---------------------------");
19 
20         //获取公网ip对象
21         InetAddress localHost3 = InetAddress.getByName("110.242.68.4");
22         System.out.println(localHost3);
23         System.out.println(localHost3.getHostName());
24         System.out.println(localHost3.getHostAddress());
25 
26         System.out.println("---------------------------");
27 
28         //判断是否互通：ping 5s之前测试是否可通
29         System.out.println(localHost3.isReachable(5000)); //5s能否和百度连通
30     }
31 }

ps : 由于个人IPv4的地址属于个人隐私，结果就不完全展示了，在此就打了个小小的🐎塞克~

UDP通信快速入门

UDP通信：一发、一收

需求：客户端实现步骤

创建DatagramSocket对象（发送端对象） --> 仍韭菜的人
创建DatagramPacket对象封装需要发送的数据（数据包对象）--> 韭菜盘子
使用DatagramSocket对象的send方法传入DatagramPacket对象 --> 开始抛出韭菜
释放资源

需求：接收端实现步骤

创建DatagramSocket对象并指定端口（接收端对象） --> 接韭菜的人
创建DatagramPacket对象接收数据（数据包对象） --> 韭菜盘子
使用DatagramSocket对象的receive方法传入Datagrampacket对象 --> 开始接收韭菜
释放资源

 1 import java.net.DatagramPacket;
 2 import java.net.DatagramSocket;
 3 import java.net.InetAddress;
 4 
 5 //发送端 【一发、一收】
 6 public class ClientDemo2 {
 7     public static void main(String[] args) throws Exception{
 8         System.out.println("============客户端启动==============");
 9         //1、创建发送端对象,发送端自带默认的端口号（人）
10         //【亦可在构造器中指定端口号
11         //DatagramSocket socket = new DatagramSocket(6666);
12         DatagramSocket socket = new DatagramSocket();
13 
14         //2、创建一个数据包对象封装数据（韭菜盘子）
15         //public DatagramPacket(byte buf[], int offset, int length, SocketAddress address)
16         /**
17          * 参数一 ： 封装要发送的数据【韭菜】
18          * 参数二 ：发送数据的大小【作用：做只发送部分数据的需要】
19          * 参数三 ：服务端的IP地址(接收方)
20          * 参数四 ：对方的端口
21          */
22         byte[] buf = "我是一盘韭菜".getBytes();
23         //DatagramPacket packet = new DatagramPacket(buf,buf.length, InetAddress.getByName(),);
24         DatagramPacket packet = new DatagramPacket(buf,buf.length, InetAddress.getLocalHost(),8888);
25 
26         //3、发送数据出去
27         socket.send(packet);
           socket.close(); //释放资源
28     }
29 }

 1 import java.net.DatagramPacket;
 2 import java.net.DatagramSocket;
 3 
 4 //服务端
 5 public class ServerDemo1 {
 6     public static void main(String[] args) throws Exception{
 7         System.out.println("============服务端启动==============");
 8         //1、创建接收端对象：注册端口（人）
 9         DatagramSocket socket = new DatagramSocket(8888);
10 
11         //2、创建一个数据包对象接收数据 （韭菜盘子）【规定盘子大小和能接收多少数据】
12         //public DatagramPacket(byte buf[], int length)
13         byte[] buf = new byte[1024 * 64];
14         DatagramPacket packet = new DatagramPacket(buf,buf.length);
15 
16         //3、接收数据
17         socket.receive(packet);
18 
19         //4、取出数据【收到多少，倒出多少】
20         int len = packet.getLength();
21         String str = new String(buf,0,len);
22         System.out.println("收到数据：" + str);
23 
24         //拓展：获取发送端的ip和端口
25         String ip = packet.getSocketAddress().toString();
26         System.out.println(ip);
27         int port = packet.getPort();
28         System.out.println(port);
29 
30         //5、关闭管道【释放资源】
31         socket.close();
32     }
33 }

UDP通信：多发、多收（多收的原因：接收端只负责接收数据包，无所谓是哪个发送端的数据包）

需求：发送端可以不断发送数据
客户端实现步骤

创建DatagramSocket对象（发送端对象） --> 扔韭菜的人
使用while死循环不断的接收用户的数据输入，如果用户输入exit则退出程序
如果用户输入的不是exit，则把数据封装成DatagramPacket -->韭菜盘子
使用DatagramSocket对象的send方法将数据包对象进行发送 -->开始抛出韭菜
释放资源

接收端实现步骤

创建DatagramSocket对象并指定端口(接收端对象) --> 接韭菜的人
创建DatagramPacket对象接收数据（数据包对象） --> 韭菜盘子
使用while循环不断地进行第四步
使用DatagramSocket对象的receive方法传入DatagramPacket对象 --> 开始接收韭菜

 1 import java.net.DatagramPacket;
 2 import java.net.DatagramSocket;
 3 import java.net.InetAddress;
 4 import java.util.Scanner;
 5 
 6 //发送端 【多发、多收】
 7 public class ClientDemo2 {
 8     public static void main(String[] args) throws Exception{
 9         System.out.println("============客户端启动==============");
10         //1、创建发送端对象,发送端自带默认的端口号（人）
11         //【亦可在构造器中指定端口号
12         DatagramSocket socket = new DatagramSocket(6666);
13         //DatagramSocket socket = new DatagramSocket(4567);
14 
15         //2、创建一个数据包对象封装数据（韭菜盘子）
16         //public DatagramPacket(byte buf[], int offset, int length, SocketAddress address)
17         /**
18          * 参数一 ： 封装要发送的数据【韭菜】
19          * 参数二 ：发送数据的大小【作用：做只发送部分数据的需要】
20          * 参数三 ：服务端的IP地址(接收方)
21          * 参数四 ：对方的端口
22          */
23         Scanner sc = new Scanner(System.in);
24         while (true) {
25             System.out.println("请说话：");
26             String msg = sc.nextLine();
27             if ("exit".equals(msg)){
28                 System.out.println("离线成功~");
29                 //释放资源
30                 socket.close();
31                 break;
32             }
33             byte[] buf = msg.getBytes();
34             //DatagramPacket packet = new DatagramPacket(buf,buf.length, InetAddress.getByName(),);
35             DatagramPacket packet = new DatagramPacket(buf,buf.length, InetAddress.getLocalHost(),8888);
36 
37             //3、发送数据出去
38             socket.send(packet);
39         }
40     }
41 }

 1 import java.net.DatagramPacket;
 2 import java.net.DatagramSocket;
 3 
 4 //服务端
 5 public class ServerDemo1 {
 6     public static void main(String[] args) throws Exception{
 7         System.out.println("============服务端启动==============");
 8         //1、创建接收端对象：注册端口（人）
 9         DatagramSocket socket = new DatagramSocket(8888);
10 
11         //2、创建一个数据包对象接收数据 （韭菜盘子）【规定盘子大小和能接收多少数据】
12         //public DatagramPacket(byte buf[], int length)
13         byte[] buf = new byte[1024 * 64];
14         DatagramPacket packet = new DatagramPacket(buf,buf.length);
15 
16         while (true) {
17             //3、接收数据
18             socket.receive(packet);
19 
20             //4、取出数据【收到多少，倒出多少】
21             int len = packet.getLength();
22             String str = new String(buf,0,len);
23             System.out.println("收到了来自" + packet.getAddress() + "的数据，对方的端口是：" + packet.getPort() + ",消息内容为：" + str);
24 
25             //拓展：获取发送端的ip和端口
26 //            String ip = packet.getSocketAddress().toString();
27 //            System.out.println(ip);
28 //            int port = packet.getPort();
29 //            System.out.println(port);
30         }
31 
32         //5、关闭管道【释放资源】
33         //socket.close();
34     }
35 }

idea多开应用程序实例设置【并发】

客户端并发启动需要注意的问题：BindException异常（Address already in use : bind）

连接异常，地址已经被使用，

UDP通信 -- 广播：

 1 import java.net.DatagramPacket;
 2 import java.net.DatagramSocket;
 3 import java.net.InetAddress;
 4 import java.util.Scanner;
 5 
 6 //发送端 【多发、多收】
 7 public class ClientDemo2 {
 8     public static void main(String[] args) throws Exception{
 9         System.out.println("============客户端启动==============");
10         //1、创建发送端对象,发送端自带默认的端口号（人）
11         //【亦可在构造器中指定端口号
12         DatagramSocket socket = new DatagramSocket(6666);
13 
14         //2、创建一个数据包对象封装数据（韭菜盘子）
15         Scanner sc = new Scanner(System.in);
16         while (true) {
17             System.out.println("请说话：");
18             String msg = sc.nextLine();
19             if ("exit".equals(msg)){
20                 System.out.println("离线成功~");
21                 //释放资源
22                 socket.close();
23                 break;
24             }
25             byte[] buf = msg.getBytes();
26             DatagramPacket packet = new DatagramPacket(buf,buf.length, InetAddress.getByName("255.255.255.255"),9999);
27 
28             //3、发送数据出去
29             socket.send(packet);
30         }
31     }
32 }

 1 import java.net.DatagramPacket;
 2 import java.net.DatagramSocket;
 3 
 4 //服务端
 5 public class ServerDemo1 {
 6     public static void main(String[] args) throws Exception{
 7         System.out.println("============服务端启动==============");
 8         //1、创建接收端对象：注册端口（人）
 9         DatagramSocket socket = new DatagramSocket(9999); //端口号指定为：9999
10 
11         //2、创建一个数据包对象接收数据 （韭菜盘子）【规定盘子大小和能接收多少数据】
12         //public DatagramPacket(byte buf[], int length)
13         byte[] buf = new byte[1024 * 64];
14         DatagramPacket packet = new DatagramPacket(buf,buf.length);
15 
16         while (true) {
17             //3、接收数据
18             socket.receive(packet);
19 
20             //4、取出数据【收到多少，倒出多少】
21             int len = packet.getLength();
22             String str = new String(buf,0,len);
23             System.out.println("收到了来自" + packet.getAddress() + "的数据，对方的端口是：" + packet.getPort() + ",消息内容为：" + str);
24         }
25     }
26 }

UDP通信 -- 组播

运行示例：

posted @ 2022-07-25 00:06 羽梦齐飞阅读(30) 评论(0) 编辑收藏举报

刷新页面返回顶部

Java --> 网络编程

公告