Swing Von vielen Klassen auf ein GUI-Element zugreifen

[Zaega]

moin,

ich arbeite im Moment an einem Projekt, bei dem ich eine GUI mit Swing habe, welche in 5 Bereiche aufgeteilt ist. Für jeden Bereich gibt es dabei ein eigenes Panel. Da bei dem Projekt MVC zum Einsatz kommt, ist jedes dieser Panels ein View wozu es jeweils auch ein Model und einen Controller gibt. (mit eienr Ausnahme wozu ich gleich komme)

Nun ist es aber so, dass einer der 5 Bereiche nur einen "Textbereich" enthalten soll, in dem Statusmeldungen, Fehlermeldungen und Exceptions, die eventuell auftreten, angezeigt werden sollen.

Genau hier bin ich mir jetzt unsicher, wie ich dies designtechnisch möglichst elegant baue. Da Statusupdates und Exceptions ja so ziemlich in jeder meiner Klassen auftreten, müsste ich diesen Textbereich ja theoretisch allen Klassen irgendwie bekannt machen, damit diese dort ihre Daten einfügen können.

Mein erster Ansatz ist jetzt, dass ich ein JTextPane nutze und in meinem Hauptfenster, welches die einzelnen Panel enthält, zum einen das panel "static" gemacht habe und eine "static" Methode anbiete, worüber ich Statusupdates an das JTextPane anhängen kann. Zudem verzichte ich bei diesm panel auf ein Model und einen Controller, da nur die JTextPane vorhanden ist.

Dieser Ansatz funktioniert zwar, aber irgendwie habe ich dabei ein ungutes Gefühl. Das muss doch irgendwie besser gehen, gibt es dafür vllt. ein spezielles Entwurfsmuster?

Würde mich über Ideen zur Verbesserung sehr freuen.

Wenn aus meiner Erkärung irgendwas nicht ganz klar wird, kann ich auch mal sehen, kann ich auch relevate Teile vom Code hier zeigen.

mfg Zaega

 

[markus99]

Ich verstehe deinen Ansatz noch nicht so ganz.

Ich würde es so Lösen:
[main] -> [gui] -> [gui element 1|2|3|4|5] -> gemeinsamer Controler -> gemeinsames Model.

Instanzierung:
[main] -> [controler] -> [gui] (->[gui elemente])
[controler] ""(->Model)""

Hier im Forum gibt es irgendwo ein gutes Beispiel, welches auch noch den Observer verwendet.
Falls du es so meinst: Du kannst natürlich für die einzelnen Panel eigene Klassen verwenden, enden sollten die trotzdem in der eigentlichen GUI-Klasse, welche dann wieder lt. MVC Pattern mit Control und Model kommuniziert.

Grüße,
Markus

 

[Zaega]

Habe mal ein Klassendiagramm dazu erstellt, jedoch fehlt darin noch, dass die Controller der einzelnen Panels alle vom MainGUIController erzeugt werden.
Werde das später noch korrigieren, hab jetzt grad leider keine Zeit dafür.

Meine Frage ist jetzt, wie kann ich jetzt am besten aus allen Klassen auf die Klasse "StatusPanel" zugreifen, um dieser Klasse diverse Änderungen bekannt zu geben?

Ich hoffe dadurch wird der Aufbaue twas klarer.

mfg zaega

 

[bERt0r]

Ich halte es für seltsam wenn der Controller die View initialisieren soll. Laut deinem Klassendiagramm haben die Panels nichtmal eine Assoziation mit den Views...
Das mit static würde ich bleiben lassen. Für deine Textpane besteht z.B die Möglichkeit den Standardoutput/error-Stream in dein Textpane umzuleiten: Code Smart: Redirecting System.out and System.err to JTextPane or JTextArea
oder deine Panels erzeugen Events, welche dein MainController abfangen kann und je nachdem was in deine Textpane schreibt: How To Create Your Own Events In Java Chad.Stever
Wenn dir das mit den custom Events zu viel Arbeit ist, kannst du auch PropertyChangeEvents nehmen. How to Write a Property Change Listener (The Java™ Tutorials > Creating a GUI With JFC/Swing > Writing Event Listeners)

 

