• Zuhause
  • Artikel
  • So erstellen Sie eine Rest-API mit Spring Boot mit MySQL und JPA
Veröffentlicht am 01-03-2019

So erstellen Sie eine Rest-API mit Spring Boot mit MySQL und JPA

Bild mit freundlicher Genehmigung: Google

Hallo allerseits! Im letzten Jahr lernte ich JavaScript für die Web-Entwicklung mit vollständigem Stack. Zur Abwechslung fing ich an, Java zu beherrschen - die leistungsfähige Object Oriented Language.

In diesem Fall fand ich ein sehr sauberes und elegantes Framework namens Spring Boot, um ein Backend zu bauen.

Zuvor habe ich in der JavaScript-Entwicklung Folgendes verwendet:

  1. Mongoose - ein ORM (Object Relational Mapping) für Mongo DB
  2. Sequelize - ein ORM für MySQL

Für die Java-Entwicklung gibt es viele ORMs wie Hibernate, JPA (Java Persistence API) und Java Object Oriented Querying.

Ich habe mich für JPA entschieden, das traditionell in Java-Anwendungen verwendet wird.

Es war sehr interessant und es dauerte ungefähr eine Woche, bis ich fertig war, da ich Spring Boot lernen musste (es gibt viele Anmerkungen „@“ und andere coole Sachen, die man lernen muss), JPA und Hibernate.

All diese Magie wird hauptsächlich durch die Anmerkungen ("@" - Symbol) aus Spring Boot ausgeführt.

Spring Boot Maven-Projekt erstellen

Erstellen Sie eine Spring Boot Maven-Projektanwendung mit diesem Link

„Maven“ ist ein Projektmanagement-Tool zum Verwalten von Abhängigkeitsmanagement. Es ist genau wie Node Package Manager (NPM) in der JS-Entwicklungsumgebung.

Wir haben package.json in NodeJS für die Verwaltung von Abhängigkeiten und pom.xml in Spring Boot für die Verwaltung von Abhängigkeiten.

Schreiben Sie unter Gruppe einen beliebigen Namen. Normalerweise wird der Domänenname der Organisation von rechts nach links geschrieben.

Beispielsweise lautet unser Domainname www.javaAPI.com, der Gruppenname könnte com.javaAPI.www sein

Geben Sie dann im Artifact den Namen des gewünschten Ordners ein.

