Android MulticastSocket IP组播

MulticastSocket是对等的关系，也就是他们通过IP多点组播保留的地址来相互接收在这个组的Socket发送的消息

我写了一个例子，MultiSocketB是一个service,用于先接收再发送，MultiSocketA用于先发送再接收，完成这一动作后退出

记得要加使用网络的权限

  1. <uses-permission android:name="android.permission.INTERNET" />  

先看MultiSocketA

  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     package="com.example.multicastsocketsend"  
  4.     android:versionCode="1"  
  5.     android:versionName="1.0" >  
  6.     <uses-permission android:name="android.permission.INTERNET" />  
  7.       
  8.     <uses-sdk  
  9.         android:minSdkVersion="8"  
  10.         android:targetSdkVersion="17" />  
  11.   
  12.     <application  
  13.         android:allowBackup="true"  
  14.         android:icon="@drawable/ic_launcher"  
  15.         android:label="@string/app_name"  
  16.         android:theme="@style/AppTheme" >  
  17.         <activity  
  18.             android:name="com.example.multicastsocketsend.MultiSocketA"  
  19.             android:label="@string/app_name" >  
  20.             <intent-filter>  
  21.                 <action android:name="android.intent.action.MAIN" />  
  22.   
  23.                 <category android:name="android.intent.category.LAUNCHER" />  
  24.             </intent-filter>  
  25.         </activity>  
  26.     </application>  
  27.   
  28. </manifest>  
  1. package com.example.multicastsocketsend;  
  2.   
  3. import java.io.IOException;  
  4. import java.net.DatagramPacket;  
  5. import java.net.InetAddress;  
  6. import java.net.MulticastSocket;  
  7.   
  8. import android.app.Activity;  
  9. import android.os.Bundle;  
  10. import android.os.Handler;  
  11. import android.os.HandlerThread;  
  12. import android.util.Log;  
  13.   
  14. /** 
  15.  * @author lijinwei 
  16.  * 本应用用于实现IP多点广播 
  17.  * 若要使用多点广播时，则需要让一个数据报标有一组目标主机地址，当数据报发出后，整个组的所有主机都能收到该数据报。 
  18.  * IP多点广播（或多点发送）实现了将单一信息发送到多个接收者的广播，其思想是设置一组特殊网络地址作为多点广播地址，每一个多点广播地址都被看做一个组， 
  19.  * 当客户端需要发送、接收广播信息时，加入到该组即可。 
  20.  */  
  21. public class MultiSocketA extends Activity {  
  22.     protected static final String TAG = "MultiSocketA";  
  23.     private Handler mHandler;  
  24.   
  25.     @Override  
  26.     protected void onCreate(Bundle savedInstanceState) {  
  27.         super.onCreate(savedInstanceState);  
  28.         setContentView(R.layout.activity_main);  
  29.         //通过Handler启动线程    
  30.         HandlerThread handlerThread = new HandlerThread("MultiSocketA");  
  31.         handlerThread.start();  
  32.         mHandler =  new Handler(handlerThread.getLooper());  
  33.         mHandler.post(mRunnable);    
  34.     }  
  35.   
  36.     private Runnable mRunnable = new Runnable() {    
  37.           
  38.         public void run() {  
  39.             Log.v(TAG, "run...");  
  40.             try {  
  41.                 sendMultiBroadcast();  
  42.             } catch (Exception e) {  
  43.                 e.printStackTrace();  
  44.             }  
  45.         }  
  46.   
  47.         private void sendMultiBroadcast() throws IOException {  
  48.             Log.v(TAG, "sendMultiBroadcast...");  
  49.             /* 
  50.              * 实现多点广播时，MulticastSocket类是实现这一功能的关键，当MulticastSocket把一个DatagramPacket发送到多点广播IP地址， 
  51.              * 该数据报将被自动广播到加入该地址的所有MulticastSocket。MulticastSocket类既可以将数据报发送到多点广播地址， 
  52.              * 也可以接收其他主机的广播信息 
  53.              */  
  54.             MulticastSocket socket = new MulticastSocket(8600);  
  55.             //IP协议为多点广播提供了这批特殊的IP地址，这些IP地址的范围是224.0.0.0至239.255.255.255  
  56.             InetAddress address = InetAddress.getByName("224.0.0.1");  
  57.             /* 
  58.              * 创建一个MulticastSocket对象后，还需要将该MulticastSocket加入到指定的多点广播地址， 
  59.              * MulticastSocket使用jionGroup()方法来加入指定组；使用leaveGroup()方法脱离一个组。 
  60.              */  
  61.             socket.joinGroup(address);  
  62.               
  63.             /* 
  64.              * 在某些系统中，可能有多个网络接口。这可能会对多点广播带来问题，这时候程序需要在一个指定的网络接口上监听， 
  65.              * 通过调用setInterface可选择MulticastSocket所使用的网络接口； 
  66.              * 也可以使用getInterface方法查询MulticastSocket监听的网络接口。 
  67.              */  
  68.             //socket.setInterface(address);  
  69.               
  70.             DatagramPacket packet;  
  71.             //发送数据包  
  72.             Log.v(TAG, "send packet");  
  73.             byte[] buf = "Hello I am MultiSocketA".getBytes();  
  74.             packet = new DatagramPacket(buf, buf.length, address, 8601);  
  75.             socket.send(packet);  
  76.               
  77.             //接收数据  
  78.             Log.v(TAG, "receiver packet");  
  79.             byte[] rev = new byte[512];  
  80.             packet = new DatagramPacket(rev, rev.length);  
  81.             socket.receive(packet);  
  82.             Log.v(TAG, "get data = " + new String(packet.getData()).trim());    //不加trim，则会打印出512个byte，后面是乱码  
  83.               
  84.             //退出组播  
  85.             socket.leaveGroup(address);  
  86.             socket.close();  
  87.         }    
  88.             
  89.     };    
  90. }  

