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

Die Starter- und Tester-Abhängigkeiten sind der Kern zum Erstellen der Spring Boot-Anwendung, die auf dem Server bereitgestellt werden soll.

Gehen wir nun zu APIApplication.java, der Hauptdatei.

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

Hier steht der Name des Pakets in der ersten Zeile des Codes. Unter Verwendung dieses Paketnamens 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. Frühjahrsantrag
2. SpringBoot-Anwendung

Da Spring Boot das neueste Anwendungsentwicklungs-Framework von Spring ist, benötigt es die Pakete von Spring Application sowie seine spezifischen Pakete.

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

1. @Component — Teilt dem Compiler mit, dass die folgende Klasse eine Komponente ist, die beim Kompilieren der gesamten Anwendung enthalten sein sollte.
2. @ComponentScan — Dieser scannt, welche Pakete wir in der folgenden Java-Klasse verwenden werden.
3. @EnableAutoConfiguration — aktiviert den Autokonfigurationsmechanismus von Spring Boot, um wichtige Module für die Ausführung von Spring Boot zu importieren.

Dies sind die Anmerkungen, die zum Starten der Spring Boot-Anwendung zum Ausführen auf einem Server verwendet werden.

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

Erstellen wir ein Modell für unsere Daten

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

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

package com.rest.API.model;
import javax.persistence.*;
import javax.validation.constraints.NotBlank;
@Entity
@Table(name = "books")
public class Book {
    @Id
    @GeneratedValue
    private Long id;
@NotBlank
    private String book_name;
@NotBlank
    private String author_name;
@NotBlank
    private String isbn;
public Book(){
        super();
    }
public Book(Long id, String book_name, String author_name, String isbn) {
        super();
        this.id = id;
        this.book_name = book_name;
        this.author_name = author_name;
        this.isbn=isbn;
    }
public Long getId() {
        return id;
    }
public void setId(Long 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 author_name;
    }
public void setAuthor_name(String author_name) {
        this.author_name = author_name;
    }
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 zum kontinuierlichen Speichern von Daten in einer Datenbank.

@Entität — Wird verwendet, um anzuzeigen, dass diese Klasse eine Entität in der Datenbank sein wird.

@Table — die einige Werte annehmen kann, wie den Namen, den Sie Ihrer Tabelle benennen werden

@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 sollten.

Abgesehen davon gibt es einen leeren Konstruktor, der eine Supermethode hat, um die JPA-Gewohnheiten zu erfüllen. Getter- und Setter-Methoden befinden sich normalerweise in einer POJO-Klasse (Plain old Java object ).

Erstellung des Repositorys

Als Nächstes erstellen wir ein Repository Paket, um sich mit der Datenbankverwaltung in Java zu befassen.

Erstellen Sie eine Schnittstelle namens BookRepository.java im Repository Paket.

package com.rest.API.repository;
import com.rest.API.model.Book;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface BookRepository extends JpaRepository<Book, Long> {
}

Ich habe das JpaRepository importiert Paket, um dieses Repository im BookRepository zu verwenden Schnittstelle, indem ich mein zuletzt codiertes Book-Modell anschließe, um CRUD auszuführen Operationen.

Es gibt bereits eingebaute Methoden in diesen Repositories, um CRUD-Operationen durchzuführen.

Beispiel:

.findAll() - to get All datas
.save()    - to save the got Data
.delete()  - to delete the data

Innerhalb des <>-Tags nehmen wir den Modellnamen, den wir verwenden werden, und den Datentyp des Primärschlüssels.

@Repository :Anmerkung zur Angabe des DAO (Data Access Object )-Komponente in der Persistenzschicht.

Es teilt dem Compiler mit, dass die Schnittstelle das Repository verwenden wird, um Datenbankaktivitäten auszuführen.

Controller und Ausnahmebehandlung erstellen

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

package 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
public class BookController {

@Autowired
    BookRepository bookRepository;

// Get All Notes
    @GetMapping("/books")
    public List<Book> getAllNotes() {
        return bookRepository.findAll();
    }

// Create a new Note
    @PostMapping("/books")
    public Book createNote(@Valid @RequestBody Book book) {
        return bookRepository.save(book);
    }

// Get a Single Note
    @GetMapping("/books/{id}")
    public Book getNoteById(@PathVariable(value = "id") Long bookId) throws BookNotFoundException {
        return bookRepository.findById(bookId)
                .orElseThrow(() -> new BookNotFoundException(bookId));
    }

// Update a Note
    @PutMapping("/books/{id}")
    public Book updateNote(@PathVariable(value = "id") Long bookId,
                           @Valid @RequestBody Book bookDetails) throws BookNotFoundException {

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());

Book updatedBook = bookRepository.save(book);

return updatedBook;
    }

// Delete a Note
    @DeleteMapping("/books/{id}")
    public ResponseEntity<?> deleteBook(@PathVariable(value = "id") Long bookId) throws BookNotFoundException {
        Book book = bookRepository.findById(bookId)
                .orElseThrow(() -> new BookNotFoundException(bookId));

bookRepository.delete(book);

return ResponseEntity.ok().build();
    }
}

