面向UDP的Android——PC双向通信（一）：实现Android客户端和PC服务器端的单向通信

导语

最近刚刚接触Android开发，也开始学习网络通信，于是选择做一个Android和PC之间双向通信的小项目。本篇我们先来实现最简单的单向通信。

UDP协议包

UDP 是User Datagram Protocol的简称， 中文名是用户数据报协议，在网络中它与TCP协议一样用于处理数据包，是一种无连接的协议。

UDP协议的主要作用是将网络数据流量压缩成数据包的形式。Java中用DatagramPacket类和DatagramSocket类来实现UDP通信，这两个类位于java.net包下。

DatagramPacket类

此类表示数据报包。

数据报包用来实现无连接包投递服务。每条报文仅根据该包中包含的信息从一台机器路由到另一台机器。从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序到达。不对包投递做出保证。

下表为DatagramPacket的构造方法：

构造方法	摘要
DatagramPacket(byte[] buf, int length)	构造数据报包，用来接收长度为 length 的数据包。
DatagramPacket(byte[] buf, int length, InetAddress address, int port)	构造数据报包，用来将长度为length的包发送到指定主机上的指定端口号
DatagramPacket(byte[] buf, int offset, int length)	构造数据报包，用来接收长度为 length 的数据包，在缓冲区中指定了偏移量。
DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)	构造数据报包，用来将长度为length偏移量为offset的包发送到指定主机上的指定端口号。
DatagramPacket(byte[] buf, int offset, int length, SocketAddress address)	构造数据报包，用来将长度为length偏移量为offset的包发送到指定主机上的指定端口号。
DatagramPacket(byte[] buf, int length, SocketAddress address)	构造数据报包，用来将长度为length的包发送到指定主机上的指定端口号。

下表为DatagramPacket的常用方法：

	方法	摘要
InetAddress	getAddress()	返回某台机器的 IP 地址，此数据报将要发往该机器或者是从该机器接收到的。
byte[]	getData()	返回数据缓冲区
int	getLength()	返回将要发送或接收到的数据的长度。
int	getOffset()	返回将要发送或接收到的数据的偏移量。
int	getPort()	返回某台远程主机的端口号，此数据报将要发往该主机或者是从该主机接收到的。
SocketAddress	getSocketAddress()	获取要将此包发送到的或发出此数据报的远程主机的 SocketAddress（通常为 IP 地址 + 端口号）。
void	setAddress(InetAddress iaddr)	设置要将此数据报发往的那台机器的IP地址。
void	setData(byte[] buf)	为此包设置数据缓冲区。
void	setData(byte[] buf, int offset, int length)	为此包设置数据缓冲区。
void	setLength(int length)	为此包设置长度。
void	setPort(int iport)	设置要将此数据报发往的远程主机上的端口号。
void	setSocketAddress(SocketAddress address)	设置要将此数据报发往的远程主机的SocketAddress（通常为 IP 地址 + 端口号）。

DatagramSocket类

此类表示用来发送和接收数据报包的套接字。

数据报套接字是包投递服务的发送或接收点。每个在数据报套接字上发送或接收的包都是单独编址和路由的。从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序到达。

在 DatagramSocket 上总是启用 UDP 广播发送。为了接收广播包，应该将 DatagramSocket 绑定到通配符地址。在某些实现中，将 DatagramSocket 绑定到一个更加具体的地址时广播包也可以被接收。

示例：

DatagramSocket s = new DatagramSocket(null); 
s.bind(new InetSocketAddress(8888)); 

这等价于：

DatagramSocket s = new DatagramSocket(8888); 

两个例子都能创建能够在 UDP 8888 端口上接收广播的 DatagramSocket。

下表为DatagramSocket的构造方法：

构造方法	摘要
DatagramSocket()	构造数据报包套接字并将其绑定到本地主机上任何可用的端口。
DatagramSocket(int port)	创建数据报包套接字并将其绑定到本地主机上的指定端口。
DatagramSocket(int port, InetAddress addr)	创建数据报包套接字，将其绑定到指定的本地地址。
DatagramSocket(SocketAddress bindaddr)	创建数据报包套接字，将其绑定到指定的本地套接字地址。

下表为DatagramSocket的常用方法：

	方法	摘要
