UDP实现客户端（Android）和服务器之间通信

原博客地址：https://blog.csdn.net/mayifan_blog/article/details/86646396

UDP通信原理

UDP一般和TCP进行比较，TCP是一种可靠的面向连接的通信协议，在发送数据前会通过三次握手建立可靠的连接，在发送数据报的过程中有数据报的重传机制，在结束连接的时候有四次挥手来保证所有的数据可以顺利地发出，然后安全地断开服务器和客户端的连接。而UDP不能保证这些，UDP只需要知道目的地的IP地址和端口号，然后把数据报送到指定的地址，而不关心数据报是否被收到，因此,UDP通信是一种无连接的不可靠的通信，丢包现象很严重，但它也有优点，那就是它效率比较高，只要人为地编写一些协议来约束，就可以实现可靠的通信，因此UDP在通信领域也被广泛地应用。

UDP通信要点

UDP通信的几个环节：
发送：
1、客户端发送端口号：需要指定某个端口作为发送数据包的端口，在实际应用中这个参数可以缺省，系统会自动为你分配一个空闲的端口号供数据的发送。
2、数据包：知道从哪里出发自然需要有要传输的内容，把数据按照一定的规则打包，包的入口参数需要包括数据生成的字节数组，字节数组长度，目标ip地址以及目标端口号。
3、服务器接收端口号：这个参数在数据包中已经包含，目标端口号需要提前告知客户端，并且在目标端口号出需要有通道等待接收，才能正确地收到数据包。
接收：
1、服务器发送端口号：服务器通过包裹的信息得到了包裹的来源就可以反过来向客户端发送数据包了，原理和发送是一样的，所以我们一般在服务器上指定一个端口来进行发送。
2、数据包：打包数据，只是地址变成了客户端的某个端口号了。
3、客户端的接收端口号：客户端也在某个端口开启通道等待数据包的到来，这样就实现了一次服务器和客户端的交互。
图示：

线程：
在Android开发中，发送和接收的代码都必须开启线程并在线程中执行，如果不开线程就会导致发送与接收的失败。原因其实也比较容易理解，如果在主线程中持续等待UDP包裹的到来，势必导致资源的浪费，这种阻塞的操作规定需要在线程中完成。线程的设计一般可以分为发送与接收这两个部分。
绑定失败：
如果重复申请在一个端口创建socket通道，这必然导致程序异常，新的通道创建失败，程序结束。另外，在Android开发中还有一些细节需要注意，重复打开多个app，它们如果要使用的是相同的端口，这会导致程序的结束；在修改代码后，一定要删除原app，再安装新的app，这也可以避免绑定失败的问题（确保之前的端口被释放）。
权限：
Internet权限必须要开，否则通道怎么也建立不起来。打开它的方法在AndroidManifest.xml文件的Permittion中add，android.permission.INTERNET。
客户端先发送包：
客户端需要先发一个包给服务器，服务器才能得到客户端的ip和端口号，才能给客户端应答。服务器刚开始是不知道客户端的地址的。
流程摘要：
客户端：
1、指定发送端口号生成通道：
DatagramSocket datagramSocket=new DatagramSocket(localSendPort);
2、通过目标String类型的ip生成地址类型的ip：
InetAddress destInetAddress=InetAddress.getByName(ip);
3、把数据生成字节数组：
byte[] buffer=str.getBytes();
3、根据字节数组，字节数组长度，目标ip地址，目标端口号生成数据包：
DatagramPacket datagramPacket=new DatagramPacket(buffer,buffer.length,destInetAddress,port);
4、通过通道发送数据包：
datagramSocket.send(datagramPacket);
服务器：
1、根据接收端口号生成通道：
DatagramSocket datagramSocket2=new DatagramSocket(localPort);
2、定义空字节数组：
byte[] buffer=new byte[50];
3、生成空数据包：
datagramPacket2=new DatagramPacket(buffer, buffer.length);
4、等待接收：
datagramSocket2.receive(datagramPacket2);

UDP通信客户端（Android）代码：

1、MainActivity：