再看MultiSocketB

 
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     package="com.example.multicastsocketreceiver"  
  4.     android:versionCode="1"  
  5.     android:versionName="1.0" >  
  6.     <uses-permission android:name="android.permission.INTERNET" />  
  7.   
  8.     <uses-sdk  
  9.         android:minSdkVersion="8"  
  10.         android:targetSdkVersion="17" />  
  11.   
  12.     <application  
  13.         android:allowBackup="true"  
  14.         android:icon="@drawable/ic_launcher"  
  15.         android:label="@string/app_name"  
  16.         android:theme="@style/AppTheme" >  
  17.         <activity  
  18.             android:name="com.example.multicastsocketreceiver.MainActivity"  
  19.             android:label="@string/app_name" >  
  20.             <intent-filter>  
  21.                 <action android:name="android.intent.action.MAIN" />  
  22.   
  23.                 <category android:name="android.intent.category.LAUNCHER" />  
  24.             </intent-filter>  
  25.         </activity>  
  26.           
  27.         <service android:name=".MultiSocketB" />  
  28.           
  29.     </application>  
  30.   
  31. </manifest>  
 
  1. package com.example.multicastsocketreceiver;  
  2.   
  3. import android.os.Bundle;  
  4. import android.app.Activity;  
  5. import android.content.Intent;  
  6.   
  7. public class MainActivity extends Activity {  
  8.   
  9.     @Override  
  10.     protected void onCreate(Bundle savedInstanceState) {  
  11.         super.onCreate(savedInstanceState);  
  12.         setContentView(R.layout.activity_main);  
  13.           
  14.         Intent intent = new Intent();  
  15.         intent.setClass(this, MultiSocketB.class);  
  16.         this.startService(intent);  
  17.     }  
  18.   
  19. }  
 
  1. package com.example.multicastsocketreceiver;  
  2.   
  3. import java.io.IOException;  
  4. import java.net.DatagramPacket;  
  5. import java.net.InetAddress;  
  6. import java.net.MulticastSocket;  
  7. import android.app.Service;  
  8. import android.content.Intent;  
  9. import android.os.Handler;  
  10. import android.os.HandlerThread;  
  11. import android.os.IBinder;  
  12. import android.util.Log;  
  13.   
  14. public class MultiSocketB extends Service {  
  15.     protected static final String TAG = "MultiSocketB";  
  16.     private Handler mHandler;  
  17.   
  18.     @Override  
  19.     public IBinder onBind(Intent intent) {  
  20.         return null;  
  21.     }  
  22.   
  23.     @Override  
  24.     public void onCreate() {  
  25.         super.onCreate();  
  26.         Log.v(TAG, "onCreate");  
  27.         // 通过Handler启动线程  
  28.         HandlerThread handlerThread = new HandlerThread("MultiSocketB");  
  29.         handlerThread.start();  
  30.         mHandler = new Handler(handlerThread.getLooper());  
  31.         mHandler.post(mRunnable);  
  32.     }  
  33.   
  34.     private Runnable mRunnable = new Runnable() {  
  35.         public void run() {  
  36.             Log.v(TAG, "run...");  
  37.             try {  
  38.                 receiveMultiBroadcast();  
  39.             } catch (Exception e) {  
  40.                 e.printStackTrace();  
  41.             }  
  42.         }  
  43.   
  44.     };  
  45.   
  46.     protected void receiveMultiBroadcast() throws IOException {  
  47.         Log.v(TAG, "receiveMultiBroadcast...");  
  48.         MulticastSocket socket = new MulticastSocket(8601);  
  49.         InetAddress address = InetAddress.getByName("224.0.0.1");  
  50.         socket.joinGroup(address);  
  51.   
  52.         DatagramPacket packet;  
  53.   
  54.         // 接收数据  
  55.         Log.v(TAG, "receiver packet");  
  56.         byte[] rev = new byte[512];  
  57.         packet = new DatagramPacket(rev, rev.length);  
  58.         socket.receive(packet);  
  59.         String receiver = new String(packet.getData()).trim();  //不加trim，则会打印出512个byte，后面是乱码  
  60.         Log.v(TAG, "get data = " + receiver);  
  61.   
  62.         //发送数据包  
  63.         Log.v(TAG, "send packet");  
  64.         String process_receiver = "I am MultiSocketB, I got " + receiver;  
  65.         byte[] buf = process_receiver.getBytes();  
  66.         packet = new DatagramPacket(buf, buf.length, address, 8600);  
  67.         socket.send(packet);  
  68.           
  69.         //退出组播  
  70.         socket.leaveGroup(address);  
  71.         socket.close();  
  72.     }  
  73.   
  74. }  
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/senior-engineer/p/4966020.html