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一直发送数据,停掉线程。

你可能感兴趣的:(Android Socket基于UDP协议通信)