Jak vytvořit Rest API s Spring Boot pomocí MySQL a JPA

Závislosti spouštěče a testeru jsou jádrem pro vytvoření aplikace Spring Boot, která bude sloužit na serveru.

Nyní se přesuneme do APIApplication.java, což je hlavní soubor.

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

Zde je název balíčku na prvním řádku kódu. Pomocí tohoto názvu balíčku můžete importovat jakoukoli třídu, metodu nebo instance v jiném souboru balíčku.

Poté jsou z balíčku „org.springframework.boot“ importovány dva moduly.

1. SpringApplication
2. Aplikace SpringBoot

Vzhledem k tomu, že Spring boot je nejnovější framework Spring pro vývoj aplikací, potřebuje balíčky Spring Application a také jejich specifické balíčky.

Poté @SpringBootApplication Používá se anotace. Tato anotace se skládá z anotace, která se používá v Spring:

1. @Component — Říká kompilátoru, že následující třída je komponenta, která by měla být zahrnuta při kompilaci celé aplikace.
2. @ComponentScan — Tento provede kontrolu, které balíčky budeme používat v následující třídě Java.
3. @EnableAutoConfiguration — umožňuje automatickému konfiguračnímu mechanismu Spring Boot importovat důležité moduly pro spuštění Spring Bootu.

Toto jsou anotace používané ke spuštění aplikace Spring Boot na serveru.

Zde je článek, který jsem napsal o anotaci a jejich použití v Javě.

Pojďme vytvořit model pro naše data

Pojďme vytvořit třídu Model pro uložení, načtení, aktualizaci a odstranění podrobností o knize.

K tomu musím vytvořit nový balíček s názvem model a uvnitř toho vytvoření Book.java třídy, abych vložil můj kód.

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

Zde používám JPA (Java Persistence API), což je sbírka tříd a metod pro nepřetržité ukládání dat do databáze.

@Entity — používá se k označení, že tato třída bude Entitou v databázi.

@Tabulka — který nabývá některých hodnot, jako je název, který se chystáte pojmenovat svou tabulku

@Id — označuje, že id je primární klíč / identifikační klíč pro tuto tabulku

@NotBlank — se používá k označení, že tyto atributy by neměly být prázdné.

Kromě toho existuje prázdný konstruktor, který má super metodu k uspokojení zvyklostí JPA. Metody getter a setter jsou obvykle ve třídě POJO (Obyčejný starý objekt Java ).

Vytvoření úložiště

Dále vytvoříme úložiště balíček pro správu databází v Javě.

Vytvořte rozhraní s názvem BookRepository.java v úložišti balíček.

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

Importoval jsem JpaRepository k použití tohoto úložiště v BookRepository rozhraní připojením mého posledního kódovaného modelu knihy k provedení CRUD operace.

V těchto úložištích jsou již vestavěné metody pro provádění operací CRUD.

Např.:

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

Uvnitř tagu <> bereme název modelu, který budeme používat, a datový typ primárního klíče.

@Repository :Anotace používaná k označení DAO (Data Access Object ) ve vrstvě perzistence.

Sděluje kompilátoru, že rozhraní bude používat úložiště k provádění databázových aktivit.

Vytvoření ovladače a zpracování výjimek

Vytvořte nový balíček s názvem controller, a uvnitř které vytvoříte BookController.java soubor, který obsahuje koncové body.

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

První importovaný balíček je pro výjimku Book Not Found (pro kterou za chvíli vytvoříme soubor).

Vysvětlení anotací, které jsme zde použili:

1. RestController: Tato anotace se používá k označení každé metody v anotované třídě jako Domain Object.

Co je tedy objekt domény…?

Jednoduše říká, že Domain Object ==Obchodní objekt.

Obvykle jsou reprezentovány entitami a hodnotovými objekty souvisejícími s koncovým bodem, který poskytujeme, abychom získali data z databáze.

2. Automatická kabeláž :Tato anotace se používá k automatickému propojení tříd fazolí.

K tomu potřebujete vědět o „Co je třída fazole...? “

Java Bean Class je v podstatě jednoduchá třída, která do ní zapouzdřuje mnoho objektů.

Toto je článek, který jsem napsal o Java Bean Classes.

Následují anotace mapování pro koncové body pro provádění operací CRUD.

3. GetMapping: Toto je rozhraní který obsahuje cestu ke koncovému bodu k provedení metody Get. Toto rozhraní GetMapping používá rozhraní RequestMapping, které může mít metodu „path, value, params, headers“ k provádění metody Get v dřívějších verzích Spring.

Nyní je to zjednodušené pomocí GetMapping.

4. Postmapování :Toto je rozhraní který obsahuje cestu ke koncovému bodu k provedení metody Post.

5. PutMapping: Toto je rozhraní který obsahuje cestu ke koncovému bodu k provedení metody Put to Update.

6. Odstranit mapování: Toto je rozhraní který obsahuje cestu ke koncovému bodu pro provedení metody Delete.

V posledních řádcích jste si pravděpodobně všimli „ResponseEntity ” klíčové slovo.

Co je to …??

Je to třída Java, která dědí HttpEntity třídy pro manipulaci s odpověďmi HTTP. Zda je požadavek na připojení „OK ” nebo pokud se vyskytnou nějaké problémy, hodí výjimku z HttpEntity třída.

neboElseThrow(): Toto je metoda nalezená v Volitelné třídě v jazyce Java8 který byl zaveden pro zpracování výjimek. Volitelná třída poskytuje různé obslužné metody pro kontrolu přítomnosti nebo nepřítomnosti objektu, což pomáhá vypořádat se s NullPointerException.

neboElseThrow je metoda, která vrací hodnotu, pokud je přítomna, jinak vyvolá výjimku.

Vytvoření výjimky NotFoundException, pokud takové book_id neexistuje

Protože metoda orElseThrow vyvolá výjimku NotFound. Následuje část Zpracování výjimek. Vytvořte BookNotFoundException.java soubor uvnitř balíčku výjimky.

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

Vytvořená třída rozšiřuje Superclass of Exception. V konstruktoru předávám book_id a vypisuje výjimku.

Takže, to je vše…

Dokončili jsme část REST API. Nyní můžete sestavit aplikaci (což bylo vysvětleno v části 1) a provést několik testů s Postmanem.

Připojení k databázi MySql

Uvnitř application.properties vašich zdrojů složku, přidejte následující:

## 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 je ono.

Ve Spring Boot jsme vytvořili základní REST API. Gratulujeme!

Pokud je něco špatně nebo je potřeba opravit, dejte mi prosím vědět v sekci komentářů.

Kontaktujte mě na Twitteru.

Šťastné kódování!