Das erste importierte Paket ist für die Ausnahme "Buch nicht gefunden" (für die wir gleich eine Datei erstellen werden).

Erklärung der hier verwendeten Anmerkungen:

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

Was ist also ein Domänenobjekt…?

Es sagt einfach, dass Domänenobjekt ==Geschäftsobjekt.

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

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

Dazu müssen Sie etwas über „Was ist eine Bean-Klasse...? wissen ”

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

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

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

3. GetMapping: Dies ist eine Schnittstelle die den Pfad des Endpunkts zum Ausführen einer Get-Methode enthält. Diese GetMapping-Schnittstelle verwendet die RequestMapping-Schnittstelle, die die Methode „path, value, params, headers“ haben kann, um die Get-Methode in früheren Spring-Versionen auszuführen.

Jetzt wird es durch die Verwendung von GetMapping. vereinfacht

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

5. PutMapping: Dies ist eine Schnittstelle die den Pfad des Endpunkts enthält, um die Put-Methode für Update auszuführen.

6. Zuordnung löschen: Dies ist eine Schnittstelle die den Pfad des Endpunkts enthält, um die Delete-Methode auszuführen.

In den letzten Zeilen ist Ihnen wahrscheinlich die „ResponseEntity“ aufgefallen ” Schlüsselwort.

Was ist das …??

Es ist eine Java-Klasse, die HttpEntity erbt Klasse zum Bearbeiten der HTTP-Antworten. Ob die Anfrage der Verbindung „OK ist ” oder wenn es irgendwelche Probleme gibt, lösen Sie eine Ausnahme aus von der HttpEntity Klasse.

oderElseThrow(): Dies ist eine Methode, die in der Optionalen Klasse in Java8 zu finden ist die eingeführt wurde, um Ausnahmen zu behandeln. Die optionale Klasse stellt verschiedene Hilfsmethoden bereit, um das Vorhandensein oder Fehlen eines Objekts zu prüfen, was bei der Behandlung von NullPointerException hilft.

oderElseThrow ist eine Methode, die einen Wert zurückgibt, falls vorhanden, andernfalls eine Ausnahme auslöst.

Erstellen einer NotFoundException, wenn es keine solche Buch-ID gibt

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

package com.rest.API.exception;
public class BookNotFoundException extends Exception {
private long book_id;
public BookNotFoundException(long book_id) {
        super(String.format("Book is not found with id : '%s'", book_id));
        }
}

Die erstellte Klasse erweitert die Superklasse von Exception. Im Konstruktor übergebe ich die book_id und drucke die Ausnahme.

Das war's also...

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

Mit MySql-Datenbank verbinden

Innerhalb der application.properties Ihrer Ressourcen Ordner, fügen Sie Folgendes hinzu:

## Spring DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties)
spring.datasource.url = jdbc:mysql://localhost:3306/library
spring.datasource.username = root //normally put your MySQL username 
spring.datasource.password = YOUR_MYSQL_PASSWORD
## Hibernate Properties
# The SQL dialect makes Hibernate generate better SQL for the chosen database
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5InnoDBDialect
# Hibernate ddl auto (create, create-drop, validate, update)
spring.jpa.hibernate.ddl-auto = update

Das ist es.

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

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

Kontaktieren Sie mich auf Twitter.

Viel Spaß beim Programmieren!