java之DatagramSocket、DatagramPackage丶MulticastSocket 广播学习

 

1.基本概念：

　　a.DatagramPacket与DatagramSocket位于java.net包中

　　b.DatagramPacket表示存放数据的数据报，DatagramSocket表示接受或发送数据报的套接字

　　c.由这两个类所有构成的网络链接是基于UDP协议，是一种不可靠的协议。

　　之所以不可靠是因为发送方不负责数据是否发送成功，接收方收到数据时也不会 　　向发送方反馈成功消息，容易导致信息的丢失。

　　但是这种协议却是快捷的，比如CS(半条命)游戏就是基于UDP协议，否则我们估计 　　要玩一次游戏后就会把机子砸了，所以我们可以看到游戏有时会失帧。

　　2.使用方法：

　　要建立基于UDP协议的链接，我们应该先建立套接字(即发送站或接收站),之后通过套接字发送或接受数据。

　　我们先了解一下DatagramSocket和DatagramPacket类

　　DatagramSocket类：

　　构造方法：

　　DatagramSocket():

　　表示创建一个默认的套接字，并绑定到本地地址和一个随机的端口号

　　DatagramSocket(int port):

　　与上面不同的是，绑定到特定端口号，其它不变

　　DatagramSocket(int port, InetAddress iad):

　　表示创建一个套接字，绑定到特定的端口号及指定地址

　　DatagramSocket(SocketAddress sad);

　　表示创建一个套接字，绑定到特定的套接字地址

　　小提示：所谓的本地地址我们可以这样来理解，我们通过“控制面板-本地连接-支持”中可以看到一个IP地址，这就是本地的IP地址，也暂且理解为本地地址。

　　基本方法：

　　close():

　　关闭套接字

　　recevie(DatagramPacket dp):

　　接受数据报

　　send(DatagramPacket dp):

　发送数据报

　　这里触及了数据报，下面介绍数据报：

　　DatagramPacket类：

　　构造方法：(只列出主要的)

　　接受类型：

　　DatagramPacket(byte[] buf, int length):

　　用来接受长度为length的buf数据(即数据存于字节数组buf中)

　　发送类型：

　　DatagramPacket(byte[] buf, int length, InetAddress address, int port);

　　将length长的buf数据发送到指定的地址的端口号处

　　DatagramPacket(byte[] buf, int length, SocketAddress address);

　　　将length长的buf数据发送到指定的套接字地址处

　　有上面可知，我们发送数据时构造的数据报应该是发送类型的，而接受数据报时应该是接受类型的　 　　

　　开始书写代码

　　代码意图：

　　1.一个接收方，一个发送方

　　2.当接收方收到发送方发送的消息后，打印发送的消息及发送方的地址和端口号，之后向发送反馈一条信息“接受方：我收到了！”

　　3.发送方打印出接收方反馈的消息

　　详细思路见代码：

 

[java] view plaincopyprint?

 

