Lassen Sie uns eine Kommunikationsanwendung in LAN Teil 2 erstellen. Zeigen Sie ein Fenster mit JavaFX an / Warten Sie auf den Socket-Empfang

Durch den Versuch, den Rhythmus des Lebens zu verbessern, aber eines Tages nicht zu töten, wird auch die Arbeitszeit verkürzt.

Übrigens werden wir diesmal den UI-Teil mit JavaFX erstellen. Dann machen wir den Standby-Teil für die Kommunikation. ** Ich habe keine Zeit! (Alles rächt sich irgendwann)**

Erstellen Sie eine Benutzeroberfläche mit JavaFX.

Was ist JavaFX?

Kurz gesagt, es ist eine "GUI-Zeichnungsbibliothek für Java".

Das Feature ist, dass das Design in XML und CSS beschrieben wird. Darüber hinaus ist dies sehr einfach, da Sie eine Anwendung namens SceneBuilder verwenden können, die per Drag & Drop kostenlos erstellt werden kann. Irgendwie kann es auf der RIA-Plattform verwendet werden.

Informationen zu Geschichte und Geschichte finden Sie unter Siehe dieses Wiki.

Machen Sie den Hauptbildschirm

Lassen Sie uns das Hauptfenster mit dem obigen Scene Builder erstellen.

Unter Berücksichtigung von Mr. IP Messanger sieht es so aus

Wenn dies ausgegeben wird, wird eine Datei im FXML-Format ausgegeben. Dieses Mal haben wir es Hauptbühne genannt, weil es der Hauptbildschirm (Bühne) ist. Erstellen wir ein Speicherverzeichnis und fügen es in die Quelle ein.

Im obigen Bild wird auch MainStage.java gespeichert, dies ist jedoch eine separat erstellte. Im Gegensatz zu C # Form ist FXML eine Datei, die die Struktur (und Informationen zur Ereignishandler) aufzeichnet Es ist erforderlich, die Java-Quelle für die Verarbeitung separat zu erstellen.

Es scheint besser zu denken, dass dieser Bereich wie ein MVC-Modell unterteilt ist.

Es kann besser sein, die Dateien nach Kontrolle und Ansicht zu teilen ...

Ich möchte es vorerst nennen.

Ich möchte die erstellte FXML vorerst aufrufen.

Ich habe verschiedene Dinge recherchiert, kann aber nur eine Vorlage für das JavaFX-Projekt finden. Insbesondere wird nur beschrieben, wie der Bildschirm mit der Methode _main () aufgerufen wird.

Dieses Mal möchte ich es von einer anderen Hauptmethode aus aufrufen, also habe ich verschiedene Dinge überprüft. Die Seiten hier waren hilfreich

• Oracle - Javaafx Documentation Class Application (Japanisch)
• Oracle --Javafx Documentation Class Parent (Japanisch)
• Oracle --Javafx Documentation Class FXMLLoader (Japanisch)
• Oracle --Javafx Documentation Class Scene (Japanisch)
• Oracle --Javafx Documentation Class Stage (Japanisch) )

Als grobes Verständnis ist die Anwendung die Hauptverwaltung von Stage (kann wie ein Fenster behandelt werden). Bühne zeichnet eine Szene. Die Szene besteht aus verschiedenen Knoten, die in Parent gespeichert sind. Ist es so

Das spezifische Verfahren ist wie folgt.

1. Bereiten Sie eine Klasse vor, die javafx.application.Application erbt.
2. Essen Sie die Anwendungsvererbungsmethode, die in der Methode javafx.application.Application.launch vorbereitet wurde.

Machen wir es konkret.

1. Bereiten Sie eine Klasse vor, die javafx.application.Application erbt.

Das ist einfach.

MainStage.java

package kugui.owd.privateMessenger.stage;

import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.stage.Stage;

public class MainStage extends Application {
	
	@Override
	public void start(Stage stage) throws Exception{
		
		Parent root = FXMLLoader.load(getClass().getResource(
				getClass().getSimpleName() + ".fxml" )
				);
		
		Scene scene = new Scene(root);
		stage.setScene(scene);
		
		stage.show();
		
		return;
	}
	
	
}

Das erste, worauf Sie achten müssen, ist das Überschreiben der start () -Methode. Es scheint, dass die an Application.launch () übergebene Vererbungsmethode für Anwendungen gemäß ihrem eigenen Lebenszyklus ausgeführt wird.

So sieht es in einfachem Schreiben aus

Beim Aufruf von

public void init()

public void start()

Am Ende

public void stop()

Init () wurde ursprünglich implementiert, aber start () wird als abstrakte Klasse deklariert, sodass es nicht ohne Override erstellt werden kann. Grundsätzlich sollte der Initialisierungsprozess zum Zeitpunkt des Starts () erfolgen.

Der Verarbeitungsablauf des obigen Codes ist wie folgt.

