Sådan bygger du en Rest API med Spring Boot ved hjælp af MySQL og JPA

Starter- og testafhængighederne er kernen for at skabe Spring Boot-applikationen til at tjene på serveren.

Lad os nu gå til APIApplication.java, som er hovedfilen.

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

Her er pakkens navn i den første linje i koden. Ved at bruge det pakkenavn kan du importere enhver klasse, metode eller instans i en anden pakkefil.

Derefter importeres to moduler fra pakken "org.springframework.boot".

1. Forårsansøgning
2. SpringBootApplication

Da Spring boot er den seneste applikationsudviklingsramme for Spring, har den brug for både Spring Applications pakker og dens specifikke pakker.

Derefter @SpringBootApplication Anmærkning bruges. Denne annotation består af annotation, som bruges i foråret:

1. @Komponent — Fortæller compileren, at følgende klasse er en komponent, som skal inkluderes, når hele applikationen kompileres.
2. @ComponentScan — Denne laver scanningen af, hvilke pakker vi skal bruge i den følgende Java-klasse.
3. @EnableAutoConfiguration — gør det muligt for Spring Boots autokonfigurationsmekanisme at importere vigtige moduler, så Spring Boot kan køre.

Dette er de annoteringer, der bruges til at starte Spring Boot-applikationen til at køre på en server.

Her er en artikel, jeg har skrevet om annotering og deres anvendelser i Java.

Lad os skabe model for vores data

Lad os oprette en modelklasse for at gemme, hente, opdatere og slette detaljerne i en bog.

Til det skal jeg oprette en ny pakke med navnet model og indeni det at skabe en Book.java klasse for at sætte min kode.

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

Her bruger jeg JPA (Java Persistence API), som er en samling af klasser og metoder til kontinuerligt at gemme data i en database.

@Entity — bruges til at angive, at denne klasse vil være en enhed i databasen.

@Tabel — som tager nogle værdier som det navn, du vil navngive din tabel

@Id — angiver, at id'et er den primære nøgle/identifikationsnøgle for denne tabel

@NotBlank — bruges til at sige, at disse attributter ikke skal være tomme.

Bortset fra det er der en tom konstruktør, som har en super metode til at tilfredsstille JPA-tolden. Getter- og setter-metoder er normalt i en POJO-klasse (Almindelig gammelt Java-objekt ).

Oprettelse af depotet

Dernæst skal vi oprette et depot pakke til at håndtere databasestyring i Java.

Opret en grænseflade kaldet BookRepository.java inde i depotet pakke.

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

Jeg har importeret JpaRepository pakke for at bruge dette lager i BookRepository grænseflade ved at forbinde min senest kodede bogmodel til CRUD operationer.

Der er allerede indbyggede metoder i disse lagre til at udføre CRUD-operationer.

F.eks.:

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

Inde i <>-tagget tager vi det modelnavn, vi skal bruge, og den primære nøgles datatype.

@Repository :Annotation brugt til at angive DAO (Data Access Object ) komponent i persistenslaget.

Det fortæller compileren, at grænsefladen vil bruge Repository til at udføre databaseaktiviteter.

Oprettelse af controller og undtagelseshåndtering

Opret en ny pakke kaldet controller, og inde, der opretter en BookController.java fil, som indeholder slutpunkterne.

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

Den første importerede pakke er til undtagelsen Bog ikke fundet (som vi skal oprette en fil til om lidt).

Forklaring af annoteringer, vi brugte her:

1. RestController: Denne annotation bruges til at betegne hver metode i den kommenterede klasse som Domain Object.

Så hvad er Domain Object...?

Det siger blot, at Domain Object ==Business Object.

De er normalt repræsenteret af entiteter og værdiobjekter relateret til det endepunkt, vi giver for at hente data fra databasen.

2. Autokabelforbundet :Denne annotation bruges til at koble bønneklasserne automatisk.

Til det skal du vide om "Hvad er en bønneklasse..? ”

Grundlæggende er en Java Bean Class en simpel klasse, som indkapsler mange objekter i den.

Dette er en artikel, jeg skrev om Java Bean Classes.

Følgende er kortlægningsannoteringerne for endepunkterne til at udføre CRUD-operationer.

3. GetMapping: Dette er en grænseflade som indeholder stien til slutpunktet for at udføre en Get-metode. Denne GetMapping-grænseflade bruger RequestMapping-grænsefladen, som kan have "path, value, params, headers"-metoden til at udføre Get-metoden i tidligere Spring-versioner.

Nu er det forenklet ved at bruge GetMapping.

4. PostMapping :Dette er en grænseflade som indeholder stien til slutpunktet for at udføre Post-metoden.

5. PutMapping: Dette er en grænseflade som indeholder stien til slutpunktet for at udføre Put-metoden til opdatering.

6. Slet kortlægning: Dette er en grænseflade som indeholder stien til slutpunktet for at udføre Slet-metoden.

I de sidste linjer har du sikkert bemærket "ResponseEntity ” søgeord.

Hvad er det …??

Det er en Java-klasse, som arver HttpEntity klasse for at manipulere HTTP-svarene. Om anmodningen om forbindelsen er "OK ” eller hvis der er problemer, så smid en undtagelse fra HttpEntity klasse.

orElseThrow(): Dette er en metode, der findes i Valgfri klasse i Java8 som blev indført for at håndtere Undtagelser. Den valgfri klasse giver forskellige hjælpemetoder til at kontrollere tilstedeværelsen eller fraværet af et objekt, hvilket hjælper med at håndtere NullPointerException.

eller ElseThrow er en metode, der returnerer værdi, hvis den er til stede, ellers fremkalder en undtagelse.

Oprettelse af en NotFoundException, hvis der ikke er et sådant book_id

Som orElseThrow-metoden kaster en NotFound-undtagelse. Følgende er undtagelseshåndteringsdelen. Opret en BookNotFoundException.java fil i undtagelsespakken.

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 oprettede klasse udvider Superklassen af ​​Undtagelse. I konstruktøren videregiver jeg book_id og udskriver undtagelsen.

Så det er det...

Vi har afsluttet REST API-delen. Nu kan du bygge appen (som blev forklaret i del 1) og lave nogle tests med Postman.

Opretter forbindelse til MySql-database

Inde i application.properties af dine ressourcer mappe, skal du tilføje følgende:

## 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 er det.

Vi har bygget en grundlæggende REST API i Spring Boot. Tillykke!

Hvis noget er forkert eller skal rettes, så lad mig det vide i kommentarfeltet.

Kontakt mig på twitter.

Glædelig kodning!