Java实现在组播组中发送数据和接受数据实例，组播组虚拟IP，是一个DatagramSocket实例，包括发送信息和关闭端口等，程序分为服务端MulticastServer.java文件和客户端MulticastClient.java文件。
 
 MulticastServer.java 代码如下：
 
 
 
 
  
 
   
 01
 import java.net.*;
 
  
 
  
 
   
 02
 import java.io.*;
 
  
 
  
 
   
 03
 public class MulticastServer{
 
  
 
  
 
   
 04
     String groupHost="232.0.0.1";  //组播组虚拟IP
 
  
 
  
 
   
 05
     int port=5678;  //端口
 
  
 
  
 
   
 06
     public MulticastServer(){
 
  
 
  
 
   
 07
         try{
 
  
 
  
 
   
 08
             MulticastSocket multicastSocket = new MulticastSocket(port); //MulticastSocket实例
 
  
 
  
 
   
 09
             InetAddress inetAddress = InetAddress.getByName(groupHost); //组地址
 
  
 
  
 
   
 10
             multicastSocket.joinGroup(inetAddress); //加入到组播组中
 
  
 
  
 
   
 11
             while (true){
 
  
 
  
 
   
 12
                 byte[] received = new byte[128]; //接收数据缓冲
 
  
 
  
 
   
 13
                 DatagramPacket datagramPacket = new DatagramPacket(received, received.length); //接收数据的数据报
 
  
 
  
 
   
 14
                 multicastSocket.receive(datagramPacket); //接收数据
 
  
 
  
 
   
 15
                 System.out.println(new String(received)); //输出接收到的数据
 
  
 
  
 
   
 16
             }
 
  
 
  
 
   
 17
         }
 
  
 
  
 
   
 18
         catch (Exception exception){
 
  
 
  
 
   
 19
             exception.printStackTrace(); //输出出错信息
 
  
 
  
 
   
 20
         }
 
  
 
  
 
   
 21
     }
 
  
 
  
 
   
 22
     public static void main(String [] arstring){
 
  
 
  
 
   
 23
         new  MulticastServer();  
 
  
 
  
 
   
 24
     }
 
  
 
  
 
   
 25
 }
 
  
 
 
 
 
 MulticastClient.java 代码如下：
 
 
 
 
  
 
   view source 
   
 
   
 
   print
   ?
  
 
 
 
 
 
  
 
   
 01
 import java.net.*;
 
  
 
  
 
   
 02
 import java.io.*;
 
  
 
  
 
   
 03
 public class MulticastClient{
 
  
 
  
 
   
 04
     String groupHost="232.0.0.1"; //组播组虚拟IP
 
  
 
  
 
   
 05
     int port=5678; //端口
 
  
 
  
 
   
 06
     public MulticastClient(){
 
  
 
  
 
   
 07
         try{
 
  
 
  
 
   
 08
             byte[] message = "Hello,This is Client.".getBytes(); //发送信息
 
  
 
  
 
   
 09
             InetAddress inetAddress = InetAddress.getByName(groupHost); //组播地址
 
  
 
  
 
   
 10
             DatagramPacket datagramPacket= new DatagramPacket(message, message.length, inetAddress, port); //发送数据报
 
  
 
  
 
   
 11
             DatagramSocket socket = new DatagramSocket(); //DatagramSocket实例
 
  
 
  
 
   
 12
             socket.send(datagramPacket); //发送数据
 
  
 
  
 
   
 13
             socket.close(); //关闭端口
 
  
 
  
 
   
 14
         }
 
  
 
  
 
   
 15
         catch (Exception exception) {
 
  
 
  
 
   
 16
             exception.printStackTrace();  //输出错误信息
 
  
 
  
 
   
 17
         }
 
  
 
  
 
   
 18
     }
 
  
 
  
 
   
 19
     public static void main(String[] args){
 
  
 
  
 
   
 20
         new MulticastClient();
 
  
 
  
 
   
 21
     }
 
  
 
  
 
   
 22
 }
 
  
 
 
 

  组播传输比起普通udp传输主要多了加入组以及设置本地回环是否接收等设定。需要注意的是，如果本地有多个IP，绑定local address的时候建议不要使用INADDR_ANY。源码如下
 
#include <iostream>
#include <winsock2.h> 
#include <Ws2tcpip.h>
#include <process.h> 

#pragma comment(lib, "ws2_32.lib")

using namespace std;

//const char* MULTICAST_IP = "224.0.0.99"; 
const char* MULTICAST_IP = "239.192.152.143"; 
const int MULTICAST_PORT = 6771; 

