Muss Datenbankverbindung immer neu geöffnet werden?

Hi Leute,

bin neu hier:)

Meine Frage ist folgende:```private void connectionToDatabase()
{
try
{
Class.forName(“com.mysql.jdbc.Driver”).newInstance();
}
catch(InstantiationException ie)
{
System.out.println(ie);
}
catch(IllegalAccessException ia)
{
System.out.println(ia);
}
catch(ClassNotFoundException cl)
{
de.getErrorMessage(“Verbindung konnte nicht erstellt werden!”, “Error”);
System.out.println(cl);
}
try
{
con = DriverManager.getConnection(url, userName, password);
}

	catch(SQLException sql)
		{
			System.out.println("Verbindung nicht vorhanden" + sql);
		}}```

Muss ich eigentlich jedesmal, wenn ich Daten aus der DB (MySQL) aufrufen/einfügen möchte,
diese Methode aufrufen? Oder kann man die Verbindung nicht “offen lassen”?

Hoffe ich konnte mich verständlich ausdrücken.

danke,

monet

Generell ist die Herstellung einer Datenbankverbindung ein “teurer” Prozess. Daher ist es durchaus legitim, die Verbindung zum Start einer Anwendung herzustellen und so lange sie benötigt wird geöffnet zu halten.

Kommt auf den Anwendungsfall an. Bei 20.000 Clients, die nicht ständig eine Verbindung zur DB benötigen, würde ich diese auch nicht immer offen halten.

Das hier: Class.forName(“com.mysql.jdbc.Driver”).newInstance(); kannst du auf Class.forName(“com.mysql.jdbc.Driver”); stützen und brauchst du nur einmal am Anfang.

Hi und danke für euer Antworten:) nur bei mir klappt das nicht, so wie ich es mir gedacht habe.

Vllt habt ihr eine Idee, hier mal ein paar Ausschintte:

private void abfrageDatenbankAdresse()
		{
			try
			{	String str = "SELECT * FROM adresse";
				stat = c.createStatement();
				rs = stat.executeQuery(str);
				
					while(rs.next())
					{
						name = rs.getString("name");
						vorname = rs.getString("vorname");
					}
					stat.close();
				rs.close();
			con.close();
			}
			
			catch(SQLException sql)
			{
				System.out.println(sql);
			}
		}

Bei mir sieht es so aus:

Klick 1: Button_1 (aus einer anderen Klasse) ruft die Methode “connectionToDatabase()”
(dann müsste doch eine Verbindung bestehen),
Klick 2 :der Button_2 ruft dann die Methode “abfrageDatenbankAdresse()” auf.
Was ich dann bekomme ist eine “NullPointerException” auf diese
Methode “stat = c.createStatement();” in der Methode “abfrageDatenbankAdresse()”.
D.h. für mich, dass die Referenzvar. con von Connection den Wert “null” hat.

Wenn ich aber diese Variante wähle, dann bekomme ich die Daten aus der DB. Nur ich
kann auf diese Daten mit einem andern Button nicht zugreifen…

private void abfrageDatenbankAdresse(Connection c)
		{
			try
			{ connectionToDatabase() //siehe mein oberes posting
	                    String str = "SELECT * FROM adresse";
				stat = c.createStatement();
				rs = stat.executeQuery(str);
				
					while(rs.next())
					{
						name = rs.getString("name");
						vorname = rs.getString("vorname");
					}
                           rs.close();
			 stat.close();				
			con.close();
			}
			
			catch(SQLException sql)
			{
				System.out.println(sql);
			}
		}

Vllt habt ihr eine Idee. Da ich zur Zeit nur alleine auf diese DB zugreife, kann sie ja zu Testzwecken
immer offenbleiben.

Danke,

monet

Was haltet ihr von der Idee, dass ich die Methode "connectionToDatabase() " einfach in
den Konstruktor der Klasse einbaue, wo sich halt die Methode "abfrageDatenbankAdresse() "
befindet?

Wäre das eine “sinnvolle” Lösung? Oder eher eine “schmutzige” Programmierung?

Danke,

monet

Sinnvoll ist es eine Klasse zu haben, die die Datenbankverbindung herstellt und bei Bedarf zurückgeben kann.
Diese Klasse kann auch statisch sein, wenn nur eine Verbindung zu einer Datenbank gehalten werden soll.

Von dieser Klasse muss dann entsprechend immer ein Exemplar gehalten werden. So stellst du sicher, dass du (eine) immer die gleiche Verbindung zur Datenbank benutzt.

Dann ist es sinnvoll eine Klasse zu haben, die die Anfragen an eine Datenbank in SQL-Queries umsetzt und an die Datenbank schickt. Und eine weitere Klasse, die die ResultSets entsprechend auf Objekten abbildet.

