Android Socket基于UDP协议通信

首先我们要知道UDP通信协议是Socket通信的一种实现方式，Socket通信一般有两种通信方式：基于TCP协议、基于UDP协议。这两者的差别和优缺点就不说了，这里主要讲一下基于UDP协议的实现。

基本原理

基于UDP的通信都是通过java.net.DatagramSocket这个类来实现的,我们常用的有connect()、disConnect()、send()、receive()几个方法。通过方法名我们可以轻易区分出用法。另一个需要知道的就是DatagramPacket类，如果把DatagramSocket比作管道的话，DatagramPacket就是管道中运输的物品，也就是说，它就是数据的载体。

DatagramSocket：

public DatagramSocket()throws SocketException {
    this(0);
}

public DatagramSocket(int aPort)throws SocketException {
    checkPort(aPort);
    createSocket(aPort, Inet4Address.ANY);
}

public DatagramSocket(int aPort, InetAddress addr)throws SocketException {
    checkPort(aPort);
    createSocket(aPort, (addr == null) ? Inet4Address.ANY : addr);
}

三个构造方法，我们可以指定端口和IP，也可以不指定，在发送数据的时候，在数据包中指定。

DatagramPacket：

public DatagramPacket(byte[]data, int length) {…}
public DatagramPacket(byte[]data, int offset, int length) {…}
public DatagramPacket(byte[]data, int offset, int length, InetAddress host, int aPort) {…}
public DatagramPacket(byte[]data, int length, InetAddress host, int port) {…}

so 我们可以看到可以在数据包中设置ip和端口，所以如果连接时不指定也是可以的。

基本操作

1、connect new出一个DatagramSocket对象，设置端口和IP，connect()；
2、send 创建一个DatagramPacket对象，socket.send(packet)发送数据；
3、receive 创建一个DatagramPacket对象，socket.receive(package)接收数据；

创建一个连接

使用connect方法创建一个Socket连接

public void connect() {
    if (mSocket == null || mSocket.isClosed()) {
        try {
            //获取连接 ip：192.168.1.3  port：11069
            InetAddress address = InetAddress.getByName(Command.udp_address);
            mSocket = new DatagramSocket();
            mSocket.connect(address, Command.udp_port);
            messageQueue = new ArrayList < String > ();
            //开启接收线程
            mReceiveThread = new ReceiveThread();
            mReceiveThread.start();
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }
}

定时发送数据保持通信

要保持通信的话，肯定要用到线程了，定时发送数据的话，可以用Handler，或者也可以使用AlarmManager。这里使用Handler实现就好了。

写的时候看了一堆博客，发送的时候都是new 出一个Thread进行发送数据，发送之后写接收数据的代码，而且没有进行回收或者怎样，只能最后通过GC回收，当然大体上看是没毛病的，但是其实有很大的问题！因为我项目要求收到服务器的应答之后做一些相应的操作，，然后，然后，，因为每一个线程都在等待着接收数据，所以服务端回复一条数据之后，这边每个线程都作出了回应（回复服务器一条不一样的数据），10s创建一个线程发送数据，服务器过了一段时间再回复，然后就瞬间爆炸！

所以，，接收和发送应该是要分开的，不能阻塞在同一个线程中。一开始想到Handler的原理和机制，想模仿它死循环从一个队列中取数据，如果有数据就发送，想法是没毛病，也能发送，但是当我想在发送成功之后从列表中remove掉这条数据之后就不行了，线程阻塞了。具体原因应该是造成死锁了，因为数据列表是定义在主线程，然后一直在被工作线程占用着，获取不到对象进行remove操作，等待一定时间后，直接crash掉了（我的分析是这样的）。

ok，那就写两个线程好了，一个SendThread，一个ReceiveThread，另外通过Handler控制10s定时发送。

发送线程：

public class SendThread extends Thread {
    @ Override
    public void run() {
        super.run();
        try {
            if (mSocket == null || mSocket.isClosed())
                return;
            if (messageQueue.size() < 1)
                return;
            //发送
            final String data = messageQueue.get(0);
            byte[]datas = data.getBytes();
            InetAddress address = InetAddress.getByName(Command.udp_address);
            final DatagramPacket packet = new DatagramPacket(datas, datas.length, address, Command.udp_port);
            mSocket.send(packet);
            Logs.e("ConnectManager", "send success data is:" + data);
            messageQueue.remove(0);

        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

接收线程：

private class ReceiveThread extends Thread {
    @ Override
    public void run() {
        super.run();
        if (mSocket == null || mSocket.isClosed())
            return;
        try {
            byte datas[] = new byte[512];
            DatagramPacket packet = new DatagramPacket(datas, datas.length, address, Command.udp_port);
            mSocket.receive(packet);
            String receiveMsg = new String(packet.getData()).trim();
            Logs.e("ConnectManager", "receive msg data is:" + receiveMsg);
            mHandler.sendEmptyMessage(2);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

我们可以看到ReceiveThread中只接收了一次数据，那如何实现一直保持通信？接收消息？Handler！接收到消息之后我们通过Handler发送了一条消息，这条消息干嘛的呢，重启这个线程，也就是让它继续接收数据。 这样的话，就保证了只有一个线程在接收数据。

private Handler mHandler = new Handler() {
    @ Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        if (msg.what == 2) {
            mReceiveThread.interrupt();
            mReceiveThread = null;
            mReceiveThread = new ReceiveThread();
            mReceiveThread.start();
        }
    }
};

同样，定时发送数据也是通过Handler实现的，每10s发送一个消息，让socket发送一个数据包，并且给自己发送一个10s后发送的同样的消息，反正就是自己控几自己啦。

发送消息：

public void sendPackageRegister() {
    String content = "(1001," + Command.deviceId + ",register)";
    messageQueue.add(content);
    mSendThread.interrupt();
    mSendThread = null;
    mSendThread = new SendThread();
    mSendThread.start();
}

最后，记得停掉Handler一直发送数据，停掉线程。