基于UDP的网络通信之屏幕共享

网络 网络管理
UDP是一种用途广泛的网络传输协议,发送方只管发送数据出去,而不管是否能够送达。

[[119951]]

UDP是一种用途广泛的网络传输协议,发送方只管发送数据出去,而不管是否能够送达。

应用范围:有时候因为网络问题,接收方可能会丢失部分数据,但是并不影响程序的功能。例如视频直播的时候有一些数据丢失了,最多就是卡顿一下,并不会造成功能很大的影响。

对于发送者而言,需要有一个发送者的地址与端口,也需要知道要发到哪个地址的哪个端口。同时还需要一个socket传送数据。

在这里,可以将他们形象的比喻成邮政系统。

发送者就是寄件人,接收者就是收件人,而传递着就是邮递员。

  1. // 创建一个发送者(发件人)   
  2. SocketAddress sender = new InetSocketAddress("127.0.0.1", 912);   
  3. // 创建一个接收者(收件人)   
  4. SocketAddress receiver = new InetSocketAddress("127.0.0.1", 913);   
  5. // 创建一个传递者(邮递员)   
  6. DatagramSocket socket = new DatagramSocket(sender);   

而对于寄件人而言,他需要将要寄的东西用一个包装装好,也就是包裹一样。然后再交给邮递员送出去。

  1. byte[] msg="Hello!".getBytes();   
  2. DatagramPacket m = new DatagramPacket(msg, msg.length, receiver);   
  3. socket.send(m);   

对于接收者而言,他需要知道去哪里取数据,邮递员是谁,收到了一个包裹。

  1. // 创建接收对象(收件人)   
  2. SocketAddress receiver = new InetSocketAddress("127.0.0.1", 913);   
  3. // 得到消息接收的socket(邮递员)   
  4. DatagramSocket socket = new DatagramSocket(receiver);   
  5. // 定义好包裹   
  6. DatagramPacket data = new DatagramPacket(buf, buf.length);   
  7. // 用socket将数据包裹接收进来   
  8. socket.receive(data);    

这其中就需要定义一些协议。

UDP出了上述一对一共享,还可以以组播的方式共享数据,即一对多。

这里以简单的屏幕分享为例

首先,要明确我们的目的是需要将某台计算机的屏幕分享给其他人。

也就是将计算机屏幕截图,再使用局域网组播。

由于每次发送的数组不能过大,所以截取屏幕得到的图片需要分多次发送出去,等客户端接收到了再拼成原图。所以需要一个信息头来保存图片的基本信息以便于客户端收到之后能顺利拼回原图。

关键在于如何定义这个信息头,在接收方我们需要知道发送端传给我们的图片是分多少次发送过来的,也要知道总共有多少个字节,还要判断是不是因为网络原因有部分数据被丢弃了,那样的话自然就无法还原数据了。

在这里,我采用的方法是:

信息头定义如下:

第一个字节为类型,暂时用0表示图片

第二个字节为数据组数,意思是这张图片分成了多少次发出去,在客户端需要收到多少才能pin回来

第三个字节为随机的一个记号,用来告诉客户端是否数据丢失了。如果有数据丢失,

则应该丢弃相关的所有数据,不能拼回原图,则跳过这一帧。

第四个字节为实际要传输的数据长度的位数。比如实际上是1234byte,则这个值是4

接下来的n个为长度信息,比如:data[4] = 1;data[5] = 2;data[6] = 3;这就表示长度为1234

每一次都发10000个实际字节数据

加上10个左右的头部信息。所以每个数组长度都是10010

客户端接收到消息之后,就要判断是不是有数据丢失。没有的话就会拼回原图并显示

接收到了这次的数据之后,如果发现前一组丢了部分数据,那么就要将前一组数据全部清空,然后继续接收#p#

部分代码如下:

发送者:

  1. package V0913;   
  2.    
  3. import java.awt.Dimension;   
  4. import java.awt.Rectangle;   
  5. import java.awt.Robot;   
  6. import java.awt.Toolkit;   
  7. import java.awt.image.BufferedImage;   
  8. import java.io.BufferedOutputStream;   
  9. import java.io.ByteArrayOutputStream;   
  10. import java.io.File;   
  11. import java.io.FileOutputStream;   
  12. import java.io.IOException;   
  13. import java.net.DatagramPacket;   
  14. import java.net.InetAddress;   
  15. import java.net.MulticastSocket;   
  16. import java.net.UnknownHostException;   
  17. import java.util.ArrayList;   
  18.    
  19. import javax.imageio.ImageIO;   
  20.    
  21. /**  
  22.  * 发送数据的线程  
  23.  *   
  24.  * @author 斌  
  25.  * @2014年9月13日  
  26.  */   
  27. public class SendThread extends Thread {   
  28.    
  29.     InetAddress inetAdd;   
  30.     MulticastSocket cast;   
  31.     byte biaoji = 0;   
  32.    
  33.     public void run() {   
  34.         try {   
  35.             // 创建组播地址   
  36.             inetAdd = InetAddress.getByName("230.0.0.1");   
  37.             // 创建组播的Socket对象   
  38.             cast = new MulticastSocket();   
  39.    
  40.             // 截屏   
  41.             Robot robot = new Robot();   
  42.             Dimension dis = Toolkit.getDefaultToolkit().getScreenSize();   
  43.    
  44.             BufferedImage image;   
  45.             while (Login.connected) {   
  46.                 // 得到屏幕截图数据   
  47.                 image = robot.createScreenCapture(new Rectangle(dis));   
  48.                 // 将图片转换为byte数组   
  49.                 ByteArrayOutputStream baos = new ByteArrayOutputStream();   
  50.                 ImageIO.write(image, "png", baos);   
  51.                 byte[] data = baos.toByteArray();   
  52.    
  53.                 // new BufferedOutputStream(new FileOutputStream(new File(   
  54.                 // "data.txt"))).write(data);   
  55.    
  56.                 send(data);   
  57.                 // // 数据丢失的模拟   
  58.                 // byte dt[] = { 0, 122, 2, 1, 4, 1, 2, 3, 4 };   
  59.                 // DatagramPacket packet = new DatagramPacket(dt, dt.length,   
  60.                 // inetAdd, 9876);   
  61.                 //   
  62.                 // // 将其发送   
  63.                 // try {   
  64.                 // cast.send(packet);   
  65.                 // } catch (IOException e) {   
  66.                 // e.printStackTrace();   
  67.                 // }   
  68.    
  69.                 if (biaoji < 100) {   
  70.                     biaoji++;   
  71.                 } else {   
  72.                     biaoji = 0;   
  73.                 }   
  74.    
  75.                 Thread.sleep(30);   
  76.             }   
  77.         } catch (UnknownHostException e) {   
  78.             e.printStackTrace();   
  79.         } catch (Exception e) {   
  80.             e.printStackTrace();   
  81.         }   
  82.     }   
  83.    
  84.     public void send(byte[] data) {   
  85.         // 将data数组拆分发送   
  86.         long length = data.length;// 数据总长度   
  87.         ArrayList<byte[]> list = new ArrayList<byte[]>();   
  88.         byte size = (byte) (length / 10000 + 1);// 这张图片有多少组数据数据   
  89.         int j = 0;   
  90.         while (j < size) {   
  91.             byte[] dataTemp;   
  92.             int temp;   
  93.             if (j < size - 1) {   
  94.                 temp = 10000;   
  95.             } else {   
  96.                 temp = (int) (length % 10000);// 最后一次需要的大小   
  97.             }   
  98.             dataTemp = new byte[10010];   
  99.             dataTemp[0] = 0;// 类型   
  100.             dataTemp[1] = biaoji;// 记号,接收方用来判断是不是丢了数据   
  101.             dataTemp[2] = size;// 总共有多少组数据需要接收   
  102.             dataTemp[3] = getLength(temp);// 数据大小占了数组几位   
  103.             for (int i = 0; i < dataTemp[3]; i++) {   
  104.                 // 将数据大小保存起来   
  105.                 dataTemp[i + 4] = getElem(temp, i);   
  106.             }   
  107.             // 每次存10000个字节数据   
  108.             for (int i = 0; i < temp; i++) {   
  109.                 dataTemp[i + 4 + dataTemp[3]] = data[j * 10000 + i];   
  110.             }   
  111.    
  112.             list.add(dataTemp);   
  113.             j++;   
  114.         }   
  115.    
  116.         // 循环发送数据   
  117.         for (int i = 0; i < list.size(); i++) {   
  118.             // 将其打包   
  119.             DatagramPacket packet = new DatagramPacket(list.get(i),   
  120.                     list.get(i).length, inetAdd, 9876);   
  121.    
  122.             // 将其发送   
  123.             try {   
  124.                 cast.send(packet);   
  125.             } catch (IOException e) {   
  126.                 e.printStackTrace();   
  127.             }   
  128.         }   
  129.         System.out.println("发送了一张图片");   
  130.     }   
  131.    
  132.     /**  
  133.      * 获得一个long的位数  
  134.      *   
  135.      * @param num  
  136.      * @return  
  137.      */   
  138.     private byte getLength(long num) {   
  139.         byte count = 1;   
  140.         while (num / 10 != 0) {   
  141.             num /= 10;   
  142.             count++;   
  143.         }   
  144.         return count;   
  145.     }   
  146.    
  147.     /**  
  148.      * 获得num中第index位的数字,以0开始计算起始位置  
  149.      *   
  150.      * @param num  
  151.      * @param index  
  152.      * @return  
  153.      */   
  154.     private byte getElem(long num, int index) {   
  155.         int length = getLength(num);   
  156.         // 最后一个   
  157.         if ((index + 1) == length) {   
  158.             return (byte) (num % 10);   
  159.         }   
  160.         long count = num;   
  161.         for (int i = 0; i < length - index - 1; i++) {   
  162.             countcount = count / 10;   
  163.         }   
  164.         countcount = count % 10;   
  165.         return (byte) count;   
  166.     }   
  167. }   

