Come creare un'API Rest con Spring Boot utilizzando MySQL e JPA

Le dipendenze di avvio e tester sono il fulcro per la creazione dell'applicazione Spring Boot da servire sul server.

Ora, passiamo a APIApplication.java che è il file principale.

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

Qui il nome del pacchetto è nella prima riga del codice. Usando quel nome di pacchetto, puoi importare qualsiasi classe, metodo o istanza in un altro file di pacchetto.

Successivamente, due moduli vengono importati dal pacchetto "org.springframework.boot".

1. Applicazione Primavera
2. Applicazione SpringBoot

Poiché Spring boot è l'ultimo framework di sviluppo di applicazioni di Spring, ha bisogno dei pacchetti di Spring Application e dei suoi pacchetti specifici.

Dopo di che @SpringBootApplication Viene utilizzata l'annotazione. Questa annotazione è costituita da un'annotazione utilizzata in primavera:

1. @Componente — Dice al compilatore che la classe seguente è un componente che dovrebbe essere incluso durante la compilazione dell'intera applicazione.
2. @ComponentScan — Questo esegue la scansione di quali pacchetti utilizzeremo nella seguente classe Java.
3. @EnableAutoConfiguration — abilita il meccanismo di configurazione automatica di Spring Boot per importare moduli importanti per l'esecuzione di Spring Boot.

Queste sono le annotazioni utilizzate per avviare l'applicazione Spring Boot per l'esecuzione su un server.

Ecco un articolo che ho scritto sull'annotazione e sui loro usi in Java.

Creiamo un modello per i nostri dati

Creiamo una classe Modello per salvare, recuperare, aggiornare ed eliminare i dettagli di un libro.

Per questo, devo creare un nuovo pacchetto chiamato model e al suo interno creando un Book.java classe per inserire il mio codice.

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

Qui sto usando JPA (Java Persistence API), che è una raccolta di classi e metodi per archiviare continuamente i dati in un database.

@Entità — utilizzato per indicare che questa classe sarà un'entità nel database.

@Tavolo — che prende alcuni valori come il nome a cui darai il nome della tua tabella

@ID — indica che l'id è la chiave primaria/identificativa per questa tabella

@NotBlank — è usato per dire che questi attributi non devono essere vuoti.

Oltre a questo c'è un costruttore vuoto che ha un metodo eccellente per soddisfare le dogane dell'APP. I metodi getter e setter sono generalmente in una classe POJO (Oggetto Java vecchio semplice ).

Creazione del repository

Successivamente, creeremo un repository pacchetto per gestire la gestione dei database in Java.

Crea un'interfaccia chiamata BookRepository.java all'interno del repository pacchetto.

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

Ho importato il JpaRepository pacchetto per utilizzare quel repository nel BookRepository interfaccia collegando il mio modello di libro codificato più di recente per eseguire CRUD operazioni.

Esistono già metodi integrati in quei repository per eseguire operazioni CRUD.

Es.:

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

All'interno del tag <> prendiamo il nome del modello che useremo e il tipo di dati della chiave primaria.

@Repository :Annotazione utilizzata per indicare il DAO (Data Access Object ) componente nel livello di persistenza.

Dice al compilatore che l'interfaccia utilizzerà il repository per eseguire attività di database.

Creazione del controller e gestione delle eccezioni

Crea un nuovo pacchetto chiamato controller, e al suo interno crea un BookController.java file che contiene gli endpoint.

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

Il primo pacchetto importato riguarda l'eccezione Book Not Found (per la quale creeremo un file tra un po').

Spiegazione delle annotazioni che abbiamo utilizzato qui:

1. RestaController: Questa annotazione viene utilizzata per denotare ogni metodo nella classe annotata come Oggetto di dominio.

Allora, cos'è Domain Object...?

Dice semplicemente che Domain Object ==Business Object.

Di solito sono rappresentati da entità e oggetti valore relativi all'endpoint che stiamo fornendo per ottenere i dati dal database.

2. Autowired :questa annotazione viene utilizzata per collegare automaticamente le classi di bean.

Per questo, devi sapere "Cos'è una classe di fagioli..? ”

Fondamentalmente, una classe Java Bean è una classe semplice che incapsula molti oggetti al suo interno.

Questo è un articolo che ho scritto su Java Bean Classes.

Di seguito sono riportate le annotazioni di mappatura per gli endpoint per eseguire operazioni CRUD.

3. GetMapping: Questa è un'interfaccia che contiene il percorso dell'endpoint per eseguire un metodo Get. Questa interfaccia GetMapping utilizza l'interfaccia RequestMapping che può avere il metodo "percorso, valore, parametri, intestazioni" per eseguire il metodo Get nelle versioni precedenti di Spring.

Ora è semplificato utilizzando GetMapping.

4. Postmapping :Questa è un'interfaccia che contiene il percorso dell'endpoint per eseguire il metodo Post.

5. Mappatura Put: Questa è un'interfaccia che contiene il percorso dell'endpoint per eseguire il metodo Put da aggiornare.

6. Elimina mappatura: Questa è un'interfaccia che contiene il percorso dell'endpoint per eseguire il metodo Delete.

Nelle righe finali, probabilmente hai notato "ResponseEntity ” parola chiave.

Che cos'è quello …??

È una classe Java che eredita HttpEntity classe per manipolare le risposte HTTP. Se la richiesta di connessione è "OK ” o se ci sono problemi, lancia un'eccezione da HttpEntity classe.

oElseThrow(): Questo è un metodo trovato nella classe opzionale in Java8 che è stato introdotto per gestire le eccezioni. La classe facoltativa fornisce vari metodi di utilità per verificare la presenza o l'assenza di un oggetto, il che aiuta a gestire NullPointerException.

oAltroLancia è un metodo che restituisce valore se presente, altrimenti invoca un'eccezione.

Creazione di una NotFoundException se non esiste tale book_id

Poiché il metodo orElseThrow genera un'eccezione NotFound. Quella che segue è la parte relativa alla gestione delle eccezioni. Crea un BookNotFoundException.java file all'interno del pacchetto di eccezioni.

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

La classe creata estende la Superclasse di Eccezione. Nel costruttore, passo il book_id e stampa l'eccezione.

Quindi, questo è tutto...

Abbiamo terminato la parte dell'API REST. Ora puoi creare l'app (come spiegato nella Parte 1) ed eseguire alcuni test con Postman.

Connessione al database MySql

All'interno di application.properties delle tue risorse cartella, aggiungi quanto segue:

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

Questo è tutto.

Abbiamo creato un'API REST di base in Spring Boot. Congratulazioni!

Se qualcosa non va o deve essere corretto, faccelo sapere nella sezione commenti.

Contattami su Twitter.

Buona codifica!