[ssoul26]

Benute Observer-Pattern - > Beobachter (Entwurfsmuster) ? Wikipedia

 

[Zaega]

Mir scheint, ich habe in meiner MVC Implementierung noch ein grundsätzlich was falsch.

Ich halte es für seltsam wenn der Controller die View initialisieren soll.

Wie würde man das denn korrekt machen?

in Main: MainGUI initialisieren und dann den MainGUIController
in MainGUI: alle Panels initialisieren und der MainGUI hinzufügen
im MainGUIController: alle Controller intialisieren
in den jeweiligen Controllern: das Model initialisieren und mit der View (dem Panel) verbinden

wäre es so besser?

Laut deinem Klassendiagramm haben die Panels nichtmal eine Assoziation mit den Views...

Wie meinst du das genau? Die Panels entsprechen ja eigendlich meinem Views. Wahrscheinlich habe ich da einen Fehler im Klassendiagramm.

Habe hier mal einen Codeausschnitt eines panels:

public class XPanel extends JPanel implements IXListener {
	private JTextField txtPath;
	private JButton btnSelectDatabase;
	private JLabel lblDatabase;

	public XPanel() {
		//unnötigen Code für bessere Übersicht entfernt

		lblDatabase = new JLabel("Database:");
		add(lblDatabase, "2, 4, right, default");

		txtPath = new JTextField();
		add(txtPath, "4, 4, fill, default");
		txtPath.setColumns(10);

		btnSelectDatabase = new JButton("Select Database");
		btnSelectDatabase.setActionCommand("Select Data");
		add(btnSelectDatabase, "6, 4");

	}

	public String getTxtPath() {
		return txtPath.getText();
	}

	public void setTxtPath(String path) {
		this.txtPath.setText(path);
	}

	public void setSelectDatabaseListener(ActionListener aListener) {
		this.btnSelectDatabase.addActionListener(aListener);
	}

	@Override
	public void databasePathChanged(String newDatabasePath) {
		txtPath.setText(newDatabasePath);
	}
}

Das mit static würde ich bleiben lassen. Für deine Textpane besteht z.B die Möglichkeit den Standardoutput/error-Stream in dein Textpane umzuleiten: Code Smart: Redirecting System.out and System.err to JTextPane or JTextArea
oder deine Panels erzeugen Events, welche dein MainController abfangen kann und je nachdem was in deine Textpane schreibt: How To Create Your Own Events In Java Chad.Stever
Wenn dir das mit den custom Events zu viel Arbeit ist, kannst du auch PropertyChangeEvents nehmen. How to Write a Property Change Listener (The Java™ Tutorials > Creating a GUI With JFC/Swing > Writing Event Listeners)

Danke, werde ich mir mal ansehen.

Benute Observer-Pattern

Danke, werde ich mir auch ansehen, hab ich zwar auch schon drüber nachgedacht, aber vllt. kommt mir dabei ja noch eine gute Idee.

mfg zaega

 

[Zaega]

Habe mich jetzt für die Lösung entschieden, den Standardoutputstream in mein Textpane umzuleiten, funktioniert sehr gut.
Vielen Danke erstmal dafür.

Würde mich freuen,
wenn noch einmal kurz jemand auf meine Frage zum MVC im letzten Post eingehen könnte, dann kann ich hier auch auf "erledigt" umstellen.

mfg zaega

 

[bERt0r]