1. import java.net.DatagramPacket;  
2. import java.net.DatagramSocket;  
3. import java.net.InetAddress;  
4. public class Sender {  
5.     public static void main(String[] args) {  
6.         try {  
7.             // 创建发送方的套接字，IP默认为本地，端口号随机  
8.             DatagramSocket sendSocket = new DatagramSocket();  
9.             // 确定要发送的消息：  
10.             String mes = "你好！接收方！";  
11.             // 由于数据报的数据是以字符数组传的形式存储的，所以传转数据  
12.             byte[] buf = mes.getBytes();  
13.             // 确定发送方的IP地址及端口号，地址为本地机器地址  
14.             int port = 8888;  
15.             InetAddress ip = InetAddress.getLocalHost();  
16.             // 创建发送类型的数据报：  
17.             DatagramPacket sendPacket = new DatagramPacket(buf, buf.length, ip,  
18.                     port);  
19.             // 通过套接字发送数据：  
20.             sendSocket.send(sendPacket);  
21.             // 确定接受反馈数据的缓冲存储器，即存储数据的字节数组  
22.             byte[] getBuf = new byte[1024];  
23.             // 创建接受类型的数据报  
24.             DatagramPacket getPacket = new DatagramPacket(getBuf, getBuf.length);  
25.             // 通过套接字接受数据  
26.             sendSocket.receive(getPacket);  
27.             // 解析反馈的消息，并打印  
28.             String backMes = new String(getBuf, 0, getPacket.getLength());  
29.             System.out.println("接受方返回的消息：" + backMes);  
30.             // 关闭套接字  
31.             sendSocket.close();  
32.         } catch (Exception e) {  
33.             e.printStackTrace();  
34.         }  
35.     }  
36. }  
37. import java.net.DatagramPacket;  
38. import java.net.DatagramSocket;  
39. import java.net.InetAddress;  
40. import java.net.SocketAddress;  
41. public class Receive {  
42.     public static void main(String[] args) {  
43.         try {  
44.             // 确定接受方的IP和端口号，IP地址为本地机器地址  
45.             InetAddress ip = InetAddress.getLocalHost();  
46.             int port = 8888;  
47.             // 创建接收方的套接字,并制定端口号和IP地址  
48.             DatagramSocket getSocket = new DatagramSocket(port, ip);  
49.             // 确定数据报接受的数据的数组大小  
50.             byte[] buf = new byte[1024];  
51.             // 创建接受类型的数据报，数据将存储在buf中  
52.             DatagramPacket getPacket = new DatagramPacket(buf, buf.length);  
53.             // 通过套接字接收数据  
54.             getSocket.receive(getPacket);  
55.             // 解析发送方传递的消息，并打印  
56.             String getMes = new String(buf, 0, getPacket.getLength());  
57.             System.out.println("对方发送的消息：" + getMes);  
58.             // 通过数据报得到发送方的IP和端口号，并打印  
59.             InetAddress sendIP = getPacket.getAddress();  
60.             int sendPort = getPacket.getPort();  
61.             System.out.println("对方的IP地址是：" + sendIP.getHostAddress());  
62.             System.out.println("对方的端口号是：" + sendPort);  
63.             // 通过数据报得到发送方的套接字地址  
64.             SocketAddress sendAddress = getPacket.getSocketAddress();  
65.             // 确定要反馈发送方的消息内容，并转换为字节数组  
66.             String feedback = "接收方说：我收到了！";  
67.             byte[] backBuf = feedback.getBytes();  
68.             // 创建发送类型的数据报  
69.             DatagramPacket sendPacket = new DatagramPacket(backBuf,  
70.                     backBuf.length, sendAddress);  
71.             // 通过套接字发送数据  
72.             getSocket.send(sendPacket);  
73.             // 关闭套接字  
74.             getSocket.close();  
75.         } catch (Exception e) {  
76.             e.printStackTrace();  
77.         }  
78.     }  
79. }  

