L'exemple de cet article décrit comment implémenter la fonction de partage d'écran en Java. Partagez-le avec tout le monde pour votre référence. L’analyse spécifique est la suivante :
Récemment, je conçois un cours de génie logiciel, je crée un système de surveillance d'écran pour le laboratoire, je me réfère à divers codes précédents et enfin je convertis mon propre code après l'avoir compris. C'est ainsi que les débutants l'imitent.
En ce qui concerne le système de surveillance d'écran, il existe un côté enseignant et un côté étudiant. Le côté enseignant est le côté serveur et le côté étudiant est le côté client. L'un des aspects les plus intéressants du système est probablement la diffusion et la surveillance de l'écran. Le reste de l'appel, le verrouillage de l'écran et l'arrêt programmé sont relativement simples.
La diffusion sur écran, en termes de mise en œuvre des fonctions, pour parler franchement, signifie que la machine de l'enseignant intercepte en permanence les informations de l'écran et les envoie à l'ordinateur de chaque élève sous forme d'images, afin que les élèves puissent voir les opérations de l'enseignant sur l'ordinateur. ce qu'on appelle la diffusion sur écran.
Il y a une chose gênante ici, c'est-à-dire que lors de la capture d'écran de l'écran, il n'y a aucune information sur la souris. Mais il y a deux solutions :
① Lors de l'envoi d'informations de capture d'écran, dessinez une souris sur l'image, de sorte qu'il y ait deux souris du côté étudiant, et que le côté étudiant puisse déplacer la souris sur son propre ordinateur.
②Envoyez les coordonnées de la souris du côté de l'enseignant au côté de l'élève, et la souris de l'ordinateur de l'élève se déplace en temps réel en fonction des informations de coordonnées. Cela implique en fait la fonction de contrôle, et le côté de l'élève ne peut pas déplacer la souris.
La surveillance d'écran est relativement délicate. En fait, elle contient deux fonctions :
①L'enseignant peut surveiller les écrans d'ordinateur de tous les élèves ;
②L'enseignant contrôle l'ordinateur d'un élève ;
Parce qu'il s'agit de concurrence, chaque client doit envoyer des informations d'écran à l'enseignant en temps réel, ce qui sera un peu gênant, mais cela peut quand même être réalisé.
La fonction de partage d'écran sans souris est temporairement implémentée ici. Elle est relativement simple et doit être améliorée, mais elle peut être utilisée comme classe d'outils pour une intégration ultérieure.
Le premier est le serveur enseignant :
Copiez le code comme suit : package Test ;
importer 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 ;
/*
* juillet 2014-11-20
* Ce type d'envoi de captures d'écran en temps réel disparaît, implémentation multithread, n'inclut pas les informations de la souris et n'optimise pas chaque Client.
*/
la classe publique SendScreenImg étend le fil de discussion
{
public statique int SERVERPORT=8000 ;
ServerSocket privé serverSocket ;
privé Robot robot;
écran de dimension publique ;
public Rectangle rect;
prise privée;
public static void main (String args[])
{
new SendScreenImg(SERVERPORT).start();
}
//Méthode de construction pour ouvrir le robot de connexion socket et obtenir la taille de l'écran
public SendScreenImg (int SERVERPORT)
{
essayer {
serverSocket = nouveau ServerSocket (SERVERPORT);
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 la taille d'un écran
}
@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();
System.out.println("Le port étudiant est connecté");
ZipOutputStream zip = new ZipOutputStream(new DataOutputStream(socket.getOutputStream()));
zip.setLevel(9); //Définir le niveau de compression
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 client se connecte en temps réel");
} catch (IOException ioe) {
System.out.println("Connexion déconnectée");
} enfin {
si (socket != nul) {
essayer {
socket.close();
} catch (IOException e) {e.printStackTrace();}
}
}
}
}
}
Ensuite, il y a le client étudiant :
Copiez le code comme suit : package Test ;
importer java.awt.Frame ;
importer java.awt.Image ;
importer java.awt.event.WindowAdapter ;
importer java.awt.event.WindowEvent ;
importer java.io.DataInputStream ;
importer java.io.IOException ;
importer java.net.Socket ;
importer java.util.concurrent.TimeUnit ;
importer java.util.zip.ZipInputStream ;
importer javax.imageio.ImageIO ;
importer javax.swing.ImageIcon ;
importer javax.swing.JFrame ;
importer javax.swing.JLabel ;
/*
* juillet 2014-11-20
* Cette classe permet de recevoir des informations sur écran du côté de l'enseignant, hors souris, et doit être optimisée.
*/
la classe publique ReceiverImages étend Thread{
cadre public BorderInit ;
prise publique;
IP de chaîne publique ;
public static void main (String[] args){
new ReceiverImages(new BorderInit(), "127.0.0.1").start();
}
images de réception publiques (cadre BorderInit, chaîne IP)
{
this.frame = cadre ;
ceci.IP=IP ;
}
public void run() {
tandis que(frame.getFlag()){
essayer {
socket = nouveau Socket(IP,8000);
DataInputStream ImgInput = new DataInputStream(socket.getInputStream());
ZipInputStream imgZip = nouveau ZipInputStream(ImgInput);
imgZip.getNextEntry(); //Aller au début du flux du fichier Zip
Image img = ImageIO.read(imgZip); //Lire les images dans le flux d'images Zip en fonction des octets
frame.jlbImg.setIcon(new ImageIcon(img));
System.out.println("Numéro de connexion"+(System.currentTimeMillis()/1000)%24%60+"secondes");
frame.validate();
TimeUnit.MILLISECONDS.sleep(50);//Intervalle de réception des images
imgZip.close();
} catch (IOException | InterruptedException e) {
System.out.println("Connexion déconnectée");
}enfin{
essayer {
socket.close();
} catch (IOException e) {}
}
}
}
}
//Classe auxiliaire de fenêtre côté client, spécialement utilisée pour afficher les informations d'écran reçues du côté enseignant
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); //Affichage plein écran, il est préférable de commenter lors des tests
//this.setAlwaysOnTop(true); //La fenêtre d'affichage est toujours à l'avant
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
}
});
}
}
Voici une si petite fonction extraite du produit inachevé. Il reste encore beaucoup à écrire avant que les amis intéressés puissent l'améliorer sur cette base.
J'espère que cet article sera utile à la programmation Java de chacun.