const int BUFFER_SIZE = 1024;

void do_send(void* arg); 
void do_read(void* arg); 
int main()
{
	WSAData wsaData;

	if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
	{
		cout << "Error in WSAStartup" << endl;
		return 0;
	}

	SOCKET server;
	server = socket(AF_INET, SOCK_DGRAM, 0); 
	cout << "create socket: " << server << endl;

	int ret;

	const int on = 1; 
	ret = setsockopt(server, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on));
	if (ret == SOCKET_ERROR)
	{
		WSACleanup();

		cout << "Error in setsockopt(SO_REUSEADDR): " << WSAGetLastError() << endl;
		return 0;
	}

	const int routenum = 10;
	ret = setsockopt(server, IPPROTO_IP, IP_MULTICAST_TTL, \
		(char*)&routenum, sizeof(routenum));
	if (ret == SOCKET_ERROR)
	{
		WSACleanup();

		cout << "Error in setsockopt(IP_MULTICAST_TTL): " << WSAGetLastError() << endl;
		return 0;
	}

	const int loopback = 1; 
	ret = setsockopt(server, IPPROTO_IP, IP_MULTICAST_LOOP, \
		(char*)&loopback, sizeof(loopback));
	if (ret == SOCKET_ERROR)
	{
		WSACleanup();

		cout << "Error in setsockopt(IP_MULTICAST_LOOP): " << WSAGetLastError() << endl;
		return 0;
	}

	sockaddr_in local;
	memset(&local, 0, sizeof(local));
	local.sin_family = AF_INET;
	local.sin_port = htons(MULTICAST_PORT);
	local.sin_addr.S_un.S_addr = INADDR_ANY;

	ret = bind(server, (sockaddr*)(&local), sizeof(local));
	if (ret == SOCKET_ERROR)
	{
		WSACleanup();

		cout << "Error in bind: " << WSAGetLastError() << endl;
		return 0;
	}

	ip_mreq mreq;
	memset(&mreq, 0, sizeof(mreq));
	mreq.imr_interface.S_un.S_addr = INADDR_ANY;
	mreq.imr_multiaddr.S_un.S_addr = inet_addr(MULTICAST_IP);

	ret = setsockopt(server, IPPROTO_IP, IP_ADD_MEMBERSHIP, \
		(char*)&mreq, sizeof(mreq));
	if (ret == SOCKET_ERROR)
	{
		WSACleanup();

		cout << "Error in setsockopt(IP_ADD_MEMBERSHIP): " << WSAGetLastError() << endl;
		return 0;
	}

	HANDLE hHandle[2];
	hHandle[0] = (HANDLE)_beginthread(do_send, 0, (void*)server);
	hHandle[1] = (HANDLE)_beginthread(do_read, 0, (void*)server);

	
	WaitForSingleObject(hHandle[0], INFINITE);

	WSACleanup();

	return 0;
}

void do_send(void* arg)
{
	SOCKET server = (SOCKET)arg;

	char sendline[BUFFER_SIZE + 1];

	sockaddr_in remote;
	memset(&remote, 0, sizeof(remote));
	remote.sin_addr.s_addr = inet_addr(MULTICAST_IP);
	remote.sin_family = AF_INET;
	remote.sin_port = htons(MULTICAST_PORT);

	for (;;) 
	{
		std::cout << "Send: ";
		std::cin >> sendline;
		//cin.getline(sendline, BUFFER_SIZE);

		if (strncmp(sendline, "end", 3) == 0)
			break;

		
		sendto(server, sendline, strlen(sendline), 0, (sockaddr*)(&remote), sizeof(remote));
	}

	cout << "do_send end..." << endl;
}

void do_read(void* arg)
{
	SOCKET server = (SOCKET)arg;

	char buf[BUFFER_SIZE + 1];
	int ret;

	sockaddr_in client;
	int clientLen;

	for (;;) 
	{
		clientLen = sizeof(client);
		memset(&client, 0, clientLen);

		ret = recvfrom(server, buf, BUFFER_SIZE, 0, (sockaddr*)(&clientLen), &clientLen);
		if (ret == 0) 
		{
			continue;
		}
		else if (ret == SOCKET_ERROR)
		{
			if (WSAGetLastError() == WSAEINTR) 
				break;

			cout << "Error in recvfrom: " << WSAGetLastError() << endl;
			break;
		}
		buf[ret] = '\0';
		cout << std::endl << "received: " << buf << endl;
		std::cout << "Send: ";
	}

	cout << "do_read end..." << endl;
}
 
 
欢迎关注本人公众号，公众号会更新一些不一样的内容，相信一定会有所收获。
 