80. 使用MulticastSocket实现多点广播

     

    DatagramSocket只允许数据报发送给指定的目标地址，而MulticastSocket可以将数据报以广播的方式发送到多个客户端

     

    若要使用多点广播，则需要让一个数据报标有一组目标主机地址，当数据报发出后，整个组的所有所有主机都能收到该数据报。IP多点广播（或多点发送）实现了将单一信息发送到多个接受者的广播，其思想是设置一组特殊网络地址作为多点广播地址，每一个多点广播地址都被看做一个组，当客户端需要发送、接收广播信息时，加入到改组即可。

    MulticastSocket既可以将数据报发送到多点广播地址，也可以接收其他主机的广播信息。

     

    

     

        MulticastSocket有点像DatagramSocket,事实上MulitcastSocket是DatagramSocket的一个子类，当要发送一个数据报时，可以使用随机端口创建一个MulticastSocket,也可以在指定端口创建MulticastSocket。MulticastSocket提供了如下3个构造器。

    1、MulticastSocket():使用本机默认地址、随机端口来创建MulticastSocket对象

    2、MulticastSocket(int portNumber)使用本机默认地址、指定端口来创建对象

    3、MulticastSocket(SocketAddress bindaddr):使用本机指定IP地址、指定端口来创建对象

     

        创建MulticastSocket对象后，还需要将该MulticastSocket加入到指定的多点广播地址，MulticastSocket使用joinGroup()方法加入指定组；使用leaveGroup()方法脱离一个组。

    1、joinGroup(InetAddress multicastAddr)：将该MulticastSocket加入指定的多点广播地址。

    2、leaveGroup(InetAddress multicastAddr)：让该MulticastSocket离开指定的多点广播地址。

     

    应用程序只将数据报包发送给组播地址，路由器将确保包被发送到改组播组中的所有主机。 
    组播地址：称为组播组的一组主机所共享的地址。组播地址的范围在224.0.0.0--- 239.255.255.255之间（都为D类地址 1110开头）。 

    备注：如果现在有三台机器A、B、C，三台机器IP地址都不一样，A\B为server监听广播消息，C为客户端发送广播消息，个人理解是将A、B两台机器的MulticastSocket对象绑定在组播地址中的其中一个，然后C客户端发送消息的组播地址一致，则A、B就能够接收C发送的消息。

     

     

    如果MulticastSocket用于接收信息则使用默认地址和随机端口即可，但是如果用来接收信息，则必须要指定端口，否则发送方无法确定发送数据报的目标端口。

     

    package hb.brodcast;
    
    import java.net.DatagramPacket;
    import java.net.InetAddress;
    import java.net.MulticastSocket;
    
    public class MulticastListener {
        private int port;
        private String host;
    
        public MulticastListener(String host, int port) {
            this.host = host;
            this.port = port;
        }
    
        public void listen() {
            byte[] data = new byte[256];
            try {
                InetAddress ip = InetAddress.getByName(this.host);
                MulticastSocket ms = new MulticastSocket(this.port);
                ms.joinGroup(ip);
                DatagramPacket packet = new DatagramPacket(data, data.length);
                //receive()是阻塞方法，会等待客户端发送过来的信息
                ms.receive(packet);
                String message = new String(packet.getData(), 0, packet.getLength());
                System.out.println(message);
                ms.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        public static void main(String[] args) {
            int port = 1234;
            String host = "224.0.0.1";
            MulticastListener ml = new MulticastListener(host, port);
            while (true) {
                ml.listen();
            }
        }
    }

     

    package hb.brodcast;
    
    import java.net.DatagramPacket;
    import java.net.InetAddress;
    import java.net.MulticastSocket;
    
    public class MulticastSender {
        private int port;
        private String host;
        private String data;
    
        public MulticastSender(String data, String host, int port) {
            this.data = data;
            this.host = host;
            this.port = port;
        }
    
        public void send() {
            try {
                InetAddress ip = InetAddress.getByName(this.host);
                DatagramPacket packet = new DatagramPacket(this.data.getBytes(), this.data.length(), ip, this.port);
                MulticastSocket ms = new MulticastSocket();
                ms.send(packet);
                ms.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        public static void main(String[] args) {
            int port = 1234;
            String host = "224.0.0.1";
            String data = "hello world.";
            System.out.println(data);
            MulticastSender ms = new MulticastSender(data, host, port);
            ms.send();
        }
    }

     

        MulticastSocket用于发送、接收数据报的方法与DatagramSocket完全一样。但MulticastSocket比DatagramSocket多了一个setTimeToLive(int ttl)方法，该ttl参数用于设置数据报最多可以跨过多少个网络，当ttl的值为0时，指定数据报应停留在本地主机；当ttl的值为1时，指定数据报发送到本地局域网；当ttl的值为32时，意味着只能发送到本站点的网络上；当ttl的值为64时，意味着数据报应保留在本地区；当ttl的值为128时，意味着数据报应保留在本大洲；当ttl的值为255时，意味着数据报可发送到所有地方；在默认情况下，该ttl的值为1。