El ejemplo de este artículo describe cómo implementar la función de compartir pantalla en Java. Compártelo con todos para tu referencia. El análisis específico es el siguiente:
Recientemente estoy diseñando un curso de ingeniería de software, creando un sistema de monitoreo de pantalla para el laboratorio, haciendo referencia a varios códigos predecesores y finalmente convirtiendo mi propio código después de comprenderlo. Así es como lo imitan los principiantes.
Cuando se trata del sistema de monitoreo de pantalla, hay un lado del maestro y un lado del estudiante. El lado del maestro es el lado del servidor y el lado del estudiante es el lado del cliente. Uno de los aspectos más interesantes del sistema es probablemente la transmisión y el monitoreo de la pantalla. El resto del pase de lista, el bloqueo de la pantalla y el apagado programado son relativamente simples.
La transmisión de pantalla, en términos de implementación de funciones, para decirlo sin rodeos, es que la máquina del profesor intercepta continuamente la información de la pantalla y la envía a la computadora de cada estudiante en forma de imágenes, para que los estudiantes puedan ver las operaciones del maestro en la computadora. la llamada transmisión en pantalla.
Hay algo problemático aquí, es decir, al tomar una captura de pantalla de la pantalla, no hay información del mouse. Pero hay dos soluciones:
① Al enviar información de captura de pantalla, dibuje un mouse sobre la imagen, de modo que haya dos mouse en el lado del estudiante y el lado del estudiante pueda mover el mouse en su propia computadora.
②Envíe las coordenadas del mouse del lado del maestro al lado del estudiante, y el mouse de la computadora del estudiante se mueve en tiempo real de acuerdo con la información de las coordenadas. Esto en realidad involucra la función de control, y el lado del estudiante no puede mover el mouse.
El monitoreo de pantalla es relativamente complicado, de hecho, contiene dos funciones:
①El profesor puede monitorear las pantallas de computadora de todos los estudiantes;
②El profesor controla la computadora de un estudiante;
Debido a que implica concurrencia, cada cliente debe enviar información de pantalla al maestro en tiempo real, lo cual será un poco problemático, pero aún se puede lograr.
La función de compartir pantalla sin mouse se implementa temporalmente aquí. Es relativamente simple y debe mejorarse, pero se puede usar como una clase de herramienta para la integración más adelante.
El primero es el servidor del profesor:
Copie el código de la siguiente manera: paquete Prueba;
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;
/*
* julio 2014-11-20
* Este tipo de envío de capturas de pantalla en tiempo real desaparece, implementación multiproceso, no incluye información del mouse y no optimiza cada Cliente.
*/
la clase pública SendScreenImg extiende el hilo
{
público estático int SERVERPORT=8000;
serverSocket privado serverSocket;
robot privado;
pantalla de dimensión pública;
rectángulo público rect;
toma de corriente privada;
principal vacío estático público (argumentos de cadena [])
{
nuevo SendScreenImg(SERVERPORT).start();
}
//Método de construcción para abrir el robot de conexión de socket y obtener el tamaño de la pantalla
SendScreenImg público (int SERVERPORT)
{
intentar {
serverSocket = nuevo ServerSocket(SERVERPORT);
serverSocket.setSoTimeout(864000000);
robot = nuevo robot();
} captura (Excepción e) {
e.printStackTrace();
}
screen = Toolkit.getDefaultToolkit().getScreenSize() //Obtener el tamaño de la pantalla principal
rect = new Rectángulo(pantalla); //Construye un rectángulo del tamaño de una pantalla
}
@Anular
ejecución pública vacía()
{
//Esperando en tiempo real recibir mensajes de captura de pantalla
mientras (verdadero)
{
intentar{
socket = serverSocket.accept();
System.out.println("El puerto de estudiantes está conectado");
ZipOutputStream zip = nuevo ZipOutputStream(nuevo DataOutputStream(socket.getOutputStream()));
zip.setLevel(9); //Establece el nivel de compresión
BufferedImage img = robot.createScreenCapture(rect);
zip.putNextEntry(new ZipEntry("prueba.jpg"));
ImageIO.write(img, "jpg", zip);
si(zip!=null)zip.close();
System.out.println("El cliente se conecta en tiempo real");
} captura (IOException ioe) {
System.out.println("Conexión desconectada");
} finalmente {
si (zócalo! = nulo) {
intentar {
socket.cerrar();
} captura (IOException e) {e.printStackTrace();}
}
}
}
}
}
Luego está el cliente estudiantil:
Copie el código de la siguiente manera: paquete Prueba;
importar java.awt.Frame;
importar java.awt.Imagen;
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;
/*
* julio 2014-11-20
* Esta clase se utiliza para recibir información de la pantalla del lado del profesor, excluyendo el mouse, y necesita ser optimizada.
*/
clase pública RecibirImages extiende Thread{
marco público BorderInit;
toma de corriente pública;
IP de cadena pública;
principal vacío estático público (String [] argumentos) {
new RecibirImages(new BorderInit(), "127.0.0.1").start();
}
Recibir imágenes públicas (marco BorderInit, IP de cadena)
{
this.frame = marco;
esta.IP=IP;
}
ejecución pública vacía() {
mientras(frame.getFlag()){
intentar {
zócalo = nuevo zócalo (IP, 8000);
DataInputStream ImgInput = nuevo DataInputStream(socket.getInputStream());
ZipInputStream imgZip = nuevo ZipInputStream(ImgInput);
imgZip.getNextEntry(); //Ir al principio de la secuencia del archivo Zip
Image img = ImageIO.read(imgZip); //Lee las imágenes en el flujo de imágenes Zip según los bytes
frame.jlbImg.setIcon(nuevo ImageIcon(img));
System.out.println("Número de conexión"+(System.currentTimeMillis()/1000)%24%60+"segundos");
marco.validar();
TimeUnit.MILLISECONDS.sleep(50);//Intervalo de tiempo para recibir imágenes
imgZip.close();
} captura (IOException | InterruptedException e) {
System.out.println("Conexión desconectada");
}finalmente{
intentar {
socket.cerrar();
} captura (IOException e) {}
}
}
}
}
// Clase auxiliar de ventana del lado del cliente, especialmente utilizada para mostrar información en pantalla recibida del lado del profesor
clase BorderInit extiende JFrame
{
serialVersionUID largo final estático privado = 1L;
público JLabel jlbImg;
bandera booleana privada;
getFlag público booleano(){
devolver esta.bandera;
}
publicBorderInit()
{
this.flag=verdadero;
this.jlbImg = nuevo JLabel();
this.setTitle("Monitoreo remoto--IP:" + "--Tema:");
this.setSize(400, 400);
//this.setUndecorated(true); // Visualización en pantalla completa, es mejor comentar al realizar la prueba
//this.setAlwaysOnTop(true); //La ventana de visualización siempre está al frente
this.add(jlbImg);
this.setLocationRelativeTo(nulo);
this.setExtendedState(Frame.MAXIMIZED_BOTH);
this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
this.setVisible(verdadero);
this.validar();
//evento de cierre de ventana
this.addWindowListener(nuevo WindowAdapter() {
ventana vacía públicaClosing(WindowEvent e) {
bandera = falso;
BorderInit.this.dispose();
System.out.println("Formulario cerrado");
System.gc(); //recolección de basura
}
});
}
}
Aquí hay una función tan pequeña extraída del producto sin terminar. Todavía queda mucho por escribir antes de que los amigos interesados puedan mejorarla sobre esta base.
Espero que este artículo sea útil para la programación Java de todos.