在System.net.Sockets名称空间中，UdpClient类简化了UDP套接字编程。UDP协议是无连接的协议，因此，UDP协议只有UdpClient类，而没有TcpListener类和TcpClient类。UdpClient类提供了发送和接受无连接的UDP数据报的方便方法。其建立默认远程主机的方式有两种：一是使用远程主机名和端口号作为参数创建UdpClient类的实例；另一种是先创建不带参数的UdpClient类的实例，然后调用Connet方法指定默认远程主机。
 
可以通过调用UdpClient对象的Send方法直接将数据发送到远程主机，该方法返回数据的长度可用于检查数据是否已被正确发送。UdpClient对象的Receive方法能够在指定的本地IP地址和端口上接收数据，该方法带一个引用类型的IPEndPoint实例，并将接收到的数据作为byte数组返回
 
UDP协议的重要用途是可以通过广播和组播实现一对多的通信。所谓广播，就是指同时向网络中的所有计算机发送消息，而这些计算机都可以接收到消息。组播也叫多路广播，是将消息从一台计算机发送到网络中指定的若干台计算机上，即发送到哪些加入指定组播组的计算机上，组播组是开放的，每台计算机都可以通过程序随时加入到组播组中，也可以随时退出。
 
组播地址是224.0.0.0到239.255.255.255的D类IP地址。使用组播时，应注意的是TTL值的设置，TTL值是允许路由器转发的最大数目。当达到这个最大值时，数据包就会被丢弃。如果使用默认值（1），则只能在同一子网内部发送。
 
在UdpClient类中，调用JoinMulticastGroup方法可将UdpClient对象和TTL一起加入组播组，调用DropMulticastGroup方法可退出组播组。
 
编写一个程序，利用组播技术向子网发送组播信息，同时接收组播的信息。
 
按顺序启动组播发送方与组播接收方程序，在组播发送方输入信息并单击“发送”按钮。该消息经UDP协议广播并成功的被组播接收方接收
 
运行结果：
 
 
源代码：
 
发送端：
 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace Socket_UdpSender
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            //系统将自动分配最合适的本地地址和端口号
            UdpClient client = new UdpClient();     
            //允许发送广播    
            client.EnableBroadcast = true;
            //必须使用组播地址
            IPEndPoint p = new IPEndPoint(IPAddress.Parse("224.0.0.2"), 8001);
            //将发送内容装换为字节数组
            byte[] bytes = Encoding.UTF8.GetBytes(textSend.Text);
            try
            {
                //向子网发送信息
                client.Send(bytes, bytes.Length, p);
                textSend.Clear();
                textSend.Focus();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "发送错误");
            }
            finally
            {
                client.Close();
            }
        }
    }
}
 
接收端：
 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace Socket_UdpReceiver
{
    public partial class Form1 : Form
    {
        private  delegate void AppendStringCallBack(string text);               //定义委托
        private AppendStringCallBack OnAppendStringCallback;                    //定义回调事件
        private UdpClient client;                                               //定义udp客户端对象
        public Form1()                                                          //窗体类的构造函数
        {
            InitializeComponent();
            OnAppendStringCallback = new AppendStringCallBack(AppendString);    //绑定事件
        }

        private void AppendString(string text)                                  //定义事件方法
        {
            //Windows窗体中的控件被绑定到特定的线程，不具备线程安全性
            //因此，若从另一个线程调用控件的方法，则必须使用Invoke方法来调用封送到适当的线程
            //InvokeRequired属性用于确定是否必须调用Invoke方法
            if (textReceive.InvokeRequired)
                this.Invoke(OnAppendStringCallback, text);                      
            else
                textReceive.AppendText(text + "\r\n");        //触发事件，执行在另一个线程中订阅事件方法
        }
        //该方法先加入主播接收主播消息，再订阅事件方法AppendSting。当onAppendStringcallBack事件被触发时将
        //收到的信息添加到RichTextBox控件，以便显示消息。为了自动接收消息，ReceiveData方法不能在运行Windows
        //窗体线程中运行，须把ReceiveData创建为一个新的线程。为此，在窗体的Load事件中创建新线程。
        private void ReceiveData()
        {
            //在本机指定的端口接收
            client = new UdpClient(8001);
            IPEndPoint remove = null;
            //不知道为啥用224.0.0.1就会出现套接字无法连接主机的错误，也许是防火墙的问题？
            //加入组播，注意必须使用组播地址范围内的地址
            client.JoinMulticastGroup(IPAddress.Parse("224.0.0.2"));
            client.Ttl = 50;
         
            while (true)                            //接收从远程主机发送过来的信息
            {
                try
                {
                    byte[] bytes = client.Receive(ref remove);
                    string data = Encoding.UTF8.GetString(bytes, 0, bytes.Length);
                    //订阅事件
                    AppendString(string.Format("来自{0}：{1}", remove, data));
                }
                catch
                {
                    break;                          //退出循环，结束线程
                }
            }

        }

        private void Form1_Load(object sender, EventArgs e)
        {
            Thread showThread = new Thread(new ThreadStart(ReceiveData));
            showThread.Start();
        }
        //在关闭窗体时先关闭UdpClient
        private void Form1_FormClosing_1(object sender, FormClosingEventArgs e)
        {
            client.Close();
        }
    }
}
 
 

  本文将客户端和服务端分开写成两个部分。
 
