前言

因为需求,可能需要在安卓上完成一个同时包含UDP和TCP的项目。因此，本来做iOS的小编在闲暇之余研究了一波安卓的UDP是如何实现的。
TCP客户端实现请点这里：TCP。

实现

1.常量设置

首先,既然要完成UDP,就需要端口和地址。小编想着安卓应该有向iOS一样的(.pch)文件或者是(.h)文件来管理这一类的参数,但是通过谷爹度娘发现,安卓并没有与(.pch)类似的文件,(.h)文件也不能像iOS一样直接引用。因此，小编建立了一个类(.java)来设置常量，用了专门管理这些参数。如下:

public class Constants {
    static final String SOCKET_HOST         = "255.255.255.255";
    static final int SOCKET_UDP_PORT        = 24680;
}

2.UDP的封装

小编看了很多资料,发现网上的资料大多数很复杂,并不能满足小编最基础的需求。因此,小编决定自己封装一个简易的类来方便使用。

创建单例

首先,小编想到的是单例。因为不管是iOS还是安卓,都应该有单例。单例的好处主要在于可以使该类在系统内存中只存在一个对象，可以节约系统资源，对于一些需要频繁创建和销毁的对象，可以明显的提高系统的性能。
安卓的单例写法有很多种,最后小编选择了一种自己认为比较好的写法,如下：

public class UDPBuild {
    private static UDPBuild udpBuild;

    private OnUDPReceiveCallbackBlock udpReceiveCallback;
//    构造函数私有化 
    private UDPBuild() {
        super();
    }
//    提供一个全局的静态方法
    public static UDPBuild getUdpBuild() {
        if (udpBuild == null) {
            synchronized (UDPBuild.class) {
                if (udpBuild == null) {
                    udpBuild = new UDPBuild();
                }
            }
        }
        return udpBuild;
    }
}

建立线程

为了能更好的处理数据,小编在这里建立了一个线程。但是安卓的线程和iOS的有一点不太一样,就是安卓设备的CPU数量不太一样,所以要根据CPU数目初始化线程池.如下:

    private static final String TAG = "UDPBuild";
//    单个CPU线程池大小
    private static final int POOL_SIZE = 5;
    private static final int BUFFER_LENGTH = 1024;
    private byte[] receiveByte = new byte[BUFFER_LENGTH];

    private boolean isThreadRunning = false;

    private ExecutorService mThreadPool;
    private Thread clientThread;
-------------------------------------------------------------------
    private UDPBuild() {
        super();
        int cpuNumbers = Runtime.getRuntime().availableProcessors();
//        根据CPU数目初始化线程池
        mThreadPool = Executors.newFixedThreadPool(cpuNumbers * POOL_SIZE);
    }
/**
     * 开启发送数据的线程
     **/
    private void startSocketThread() {
        clientThread = new Thread(new Runnable() {
            @Override
            public void run() {
                Log.d(TAG, "clientThread is running...");
            }
        });
        isThreadRunning = true;
        clientThread.start();
    }

UDP发送和接收的集成

接下来就是集成UDP的时候了。安卓有两个类，一个是DatagramSocket,这个类就是安卓代表UDP的Socket;另一个类是DatagramPacket,这个类是安卓接收UDP包的类。所谓的集成就是对这两个类的使用。
集成的思路是建立一个方法去初始化socket,初始化完后开启线程,并在线程中加入接收数据的方法。在发送信息时判断socket存不存在,不存在就使用刚刚说的方法去初始化,初始化完了再发送。如下:

    private DatagramSocket client;
    private DatagramPacket receivePacket;
