Hinzufügen einer PostgreSQL-Datenbank zu einem RESTful-Dienst auf Spring Boot. Teil 1

Lassen Sie mich zunächst sagen, dass mir die Artikelserie von Elleanor Kerry mit dem Titel „REST Overview“ wirklich gefallen hat. Hier finden Sie Links zu diesen Artikeln:

• Übersicht über REST. Teil 1: Was ist REST?
• Übersicht über REST. Teil 2: Kommunikation zwischen Client und Server
• Übersicht über REST. Teil 3: Erstellen eines RESTful-Dienstes in Spring Boot

Im Allgemeinen habe ich beschlossen, mir die Freiheit zu nehmen und ihnen ein wenig hinzuzufügen. Erklären Sie nämlich, wie Sie eine Datenbank erstellen und diese mit dieser Anwendung verbinden. Wo soll ich anfangen? Wahrscheinlich aus der Datenbank selbst. Ich habe mich für PostgreSQL entschieden , weil mir die benutzerfreundliche Admin-Oberfläche gefiel. Zuerst müssen wir das PostgreSQL-Installationsprogramm herunterladen, zum Beispiel von hier: PostgreSQL Database Download Ich werde den vollständigen Installationsprozess nicht beschreiben, weil es kann je nach Betriebssystem unterschiedlich sein. Ich stelle jedoch fest, dass Sie sich dabei ein Administratorkennwort für die Standard- Postgres- Rolle (Konto) ausdenken und dieses zweimal eingeben müssen. Der Einfachheit halber habe ich das Passwort auf 123 gesetzt . Natürlich muss man sich bei realen Projekten etwas Komplizierteres einfallen lassen. Als nächstes fordert Sie das Installationsprogramm auf, einen Port auszuwählen; ich habe ihn auf dem Standardwert belassen. Auch das Gebietsschema wurde als Standard beibehalten. Installiert, dann öffnen Sie die Administratoroberfläche pgAdmin . Es öffnet sich ein Browser mit einem Popup-Fenster, in dem wir aufgefordert werden, das zuvor erstellte Passwort einzugeben. Jetzt müssen wir die Sprache der Benutzeroberfläche festlegen. Klicken Sie dazu auf pgAdmin konfigurieren --> Verschiedenes --> Benutzersprache , wählen Sie die gewünschte Sprache aus --> Speichern und laden Sie die Browserseite neu . Klicken Sie in der oberen linken Ecke der Seite auf Server . Das Fenster „ Mit Server verbinden “ wird angezeigt . Geben Sie unser Passwort erneut ein und aktivieren Sie das Kontrollkästchen Passwort speichern , um es nicht jedes Mal erneut eingeben zu müssen. Wir könnten weiterhin die Administratorrolle für alle Datenbanken verwenden, es wäre jedoch besser, eine neue Rolle zu erstellen, da wir möglicherweise viele Datenbanken und viele Programme haben, die sie verwenden. Klicken Sie dazu in der oberen linken Ecke auf PostgreSQL 12 --> RMB bei Login/Gruppenrollen --> Erstellen --> Login/Gruppenrolle . Geben Sie im Popup-Fenster auf der Registerkarte „ Allgemein “ das ein Name der Rolle. Ich habe die Rolle root genannt . Auf der Registerkarte „ Definition “ erstellen wir ein neues Passwort, ich habe 123 belassen , nur um nicht verwirrt zu werden. Gehen Sie zur Registerkarte „ Rechte “ und markieren Sie alle erforderlichen Elemente. Ich habe alle Punkte auf „ JA “ gesetzt. Klicken Sie auf „ Speichern “. Wir fahren mit der Erstellung einer Datenbank fort. Klicken Sie mit der rechten Maustaste auf „Datenbanken“ -> Erstellen -> Datenbank . Erstellen Sie auf der Registerkarte „ Allgemein “ den Namen der Datenbank. Seien es zum Beispiel Kunden . Den Besitzer weisen wir root zu , den wir im vorherigen Schritt erstellt haben. Auf der "Definition » Überprüfen Sie, ob die UTF8- Kodierung eingestellt ist . Klicken Sie auf „ Speichern “. Das war's, unsere Datenbank wurde erstellt (vorerst leer). An dieser Stelle könnten wir mit pgAdmin enden, weil... Wir werden Tabellen programmgesteuert erstellen, aber für alle Fälle zeige ich Ihnen, wie Sie eine Tabelle manuell erstellen. Erweitern Sie die Kunden -> Schemas -> öffentliche Baumstruktur . Klicken Sie mit der rechten Maustaste auf Tabellen --> Erstellen --> Tabelle . Es öffnet sich ein Popup-Fenster. Auf der Registerkarte „ Allgemein “ weisen wir unserer Tabelle einen Namen zu, zum Beispiel test_table , und weisen root als Eigentümer zu . Gehen Sie zur Registerkarte „ Spalten “ und klicken Sie auf „ + “, um eine neue Spalte zu erstellen. Geben Sie den Namen „ id “ und den Datentyp bigserial ein, der dem Long- Typ in Java entspricht , jedoch mit automatischer Inkrementierung (beim Hinzufügen eines neuen Datensatzes wird die ID automatisch um eins erhöht). Wir markieren Nicht-NULL als „ Ja “, der Primärschlüssel ist ebenfalls „ Ja “. Auf die gleiche Weise erstellen wir die Spalten „ Name “, „ E-Mail “ und „ Telefon “ . Wir wählen den Datentyp Zeichen variierend aus , dieser entspricht dem Typ String , ermöglicht aber die Festlegung der maximalen Länge. Wir legen die maximale Namenslänge auf 200 Zeichen fest, um den vollständigen Namen auszufüllen. in einer Spalte. Wir legen die maximale E-Mail- Länge auf 254 Zeichen fest. Warum E-Mails eine solche maximale Länge haben, erfahren Sie hier . Wählen Sie für eine Telefonnummer 20 Zeichen aus, das sollte ausreichen. Ein wenig über Telefonnummern: Missverständnisse von Programmierern über Telefonnummern (Habr) Wir markieren ungleich NULL in allen Spalten als „ Ja “, wenn wir möchten, dass diese Daten obligatorisch sind. Klicken Sie auf „ Speichern “. Das war's, die Tabelle wurde erstellt. Um unsere Testtabelle zu löschen, klicken Sie mit der rechten Maustaste darauf (im Baum) und „ löschen “, weil Wir brauchen es nicht mehr, da wir Tabellen aus unserem Programm erstellen werden. Schließen Sie pgAdmin und gehen Sie zu unserem Programm. Lassen Sie uns IDEA mit unserem Projekt öffnen. Klicken Sie in der rechten Spalte der Benutzeroberfläche auf „ Datenbank“ und dann auf „ + “, um unsere Datenbank hinzuzufügen. Nächste Datenquelle -> PostgreSQL . Geben Sie im Popup-Fenster im Feld „Benutzer“ die Root- Rolle ein , die wir zuvor erstellt haben, und unser PasswortGeben Sie im Passwortfeld 123 ein . In das Feld Datenbank schreiben wir den Namen unserer Kundendatenbank . Wir drücken die Schaltfläche Verbindung testen und wenn wir darunter ein grünes Häkchen sehen, ist alles in Ordnung und wir drücken die Schaltfläche OK . Das war's, wir haben eine Verbindung zur Datenbank hergestellt, jetzt gehen wir zur Datei pom.xml und fügen Abhängigkeiten hinzu. So arbeiten Sie mit der ORM-Datenbank :

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

