为了账号安全,请及时绑定邮箱和手机立即绑定

Android 基于UDP的Socket通信

标签:
Android

截图

1、Android 客户端

webp

client.png

2、PC服务端:用的是SocketTool软件模拟

webp

server.png

流程

1、连接DatagramSocket的服务端(ip和port):开启异步线程和socket
2、发送数据(DatagramPacket):异步
3、接收数据(DatagramPacket):注意连接状态,异步读取
4、关闭连接:关闭DatagramSocket和对应线程

注意

1、异常:android.os.NetworkOnMainThreadException。 socket需要在线程中使用
2、前后端统一传输或者接收协议 [requestcode   size  d1 d2 d3 ... ],在解析时候用得到
3、实施监控socket的连接状态,还是用心跳包发过去,然后返回数据,一段时间没有的话则代表socket连接失败。
4、注意receive接收数据后的有效长度(一个是预存的buffer,一个是有效结果buffer)
5、客户端连上去后不知道为何一定要先发送一次,才能接收?
6、UDP不安全,有长度限制64K

代码

1、UdpClient.java:udp-socket的客户端,略微做了通用封装,主要是连接,发送,接收,然后设置监听
/**
 * Created by wujn on 2019/2/15.
 * Version : v1.0
 * Function: udp client 64k限制
 */public class UdpClient {    /**
     * single instance UdpClient
     * */
    private static UdpClient mSocketClient = null;    private UdpClient(){}    public static UdpClient getInstance(){        if(mSocketClient == null){            synchronized (UdpClient.class) {
                mSocketClient = new UdpClient();
            }
        }        return mSocketClient;
    }


    String TAG_log = "Socket";    private DatagramSocket mSocket;    private DatagramPacket sendPacket;    //发送
    private DatagramPacket receivePacket; //接受//  private OutputStream mOutputStream;//  private InputStream mInputStream;

    private SocketThread mSocketThread;    private boolean isStop = false;//thread flag


    /**
     * 128 - 数据按照最长接收,一次性
     * */
    private class SocketThread extends Thread {        private String ip;        private int port;        public SocketThread(String ip, int port){            this.ip = ip;            this.port = port;
        }        @Override
        public void run() {
            Log.d(TAG_log,"SocketThread start ");            super.run();            //connect ...
            try {                if (mSocket != null) {
                    mSocket.close();
                    mSocket = null;
                }

                InetAddress ipAddress = InetAddress.getByName(ip);
                mSocket = new DatagramSocket();
                mSocket.connect(ipAddress, port); //连接

                //设置timeout
                //mSocket.setSoTimeout(3000);
                Log.d(TAG_log,"udp connect = "+isConnect());                if(isConnect()){
                    isStop = false;
                    uiHandler.sendEmptyMessage(1);
                }                /* 此处这样做没什么意义不大,真正的socket未连接还是靠心跳发送,等待服务端回应比较好,一段时间内未回应,则socket未连接成功 */
                else{
                    uiHandler.sendEmptyMessage(-1);
                    Log.e(TAG_log,"SocketThread connect fail");                    return;
                }

            }            catch (IOException e) {
                uiHandler.sendEmptyMessage(-1);
                Log.e(TAG_log,"SocketThread connect io exception = "+e.getMessage());
                e.printStackTrace();                return;
            }
            Log.d(TAG_log,"SocketThread connect over ");            //发送一次,否则不发送则收不到,不知道为啥。。。
            sendByteCmd(new byte[]{00},-1);//send once

            //read ...
            while (isConnect() && !isStop && !isInterrupted()) {                int size;                try {                    byte[] preBuffer = new byte[4 * 1024];//预存buffer
                    receivePacket = new DatagramPacket(preBuffer, preBuffer.length);
                    mSocket.receive(receivePacket);                    if (receivePacket.getData() == null) return;
                    size = receivePacket.getLength();     //此为获取后的有效长度,一次最多读64k,预存小的话可能分包
                    Log.d(TAG_log, "pre data size = "+receivePacket.getData().length + ", value data size = "+size);                    byte[] dataBuffer = Arrays.copyOf(preBuffer, size);                    if (size > 0) {
                        Message msg = new Message();
                        msg.what = 100;
                        Bundle bundle = new Bundle();
                        bundle.putByteArray("data",dataBuffer);
                        bundle.putInt("size",size);
                        bundle.putInt("requestCode",requestCode);
                        msg.setData(bundle);
                        uiHandler.sendMessage(msg);
                    }
                    Log.i(TAG_log, "SocketThread read listening");                    //Thread.sleep(100);//log eof
                }                catch (IOException e) {
                    uiHandler.sendEmptyMessage(-1);
                    Log.e(TAG_log,"SocketThread read io exception = "+e.getMessage());
                    e.printStackTrace();                    return;
                }
            }
        }
    }    //==============================socket connect============================
    private String ip;    private int port;    /**
     * connect socket in thread
     * Exception : android.os.NetworkOnMainThreadException
     * */
    public void connect(String ip, int port){        this.ip = ip;        this.port = port;
        mSocketThread = new SocketThread(ip, port);
        mSocketThread.start();
    }    /**
     * socket is connect
     * */
    public boolean isConnect(){        boolean flag = false;        if (mSocket != null) {
            flag = mSocket.isConnected();
        }        return flag;
    }    
    /**
     * socket disconnect
     * */
    public void disconnect() {
        isStop = true;        if (mSocket != null) {
            mSocket.close();
            mSocket = null;
        }        if (mSocketThread != null) {
            mSocketThread.interrupt();//not intime destory thread,so need a flag
        }
    }    /**
     * send byte[] cmd
     * Exception : android.os.NetworkOnMainThreadException
     * */
    public void sendByteCmd(final byte[] mBuffer,int requestCode) {        this.requestCode = requestCode;        new Thread(new Runnable() {            @Override
            public void run() {                try {
                    InetAddress ipAddress = InetAddress.getByName(ip);
                    sendPacket = new DatagramPacket(mBuffer, mBuffer.length, ipAddress, port);
                    mSocket.send(sendPacket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();

    }




    Handler uiHandler = new Handler() {        @Override
        public void handleMessage(Message msg) {            super.handleMessage(msg);            switch(msg.what){                //connect error
                case -1:                    if (null != onDataReceiveListener) {
                        onDataReceiveListener.onConnectFail();
                        disconnect();
                    }                    break;                //connect success
                case 1:                    if (null != onDataReceiveListener) {
                        onDataReceiveListener.onConnectSuccess();
                    }                    break;                //receive data
                case 100:
                    Bundle bundle = msg.getData();                    byte[] buffer = bundle.getByteArray("data");                    int size = bundle.getInt("size");                    int mequestCode = bundle.getInt("requestCode");                    if (null != onDataReceiveListener) {
                        onDataReceiveListener.onDataReceive(buffer, size, mequestCode);
                    }                    break;
            }
        }
    };    
    /**
     * socket response data listener
     * */
    private OnDataReceiveListener onDataReceiveListener = null;    private int requestCode = -1;    public interface OnDataReceiveListener {        public void onConnectSuccess();        public void onConnectFail();        public void onDataReceive(byte[] buffer, int size, int requestCode);
    }    public void setOnDataReceiveListener(
            OnDataReceiveListener dataReceiveListener) {
        onDataReceiveListener = dataReceiveListener;
    }
    

}
MainActivity.java:使用,简单明了
private void initListener(){        //socket connect
        btn_connect.setOnClickListener(new View.OnClickListener() {            @Override
            public void onClick(View v) {
                String ip = et_ip.getText().toString();
                String port = et_port.getText().toString();                if(TextUtils.isEmpty(ip)){
                    Toast.makeText(UdpActivity.this,"IP地址为空",Toast.LENGTH_SHORT).show();                    return;
                }                if(TextUtils.isEmpty(port)){
                    Toast.makeText(UdpActivity.this,"端口号为空",Toast.LENGTH_SHORT).show();                    return;
                }

                connect(ip, Integer.parseInt(port));
            }
        });        //socket disconnect
        btn_disconnect.setOnClickListener(new View.OnClickListener() {            @Override
            public void onClick(View v) {
                disconnect();
            }
        });        //socket send
        btn_send.setOnClickListener(new View.OnClickListener() {            @Override
            public void onClick(View v) {                if (UdpClient.getInstance().isConnect()) {                    byte[] data = et_send.getText().toString().getBytes();
                    send(data);
                } else {
                    Toast.makeText(UdpActivity.this,"尚未连接,请连接Socket",Toast.LENGTH_SHORT).show();
                }
            }
        });        //clear receive
        btn_clear.setOnClickListener(new View.OnClickListener() {            @Override
            public void onClick(View v) {
                tv_receive.setText("");
            }
        });
    }    /**
     * socket data receive
     * */
    private void initDataReceiver(){
        UdpClient.getInstance().setOnDataReceiveListener(dataReceiveListener);
    }    /**
     * socket connect
     * */
    private void connect(String ip, int port){
        UdpClient.getInstance().connect(ip, port);
    }    /**
     * socket disconnect
     * */
    private void disconnect(){
        UdpClient.getInstance().disconnect();
        tv_state.setText("未连接");
    }    /**
     * socket send
     * */
    private void send(byte[] data){
        String ip = et_ip.getText().toString();
        String port = et_port.getText().toString();

        UdpClient.getInstance().sendByteCmd(data,1001);
    }    /**
     * socket data receive
     * data(byte[]) analyze
     * */
    private UdpClient.OnDataReceiveListener dataReceiveListener = new UdpClient.OnDataReceiveListener() {        @Override
        public void onConnectSuccess() {
            Log.i(TAG_log,"onDataReceive connect success");
            tv_state.setText("已连接");
        }        @Override
        public void onConnectFail() {
            Log.e(TAG_log,"onDataReceive connect fail");
            tv_state.setText("未连接");
        }        @Override
        public void onDataReceive(byte[] buffer, int size, int requestCode) {            //获取有效长度的数据
            byte[] data = new byte[size];
            System.arraycopy(buffer, 0, data, 0, size);            final String oxValue = Arrays.toString(HexUtil.Byte2Ox(data));
            Log.i(TAG_log,"onDataReceive requestCode = "+requestCode + ", content = "+oxValue);

            tv_receive.setText(tv_receive.getText().toString() + oxValue + "\n");

        }
    };    @Override
    protected void onDestroy() {
        UdpClient.getInstance().disconnect();        super.onDestroy();
    }



作者:Kandy_JS
链接:https://www.jianshu.com/p/9dbb8ac146f6


点击查看更多内容
TA 点赞

若觉得本文不错,就分享一下吧!

评论

作者其他优质文章

正在加载中
  • 推荐
  • 评论
  • 收藏
  • 共同学习,写下你的评论
感谢您的支持,我会继续努力的~
扫码打赏,你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫,即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消