-------------------------------------------------------------------
    public void startUDPSocket() {
        if (client != null) return;
        try {
//            表明这个 Socket 在设置的端口上监听数据。
            client = new DatagramSocket(Constants.SOCKET_UDP_PORT);

            if (receivePacket == null) {
                receivePacket = new DatagramPacket(receiveByte, BUFFER_LENGTH);
            }
            startSocketThread();
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }
    /**
     * 开启发送数据的线程
     **/
    private void startSocketThread() {
        clientThread = new Thread(new Runnable() {
            @Override
            public void run() {
                Log.d(TAG, "clientThread is running...");
                receiveMessage();
            }
        });
        isThreadRunning = true;
        clientThread.start();
    }
    /**
     * 处理接受到的消息
     **/
    private void receiveMessage() {
        while (isThreadRunning) {
            if (client != null) {
                try {
                    client.receive(receivePacket);
                } catch (IOException e) {
                    Log.e(TAG, "UDP数据包接收失败！线程停止");
                    e.printStackTrace();
                    return;
                }
            }

            if (receivePacket == null || receivePacket.getLength() == 0) {
                Log.e(TAG, "无法接收UDP数据或者接收到的UDP数据为空");
                continue;
            }
            String strReceive = new String(receivePacket.getData(), 0, receivePacket.getLength());
            Log.d(TAG, strReceive + " from " + receivePacket.getAddress().getHostAddress() + ":" + receivePacket.getPort());
//            每次接收完UDP数据后，重置长度。否则可能会导致下次收到数据包被截断。
            if (receivePacket != null) {
                receivePacket.setLength(BUFFER_LENGTH);
            }
        }
    }
   /**
    * 发送信息
    **/
    public void sendMessage(final String message) {
        if (client == null) {
            startUDPSocket();
        }
        mThreadPool.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    InetAddress targetAddress = InetAddress.getByName(Constants.SOCKET_HOST);

                    DatagramPacket packet = new DatagramPacket(message.getBytes(), message.length(), targetAddress, Constants.SOCKET_UDP_PORT);
                    client.send(packet);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }

在接收到数据包之后需要将数据回调出去,但是网上大多数都是把控制器在类中,这不是小编的初衷。因此小编用了一种类似iOS中Block的方式去回调。如下:

    private OnUDPReceiveCallbackBlock udpReceiveCallback;
-------------------------------------------------------------------
    public interface OnUDPReceiveCallbackBlock {
        void OnParserComplete(DatagramPacket data);
    }
    public void setUdpReceiveCallback(OnUDPReceiveCallbackBlock callback) {
        this.udpReceiveCallback = callback;
    }
    public void removeCallback(){
        udpReceiveCallback = null;
    }
    /**
     * 处理接受到的消息
     **/
    private void receiveMessage() {
        while (isThreadRunning) {
            if (client != null) {
                try {
                    client.receive(receivePacket);
                } catch (IOException e) {
                    Log.e(TAG, "UDP数据包接收失败！线程停止");
                    e.printStackTrace();
                    return;
                }
            }

            if (receivePacket == null || receivePacket.getLength() == 0) {
                Log.e(TAG, "无法接收UDP数据或者接收到的UDP数据为空");
                continue;
            }
            String strReceive = new String(receivePacket.getData(), 0, receivePacket.getLength());
            Log.d(TAG, strReceive + " from " + receivePacket.getAddress().getHostAddress() + ":" + receivePacket.getPort());
            if (udpReceiveCallback != null) {
                udpReceiveCallback.OnParserComplete(receivePacket);
            }
//            每次接收完UDP数据后，重置长度。否则可能会导致下次收到数据包被截断。
            if (receivePacket != null) {
                receivePacket.setLength(BUFFER_LENGTH);
            }
        }
    }

既然有开启UDP,那肯定有关闭UDP的时候,关闭UDP时需要接收信息的回调和线程也移除。注意：在接收包时,有可能因为socket原因而接收失败,此时也需要关闭。这里并不影响下次发送，因为下次发送时会判断socket存不存在，不存在会重新建立。如下:

    /**
     * 处理接受到的消息
     **/
    private void receiveMessage() {
        while (isThreadRunning) {
            if (client != null) {
                try {
                    client.receive(receivePacket);
                } catch (IOException e) {
                    Log.e(TAG, "UDP数据包接收失败！线程停止");
                    stopUDPSocket();
                    e.printStackTrace();
                    return;
                }
            }

            if (receivePacket == null || receivePacket.getLength() == 0) {
                Log.e(TAG, "无法接收UDP数据或者接收到的UDP数据为空");
                continue;
            }
            String strReceive = new String(receivePacket.getData(), 0, receivePacket.getLength());
            Log.d(TAG, strReceive + " from " + receivePacket.getAddress().getHostAddress() + ":" + receivePacket.getPort());
            if (udpReceiveCallback != null) {
                udpReceiveCallback.OnParserComplete(receivePacket);
            }
//            每次接收完UDP数据后，重置长度。否则可能会导致下次收到数据包被截断。
            if (receivePacket != null) {
                receivePacket.setLength(BUFFER_LENGTH);
            }
        }
    }
    /**
     * 停止UDP
     **/
    public void stopUDPSocket() {
        isThreadRunning = false;
        receivePacket = null;
        if (clientThread != null) {
            clientThread.interrupt();
        }
        if (client != null) {
            client.close();
            client = null;
        }
        removeCallback();
    }

到这里，就集成完成了。

3.使用

使用起来相当简单,导入类,初始化,通过该类的方法发送信息和接收信息即可,如下:

public class MainActivity extends AppCompatActivity {
    private UDPBuild udpBuild;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        udpBuild = UDPBuild.getUdpBuild();
        udpBuild.setUdpReceiveCallback(new UDPBuild.OnUDPReceiveCallbackBlock() {
            @Override
            public void OnParserComplete(DatagramPacket data) {
                String strReceive = new String(data.getData(), 0, data.getLength());
                SimpleDateFormat formatter = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
                Date curDate =  new Date(System.currentTimeMillis());
                String str = formatter.format(curDate);
//在真机上运行需要用handle回到主线程再更新UI，不然会崩。模拟器上不会
                TextView receive = findViewById(R.id.receive_textView);
                receive.append(str + ':' + strReceive + '\n');
            }
        });
    }
    public void sendMessage(View view) {
        EditText editText = findViewById(R.id.send_editText);
        String message = editText.getText().toString();
        udpBuild.sendMessage(message);

        TextView send = findViewById(R.id.send_textView);
        send.append(message + '\n');
    }
}

到这里为止，UDP的Demo就完成了，写的不好的地方欢迎大家指出，Demo下载地址：Demo。最后，希望这篇文章对各位看官们有所帮助。对支持小编的看官们表示感谢。

Android-UDP的实现