Das Beispiel in diesem Artikel beschreibt, wie Java Screen Broadcasting durch Steuerung der Maus implementiert. Teilen Sie es als Referenz mit allen. Die spezifische Analyse lautet wie folgt:
Im vorherigen Artikel „Analyse von Beispielen für die Implementierung der Bildschirmfreigabefunktion in Java“ wurde erwähnt, dass beim Erfassen des Bildschirms keine Maus vorhanden ist. Um die Maus auf der Lehreroberfläche anzuzeigen, können Sie die Maus zu jedem Screenshot ziehen Da die Screenshots jedoch einzeln aufgenommen werden, bleibt die Maus, die Sie sehen, zwangsläufig etwas hängen. Ich habe zuvor ein Java-Maussteuerungs-Applet geschrieben, und Sie können die Mausdemonstration auf diese Weise sehen.
Die Implementierungsmethode ist ebenfalls recht einfach. In den beiden vorherigen Artikeln wurden Maussteuerungs- und Bildschirmfreigabefunktionen ohne Maus implementiert. Lassen Sie uns dies im Folgenden kurz analysieren.
Auf der Serverseite werden SendScreenImg und SendMouseMessage als zwei Toolklassen betrachtet, die jeweils unterschiedliche Ports überwachen. Beide implementieren die Thread-Klasse und wir verwenden die Thread-Pool-Klasse ExecutorService, um sie zu steuern.
Es werden zwei Ports verwendet, da ich noch nicht weiß, wie ich die Mausinformationen und die Bildinformationen zusammen senden soll. Vielleicht kann ich das Bild in ein Byte-Array umwandeln und die Mauskoordinaten vor das Array setzen, aber in diesem Fall Maus möglicherweise nicht Es wird inkohärent sein, da die Geschwindigkeit der Übertragung von Mauskoordinaten schneller ist als die von Bildern. Versuchen Sie es erneut, wenn Sie Zeit haben.
Die Client-Analogie ist die gleiche wie oben.
Hier ist der Code:
Server:
Hauptprogramm:
Kopieren Sie den Codecode wie folgt:/*
* Die Screen-Broadcast-Klasse ruft zwei Tool-Klassen auf: eine Klasse zum Senden von Screenshot-Informationen und eine Klasse zum Senden von Maus-Informationen unter Verwendung des Thread-Pools.
*/
öffentliche Klasse BroderCast {
public static void main(String[] args)
{
new BroderCast();
System.out.println("Start");
}
öffentlicher BroderCast()
{
ExecutorService exector = Executors.newFixedThreadPool(2);
exector.execute(new SendScreenImg());
exector.execute(new SendMouseMessage());
}
}
Screenshot-Code senden:
Kopieren Sie den Code wie folgt: 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;
/*
* Tools: Screenshot-Informationen von der Lehrerseite an die Schülerseite senden. Es gibt keine Mausinformationen und es wird Port 8002 verwendet.
* Die Mausinformationen können auf die Komponente des gesendeten Bildes gezeichnet werden, sodass die Mausinformationen auf der Schüleroberfläche angezeigt werden können. Diese Funktion wurde noch nicht implementiert.
*
*/
Die öffentliche Klasse SendScreenImg erweitert Thread
{
public int serverPort=8002;
privater ServerSocket serverSocket;
privater Roboterroboter;
öffentlicher Dimensionsbildschirm;
öffentliches Rechteck rect;
private Steckdose;
public static void main(String args[])
{
new SendScreenImg().start();
}
public void changeServerPort(int serverPort)
{
if(this.serverPort == serverPort) return;
versuchen{
this.serverSocket.close(); //Es ist notwendig, zuerst den aktuellen Port zu schließen
this.serverPort = serverPort;
serverSocket = new ServerSocket(this.serverPort);
serverSocket.setSoTimeout(8000000);
}catch(Ausnahme e){}
}
//Konstruktionsmethode zum Öffnen des Socket-Verbindungsroboters und zum Abrufen der Bildschirmgröße
public SendScreenImg()
{
versuchen {
serverSocket = new ServerSocket(getServerPort());
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 entsprechender Größe
}
@Override
public void run()
{
//Warten in Echtzeit auf den Empfang von Screenshot-Nachrichten
while(true){
versuchen {
socket = serverSocket.accept();
ZipOutputStream zip = new ZipOutputStream(new DataOutputStream(socket.getOutputStream()));
zip.setLevel(9); //Komprimierungsstufe festlegen
versuchen{
BufferedImage img = robot.createScreenCapture(rect);
zip.putNextEntry(new ZipEntry("test.jpg"));
ImageIO.write(img, "jpg", zip);
if(zip!=null)zip.close();
System.out.println("Studentenport ist verbunden");
} Catch (IOException ioe) {
System.out.println("kontrolliertes Terminal: Verbindung trennen");
}
} Catch (IOException ioe) {
System.out.println("Verbindungsfehler");
} Endlich {
if (socket != null) {
versuchen {
socket.close();
} Catch (IOException e) {
}
}
}
}
}
}
Mausinformationen senden:
Kopieren Sie den Codecode wie folgt:/*
* Werkzeugklasse: Mausinformationen abrufen und an das Schülerterminal senden
*/
öffentliche Klasse SendMouseMessage erweitert Thread{
private int OPERATE_PORT = 8001;
privater ServerSocket-Server;
private Steckdose;
private String OperateStr;
public static void main(String[] args)
{
new SendMouseMessage().start();
}
öffentliche SendMouseMessage(){
versuchen {
server = new ServerSocket(OPERATE_PORT);
//JOptionPane.showMessageDialog(null, "hat begonnen zuzuhören");
} Catch (IOException e1) {
e1.printStackTrace();
}
}
//Mehrere Threads überwachen den Client in einer drahtlosen Schleife
public void run()
{
while(true){
Punkt point = MouseInfo.getPointerInfo().getLocation();
operaStr = "Movemouse,"+point.x+","+point.y;
versuchen {
socket = server.accept();
socket.setSoTimeout(1000000);
DataOutputStream-Ausgabe =new DataOutputStream(socket.getOutputStream());
Output.write(operateStr.getBytes());
Output.flush(); //Leere den Ausgabestream und schreibe alle gepufferten Ausgabebytes aus
Output.close(); //Schließen Sie den Ausgabestream und geben Sie Ressourcen frei
System.out.println("INFO: "+operateStr);
} Catch (IOException e) {
System.out.println("Verbindung wurde unterbrochen");
break; // Stoppen Sie die drahtlose Schleife, wenn Sie die Verbindung trennen
}
}
}
}
Kunde:
Hauptprogramm:
Kopieren Sie den Code wie folgt: import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import com.Tool.OperateMouse;
import com.Tool.ReceiveImages;
öffentliche Klasse ReceiveBroderCast {
öffentlicher ExecutorService-Exektor;
öffentlicher statischer String IP="202.216.60.9";
public static void main(String[] args)
{
new ReceiveBroderCast(IP);
}
public ReceiveBroderCast(String IP) {
exector = Executors.newFixedThreadPool(2);
exector.execute(new ReceiveImages(IP));
exector.execute(new OperateMouse(IP));
}
}
Screenshot-Code erhalten:
Kopieren Sie den Codecode wie folgt:/*
* Juli 20.11.2014
* Diese Klasse wird zum Empfangen von Bildschirminformationen von der Lehrerseite verwendet, mit Ausnahme der Maus
* Socket() verwenden
*/
Die öffentliche Klasse „ReceiveImages“ erweitert Thread{
öffentlicher BorderInit-Frame;
öffentliche Steckdose;
öffentliche String-IP;
public static void main(String[] args){
new ReceiveImages("202.216.60.7").start();
}
publicReceiveImages(String IP)
{
frame=new BorderInit();
this.IP=IP;
}
public void run() {
while(frame.getFlag()){
System.out.println("Connected"+(System.currentTimeMillis()/1000)%24%60+"seconds");
versuchen {
socket = neuer Socket(IP,8002);
DataInputStream ImgInput = new DataInputStream(socket.getInputStream());
ZipInputStream imgZip = new ZipInputStream(ImgInput);
Bild img = null;
versuchen{
imgZip.getNextEntry(); //Gehe zum Anfang des Zip-Dateistreams
img = ImageIO.read(imgZip); //Lesen Sie die Bilder im Zip-Bildstream nach Bytes
frame.jlbImg.setIcon(new ImageIcon(img));
frame.validate();
}catch (IOException e) {e.printStackTrace();}
versuchen{
imgZip.close();
} Catch (IOException e) {
System.out.println("Verbindung getrennt");
}
versuchen {
TimeUnit.MILLISECONDS.sleep(50);//Intervallzeit für den Empfang von Bildern
} Catch (InterruptedException ie) {
dh.printStackTrace();
}
} Catch (IOException e) {
e.printStackTrace();
}Endlich{
versuchen {
socket.close();
} Catch (IOException e) {}
}
}
}
}
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);
//this.setAlwaysOnTop(true); //Immer im Vordergrund
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
}
});
}
}
Erhalten Sie Mausinformationen und steuern Sie die Mausbewegung:
Kopieren Sie den Code wie folgt: import java.awt.AWTException;
java.awt.Robot importieren;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
java.net.Socket importieren;
import javax.swing.JOptionPane;
/*
* Die Maussteuerung auf der Schülerseite ist die gleiche wie auf der Lehrerseite
* Diese Klasse ist für den Empfang von Mausinformationen und die Steuerung der Mausbewegung mithilfe der Funktion robot.mouseMove() verantwortlich
*/
öffentliche Klasse OperateMouse erweitert Thread{
public static void main(String[] args)
{
new OperateMouse("202.116.60.7").start();
}
private Steckdose;
öffentliche String-IP;
private int OPERATE_PORT = 8001;
privater Roboterroboter;
public OperateMouse(String IP)
{
this.IP = IP;
}
public void run() {
while(true){
versuchen {
socket = new Socket(IP,OPERATE_PORT);
robot = new Robot();
//Mausbewegungsinformationen abrufen
DataInputStream dataIn = new DataInputStream(socket.getInputStream());
String info="";
int r;
while((r=dataIn.read()) != -1){
info +=""+(char)r; //Konvertieren Sie alle Elemente im Byte-Array in den Zeichentyp
}
dataIn.close();
System.out.println("Datenfluss getrennt"+info);
if(info!=null){
String s[] = info.trim().split(",");
if("Movemouse".equals(s[0].trim()));
{
if (s. Länge == 3) {
int x = Integer.parseInt(s[1].trim());
int y = Integer.parseInt(s[2].trim());
System.out.println("Mausinformationen ausgeben"+x+" "+ y);
robot.mouseMove(x, y);
}
}
}
} Catch (IOException e) {
System.out.println("Disconnected");
brechen;
} Catch (AWTException e) {
e.printStackTrace();
}
}
}
}
Ich hoffe, dass dieser Artikel für die Java-Programmierung aller hilfreich sein wird.