# MySQL-Verbindung in anderer Klasse nutzen



## perlfan (2. Jan 2016)

Hallo zusammen,

ich habe eine MySQL-Methode, mit der ich erfolgreich in einer anderen Klasse über MySQL.Queries(URL, USERNAME, PASSWORD); eine Verbindung aufbauen kann.

Meine Frage ist nun, wie ich in anderen Klassen auf die Verbindung zugreifen kann, um dann z.B. Selects auszuführen (wie in meiner Queries-Methode mit PreparedStatement)? Ich möchte zentral einmal die Verbindung aufbauen und diese dann mehrfach nutzen.

Vielen Dank für eure Hilfe!

Grüße, Frank


```
public class MySQL {

  public static void Queries(String URL, String USERNAME, String PASSWORD) {  
    try {
  // connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);
  Connection conn = DriverManager.getConnection(URL,USERNAME,PASSWORD);
    PreparedStatement ps = conn.prepareStatement("SELECT lastname FROM employees WHERE ID=2");
  
  ResultSet rs = ps.executeQuery();
  
  MessageBox.show("MYSQL OK", "MYSQL");
  
  while (rs.next())
  
  // label.setText(rs.getString(1));
  ps.close();
  conn.close();
    } catch (SQLException e) {
  MessageBox.show("Fehler bei der Datenbankabfrage", "Fehler");
  e.printStackTrace();
    }
    }
}
```


----------



## thet1983 (8. Jan 2016)

schreib dir eine klasse die die Connection verwaltet
zb.

```
public class ConnectionManager{
  Connection conn;
 
  public static Connection connect(){
     if(conn == null)
        // lade drivermanager / class etc..
     return conn;
  }
}
```

und wenn du die in einer anderen klasse benötigst dann machst du vom Connection Object
Getter und Setter
zb.

```
Connection connection;
public getConnection(){return connection;}
public void setConnection(Connection connection){this.connection = connection;}

// bei der verwendung in einer anderen klasse schreibst du dann 
setConnection(ConnectionManager.connect());
// oder du lädst eine connection und reichst sie immer weiter von klasse zu klasse
classB.setConnection(getConnection()/*classA*/);
```


----------



## kneitzel (8. Jan 2016)

Also ein generelles Pattern, das sehr oft verwendet wird, ist ein komplett anderes:
Eine Connection wird, wann immer diese benötigt wird, geöffnet und dann wieder geschlossen.
Es wird keine Connection geöffnet um diese dann geöffnet zu lassen und immer wieder neu zu nutzen.

Wieso ist dies so?
Wenn Du eine Connection immer wieder weiter verwenden willst, dann müsstest Du immer den Status der Connection überprüfen. Die Connection kann ungültig werden weil es z.B. einen Timeout gab oder so. Dies ist aber eine Arbeit, die einfach unnötig ist.
Desweiteren musst Du so keine Angst haben, wenn Du Verbindungen mit mehreren Threads verwendest. Ist deine zentrale Connection gerade in Benutzung oder ist diese frei?

Jetzt wirst Du evtl. einwenden, dass es aber doch zuviel Zeit kostet, immer eine Verbindung zu öffnen wenn man diese benötigt. Daher würde es Sinn machen, hier ein Connection Pooling aufzubauen! -> Ja, das ist vollkommen richtig. Dies macht tatsächlich Sinn. Und zwar so viel Sinn, dass dieses Connection Pooling eigentlich bei jeder Datenbank mit vorhanden sind. Bei MySQL gibt es dies auf jeden Fall beim Connector/J:
https://dev.mysql.com/doc/connector...genotes-j2ee-concepts-connection-pooling.html

(In meinen Augen würde ich eigentlich keine Datenbank-Software nutzen, die dies nicht bietet. Das ist einfach eine existenzielle Sache und wenn die fehlt möchte ich nicht wissen, was sonst noch so an Dingen fehlt.)

Konrad


----------