public class MainActivity extends Activity {
	private DatagramSocket datagramSocket;//发送通道（缺省）
	private DatagramSocket datagramSocket2;//此通道确定本机接收地址			
	private String destIp;//目标ip
	private int destPort;//目标接收端端口号
	private String localIp;//本地ip	
	private int localSendPort;//本地发送端口号
	private int localReceivePort;//本地接收端口号	
	private SendMethod sendMethod;//发送类
	private GetMethod getMethod;//接收类                
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);//调用父类构造方法
        setContentView(R.layout.activity_main);//设置当前布局        
        init();//初始化       
    	new Thread(){
	    	public void run(){
	    		try {
    			        sendMethod.sendMessage("111", "192.168.1.100", 9999);
    			        getMethod.getMessage();    			        
				} catch (Exception e) {
					e.printStackTrace();
				}
    		}
    	}.start();    	
    }
    /**
     * 参数配置（工厂）
     */
    public void init(){
    	destIp="192.168.1.100";//目标ip
    	destPort=9999;//目标接收端端口号
    	localIp="";//本地ip，未知
    	localSendPort=8888;//本地发送端端口号    	
    	localReceivePort=7777;//本地接收端端口号   	 	
    	try { 	    
    		datagramSocket=new DatagramSocket(localSendPort);//发送的数据通道
			datagramSocket2=new DatagramSocket(localReceivePort);//接收的数据通道	
			Log.v("MainActivity", "初始化成功");
		} catch (Exception e) {
			Log.v("MainActivity", "初始化错误");
			e.printStackTrace();
		}    	
    	sendMethod=new SendMethod(datagramSocket);//实例化发送方法的引用
    	getMethod=new GetMethod(datagramSocket2);//实例化接收方法的引用 
    }          
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }    
}

 
 

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

2、发送类及发送的方法：

public class SendMethod {
	private DatagramPacket datagramPacket;//发送数据报
    private InetAddress destInetAddress;//目标地址,ip需要包装为它才能传入包
    private DatagramSocket datagramSocket;//发送通道   
	public SendMethod(DatagramSocket datagramSocket){
		this.datagramSocket=datagramSocket;
	}		
    /**
     * 发信息的方法
     */
    public void sendMessage(String str,String ip,int port)throws Exception{ 
    	 Log.v("MainActivity", str);
         Log.v("MainActivity", ip);
         Log.v("MainActivity", String.valueOf(port));         
         str+='#'+"7777"+"#";         
         destInetAddress=InetAddress.getByName(ip);//把ip包装为地址
         byte[] buffer=str.getBytes();
         try {       	 
			datagramPacket=new DatagramPacket(buffer,buffer.length,destInetAddress,port);//创建数据报
        	datagramSocket.send(datagramPacket); //发送数据报        	 			
			Log.v("MainActivity", "成功发送的消息："+str);	
		} catch (Exception e) {	
			Log.v("MainActivity", "error");
			e.printStackTrace();
		}        
    }		
}

 
 

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

3、接收类及接收的方法：

public class GetMethod {
	private DatagramPacket datagramPacket;//用来接收的数据报
	private DatagramSocket datagramSocket;//接收的通道	
	/**
	 * 构造方法
	 * @param datagramSocket
	 */
	public GetMethod(DatagramSocket datagramSocket){
		this.datagramSocket=datagramSocket;
	}			
	/**
	 * 获取消息的方法
	 * @return
	 */
	public String getMessage(){
		String str=null;
		try{		
		byte[] buffer=new byte[50];//初始化字节
		datagramPacket=new DatagramPacket(buffer,50);//创建一个空的包准备接收
		Log.v("MainActivity","等待接收数据报");
		datagramSocket.receive(datagramPacket);//等待接收数据报
		str=new String(buffer).trim();//trim可以去掉多余的空格
		Log.v("MainActivity", "收到了字符串："+str);
		return str;
		}catch(Exception e){
			e.printStackTrace();
			Log.v("MainActivity", "接收错误");
			return "error";
		}
	}  	
}

 
 

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

服务器测试代码（Java实现）

