Android UDP\TCP Socket Demo (新手上路,源码提供)

安稳www

已于 2023-02-16 14:56:11 修改

阅读量560

点赞数 1

文章标签： android udp tcp/ip

于 2023-02-16 14:52:58 首次发布

本文链接：https://blog.csdn.net/qq_40968567/article/details/129043182

版权

Android UDP\TCP Socket Demo (新手上路,源码提供)**

欢迎各路大神,批评指正!
/**
简单说下, 用法区别:( 目前这篇是UDP!!! 整理不易… 看看大家得需求, 我们下篇再写TCP, 毕竟已经封装好得了…)
1. UDP 是链接同一个域名Ip, Server通过广播发送数据消息, 接收端通过网络或去到数据(注: 不可靠,无链接)
2. TCP Server 与 Client 相互通讯, 点对点, 可靠有链接, 但是应用相对麻烦 (个人发现: 多次发送数据, 出现粘包等问题)
*/

上代码!

这边是给大家直接做好了工具类,大家直接按照我的过程调用就好使…
/**
Server一端使用流程:
1. new UdpSocketServer.initWifi(this);//初始化Wifi
2. new UdpSocketServer.setReviceCallBack(this);// 设置接收监听
3. new UdpSocketServer.SendData(“你好哇~”);// 发送数据
*/

