Hur man bygger ett Rest API med Spring Boot med MySQL och JPA

Start- och testberoendena är kärnan för att skapa Spring Boot-applikationen för att tjäna på servern.

Låt oss nu gå till APIApplication.java som är huvudfilen.

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

Här står paketets namn i den första raden i koden. Med det paketnamnet kan du importera vilken klass, metod eller instans som helst i en annan paketfil.

Därefter importeras två moduler från paketet "org.springframework.boot".

1. Våransökan
2. SpringBootApplication

Eftersom Spring boot är det senaste ramverket för applikationsutveckling i Spring, behöver det paketen med Spring Application såväl som dess specifika paket.

Efter det @SpringBootApplication Anteckning används. Denna anteckning består av anteckning som används på våren:

1. @Component — Talar om för kompilatorn att följande klass är en komponent som bör inkluderas när hela applikationen kompileras.
2. @ComponentScan — Den här gör genomsökningen av vilka paket vi ska använda i följande Java-klass.
3. @EnableAutoConfiguration — gör det möjligt för Spring Boots autokonfigurationsmekanism att importera viktiga moduler för att Spring Boot ska köras.

Det här är anteckningarna som används för att starta Spring Boot Application för att köras på en server.

Här är en artikel jag har skrivit om Annotation och deras användning i Java.

Låt oss skapa modell för vår data

Låt oss skapa en modellklass för att spara, hämta, uppdatera och radera detaljerna i en bok.

För det måste jag skapa ett nytt paket som heter modell och inuti det skapa en Book.java klass för att lägga min 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;
    }
}

Här använder jag JPA (Java Persistence API) som är en samling klasser och metoder för att kontinuerligt lagra data i en databas.

@Entity — används för att ange att den här klassen kommer att vara en Entity i databasen.

@Table — som tar vissa värden som namnet du ska ge din tabell ett namn

@Id — anger att id:t är primärnyckeln/identifieringsnyckeln för denna tabell

@NotBlank — används för att säga att dessa attribut inte ska vara tomma.

Annat än det finns det en tom konstruktör som har en supermetod för att tillfredsställa JPA-tullarna. Getter- och settermetoder är vanligtvis i en POJO-klass (Vanligt gammalt Java-objekt ).

Skapa arkivet

Därefter ska vi skapa ett förråd paket för att hantera databashantering i Java.

Skapa ett gränssnitt som heter BookRepository.java inuti förvaret 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> {
}

Jag har importerat JpaRepository paketet för att använda det förrådet i BookRepository gränssnitt genom att ansluta min senast kodade bokmodell för att göra CRUD operationer.

Det finns redan inbyggda metoder i dessa förvar för att utföra CRUD-operationer.

T.ex.:

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

Inuti <>-taggen tar vi modellnamnet vi ska använda och den primära nyckelns datatyp.

@Repository :Anteckning används för att indikera DAO (Data Access Object ) komponent i beständighetslagret.

Den talar om för kompilatorn att gränssnittet kommer att använda arkivet för att utföra databasaktiviteter.

Skapa kontrollant och undantagshantering

Skapa ett nytt paket som heter controller, och inuti som skapar en BookController.java fil som innehåller slutpunkterna.

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

Det första importerade paketet är för undantaget Book Not Found (för vilket vi ska skapa en fil om en stund).

Förklaring av kommentarer vi använde här:

1. RestController: Denna annotering används för att beteckna varje metod i den kommenterade klassen som Domain Object.

Så vad är Domain Object...?

Det står helt enkelt att Domain Object ==Business Object.

De representeras vanligtvis av entiteter och värdeobjekt relaterade till den slutpunkt vi ger för att hämta data från databasen.

2. Autokabelansluten :Den här annoteringen används för att koppla bönklasserna automatiskt.

För det behöver du veta om "Vad är en bönklass..? ”

I grund och botten är en Java Bean Class en enkel klass som kapslar in många objekt i den.

Det här är en artikel jag skrev om Java Bean Classes.

Följande är mappningsanteckningarna för slutpunkterna för att utföra CRUD-operationer.

3. GetMapping: Detta är ett gränssnitt som innehåller sökvägen till slutpunkten för att utföra en Get-metod. Detta GetMapping-gränssnitt använder RequestMapping-gränssnittet som kan ha metoden "path, value, params, headers" för att utföra Get-metoden i tidigare vårversioner.

Nu är det förenklat genom att använda GetMapping.

4. PostMapping :Detta är ett gränssnitt som innehåller sökvägen till slutpunkten för att utföra Post-metoden.

5. PutMapping: Detta är ett gränssnitt som innehåller sökvägen till slutpunkten för att utföra Put-metoden för att uppdatera.

6. DeleteMapping: Detta är ett gränssnitt som innehåller sökvägen till slutpunkten för att utföra raderingsmetoden.

På de sista raderna märkte du förmodligen "ResponseEntity " nyckelord.

Vad är det …??

Det är en Java-klass som ärver HttpEntity klass för att manipulera HTTP-svaren. Om begäran om anslutning är "OK ” eller om det finns några problem, kasta ett undantag från HttpEntity klass.

orElseThrow(): Detta är en metod som finns i Valfri klass i Java8 som infördes för att hantera undantag. Den valfria klassen tillhandahåller olika verktygsmetoder för att kontrollera närvaron eller frånvaron av ett objekt, vilket hjälper till att hantera NullPointerException.

eller ElseThrow är en metod som returnerar värde om det finns, annars åberopar ett undantag.

Skapa ett NotFoundException om det inte finns något sådant book_id

Som orElseThrow-metoden kastar ett NotFound-undantag. Följande är undantagshanteringsdelen. Skapa en BookNotFoundException.java fil i undantagspaketet.

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

Den skapade klassen utökar Superclass of Exception. I konstruktorn skickar jag book_id och skriver ut undantaget.

Så det är det...

Vi har avslutat REST API-delen. Nu kan du bygga appen (vilket förklarades i del 1) och göra några tester med Postman.

Ansluter till MySql Database

Inuti application.properties av dina resurser lägg till följande:

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

Det är det.

Vi har byggt ett grundläggande REST API i Spring Boot. Grattis!

Om något är fel eller behöver korrigeras, vänligen meddela mig i kommentarsfältet.

Kontakta mig på twitter.

Lycka till med kodningen!