#p#接收者:

  1. package V0913;   
  2.    
  3. import java.io.IOException;   
  4. import java.net.DatagramPacket;   
  5. import java.net.InetAddress;   
  6. import java.net.MulticastSocket;   
  7. import java.util.ArrayList;   
  8.    
  9. import javax.swing.ImageIcon;   
  10.    
  11. /**  
  12.  * 接收数据的线程  
  13.  *   
  14.  * @author 斌  
  15.  * @2014年9月13日  
  16.  */   
  17. public class ReceiveThread extends Thread {   
  18.    
  19.     private MulticastSocket cast;   
  20.    
  21.     public void run() {   
  22.    
  23.         try {   
  24.             // 创建窗口   
  25.             MainUI mu = new MainUI();   
  26.             // 创建socket用来接收数据   
  27.             cast = new MulticastSocket(9876);   
  28.             // 定义组播地址   
  29.             InetAddress inetAdd = InetAddress.getByName("230.0.0.1");   
  30.             // 将socket加入该地址组   
  31.             cast.joinGroup(inetAdd);   
  32.             System.out.println("stratServer");   
  33.             while (mu.connect) {   
  34.                 ImageIcon icon = receive();   
  35.                 // 显示在窗口上   
  36.                 if (icon != null) {   
  37.                     mu.label.setIcon(icon);   
  38.                     mu.center.repaint();   
  39.                 }   
  40.             }   
  41.         } catch (IOException e) {   
  42.             e.printStackTrace();   
  43.         }   
  44.     }   
  45.    
  46.     public ImageIcon receive() throws IOException {   
  47.    
  48.         ArrayList<byte[]> list = new ArrayList<byte[]>();   
  49.         // 创建数据包对象   
  50.    
  51.         byte dataTemp[] = new byte[10010];   
  52.    
  53.         long alllength = 0;   
  54.    
  55.         DatagramPacket packet = new DatagramPacket(dataTemp, dataTemp.length);   
  56.    
  57.         // 接收数据包   
  58.    
  59.         cast.receive(packet);   
  60.         // 提取头部信息进行解析,第0个为类型,判断是否为0,第1个为记号,第2个为多少个数据需要接受,第3个为长度的长度,之后接着长度信息,之后再是数据   
  61.    
  62.         int biaoji = dataTemp[1];   
  63.         byte size = dataTemp[2];   
  64.         alllength += getLength(dataTemp);   
  65.         list.add(dealData(dataTemp));   
  66.    
  67.         for (int i = 1; i < size; i++) {   
  68.             packet = new DatagramPacket(dataTemp, dataTemp.length);   
  69.             // 接收数据包   
  70.             cast.receive(packet);   
  71.             if (biaoji == dataTemp[1]) {   
  72.                 list.add(dealData(dataTemp));   
  73.                 alllength += getLength(dataTemp);   
  74.             } else {   
  75.                 // ***************************************************************************************//   
  76.                 System.out.println("有数据丢了");   
  77.                 // 初始化数据   
  78.                 list.clear();   
  79.                 biaoji = dataTemp[1];   
  80.                 size = dataTemp[2];   
  81.                 i = 0;   
  82.                 list.add(dealData(dataTemp));   
  83.                 alllength = getLength(dataTemp);   
  84.             }   
  85.         }   
  86.         // 将list中的数组全部加到data中去   
  87.         byte data[] = new byte[(int) alllength];   
  88.         for (int i = 0; i < list.size(); i++) {   
  89.             byte t[] = list.get(i);   
  90.             for (int j = 0; j < t.length; j++) {   
  91.                 data[i * 10000 + j] = t[j];   
  92.             }   
  93.         }   
  94.         // new BufferedOutputStream(new FileOutputStream(new File("data.txt")))   
  95.         // .write(data);   
  96.    
  97.         // 将数据还原成图像   
  98.         ImageIcon icon = new ImageIcon(data);   
  99.         return icon;   
  100.     }   
  101.    
  102.     /**  
  103.      * 处理收到的数据,得到真正需要的数据  
  104.      *   
  105.      * @param dataTemp  
  106.      * @return  
  107.      */   
  108.     public byte[] dealData(byte dataTemp[]) {   
  109.    
  110.         int length = getLength(dataTemp);// 一般为10000   
  111.    
  112.         byte[] data = new byte[length];   
  113.         // 得到了数据长度,之后开始读数据   
  114.         for (int i = 0; i < length; i++) {   
  115.             data[i] = dataTemp[i + dataTemp[3] + 4];   
  116.         }   
  117.         return data;   
  118.     }   
  119.    
  120.     /**  
  121.      * 获得实际需要数据的长度  
  122.      *   
  123.      * @param dataTemp  
  124.      * @return  
  125.      */   
  126.     public int getLength(byte dataTemp[]) {   
  127.         byte temp[] = new byte[dataTemp[3]];   
  128.         for (int i = 0; i < dataTemp[3]; i++) {   
  129.             temp[i] = dataTemp[i + 4];   
  130.         }   
  131.    
  132.         return getNum(temp);   
  133.     }   
  134.    
  135.     /**  
  136.      * 根据byte数组合成一个数字 如:{1,2,3,4}合成之后为1234  
  137.      *   
  138.      * @param data  
  139.      * @return  
  140.      */   
  141.     public int getNum(byte data[]) {   
  142.         int temp = 0;   
  143.         for (int i = 0; i < data.length; i++) {   
  144.             temp += data[i] * Math.pow(10, data.length - i - 1);   
  145.         }   
  146.         return temp;   
  147.     }   
  148. }   

