MySQL Zugriff auf Datenbank Objekt

[goodcat]

Hi,

ich habe da mal zwei Fragen was den Zugriff auf das Datenbank Objekt angeht. Und DB Zugriffe in verbindung mit Threads.

Und zwar habe ich mehrere Klassen die auf die Datenbank zugreifen müssen. Diese Klassen bauen die SQL Querys zusammen und schicken diese an den DBConnector.

Ich habe eine Klasse DBConnector.java die folgendermaßen aussieht:

public class DBConnector {
		
	public MysqlDataSource ds = new MysqlDataSource();	
	public Connection DBConn;
	private Statement stm;
	private ResultSet rs;
	private int DBError = 0;
	
	public DBConnector() {
		
		try {
			ds.setDatabaseName(Main.dbDatabaseName);
			ds.setServerName(Main.dbServerName);
			ds.setPort(Main.dbPort);
			ds.setUser(Main.dbUsername);
			ds.setPassword(Main.dbPassword);
		}
		catch (Exception e) {
			e.printStackTrace();
		}

	}
	
	/**
	 * Schließt die Verbindung zum Datenbank Server.
	 */
	public void closeConnection() {	
		
		try {
			DBConn.close();
		} 
		catch (Exception e) {
			e.printStackTrace();
		}
		
	}

	public ResultSet executeQuery( String query ) {
    	try {
    		this.DBConn = ds.getConnection();
    		this.stm = DBConn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
        	this.rs = stm.executeQuery(query);
    	}
    	catch (CommunicationsException eConn) {
    		if (this.DBError != 1) {
    			JOptionPane.showMessageDialog(null, "ERROR: Could not establish a database connection", "DB Error", JOptionPane.ERROR_MESSAGE);
    		}
    		this.DBError = 1;
    	}
    	catch (Exception e) {
			e.printStackTrace();
		}
    	
    	return this.rs;
	}
	
	public void alterQuery( String query ) {
	     
        try {
        	DBConn = ds.getConnection();
        	stm = DBConn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
        	stm.executeUpdate(query);
        }
        catch(MySQLIntegrityConstraintViolationException e1) {
        	e1.printStackTrace();
        	JOptionPane.showMessageDialog(null, "Der Eintrag konnte nicht gelöscht werden, da er mit einem anderen Datensatz verknüpft ist!", "DB Error", JOptionPane.ERROR_MESSAGE);
		}
        catch (Exception e) {
        	e.printStackTrace();
        }        
       
    }
	
}

Bisher habe ich diese Klasse einmal instanziert und übergebe aus der "MainGui" den Klassen die einen Zugriff auf die DB benötigen dieses Objekt.

Jetzt ist die Frage wie ihr das macht bzw. es gibt doch bestimmt ein Pattern o.ä. welches Zugriffe auf die DB regelt. Wird die DB Klasse in jeder Klasse neu instanziert oder wird die klasse statisch? Oder werden die Klassen mit dem DBConnector erweitert (extends)... (Habe gelesen das DB Zugriffe nicht unbedingt statisch geschehen sollen... )...

Die andere Frage ist, momentan werden alle SQL Abfragen in dem Swing Thread ausgeführt was auch nicht besonders klever ist. Habt ihr eventuell einen Tipp für mich wie ich den DB Zugriff über Threads realisieren kann (Rückgabe, synchron etc..). Ich bin Anfänger und habe doch ein paar Probleme was das Design bzw. die Struktur angeht. Deswegen würde ich mich sehr über ein paar gute Links oder sogar eine bereits von euch eingesetzte Lösung sehr freuen!

Thx Goodcat

 

[goodcat]

