L'exemple de cet article décrit comment Java implémente la diffusion d'écran en contrôlant la souris. Partagez-le avec tout le monde pour votre référence. L’analyse spécifique est la suivante :
Dans l'article précédent "Analyse des exemples d'implémentation de la fonction de partage d'écran en Java", il a été mentionné qu'il n'y avait pas de souris lors de la capture d'écran. Afin de voir la souris sur l'interface du professeur, vous pouvez dessiner la souris sur chaque capture d'écran lors de la capture d'écran. capturer l'écran.Cependant, comme les captures d'écran sont prises une par une, la souris que vous voyez sera inévitablement un peu bloquée. J'ai déjà écrit une applet de contrôle de souris Java, et vous pouvez voir la démonstration de la souris de cette façon.
La méthode de mise en œuvre est également assez simple. Les deux articles précédents implémentaient respectivement les fonctions de contrôle de la souris et de partage d'écran sans souris. Analysons-les brièvement ci-dessous.
Côté serveur, SendScreenImg et SendMouseMessage sont considérés comme deux classes d'outils, écoutant respectivement des ports différents implémentant la classe Thread, et nous utilisons la classe ExecutorService du pool de threads pour les contrôler.
Deux ports sont utilisés, car je ne sais pas encore comment envoyer les informations de la souris et les informations de l'image ensemble. Peut-être que je peux convertir l'image en un tableau d'octets et placer les coordonnées de la souris devant le tableau, mais dans ce cas, le la souris ne le sera peut-être pas. Ce sera incohérent, car la vitesse de transmission des coordonnées de la souris sera plus rapide que celle des images. Eh bien, réessayez lorsque vous aurez le temps.
L’analogie avec le client est la même que ci-dessus.
Voici le code :
Serveur:
Programme principal :
Copiez le code comme suit :/*
* La classe de diffusion d'écran appelle deux classes d'outils : une classe pour envoyer des informations de capture d'écran et une classe pour envoyer des informations de souris, en utilisant le pool de threads.
*/
classe publique BroderCast {
public static void main (String[] arguments)
{
new BroderCast();
System.out.println("Démarrer");
}
BroderCast public()
{
ExecutorService exector = Executors.newFixedThreadPool(2);
exector.execute(nouveau SendScreenImg());
exector.execute(nouveau SendMouseMessage());
}
}
Envoyer le code de capture d'écran :
Copiez le code comme suit : import java.awt.Dimension;
importer java.awt.Rectangle ;
importer java.awt.Robot ;
importer java.awt.Toolkit ;
importer java.awt.image.BufferedImage ;
importer java.io.DataOutputStream ;
importer java.io.IOException ;
importer java.net.ServerSocket ;
importer java.net.Socket ;
importer java.util.zip.ZipEntry ;
importer java.util.zip.ZipOutputStream ;
importer javax.imageio.ImageIO ;
/*
* Outils : envoyer des informations de capture d'écran du côté enseignant au côté étudiant. Il n'y a aucune information sur la souris et le port 8002 est utilisé.
* Les informations de la souris peuvent être dessinées sur le composant de l'image envoyée, afin que les informations de la souris soient visibles sur l'interface étudiant. Cette fonction n'a pas encore été implémentée.
*
*/
la classe publique SendScreenImg étend le fil de discussion
{
public int serverPort=8002 ;
ServerSocket privé serverSocket ;
privé Robot robot;
écran de dimension publique ;
public Rectangle rect;
prise privée;
public static void main (String args[])
{
nouveau SendScreenImg().start();
}
public void changeServerPort (int serverPort)
{
if(this.serverPort == serverPort) return ;
essayer{
this.serverSocket.close(); //Il faut d'abord fermer le port actuel
this.serverPort = serverPort;
serverSocket = nouveau ServerSocket(this.serverPort);
serverSocket.setSoTimeout(8000000);
}attraper(Exception e){}
}
//Méthode de construction pour ouvrir le robot de connexion socket et obtenir la taille de l'écran
public SendScreenImg()
{
essayer {
serverSocket = nouveau ServerSocket(getServerPort());
serverSocket.setSoTimeout(864000000);
robot = nouveau Robot();
} attraper (Exception e) {
e.printStackTrace();
}
screen = Toolkit.getDefaultToolkit().getScreenSize(); //Obtenir la taille de l'écran principal
rect = new Rectangle(screen); //Construit un rectangle de taille correspondante
}
@Outrepasser
exécution publique vide()
{
//Attente en temps réel de recevoir des messages de capture d'écran
tandis que(vrai){
essayer {
socket = serverSocket.accept();
ZipOutputStream zip = new ZipOutputStream(new DataOutputStream(socket.getOutputStream()));
zip.setLevel(9); //Définir le niveau de compression
essayer{
BufferedImage img = robot.createScreenCapture(rect);
zip.putNextEntry(new ZipEntry("test.jpg"));
ImageIO.write(img, "jpg", zip);
if(zip!=null)zip.close();
System.out.println("Le port étudiant est connecté");
} catch (IOException ioe) {
System.out.println("terminal contrôlé : déconnexion");
}
} catch (IOException ioe) {
System.out.println("Erreur de connexion");
} enfin {
si (socket != nul) {
essayer {
socket.close();
} catch (IOException e) {
}
}
}
}
}
}
Envoyer les informations de la souris :
Copiez le code comme suit :/*
* Classe d'outils : obtenez les informations de la souris et envoyez-les au terminal étudiant
*/
la classe publique SendMouseMessage étend Thread{
privé int OPERATE_PORT = 8001 ;
serveur ServerSocket privé ;
prise privée;
chaîne privée operaStr ;
public static void main (String[] arguments)
{
nouveau SendMouseMessage().start();
}
public SendMouseMessage(){
essayer {
serveur = nouveau ServerSocket(OPERATE_PORT);
//JOptionPane.showMessageDialog(null, "a commencé à écouter");
} catch (IOException e1) {
e1.printStackTrace();
}
}
//Plusieurs threads surveillent le client dans une boucle sans fil
exécution publique vide()
{
tandis que(vrai){
Point point = MouseInfo.getPointerInfo().getLocation();
operaStr = "Movemouse,"+point.x+","+point.y;
essayer {
socket = serveur.accepter();
socket.setSoTimeout(1000000);
Sortie DataOutputStream =new DataOutputStream(socket.getOutputStream());
sortie.write(operateStr.getBytes());
output.flush(); // Vider le flux de sortie et écrire tous les octets de sortie mis en mémoire tampon
output.close(); //Ferme le flux de sortie et libère les ressources
System.out.println("INFO: "+operateStr);
} catch (IOException e) {
System.out.println("La connexion s'est arrêtée");
break; //Arrêtez la boucle sans fil lors de la déconnexion
}
}
}
}
Client:
Programme principal :
Copiez le code comme suit : import java.util.concurrent.ExecutorService ;
importer java.util.concurrent.Executors ;
importer com.Tool.OperateMouse ;
importer com.Tool.ReceiveImages ;
classe publique RecevoirBroderCast {
exécuteur public ExecutorService ;
chaîne statique publique IP="202.216.60.9" ;
public static void main (String[] arguments)
{
nouveau RecevoirBroderCast(IP);
}
public RecevoirBroderCast (String IP) {
exector = Executors.newFixedThreadPool(2);
exector.execute (nouveau RecevoirImages (IP));
exector.execute (nouveau OperateMouse (IP));
}
}
Recevoir le code de capture d'écran :
Copiez le code comme suit :/*
* juillet 2014-11-20
* Cette classe permet de recevoir des informations à l'écran du côté de l'enseignant, hors souris.
* Utilisez socket()
*/
la classe publique ReceiverImages étend Thread{
cadre public BorderInit ;
prise publique;
IP de chaîne publique ;
public static void main (String[] args){
nouveau RecevoirImages("202.216.60.7").start();
}
publicReceiveImages (chaîne IP)
{
frame=nouveau BorderInit();
ceci.IP=IP ;
}
public void run() {
tandis que(frame.getFlag()){
System.out.println("Connecté"+(System.currentTimeMillis()/1000)%24%60+"secondes");
essayer {
socket = nouveau Socket(IP,8002);
DataInputStream ImgInput = new DataInputStream(socket.getInputStream());
ZipInputStream imgZip = nouveau ZipInputStream(ImgInput);
Image img = nulle ;
essayer{
imgZip.getNextEntry(); //Aller au début du flux du fichier Zip
img = ImageIO.read(imgZip); //Lire les images dans le flux d'images Zip en fonction des octets
frame.jlbImg.setIcon(new ImageIcon(img));
frame.validate();
}catch (IOException e) {e.printStackTrace();}
essayer{
imgZip.close();
} catch (IOException e) {
System.out.println("Connexion déconnectée");
}
essayer {
TimeUnit.MILLISECONDS.sleep(50);//Intervalle de réception des images
} catch (InterruptedException, c'est-à-dire) {
c'est à dire.printStackTrace();
}
} catch (IOException e) {
e.printStackTrace();
}enfin{
essayer {
socket.close();
} catch (IOException e) {}
}
}
}
}
la classe BorderInit étend JFrame
{
privé statique final long serialVersionUID = 1L ;
public JLabel jlbImg;
drapeau booléen privé ;
public booléen getFlag(){
renvoie ce.flag ;
}
publicBorderInit()
{
this.flag=true ;
this.jlbImg = new JLabel();
this.setTitle("Surveillance à distance--IP:" + "--Topic:" );
this.setSize(400, 400);
//this.setUndecorated(true);
//this.setAlwaysOnTop(true); //Toujours au top
this.add(jlbImg);
this.setLocationRelativeTo(null);
this.setExtendedState(Frame.MAXIMIZED_BOTH);
this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
this.setVisible(true);
this.validate();
//événement de fermeture de fenêtre
this.addWindowListener(new WindowAdapter() {
public void windowClosing (WindowEvent e) {
drapeau = faux ;
BorderInit.this.dispose();
System.out.println("Formulaire fermé");
Système.gc(); //collecte des déchets
}
});
}
}
Recevez des informations sur la souris et contrôlez les mouvements de la souris :
Copiez le code comme suit : import java.awt.AWTException;
importer java.awt.Robot ;
importer java.io.BufferedInputStream ;
importer java.io.BufferedReader ;
importer java.io.DataInputStream ;
importer java.io.IOException ;
importer java.io.InputStream ;
importer java.net.Socket ;
importer javax.swing.JOptionPane ;
/*
* Le contrôle de la souris côté étudiant est le même que celui côté professeur
* Cette classe est responsable de la réception des informations sur la souris et du contrôle des mouvements de la souris à l'aide de la fonction robot.mouseMove()
*/
la classe publique OperateMouse étend Thread{
public static void main (String[] arguments)
{
new OperateMouse("202.116.60.7").start();
}
prise privée;
IP de chaîne publique ;
privé int OPERATE_PORT = 8001 ;
privé Robot robot;
public OperateMouse (chaîne IP)
{
ceci.IP = IP ;
}
public void run() {
tandis que(vrai){
essayer {
socket = nouveau Socket(IP,OPERATE_PORT);
robot = nouveau Robot();
//Obtenir des informations sur les mouvements de la souris
DataInputStream dataIn = new DataInputStream(socket.getInputStream());
Chaîne info="";
int r;
while((r=dataIn.read()) != -1){
info +=""+(char)r; //Convertir tous les éléments du tableau d'octets en type caractère
}
dataIn.close();
System.out.println("Flux de données déconnecté"+info);
si(info!=null){
Chaîne s[] = info.trim().split(",");
if("Movemouse".equals(s[0].trim()));
{
si (s. longueur == 3) {
int x = Integer.parseInt(s[1].trim());
int y = Integer.parseInt(s[2].trim());
System.out.println("Informations de sortie de la souris"+x+" "+ y);
robot.mouseMove(x, y);
}
}
}
} catch (IOException e) {
System.out.println("Déconnecté");
casser;
} catch (AWTException e) {
e.printStackTrace();
}
}
}
}
J'espère que cet article sera utile à la programmation Java de chacun.