Ich erstelle gerade eine Datenbankapplikation, welche auf MySQL zugreift!
Ich habe mehrere GUI Klassen.
In allen GUI Klassen (Masken) habe ich Abfragen zu erledigen!
Frage:
Wie kann ich es verhindern in jeder Klasse eine neue DB-Verbindung aufzubauen? So, dass ich meine Connection in jeder Klasse verwenden kann?
Es gibt verschiedene Möglichkeiten, du kannst die Connection weiterreichen oder eine Klasse schreiben von der du dir eine Connection abholen kannst. Du könntest zum Beispiel ein Singleton schreiben, von welchem du Connections bekommst. Später kannst du die Connection in einen ConnectionPool umbauen.
Es gibt natürlich auch schon fertige Connection-Pools, solltest dich mal ein bischen umschauen...
danke. Ich habe eine entsprechende Klasse für das erstellen der Connection erstellt:
Code:
DB CONNECTION = new DB();
... dies wird in der Hauptklasse meiner Applikation geöffnet und erstellt mir in der Klasse DB eine Connection!
Code:
public class DB {
public Connection conn;
public DB() {
try {
Connect();
}
catch (Exception ex) {
ex.printStackTrace();
}
}
static void Connect() {
try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection(
"jdbc:mysql://localhost/flightflow?user=root&password=gismo");
System.out.print("DB-Connect established!");
}
catch (ClassNotFoundException ex) {
/** @todo Diese Exception verarbeiten */
}
catch (SQLException ex) {
/** @todo Diese Exception verarbeiten */
}
}
... Jedoch kann ich nur in meiner Hauptklasse auf CONNECTION zugreifen. In einer anderen Klasse ist kein Zugriff möglich. Mache ich denn einen Überlegungsfehler?
Jo, wie gesagt, du solltest ein Singleton daraus machen, also ungefähr so:
Code:
public class ConnectionPool {
private final static ConnectionPool INSTANCE = new ConnectionPool ();
private ConnectionPool () {
}
public synchronized Connection getConnection(){
// hier Connection öffnen oder vorhandene ausliefern
return con;
}
public synchronized void putConnection(Connection con){
// hier Connection schließen oder aufheben für spätere Auslieferung
}
public synchronized static ConnectionPool getInstance(){
return INSTANCE;
}
}
Und dann kommst du an die einzige Instanz dieser Klasse von überall ran indem du:
Code:
public class MyConnectionUser {
public MyConnectionUser() {
ConnectionPool connectionPool = ConnectionPool .getInstance();
Connection con = connectionPool.getConnection();
// arbeit erledigen
connectionPool.putConnection(con);
}
}
Also falls dir weder "Singleton", "Design Pattern" noch "Connection-Pool" ein Begriff sind, solltest du noch ein bischen lesen, aber mit dem o.g. Beispiel kannst du schonmal loslegen. Wie der Name schon sagt und wie ich in den Kommentaren angedeutet habe ist es üblich das der Connection Pool eine gewisse Anzahl von Connection offen hält und diese immer wieder benutzt werden.
1. variablen werden klein geschrieben (=> Connection)
2. variablen werden private deklariert (=> Connection)
3. erledigt man in der GUI keine abfragen, sondern im controller
4. singleton verwenden (wie schon gesagt)
5. ja du machst was falsch. du deklarierst conn als Instanzvariable und deklarierst eine weitere Variable conn als temporäre Variable in der Funktion "Connect"
Code:
public class DB {
public Connection conn;
public DB() {
try {
Connect();
}
catch (Exception ex) {
ex.printStackTrace();
}
}
static void Connect() {
try {
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection(
"jdbc:mysql://localhost/flightflow?user=root&password=gismo");
System.out.print("DB-Connect established!");
}
catch (ClassNotFoundException ex) {
/** @todo Diese Exception verarbeiten */
}
catch (SQLException ex) {
/** @todo Diese Exception verarbeiten */
}
}
