Android编程：UDP客户端和TCP客户端

Android编程：UDP客户端和TCP客户端

本文博客链接:http://blog.csdn.net/jdh99,作者:jdh,转载请注明.

环境：

主机:WIN10

开发环境:Android Studio 2.2 Preview 3

说明：

1.服务器的IP和端口固定，分别编写UDP和TCP客户端。

2.Android中主线程不允许网络操作，所以用线程实现UDP和TCP的收发。

3.用JAVA内置的观察者模式处理接收数据，如果接收到数据，则通知观察者。

4.Socket_Audio.java为UDP客户端

5.Socket_Cmd.java为TCP客户端

源码：

Socket_Audio.java

package com.bazhangkeji.demo01;

/**
 * @file Socket_Audio.java
 * @brief 语音端口类
 * @author jdh
 * @date 2016/7/9
 * @update 2016/7/10
 */

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.UnknownHostException;
import java.util.Observable;

public class Socket_Audio extends Observable implements Runnable {

    //常量
    //服务器IP
    private final String SERVER_IP = "115.28.86.171";
    //语音端口
    private final int SERVER_PORT_AUDIO = 12801;
    //本地端口
    private final int LOCAL_PORT_AUDIO = 12801;

    //网络相关变量
    //最大帧长
    private static final int MAX_DATA_PACKET_LENGTH = 1024;
    //接收数据缓存
    private byte[] Buffer_Receive = new byte[MAX_DATA_PACKET_LENGTH];

//    private StringBuilder Frame_Receive = new StringBuilder(MAX_DATA_PACKET_LENGTH);

    //接收数据包
    private DatagramPacket Packet_Receive;
    //端口
    private DatagramSocket Udp_Socket;