Ist die Frage so bescheuert? ;(

 

[vanny]

Ich würde sagen, dass es durchaus sinnvoll ist mind. einen extra Thread zu benutzen.
Ob dieser permanent laufen sollte oder jeweils neu instanziert wird, hängt mMn. von deinen Programmvorstellungen ab.

Wann du deine Threads syncronisieren musst kann ich dir so leider nicht beantworten, halt immer dann, wenn sie sich in die Quere kommen können (Stichwort: "raise conditions" und "lost update").

Wenn´s komplexer wird, kannste auch ein framework benutzen z.Bsp. Hibernate


Gruß Vanny

 

[goodcat]

Hi danke für deine Antwort.

Mh also ich glaube ein Framework werde ich nicht brauchen.
Ja meine Programmvorstellungen :bahnhof: ... Ich benötige diesen DBConnector ziemlich oft. Da das Programm nur mit einer MySQL DB zusammen arbeitet. Sprich alle Daten kommen aus der DB.

D.h. was läuft denn dann in dem extra Thread, nur der DBConnector, oder alles was nicht zur Gui gehört?

Danke Goodcat

 

[vanny]

Das hängt nicht zwingend mit dem Thema DatenBank zusammen sondern eher mit dem richtigen Einsatz des EDT.

Den extra Thread benötigst du immer dann, wenn dein Event(zBsp. Buttonklick) einen längeren Prozess abarbeitet, welcher dann deine GUI blockiert.

Das machst du entweder manuell oder per SwingWorker.

Gruß Vanny

 

[goodcat]

Ein Datenbank Zugriff kann ja unter umständen die Gui blockieren... Wenn man das Programm "normal" benutzt ist alles wunderbar nur wenn ich z.B. 20> Datensätze lösche dann wird die Gui ganz kurz blokiert. Das merkt man definitiv nur ist es nicht unbedingt schlimm... Ich denke mal ich muss mir was das Thema Threading in Verbindung mit Swing angeht etwas schlauer machen.

Aber würdest Du denn den DB Zugriff statisch gestalten? Oder ist idas quatsch?


Danke Goodcat

 

[vanny]

Ich persönlich verwende statische Klassen wirklich nur, wenn es Sinn macht und eine nicht statische Klasse keinen Sinn macht.

In deinem Fall tendiere ich zu "is Quatsch"

 

[mimo]

Hallo,

Als Erstes nochmal den Hinweis, dass Variablen in JAVA kleingeschrieben werden. Dann versteh ich nicht, wieso die Variablen als public definiert sind.

Persönlich halte ich auch nichts davon, die Fehlerbehandlung in dieser Klasse zu erledigen. Leite die Fehler bis zur GUI durch und wenn Du nicht vor dem Anwender die Originalmeldung verbergen möchtest, würde ich diese auch anzeigen lassen. Nach dem Geheimnisprinzip hast Du ja keine Ahnung davon, warum ein Fehler geschmissen wird.

Ansonsten solltest Du Dir darüber klar werden, ob Du mehrere parallele Verbindungen aufbauen möchtest. Ich gehe mal davon aus, dass Du nur eine Verbindung öffnen möchtest, da ein Verbindungsaufbau sehr teuer ist und parallele Verbindungen nur selten Sinn machen.
Vor der Ausführung Deiner Query würde ich prüfen, ob die Verbindung offen ist, dann brauchst Du die Verbindung nicht neu zu öffnen. Wenn Du nur eine Verbindung nutzen möchtest, würde ich mit einem Singleton arbeiten, eventuell in einer Klasse Session, die die Referenz auf die aktuelle Verbindung hält und verwaltet.

Gruß

Mimo

 

[vanny]

Ich denke auch, dass mehrere parallele Verbindungen nicht wünschenswert sind, ob man aber die Verbindung per Singleton aufrecht erhält, oder die Connection jeweils fix initialisiert und dann halt sicherstellt, dass sie wieder geschlossen wird, wenn der Batch abgearbeitet ist, hängt wohl davon ab, ob du dauerhaft Änderungen an der DB vornimmst (Singleton) oder ob du nur ab und an ´nen Button klickst und dann deinen Datenstapel abarbeitest (neue Connection).

Gruß Vanny

 

[goodcat]

Sorry das ich erst jetzt antworte!
Erstmals danke.
Auf jeden fall wollte ich mehrere Verbindungen vermeiden. Singleton hört sich ganz gut an, ist auch das einzige Design Pattern das ich bis jetzt einigermaßen durchschaut habe :lol: ... (Singelton in Verbindung mit einem Thread wäre natürlich ideal. Wenn das so möglich ist.)

Vor der Ausführung Deiner Query würde ich prüfen, ob die Verbindung offen ist, dann brauchst Du die Verbindung nicht neu zu öffnen. Wenn Du nur eine Verbindung nutzen möchtest, würde ich mit einem Singleton arbeiten, eventuell in einer Klasse Session, die die Referenz auf die aktuelle Verbindung hält und verwaltet.

Habe eine ganz grobe Idee wie ich das mit Singleton umsetzen könnte, aber keinen Schimmer ob das so funktioniert... Ich werde mal zusehen dass ich heute oder morgen den DBConnector überarbeite und einen Singleton einbinde... Vielleicht könnt ihr euch das dann mal anschauen.

Aber vielen Dank schon mal für eure Hilfe!

 

[mimo]

Hier mal eine Möglichkeit mit der ich das gelöst habe.

Anmerkung:
Ich habe die Klasse MySQLConnection zusammen mit dem Treiber in einem Plugin abgelegt, das ich bei Bedarf importieren kann. Äquivalent hierzu besitze ich Plugin / Pakete für Postgre und Oracle.

Wichtig hierbei ist, dass eventuell geworfene Exceptions nicht abgefangen, sondern weitergeworfen werden.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

/**
 * Sollte kein Singelton sein, falls man mehrere Verbindungen zu unterschiedlichen
 * Datenbanken benötigt.
 *
 * Bei mir befindet sich diese Klasse zusammen mit dem MySQL-Treiber in einem Plugin,
 * welches ich mir bei Bedarf importieren kann.
 */
public class MySQLConnection {

	private Connection connection;
	private String benutzername;
	private String passwort;
	private String port = "3306";
	private String server;
	private String datenbank;
	
	public MySQLConnection(){
		
	}
	
	/**
	 * Liefert das Connection-Objekt  der MySql-Verbindung zurück.
	 * @return
	 * @throws SQLException
	 */
	public Connection getConnection() throws SQLException{

		
        if(connection==null || connection.isClosed()){
        	
	        // MySQL Treiber laden
	        DriverManager.registerDriver (new com.mysql.jdbc.Driver());
	        // Verbindung herstellen
	        String str = "jdbc:mysql://" + server + ":" + port + "/" +
	        datenbank;
	        
	        connection = DriverManager.getConnection(str, benutzername, passwort);

        }
        
        return connection;

    }

	/**
	 * @return the benutzername
	 */
	public String getBenutzername() {
		return benutzername;
	}

	/**
	 * @param benutzername the benutzername to set
	 */
	public void setBenutzername(String benutzername) {
		this.benutzername = benutzername;
	}

	/**
	 * @return the passwort
	 */
	public String getPasswort() {
		return passwort;
	}

	/**
	 * @param passwort the passwort to set
	 */
	public void setPasswort(String passwort) {
		this.passwort = passwort;
	}

	/**
	 * Port (Default=3306)
	 * @return the port
	 */
	public String getPort() {
		return port;
	}

	/**
	 * Port (Default=3306)
	 * @param port the port to set
	 */
	public void setPort(String port) {
		this.port = port;
	}

	/**
	 * @return the server
	 */
	public String getServer() {
		return server;
	}

	/**
	 * @param server the server to set
	 */
	public void setServer(String server) {
		this.server = server;
	}

	/**
	 * @return the datenbank
	 */
	public String getDatenbank() {
		return datenbank;
	}

	/**
	 * @param datenbank the datenbank to set
	 */
	public void setDatenbank(String datenbank) {
		this.datenbank = datenbank;
	}
	
}

/**
 *	Steuert den Programmablauf und hält Referenzen zu den Global benötigten Objekten
 *	
 *
 *
 */
public class Session {
	
	//Hält die Referenz auf das Singelton-Objekt
	private static final Session INSTANCE = new Session();
	
	//LMS-Datenbank
	private String user = "meinName";
	private String passwd = "meinPasswort";
	private String server = "meinServer";
	private String port = "3306"
	private String datenbank = "meineDatenbank";
	private MySQLConnection lmsConnection;

	
	private Session(){
		
	}

        public static Session getInstance(){
            return INSTANCE;
	}

	/**
	 * Liefert eine Connection-Objekt der Datenbank
	 * 		Falls dieses noch nicht existiert, wird es neu angelegt.
	 *		Sollte nicht direkt beim Aufruf des Konstruktors angelegt werden,
	 *		da eventuell noch nicht feststeht ob und wann eine Verbindung benötigt wird
	 *		und ob die Übergabeparameter bereits beim Start feststehen (User/Passwort/usw.)
	 *
	 *		Mit der Methode 'getConnection()' kann auf die aktuelle Verbindung zugegriffen werden.
	 *
	 * @return the Connection
	 */
	public MySQLConnection getConnection() {
		if(connection==null){
			connection = new MySQLConnection();
			connection.setBenutzername(user);
			connection.setPasswort(passwd);
			connection.setPort(port);
			connection.setServer(server);
			connection.setDatenbank(datenbank);
		}
		return connection;
	}


}

 

[goodcat]

Wow vielen Dank!
Ach mensch habe mich schon drauf gefreut da heute etwas dran rumzuwerkeln. Naja dann muss ich es nur noch anpassen

Jetzt ist nur noch die Frage ob man die Verbindung jetzt noch in einen extra Thread legen sollte.
Ich werde aber erstmal den Code von Dir anpassen.

Vielen Dank!!
Goodcat

 

[mimo]

Das kommt darauf an ob Du den User parallel weiterarbeiten lassen möchtest oder nicht. Ich würde einen Fortschrittsbalken modal anzeigen lassen, damit der User sieht, dass das System noch arbeitet, aber selbst nichts mehr machen kann. Dafür benötigst Du natürlich min. zwei parallele Threats.

 

[goodcat]

Ok ich habe deinen Code übernommen und eingebunden. Ich muss jetzt natürlich mein halbes Programm umschreiben. Dabei ist mir aufgefallen das ich garnicht genau weiß wie ich auf das Connection Objekt zugreifen kann bzw. sollte.

Hier erstmal Session und MySQLConnection:

import java.sql.*;
import com.mysql.jdbc.exceptions.jdbc4.CommunicationsException;
import com.mysql.jdbc.exceptions.jdbc4.MySQLIntegrityConstraintViolationException;
import com.mysql.jdbc.jdbc2.optional.*;

public class MySQLConnection {
		
	private MysqlDataSource ds = new MysqlDataSource();	
	private Connection dbConnection;
	private Statement stm;
	private ResultSet rs;
	private ConfigFile iniFile;
	
	
	public MySQLConnection() {
		this.iniFile = new ConfigFile();
	}
	
	
	public void openConnection() {
		try {
			ds.setDatabaseName(iniFile.getDbname());
			ds.setServerName(iniFile.getServername());
			ds.setPort(Integer.parseInt(iniFile.getServerport()));
			ds.setUser(iniFile.getUsername());
			ds.setPassword(iniFile.getPassword());
		}
		catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public Connection getConnection() {
		try {
			if( dbConnection==null || dbConnection.isClosed() ){
				openConnection();
			}
		} 
		catch (SQLException e) {
			e.printStackTrace();
		}
        
        return dbConnection;
	}
	
	public void closeConnection() {	
		
		try {
			dbConnection.close();
		} 
		catch (Exception e) {
			e.printStackTrace();
		}
		
	}

	public ResultSet executeQuery( String query ) {
    	try {
    		dbConnection = ds.getConnection();
    		stm = dbConnection.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
        	rs = stm.executeQuery(query);
    	}
    	catch (CommunicationsException e) {
    		e.printStackTrace();
    		return null;
    	}
    	catch (Exception e) {
			e.printStackTrace();
			return null;
		}
    	
    	return this.rs;
	}
	
	public boolean alterQuery( String query ) {
	     
        try {
        	dbConnection = ds.getConnection();
        	stm = dbConnection.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
        	stm.executeUpdate(query);
        }
        catch(MySQLIntegrityConstraintViolationException e) {
        	e.printStackTrace();
        	return false;
		}
        catch (Exception e) {
        	e.printStackTrace();
        	return false;
        }
        
		return true;        
       
    }
	
}

public class Session {

    private static final Session INSTANCE = new Session();    
    private MySQLConnection dbConnection;
 
    
    private Session(){
    }
    
 
    public static Session getInstance(){
        return INSTANCE;
    }


    public MySQLConnection getConnection() {
        if( dbConnection==null ){
        	dbConnection = new MySQLConnection();
        }
        return dbConnection;
    }
 
 
}

Jetzt habe ich eine Klasse die auf die DB Zugreifen muss. Diese Klasse wird instanziert wenn z.B. ein Kunde in die DB hinzugefügt werden soll.
Kann ich jetzt das Connection Objekt im Konstruktor (der Klasse Kunde) als Eigenschaft zuweisen oder sollte ich es immer nur tun wenn ich es wirklich benötige, also z.B. in der Methode.

Und wie greife ich am besten auf das Objekt zu. Habe folgendes probiert:

ResultSet rs = Session.getInstance().getConnection().executeQuery( "SELECT name FROM tbl_kunden ORDER BY name ASC;" );

Ist das so gedacht bzw. sinnvoll?


Danke Goodcat

 

[mimo]

Versuchs mal so:

Connection conn = Session.getInstance().getConnection().getConnection();

Ich habe die Methode in Session nicht clever benannt

Die enthielt vorher den Namen der Datenbank bzw. des Programms welches die Datenbank original benutzte.

Gruß

MIMO

 

[mimo]

Ohh sorry, habe nicht gesehen, dass Du die Klasse umgewandelt hasst.

In dem Fall musst Du bei executeQuery dir die Connection über this.getConnection() besorgen. Sonst umgest Du ja die Kontrolle der getter-Methode.

Ich würde die Datenbankabfragen auch in spezielle DAO-Klassen auslagern.

 

[goodcat]

Ok werde ich nacher ausprobieren. Danke.

Oh ja stimmt ist mir garnicht aufgefallen... Ich sollte natürlich die getConnection() Methode aus der MySQL Klasse benutzen und nicht this.dbConnection... Könnte ja null oder geschlossen sein.!

Zum 2. Post, DAO klasse = Data Access Object soviel weiss ich darüber :lol:
Ich nehme mal an das wird eine Klasse sein die SQL Statements entgegen nimmt bzw. sich um die Zugriffe kümmert...

Also eine Klasse die z.B. nur die beiden Methoden (exceuteQuery und alterQuery) beinhaltet?
Hast Du eventuell gute Links wo die DAO Klassen erklärt werden bzw. ich werde mal nach Googlen?

Thx
Goodcat

 

[goodcat]

Also diese DAO Geschichte muss ich mir nochmal genauer anschauen.
Der DB Zugriff funktioniert soweit einwandfrei.

Jetzt nur noch eine Frage und zwar wie ich die Abfrage in einem extra Thread ausführen kann?
Ist die Frage was sinniger ist. Ob ich executeQuery() und alterQuery() in eine extra Klasse packe und die Threade oder die ganze MySQLConnection Klasse Threade? Vermutlich ist es nicht so sinnvoll die ganze MySQLConnection klasse zu Threaden?!

public class Session {

	private static final Session INSTANCE = new Session();
	private MySQLConnection dbConnection;

	private Session() {
	}

	public static Session getInstance() {
		return INSTANCE;
	}

	public MySQLConnection getMySQLClass() {
		if (dbConnection == null) {
			dbConnection = new MySQLConnection();
		}
		return dbConnection;
	}

}

public class MySQLConnection {

	private MysqlDataSource ds = new MysqlDataSource();
	private Connection dbConnection;
	private Statement stm;
	private ResultSet rs;
	private ConfigFile iniFile;

	public MySQLConnection() {
		this.iniFile = new ConfigFile();
		
	}

	/**
	 * Prüft ob eine Verbindung besteht oder ob Sie geschlossen wurde und
	 * liefert eine Connection zurück.
	 * 
	 * @return Connection
	 */
	public Connection getConnection() {
		try {
			if (this.dbConnection == null || this.dbConnection.isClosed()) {
				try {
					ds.setDatabaseName(iniFile.getDbname());
					ds.setServerName(iniFile.getServername());
					ds.setPort(Integer.parseInt(iniFile.getServerport()));
					ds.setUser(iniFile.getUsername());
					ds.setPassword(iniFile.getPassword());
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}

		return this.dbConnection;
	}

	/**
	 * Schließt die Verbindung zum Datenbank Server.
	 */
	public void closeConnection() {

		try {
			dbConnection.close();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	/**
	 * Methode zum einfügen von Datensätzen.<br>
	 * Erwartet einen String mit der SQL Query die ausgeführt werden soll.
	 * 
	 * @param query
	 *            String
	 * @return ResultSet
	 */
	public ResultSet executeQuery(String query) {
		try {
			getConnection();
			this.dbConnection = ds.getConnection();
			this.stm = dbConnection.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
			this.rs = stm.executeQuery(query);
		} catch (CommunicationsException e) {
			e.printStackTrace();
			return null;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}

		return this.rs;
	}

	/**
	 * Methode zum löschen von Datensätzen<br>
	 * Erwartet einen String mit der SQL Query die ausgeführt werden soll.
	 * 
	 * @param query
	 *            String
	 */
	public boolean alterQuery(String query) {

		try {
			getConnection();
			this.dbConnection = ds.getConnection();
			this.stm = dbConnection.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
			this.stm.executeUpdate(query);
		} catch (MySQLIntegrityConstraintViolationException e) {
			e.printStackTrace();
			return false;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}

		return true;

	}

}

Und so benutze ich dann das Singleton.
Ich greife nicht auf die Connection direkt zu sondern auf das MySQLConnection Objekt und hole mir dann das ResultSet:

public DefaultComboBoxModel<String> getCustomerDfcbm() {
		
		MySQLConnection dbObj  = Session.getInstance().getMySQLClass();
		
		try {			
			ResultSet rs = dbObj.executeQuery( "SELECT name FROM tbl_customers ORDER BY name ASC;" );
			this.customer = new DefaultComboBoxModel<String>();
				
			this.customer.addElement("");
			
			while (rs.next()) {
				this.customer.addElement(rs.getString(1));
			}
			rs.close();
		}		
		catch (Exception e) {
			e.printStackTrace();
		}
		
		dbObj.closeConnection();
		
		return this.customer;
		
	}

 

[mimo]

Du solltest Dir die Frage stellen, wieviel Zeit die Abfragen durchschnittlich in anspruchnehmen. Hier bei der Initalisierung Deines GUIs liegt die Zeit wahrscheinlich unter 2 Sekunden. Da würde ich keinen extra Thread für einrichten. Alle Abfragen die länger Dauern sollte man durch einen Indikator dem User kenntlich machen. Zum Beispiel durch Änderung des Mousepointersymbols oder durch Anzeige einer Progressbar(Progressdialog). Zum Ändern des Mousepointers benötigst Du auch nicht unbedingt einen neuen Thread und ist sicher sinnvoll. Falls ein neuer Thread erforderlich sein sollte, packe die Initialisierung aller Felder in eine Methode, die Du in einem Runnable kapselst, welches Du anschließend in einem separaten Thread starten kannst.

 

[goodcat]

Tjo also das starten der MainGui geht ruck zuck. Einzelne DB abfragen sind kein Thema.
Ein bisschen nervig wird es wenn ich 30 Einträge nacheinander öffne (eigentlich absolut ok).
Ich habe mal zum Spaß einen SwingWorker die DB Abfragen und den Aufbau der Gui zum bearbeiten des Datensatzes machen lassen.
Interessanterweise dauert es mit dem SwingWorker 3x länger! Aber ich vermute das liegt daran das er jeden Eintrag nacheinander abarbeitet. Nach jedem Eintrag wird die Gui zum bearbeiten geöffnet dann wird zum nächsten Eintrag (DB Zeile) gesprungen usw. Ich vermute das das aufbauen der Gui die verzögerung verursacht...

Dein Tipp wäre ne Möglichkeit nur das problem wird dasselbe sein.
- Ich wähle 40 Datensätze aus und sage bearbeiten
- for Scheife läuft durch und öffnet jede Zeile nacheinander und baut die Gui auf (neues JInternalFrame wird geöffnet)

Wenn ich jetzt ein WarteDialog einblende wird der auch hänger haben. Da durch das öffnen der Eintrage der EDT kurzzeitig ausgelastet ist. So meine vermutung... Thread hin oder her. Da ja alle Swing Operationen im EDT abgearbeitet werden, wenn ich mich nicht irre.

Aber wann öffnet man schonmal 40 Fenster... mal davon abgesehen wenn ich 40 Fenster (MDI) aufhabe die Oberfläche sowieso "langsamer" ist (fühlt sich "schmierig" an wenn Fenster verschoben werden...).

Also ich denke mal das Threads absolut unnötig sind... eventuell könnte man noch Performance gewinnen wenn ich die DB Querys sammle und aufeinmal abschicke (Transaktionen) ..


Hat sich erstmal alles erledigt, muss als nächstes sowieso die Struktur von dem Prog. komplett überarbeiten... Die OOP bereitet mir echt Kopfschmerzen, bin da noch nicht ganz durchgestiegen :rtfm:
Vielen Dank für deine Hilfe, das mit dem Singleton funzt 1A!!
Goodcat