So erstellen Sie einen REST-Controller:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>

Für Tomcat-Server:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
</dependency>

Für PostgreSQL:

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.2.10</version>
</dependency>

Nachdem wir nun pom.xml sortiert haben, gehen wir zum Ressourcenordner und füllen die Datei application.properties wie folgt aus:

spring.datasource.url=jdbc:postgresql://localhost:5432/customers
spring.datasource.username=root
spring.datasource.password=123

spring.datasource.driver-class-name=org.postgresql.Driver
spring.jpa.database=postgresql
spring.jpa.database-platform=org.hibernate.dialect.PostgreSQL10Dialect

Hier haben wir die URL unserer Datenbank eingegeben, den Benutzernamen und das Passwort dafür angegeben, den Treiber für PostgreSQL registriert, angegeben, dass wir den PostgreSQL-Datentyp verwenden würden, und den Dialekt für den Ruhezustand angegeben. Als Nächstes erstellen wir ein neues Verzeichnis mit dem Namen „Datenbank“ im selben Ressourcenordner . In diesem Verzeichnis erstellen wir zwei Dateien: initDB.sql und populateDB.sql . Der erste ist für die Erstellung der Tabellen verantwortlich, der zweite für das Ausfüllen dieser zunächst. Öffnen wir initDB.sql und sehen oben einen grünen Balken, der besagt, dass der SQL-Dialekt nicht konfiguriert ist . Das bedeutet, dass wir für unser Projekt keinen SQL-Dialekt gewählt haben (und davon gibt es mehrere). Klicken Sie auf der rechten Seite desselben Streifens auf die Aufschrift „ Dialekt ändern in…“ . Klicken Sie im Popup-Fenster auf „Project SQL Dialect“ und da unsere Datenbank PostgreSQL ist , wählen wir den gleichnamigen Dialekt aus. Klicken Sie auf „OK“. Fahren wir mit dem Ausfüllen unserer .sql- Dateien fort . Füllen wir zunächst die Datei initDB.sql aus :