    /**
     * @brief 构造函数
     */
    public Socket_Audio()
    {
        try
        {
            //端口
            Udp_Socket = new DatagramSocket(LOCAL_PORT_AUDIO);
            //接收包
            Packet_Receive = new DatagramPacket(Buffer_Receive, MAX_DATA_PACKET_LENGTH);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    /**
     * @brief 发送数据
     * @param data:需要发送的数据
     * @param len:数据字节数据
     */
    public void send(byte[] data, int len)
    {
        Thread_Send thread_send = new Thread_Send(data, len);
        new Thread(thread_send).start();
    }

    @Override
    public void run() {
        while (true)
        {
            try
            {
                //接收数据
                Udp_Socket.receive(Packet_Receive);
//                //打印接收数据
//                System.out.println(new String(Buffer_Receive,0,Packet_Receive.getLength()));

                //判断数据是否合法
                InetSocketAddress address = (InetSocketAddress) Packet_Receive.getSocketAddress();
                //判断是否是调度服务器的ip
                if (!address.getHostName().equals(SERVER_IP))
                {
                    continue;
                }
                //判断是否是调度服务器的端口
				if (address.getPort() != SERVER_PORT_AUDIO)
                {
                    continue;
                }

                //通知观察者
                setChanged();
                notifyObservers(Packet_Receive);
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }

    /**
     * @brief 发送线程
     */
    private class Thread_Send implements Runnable {
        //发送数据缓存
        private byte[] Buffer_Send = new byte[MAX_DATA_PACKET_LENGTH];
        //发送数据包
        private DatagramPacket Packet_Send;

        /**
         * @brief 构造函数
         * @param data:需要发送的数据
         * @param len:数据字节数据
         */
        public Thread_Send(byte[] data, int len) {
            //发送包
            Packet_Send = new DatagramPacket(Buffer_Send, MAX_DATA_PACKET_LENGTH);
            Packet_Send.setData(data);
            Packet_Send.setLength(len);
        }

        @Override
        public void run() {
            try {
                Packet_Send.setPort(SERVER_PORT_AUDIO);
                Packet_Send.setAddress(InetAddress.getByName(SERVER_IP));
                Udp_Socket.send(Packet_Send);
            } catch (UnknownHostException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Socket_Cmd.java

package com.bazhangkeji.demo01;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.DatagramPacket;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.util.Observable;
import java.util.Observer;

/**
 * @file Socket_Cmd.java
 * @brief 信令端口类
 * @author jdh
 * @date 2016/7/9
 * @update 2016/7/10
 */

public class Socket_Cmd extends Observable implements Runnable {

    //常量
    //服务器IP
    private final String SERVER_IP = "115.28.86.171";
    //语音端口
    private final int SERVER_PORT_CMD = 12800;
    //本地端口
    private final int LOCAL_PORT_CMD = 12800;

    //网络相关变量
    //最大帧长
    private static final int MAX_DATA_PACKET_LENGTH = 1024;

    //端口
    Socket Tcp_Socket;
    //输入流
    InputStream Buffer_Receive_Stream;
    //网络连接标志
    private boolean Flag_Connect = false;
    //接收数据缓存
    private byte[] Buffer_Receive = new byte[MAX_DATA_PACKET_LENGTH];
    //接收数据包
    private DatagramPacket Packet_Receive;

    /**
     * @brief 构造函数
     */
    public Socket_Cmd() {
        //接收包
        Packet_Receive = new DatagramPacket(Buffer_Receive, MAX_DATA_PACKET_LENGTH);
    }

    /**
     * @brief 发送数据
     * @param data:需要发送的数据
     * @param len:数据字节数据
     */
    public synchronized void send(final byte[] data, final int len) {
        //判断是否连接服务器
        if (!Flag_Connect) {
            return;
        }

        //发送
        Thread_Send thread_send = new Thread_Send(data, len);
        new Thread(thread_send).start();
    }

    @Override
    public void run() {
        //连接服务器
        //端口
        try {
            Tcp_Socket = new Socket(SERVER_IP, SERVER_PORT_CMD);
            Buffer_Receive_Stream = Tcp_Socket.getInputStream();
        } catch (IOException e) {
            e.printStackTrace();
        }

        //开启监听线程
        try
        {
            new Thread(new Runnable(){
                @Override
                public void run() {
                    while (true) {
                        //判断当前是否连接
                        if (!Flag_Connect)
                        {
                            continue;
                        }

                        //监听
                        try {
                            if (Buffer_Receive_Stream.available() > 0)
                            {
                                Packet_Receive.setLength(Buffer_Receive_Stream.read(Packet_Receive.getData()));
//                                System.out.println(new String(Packet_Receive.getData(),0,Packet_Receive.getLength()));
                                //通知观察者
                                setChanged();
                                notifyObservers(Packet_Receive);
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }).start();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }

        //检测连接状态
        while (true) {
            Flag_Connect = Tcp_Socket.isConnected();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
//            System.out.println("连接状态:" + Flag_Connect);
            if (!Flag_Connect) {
                SocketAddress address = new InetSocketAddress(SERVER_IP, SERVER_PORT_CMD);
                try {
                    Tcp_Socket.connect(address);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * @brief 发送线程
     */
    private class Thread_Send implements Runnable {
        //输出流
        OutputStream Buffer_Send;
        //发送数据缓存
        private byte[] Buf_Send = new byte[MAX_DATA_PACKET_LENGTH];
        private int Len = 0;

        /**
         * @brief 构造函数
         * @param data:需要发送的数据
         * @param len:数据字节数据
         */
        public Thread_Send(byte[] data, int len) {
            Len = len;
            for (int i = 0;i < Len;i++) {
                Buf_Send[i] = data[i];
            }

            //输出流
            try {
                Buffer_Send = Tcp_Socket.getOutputStream();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void run() {
            try {
                Buffer_Send.write(Buf_Send,0,Len);
                Buffer_Send.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

发送示例代码：

Socket_Audio socket_audio = new Socket_Audio();
        new Thread(socket_audio).start();
//        String buf = "hello,i am jdh1";
//        socket_audio.send(buf.getBytes(),buf.length());
        for (int i = 0;i < 20;i++)
        {
            String buf1 = "UDP:I AM JDH" + i;
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            socket_audio.send(buf1.getBytes(),buf1.length());
        }

        Socket_Cmd socket_cmd = new Socket_Cmd();
        new Thread(socket_cmd).start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0;i < 20;i++)
        {
            String buf1 = "TCP:I AM JDH" + i;
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            socket_cmd.send(buf1.getBytes(),buf1.length());
        }