#p#运行效果图如下:

 

 

发送端点击开始按钮开始发送截图

 

 

接收方点击开始,开始接受数据

 

 

由于在本地上直接测试,所以会出现重叠。程序中使用了jna和platform的透明效果。

责任编辑:林琳 来源: ITeye-博客
相关推荐

2019-04-29 10:26:49

TCP网络协议网络通信

2020-07-06 07:52:10

Kubernetes网络通信

2024-02-20 19:53:57

网络通信协议

2019-09-25 08:25:49

RPC网络通信

2013-03-21 11:05:14

2020-11-12 08:52:16

Python

2023-09-18 13:12:00

TCPUDP

2009-08-24 17:20:13

C#网络通信TCP连接

2010-07-01 15:45:22

网络通信协议

2017-01-15 17:44:56

node网络通信Socket

2010-06-14 19:13:28

网络通信协议

2010-06-29 10:15:31

局域网故障

2010-06-09 11:57:42

网络通信协议

2021-08-13 11:27:25

网络通信数据

2022-12-05 09:25:17

Kubernetes网络模型网络通信

2023-03-15 08:17:27

Kafka网络通信组件

2023-06-19 07:54:37

DotNetty网络通信框架

2009-10-16 08:48:08

2010-04-22 16:10:48

Aix操作系统网络通信

2021-08-30 13:08:56

Kafka网络通信
点赞
收藏

51CTO技术栈公众号