public class UDPTest {
    InetAddress destAddress;//目标ip地址，String的ip需要包装为它
    DatagramPacket datagramPacket;//用于发送的包（有数据）
    DatagramSocket datagramSocket;//用于发送的通道（缺省）
    DatagramPacket datagramPacket2;//用于接收的空包
    DatagramSocket datagramSocket2; //用于接收的通道（具体地址被指定）
	String destIp;//目标ip
	int destPort;//目标接收端端口号
	String localIp;//本地ip
	int localPort;//本地接收端端口号
	public static void main(String[] args){				
		UDPTest udp=new UDPTest();
		udp.test(udp);		
	}	
	/**
	 * 测试方法入口
	 */
	public void test(UDPTest udp){								
		ipPortConfig();//配置地址参数
		new MessageGetThread(udp).start();//开启接收线程		
	}	
	/**
	 * 获取包的来源IP
	 * @return
	 */
	public String getIP(){
		return datagramPacket2.getAddress().getHostAddress();
	}	
	public void setIP(String str){
		this.destIp=str;
	}		
	/**
	 * 获取包的来源端口号
	 * @return
	 */
	public int getLastPort(String str){
		String s="";
		boolean portFlag=false;
		for(int i=0;i<str.length();i++){
			if(str.charAt(i)=='#'&&portFlag==false){
				portFlag=true;
			}else if(str.charAt(i)!='#'&&portFlag==true){
				s+=str.charAt(i);
			}else if(str.charAt(i)=='#'&&portFlag==true){
				portFlag=true;
			}
		}
		return Integer.parseInt(s);
	}
    /**
     * 设置目标端口号 
     * @param port
     */
	public void setPort(int port){
		this.destPort=port;
	}	
	/**
	 * 获取目标端口号
	 * @return
	 */
	public int getPort(){
		return this.destPort;
	}				
	/**
	 * 获取消息去掉端口号后的内容
	 * @param str
	 */
	public String getContent(String str){
		String s="";
		for(int i=0;i<str.length();i++){
			if(str.charAt(i)!='#'){
				s+=str.charAt(i);
			}else if(str.charAt(i)=='#'){
				break;
			}
		}
		return s;
	}	
	/**
	 * 初始化配置方法
	 */
    public void ipPortConfig(){
    	localIp="192.168.1.100";//本地ip
    	localPort=9999;//本地接收端端口号
    	try {
			datagramSocket2=new DatagramSocket(localPort);//初始化本机接收通道，指定端口号		
		} catch (SocketException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }	
	/**
	 * 获取消息的方法
	 * @return
	 */
	public String getMessage(){
		String str=null;
		try{
		byte[] buffer=new byte[50];//初始化字节
		datagramPacket2=new DatagramPacket(buffer, buffer.length);//创建一个空的包准备接收
		System.out.println("等待接收数据报");
		datagramSocket2.receive(datagramPacket2);//等待接收数据报
		str=new String(buffer).trim();//trim可以去掉多余的空格
		return str;
		}catch(Exception e){
			e.printStackTrace();
			return "error";
		}
	}	
	/**
     * 发信息的方法
     */
    public void sendMessage(String str,String ip,int port){       
         System.out.println("发给ip:"+ip);
         System.out.println("发给port:"+port);
         byte buffer[]=str.getBytes();
         try {
        	destAddress=InetAddress.getByName(ip);//创建目标ip地址
			datagramSocket=new DatagramSocket(0);//创建数据通道
			datagramPacket=new DatagramPacket(buffer,buffer.length,destAddress,port);//创建数据报
			datagramSocket.send(datagramPacket);//发送数据报
			System.out.println("成功发送的消息："+str);			
		} catch (Exception e) {	
			System.out.println("error");
			e.printStackTrace();
		}                  
    }
}
class MessageGetThread extends Thread{
	UDPTest udp;
	public MessageGetThread(UDPTest udp){
		this.udp=udp;
	}	
	public void run(){
		while(true){
			String str=udp.getMessage();//接收消息的阻塞方法
			String ip=udp.getIP();//获取到字符串ip			
			System.out.println("消息来自ip："+ip);
			int port=udp.getLastPort(str);//获取端口号
			System.out.println("消息来自port："+port);
			String content=udp.getContent(str);//获取消息的内容
			System.out.println("消息的内容是："+content);
			udp.setIP(ip);//更新ip
			udp.setPort(port);//更新port
			udp.sendMessage("222",ip, port);//发出消息			
		}
	}
}

 
 

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

测试结果

客户端（Android）：

服务器（Java）：

客户端向服务器发送字符串“111”，服务器收到之后解析获得其ip，并从包中的信息读到了客户端的接收端口号，服务器向客户端发一个“222”表示回应，最后客户端收到了这段字符串。