屏幕广播

1、服务器端

public class ThreadMain {

    public static void main(String[] args) {
        new ServerSender().start();
    }

}


public class ServerSender {
    //UDP套接字
    private DatagramSocket socket;
    //创建机器人，抓图
    private Robot robot;
    private Rectangle rect;
    public ServerSender()  {
        try {
            socket=new DatagramSocket(8888);
            robot=new Robot();
            rect=new Rectangle(0, 0, 1366, 768);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public void start(){
        int i=0;
        while(true){
            sendOneScreen();
        }
    }
    private void sendOneScreen() {
        //1.抓取一屏幕
        byte[] frameData=catchOneScreen(true);
        //2.切割
        List<FrameUnit> units=splitScreen(frameData);
        //3.组装内容，并发送所有帧单元
        sendAllUnits(units);
    }
    //发送所有帧单元
    private void sendAllUnits(List<FrameUnit> units){
        for (FrameUnit unit:units) {
            //处理帧单元
            DatagramPacket pack=processUnit(unit);
            try {
                socket.send(pack);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //处理帧单元
    private DatagramPacket processUnit(FrameUnit unit){
        byte[] buf=new byte[unit.getLength()+14];
        //时间戳
        byte[] timeBytes=bytesUtil.long2ByteArr(unit.getTimestamp());
        System.arraycopy(timeBytes, 0, buf, 0, 8);
        //count
        buf[8]=(byte) unit.getCount();
        //index
        buf[9]=(byte) unit.getIndex();
        //data长度
        byte[] unitLengBytes=bytesUtil.int2ByteArr(unit.getLength());
        System.arraycopy(unitLengBytes, 0, buf, 10, 4);
        //数据
        byte[] unitDataBytes=unit.getUnitData();
        System.arraycopy(unitDataBytes, 0, buf, 14, unitDataBytes.length);
        //设置数据报包的广播地址
        DatagramPacket pack=new DatagramPacket(buf, buf.length);
        InetSocketAddress addr=new InetSocketAddress("localhost", 9999);
        pack.setSocketAddress(addr);
        return pack;
        
    }
    //切屏
    private List<FrameUnit> splitScreen(byte[] frameData) {
        //frameUnit的长度
        int unitLength=60*1024;
        //帧单元集合
        List<FrameUnit> list = new ArrayList<>();
        int count=0;
        //正好整除unit大小
        if(frameData.length % unitLength==0){
            count=frameData.length / unitLength;
        }
        else{
            count=frameData.length / unitLength +1;
        }
        //取出时间戳
        long timestamp=System.currentTimeMillis();
        for(int i=0;i<count;i++){
            FrameUnit unit = new FrameUnit();
            unit.setTimestamp(timestamp);
            unit.setCount(count);
            unit.setIndex(i);
            //如果不是最后一帧单元，大小为60k;
            if(i !=(count-1)){
                unit.setLength(60*1024);
                byte[] unitData=new byte[60*1024];
                System.arraycopy(frameData, i*60*1024, unitData, 0, 60*1024);
                unit.setUnitData(unitData);
            }
            //最后一帧处理
            else{
                //取得最后一帧的长度
                int remain=frameData.length % unitLength==0?60*1024:frameData.length % unitLength;
                unit.setLength(remain);
                byte[] unitData=new byte[remain];
                System.arraycopy(frameData, i*60*1024, unitData, 0, remain);
                unit.setUnitData(unitData);
            }
            list.add(unit);
        }
    
        return list;
    }
    //抓取一屏画面
    private byte[] catchOneScreen(boolean zip) {
        try {
            BufferedImage image = robot.createScreenCapture(rect);
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ImageIO.write(image, "jpg", bos);
            //原生数据
            byte[] rawrate=bos.toByteArray();
            //需要压缩
            if(zip){
                ByteArrayOutputStream bos0 = new ByteArrayOutputStream();
                ZipOutputStream zos=new ZipOutputStream(bos0);
                zos.putNextEntry(new ZipEntry("0001"));
                zos.write(rawrate);
                zos.close();
                bos0.close();
                //直接返回该数据，后面不再执行
                return bos0.toByteArray();
            }
            return rawrate;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

2、客户端

public class StudentMain {

    public static void main(String[] args) {
        StudentUI ui = new StudentUI();
        new ReceiverThread(ui).start();
    }

}

public class ReceiverThread extends Thread {
    // 存放所有帧单元的集合
    private Map<Integer, FrameUnit> map = new HashMap<>();
    private StudentUI ui;
    private DatagramSocket socket;

    public ReceiverThread(StudentUI ui) {
        try {
            this.ui = ui;
            socket = new DatagramSocket(9999);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    public void run() {
        // 数据缓存区
        byte[] buf = new byte[60 * 1024 + 14];
        DatagramPacket pack = new DatagramPacket(buf, buf.length);
        try {
            while (true) {
                socket.receive(pack);
                // 解析数据报包成FrameUnit
                FrameUnit unit = parsePack(pack);
                // 处理帧单元
                processUnit(unit);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 解析数据包，解析帧单元
    private FrameUnit parsePack(DatagramPacket pack) {
        // 缓冲区数据，含有header
        byte[] bufData = pack.getData();
        FrameUnit unit = new FrameUnit();
        // 处理时间戳
        long timestamp = bytesUtil.byte2long(bufData);
        unit.setTimestamp(timestamp);
        // frameUnit个数
        int count = bufData[8];
        unit.setCount(count);
        // frame索引
        int index = bufData[9];
        unit.setIndex(index);
        // 数据长度
        byte[] bytelength = new byte[4];
        System.arraycopy(bufData, 10, bytelength, 0, 4);
        int dataLen = bytesUtil.byte2int(bytelength);
        unit.setLength(dataLen);
        // 图像数据处理
        byte[] unitData = new byte[dataLen];
        System.arraycopy(bufData, 14, unitData, 0, dataLen);
        unit.setUnitData(unitData);
        return unit;
    }

    // 处理帧单元
    private void processUnit(FrameUnit unit) {
        // 如果集合为空，没有帧单元数据
        if (map.isEmpty()) {
            map.put(unit.getIndex(), unit);
        } else {
            // 提取map中存放的帧单元的时间戳
            long oldTime = map.values().iterator().next().getTimestamp();
            long currTime = unit.getTimestamp();
            // 同一帧
            if (oldTime == currTime) {
                map.put(unit.getIndex(), unit);
            }
            // 新帧单元
            else if (currTime > oldTime) {
                map.clear();
                map.put(unit.getIndex(), unit);
            }
            // 老帧单元迟到，直接丢弃
            else {
            }
        }
        // 处理frame
        prcessFrame(true);
    }

    // 判断是否集齐了所有帧单元，处理称为一帧
    private void prcessFrame(boolean zip) {
        try {
            int count = map.values().iterator().next().getCount();
            int size = map.size();
            // 集齐了所有帧单元
            if (count == size) {
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                for (int i = 0; i < count; i++) {
                    FrameUnit unit = map.get(i);
                    bos.write(unit.getUnitData());
                }
                // 得到一屏幕画面的帧数据
                byte[] frameData = bos.toByteArray();
                if (zip) {
                    ByteArrayOutputStream bos0 = new ByteArrayOutputStream();
                    ByteArrayInputStream bis = new ByteArrayInputStream(frameData);
                    ZipInputStream zis = new ZipInputStream(bis);
                    zis.getNextEntry();
                    byte[] buf = new byte[1024];
                    int len = -1;
                    while ((len=zis.read(buf)) != -1) {
                        bos0.write(buf, 0, len);
                    }
                    zis.close();
                    // 解压数据
                    frameData = bos0.toByteArray();
                }
                ui.updateUI(frameData);
                map.clear();
            }

        } catch (Exception e) {
        }
    }

}


public class StudentUI extends JFrame{

    private static final long serialVersionUID = 2084514325030688532L;
    //标签字段
    private JLabel lbl;
    public StudentUI(){
        init();
        this.setVisible(true);
    }
    private void init() {
        this.setTitle("学生端");
        this.setLayout(null);
        this.setBounds(0, 0, 1366, 768);
        
        lbl=new JLabel();
        lbl.setBounds(0, 0, 1366, 768);
        this.add(lbl);
        
        this.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(-1);
            }
        });
    }
    //更新UI
    public void updateUI(byte[] frameData){
        try {
            ByteArrayInputStream bis = new ByteArrayInputStream(frameData);
            BufferedImage image = ImageIO.read(bis);
            ImageIcon icon = new ImageIcon(image);
            lbl.setIcon(icon);
        } catch (Exception e) {
        }
    
}
}

3、工具类

public class bytesUtil {
    //字节数组转成int
    public static int byte2int(byte[] arr){
        int i0=arr[0] & 0xff;
        int i1=(arr[1] & 0xff)<<8;
        int i2=(arr[2] & 0xff)<<16;
        int i3=(arr[3] & 0xff)<<24;
        return i0 |i1|i2|i3;
    }
    //字节数组转成long
    public static long byte2long(byte[] arr){
        long i0=arr[0] & 0xffL;
        long i1=(arr[1] & 0xffL)<<8;
        long i2=(arr[2] & 0xffL)<<16;
        long i3=(arr[3] & 0xffL)<<24;
        long i4=(arr[4] & 0xffL)<<32;
        long i5=(arr[5] & 0xffL)<<40;
        long i6=(arr[6] & 0xffL)<<48;
        long i7=(arr[7] & 0xffL)<<56;
        return i0 | i1 | i2 | i3 | i4 | i5 | i6 | i7;
    }
    /**
     * 将整数转换成字节数组
     */
    public static byte[] int2ByteArr(int i){
        byte[] bytes = new byte[4] ;
        bytes[0] = (byte)(i >> 0) ;
        bytes[1] = (byte)(i >> 8) ;
        bytes[2] = (byte)(i >> 16) ;
        bytes[3] = (byte)(i >> 24) ;
        return bytes ;
    }
    /**
     * 将长整数转换成字节数组
     */
    public static byte[] long2ByteArr(long i){
        byte[] bytes = new byte[8] ;
        bytes[0] = (byte)(i >> 0) ;
        bytes[1] = (byte)(i >> 8) ;
        bytes[2] = (byte)(i >> 16) ;
        bytes[3] = (byte)(i >> 24) ;
        bytes[4] = (byte)(i >> 32) ;
        bytes[5] = (byte)(i >> 40) ;
        bytes[6] = (byte)(i >> 48) ;
        bytes[7] = (byte)(i >> 56) ;
        return bytes ;
    }
}

public class FrameUnit {
    private long timestamp;
    private int count;
    private int index;
    private int length;
    private byte[] unitData;
    public long getTimestamp() {
        return timestamp;
    }
    public void setTimestamp(long timestamp) {
        this.timestamp = timestamp;
    }
    public int getCount() {
        return count;
    }
    public void setCount(int count) {
        this.count = count;
    }
    public int getIndex() {
        return index;
    }
    public void setIndex(int index) {
        this.index = index;
    }
    public int getLength() {
        return length;
    }
    public void setLength(int length) {
        this.length = length;
    }
    public byte[] getUnitData() {
        return unitData;
    }
    public void setUnitData(byte[] unitData) {
        this.unitData = unitData;
    }    
}