Java-SQL: Unterschied zwischen den Versionen
(6 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt) | |||
Zeile 28: | Zeile 28: | ||
Es soll jetzt eine Java-Methode entwickelt werden, die alle Schüler | Es soll jetzt eine Java-Methode entwickelt werden, die alle Schüler einer Klasse als eine Liste vom Inhaltstyp <code>Person</code> zurückgibt.<br/>Die Klasse soll man als Parameter <code>pKlasse</code> übergeben können. | ||
D.h. die Methodenkopf soll wie folgt aussehen: | |||
<code> | |||
public List<Person> schuelerDerKlasse(String pKlasse) | |||
</code> | |||
''(Die Klasse Person hat einen Konstruktor <code>public Person(String pName, String pVorname)</code> - mehr muss man über die Klasse Person hier nicht wissen.)'' | |||
==Datenbank-Abfrage== | |||
Die '''Datenbank-Abfrage''', die das ermöglicht, ist die folgende - hier aufgezeigt am Beispiel der 8B: | Die '''Datenbank-Abfrage''', die das ermöglicht, ist die folgende - hier aufgezeigt am Beispiel der 8B: | ||
<code> | <code> | ||
Zeile 35: | Zeile 43: | ||
FROM schueler s JOIN klasse k | FROM schueler s JOIN klasse k | ||
ON s.klasse_id = k.id | ON s.klasse_id = k.id | ||
WHERE k.name = '8B' | WHERE k.name = '<font color='red'>8B</font>' | ||
</code> | </code> | ||
Diese Datenbank-Abfrage sollte man vorab entwickelt und getestet haben. | |||
''Es ist besser, wenn man für die SQL-Abfrage <u>einfach Anführungszeichen</u> nimmt!''<br/> | |||
''Die doppelten Anführungszeichen braucht man für Java!'' | |||
==Strategie== | ==Strategie== | ||
Zeile 42: | Zeile 55: | ||
# Es gibt ein Attribut <code>connector</code> vom Typ <code>DatabaseConnector</code> | # Es gibt ein Attribut <code>connector</code> vom Typ <code>DatabaseConnector</code> | ||
# Im Konstruktor wird der <code>connector</code> erzeugt. | # Im Konstruktor wird der <code>connector</code> erzeugt. | ||
# In der Methode <code> | # In der Methode <code>schuelerDerKlasse(String pKlasse)</code> geht man so vor: | ||
## SQL-Statement "zusammenbauen": <br/><code>String sqlStatement = " SELECT ..."</code> | ## SQL-Statement "zusammenbauen": <br/><code>String sqlStatement = " SELECT ..."</code> | ||
## SQL-Statement ausführen: <br/><code>connector.executeStatement(sqlStatement);</code> | ## SQL-Statement ausführen: <br/><code>connector.executeStatement(sqlStatement);</code> | ||
Zeile 48: | Zeile 61: | ||
## Die Daten des Ergebnisses ermitteln: <br/><code>String[][] data = queryResult.getData();</code><br/>Man erhält ein 2-dimensionales Array. <br/>Dabei ist die erste Dimension für die Zeilen, die zweite Dimension für die Spalten. | ## Die Daten des Ergebnisses ermitteln: <br/><code>String[][] data = queryResult.getData();</code><br/>Man erhält ein 2-dimensionales Array. <br/>Dabei ist die erste Dimension für die Zeilen, die zweite Dimension für die Spalten. | ||
## Die Zeilen werden mit einer <code>for</code>-Schleife durchlaufen: <br/><code>for (int i = 0; i < data.length; i++)</code> | ## Die Zeilen werden mit einer <code>for</code>-Schleife durchlaufen: <br/><code>for (int i = 0; i < data.length; i++)</code> | ||
## Jetzt liest man die einzelnen Werte nach Spaltennummer aus, z.B. für | ## Jetzt liest man die einzelnen Werte nach Spaltennummer aus, z.B. für den Namen<br/><code>String name = data[i][0];</code> | ||
## Man erhält grundsätzlich Objekte vom Typ <code>String</code>. <br/>Evtl. muss man sie noch in einen richtigen Datentyp konvertieren | ## ''Man erhält grundsätzlich Objekte vom Typ <code>String</code>. <br/>Evtl. muss man sie noch in einen richtigen Datentyp konvertieren.'' | ||
==Java-Code== | ==Java-Code== | ||
Zeile 64: | Zeile 77: | ||
} | } | ||
'''public List< | '''public List<Person> schuelerDerKlasse(String <font color='red'>pKlasse</font>){''' | ||
List< | List<Person> ergebnis = new List<Person>(); | ||
<font color='blue'><b>//Das SQL-Statement zusammenbauen</b></font> | <font color='blue'><b>//Das SQL-Statement zusammenbauen</b></font> | ||
<font color='blue'><b>// Der Paramenter | <font color='blue'><b>// Der Paramenter <font color='red'>pKlasse</font> wird "eingebaut". - man muss auf die Leerzeichen achten!!</b></font> | ||
<font color='blue'><b>// Dabei muss man muss auf die <u>Leerzeichen</u> achten...</b></font> | |||
<font color='blue'><b>// ... und die </font><font color='orange'><u>einfachen Anführungszeichen für SQL</u></font><font color='blue'> mitschreiben! </b></font> | |||
String sqlStatement = | String sqlStatement = | ||
" <font color='grey'>SELECT | " <font color='grey'>SELECT s.name, s.vorname</font> "+ | ||
" <font color='grey'>FROM | " <font color='grey'>FROM schueler s JOIN klasse k</font> "+ | ||
" <font color='grey'> | " <font color='grey'>ON s.klasse_id = k.id</font> "+ | ||
" <font color='grey'> | " <font color='grey'>WHERE k.name = </font><font color='orange'><b>'</b></font>" +<font color='red'><b> pKlasse </b></font>+ "<font color='orange'><b>'</b></font> "; | ||
<font color='blue'><b>// Zur Kontrolle das SQL-Statement ausgeben</b></font> | <font color='blue'><b>// Zur Kontrolle das SQL-Statement ausgeben</b></font> | ||
System.out.println(sqlStatement); | System.out.println(sqlStatement); | ||
Zeile 91: | Zeile 106: | ||
} | } | ||
<font color='blue'><b>// Das Ergebnis der | <font color='blue'><b>// Das Ergebnis der Datenbankabfrage ermitteln:</b></font> | ||
<font color='blue'><b>// Man erhält ein Objekt vom Typ QueryResult</b></font> | <font color='blue'><b>// Man erhält ein Objekt vom Typ QueryResult</b></font> | ||
QueryResult queryResult = connector.getCurrentQueryResult(); | QueryResult queryResult = connector.getCurrentQueryResult(); | ||
Zeile 104: | Zeile 119: | ||
for (int i = 0; i < data.length; i++) { | for (int i = 0; i < data.length; i++) { | ||
<font color='blue'><b>// Die einzelnen <u>Spalten</u> einer Zeile abfragen </b></font> | <font color='blue'><b>// Die einzelnen <u>Spalten</u> einer Zeile abfragen </b></font> | ||
String | String name = data[i][0]; | ||
String | String vorname = data[i][1]; | ||
<font color='blue'><b>// ein | <font color='blue'><b>// ein Person-Objekt erzeugen ...</b></font> | ||
Person p = new Person(name, vorname); | |||
<font color='blue'><b>// ... und an die Liste ergebnis anhaengen</b></font> | <font color='blue'><b>// ... und an die Liste ergebnis anhaengen</b></font> | ||
ergebnis.append( | ergebnis.append(p); | ||
} | } | ||
return ergebnis; | return ergebnis; | ||
Zeile 126: | Zeile 136: | ||
} | } | ||
</code> | </code> | ||
Aktuelle Version vom 6. Februar 2024, 17:29 Uhr
Auf dieser Seite wird erklärt, wie man aus Java heraus SQL-Abfragen auf einer Datenbank ausführen kann.
Einschränkung der Allgemeingültigkeit dieser Seite:
Hier werden die Klassen DatabaseConnector.java
und QueryResult.java
verwendet, deren Schnittstelle vom Zentralabitur NRW vorgegeben ist
Erklärvideo
Mit Java auf Datenbanken zugreifen (gemäß Schnittstelle NRW-Zentralabitur)
Fachbegriffe
SQL-Abfrage, Parameter, QueryResult, 2-dimensionales Array, Zeile und Spalte(im 2-dim. Array)
Schnittstelle des Zentralabitur
Datei:DatabaseConnector QueryResult Abi 2018.pdf
Beispiel
Vorüberlegungen
Das folgende Beispiel bezieht sich auf die Datenbank Schule, die auch im Unterricht häufig zum Einsatz kommt.
Das Datenbank-Modell und alle Daten der Datenbank finden sich hier:
Es soll jetzt eine Java-Methode entwickelt werden, die alle Schüler einer Klasse als eine Liste vom Inhaltstyp Person
zurückgibt.
Die Klasse soll man als Parameter pKlasse
übergeben können.
D.h. die Methodenkopf soll wie folgt aussehen:
public List<Person> schuelerDerKlasse(String pKlasse)
(Die Klasse Person hat einen Konstruktor public Person(String pName, String pVorname)
- mehr muss man über die Klasse Person hier nicht wissen.)
Datenbank-Abfrage
Die Datenbank-Abfrage, die das ermöglicht, ist die folgende - hier aufgezeigt am Beispiel der 8B:
SELECT s.name, s.vorname
FROM schueler s JOIN klasse k
ON s.klasse_id = k.id
WHERE k.name = '8B'
Diese Datenbank-Abfrage sollte man vorab entwickelt und getestet haben.
Es ist besser, wenn man für die SQL-Abfrage einfach Anführungszeichen nimmt!
Die doppelten Anführungszeichen braucht man für Java!
Strategie
Die möglichen Fehlerbehandlungen werden in der Strategie nicht berücksichtigt.
- Es gibt ein Attribut
connector
vom TypDatabaseConnector
- Im Konstruktor wird der
connector
erzeugt. - In der Methode
schuelerDerKlasse(String pKlasse)
geht man so vor:- SQL-Statement "zusammenbauen":
String sqlStatement = " SELECT ..."
- SQL-Statement ausführen:
connector.executeStatement(sqlStatement);
- Das Ergebnis der SQL-Abfrage ermitteln:
QueryResult queryResult = connector.getCurrentQueryResult()
- Die Daten des Ergebnisses ermitteln:
String[][] data = queryResult.getData();
Man erhält ein 2-dimensionales Array.
Dabei ist die erste Dimension für die Zeilen, die zweite Dimension für die Spalten. - Die Zeilen werden mit einer
for
-Schleife durchlaufen:for (int i = 0; i < data.length; i++)
- Jetzt liest man die einzelnen Werte nach Spaltennummer aus, z.B. für den Namen
String name = data[i][0];
- Man erhält grundsätzlich Objekte vom Typ
String
.
Evtl. muss man sie noch in einen richtigen Datentyp konvertieren.
- SQL-Statement "zusammenbauen":
Java-Code
public class DatenbankTest {
private DatabaseConnector connector;
public DatenbankTest() {
// Die Verbindung zur Datenbank aufbauen
// ip port database user password
connector = new DatabaseConnector("localhost", 3306, "demo", "admin", "geheim");
String errorMessage = connector.getErrorMessage();
if(errorMessage != null) System.err.println(errorMessage);
}
public List<Person> schuelerDerKlasse(String pKlasse){
List<Person> ergebnis = new List<Person>();
//Das SQL-Statement zusammenbauen
// Der Paramenter pKlasse wird "eingebaut". - man muss auf die Leerzeichen achten!!
// Dabei muss man muss auf die Leerzeichen achten...
// ... und die einfachen Anführungszeichen für SQL mitschreiben!
String sqlStatement =
" SELECT s.name, s.vorname "+
" FROM schueler s JOIN klasse k "+
" ON s.klasse_id = k.id "+
" WHERE k.name = '" + pKlasse + "' ";
// Zur Kontrolle das SQL-Statement ausgeben
System.out.println(sqlStatement);
// Das SQL-Statement ausführen
connector.executeStatement(sqlStatement);
// Abbruchbedingung für einen Error
String errorMessage = connector.getErrorMessage();
if(errorMessage != null)
{
// Die Fehlernachricht ausgeben
System.err.println(errorMessage);
return null;
}
// Das Ergebnis der Datenbankabfrage ermitteln:
// Man erhält ein Objekt vom Typ QueryResult
QueryResult queryResult = connector.getCurrentQueryResult();
// Die Daten aus QueryResult auslesen
// Die Daten werden als 2-dim. Array wiedergegeben:
// 1. Dimension: Zeile des Ergebnisses
// 2. Dimension: Spalte des Ergebnisses (in der Reihenfolge wie im SQL-Statement
String[][] data = queryResult.getData();
// Die Zeilen durchlaufen
for (int i = 0; i < data.length; i++) {
// Die einzelnen Spalten einer Zeile abfragen
String name = data[i][0];
String vorname = data[i][1];
// ein Person-Objekt erzeugen ...
Person p = new Person(name, vorname);
// ... und an die Liste ergebnis anhaengen
ergebnis.append(p);
}
return ergebnis;
}
public static void main(String[] args) {
new GUI(new DatenbankTest());
}
}