CREATE TABLE IF NOT EXISTS clients
(
    id    BIGSERIAL PRIMARY KEY ,
    name  VARCHAR(200) NOT NULL ,
    email VARCHAR(254) NOT NULL ,
    phone VARCHAR(20)  NOT NULL
);

Wenn nach dem Ausfüllen der Datei einige andere Wörter als „ Clients“ in weißer Schrift geschrieben sind, klicken Sie mit der rechten Maustaste in den Text und wählen Sie erneut „Dialekt ändern --> PostgreSQL“ . Wie Sie wahrscheinlich bereits verstanden haben, handelt es sich hierbei um dieselben Daten, die wir bei der manuellen Erstellung der Testtabelle eingegeben haben. Hier sind sie im PostgreSQL-Dialekt der SQL-Sprache formatiert. Füllen wir nun die Datei populateDB.sql :

INSERT INTO clients VALUES
(1, 'Vassily Petrov', 'vpetrov@jr.com', '+7 (191) 322-22-33)'),
(2, 'Pjotr Vasechkin', 'pvasechkin@jr.com', '+7 (191) 223-33-22)');

Wenn der Name des Tisches Ihres Kunden in roten Buchstaben geschrieben ist, ist das in Ordnung. Der Punkt ist, dass wir diese Tabelle noch nicht erstellt haben und IDEA sie noch nicht erkennt. Um die Tabelle zu erstellen und zu füllen, müssen wir zur Datei application.properties zurückkehren und dort die folgenden drei Zeilen hinzufügen:

spring.datasource.initialization-mode=ALWAYS
spring.datasource.schema=classpath*:database/initDB.sql
spring.datasource.data=classpath*:database/populateDB.sql

In diesen Zeilen sagen wir, dass wir die Datenbank programmgesteuert initialisieren wollen und geben an, welche Dateien dafür verwendet werden müssen. Gehen Sie als Nächstes zur Hauptmethode unserer Anwendung und starten Sie sie . Gehen Sie danach zu pgAdmin -> Server -> PostgreSQL 12 -> Datenbanken -> Kunden -> Schemas -> öffentlich und klicken Sie mit der rechten Maustaste auf „ Tabellen “, „ Aktualisieren “. Wenn alles gut gelaufen ist, sehen wir die von uns erstellte Kundentabelle . Gehen Sie danach zurück zur Datei application.properties und kommentieren Sie die Zeile aus.

spring.datasource.data=classpath*:database/populateDB.sql

wie nachstehend:

spring.datasource.url=jdbc:postgresql://localhost:5432/customers
spring.datasource.username=root
spring.datasource.password=123

spring.datasource.driver-class-name=org.postgresql.Driver
spring.jpa.database=postgresql
spring.jpa.database-platform=org.hibernate.dialect.PostgreSQL10Dialect

spring.datasource.initialization-mode=ALWAYS
spring.datasource.schema=classpath*:database/initDB.sql
#spring.datasource.data=classpath*:database/populateDB.sql

