Java MulticastSocket.setLoopbackMode方法代码示例

import java.net.MulticastSocket; //导入方法依赖的package包/类
/**
 * 
 * @param multicastIP for example, 224.X.X.X or 239.X.X.X
 * @param port
 * @param bs
 */
public static void multicast(final String multicastIP, final int port, final byte[] sendData){
	final WifiManager wifi = getWiFiManager();
	MulticastLock multicastLock = wifi.createMulticastLock(String.valueOf(System.currentTimeMillis()));
	multicastLock.setReferenceCounted(true);
	multicastLock.acquire();
	
	try{
		final MulticastSocket multicastSocket=new MulticastSocket(port);
        multicastSocket.setLoopbackMode(true);
        final InetAddress group = InetAddress.getByName(multicastIP);
        multicastSocket.joinGroup(group);
        
        final DatagramPacket packet=new DatagramPacket(sendData, sendData.length,group,port);
        
           multicastSocket.send(packet);
	}catch (final Throwable e) {
		e.printStackTrace();
	}
	
	if (multicastLock != null) {
	    multicastLock.release();
	    multicastLock = null;
	}
}
 

import java.net.MulticastSocket; //导入方法依赖的package包/类
/**
 * Creates multicast socket and joins multicast group.
 *
 * @throws IOException If fails to create socket or join multicast group.
 * @return Multicast socket.
 */
private MulticastSocket createSocket() throws IOException {
    MulticastSocket sock = new MulticastSocket(mcastPort);

    sock.setLoopbackMode(false); // Use 'false' to enable support for more than one node on the same machine.

    if (sockItf != null)
        sock.setInterface(sockItf);

    if (sock.getLoopbackMode())
        U.warn(log, "Loopback mode is disabled which prevents nodes on the same machine from discovering " +
            "each other.");

    sock.joinGroup(mcastGrp);

    if (ttl != -1)
        sock.setTimeToLive(ttl);

    return sock;
}
 

import java.net.MulticastSocket; //导入方法依赖的package包/类
/**
     * 
     * @param flag true to enable loopback, fals to disable loopback
     */
    public void setLoopbackMode(boolean flag) {
        try {
            Field connField = KNXNetworkLinkIP.class.getDeclaredField("conn");
            connField.setAccessible(true);
            
//            KNXnetIPConnection conn = (KNXnetIPConnection) connField.get(this);
            KNXnetIPRouting conn = (KNXnetIPRouting) connField.get(this);
            
            if (conn instanceof KNXnetIPRouting) {
                KNXnetIPRouting knxnetiprouting = (KNXnetIPRouting) conn;
                
                Field socketField = KNXnetIPRouting.class.getSuperclass().getDeclaredField("socket");
                socketField.setAccessible(true);
                MulticastSocket socket = (MulticastSocket) socketField.get(knxnetiprouting);
                socket.setLoopbackMode(!flag); // weird inverse logic, see javadoc of MulticastSocket#setLoopbackMode
                
                Field loopbackEnabledField = KNXnetIPRouting.class.getDeclaredField("loopbackEnabled");
                loopbackEnabledField.setAccessible(true);
                loopbackEnabledField.set(knxnetiprouting, !socket.getLoopbackMode());
                Boolean loopbackEnabled = (Boolean) loopbackEnabledField.get(knxnetiprouting);
                logger.info("multicast loopback mode " + (loopbackEnabled ? "enabled" : "disabled"));
                
            }
                    
        } catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException | SocketException ex) {
            ex.printStackTrace();
        }
    }
 

import java.net.MulticastSocket; //导入方法依赖的package包/类
protected DatagramSocket createSocket() throws IOException {
    MulticastSocket s = new MulticastSocket();
    s.setSendBufferSize(maxTraceDatagramSize);
    s.setBroadcast(broadcast);
    s.setLoopbackMode(true);
    s.setTimeToLive(timeToLive);
    return s;
}
 

import java.net.MulticastSocket; //导入方法依赖的package包/类
protected CommandChannel createCommandChannel() throws IOException {
    socket = new MulticastSocket(mcastPort);
    socket.setLoopbackMode(loopBackMode);
    socket.setTimeToLive(timeToLive);

    LOG.debug("Joining multicast address: " + getMulticastAddress());
    socket.joinGroup(getMulticastAddress());
    socket.setSoTimeout((int)keepAliveInterval);

    return new CommandDatagramSocket(this, getWireFormat(), getDatagramSize(), getTargetAddress(), createDatagramHeaderMarshaller(), getSocket());
}
 

import java.net.MulticastSocket; //导入方法依赖的package包/类
/**
 * @return
 */
private boolean createSocket() {
	try {
		m_socket = new MulticastSocket(m_port);
		m_socket.setLoopbackMode(false);
	} catch (IOException e) {
		s_LOGGER.error(e.getMessage(), e);

		return false;
	}

	return true;
}
 

import java.net.MulticastSocket; //导入方法依赖的package包/类
/**
 * start the discovery agent
 * 
 * @throws Exception
 */
public void start() throws Exception {
	
    if (started.compareAndSet(false, true)) {        	
    	         	
        if (group == null || group.length() == 0) {
            throw new IOException("You must specify a group to discover");
        }
        String type = getType();
        if (!type.endsWith(".")) {
            LOG.warn("The type '" + type + "' should end with '.' to be a valid Discovery type");
            type += ".";
        }
        
        if (discoveryURI == null) {
            discoveryURI = new URI(DEFAULT_DISCOVERY_URI_STRING);
        }
        
        if (LOG.isTraceEnabled()) 
    	  	LOG.trace("start - discoveryURI = " + discoveryURI);        	  	        	  
    	  
    	  String myHost = discoveryURI.getHost();
    	  int    myPort = discoveryURI.getPort(); 
    	     
    	  if( DEFAULT_HOST_STR.equals(myHost) ) 
    	  	myHost = DEFAULT_HOST_IP;       	      	  
    	  
    	  if(myPort < 0 )
    	    myPort = DEFAULT_PORT;        	    
    	  
    	  if (LOG.isTraceEnabled()) {
    	  	LOG.trace("start - myHost = " + myHost); 
    	  	LOG.trace("start - myPort = " + myPort);   	
    	  	LOG.trace("start - group  = " + group );		       	  	
    	  	LOG.trace("start - interface  = " + mcInterface );
    	  	LOG.trace("start - network interface  = " + mcNetworkInterface );
    	  	LOG.trace("start - join network interface  = " + mcJoinNetworkInterface );
    	  }	
    	  
        this.inetAddress = InetAddress.getByName(myHost);
        this.sockAddress = new InetSocketAddress(this.inetAddress, myPort);
        mcast = new MulticastSocket(myPort);
        mcast.setLoopbackMode(loopBackMode);
        mcast.setTimeToLive(getTimeToLive());
        if (mcJoinNetworkInterface != null) {
            mcast.joinGroup(sockAddress, NetworkInterface.getByName(mcJoinNetworkInterface));
        }
        else {
        	mcast.joinGroup(inetAddress);
        }
        mcast.setSoTimeout((int)keepAliveInterval);
        if (mcInterface != null) {
            mcast.setInterface(InetAddress.getByName(mcInterface));
        }
        if (mcNetworkInterface != null) {
            mcast.setNetworkInterface(NetworkInterface.getByName(mcNetworkInterface));
        }
        runner = new Thread(this);
        runner.setName(this.toString() + ":" + runner.getName());
        runner.setDaemon(true);
        runner.start();
        doAdvertizeSelf();
    }
}