Meiner Meinung nach wird der Conroller immer viel zu wichtig gemacht. Weil er eben Controller heisst. Der Grundstein von MVC ist das Model, das heisst das Model kann auch ohne View und Controller existieren. Eine View gibts nur wenn jemand das Model anschaun will und einen Controller nur, wenn jemand, über die View, was an dem Model auslösen/verändern will.
Ein XPanel implements XListener ist immer schlecht, weil du damit ja quasi View und Controller zusammenlegst. Ja, das Panel kann die View sein aber Listener sind die Controller. Es macht keinen Unterschied ob du jetzt eine eigene Datei oder eine eigene Klasse für deine Controller machst aber sie sollten zumindest ein eigenes Objekt sein.

 

[Zaega]

Entweder ich versteh nicht was du meinst, oder du interpretierst den Codeabschnitt den ich gepostet habe nicht ganz richtig. Hier hab ich nochmal den Code von einem Panel(View), Controller, Model und den zugehörigen Interfaces.

Panel(View):

package gui.view;

import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;

import businesslogic.model.interfaces.IMMListener;

import com.jgoodies.forms.factories.FormFactory;
import com.jgoodies.forms.layout.ColumnSpec;
import com.jgoodies.forms.layout.FormLayout;
import com.jgoodies.forms.layout.RowSpec;

public class MMPanel extends JPanel implements IMMListener {
	private JTextField txtPath;
	private JButton btnSelectDatabase;
	private JLabel lblDatabase;

	/**
	 * Create the panel.
	 */
	public MMPanel() {
		setLayout(new FormLayout(
				new ColumnSpec[] { FormFactory.RELATED_GAP_COLSPEC,
						ColumnSpec.decode("max(44dlu;default)"),
						FormFactory.RELATED_GAP_COLSPEC,
						ColumnSpec.decode("max(135dlu;default):grow"),
						FormFactory.RELATED_GAP_COLSPEC,
						ColumnSpec.decode("max(0dlu;default)"),
						FormFactory.RELATED_GAP_COLSPEC,
						FormFactory.DEFAULT_COLSPEC, }, new RowSpec[] {
						FormFactory.RELATED_GAP_ROWSPEC,
						FormFactory.DEFAULT_ROWSPEC,
						FormFactory.RELATED_GAP_ROWSPEC,
						FormFactory.DEFAULT_ROWSPEC,
						FormFactory.RELATED_GAP_ROWSPEC,
						FormFactory.DEFAULT_ROWSPEC, }));

		lblDatabase = new JLabel("Database:");
		add(lblDatabase, "2, 4, right, default");

		txtPath = new JTextField();
		add(txtPath, "4, 4, fill, default");
		txtPath.setColumns(10);

		btnSelectDatabase = new JButton("Select Database");
		btnSelectDatabase.setActionCommand("Select Data");
		add(btnSelectDatabase, "6, 4");

	}

	public String getTxtPath() {
		return txtPath.getText();
	}

	public void setTxtPath(String path) {
		this.txtPath.setText(path);
	}

	public void setSelectDatabaseListener(ActionListener aListener) {
		this.btnSelectDatabase.addActionListener(aListener);
	}

	@Override
	public void databasePathChanged(String newDatabasePath) {
		txtPath.setText(newDatabasePath);
	}
}

Controller:

package businesslogic.controller;

import gui.view.MMPanel;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;

import javax.swing.JFileChooser;

import businesslogic.model.MMModel;
import businesslogic.model.interfaces.IMMListener;

public class MMPanelController {
	private MMPanel mmPanel;
	private MMModel mmModel;

	public MMPanelController(MMPanel mmPanel) {
		this.mmPanel = mmPanel;
		this.mmModel = new MMModel();
		addMMListener(mmPanel);
		addListener();
	}

	private void addListener() {
		this.mmPanel.setSelectDatabaseListener(new SelectDatabaseListener());
	}

	private void addMMListener(IMMListener mmListener) {
		this.mmModel.addMMListener(mmListener);
	}