Innerhalb deines Programms arbeitest du dann nur noch mit diesen Objekten.

Aus deinen Schnipseln lässt sich auf den ersten Blick nicht entnehmen, wo das Problem sitzt.

Hi und danke erstmal,

ich weiß, meine Codes sind echt sparsam. Aber ich versuche mal mein Verständnisprob.
bildlich zu beschreiben.

Ich habe mir das so vorgestellt, dass diese Methode “connectionToDatabase()” (siehe ganz oben)
sozusagen ein Schlüssel für die Tür ist, wo sich dahinter ein DB befindet. Mit der Methode oder mehreren
anderen könnte ich dann halt durch die Anweisung

...stat = c.createStatement();
 rs = stat.executeQuery(str);
 while(rs.next())
 { name = rs.getString("name");
 vorname = rs.getString("vorname"); } 

immer durch die offene Tür gehen und mir die Daten aus der DB holen (bildlich gesprochen)

So eine Art standby-Verbindung zur DB.

Ich habe auch gelesen, dass die Methode “close()” nur virtuel die Verbindung trennt und nicht
statisch. ist das richtig?

Ist meine (bildliche) Vorstellung richtig oder sehe ich das falsch?

wie geht denn das?

Ich kann das aber im Moment nur machen, wenn ich die Methode “connectionToDatabase()” (siehe Thread ganz oben) mit einbeziehen
wie hier:

private void abfrageDatenbankAdresse(Connection c)
 { try { 
          connectionToDatabase() //siehe mein oberes posting 
          String str = "SELECT * FROM adresse";
         stat = c.createStatement();
         rs = stat.executeQuery(str);
              while(rs.next()) 
                 { name = rs.getString("name");
                   vorname = rs.getString("vorname"); 
}
                   rs.close(); 
                 stat.close();
             con.close(); }

 catch(SQLException sql)
 { System.out.println(sql); } }

Wenn ich diese Methode ohne die “connectionToDatabase()” mache, bekomme ich eine
“NullPointerException” auf diese Methode “stat = c.createStatement();”, hier im Code.

danke,
monet

Hi L-extron-X,

ich habe mir so etwas jetzt gebaut. Was hältst du davon?

import java.sql.*;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.Connection;
import javax.sql.DataSource;
import com.mysql.jdbc.jdbc2.optional.*;

public class VersuchsKlasseDatenbankVerbindung {

	DataSource ds;
	Statement stat;
	ResultSet rs;
	Connection con;
	
	String name;
	String vorname;
	
	public VersuchsKlasseDatenbankVerbindung()
	{
		;
	}
		
	public DataSource getConnectionPoolDataSource(String server, String port,
										String database, String user, String password)
	{
		MysqlConnectionPoolDataSource source;
		
			try{
				source = new MysqlConnectionPoolDataSource();
				source.setServerName(server);
				source.setPort(Integer.parseInt(port));
				source.setDatabaseName(database);
				source.setUser(user);
				source.setPassword(password);
			}
			
			catch(Exception e)
			{
				e.printStackTrace();
				source = null;
			}
		return source;
	}
	
			public void versuch_1()
			{
				try{
					ds = this.getConnectionPoolDataSource("localhost" ,"3306", "adressen", "rXXt", "mXXXXXtXXXXXX");
				
				String str = "SELECT * FROM adresse";
				con = ds.getConnection();
				stat = con.createStatement();
				rs = stat.executeQuery(str);
				
					while(rs.next())
					{
						name = rs.getString("name");
						vorname = rs.getString("vorname");
						System.out.println(name + " " + vorname);
					}
					stat.close();
					}
				
				catch(Exception e)
					{
						e.printStackTrace();
					}
			}

Aber erlich gesagt ich habe nicht viel Ahnung vom dem was ich mir hier gebaut habe.
Ich weiß, dass es ein Connection pool ist aber was bedeutet das eigentlich. Wie erkenne
ich eigentlich ob die Verbindung zur DB physikalisch vorhanden ist und nicht Connection == nul ist?

Ich dachte mir: “Bau Dir eine Verbindung, die dauerhaft ist und dann kannst du mit einer
statemant-Instanz und eine ResultSet aus anderen Methode auf die Db zugreifen…”.
Ist das überhaupt so möglich?

Was bewirkt eigentlch diese Methode?

getConnectionPoolDataSource("localhost" ,"3306", "adressen", "rXXt", "mXXXXXtXXXXXX");

Ist viel zum lesen:( Vllt kannst Du mir dabei helfen!

danke,
monet