【Socket编程】经过Socket实现UDP编程

经过Socket实现UDP编程

UDP通讯：

一、UDP协议(用户数据报协议)是无链接、不可靠、无序的。

二、UDP协议以数据报做为数据传输的载体。

三、使用UDP进行数据传输时，首先须要将要传输的数据定义成数据报(Datagram),在数据报中指明所要达到的Socket(主机地址和端口号)，而后在将数据报发生出去。

四、相关操做类：

• DatagramPacket：表示数据报包
• DatagramSocket：进行端到端通讯的类

1、DatagramPacket&DatagramSocket类的经常使用方法

<DatagramPacket类>

构造方法：

1 DatagramPacket(byte[] buf,int length)//接受长度为length的数据包
3 DatagramPacket(byte[] buf,int length,InetAddress address,int port)//将指定长度的字节发生到指定主机的指定端口 

<DatagramSocket类>

构造方法：

1  DatagramSocket();
2  DatagramSocket(int port,InetAddress laddr);

经常使用方法：

1  close();//关闭DatagramSocket
2  getInetAddress();//获取地址
3  getPort();//获取端口号
4  send(DatagramPacket p);//今后套接字发送数据包
5  recrive(DatagramPacket p);//今后套接字接收数据包

2、编程实现基于UDP的用户登陆小程序

经过写一个用户登陆的小程序，来直观了解基于UDP的Socket通讯的工做过程，首先咱们得知道在客户端和服务器通讯时，二者的运做流程是如何的，先从服务器入手。

服务器端实现步骤：

一、建立DatagramSocket,指定端口号

二、建立DatagramPacket

三、接收客户端发送的数据信息

四、读取数据

那么用户登陆的测试案例的服务器端类能够这样（待完善）：

 1 public static void main(String[] args) throws IOException {
 2         // TODO Auto-generated method stub
 3         
 4         try {
 5             //1.建立服务器端DatagramSocket，指定端口
 6             DatagramSocket ds=new DatagramSocket(8080);
 7             //2.建立数据报DatagramPacket,用于接收客户端发送的数据
 8             byte[] data=new byte[1024];//建立字节数组，指定接受的数据报大小
 9             DatagramPacket dp=new DatagramPacket(data, data.length);
10             //3.接收客户端发送的数据
11             ds.receive(dp);//此方法在接收到数据报以前会一直阻塞
12             //4.读取数据
13             //String info=Arrays.toString(data);
14             String info=new String(data, 0, dp.getLength());
15             System.out.println("我是服务器，客户端说："+info);
16         } catch (SocketException e) {
17             // TODO Auto-generated catch block
18             e.printStackTrace();
19         }
20     }

接着咱们看一下客户端的运做过程，其实和服务器端差很少，可是其中的区别仍是要清楚的。

客户端实现步骤：

一、定义发送信息

二、建立DatagramPacket：包含将要发送信息

三、建立DatagramSocket

四、发送数据

那么用户登陆的测试案例的客户端类能够这样（待完善）：

 1 public static void main(String[] args) throws IOException {
 2         // TODO Auto-generated method stub
 3         //1.定义服务器的地址、端口号、数据
 4         InetAddress add=InetAddress.getByName("localhost");
 5         int port=8080;
 6         byte[] data="用户名：admin；密码：123".getBytes();
 7         //2.建立数据报,包含了发送的相关信息
 8         DatagramPacket ap=new DatagramPacket(data, data.length, add, port);
 9         //3.建立DatagramSocket对象
10         DatagramSocket ds=new DatagramSocket();
11         //4.向服务器端发送数据报
12         ds.send(ap);
13         
14     }

这样服务端和客户端就能进行最简单的通讯了，目前这个还不能实现交互，下面会讲二者的交互。

运行一下，看看服务器端是否能接收到客户端发送的信息了呢...

分别启动服务器和客户端，注意必须先启动服务器再启动客户端，不然客户端找不到资源报错：

---

完善用户登陆之服务器响应客户端

在上述的例子中，服务器和客户端仅仅只是相互能够通讯，但服务器对于接收到的客户端信息并无向客户端响应，客户端没有接收到服务器端的任何信息，这明显是不完善不友好的，在这里将对刚刚的例子进行完善，完成服务器对客户端的响应。

修改后的服务器端：

 1 public static void main(String[] args) throws IOException {
 2         // TODO Auto-generated method stub
 3         
 4         try {
 5             /*
 6              * 接收客户端发送的数据
 7              */
 8             //1.建立服务器端DatagramSocket，指定端口
 9             DatagramSocket ds=new DatagramSocket(8080);
10             //2.建立数据报DatagramPacket,用于接收客户端发送的数据
11             byte[] data=new byte[1024];//建立字节数组，指定接受的数据报大小
12             DatagramPacket dp=new DatagramPacket(data, data.length);
13             //3.接收客户端发送的数据
14             System.out.println("服务器端已启动，等待客户端发送数据...");
15             ds.receive(dp);//此方法在接收到数据报以前会一直阻塞
16             //4.读取数据
17             //String info=Arrays.toString(data);
18             String info=new String(data, 0, dp.getLength());
19             System.out.println("我是服务器，客户端说："+info);
20             /*
21              * 响应客户端
22              */
23             //1.定义客户端的地址、端口号、数据
24             InetAddress add=dp.getAddress();
25             int port=dp.getPort();
26             byte[] data2="欢迎您！".getBytes();
27             //2.建立数据报，包含响应的数据信息
28             DatagramPacket dp2=new DatagramPacket(data2, data2.length, add, port);
29             //3.响应客户端
30             ds.send(dp2);
31             //4.关闭资源
32             ds.close();
33             
34             
35         } catch (SocketException e) {
36             // TODO Auto-generated catch block
37             e.printStackTrace();
38         }
39     }

