组播发现服务器的java实现

最新推荐文章于 2021-06-15 19:39:12 发布
最新推荐文章于 2021-06-15 19:39:12 发布
阅读量288 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： socket discover
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/assertmyselfsunday/article/details/84830332
组播发现服务器的一个示例


[size=medium][color=green]发现服务器[/color][/size]
DiscoverServer 

package com.gbcom.ccsv3.transport.multidiscover;

import org.apache.log4j.Logger;

/**
 * 发现服务器
 * 
 * <p>
 * 
 * @author syz
 *         <p>
 * @date 2015-6-26,下午04:23:36
 *       <p>
 * @version v1.0.0
 *          <p>
 * @see com.gbcom.ccsv3.transport.multidiscover.DiscoverServer
 */
public class DiscoverServer {
	private static final Logger LOGGER = Logger.getLogger(DiscoverServer.class);

	private static class DiscoverServerHolder{
		private static final DiscoverServer INSTANCE = new DiscoverServer();
	}
	/**
	 * 获取单例
	 * 
	 * @return DiscoverServer
	 */
	public static DiscoverServer getInstance() {
		return DiscoverServerHolder.INSTANCE;
	}

	private boolean started = false;
	private Receiver discover;

	private DiscoverServer() {
		discover = UdpDiscoverFactory.getMultiUdpDiscover();
	}

	/**
	 * 开
	 */
	public void on() {
		started = true;

		Thread t = new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				try {
					discover.start();
				} catch (Exception e) {
					e.printStackTrace();
					discover = null;
					LOGGER.error("start discover server unknoe host", e);
					started = false;

					// maybe throws new exception.
				}
			}

		});
		t.start();
		LOGGER.info("start discover server  for device success!!!!");
	}

	/**
	 * 关
	 */
	public void off() {
		if (discover != null) {
			discover.stop();
		}
		started = false;
	}

	/**
	 * 是否开启
	 * 
	 * @return started
	 */
	public boolean isStarted() {
		return started;
	}

	static class UdpDiscoverFactory {
		/**
		 * 获取多播发现者
		 * 
		 * @return Receiver
		 */
		public static Receiver getMultiUdpDiscover() {
			return new MultiReceiver();
		}

		/**
		 * 获取单播发现者
		 * 
		 * @return Receiver
		 */
		public static Receiver getUdpDiscover() {
			return new UniReceiver();
		}
	}

}



[color=green][size=medium]接受者[/size][/color]
接口 
package com.gbcom.ccsv3.transport.multidiscover;

import java.net.UnknownHostException;

/**
 * UDP 发现
 * 
 * <p>
 * 
 * @author syz
 *         <p>
 * @date 2015-6-26,下午04:39:06
 *       <p>
 * @version v1.0.0
 *          <p>
 * @see com.gbcom.ccsv3.transport.multidiscover.Receiver
 */
public interface Receiver {

	/**
	 * 开始
	 * 
	 * @throws UnknownHostException
	 *             Exception
	 */
	public void start() throws UnknownHostException;

	/**
	 * 停止
	 */
	public void stop();

	/**
	 * 是否开启
	 * 
	 * @return Boolean
	 */
	public boolean isStarted();

}


组播的实现 

package com.gbcom.ccsv3.transport.multidiscover;

import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.MulticastSocket;
import java.net.UnknownHostException;
import java.util.Date;

import org.apache.log4j.Logger;

/**
 * 多播发现者
 * 
 * * 组播 通信端口 1107 单播 通信端口1108
 * 
 * <p>
 * 
 * @author syz
 *         <p>
 * @date 2015-6-26,下午04:25:33
 *       <p>
 * @version v1.0.0
 *          <p>
 * @see com.gbcom.ccsv3.transport.multidiscover.MultiReceiver
 */
public class MultiReceiver implements Receiver {
	private static final Logger LOGGER = Logger.getLogger(MultiReceiver.class);

	/**
	 * 多播ip
	 */
	public static final String MULTI_GROUP_IP = "224.7.11.3";
	/**
	 * 多播端口
	 */
	public static final int MULTI_GROUP_PORT = 1107;
	private MulticastSocket msr = null;
	private InetAddress group = null;

	private boolean started = false;