1. 客户端
 
#include <stdio.h>  
#include <winsock2.h>  
#include <ws2tcpip.h>  
#pragma comment(lib, "ws2_32.lib")

int test3()
{
	int iRet = 0;
	WSADATA wsaData;
	WSAStartup(MAKEWORD(2, 2), &wsaData);

	SOCKET sock = socket(AF_INET, SOCK_DGRAM, 0);

	int iFlag = 0;	// 0-ͬһ̨Ö÷»ú 1-¿äÖ÷»ú
	iRet = setsockopt(sock, IPPROTO_IP, IP_MULTICAST_TTL, (char*)&iFlag, sizeof(iFlag));
	if (iRet != 0) {
		printf("setsockopt fail:%d", WSAGetLastError());
		return -1;
	}

	sockaddr_in addr;
	addr.sin_addr.S_un.S_addr = inet_addr("234.2.2.2");
	addr.sin_family = AF_INET;
	addr.sin_port = htons(9411);

	char strSend[1024] = { 0 };
	static int iIdx = 0;
	while (1)
	{
		sprintf_s(strSend, "udp send group data:%d", iIdx++);
		iRet = sendto(sock, strSend, strlen(strSend) + 1, 0, (sockaddr*)&addr, sizeof(sockaddr));
		if (iRet <= 0) {
			printf("send fail:%d", WSAGetLastError());
		}
		else {
			printf("send data:%s\n", strSend);
		}
		Sleep(500);
	}

	closesocket(sock);
	WSACleanup();

	return 0;
}
 
2. 服务端
 
#include <stdio.h>  
#include <winsock2.h>  
#include <ws2tcpip.h>  
#pragma comment(lib, "ws2_32.lib")

int test3()
{
	int iRet = 0;
	WSADATA wsaData;
	WSAStartup(MAKEWORD(2, 2), &wsaData);

	SOCKET sock = socket(AF_INET, SOCK_DGRAM, 0);

	sockaddr_in addr;
	addr.sin_family = AF_INET;
	//addr.sin_addr.S_un.S_addr = INADDR_ANY;
	addr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
	addr.sin_port = htons(9411);

	bool bOptval = true;
	iRet = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*)&bOptval, sizeof(bOptval));
	if (iRet != 0) {
		printf("setsockopt fail:%d", WSAGetLastError());
		return -1;
	}

	iRet = bind(sock, (sockaddr*)&addr, sizeof(addr));
	if (iRet != 0) {
		printf("bind fail:%d", WSAGetLastError());
		return -1;
	}
	printf("socket:%d bind success\n", sock);

	// ¼ÓÈë×é²¥  
	ip_mreq multiCast;
	//multiCast.imr_interface.S_un.S_addr = INADDR_ANY;
	multiCast.imr_interface.S_un.S_addr = inet_addr("127.0.0.1");
	multiCast.imr_multiaddr.S_un.S_addr = inet_addr("234.2.2.2");
	iRet = setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&multiCast, sizeof(multiCast));
	if (iRet != 0) {
		printf("setsockopt fail:%d", WSAGetLastError());
		return -1;
	}

	printf("udp group start\n");

	int len = sizeof(sockaddr);
	char strRecv[1024] = { 0 };
	while (true)
	{
		memset(strRecv, 0, sizeof(strRecv));
		iRet = recvfrom(sock, strRecv, sizeof(strRecv) - 1, 0, (sockaddr*)&addr, &len);
		if (iRet <= 0) {
			printf("recvfrom fail:%d", WSAGetLastError());
			return -1;
		}
		printf("recv data:%s\n", strRecv);
	}

	closesocket(sock);
	WSACleanup();

	return 0;
}
 
 
欢迎关注本人公众号，公众号会更新一些不一样的内容，相信一定会有所收获。