修改后的客户端：

 1 public static void main(String[] args) throws IOException {
 2         // TODO Auto-generated method stub
 3         /*
 4          * 向服务器发送数据
 5          */
 6         //1.定义服务器的地址、端口号、数据
 7         InetAddress add=InetAddress.getByName("localhost");
 8         int port=8080;
 9         byte[] data="用户名：admin；密码：123".getBytes();
10         //2.建立数据报,包含了发送的相关信息
11         DatagramPacket ap=new DatagramPacket(data, data.length, add, port);
12         //3.建立DatagramSocket对象
13         DatagramSocket ds=new DatagramSocket();
14         //4.向服务器端发送数据报
15         ds.send(ap);
16         /*
17          * 接收服务器端的响应
18          */
19         //1.建立数据报DatagramPacket,用于接收服务器发送的数据
20         byte[] data2=new byte[1024];
21         DatagramPacket dp2= new DatagramPacket(data2, data2.length);
22         //2.接收响应
23         ds.receive(dp2);
24         //3.读取数据
25         String info=new String(data2, 0, dp2.getLength());
26         System.out.println("我是客户端，服务器说："+info);
27         //4.关闭资源
28         ds.close();
29     }

运行结果：

3、使用多线程实现多客户端的通讯

 应用多线程来实现服务器与多客户端之间的通讯。<关于多线程更多的内容之后再总结>

多线程基本步骤：

1.服务器端建立DatagramSocket，循环调用receive()等待客户端发送数据报。

2.客户端建立一个DatagramSocket发送数据报到服务器端。

3.服务器端接收客户端的数据报，建立DatagramPacket与该客户创建专线接收数据报。

4.创建交互数据报在一个单独的线程上对话。

5.服务器端继续等待新的数据报。

 ------------------------------------------------------------------------------

下面再将上述的例子修改为多线程的通讯

新建一个服务器线程处理类UDPServerThread，该类继承Thread类：

 

 1 /*
 2  * 服务器线程处理类
 3  */
 4 public class UDPServerThread extends Thread {
 5     DatagramSocket ds=null;
 6     DatagramPacket dp=null;
 7     public UDPServerThread(DatagramSocket ds,DatagramPacket dp){
 8         this.ds=ds;
 9         this.dp=dp;
10     }
11     
12     
13     public void run(){
14         
15     
16         try {
17             /*
18              * 接收客户端发送的数据
19              */
20             
21             //4.读取数据
22             //String info=Arrays.toString(data);
23             byte[] data=dp.getData();
24             String info=new String(data, 0, dp.getLength());
25             System.out.println("我是服务器，客户端说："+info);
26             /*
27              * 响应客户端
28              */
29             //1.定义客户端的地址、端口号、数据
30             InetAddress add=dp.getAddress();
31             int port=dp.getPort();
32             byte[] data2="欢迎您！".getBytes();
33             //2.建立数据报，包含响应的数据信息
34             DatagramPacket dp2=new DatagramPacket(data2, data2.length, add, port);
35             //3.响应客户端
36             ds.send(dp2);
37             
38         
39         } catch (IOException e) {
40             // TODO Auto-generated catch block
41             e.printStackTrace();
42         }
43         
44     }
45 }

服务器端：

 1 /*
 2  * 服务器端
 3  */
 4 public class UDPSever {
 5 
 6     public static void main(String[] args) throws IOException {
 7         // TODO Auto-generated method stub
 8 
 9         try {
10 
11             // 1.建立服务器端DatagramSocket，指定端口
12             DatagramSocket ds = new DatagramSocket(8080);
13             System.out.println("服务器即将启动，等待客户端的链接...");
14             byte[] data = new byte[1024];
15             // 记录客户端的数量
16             int count = 0;
17             // 循环侦听等待客户端的链接
18             while (true) {
19                 DatagramPacket dp = new DatagramPacket(data, data.length);
20                 ds.receive(dp);
21                 // 建立一个新的线程
22                 UDPServerThread udp = new UDPServerThread(ds, dp);
23                 // 启动线程，执行与客户端的交互
24                 udp.start();
25                 count++;
26                 System.out.println("此时客户端数量为：" + count);
27                 InetAddress add = dp.getAddress();
28                 System.out.println("当前客户端的ip地址为" + add.getHostAddress());
29             }
30 
31         } catch (SocketException e) {
32             // TODO Auto-generated catch block
33             e.printStackTrace();
34         }
35     }
36 
37 }

多个客户端的运行结果：

这样一个简单的多线程UDP通讯就完成了。

4、UDP和TCP

<解 惑>TCP和UDP编程都用在什么地方？

<回 答>网络通讯，例如QQ客户端和服务器间的通讯。

TCP是面向链接的、可靠的，若是对通讯数据的可靠性要求比较高，确保数据对方能够收到，可使用TCP。

UDP是无链接的，在通讯前不会预先创建链接，没法保证可靠性，通常用于对数据可靠性要求不是那么高的场合。

 

<解 惑>UDP和TCP相比较有什么优缺点？

<回 答>UDP相较于TCP，不须要进行复杂的设定输入输出流，只须要设定数据报，即DatagramPacket。而TCP的发送以及接收消息，是经过socket.getInputStream()或者getOutputStream()方法，而UDP是直接设置了，DatagramSocket，经过其send()或者receive()方法来接收或发送消息。TCP的关键组成有server端的ServerSocket.accept()方法，这个方法是直到接收到了客户端的链接才会返回一个Socket，用于接下来的输入和输出。

因此说，TCP的数据传输是须要提早链接、三方握手，数据传输很是安全；

而UDP是不须要提早链接的，无需等待对方回答，因此不保证数据不丢失。

---------------点击查看更多关于Socket信息------------------