1. Generieren Sie eine übergeordnete Instanz (übergeordnet) mit der Methode FXMKLoader.load () basierend auf der Datei fxml.
2. Erstellt basierend auf der übergeordneten Instanz, die die Szeneninstanz (Szene) erstellt hat.
3. Führen Sie die erstellte Szeneninstanz (Szene) in den von der Anwendung übergebenen Stage-Typparameter (Stage) ein.
4. Verwenden Sie zum Zeichnen die Methode stage.show ().

Es gibt viele Beispiele, die die Verarbeitung in derselben Klasse beschreiben, sodass sie möglicherweise nicht so häufig stolpert.

2. Essen Sie die Anwendungsvererbungsmethode, die in der Methode javafx.application.Application.launch vorbereitet wurde.

Da die geerbte Anwendungsklasse vorerst vorbereitet wurde, legen Sie den Anrufer als Nächstes fest.

Ich habe ppa.java ein wenig hinzugefügt, der es im vorherigen Artikel verlassen hat.

ppa.java

public class Ppa
{
	public static void main( String[] args) {
		System.out.println( "Good night World");
		
		Application.launch(MainStage.class, args);

		return;
	}
}

Application.launcher () scheint die folgenden Einschränkungen zu haben.

• Kann nicht mehrmals aufgerufen werden.
• Kann nicht von einer geerbten Klasse aufgerufen werden (RuntimeException wird ausgelöst)

Dann muss man sich ein wenig überlegen, wie man es umsetzt.

Dieser launch () ist übrigens eine synchrone Methode. Wenn Sie danach einen Prozess schreiben, wird dieser ausgeführt, nachdem das Fenster geschlossen wurde.

Wenn ich hier bin, werde ich es vorerst anzeigen.

Jep. Bisher scheint es kein Problem zu geben.

Erstellen Sie einen Standby-Thread.

Um ehrlich zu sein, habe ich noch nie ein Multithread-Programm erstellt. Zumindest habe ich es nie als eingebettetes Gerät gesehen. Weil es in Ordnung ist, mehrere Prozesse einzubauen, und IRQ häufiger als IPC ist. Oh, ich habe es nicht in Frameware gesehen.

Es ist ein Eindruck, dass Sie Morimori verwenden, wenn es um Spiele geht. Es ist eine große Sache, also gewöhnen wir uns hier daran.

Es ist natürlich, dass Dinge, die nicht getan wurden, besser werden. Aber wenn Sie es tun, gibt es nichts. Die Welt besteht aus solchen Dingen.

Bereiten Sie eine Klasse für die Ausführung als Thread vor

Wie funktioniert es als Thread?

Die Verwendung von Threads wird grob wie folgt zusammengefasst.

1. Erstellen Sie eine Klasse, die das Threading unterstützt.
2. Implementieren Sie den Aufruf des Threads.

Es ist einfach. Lass es uns machen.

1. Erstellen Sie eine Klasse, die das Threading unterstützt.

Es gibt zwei Möglichkeiten, eine "Thread-Klasse" in Java zu erstellen.

• Erstellen Sie eine Klasse, indem Sie die Thread-Klasse erben.
• Implementieren Sie die Runnable-Schnittstelle, um eine Klasse zu erstellen.

Was ist der Unterschied? Es scheint, dass die Operation die gleiche ist. Verwenden Sie aufgrund von Java-Sprachspezifikationen, die keine Mehrfachvererbung zulassen, die Runnable-Schnittstelle, wenn Sie andere Klassen erben und Threads erstellen möchten! Es scheint, dass.

Erstellen Sie jetzt eine neue Standby-Thread-Klasse RxThread, indem Sie die Java.lang.Thread-Klasse erben. Die Thread-Klasse kann übrigens ohne Import verwendet werden.

RxThread.java

package kugui.owd.privateMessenger;


public class RxThread extends Thread{
	
	public void run() {
		
		int countPray = 0;
		
		try {
			while(true) {
				
				System.out.println(String.format("%2d : please let me see the good dream...", countPray));
				Thread.sleep(1000);
				
				countPray++;
			}
		}catch(InterruptedException ie ) {
			
			/* no operation */
			
		}catch(Exception ex) {
			
			ex.printStackTrace();
			
		}
		
		return;
	}
	
}

Mit Schleifenverarbeitung zur Überprüfung der Operation.

Es scheint, dass Thread auch so etwas wie einen Lebenszyklus hat ... und die void run () -Methode wird aufgerufen, wenn der Thread ausgeführt wird. Implementieren Sie also die run () -Methode und beschreiben Sie den Prozess. Ich habe nach einer Beschreibung gesucht, die andere Methoden aufrufen würde, konnte sie jedoch nicht finden. Daher scheint es notwendig zu sein, zu schreiben, um von run () von der Initialisierung bis zur Beendigungsverarbeitung aufzurufen.

2. Implementieren Sie den Aufruf des Threads.

ppa.java Fügen Sie Ihrer main () -Methode die folgende Verarbeitung hinzu