Wenn wir dies nicht tun, erhalten wir beim nächsten Ausführen des Programms die folgende Fehlermeldung: org.postgresql.util.PSQLException: ERROR: Ein doppelter Schlüsselwert verletzt die eindeutige Einschränkung „clients_pkey“ . Dies geschieht, weil wir die Felder mit den IDs 1 und 2 in der Tabelle bereits ausgefüllt haben (sogar beim ersten Start). In der von uns erstellten Tabelle ist das ID- Feld als bigserial angegeben , was dem Long- Typ in Java entspricht. In unserem Programm ist der Typ für dieses Feld jedoch Integer . Ich habe beschlossen, die Verwendung von Long (BIGSERIAL) zu zeigen, da es einen größeren Bereich als Integer hat. Tatsache ist, dass in Tabellen ein als Primärschlüssel bezeichnetes Feld nicht nur zum Speichern von Benutzer- IDs , sondern auch zum Speichern von Indizes einer Vielzahl von Daten verwendet werden kann und die Anzahl solcher Datensätze den maximalen Ganzzahlwert überschreiten kann. Wenn unser Programm beispielsweise jede Sekunde einige Messungen vornimmt und die Daten in eine Tabelle schreibt. Um unsere Klassen so umzuschreiben, dass sie den Long-Datentyp verwenden, müssen wir den Typ in allen Klassen und Methoden, die das ID- Feld verwenden, von Integer in Long ändern . Wir werden dies nicht tun, da das Programm ursprünglich vom Autor für den Typ „id Integer“ geschrieben wurde, was bedeutet, dass dies durchaus Sinn macht. Um fortzufahren, entfernen wir noch einmal die von uns erstellte Clients- Tabelle aus unserer Datenbank, aber jetzt versuchen wir, dies programmgesteuert und nicht manuell zu tun. Kommentieren Sie dazu unseren Code in der Datei initDB.sql aus und fügen Sie eine Zeile hinzu:

-- CREATE TABLE IF NOT EXISTS clients
-- (
--     id    BIGSERIAL PRIMARY KEY ,
--     name  VARCHAR(200) NOT NULL ,
--     email VARCHAR(254) NOT NULL ,
--     phone VARCHAR(20)  NOT NULL
-- );
DROP TABLE IF EXISTS clients

Starten wir das Programm, gehen Sie zu pgAdmin , klicken Sie mit der rechten Maustaste auf „ Tabellen “ (in unserer Kundendatenbank ) -> „ Aktualisieren “, und wir werden sehen, dass unsere Tabelle verschwunden ist. ACHTUNG! Seien Sie vorsichtig, wenn Sie diesen Befehl verwenden, sonst riskieren Sie den Verlust aller Daten, die Sie in Ihrer Tabelle hatten! Kehren wir zur Datei initDB.sql zurück und schreiben sie wie folgt um:

CREATE TABLE IF NOT EXISTS clients
(
    id    SERIAL PRIMARY KEY ,
    name  VARCHAR(200) NOT NULL ,
    email VARCHAR(254) NOT NULL ,
    phone VARCHAR(50)  NOT NULL
);

Hier haben wir den ID- Typ in SERIAL geändert , was dem Integer- Typ entspricht, den wir für das ID- Feld in unserem Programm verwenden . Darüber hinaus wurde die maximale Länge des Telefonfelds erhöht, sodass wir beim Schreiben frei Leerzeichen und Sonderzeichen (Klammern, Bindestriche usw.) verwenden können. Die maximale Ziffernanzahl einer Telefonnummer beträgt derzeit 18 Ziffern (wenn ich mich richtig erinnere). Zur Sicherheit habe ich die Größe auf 50 Zeichen eingestellt. Gehen wir zur Datei application.properties und kommentieren die Zeile aus:

spring.datasource.data=classpath*:database/populateDB.sql

Lassen Sie uns unser Programm ausführen, zu pgAdmin gehen, überprüfen, ob unsere Tabelle erstellt wurde, und diese Zeile wieder auskommentieren.

#spring.datasource.data=classpath*:database/populateDB.sql

Hier werde ich wahrscheinlich den ersten Teil des Artikels beenden. Ich hoffe es gefällt euch, schreibt Kommentare (auch wenn es euch nicht gefallen hat). Im zweiten Teil werden wir unsere Klassen umschreiben, damit sie mit echten Datenbanken arbeiten können. Fortsetzung: Hinzufügen einer PostgreSQL-Datenbank zu einem RESTful-Dienst auf Spring Boot. Teil 2 UPD Vielen Dank an die Moderatoren für die Korrektur meiner Bilder und Textformatierung!