Android实现socket简单通讯总结

参考自：http://www.itlanbao.com/ns/news.aspx?s=600032

基于UDP协议的数据传输 
服务器端首先创建一个DatagramSocket对象，并且指点监听的端 口。接下来创建一个空的DatagramSocket对象用于接收数据 （bytedata[]=newbyte[1024;]DatagramSocketpacket=newDatagramSocket（data，data.length））, 

使用DatagramSocket的receive方法接收客户端发送的数据，receive（）与serversocket的accepet（）类似， 在没有数据进行接收的处于堵塞状态。
客户端也创建个DatagramSocket对象，并且指点监听的端口。接 下来创建一个InetAddress对象，这个对象类似与一个网络的发送地址 

（InetAddressserveraddress=InetAddress.getByName（"172.168.1.120"））

.定义要发送的 一个字符串，创建一个DatagramPacket对象，并制定要讲这个数据报包发送到网络的那个地址以及端口号，

最后使用DatagramSocket 的对象的send（）发送数据。

*（Stringstr="hello";bytedata[]=str.getByte(); DatagramPacketpacket=new DatagramPacket(data,data.length,serveraddress,4567);socket.send(packet);）

四、android 实现socket简单通信

4.1使用TCP协议通信

android端实现：

[java] view plaincopy 

1.     protected void connectServerWithTCPSocket() {  
2.   
3.         Socket socket;  
4.         try {// 创建一个Socket对象，并指定服务端的IP及端口号  
5.             socket = new Socket("192.168.1.32", 1989);  
6.             // 创建一个InputStream用户读取要发送的文件。  
7.             InputStream inputStream = new FileInputStream("e://a.txt");  
8.             // 获取Socket的OutputStream对象用于发送数据。  
9.             OutputStream outputStream = socket.getOutputStream();  
10.             // 创建一个byte类型的buffer字节数组，用于存放读取的本地文件  
11.             byte buffer[] = new byte[4 * 1024];  
12.             int temp = 0;  
13.             // 循环读取文件  
14.             while ((temp = inputStream.read(buffer)) != -1) {  
15.                 // 把数据写入到OuputStream对象中  
16.                 outputStream.write(buffer, 0, temp);  
17.             }  
18.             // 发送读取的数据到服务端  
19.             outputStream.flush();  
20.   
21.             /** 或创建一个报文，使用BufferedWriter写入,看你的需求 **/  
22. //          String socketData = "[2143213;21343fjks;213]";  
23. //          BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(  
24. //                  socket.getOutputStream()));  
25. //          writer.write(socketData.replace("\n", " ") + "\n");  
26. //          writer.flush();  
27.             /************************************************/  
28.         } catch (UnknownHostException e) {  
29.             e.printStackTrace();  
30.         } catch (IOException e) {  
31.             e.printStackTrace();  
32.         }  
33.   
34.     }  

服务器端简单实现： 

[java] view plaincopy 

1. public void ServerReceviedByTcp() {  
2.     // 声明一个ServerSocket对象  
3.     ServerSocket serverSocket = null;  
4.     try {  
5.         // 创建一个ServerSocket对象，并让这个Socket在1989端口监听  
6.         serverSocket = new ServerSocket(1989);  
7.         // 调用ServerSocket的accept()方法，接受客户端所发送的请求，  
8.         // 如果客户端没有发送数据，那么该线程就停滞不继续  
9.         Socket socket = serverSocket.accept();  
10.         // 从Socket当中得到InputStream对象  
11.         InputStream inputStream = socket.getInputStream();  
12.         byte buffer[] = new byte[1024 * 4];  
13.         int temp = 0;  
14.         // 从InputStream当中读取客户端所发送的数据  
15.         while ((temp = inputStream.read(buffer)) != -1) {  
16.             System.out.println(new String(buffer, 0, temp));  
17.         }  
18.         serverSocket.close();  
19.     } catch (IOException e) {  
20.         e.printStackTrace();  
21.     }  
22. }  

4.2使用UDP协议通信 

客户端发送数据实现：

[java] view plaincopy 

1. protected void connectServerWithUDPSocket() {  
2.       
3.     DatagramSocket socket;  
4.     try {  
5.         //创建DatagramSocket对象并指定一个端口号，注意，如果客户端需要接收服务器的返回数据,  
6.         //还需要使用这个端口号来receive，所以一定要记住  
7.         socket = new DatagramSocket(1985);  
8.         //使用InetAddress(Inet4Address).getByName把IP地址转换为网络地址    
9.         InetAddress serverAddress = InetAddress.getByName("192.168.1.32");  
10.         //Inet4Address serverAddress = (Inet4Address) Inet4Address.getByName("192.168.1.32");    
11.         String str = "[2143213;21343fjks;213]";//设置要发送的报文    
12.         byte data[] = str.getBytes();//把字符串str字符串转换为字节数组    
13.         //创建一个DatagramPacket对象，用于发送数据。    
14.         //参数一：要发送的数据  参数二：数据的长度  参数三：服务端的网络地址  参数四：服务器端端口号   
15.         DatagramPacket packet = new DatagramPacket(data, data.length ,serverAddress ,10025);    
16.         socket.send(packet);//把数据发送到服务端。    
17.     } catch (SocketException e) {  
18.         e.printStackTrace();  
19.     } catch (UnknownHostException e) {  
20.         e.printStackTrace();  
21.     } catch (IOException e) {  
22.         e.printStackTrace();  
23.     }    
24. }  

客户端接收服务器返回的数据： 

[java] view plaincopy 

1. public void ReceiveServerSocketData() {  
2.     DatagramSocket socket;  
3.     try {  
4.         //实例化的端口号要和发送时的socket一致，否则收不到data  
5.         socket = new DatagramSocket(1985);  
6.         byte data[] = new byte[4 * 1024];  
7.         //参数一:要接受的data 参数二：data的长度  
8.         DatagramPacket packet = new DatagramPacket(data, data.length);  
9.         socket.receive(packet);  
10.         //把接收到的data转换为String字符串  
11.         String result = new String(packet.getData(), packet.getOffset(),  
12.                 packet.getLength());  
13.         socket.close();//不使用了记得要关闭  
14.         System.out.println("the number of reveived Socket is  :" + flag  
15.                 + "udpData:" + result);  
16.     } catch (SocketException e) {  
17.         e.printStackTrace();  
18.     } catch (IOException e) {  
19.         e.printStackTrace();  
20.     }  
21. }  

服务器接收客户端实现： 

[java] view plaincopy 

1. public void ServerReceviedByUdp(){  
2.     //创建一个DatagramSocket对象，并指定监听端口。（UDP使用DatagramSocket）    
3.     DatagramSocket socket;  
4.     try {  
5.         socket = new DatagramSocket(10025);  
6.         //创建一个byte类型的数组，用于存放接收到得数据    
7.         byte data[] = new byte[4*1024];    
8.         //创建一个DatagramPacket对象，并指定DatagramPacket对象的大小    
9.         DatagramPacket packet = new DatagramPacket(data,data.length);    
10.         //读取接收到得数据    
11.         socket.receive(packet);    
12.         //把客户端发送的数据转换为字符串。    
13.         //使用三个参数的String方法。参数一：数据包 参数二：起始位置 参数三：数据包长    
14.         String result = new String(packet.getData(),packet.getOffset() ,packet.getLength());    
15.     } catch (SocketException e) {  
16.         e.printStackTrace();  
17.     } catch (IOException e) {  
18.         e.printStackTrace();  
19.     }    
20. }