Fügen Sie auf der rechten Seite die folgenden Abhängigkeiten hinzu:

  1. WEB - So verwenden Sie die Abhängigkeiten von Spring (Das ältere Framework von Spring Boot, das zum Entwickeln von Webanwendungen verwendet wird)
    1. JPA - Java-Persistenz-API
    2. MYSQL
    3. Klicken Sie dann auf "Projekt generieren". Sie finden eine rar-Datei - extrahieren Sie sie. Öffnen Sie dann diesen Ordner in Ihrer bevorzugten IDE.

      Klicken Sie auf die Datei com.rest.API und Sie finden eine ApiApplication.java-Datei wie folgt:

      Paket com.rest.API;
      import org.springframework.boot.SpringApplication;
      import org.springframework.boot.autoconfigure.SpringBootApplication;
      @SpringBootApplication
      öffentliche Klasse ApiApplication {
      public static void main (String [] args) {
            SpringApplication.run (ApiApplication.class, args);
         }
      }

      Dieser Code reicht aus, um Ihren Server zu starten. Normalerweise läuft der Spring Boot auf localhost: 8080.

      Geben Sie Ihr Terminal wie folgt ein:

      MVN Spring-Boot: laufen

      Sehen Sie sich Ihren localhost im Webbrowser an Port 8080 an. Er sieht leer aus, da wir noch nichts unternommen haben.

      Untersuchen wir die Dateien und ihre Tags

      Wenn Sie sich die Datei pom.xml ansehen, stellen Sie möglicherweise fest, dass die Abhängigkeiten, die Sie beim Erstellen der Anwendung in Spring Initialize wie MySQL, JPA und Web angegeben haben, innerhalb eines -Tags liegen.

      Die Starter- und Testerabhängigkeiten sind der Kern für das Erstellen der Spring Boot Application, die auf dem Server bereitgestellt werden soll.

      Gehen wir nun zu APIApplication.java, der Hauptdatei.

      Paket com.rest.API;
      import org.springframework.boot.SpringApplication;
      import org.springframework.boot.autoconfigure.SpringBootApplication;
      @SpringBootApplication
      öffentliche Klasse ApiApplication {
      public static void main (String [] args) {
            SpringApplication.run (ApiApplication.class, args);
         }
      }

      Hier steht der Name des Pakets in der ersten Codezeile. Mit diesem Paketnamen können Sie jede Klasse, Methode oder Instanz in eine andere Paketdatei importieren.

      Danach werden zwei Module aus dem Paket "org.springframework.boot" importiert.

      1. SpringApplication
      1. SpringBootApplication

      Da Spring boot das neueste Anwendungsentwicklungs-Framework von Spring ist, werden die Pakete von Spring Application sowie die zugehörigen Pakete benötigt.

      Danach wird @SpringBootApplication Annotation verwendet. Diese Annotation besteht aus Annotation, die in Spring verwendet wird:

    4. @Component - teilt dem Compiler mit, dass die folgende Klasse eine Komponente ist, die beim Kompilieren der gesamten Anwendung enthalten sein sollte.
  2. @ComponentScan - Hiermit wird geprüft, welche Pakete in der folgenden Java-Klasse verwendet werden.
  1. @EnableAutoConfiguration - aktiviert den automatischen Konfigurationsmechanismus von Spring Boot, um wichtige Module für die Ausführung des Spring Boot zu importieren.
  2. Dies sind die Anmerkungen, die zum Starten der Spring Boot-Anwendung zur Ausführung auf einem Server verwendet werden.

    Hier ist ein Artikel, den ich über Annotation und deren Verwendung in Java geschrieben habe.

    Erstellen wir ein Modell für unsere Daten

    Erstellen Sie eine Model-Klasse, um die Details eines Buches zu speichern, abzurufen, zu aktualisieren und zu löschen.

    Dafür muss ich ein neues Paket mit dem Namen model erstellen und darin eine Book.java-Klasse erstellen, um meinen Code einzufügen.

    Paket com.rest.API.model;
    Import javax.persistence. *;
    import javax.validation.constraints.NotBlank;
    @Entität
    @Table (name = "books")
    öffentliches Klassenbuch {
        @Ich würde
        @GeneratedValue
        private lange ID;
    @NotBlank
        private String book_name;
    @NotBlank
        privater String Autorenname;
    @NotBlank
        private String isbn;
    öffentliches Buch () {
            Super();
        }
    Öffentliches Buch (lange ID, String book_name, String author_name, String isbn) {
            Super();
            this.id = id;
            this.book_name = book_name;
            this.author_name = Autorenname;
            this.isbn = isbn;
        }
    public Long getId () {
            ID zurückgeben;
        }
    public void setId (lange ID) {
            this.id = id;
        }
    public String getBook_name () {
            return book_name;
        }
    public void setBook_name (String book_name) {
            this.book_name = book_name;
        }
    public String getAuthor_name () {
            return autor_name;
        }
    public void setAuthor_name (Zeichenkette autor_name) {
            this.author_name = Autorenname;
        }
    public String getIsbn () {
            return isbn;
        }
    public void setIsbn (String isbn) {
            this.isbn = isbn;
        }
    }

    Hier verwende ich JPA (Java Persistence API), eine Sammlung von Klassen und Methoden, um fortlaufend Daten in einer Datenbank zu speichern.

    @Entity - Wird verwendet, um anzugeben, dass diese Klasse eine Entität in der Datenbank sein wird.

    @Table - nimmt einige Werte wie den Namen, den Sie Ihrer Tabelle nennen wollen

    @Id - Gibt an, dass die ID der Primärschlüssel / Identifizierungsschlüssel für diese Tabelle ist

    @NotBlank - wird verwendet, um zu sagen, dass diese Attribute nicht leer sein dürfen.

    Ansonsten gibt es einen leeren Konstruktor, der über eine Super-Methode verfügt, um den JPA-Zoll zu erfüllen. Getter- und Setter-Methoden befinden sich normalerweise in einer POJO-Klasse (einfaches altes Java-Objekt).

    Repository erstellen

    Als Nächstes erstellen wir ein Repository-Paket für die Datenbankverwaltung in Java.

    Erstellen Sie eine Schnittstelle mit dem Namen BookRepository.java im Repository-Paket.

    Paket com.rest.API.repository;
    import com.rest.API.model.Book;
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.stereotype.Repository;
    @Repository
    öffentliche Schnittstelle BookRepository erweitert JpaRepository  {
    }

    Ich habe das JpaRepository-Paket importiert, um dieses Repository in der BookRepository-Schnittstelle zu verwenden, indem ich mein zuletzt codiertes Book-Modell mit CRUD-Vorgängen verbinde.

    In diesen Repositorys gibt es bereits integrierte Methoden, um CRUD-Vorgänge auszuführen.

    Z.B:

    .findAll () - um alle Daten abzurufen
    .save () - um die erhaltenen Daten zu speichern
    .delete () - zum Löschen der Daten

    Innerhalb des Tags <> nehmen wir den Modellnamen und den Datentyp des Primärschlüssels an.

    @Repository: Anmerkung zum Anzeigen der DAO-Komponente (Data Access Object) in der Persistenzschicht.

    Sie teilt dem Compiler mit, dass die Schnittstelle das Repository für Datenbankaktivitäten verwenden wird.

    Controller- und Ausnahmebehandlung erstellen

    Erstellen Sie ein neues Paket mit dem Namen Controller, und erstellen Sie darin eine Datei BookController.java, die die Endpunkte enthält.

    Paket com.rest.API.controller;
    import com.rest.API.exception.BookNotFoundException;
    import com.rest.API.model.Book;
    import com.rest.API.repository.BookRepository;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation. *;
    import org.springframework.http.ResponseEntity;
    Import javax.validation.Valid;
    import java.util.List;
    @RestController
    öffentliche Klasse BookController {
    @Autowired
        BookRepository bookRepository;
    // Alle Notizen abrufen
        @ GetMapping ("/ books")
        öffentliche Liste  getAllNotes () {
            return bookRepository.findAll ();
        }
    // Eine neue Notiz erstellen
        @PostMapping ("/ books")
        public Book createNote (@Valid @RequestBody-Buchbuch) {
            return bookRepository.save (Buch);
        }
    // Eine einzelne Notiz erhalten
        @ GetMapping ("/ books / {id}")
        public Book getNoteById (@PathVariable (value = "id") Long bookId) löst BookNotFoundException {aus.
            return bookRepository.findById (bookId)
                    .orElseThrow (() -> new BookNotFoundException (bookId));
        }
    // Eine Notiz aktualisieren
        @PutMapping ("/ books / {id}")
        public Book updateNote (@PathVariable (value = "id") Lange bookId,
                               @Valid @RequestBody Book bookDetails) löst BookNotFoundException {aus.
    Book book = bookRepository.findById (bookId)
                    .orElseThrow (() -> new BookNotFoundException (bookId));
    book.setBook_name (bookDetails.getBook_name ());
            book.setAuthor_name (bookDetails.getAuthor_name ());
            book.setIsbn (bookDetails.getIsbn ());
    Buch aktualisiertBook = bookRepository.save (Buch);
    retouredBook zurück;
        }
    // Eine Notiz löschen
        @DeleteMapping ("/ books / {id}")
        public ResponseEntity  deleteBook (@PathVariable (value = "id") Long bookId) löst BookNotFoundException {
            Book book = bookRepository.findById (bookId)
                    .orElseThrow (() -> new BookNotFoundException (bookId));
    bookRepository.delete (Buch);
    return ResponseEntity.ok (). build ();
        }
    }

    Das erste importierte Paket ist für die Book Not Found-Ausnahme (für die wir in Kürze eine Datei erstellen).

    Erklärung der Anmerkungen, die wir hier verwendet haben:

    1. RestController: Diese Annotation wird verwendet, um jede Methode in der annotierten Klasse als Domänenobjekt zu kennzeichnen.

    Was ist also ein Domain-Objekt?

    Es sagt einfach, dass das Domain-Objekt ein Business-Objekt ist.

    Sie werden normalerweise durch Entitäten und Wertobjekte dargestellt, die sich auf den Endpunkt beziehen, den wir angeben, um die Daten aus der Datenbank abzurufen.

    2. Autowired: Diese Anmerkung wird verwendet, um die Bean-Klassen automatisch zu verbinden.

    Dazu müssen Sie wissen, was eine Bean-Klasse ist ..?

    Grundsätzlich ist eine Java Bean-Klasse eine einfache Klasse, die viele Objekte darin einkapselt.

    Dies ist ein Artikel, den ich über Java Bean Classes geschrieben habe.

    Im Folgenden finden Sie die Zuordnungsanmerkungen für die Endpunkte zum Durchführen von CRUD-Vorgängen.

    3. GetMapping: Dies ist eine Schnittstelle, die den Pfad des Endpunkts für die Ausführung einer Get-Methode enthält. Diese GetMapping-Schnittstelle verwendet die RequestMapping-Schnittstelle, die die Methode "Pfad, Wert, Parameter, Header" verwenden kann, um die Get-Methode in früheren Spring-Versionen auszuführen.

    Jetzt wird es mit GetMapping vereinfacht.

    4. PostMapping: Dies ist eine Schnittstelle, die den Pfad des Endpunkts für die Post-Methode enthält.

    5. PutMapping: Dies ist eine Schnittstelle, die den Pfad des Endpunkts enthält, um die Put-Methode zu aktualisieren.

    6. DeleteMapping: Dies ist eine Schnittstelle, die den Pfad des Endpunkts für die Löschmethode enthält.

    In den letzten Zeilen haben Sie wahrscheinlich das Schlüsselwort „ResponseEntity“ bemerkt.

    Was ist das…??

    Es ist eine Java-Klasse, die die HttpEntity-Klasse erbt, um die HTTP-Antworten zu bearbeiten. Geben Sie eine Ausnahme von der Klasse HttpEntity ein, wenn die Anforderung der Verbindung "OK" ist oder wenn Probleme auftreten.

    orElseThrow (): Diese Methode befindet sich in der optionalen Klasse von Java8, die zur Behandlung von Exceptions eingeführt wurde. Die optionale Klasse stellt verschiedene Dienstmethoden zur Verfügung, um das Vorhandensein oder Nicht-Vorhandensein eines Objekts zu überprüfen, was bei der Behandlung von NullPointerException hilft.

    orElseThrow ist eine Methode, die den Wert zurückgibt, falls vorhanden, ansonsten eine Ausnahme ausgelöst.

    Erstellen einer NotFoundException, wenn keine solche book_id vorhanden ist

    Als orElseThrow-Methode wird eine NotFound-Ausnahme ausgelöst. Das Folgende ist der Ausnahmebehandlungsteil. Erstellen Sie eine BookNotFoundException.java-Datei innerhalb des Ausnahmepakets.

    Paket com.rest.API.exception;
    Die öffentliche Klasse BookNotFoundException erweitert die Ausnahme {
    private lange book_id;
    public BookNotFoundException (long book_id) {
            super (String.format ("Buch wurde nicht gefunden mit der ID: '% s'" ", book_id)));
            }
    }

    Die erstellte Klasse erweitert die Oberklasse der Ausnahme. Im Konstruktor übergebe ich die book_id und gibt die Ausnahme aus.

    So, das war es…

    Wir haben den REST-API-Teil fertiggestellt. Jetzt können Sie die App (die in Teil 1 erläutert wurde) erstellen und einige Tests mit Postman durchführen.

    Verbindung mit der MySql-Datenbank

    Fügen Sie in den application.properties Ihres Ressourcenordners Folgendes hinzu:

    ## Spring DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties)
    spring.datasource.url = jdbc: mysql: // localhost: 3306 / library
    spring.datasource.username = root // In der Regel muss Ihr MySQL-Benutzername angegeben werden
    spring.datasource.password = YOUR_MYSQL_PASSWORD
    ## Ruhezustandseigenschaften
    # Der SQL-Dialekt bewirkt, dass Hibernate bessere SQL für die ausgewählte Datenbank generiert
    spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5InnoDBDialect
    # Ruhezustand ddl auto (Erstellen, Erstellen, Ablegen, Überprüfen, Aktualisieren)
    spring.jpa.hibernate.ddl-auto = update

    Das ist es.

    Wir haben eine grundlegende REST-API in Spring Boot erstellt. Glückwunsch!

    Wenn etwas falsch ist oder korrigiert werden muss, teilen Sie mir dies bitte im Kommentarbereich mit.

    Kontaktieren Sie mich auf Twitter.

    Viel Spaß beim Codieren!