1. Erstellen Sie eine Instanz der von Ihnen erstellten Thread-Klasse.
2. Generieren Sie, indem Sie die Thread-Klasse füttern, die die Thread-Klasse generiert hat.
3. Rufen Sie die Methode thread.start () auf, um den Thread zu starten.
4. Senden Sie eine Interrupt-Warteschlange an den Thread (nachdem Sie das Sendefenster gelöscht haben).

ppa.java

	public static void main( String[] args) {
		
		RxThread rxThread = new RxThread();
		Thread thread = new Thread(rxThread);
		
		System.out.println( "Good night World");
		
		thread.start();
		Application.launch(MainStage.class, args);
		thread.interrupt();
		
		System.out.println( "r u still awake?");
		
		return;
                }

Wenn ich den Vorgang überprüfe, sieht es so aus.

_ ↓ Fenster Im geschlossenen Zustand sieht es so aus _

Ich habe unten ein wenig hinzugefügt, was ich bisher beim Einfädeln festgefahren habe.

• Was passiert, wenn der Hauptthread beendet wird, während der Thread eine Endlosschleife ausführt?
• Muss ich eine Thread-Instanz erstellen, um Thread zu erben?

Was passiert, wenn der Hauptthread beendet wird, während der Thread eine Endlosschleife ausführt?

Um ehrlich zu sein, dachte ich: "Wenn der übergeordnete Thread verschwindet, verschwindet auch der untergeordnete Thread." Ja, es fühlt sich ein wenig stark an, wenn geschrieben steht: "Eltern sterben, aber Kinder leben".

Wenn ich versuche, es zu bewegen, sieht es so aus.

Wenn Sie sorgfältig darüber nachdenken, ist es wie "Eltern sind tot und Kinder sind Zombies", also ist es in Ordnung, pechschwarz zu sein. Daher muss sichergestellt werden, dass der untergeordnete Prozess beendet wird, bevor der übergeordnete Prozess beendet wird.

Deshalb habe ich es nachgeschlagen. So beenden Sie einen Thread. Dann fand ich heraus, dass eine Methode namens Thread.stop () implementiert wurde.

Wenn ich das schreibe, ist Eclipse diesmal krank.

Sogar die Stornierungszeile wird wie ein Thread gelöscht. ~~ stop ~~ (). Warum? Wenn Sie diese Methode denken, veraltete Methode. Details: Oracle --Documentation Class Thread (Japanisch) - Siehe Abschnitt stop ()

Um das Warten abzubrechen, verwenden Sie die Thread.interrupt () -Methode und lassen Sie den Thread den Thread selbst beenden. Übrigens sind suspend (), das den Thread-Vorgang unterbricht, und resume (), das ihn wieder aufnimmt, ebenfalls veraltet. Der Grund ist "es ist leicht, Dead Lock zu verursachen!" Grundsätzlich scheint die Interferenz mit anderen Threads auf die Interrupt-Warteschlange mit thread.interrupt () beschränkt zu sein.

Wenn Sie das Steuerungssystem unzusammenhängend machen, können Sie sich später erwürgen.

Muss ich eine Thread-Instanz erstellen, um Thread zu erben?

Ich habe es versucht und es funktioniert gut. Wenn es sich um eine Musterklasse handelt, die die Runnable-Schnittstelle implementiert, müssen Sie dies hier tun. (start () Methode oder)

Machen Sie einen Standby-Prozess

Da es sich bei dieser Zeit um Socket-Kommunikation handelt, erfolgt die Kommunikation über webSocket.

Hmmm, wie erklären Sie die Socket-Kommunikation auf leicht verständliche Weise? Da es einen Datenspeicherbereich gibt, der auch als Port zum Senden und Empfangen von Daten verwendet wird, Ein Bild zur Angabe des Ports, der im Standby-Modus verwendet werden soll, und zur Überwachung.

Als ich es nachgeschlagen habe, scheint es, dass die Kommunikation mit Java-Sockets sehr einfach ist.

Sofort üben.

Löschen Sie den oben einmal gekneteten Prozess von RxThread.run () und ändern Sie ihn in den Standby-Prozess

RxThrea.java

package kugui.owd.privateMessenger;

import java.io.IOException;
import java.net.*;

public class RxThread extends Thread{
	
	public void run() {
		
		int port = 80; //Zum Test.
		ServerSocket sSocket;
		
		try {
			
			sSocket = new ServerSocket(port);
			sSocket.accept();
			
			System.out.println( String.format("port %d : socket accept", port));
			
		}catch(IOException ioE) {
			
			ioE.printStackTrace();
			
		}
		
		if( sSocket != null ){
			sSocket.Close();
		}

		System.out.println( "finished");
		
		return;
	}
}

Beginnen Sie sofort nach dem Zusammenbau.

Greifen Sie mit einem Browser auf localhost zu, um Daten an Port 80 zu senden.