void	bind(SocketAddress addr)	将此 DatagramSocket 绑定到特定的地址和端口。
void	close()	关闭此数据报包套接字。
void	connect(InetAddress address,int port)	将套接字连接到此套接字的远程地址。
void	connect(SocketAddress addr)	将此套接子连接到远程套接子地址（IP地址+端口号）。
void	disconnect(）	断开套接字的连接。
InetAddress	getInetAddress()	返回此套接字连接的地址。
InetAddress	getLocalAddress()	获取套接字绑定的本地地址。
int	getLocalPort()	返回此套接字绑定的本地主机上的端口号。
int	getPort()	返回此套接字的端口。

Android客户端

我们选择用Android开发客户端，先实现最简单的发送消息的功能：

1. 获取要发送的消息

UDP传输的是byte数组，所以要根据协议将要传输的数据都转换为byte数组传输：

byte[] data = str.getBytes();
//如果要支持汉字，要选定编码方式
byte[] data = str.getBytes("GBK");

2. 创建socket对象

创建数据报包套接字，并将其绑定到本地主机上的指定端口9999。

//参数9999是指定本地端口号
//即本地使用9999端口向客户端发送消息
DatagramSocket socket = new DatagramSocket(9999);
//如果想要将其绑定到随机一个未被占用的端口，可以直接使用参数0。
DatagramSocket socket = new DatagramSocket(0);

3. 创建数据报包

先获取远程主机的IP对象

InetAddress ServerAddress = InetAddress.getByName("192.168.31.233");

然后创建发送给该IP对象指定端口的数据报包，这里是发送给IP地址为192.168.31.233，端口为9999的套接字。

DatagramPacket request =new DatagramPacket(data,data.length,ServerAddress,9999);

4. 发送数据

socket.send(request);	//发送数据报包request

Java服务器端

1. 创建socket对象

指定一个本地端口号来接收消息，这里用了9999端口。

try{
       DatagramSocket socket = new DatagramSocket(9999);
       //参数9999是指定本地端口号
       //即本地使用9999端口接收来自客户端的消息
}catch(Exception e){
       e.printStackTrace();
}

2. 创建数据报包

先开辟一块空间，用来存储接收到的byte数组
再创建数据报包，用来接收数据。

//创建大小为1000的byte数组用来储存接收到的消息
byte data[] = new byte[1000];
DatagramPacket request = new DatagramPacket(data,data.length);

3. 接收处理消息

接收数据报包，然后根据协议将byte数组转换为原数据。

socket.receive(request);
String s = new String(data);
//如果要支持汉字，要选定编码方式
String s = new String(data,"GBK");

示例代码

客户端代码

package com.myscelyn.udpclient;

import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class MainActivity extends AppCompatActivity {

    public DatagramSocket socket;
    public EditText TextSend;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Button BtnSend = this.findViewById(R.id.BtnSend);
        TextSend = this.findViewById(R.id.TextSend);
        try{
            socket = new DatagramSocket(9999);
        }catch(Exception e){
            e.printStackTrace();
        }

        BtnSend.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                final String msg = TextSend.getText().toString();
                new Thread(){
                    public void run(){
                        sendMsg(msg);
                    }
                }.start();
            }
        });
    }

    public void sendMsg(String msg){
        Log.v("Client send:",msg);
        Toast.makeText(MainActivity.this,msg,Toast.LENGTH_LONG);
        try{
            byte data[] = msg.getBytes("GBK");
            InetAddress ServerAddress = InetAddress.getByName("192.168.31.233");
            DatagramPacket request =
                    new DatagramPacket(data,data.length,ServerAddress,9999);
            socket.send(request);
        }
        catch(Exception e){
            e.printStackTrace();
        }

    }

}

服务器端代码

import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextArea;

public class UDPServer {
	public JFrame frame;
	public JLabel IPShow;
	public JLabel PortShow;
	public JTextArea MsgReceive;
	
	public InetAddress ClientAddress;
	public String AddressStr;
	public int ClientPort;
	
	public DatagramSocket socket;
	
	public static void main(String[] args) throws Exception{
		UDPServer server = new UDPServer();
		server.showUI();
		server.receiveMsg();			
	}
	
	public void showUI(){
		frame = new JFrame("UDP Server");
		frame.setSize(800, 400);
		frame.setLocationRelativeTo(null);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setLayout(new FlowLayout());
		JLabel IPLabel = new JLabel("    源IP：");
		IPLabel.setPreferredSize(new Dimension(80,30));
		IPShow = new JLabel("__________________");
		IPShow.setPreferredSize(new Dimension(300,30));
		JLabel PortLabel = new JLabel("端口：");
		PortLabel.setPreferredSize(new Dimension(80,30));
		PortShow = new JLabel("__________________");
		PortShow.setPreferredSize(new Dimension(300,30));
		JLabel RecvLabel = new JLabel("接收到消息：");
		RecvLabel.setPreferredSize(new Dimension(700,30));
		MsgReceive = new JTextArea();
		MsgReceive.setPreferredSize(new Dimension(750,200));
		
		frame.add(IPLabel);		//源IP
		frame.add(IPShow);		
		frame.add(PortLabel);	//端口
		frame.add(PortShow);	
		frame.add(RecvLabel);	//接收到消息：
		frame.add(MsgReceive);
		
		frame.setVisible(true);
		
	}
	
	/**
	 * 接收消息
	 * @throws Exception
	 */
	public void receiveMsg() throws Exception{
		System.out.println("UDPServer start...");
		socket = new DatagramSocket(9999);
				
		
		new Thread(){
			public void run(){
				while(true){
					byte[] data = new byte[100];
					DatagramPacket request = new DatagramPacket(data, 100);
					System.out.println("准备接收消息");
					try {
						socket.receive(request);
						System.out.println("消息接收完毕");

						ClientAddress=request.getAddress();						
						IPShow.setText(ClientAddress.toString());
						System.out.println("客户机IP地址："+IPShow.getText());
						
						ClientPort=request.getPort();
						PortShow.setText(""+ClientPort);
						System.out.println("客户机端口："+PortShow.getText());
						
						String s = new String(data,"GBK");
						System.out.println("收到新消息："+s+"\n"+s.length());
						MsgReceive.setText(s);
						
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			}
			
		}.start();
			
	}

}