	/**
	 * 开始
	 * 
	 * @throws UnknownHostException
	 *             Exception
	 */
	@Override
	public void start() throws UnknownHostException {
		// 创建多播socket
		// 接收报文
		this.group = InetAddress.getByName(MULTI_GROUP_IP);// 组播地址

		try {
			msr = new MulticastSocket(MULTI_GROUP_PORT); // server bind port
			//java.net.SocketException: No such device
//	        at java.net.PlainDatagramSocketImpl.join(Native Method)
//	        at java.net.PlainDatagramSocketImpl.join(PlainDatagramSocketImpl.java:181)
//	        at java.net.MulticastSocket.joinGroup(MulticastSocket.java:277)
//	        at com.gbcom.ccsv3.transport.multidiscover.MultiReceiver.start(MultiReceiver.java:56)
//	        at com.gbcom.ccsv3.transport.multidiscover.DiscoverServer$1.run(DiscoverServer.java:50)
//	        at java.lang.Thread.run(Thread.java:662)
			msr.joinGroup(group);// 加入连接
			byte[] buffer = new byte[50];
			LOGGER.info("Thread=" + Thread.currentThread()
					+ " ; MultiReceiver started!!! (启动时间: " + new Date() + ")");
			started = true;
			while (true) {
				try {
					// 建立一个指定缓冲区大小的数据包
					DatagramPacket dp = new DatagramPacket(buffer,
							buffer.length);
					msr.receive(dp);
					DpDispatcher.getInstance().addDp(dp);
				} catch (Exception e) {
					LOGGER.error("receiver is error , continue", e);
					continue;
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
			LOGGER.error("MultiDiscover --- start -- error", e);
		} finally {
			if (msr != null) {
				try {
					msr.leaveGroup(group);
					msr.close();
				} catch (Exception e) {
					LOGGER.error("MultiDiscover --- start finall -- error", e);
				}
			}
		}

	}

	/**
	 * 停止
	 */
	@Override
	public void stop() {
		if (msr != null) {
			try {
				msr.leaveGroup(group);
				msr.close();
			} catch (Exception e) {
				LOGGER.error("MultiDiscover --- start finall -- error", e);
			}
		}
		started = false;

	}

	/**
	 * 是否开启
	 * 
	 * @return started
	 */
	@Override
	public boolean isStarted() {
		return started;
	}

}



[size=medium][color=green]发送者[/color][/size] 
package com.gbcom.ccsv3.transport.multidiscover;

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * UDP 发现
 * 
 * <p>
 * 
 * @author syz
 *         <p>
 * @date 2015-6-26,下午04:39:06
 *       <p>
 * @version v1.0.0
 *          <p>
 * @see Sender
 */
public interface Sender {

	/**
	 * 发送消息。 添加ip 和port 兼容单播处理，作为单播的 端口和地址，
	 * 
	 * @param msg
	 *            String
	 * @param ip
	 *            InetAddress
	 * @param port
	 *            int
	 * @throws UnknownHostException
	 *             Exception
	 */
	public void send(String msg, InetAddress ip, int port)
			throws UnknownHostException;

}


组播实现 
package com.gbcom.ccsv3.transport.multidiscover;

import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.MulticastSocket;
import java.net.UnknownHostException;
import org.apache.log4j.Logger;

/**
 * 多播发送者,单利 和 静态类 * 组播 通信端口 1107 单播 通信端口1108
 * 
 * <p>
 * 
 * @author syz
 *         <p>
 * @date 2015-6-26,下午04:25:33
 *       <p>
 * @version v1.0.0
 *          <p>
 * @see MultiSender
 */
public final class MultiSender implements Sender {
	private static final Logger LOGGER = Logger.getLogger(MultiSender.class);

	/**
	 * 多播ip
	 */
	public static final String MULTI_GROUP_IP = "224.7.11.3";
	/**
	 *多播端口
	 */
	public static final int MULTI_GROUP_PORT = 1108;
	private static final MultiSender INSTANCE = new MultiSender();

	/**
	 * 单例模式，获取单例
	 * 
	 * @return MultiSender
	 */
	public static MultiSender getInstance() {
		return INSTANCE;
	}

	private MultiSender() {

	}

	/**
	 * @param msg
	 *            String
	 * @param ip
	 *            InetAddress
	 * @param port
	 *            int
	 * @throws UnknownHostException
	 *             Exception
	 */
	@Override
	public void send(String msg, InetAddress ip, int port)
			throws UnknownHostException {

		InetAddress group = InetAddress.getByName(MULTI_GROUP_IP);// 组播地址
		MulticastSocket mss = null;
		try {
			// mss = new MulticastSocket(MULTI_GROUP_PORT);
			mss = new MulticastSocket(); // 随机端口 client
			mss.joinGroup(group);

			byte[] buffer = msg.getBytes();
			DatagramPacket dp = new DatagramPacket(buffer, buffer.length,
					group, MULTI_GROUP_PORT);
			mss.send(dp);
		} catch (Exception e) {
			e.printStackTrace();
			LOGGER.error("MultiSender -- send", e);
		} finally {
			try {
				if (mss != null) {
					mss.leaveGroup(group);
					mss.close();
				}
			} catch (Exception e) {
				LOGGER.error("MultiSender -- send -- final", e);
			}
		}

	}

}



[size=medium][color=green]
处理器实现[/color][/size] 
package com.gbcom.ccsv3.transport.multidiscover;

import java.net.DatagramPacket;
import java.net.InetAddress;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import org.apache.log4j.Logger;
import com.gbcom.omc.si.common.Const;

/**
 * 转发器，接收dp
 * 
 * <p>
 * 
 * @author syz
 *         <p>
 * @date 2015-6-26,下午04:29:42
 *       <p>
 * @version v1.0.0
 *          <p>
 * @see com.gbcom.ccsv3.transport.multidiscover.DpDispatcher
 */
public class DpDispatcher {
	private static final Logger LOG = Logger.getLogger(DpDispatcher.class);
	private static final int THREAD_NUM = 1;
	private static final int BLOCK_QUEUE_MAX_SIZE = 10000;
	private static final int BLOCK_QUEUE_CLEAR_SIZE = 10000;

	/**
	 * 线程的执行器
	 */
	private ExecutorService executor = null;

	private boolean isRunning = false;
	/**
	 * 上报Trap消息的队列 :SIZE
	 */
	private BlockingQueue<DatagramPacket> dpQueue = new LinkedBlockingQueue<DatagramPacket>(
			BLOCK_QUEUE_MAX_SIZE);

	private static class DpDispatcherHolder {
		private static final DpDispatcher INSTANCE = new DpDispatcher();
	}

	/**
	 * 获取单例对象
	 * 
	 * @return TaskDispatcher
	 */
	public static DpDispatcher getInstance() {
		return DpDispatcherHolder.INSTANCE;
	}

	private DpDispatcher() {
		init();
		start();
	}

	private void init() {
		isRunning = false;
	}

	/**
	 * 添加数据包
	 * 
	 * @param dp
	 *            DatagramPacket
	 */
	public void addDp(DatagramPacket dp) {

		if (!isRunning) {
			LOG
					.error("UdpDispatcher  is not running, the Task below may not process");
		}
		if (LOG.isDebugEnabled()) {
			LOG.debug("add DatagramPacket to Queue，， Address="
					+ dp.getAddress());
		}
		try {
			if (dpQueue.size() >= BLOCK_QUEUE_CLEAR_SIZE) {
				LOG
						.info(" *****cleart request Task***** trap queue size is more than "
								+ BLOCK_QUEUE_CLEAR_SIZE
								+ ";;  CLEAR BlockingQueue");
				dpQueue.clear();
			}
			dpQueue.put(dp);
		} catch (InterruptedException e) {
			LOG.info("/******* add dp InterruptedException*********/");
			LOG.error("add dp to queue interrupted", e);
			LOG.info("/******* add dp InterruptedException  *********/");
		} catch (Exception e) {
			LOG.error("Other Exception  ", e);
		}

	}

	/**
	 * 停止
	 */
	public void stop() {
		executor.shutdownNow();
		isRunning = false;
	}

	/**
	 * 开始
	 */
	public void start() {

		executor = Executors.newCachedThreadPool();
		for (int i = 0; i < THREAD_NUM; i++) {
			executor.execute(new DispatcherTask());
		}
		isRunning = true;
		LOG.info("do Dispatcher task start  , current thread size =  "
				+ THREAD_NUM);

	}

	class DispatcherTask implements Runnable {

		/**
		 * 线程执行方法
		 */
		@Override
		public void run() {

			DatagramPacket dp = null;
			while (!Thread.currentThread().isInterrupted()) {
				try {
					long begin = System.currentTimeMillis();
					dp = dpQueue.take();

					String s = new String(dp.getData(), 0, dp.getLength());
					LOG.info("discover receiver dp , msg=" + s
							+ ",dpQueue size=" + dpQueue.size());
					if (s.equalsIgnoreCase("who")) {
						/*
						 * TransportMapping mapping
						 * =SnmpSingleton.getTransportMapping(); if(mapping
						 * instanceof DefaultUdpTransportMapping){ String ip =
						 * ((DefaultUdpTransportMapping)mapping).getAddress().
						 * getInetAddress().toString();
						 * SenderFactory.getMultiSender().send(ip); }
						 */

						String ip = "NULL";
						int port = 162;
						if (Const.sourceSnmpIp == null
								|| Const.sourceSnmpIp.trim().equals("")) {
							ip = InetAddress.getLocalHost().getHostAddress()
									.toString();
						} else {
							String[] udpSrc = (Const.sourceSnmpIp.trim())
									.split("/");
							if (udpSrc.length < 1 || udpSrc.length > 2) {
								ip = InetAddress.getLocalHost()
										.getHostAddress().toString();
							} else {
								ip = udpSrc[0];
								port = (udpSrc.length == 2) ? Integer
										.parseInt(udpSrc[1]) : 162;
							}
						}
						String msg = "IP:" + ip + "," + "PORT:" + port;
						// InetAddress addr =
						// InetAddress.getByName(MultiSender.MULTI_GROUP_IP);
						// SenderFactory.getMultiSender().send(msg,MultiSender.MULTI_GROUP_IP,MultiSender.MULTI_GROUP_PORT);

						SenderFactory.getUniSender().send(msg, dp.getAddress(),
								dp.getPort());
					} else {
						// LOG.error("OTHER INFOR---"+s);
					}

					if (LOG.isDebugEnabled()) {

						LOG.info("process Task  success, thread="
								+ Thread.currentThread().getName()
								+ "  ;spend time ：total= "
								+ ((System.currentTimeMillis() - begin) / 1000)
								+ "s  || the queue size is not actually:"
								+ dpQueue.size());
					}
				} catch (InterruptedException e) {
					LOG
							.info("/******* DP Dispatcher  InterruptedException*********/");
					LOG.error("DP Dispatcher thread interrupted ;; tread = "
							+ Thread.currentThread().getName(), e);
					LOG
							.info("/******* DP Dispatcher  InterruptedException*********/");
					Thread.currentThread().interrupt();
					break;
				} catch (Exception e) {
					LOG.error("DP Dispatcher thread exception", e);
					continue;
				}
			}

		}
	}

	public static class SenderFactory {
		/**
		 * 获取多播发送者
		 * 
		 * @return Sender
		 */
		public static Sender getMultiSender() {
			return MultiSender.getInstance();
		}

		/**
		 * 获取单播发送者
		 * 
		 * @return UniSender
		 */
		public static Sender getUniSender() {
			return UniSender.getInstance();
		}

	}

}



使用 打开发现服务器，，扩展处理器模块即可。


示例代码仅支持udp，完整代码参考附件。
java组播跨网段_跨网段组播数据转发
weixin_39736606的博客
03-02 1621
http://blog.youkuaiyun.com/suiyuan19840208/article/details/86395092013最近在实际的项目中遇到了组播通信，其中最主要的问题是组播如何跨网络路由的问题，起初在网络找资料，找到了PIMD来实现组播数包的转发。借助pimd也能实现组包数据包的转发。但是，pimd是个应用程序，如果组播数据平凡的话，会影响到系统的效率。同时考虑到实际的项目中，组播数据...
Java使用组播方式发送和接受数据.rar
07-10
Java使用组播方式发送和接受数据，代码中涉及到生成组播组虚拟IP、MulticastSocket实例、接收数据的数据报、接收数据缓冲、定义组地址、输出接收到的数据、输出出错信息等。 　　MulticastSocket multicastSocket = new MulticastSocket(port); //MulticastSocket实例 　　InetAddress inetAddress = InetAddress.getByName(groupHost); //组地址 　　multicastSocket.joinGroup(inetAddress); //加入到组播组中 　　while (true){ 　　 byte[] received = new byte[128]; //接收数据缓冲 　　 DatagramPacket datagramPacket = new DatagramPacket(received, received.length); //接收数据的数据报 　　 multicastSocket.receive(datagramPacket); //接收数据 　　 System.out.println(new String(received)); //输出接收到的数据 　　}
java组播MulticastSocket
STN_LCD的专栏
03-24 686
http://www.2cto.com/kf/201506/404287.html 在单播模式中有服务器端和客户端之分，而组播模式与单播模式不同，每个端都是以路由器或交换机做为中转广播站，任意一端向路由器或交换机发送消息，路由或交换机负责发送其他节点，每个节点都是同等的。所以在编程模式上用同一个类表示即可——MulticastSocket。 MulticastSocke
java使用MulticastSocket实现组播
08-26
主要为大家详细介绍了java使用MulticastSocket实现组播，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
基本概念之局域网发现之UDP组播
上善若水的博客
09-27 1548
基本概念之局域网发现之UDP组播单播多播单播和组播、广播的区别多播的优点广播的缺点组播与广播局域网的多播初步结论 局域网发现设备是通信的第一步，通信需要先知道对方的ip地址，因为一般使用 DHCP 动态分配 ip 地址的局域网内，各个主机的 IP 地址是由 DHCP 服务器来帮你分配 IP 地址的。所以在很多情况下，你要知道对方的 IP 地址是比较麻烦的。 因此，局域网发现，我们要解决的事情就是：如何找到局域网内其他设备，并获取到设备的ip； 查询资料之后，发现使用udp单播、组播、广播来实现的方式都有，并
组播测试demo（android）
01-14
用于测试手机是否可接受组播 打开组播锁的关键代码 WifiManager wifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE); mMulticastLock = wifiManager.createMulticastLock("multicast.test"); if (mMulticastLock != null){ mMulticastLock.acquire(); }
Java实现组播发现服务器技术解析
资源摘要信息:"组播发现服务器的java实现" 组播发现服务器是一种网络服务，允许网络中的设备通过组播通信的方式互相发现和交互。组播是一种网络传输方式，它允许数据包从单个源发送到网络上的多个目标。在组播通信...
java 单播、广播、组播详解及实例代码
08-31
本文将详细解析这三种通信模式，并提供相关的Java实现代码。 首先，单播是最基本的通信方式，类似于人与人之间的对话。一个主机发送数据到另一个特定的主机。这种通信模式在服务器响应客户端请求时特别常见，如电子...
iptv_udp_socket_java.zip_IPTV java_iptv服务器_中兴捧月_机顶盒_组播视频
09-22
具体：服务器可以实时显示三个频道的信息，并把三个频道的视频帧以UDP单播形式发送到交换机，然后交换分别把三个频道的数据发送到三个组播组，机顶盒可以选择加入某个组，实现浏览不同频道的节目
使用JavaCV通过UDP组播实现零服务器同屏浏览技术
资源摘要信息: "本项目利用javacv库实现了同屏浏览功能，通过UDP组播的方式推送桌面视频流。用户无需视频流服务器进行中转，即可完成视频流的推拉过程。本项目使用的javacv版本为javacv-platform-1.5-bin，开发者...
局域网发现设备
10-21
利用jmdns发现局域网设备，在局域网内，你要通过一台主机和其他主机进行通信，你需要知道对方的ip地址，但是有些时候，你并不知道对方的ip地址，因为一般使用DHCP动态分配ip地址的局域网内，各个主机的IP地址是由DHCP服务器来帮你分配IP地址的。所以在很多情况下，你要知道对方的IP地址是比较麻烦的。 鉴于发现这篇文章最近的浏览量比较多，晚上也有不少转载，特别声明一下，文章水平可能不大够，只是我当时的一些理解，所以希望大家以批判的角度来看，然后又什么问题欢迎讨论。真心不希望误导大家^_^ mDNS就是来解决这个问题的。通过一个约定俗成的端口号，5353。（这个端口号应该是由IETF组织约定的。）每个进入局域网的主机，如果开启了mDNS服务的话，都会向局域网内的所有主机组播一个消息，我是谁，和我的IP地址是多少。然后其他也有该服务的主机就会响应，也会告诉你，它是谁，它的IP地址是多少。当然，具体实现要比这个复杂点。 比如，A主机进入局域网，开启了mDNS服务，并向mDNS服务注册一下信息：我提供FTP服务，我的IP是192.168.1.101，端口是21。当B主机进入局域网，并向B主机的mDNS服务请求，我要找局域网内FTP服务器，B主机的mDNS就会去局域网内向其他的mDNS询问，并且最终告诉你，有一个IP地址为192.168.1.101，端口号是21的主机，也就是A主机提供FTP服务，所以B主机就知道了A主机的IP地址和端口号了。 大概的原理就是这样子，mDNS提供的服务要远远多于这个，当然服务多但并不复杂。 在Apple 的设备上（电脑，笔记本，iphone，ipad等设备）都提供了这个服务。很多Linux设备也提供这个服务。Windows的设备可能没有提供，但是如果安装了iTunes之类的软件的话，也提供了这个服务。 这样就可以利用这个服务开发一些局域网内的自动发现，然后提供一些局域网内交互的应用了。
asio_service_discovery:通过udp组播进行服务发现的组件。 它正在使用升压
05-24
asio_service_discovery 通过udp组播进行服务发现的组件。 它使用boost :: asio进行异步网络连接。 它是非阻塞和非锁定的。 最好的入门方法是。 基本功能源自。 请注意，udp数据包的最大数据包大小受到限制。 该库支持正在运行的机器上udp数据包的最大大小（在我的机器上为〜8kb）。 但是在选择服务名称时请记住这一点。 但是，低于kb的任何内容都可以。 如果收到“消息过长”错误，请确保没有选择过长的服务名。 要求 asio_service_discovery正在使用boost :: asio，因此您需要boost asio标头，并且需要再次链接boost_system。 您还需要支持C ++ 11的编译器 如果要运行测试，还需要安装cmake 这个怎么运作 有两个组件：service_announcer和service_discoverer。 播音员以
java组播跨网段_跨网段使用组播部署批量部署客户端电脑系统
weixin_42292183的博客
03-02 494
课程简介MDT是微软原生的免费批量系统部署工具集，使用该工具集可以实现企业单域多站点批量部署客户端电脑系统，例如批量部署Windows10等。基于企业实际应用，本课程从零开始手把手搭建MDT客户端电脑部署系统，以在企业生产环境中实现批量Windows10操作系统部署。本课程涉及：-搭建和配置MDT部署系统。-定制WinPE启动镜像，以集成网卡硬盘驱动、显示中文和多平台支持。-定义企业标准软件列表，...
Java实现UDP组播(支持跨网段)
SCGH_Fx的专栏
07-18 3601
以下是接收端代码： package com.udp.test; import sun.security.util.BitArray; import javax.xml.bind.DatatypeConverter; import java.io.IOException; import java.net.DatagramPacket; import java.net.InetAddress;...
java组播跨网段_服务做两台Exchange CAS的集群配置完NLB后发现同网段访问正常跨网段不通...
weixin_39852953的博客
03-02 478
服务做两台Exchange CAS的集群配置完NLB后发现同网段访问正常跨网段不通刘大喵•2018 年 10 月 23 日问题描述:微软的NLB(网络负载均衡)服务做两台Exchange CAS(Client Access Server)的集群，配置完NLB后发现同网段访问正常，跨网段都无法访问，甚至在NLB网段的网关上都无法访问。拓扑如下：故障截图：处理过程:1.首先尝试从网关S7700上p...
802.11 - 定向多播服务(Directed multicast service)
喂马，劈材
06-15 1777
处理的多点传送服务器(DMS) ： DMS使得non-AP STA能够请求AP将发往STA的组寻址帧作为单独寻址帧发送，类似一个动态媒体流功能。 客户端能要求到AP (支持DMS的接入点)发送组播流作为单播，类似一个动态媒体流功能。 欲知媒体流的更多信息：VideoStream部署指南 没有使用DMS客户端必须醒来每个DTIM间隔为了接收组播流量。使用DMS， AP (接入点)缓冲某一 客户端的组播数据流，当客户端叫醒它时发送单播帧为了请求此流量。它允许客户端为最长时间休 眠和节省电池功率。组播帧传送作为在
Java-UDP程序编写（实现组播）
qq_42794720的博客
12-22 1939
1.播报广播端 package test; import java.net.DatagramPacket; import java.net.InetAddress; import java.net.MulticastSocket; public class Weather extends Thread{ String weather = "今晚团建"; int port = 9898; ...
IP组播基础及工作原理——3
kaoa000的专栏——非淡泊无以明志，非宁静无以致远
01-22 5406
PIM基础及工作原理 PIM（协议无关组播）中的“协议无关”指的是与单播路由协议无关，即PIM不需要维护专门的单播路由信息，而是直接利用单播路由表的路由信息（注意：还有自己的组播路由表），对组播报文执行RPF（Reverse Path Forwarding，逆向路径转发）检查，检查通过后创建组播路由表项，从而转发组播报文。 目前在实际网络中，PIM主要有两种模式：PIM-DM（PIM-Dens
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值