Wenn Sie auf der Suche nach einem plattformübergreifenden Open-Source-XML-Editor sind, können Sie diesen Wunsch vielleicht bald verwirklichen. In dieser dreiteiligen Serie begleite ich Sie durch die Entwicklung eines einfachen XML-Editors unter Verwendung einiger der gängigsten Java 2 Swing-Komponenten. Von dieser Serie profitieren diejenigen, die ihren eigenen XML-Editor schreiben oder Swing erlernen oder auffrischen möchten.
Dies ist der dritte Artikel dieser Serie. Im ersten Artikel haben wir kurz XML besprochen und erläutert, warum Baumstrukturen für die Anzeige von XML geeignet sind, wie XML-Daten verarbeitet werden, wie die JTree Swing-Komponente verwendet wird, und wir haben außerdem eine wiederverwendbare Komponente erstellt, um XML-Dateien zu analysieren und in JTree Display zu verwenden Daten in .
Im zweiten Artikel haben wir die Grundstruktur für unseren XML-Editor erstellt. Zu diesem Zweck haben wir über eine Reihe von Swing-Komponenten gesprochen (einschließlich jsplitPane, JScrollPane, JButton und JTextArea). Das JSplitPane-Objekt enthält zwei JScrollPane-Objekte, eines zum grafischen Durchsuchen von XML und das andere zum Durchsuchen von Text.
In diesem letzten Artikel werden wir die endgültige Schnittstelle zum XML-Editor hinzufügen, um ihn benutzerfreundlicher zu machen. Wir erstellen zunächst ein Menüsystem und fahren dann mit dem Aufbau der JFileChooser-Komponente fort, die auf das zugrunde liegende Dateisystem zugreift, um das Speichern von XML-Dateien und das Öffnen neuer Dokumente zu ermöglichen. Abschließend erstellen wir ein JDialog-Feld, das es dem Benutzer ermöglicht, einen Befehl abzubrechen und die Anwendung zu beenden.
Wie können wir also die Leistung unserer Swing-Anwendungen verbessern, damit sie Menüs nutzen, auf das Dateisystem zugreifen und es dem Benutzer ermöglichen, Vorgänge abzubrechen? Wir müssen eine JMenu-Komponente erstellen, um das Menü der Anwendung zu verwalten, eine JFileChooser-Komponente, um auf das zugrunde liegende Dateisystem zuzugreifen, und ein JDialog-Feld, damit der Benutzer den Vorgang abbrechen kann.
In früheren Artikeln haben wir die XTree-Klasse entwickelt, eine wiederverwendbare Komponente, die von der JTree-Klasse abgeleitet ist und XML-Daten als grafischen Baum anzeigen kann. Da wir gerne objektorientierte Prinzipien verwenden, werden die Änderungen, die wir heute vornehmen, diese Klasse nicht berühren. Da wir gerne objektorientierte Prinzipien verwenden, werden die Änderungen, die wir heute vornehmen, diese Klasse nicht berühren. Es handelt sich um eine eigenständige wiederverwendbare Klasse, die von unserem JFrame-Container verwendet und nicht kombiniert wird.
Abschnitt 1 Erstellen einer Menükomponente
Eine JMenu-Komponente umfasst mehrere Objekte: eine Menüleiste, ein oder mehrere Menüs und ein oder mehrere Menüelemente. Menüleisten enthalten Menüs, die Menüelemente enthalten. Die Namen dieser Swing-Komponenten sind recht intuitiv (JMenuBar, JMenu bzw. JMenuItem).
Hier ist der vollständige Code zum Erstellen eines minimalen „Datei“-Menüs mit einem einzelnen Menüelement:
JMenu fileMenu = new JMenu( "File" );
JmenuItem exitItem = new JMenuItem ( "Exit" );
fileMenu.add( exitItem );
JmenuBar menuBar = new JMenuBar();
menuBar.add( fileMenu );
setJMenuBar( menuBar );
Wir sollten mit diesem Prozess sehr vertraut sein. Die JMenu-Komponente wird erstellt, wenn eine andere Java-GUI-Komponente erstellt wird. Innerste Elemente werden zu ihren unmittelbar übergeordneten Elementen hinzugefügt, bis für alle Elemente ein geeigneter Container definiert ist.
Zurück zur XmlEditor-Fallstudie: Wir haben tatsächlich ein vollständiges Dateimenü erstellt, mit der Möglichkeit, eine neue XML-Datei zu erstellen, eine vorhandene Datei zu öffnen, die Datei zu speichern und zu beenden. Wir werden im nächsten Abschnitt mehr darüber sprechen.
Abschnitt 2 Umgang mit Menüereignissen
Wir möchten ein typisches Dateimenü erstellen, das es unseren Benutzern ermöglicht, ein neues Dokument zu erstellen, eine vorhandene Datei zu öffnen, die aktuelle Datei zu speichern und die Anwendung zu beenden. Nachdem wir nun wissen, wie man dieses Menü erstellt, wie reagieren wir auf die Menüauswahl des Benutzers? Wie bei anderen Swing-Komponenten liegt die Antwort im Ereignismodell und den verfügbaren Listener-Komponenten.
Die einfachste Möglichkeit, eine Menüauswahl zu handhaben, besteht darin, dem Menüelement einen Aktions-Listener hinzuzufügen: exitItem.addActionListener(new exitMenuHandler()); wenn es um die Verarbeitung komplexer Ereignisse geht (da sich das Menüsystem sehr ändern kann). komplex) sollten Event-Handler als separate Klassen definiert werden. Das oben angegebene Beispiel fügt einen Aktions-Listener vom Typ „exitMenuHandler“ hinzu. Dieser Typ wird später in dieser Anwendung definiert. Das Folgende ist der minimale Code, der zum Definieren der Klasse „exitMenuHandler“ erforderlich ist:
class exitMenuHandler implementiert ActionListener {
public void actionPerformed( ActionEvent ae ) {
System.exit(0);
}
}
Obwohl diese Implementierung möglicherweise zu einfach erscheint, um die Definition einer einzelnen Klasse zu demonstrieren, werden Sie bei der Definition des Ereignisbehandlungscodes zum Öffnen und Speichern von Dateien mit der separaten Funktionalität vertraut gemacht. Die Bedeutung des Puttens Eigenschaften in separate Klassendateien. Darüber hinaus können Sie mit diesem Ansatz gemeinsame Menüfunktionen in verschiedenen Anwendungen wiederverwenden.
Abschnitt 3 Erstellen von Dateisystem-Zugriffskomponenten
Diese Java-Anwendung muss Benutzern häufig den Zugriff auf das Dateisystem über einen grafischen Dateisystembrowser ermöglichen. Dies liegt in der Regel daran, dass der Benutzer eine Komponente oder Datei öffnen oder speichern möchte. In unserer XmlEditor-Anwendung möchten wir, dass der Benutzer dies tun kann.
Für den Zugriff auf das grundlegende Dateisystem gibt es eine sehr gute Komponente im javax.swing-Paket: die JFileChooser-Komponente. Zweifellos haben Sie bereits eine Swing-Anwendung verwendet, bevor Sie die Vorteile der JFileChooser-Komponente nutzen.
Um einen JFileChooser zu erstellen, instanziieren Sie zunächst ein JFileChooser-Objekt, legen seine Größe fest und deklarieren es dann so, dass es entweder zum Öffnen oder Speichern von Dateien verwendet werden kann. Sie verknüpfen dieses Objekt mit seinem übergeordneten Objekt – dem Objekt, mit dem es aktiviert wurde (in unserem Fall ein Menüelement) – und stellen es dann so ein, dass es entweder den Dialog öffnet oder speichert. Dazu nutzen Sie die Methoden showSaveDialog() oder showOpenDialog(), die beide einen int-Rückgabewert zurückgeben. Hier ist ein kurzes Beispiel:
JFileChooser jfc = new JFileChooser();
jfc.setSize( 500, 250 );
Container parent = openItem.getParent();
int choice = jfc.showOpenDialog(parent);
Der in der letzten Zeile zurückgegebene ganzzahlige Wert gibt an, ob der Benutzer schließlich eine Datei geöffnet/gespeichert oder die Schaltfläche „Abbrechen“ gedrückt hat. Als Reaktion auf Öffnungs-/Speicherereignisse kann dieser ganzzahlige Wert mit der in der JFileChooser-Klasse definierten APPROVE_OPTION-Konstante verglichen werden. An diesem Punkt müssen Sie nur noch die entsprechende Methode verwenden, um die vom Benutzer angeforderte Datei zu öffnen/speichern.
Bitte sehen Sie sich Codeausschnitt 1 an, der die vollständige Implementierung dieser Anwendung darstellt. Er enthält alle sechs Methoden, die zum Erstellen der Menüverarbeitungsfunktion der XmlEditor-Anwendung verwendet werden.
Abschnitt 4 Erstellen einer Dialogkomponente zur Validierung von Auswahlen
Wenn Sie nun auf das Schließfenster des Jframes klicken, wird die Anwendung sofort geschlossen. Das ist nicht gut. Was passiert, wenn der Benutzer versehentlich das Fenster schließt, während er an einer Datei arbeitet? Wir möchten den Benutzer dazu auffordern und ihn fragen, ob er die Anwendung wirklich schließen möchte.
Um diesen Zweck zu erreichen, können wir ein JDialog-Dialogfeld verwenden. Jede Grafikanwendung kann sie verwenden, um den Benutzer zu warnen, bevor eine andere Datei überschrieben wird, eine Datei ohne Speichern geschlossen wird oder bevor die Anwendung geschlossen wird. Um die Programmierung zu vereinfachen, legen wir Wert darauf, den Benutzer beim Schließen des Editors daran zu erinnern.
Alles, was wir tun müssen, ist ein JDialog-Dialogfeld zu erstellen. Dieses Dialogfeld ist mit einem Jlabel ausgestattet. Es enthält eine Eingabeaufforderung und zwei Schaltflächen, eine zum Empfangen des Befehls zum Schließen des Programms und die andere zum Abbrechen der Befehl zum Schließen des Programms. Im Folgenden finden Sie den Code zum Erstellen dieser Komponente:
JDialog verifyDialog = new JDialog( this, „Exit bestätigen“, true );
Jlabel questions = new JLabel( „Sind Sie sicher, dass Sie beenden möchten? " ) ;
Jbutton okButton = new JButton( "OK" );
okButton.addActionListener( this );
Jbutton cancelButton = new JButton( "Cancel" );
cancelButton.addActionListener( this ) ;
verifyDialog.getContentPane().setLayout( new FlowLayout() );
verifyDialog.getContentPane().add( Frage );
verifyDialog.getContentPane().add( okButton );
verifyDialog .getContentPane ().add( cancelButton );
verifyDialog.hide();
Nun müssen noch zwei Dinge erledigt werden. Wir müssen Ereignisbehandlungscode für diese beiden Schaltflächen schreiben und das Ereignisverhalten beim Fensterschließen durch sie ersetzen. Was die Handhabung dieser beiden Schaltflächen betrifft, schließen wir einfach die Anwendung, wenn wir auf „OK“ klicken, und blenden den Dialog aus, wenn wir „Abbrechen“ drücken.
Der letzte Schritt besteht darin, die Standardereignisaktion zum Schließen des Fensters zu überschreiben. Selbst wenn Sie ein Dialogfeld erstellen und der Benutzer auf die Schaltfläche „Abbrechen“ klickt, empfängt JFrame standardmäßig weiterhin das Ereignis „Fenster schließen“. Dies führt dazu, dass sich der JFrame selbst ausblendet, es sei denn, wir überschreiben ihn mit der folgenden Einstellung:
setDefaultCloSEOperation( JFrame.DO_NOTHING_ON_CLOSE );
Die neue Einstellung sorgt dafür, dass er sich als Reaktion auf das absolut nicht selbst schließt Fensterschließereignis. Es schließt sich nur als Reaktion auf einen System.exit()-Aufruf.
Sobald Sie die Menükomponente hinzugefügt, Ereignishandler für die Menüereignisse definiert und eine Methode zum Abbrechen des unerwarteten Fensterschließereignisses hinzugefügt haben, können wir die Anwendung testen und mit dem Erstellen, Bearbeiten und Speichern von XML-Dateien beginnen.
Herzlichen Glückwunsch! Glückwunsch! Sie verfügen bereits über einen handgeschriebenen Swing-basierten XML-Editor. Der Rest der Arbeit liegt bei Ihnen. Sie müssen es überprüfen, seine Robustheit erhöhen und möglicherweise einige neue Funktionen hinzufügen.
Anhang: Codeausschnitt 1
Klasse newMenuHandler implementiert ActionListener
{
public void actionPerformed ( ActionEvent ae )
{
textArea.setText( "" );
try
{ // Erstelle einen neuen XTree
xTree = new XTree();
xTree.getSelectionModel().setSelectionMode(
howsRootHandles ( true );
// A more erweiterte Version dieses Tools, die die Änderung von JTree ermöglicht
xTree.setEditable( false );
}
Catch( Exception ex )
{
String message = ex.getMessage();
ex.printStackTrace();
}
file://结束try/catch
}
file://结束actionPerformed()
}
file://结束class newMenuHandler
class openMenuHandler implementiert ActionListener
{
JFileChooser jfc;
Container parent;
int choice;
openMenuHandler()
{
super();
jfc = new JFileChooser();
jfc.setSize( 400,300 );
jfc.setFileFilter( new. XmlFile Filter( ) );
parent = openItem.getParent(); } } } int choice;
openMenuHandler()
{
super();
jfc = new JFileChooser();
jfc.setSize( 400,300. );
j fc.setFileFilter( new XmlFileFilter() );
parent = openItem.getParent() == JFileChooser.APPROVE_OPTION )
{
String fileName, line;
BufferedReader read;
fileName = jfc.getSelectedFile().getAbsolutePath();
versuchen
{
reader = new BufferedReader(
new FileReader( fileName ) );
textArea.setText( reader.readLine() + " " );
während ( ( line = reader.readLine() ) != null )
{
textArea.append( line + " " );
}
reader.close();
xTree. fresh( textArea.getText() );
}
catch ( Exception ex )
{
String message = ex.getMessage();
ex.printStackTrace();
}
jfc.setCurrentDirectory( new File( fileName ) );
}
}
}
class saveMenuHandler implementiert ActionListener
{
JFileChooser jfc;
Container parent;
int choice;
saveMenuHandler()
{
super();
jfc = new JFileChooser();
jfc.setSize( 400.300 ) ;
jfc.setFileFilter( new 🎜>
choice = jfc.showSaveDialog( parent );
if ( choice == JFileChooser.APPROVE_OPTION )
{
String. fileName;
Datei fObj;
FileWriter-Writer ;
fileName = jfc.getSelectedFile().getAbsolutePath();
try
{
writer = new FileWriter( fileName );
textArea.write (Writer);
writer.close();
}
catch ( IOException ioe. )
{
ioe.printStackTrace();
}
jfc. setCurrentDirectory( new File( fileName ) );
}
}
}
class exitMenuHandler implementiert ActionListener
{
public void actionPerformed( ActionEvent ae )
{
verifyDialog.show();
}
}
class
if ( fobj.isDirectory() )
return true;
else
return fobj.getName().endsWith( ".xml" );
}
public String getDescription()
{
return "*.xml";
}
}
更多相关内容请关注PHP中文网（www.php.cn）！