	class SelectDatabaseListener implements ActionListener {
		public void actionPerformed(ActionEvent e) {

			JFileChooser fc = new JFileChooser();
			int returnVal = fc.showOpenDialog(mmPanel);

			if (returnVal == JFileChooser.APPROVE_OPTION) {
				File file = fc.getSelectedFile();
				mmModel.setDatabase(file);
			}
		}
	}
}

Model:

package businesslogic.model;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

import businesslogic.model.interfaces.IMMListener;
import businesslogic.model.interfaces.IMMModel;

public class MMModel implements IMMModel {

	private File database;

	private List<IMMListener> listeners = new ArrayList<IMMListener>();

	public MMModel() {
		// initialize dummy data to avoid nullpointers at the first comparison
		database = new File("");
	}

	@Override
	public void setDatabase(File database) {
		if (!this.database.getAbsolutePath().equals(database.getAbsolutePath())) {
			this.database = database;
			for (IMMListener listener : listeners) {
				listener.databasePathChanged(database.getAbsolutePath());
			}
		}
	}

	public void setDatabase(String path) {
		if (!this.database.getAbsolutePath().equals(path)) {
			this.database = new File(path);
			for (IMMListener listener : listeners) {
				listener.databasePathChanged(database.getAbsolutePath());
			}
		}
	}

	@Override
	public void addMMListener(IMMListener mmListener) {
		listeners.add(mmListener);
	}

	@Override
	public void removeMMListener(IMMListener mmListener) {
		listeners.remove(mmListener);
	}

}

ModelInterface:

package businesslogic.model.interfaces;

import java.io.File;

public interface IMMModel {
	void setDatabase(File database);

	void addMMListener(IMMListener mmListener);

	void removeMMListener(IMMListener mmListener);
}

ViewInterface:

package businesslogic.model.interfaces;

public interface IMMListener {
	void databasePathChanged(String newDatabasePath);
}

Dabei habe ich mich an diesen Beiträgen zu MVC orientiert.

Mir ist leider nicht klar, wieso ich die View und den Controller zusammengelegt habe, könntest du vllt ein kurzes Beispiel geben, wie das ganze besser wäre? Oder es nochmal mit andern Worten erklären?

Oder ist es so gemeint, dass ich nicht mein View beim Model als Beobachter registriere, sondern stattdessen meinen Controller, und dann die View vom Controller manipulieren lasse, statt dass die View sich selbst manipuliert?

edit: Ich schaue mir grad mal dein Beispiel an.

mfg zaega

 

[bERt0r]

Ok, das hat dann nur so ausgesehen als ob du View und Controller zusammenlegst. Trotzdem ist es keit guter Stil, wenn man Panel implements Listener schreibt. Wenn mans nur für den Listener aufs Model macht mags ja noch ok sein, sobald man dann implements XYZListener, ActionListener, ChangeListener macht wirds aber unübersichtlich.
Sprechende Namen für deine Klassen wären auch ganz toll, unter IMMListener kann man sich nämlich nicht viel vorstellen und dann hält man das ganze für was anderes, als es ist. Du hättest das Model z.B DatabaseModel nennen können und den Listener DatabaseChangeListener.

 

[Robokopp]

Also ich hab mich vor kurzem auch mit der Frage beschäftigt.
Dann bin ich kurz um zu der Lösung gekommen, eine handlerKlasse zu schreiben die mit der Ui kommuniziert.
Und zwar tut sie das folgendermaßen :
1.Klasse xyz ,die der ui etwas mitteilen möchte erzeugt eine Instanz dieser handler klasse.
2.ein string wird der Klasse übergeben und es wird ein neuer thread erzeugt(damit ist die Arbeit für den ursprünglichen thread getan und er muss auf nichts warten)
3.dieser erzeugte thread ruft nun eine statische synchronisierte Methode auf, die direkt mit der ui verbunden ist und schickt den string an die selbige.

Hab das ganze in einen Server gebastelt um zu protokollieren und Statistiken anzuzeigen und es klappt hervorragend ohne irgendwelche Fehler oder Abstürze.