Führen Sie PostgreSQL unter Java aus
Lassen Sie uns PostgreSQL auf Java ausführen.
Umgebung
- macOS Mojave
- Eclipse 4.7.3
- PostgreSQL 11.4
- JDBC Driver 42.2.5（postgresql-42.2.5.jar）
Einführung des JDBC-Treibers
Der JDBC-Treiber wird als Standard-Java-API für den Zugriff auf die RDB von PostgreSQL benötigt.
Zunächst aus dem Download.
https://jdbc.postgresql.org/download.html#current
Hier wird ** postgresql-42.2.5.jar ** verwendet.
Platziere es irgendwo unter diesem Projekt (ist es in lib / leicht zu verstehen?)
Da es jedoch so ist, ist es nicht möglich zu wissen, wo es sich bezieht, daher ist es notwendig, den Pfad festzulegen.
Wenn mac
Klicken Sie auf
postgresql-42.2.5.jar** Registerkarte Projekt ** -> ** Eigenschaften ** -> ** Java-Erstellungspfad ** -> ** Bibliothek ** -> * * Externe JAR hinzufügen ** -> Findpostgresql-42.2.5.jarund open-> ** Übernehmen und schließen **
OK, wenn auf postgresql-42.2.5.jar in der Referenzbibliothek in verwiesen wird
DB zu verwenden
Dieses Mal werden wir alle zuvor verwendeten wiederverwenden.
Die Benutzer sind wie folgt
terminal
customer=# \l
List of databases
Name | Owner | Encoding | Collate | Ctype | Access privileges
-----------+-------------+----------+---------+-------+-----------------------
customer | sf213471118 | UTF8 | C | C |
Die Tabelle verwendet die ** Kunden ** -Tabelle
terminal
customer=# \d
List of relations
Schema | Name | Type | Owner
--------+----------+-------+-------------
public | customer | table | sf213471118
Der Inhalt der ** Kundentabelle ** ist wie folgt
terminal
customer=# SELECT * FROM customer;
id | name | gender | age
-----------------+----------+--------+-----
10001 |Taro Tanaka| m | 31
10002 |Hanako Nakamura| w | 44
10003 |Ichiro Sato| m | 20
10004 |Aya Uchida| w | 18
10005 |Jiro Takahashi| m | 56
10006 |Satoru Nakazato| m | 34
(6 rows)
Ein wichtiger Teil beim Schreiben von Java
Ich werde einen Ort verlassen, an den ich mich beim Schreiben erinnern möchte.
Ausnahmebehandlung
.java
public static void main(String[] args) throws Exception {
try {
System.out.println("DB access start");
PostgreSQL_test.dbConnect();
} catch (Exception e) {
System.out.println("error main()");
e.printStackTrace();
} finally {
System.out.println("DB access finished");
}
}
Die Ausnahmebehandlung wird durch "try-catch (-finally)" beschrieben.
In diesem Beispiel kann, da es sich um "Ausnahme e" handelt, nur der Ort des Fehlers angegeben werden. Es ist jedoch auch möglich, den Fehlerinhalt sofort zu erfassen, indem die Fangbedingung geändert und parallel geschrieben wird.
Zum Beispiel
.java
try {
file_reader = new FileReader(customer);
~
} catch (FileNotFoundException f) { //Dateisuchfehler
System.out.println("cannot find file");
f.printStackTrace();
} catch (IOException i) { //Dateieingabe- / Ausgabefehler
System.out.println("in/out error");
i.printStackTrace();
} finally {
try {
if(file_reader != null) {
file_reader.close();
}
} catch (IOException i) { //Fehler beim Schließen der Datei
System.out.println(i);
i.printStackTrace();
}
}
Wenn es einen Fluss gibt
① try --catch --catch
- Wenn Sie "neuer FileReader (Kunde)" ausführen, aber den Dateinamen nicht finden können
- ** Kunde ** Wenn eine Datei vorhanden ist, diese aber nicht ausgegeben werden kann
Es ist unter Berücksichtigung der beiden verzweigt.
② endlich - versuchen - fangen
- Fehler beim Schließen
Nur erkannt.
Es gibt viele andere Ausnahmen als "FileNotFoundException" und "IOException", aber Sie können alle Fehler mit "Exception" abfangen (obwohl ich nur daran denken kann, den Speicherort wie in Programm 2 oben angegeben anzugeben. )
Für DB-Verbindung
JDBC-Initialisierung
Sie müssen den JDBC-Treiber initialisieren, bevor Sie eine Verbindung zur Datenbank herstellen.
Schreiben Sie im Fall von PostgreSQL wie folgt
.java
Class.forName("org.postgresql.Driver").newInstance();
DB-Verbindung herstellen / DB trennen
Darüber hinaus muss die Methode ** getConnection ** verwendet werden, über die die Klasse ** DriverManager ** standardmäßig verfügt, um die DB-Verbindung herzustellen.
.java
connection = DriverManager.getConnection( <URL> , <USER>, <PASSWORD>);
Die URL lautet "jdbc: postgresql: //
Dieses Mal habe ich es unten eingestellt.
| Ort | Port-Nummer | DB-Name |
|---|---|---|
| localhost | 5432 | customer |
Stellen Sie in Bezug auf die Trennung sicher, dass Sie ** endlich ** für alle Fälle verwenden.
.java
rs.close(); //rs ist eine Variable in der ResultSet-Schnittstelle
Beschreibung der SQL-Anweisung
Wenn Sie SQL an DB senden, müssen Sie zuerst eine Anweisung mit der in der Schnittstelle ** Connection ** definierten Methode ** createStatement ** erstellen (muss beim Senden von SQL als Satz geschrieben werden).
.java
statement = con.createStatement();
Schreiben Sie nach Abschluss des obigen Vorgangs eine Abfrage für die SQL-Anweisung.
.java
resultset = stm.executeQuery(" <SQL-Anweisung> ");
Datenausgabe
Sie können zeilenweise mit der ** next () ** -Methode der ** ResultSet ** -Schnittstelle verarbeiten.
.java
while (rs.next()) {
System.out.println(rs.getInt("<column>"));
System.out.println(rs.getString("<column>"));
}
Diesmal Java-Beschreibung
PostgreSQL_test.java
package customer;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class PostgreSQL_test {
public static void main(String[] args) throws Exception {
try {
System.out.println("DB access start");
PostgreSQL_test.dbConnect();
} catch (Exception e) {
System.out.println("error main()");
e.printStackTrace();
} finally {
System.out.println("DB access finished");
}
}
private static void dbConnect() throws Exception {
Connection con = null;
Statement stm = null;
ResultSet rs = null;
int num = 1;
String url = "jdbc:postgresql://localhost:5432/customer";
String user = "sf213471118";
String password = ""; //Diesmal wurde kein Passwort festgelegt
try {
Class.forName("org.postgresql.Driver").newInstance();
con = DriverManager.getConnection(url, user, password);
stm = con.createStatement();
rs = stm.executeQuery("SELECT * FROM customer");
while (rs.next()) {
System.out.println("[" + num + "Artikel]");
num++;
System.out.println("id : " + rs.getString("id"));
System.out.println("name : " + rs.getString("name"));
System.out.println("gender : " + rs.getString("gender"));
System.out.println("age : " + rs.getInt("age"));
}
} catch(SQLException e) {
System.out.println("error dbConnect()");
e.printStackTrace();
}finally {
try {
if ((rs != null)||(stm != null)||(con != null)) {
rs.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
Wenn Sie dies verschieben, wird Folgendes zurückgegeben.
JavaConsole
DB access start
[1. Fall]
id : 10001
name :Taro Tanaka
gender : m
age : 31
[2 ..]
id : 10002
name :Hanako Nakamura
gender : w
age : 44
[3. Fall]
id : 10003
name :Ichiro Sato
gender : m
age : 20
[4 ..]
id : 10004
name :Aya Uchida
gender : w
age : 18
[5 ..]
id : 10005
name :Jiro Takahashi
gender : m
age : 56
[6 ..]
id : 10006
name :Satoru Nakazato
gender : m
age : 34
DB access finished
Wenn es wahr ist, wollte ich die aktuelle Anzahl von Fällen mit rs.next () ausgeben, aber ich habe es nicht gut verstanden, also habe ich es mit einem Seufzer ausgegeben. .. ..
~~ Ich würde mich sehr freuen, wenn mir jemand beibringen könnte, wie es geht ~~
[Ergänzung] 29.7.2019
Danke für deinen Kommentar. Ich habe es wie folgt behoben.
① Erhalten Sie die Anzahl der Versuche des Schleifenteils mit rs.getRow ()
PostgreSQL_test.java
while (rs.next()) {
System.out.println("[" + rs.getRow() + "Artikel]"); /*Korrekturteil*/
System.out.println("id : " + rs.getString("id"));
System.out.println("name : " + rs.getString("name"));
System.out.println("gender : " + rs.getString("gender"));
System.out.println("age : " + rs.getInt("age"));
}
②Freie enge Auslassung behoben
PostgreSQL_test.java
try {
if ((rs != null)||(stm != null)||(con != null)) {
rs.close();
stm.close(); /*Korrekturteil*/
con.close(); /*Korrekturteil*/
}
} catch (Exception e) {
e.printStackTrace();
}
Danke nochmal.
Recommended Posts