Das Beispiel in diesem Artikel beschreibt, wie die Bildschirmfreigabefunktion in Java implementiert wird. Teilen Sie es als Referenz mit allen. Die spezifische Analyse lautet wie folgt:
Kürzlich entwerfe ich einen Software-Engineering-Kurs, erstelle ein Bildschirmüberwachungssystem für das Labor, beziehe mich auf verschiedene Vorgängercodes und konvertiere schließlich meinen eigenen Code, nachdem ich ihn verstanden habe. So imitieren Anfänger ihn.
Beim Bildschirmüberwachungssystem gibt es eine Lehrerseite und eine Schülerseite. Die Lehrerseite ist die Serverseite und die Schülerseite ist die Clientseite. Einer der interessanteren Aspekte des Systems ist wahrscheinlich die Bildschirmübertragung und Bildschirmüberwachung. Der Rest des Appells, die Bildschirmsperre und das geplante Herunterfahren sind relativ einfach.
Im Hinblick auf die Funktionsimplementierung besteht die Bildschirmübertragung darin, dass die Maschine des Lehrers kontinuierlich Bildschirminformationen abfängt und sie in Form von Bildern an den Computer jedes Schülers sendet, sodass die Schüler die Vorgänge des Lehrers auf dem Computer sehen können die sogenannte Bildschirmübertragung.
Hier gibt es ein Problem: Beim Erstellen eines Screenshots des Bildschirms sind keine Mausinformationen vorhanden. Aber es gibt zwei Lösungen:
① Wenn Sie Screenshot-Informationen senden, ziehen Sie eine Maus über das Bild, sodass auf der Schülerseite zwei Mäuse vorhanden sind und die Schülerseite die Maus auf ihrem eigenen Computer bewegen kann.
②Senden Sie die Mauskoordinaten der Lehrerseite an die Schülerseite, und die Computermaus des Schülers bewegt sich in Echtzeit entsprechend den Koordinateninformationen. Dies beinhaltet tatsächlich die Steuerfunktion, und die Schülerseite kann die Maus nicht bewegen.
Die Bildschirmüberwachung ist relativ knifflig. Tatsächlich enthält sie zwei Funktionen:
①Der Lehrer kann die Computerbildschirme aller Schüler überwachen;
②Der Lehrer steuert den Computer eines Schülers.
Da es sich um Parallelität handelt, muss jeder Client Bildschirminformationen in Echtzeit an den Lehrer senden, was etwas mühsam sein wird, aber dennoch erreichbar ist.
Die Bildschirmfreigabefunktion ohne Maus ist hier vorübergehend implementiert. Sie ist relativ einfach und muss verbessert werden, kann aber später als Toolklasse verwendet werden.
Der erste ist der Lehrerserver:
Kopieren Sie den Code wie folgt: package Test;
import java.awt.Dimension;
import java.awt.Rectangle;
java.awt.Robot importieren;
java.awt.Toolkit importieren;
import java.awt.image.BufferedImage;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
java.net.Socket importieren;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
import javax.imageio.ImageIO;
/*
* Juli 20.11.2014
* Diese Art des Sendens von Screenshots in Echtzeit entfällt, Multithread-Implementierung, keine Mausinformationen und keine Optimierung jedes Clients.
*/
Die öffentliche Klasse SendScreenImg erweitert Thread
{
public static int SERVERPORT=8000;
privater ServerSocket serverSocket;
privater Roboterroboter;
öffentlicher Dimensionsbildschirm;
öffentliches Rechteck rect;
private Steckdose;
public static void main(String args[])
{
new SendScreenImg(SERVERPORT).start();
}
//Konstruktionsmethode zum Öffnen des Socket-Verbindungsroboters und zum Abrufen der Bildschirmgröße
public SendScreenImg(int SERVERPORT)
{
versuchen {
serverSocket = new ServerSocket(SERVERPORT);
serverSocket.setSoTimeout(864000000);
robot = new Robot();
} Catch (Ausnahme e) {
e.printStackTrace();
}
screen = Toolkit.getDefaultToolkit().getScreenSize(); //Ermitteln Sie die Größe des Hauptbildschirms
rect = neues Rechteck(Bildschirm); //Konstruieren Sie ein Rechteck in Bildschirmgröße
}
@Override
public void run()
{
//Warten in Echtzeit auf den Empfang von Screenshot-Nachrichten
while(true)
{
versuchen{
socket = serverSocket.accept();
System.out.println("Studentenport ist verbunden");
ZipOutputStream zip = new ZipOutputStream(new DataOutputStream(socket.getOutputStream()));
zip.setLevel(9); //Komprimierungsstufe festlegen
BufferedImage img = robot.createScreenCapture(rect);
zip.putNextEntry(new ZipEntry("test.jpg"));
ImageIO.write(img, "jpg", zip);
if(zip!=null)zip.close();
System.out.println("Client stellt in Echtzeit eine Verbindung her");
} Catch (IOException ioe) {
System.out.println("Verbindung getrennt");
} Endlich {
if (socket != null) {
versuchen {
socket.close();
} Catch (IOException e) {e.printStackTrace();}
}
}
}
}
}
Dann gibt es noch den Studenten-Client:
Kopieren Sie den Code wie folgt: package Test;
java.awt.Frame importieren;
java.awt.Image importieren;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.DataInputStream;
import java.io.IOException;
java.net.Socket importieren;
import java.util.concurrent.TimeUnit;
import java.util.zip.ZipInputStream;
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
/*
* Juli 20.11.2014
* Diese Klasse wird zum Empfangen von Bildschirminformationen auf Lehrerseite verwendet, mit Ausnahme der Maus, und muss optimiert werden.
*/
Die öffentliche Klasse „ReceiveImages“ erweitert Thread{
öffentlicher BorderInit-Frame;
öffentliche Steckdose;
öffentliche String-IP;
public static void main(String[] args){
new ReceiveImages(new BorderInit(), "127.0.0.1").start();
}
public ReceiveImages(BorderInit Frame,String IP)
{
this.frame = Rahmen;
this.IP=IP;
}
public void run() {
while(frame.getFlag()){
versuchen {
socket = neuer Socket(IP,8000);
DataInputStream ImgInput = new DataInputStream(socket.getInputStream());
ZipInputStream imgZip = new ZipInputStream(ImgInput);
imgZip.getNextEntry(); //Gehe zum Anfang des Zip-Dateistreams
Image img = ImageIO.read(imgZip); //Lesen Sie die Bilder im Zip-Bildstream nach Bytes
frame.jlbImg.setIcon(new ImageIcon(img));
System.out.println("Verbindungsnummer"+(System.currentTimeMillis()/1000)%24%60+"Sekunden");
frame.validate();
TimeUnit.MILLISECONDS.sleep(50);//Intervallzeit für den Empfang von Bildern
imgZip.close();
} Catch (IOException | InterruptedException e) {
System.out.println("Verbindung getrennt");
}Endlich{
versuchen {
socket.close();
} Catch (IOException e) {}
}
}
}
}
//Hilfsklasse des Client-Seitenfensters, die speziell zum Anzeigen von Bildschirminformationen verwendet wird, die von der Lehrerseite empfangen werden
Die Klasse BorderInit erweitert JFrame
{
private static final long serialVersionUID = 1L;
öffentliches JLabel jlbImg;
privates boolesches Flag;
öffentlicher boolescher getFlag(){
return this.flag;
}
publicBorderInit()
{
this.flag=true;
this.jlbImg = new JLabel();
this.setTitle("Fernüberwachung--IP:" + "--Topic:" );
this.setSize(400, 400);
//this.setUndecorated(true); //Vollbildanzeige, beim Testen am besten auskommentieren
//this.setAlwaysOnTop(true); //Das Anzeigefenster ist immer vorne
this.add(jlbImg);
this.setLocationRelativeTo(null);
this.setExtendedState(Frame.MAXIMIZED_BOTH);
this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
this.setVisible(true);
this.validate();
//Fensterschließereignis
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
flag=false;
BorderInit.this.dispose();
System.out.println("Formular geschlossen");
System.gc(); //Garbage Collection
}
});
}
}
Hier ist so eine kleine Funktion, die aus dem unfertigen Produkt extrahiert wird. Es gibt noch viel zu schreiben, bevor das fertige Produkt auf dieser Basis verbessert werden kann.
Ich hoffe, dass dieser Artikel für die Java-Programmierung aller hilfreich sein wird.