Jak zbudować Rest API z Spring Boot przy użyciu MySQL i JPA?

Zależności startera i testera są podstawą tworzenia aplikacji Spring Boot, która ma służyć na serwerze.

Przejdźmy teraz do APIApplication.java, który jest głównym plikiem.

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

Tutaj nazwa pakietu znajduje się w pierwszym wierszu kodu. Używając tej nazwy pakietu, możesz zaimportować dowolną klasę, metodę lub instancje do innego pliku pakietu.

Następnie dwa moduły są importowane z pakietu „org.springframework.boot”.

1. WiosnaAplikacja
2. Aplikacja SpringBoot

Ponieważ Spring Boot jest najnowszym frameworkiem do tworzenia aplikacji Spring, potrzebuje zarówno pakietów Spring Application, jak i konkretnych pakietów.

Następnie @SpringBootApplication Używana jest adnotacja. Ta adnotacja składa się z adnotacji używanej na wiosnę:

1. @Komponent — Informuje kompilator, że poniższa klasa jest komponentem, który powinien zostać uwzględniony podczas kompilowania całej aplikacji.
2. @ComponentScan — Ten skanuje, których pakietów będziemy używać w następującej klasie Java.
3. @EnableAutoConfiguration — umożliwia mechanizmowi autokonfiguracji Spring Boot importowanie ważnych modułów w celu uruchomienia Spring Boot.

Są to adnotacje używane do uruchamiania aplikacji Spring Boot w celu uruchomienia na serwerze.

Oto artykuł, który napisałem o adnotacjach i ich zastosowaniach w Javie.

Stwórzmy model dla naszych danych

Stwórzmy klasę Model, aby zapisywać, pobierać, aktualizować i usuwać szczegóły książki.

W tym celu muszę stworzyć nowy pakiet o nazwie model a wewnątrz tego tworząc Book.java klasę, aby umieścić mój kod.

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;
    }
}

Tutaj używam JPA (Java Persistence API), który jest zbiorem klas i metod do ciągłego przechowywania danych w bazie danych.

@Podmiot — używane do oznaczenia, że ​​ta klasa będzie Entity w bazie danych.

@Tabela — która przyjmuje pewne wartości, takie jak nazwa, którą chcesz nazwać swoją tabelą

@Identyfikator — oznacza, że ​​identyfikator jest głównym kluczem / kluczem identyfikującym dla tej tabeli

@NotBlank — jest używany do powiedzenia, że ​​te atrybuty nie powinny być puste.

Poza tym istnieje pusty konstruktor, który ma super metodę, aby spełnić zwyczaje JPA. Metody pobierające i ustawiające są zwykle w klasie POJO (Zwykły stary obiekt Java ).

Tworzenie repozytorium

Następnie utworzymy repozytorium pakiet do zarządzania bazą danych w Javie.

Utwórz interfejs o nazwie BookRepository.java wewnątrz repozytorium pakiet.

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> {
}

Zaimportowałem JpaRepository pakiet do korzystania z tego repozytorium w BookRepository interfejs, podłączając mój ostatnio zakodowany model książki w celu wykonania CRUD operacje.

W tych repozytoriach są już wbudowane metody do wykonywania operacji CRUD.

Np.:

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

Wewnątrz tagu <> pobieramy nazwę modelu, którego będziemy używać, oraz typ danych klucza podstawowego.

@Repozytorium :Adnotacja używana do wskazania DAO (Obiekt dostępu do danych ) w warstwie trwałości.

Mówi kompilatorowi, że interfejs będzie używał Repozytorium do wykonywania czynności związanych z bazą danych.

Tworzenie kontrolera i obsługi wyjątków

Utwórz nowy pakiet o nazwie kontroler, i wewnątrz, które tworzą BookController.java plik zawierający punkty końcowe.

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

Pierwszy zaimportowany pakiet dotyczy wyjątku Nie znaleziono książki (dla którego za chwilę utworzymy plik).

Wyjaśnienie użytych tutaj adnotacji:

1. Kontroler odpoczynku: Ta adnotacja jest używana do oznaczenia każdej metody w opisanej klasie jako obiektu domeny.

Czym więc jest obiekt domeny…?

Mówi po prostu, że obiekt domeny ==obiekt biznesowy.

Zazwyczaj są one reprezentowane przez encje i obiekty wartości związane z punktem końcowym, który podajemy, aby uzyskać dane z bazy danych.

2. Automatycznie :Ta adnotacja jest używana do automatycznego łączenia klas ziaren.

W tym celu musisz wiedzieć o „Co to jest klasa fasoli…? ”

Zasadniczo klasa Java Bean jest prostą klasą, która zawiera w sobie wiele obiektów.

To jest artykuł, który napisałem na temat klas Java Bean.

Poniżej znajdują się adnotacje mapowania dla punktów końcowych do wykonywania operacji CRUD.

3. Pobierz mapowanie: To jest interfejs który zawiera ścieżkę punktu końcowego do wykonania metody Get. Ten interfejs GetMapping wykorzystuje interfejs RequestMapping, który może mieć metodę „ścieżka, wartość, parametry, nagłówki” do wykonywania metody Get we wcześniejszych wersjach Spring.

Teraz jest to uproszczone za pomocą GetMapping.

4. PostMapping :to jest interfejs który zawiera ścieżkę punktu końcowego do wykonania metody Post.

5. Mapowanie Put: To jest interfejs który zawiera ścieżkę punktu końcowego do wykonania metody Put w celu aktualizacji.

6. Usuń mapowanie: To jest interfejs który zawiera ścieżkę punktu końcowego do wykonania metody Delete.

W ostatnich wierszach prawdopodobnie zauważyłeś „ResponseEntity ” słowo kluczowe.

Co to to …??

Jest to klasa Java, która dziedziczy HttpEntity do manipulowania odpowiedziami HTTP. Czy żądanie połączenia jest „OK ” lub jeśli wystąpią jakiekolwiek problemy, zgłoś wyjątek z HttpEntity klasa.

lubElseThrow(): Jest to metoda znaleziona w klasie Optional w Java8 który został wprowadzony do obsługi wyjątków. Opcjonalna klasa zapewnia różne metody narzędziowe do sprawdzania obecności lub nieobecności obiektu, co pomaga radzić sobie z NullPointerException.

lubElseThrow jest metodą, która zwraca wartość, jeśli jest obecna, w przeciwnym razie wywołuje wyjątek.

Tworzenie wyjątku NotFoundException, jeśli nie ma takiego book_id

Ponieważ metoda orElseThrow zgłasza wyjątek NotFound. Poniżej znajduje się część dotycząca obsługi wyjątków. Utwórz plik BookNotFoundException.java plik wewnątrz pakietu wyjątków.

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

Stworzona klasa rozszerza Superklasę Wyjątku. W konstruktorze przekazuję book_id i wypisuję wyjątek.

A więc to wszystko…

Zakończyliśmy część REST API. Teraz możesz zbudować aplikację (co zostało wyjaśnione w części 1) i przeprowadzić kilka testów z Postmanem.

Łączenie z bazą danych MySql

Wewnątrz application.properties Twoich zasobów folder, dodaj następujące:

## 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

To wszystko.

W Spring Boot zbudowaliśmy podstawowe API REST. Gratulacje!

Jeśli coś jest nie tak lub wymaga poprawy, daj mi znać w sekcji komentarzy.

Skontaktuj się ze mną na Twitterze.

Miłego kodowania!