O exemplo neste artigo descreve como implementar a função de compartilhamento de tela em Java. Compartilhe com todos para sua referência. A análise específica é a seguinte:
Recentemente estou projetando um curso de engenharia de software, fazendo um sistema de monitoramento de tela para o laboratório, referindo-me a vários códigos antecessores e, finalmente, convertendo meu próprio código depois de entendê-lo.
Quando se trata do sistema de monitoramento de tela, existe um lado do professor e um lado do aluno. O lado do professor é o lado do servidor e o lado do aluno é o lado do cliente. Um dos aspectos mais interessantes do sistema é provavelmente a transmissão e o monitoramento da tela. O resto da chamada, bloqueio de tela e desligamento programado são relativamente simples.
A transmissão de tela, em termos de implementação de função, para ser franco, é que a máquina do professor intercepta continuamente as informações da tela e as envia para o computador de cada aluno na forma de imagens, para que os alunos possam ver as operações do professor no computador. a chamada transmissão de tela.
Há uma coisa problemática aqui, ou seja, ao fazer uma captura de tela da tela, não há informações do mouse. Mas existem duas soluções:
① Ao enviar informações de captura de tela, desenhe um mouse na imagem, de modo que haja dois mouses do lado do aluno, e o aluno possa mover o mouse em seu próprio computador.
②Envie as coordenadas do mouse do lado do professor para o lado do aluno, e o mouse do computador do aluno se moverá em tempo real de acordo com as informações das coordenadas. Isso realmente envolve a função de controle, e o lado do aluno não pode mover o mouse.
O monitoramento de tela é relativamente complicado. Na verdade, contém duas funções:
①O professor pode monitorar as telas dos computadores de todos os alunos;
②O professor controla o computador do aluno;
Por envolver simultaneidade, cada cliente deve enviar informações da tela ao professor em tempo real, o que será um pouco incômodo, mas ainda pode ser conseguido.
A função de compartilhamento de tela sem mouse é implementada temporariamente aqui. É relativamente simples e precisa ser melhorada, mas pode ser usada como uma classe de ferramenta para integração posterior.
O primeiro é o servidor do professor:
Copie o código da seguinte forma: package Test;
importar java.awt.Dimension;
importar java.awt.Rectangle;
importar java.awt.Robot;
importar java.awt.Toolkit;
importar java.awt.image.BufferedImage;
importar java.io.DataOutputStream;
importar java.io.IOException;
importar java.net.ServerSocket;
importar java.net.Socket;
importar java.util.zip.ZipEntry;
importar java.util.zip.ZipOutputStream;
importar javax.imageio.ImageIO;
/*
* 2014-11-20
* Este tipo de envio de screenshots em tempo real desaparece, implementação multithread, não inclui informações do mouse e não otimiza cada Cliente.
*/
classe pública SendScreenImg estende Thread
{
public static int SERVERPORT=8000;
servidorSocket privado serverSocket;
robô robô privado;
tela de dimensão pública;
retângulo público retângulo;
tomada privada;
público estático void principal(String args[])
{
new SendScreenImg(SERVERPORT).start();
}
//Método de construção para abrir o robô de conexão do soquete e obter o tamanho da tela
SendScreenImg público (int SERVERPORT)
{
tentar {
serverSocket = novo ServerSocket(SERVERPORT);
serverSocket.setSoTimeout(864000000);
robô = novo Robô();
} catch (Exceção e) {
e.printStackTrace();
}
screen = Toolkit.getDefaultToolkit().getScreenSize(); //Obter o tamanho da tela principal
rect = new Rectangle(screen); //Constrói um retângulo do tamanho de uma tela
}
@Substituir
execução de vazio público ()
{
//Aguardando em tempo real para receber mensagens de captura de tela
enquanto (verdadeiro)
{
tentar{
soquete = serverSocket.accept();
System.out.println("A porta do aluno está conectada");
ZipOutputStream zip = new ZipOutputStream(new DataOutputStream(socket.getOutputStream()));
zip.setLevel(9); //Definir o nível de compactação
BufferedImage img = robot.createScreenCapture(rect);
zip.putNextEntry(new ZipEntry("teste.jpg"));
ImageIO.write(img, "jpg", zip);
if(zip!=null)zip.close();
System.out.println("Cliente está se conectando em tempo real");
} catch (IOException ioe) {
System.out.println("Conexão desconectada");
} finalmente {
if (soquete! = nulo) {
tentar {
soquete.close();
} catch (IOException e) {e.printStackTrace();}
}
}
}
}
}
Depois, há o cliente estudante:
Copie o código da seguinte forma: package Test;
importar java.awt.Frame;
importar java.awt.Image;
importar java.awt.event.WindowAdapter;
importar java.awt.event.WindowEvent;
importar java.io.DataInputStream;
importar java.io.IOException;
importar java.net.Socket;
importar java.util.concurrent.TimeUnit;
importar java.util.zip.ZipInputStream;
importar javax.imageio.ImageIO;
importar javax.swing.ImageIcon;
importar javax.swing.JFrame;
importar javax.swing.JLabel;
/*
* 2014-11-20
*Esta classe é utilizada para receber informações da tela do lado do professor, excluindo o mouse, e precisa ser otimizada.
*/
classe pública ReceiveImages estende Thread{
quadro BorderInit público;
soquete público;
IP de string pública;
public static void main(String[] args){
new ReceiveImages(new BorderInit(), "127.0.0.1").start();
}
ReceiveImages públicas (quadro BorderInit, String IP)
{
este.frame = quadro;
este.IP=IP;
}
execução void pública() {
enquanto(frame.getFlag()){
tentar {
soquete = novo Soquete(IP,8000);
DataInputStream ImgInput = new DataInputStream(socket.getInputStream());
ZipInputStream imgZip = new ZipInputStream(ImgInput);
imgZip.getNextEntry(); //Vá para o início do fluxo do arquivo Zip
Image img = ImageIO.read(imgZip); //Lê as imagens no fluxo de imagens Zip de acordo com os bytes;
frame.jlbImg.setIcon(new ImageIcon(img));
System.out.println("Número de conexão"+(System.currentTimeMillis()/1000)%24%60+"segundos");
frame.validate();
TimeUnit.MILLISECONDS.sleep(50);//Tempo de intervalo para recebimento de fotos
imgZip.close();
} catch (IOException | InterruptedException e) {
System.out.println("Conexão desconectada");
}finalmente{
tentar {
soquete.close();
} capturar (IOException e) {}
}
}
}
}
//Classe auxiliar da janela do lado do cliente, especialmente usada para exibir informações da tela recebidas do lado do professor
classe BorderInit estende JFrame
{
privado estático final longo serialVersionUID = 1L;
público JLabel jlbImg;
sinalizador booleano privado;
getFlag booleano público(){
retorne este.flag;
}
publicBorderInit()
{
this.flag=true;
this.jlbImg = new JLabel();
this.setTitle("Monitoramento remoto--IP:" + "--Tópico:" );
this.setSize(400, 400);
//this.setUndecorated(true); //Exibição em tela cheia, é melhor comentar durante o teste
//this.setAlwaysOnTop(true); //A janela de exibição está sempre na frente
this.add(jlbImg);
this.setLocationRelativeTo(nulo);
this.setExtendedState(Frame.MAXIMIZED_BOTH);
this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
this.setVisible(verdadeiro);
this.validate();
//evento de fechamento da janela
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
sinalizador=falso;
BorderInit.this.dispose();
System.out.println("Formulário fechado");
System.gc();
}
});
}
}
Aqui está uma função tão pequena extraída do produto inacabado. Ainda há muito o que escrever antes que o produto final possa melhorá-lo.
Espero que este artigo seja útil para a programação Java de todos.