public class UdpSocketServer {
private static final String TAG = "UdpSocketServer";
private static String IP;
private static UdpSocketServer instance;
private InetAddress inetAddress = null;
private static int BROADCAST_PORT = 9999;
private static String BROADCAST_IP = "255.255.255.255";

private ReceiveThread receiveThread;
private DatagramSocket sendSocket = null;
private DatagramSocket receiveSocket = null;
private volatile boolean isRuning = true;
private BroadcastThread broadcastThread;
private String reviceData;
private ReviceCallBack reviceCallBack;

private UdpSocketServer() {
}

public void initWifi(Context context) {
    //Wifi状态判断
    WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
    if (wifiManager.isWifiEnabled()) {
        WifiInfo wifiInfo = wifiManager.getConnectionInfo();
        IP = getIpString(wifiInfo.getIpAddress());
        Log.i(TAG, "initWifi: Ip: " + IP
        );
    }
    initThread();
    initAddress();
}

private void initAddress() {
    try {
        inetAddress = InetAddress.getByName(BROADCAST_IP);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

private void initThread() {
    broadcastThread = new BroadcastThread();
    broadcastThread.start();
    receiveThread = new ReceiveThread();
    receiveThread.start();
}

public class BroadcastThread extends Thread {
    private Handler mhandler = null;

    @SuppressLint("HandlerLeak")
    @Override
    public void run() {
        Looper.prepare();
        mhandler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                String message = (String) msg.obj;
                byte[] data = message.getBytes();
                DatagramPacket dpSend = null;
                dpSend = new DatagramPacket(data, data.length, inetAddress, BROADCAST_PORT);
                try {
                    sendSocket = new DatagramSocket();
                    sendSocket.send(dpSend);
                    sendSocket.close();
                    Thread.sleep(80);
                    Log.i(TAG, "sendMessage: data " + new String(data));
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        Looper.loop();
    }
}
public void SendData(String message){
    Message msg = Message.obtain();
    msg.obj = message;
    msg.what = 1;
    broadcastThread.mhandler.sendMessage(msg);
}

public class ReceiveThread extends Thread {
    @Override
    public void run() {
        try {
            while (true) {
                if (isRuning) {
                    byte[] receiveData = new byte[1024];
                    DatagramPacket dpReceive = null;
                    dpReceive = new DatagramPacket(receiveData, receiveData.length);
                    if (receiveSocket == null) {
                        receiveSocket = new DatagramSocket(BROADCAST_PORT);
                    }
                    receiveSocket.receive(dpReceive);
                    String recIp = dpReceive.getAddress().toString().substring(1);
                    String reviceMsg = new String(receiveData, 0, dpReceive.getLength());
                    if (mListener != null){
                        reviceCallBack.reviceData(reviceMsg);
                    }
                    Thread.sleep(80);
                    Log.i(TAG, "run: reviceMsg: " + reviceMsg);
                }
            }
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}
private String getIpString(int i) {
    return (i & 0xFF) + "." + ((i >> 8) & 0xFF) + "."
            + ((i >> 16) & 0xFF) + "." + (i >> 24 & 0xFF);
}

public void setReviceCallBack(ReviceCallBack reviceCallBack) {
    this.reviceCallBack = reviceCallBack;
}
public interface ReviceCallBack {
    void reviceData(String data);
}

}

/**
Client一端使用流程:
1. new UdpSocketClient().initWifi(this);//初始化Wifi
2. new UdpSocketClient().setReviceCallBack(this);// 设置接受监听
注: //这边得逻辑是循环发送数据,这个很好改,抽出来个方法就可以了,
*/

public class UdpSocketClient {
private static final String TAG = "UdpSocketClient";

private static String IP;
private static int BROADCAST_PORT = 9999;

private String receiveIp;
private String sendIp;
private DatagramSocket receiveSocket = null;
private DatagramSocket sendSocket = null;
private DatagramPacket dpReceive = null;
private SendThread sendThread;
private ReceiveThread receiveThread;
private boolean isRunning = true;
private String previousContent = new String();
private ReviceCallBack reviceCallBack;
private String sendData;

private UdpSocketClient() {
}

public void initWifi(Context context) {
    Log.i(TAG, "initWifi: is run.");
    WifiManager wifiManager = (WifiManager) context.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
    if (wifiManager.isWifiEnabled()) {
        WifiInfo wifiInfo = wifiManager.getConnectionInfo();
        IP = getIpString(wifiInfo.getIpAddress());
        Log.i(TAG, "onCreate: Ip: " + IP);
    }

    receiveThread = new ReceiveThread();
    sendThread = new SendThread();
    receiveThread.start();
    sendThread.start();
}

private class ReceiveThread extends Thread {
    @SuppressLint("LongLogTag")
    @Override
    public void run() {
        while (true) {
            if (isRunning) {
                String receiveContent = null;
                byte[] buf = new byte[1024];
                dpReceive = new DatagramPacket(buf, buf.length);
                try {
                    if (receiveSocket == null) {
                        receiveSocket = new DatagramSocket(BROADCAST_PORT);
                    }
                    receiveSocket.receive(dpReceive);
                    receiveContent = new String(buf, 0, dpReceive.getLength());
                    receiveIp = dpReceive.getAddress().toString().substring(1);
                    if (receiveIp != IP) {
                        sendIp = receiveIp;
                    }
                    if (reviceCallBack != null && reviceBean.getFlag().equals("server")) {
                        reviceCallBack.reviceData(receiveContent);
                    }
                    previousContent = receiveContent;

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

private class SendThread extends Thread {

    @SuppressLint("HandlerLeak")
    @Override
    public void run() {
        while (true) {
            try {
                Log.i(TAG, "handleMessage: is run.");
                DatagramPacket dpSend = null;
                sendData = "感谢点赞!";
                byte[] sendMsg = sendData.getBytes();
                if (receiveIp != IP) {
                    InetAddress inetAddress = InetAddress.getByName(sendIp);
                    dpSend = new DatagramPacket(ip, ip.length, inetAddress, BROADCAST_PORT);
                }
                String sendData = new String(sendMsg, 0, dpSend.getLength());
                sendSocket = new DatagramSocket();
                sendSocket.send(dpSend);
                Log.i(TAG, "run: Client: send message : " + sendData);
                sendSocket.close();
                Thread.sleep(80);
            } catch (IOException | InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

private String getIpString(int i) {
    return (i & 0xFF) + "." + ((i >> 8) & 0xFF) + "."
            + ((i >> 16) & 0xFF) + "." + (i >> 24 & 0xFF);
}

public void setReviceCallBack(ReviceCallBack reviceCallBack) {
    this.reviceCallBack = reviceCallBack;
}

public interface ReviceCallBack {
    void reviceData(String data);
}

}

说明已经很详细了, 你们自己调用就可以啦~~~~~~~~~~~~~~~~~~~~~~~~