Hoe een Rest API te bouwen met Spring Boot met behulp van MySQL en JPA

De starter- en tester-afhankelijkheden vormen de kern voor het maken van de Spring Boot-applicatie om op de server te dienen.

Laten we nu naar APIApplication.java gaan, wat het hoofdbestand is.

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

Hier staat de naam van het pakket in de eerste regel van de code. Door die pakketnaam te gebruiken, kunt u elke klasse, methode of instantie in een ander pakketbestand importeren.

Daarna worden twee modules geïmporteerd uit het pakket "org.springframework.boot".

1. SpringApplication
2. SpringBootApplicatie

Aangezien Spring Boot het nieuwste framework voor het ontwikkelen van applicaties van Spring is, heeft het zowel de pakketten van Spring Application als de specifieke pakketten nodig.

Daarna @SpringBootApplication Er wordt gebruik gemaakt van annotatie. Deze annotatie bestaat uit een annotatie die in het voorjaar wordt gebruikt:

1. @Component — Vertelt de compiler dat de volgende klasse een component is die moet worden opgenomen bij het compileren van de hele applicatie.
2. @ComponentScan — Deze scant welke pakketten we gaan gebruiken in de volgende Java-klasse.
3. @EnableAutoConfiguration — schakelt het automatische configuratiemechanisme van Spring Boot in om belangrijke modules te importeren zodat Spring Boot kan worden uitgevoerd.

Dit zijn de annotaties die worden gebruikt om de Spring Boot-applicatie op een server te laten draaien.

Hier is een artikel dat ik heb geschreven over annotatie en hun gebruik in Java.

Laten we een model maken voor onze gegevens

Laten we een modelklasse maken om de details van een boek op te slaan, op te halen, bij te werken en te verwijderen.

Daarvoor moet ik een nieuw pakket maken met de naam model en daarbinnen maak je een Book.java class om mijn code te plaatsen.

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

Hier gebruik ik JPA (Java Persistence API), een verzameling klassen en methoden om continu gegevens in een database op te slaan.

@Entity — wordt gebruikt om aan te geven dat deze klasse een entiteit in de database wordt.

@Tabel — die een aantal waarden nodig heeft, zoals de naam die u uw tabel gaat geven

@Id — geeft aan dat de id de primaire sleutel/identificatiesleutel is voor deze tabel

@NotBlank — wordt gebruikt om te zeggen dat deze kenmerken niet leeg mogen zijn.

Verder is er een lege constructor die een supermethode heeft om aan de JPA-gebruiken te voldoen. Getter- en setter-methoden bevinden zich meestal in een POJO-klasse (Gewoon oud Java-object ).

De repository maken

Vervolgens gaan we een repository . maken pakket voor databasebeheer in Java.

Maak een interface met de naam BookRepository.java in de repository pakket.

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

Ik heb de JpaRepository . geïmporteerd pakket om die repository te gebruiken in de BookRepository interface door mijn meest recent gecodeerde boekmodel te verbinden om CRUD . te doen operaties.

Er zijn al ingebouwde methoden in die opslagplaatsen om CRUD-bewerkingen uit te voeren.

Bijv.:

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

Binnen de <> tag nemen we de modelnaam die we gaan gebruiken en het datatype van de primaire sleutel.

@Repository :Annotatie die wordt gebruikt om de DAO aan te geven (Data Access Object ) component in de persistentielaag.

Het vertelt de compiler dat de interface de Repository gaat gebruiken om database-activiteiten uit te voeren.

Controller en afhandeling van uitzonderingen maken

Maak een nieuw pakket met de naam controller, en daarbinnen maak je een BookController.java bestand dat de eindpunten bevat.

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

Het eerste geïmporteerde pakket is voor de uitzondering Boek niet gevonden (waarvoor we zometeen een bestand gaan maken).

Uitleg van annotaties die we hier hebben gebruikt:

1. RestController: Deze annotatie wordt gebruikt om elke methode in de geannoteerde klasse aan te duiden als Domain Object.

Dus wat is domeinobject...?

Er staat gewoon dat Domain Object ==Business Object.

Ze worden meestal vertegenwoordigd door entiteiten en waardeobjecten die verband houden met het eindpunt dat we geven om de gegevens uit de database te halen.

2. Autowired :Deze annotatie wordt gebruikt om de bonenklassen automatisch te bedraden.

Daarvoor moet je weten over "Wat is een bonenklasse..? ”

Kortom, een Java Bean-klasse is een eenvoudige klasse waarin veel objecten zijn ingekapseld.

Dit is een artikel dat ik heb geschreven over Java Bean Classes.

Hieronder volgen de toewijzingsannotaties voor de eindpunten om CRUD-bewerkingen uit te voeren.

3. GetMapping: Dit is een interface die het pad van het eindpunt bevat om een ​​Get-methode uit te voeren. Deze GetMapping-interface gebruikt de RequestMapping-interface die de methode "path, value, params, headers" kan hebben om de Get-methode in eerdere Spring-versies uit te voeren.

Nu is het vereenvoudigd door GetMapping te gebruiken.

4. PostMapping :Dit is een interface die het pad van het eindpunt bevat om de Post-methode uit te voeren.

5. PutMapping: Dit is een interface die het pad van het eindpunt bevat om de methode Put to Update uit te voeren.

6. Mapping verwijderen: Dit is een interface die het pad van het eindpunt bevat om de methode Verwijderen uit te voeren.

In de laatste regels heb je waarschijnlijk de "ResponseEntity . opgemerkt ” zoekwoord.

Wat is dat …??

Het is een Java-klasse die HttpEntity . erft class om de HTTP-reacties te manipuleren. Of het verzoek van de verbinding "OK . is ” of als er problemen zijn, gooi een uitzondering van de HttpEntity klasse.

ofElseThrow(): Dit is een methode die wordt gevonden in de Optionele klasse in Java8 die is geïntroduceerd om Exceptions af te handelen. De optionele klasse biedt verschillende hulpprogramma's om de aan- of afwezigheid van een object te controleren, wat helpt om met NullPointerException om te gaan.

ofElseThrow is een methode die waarde retourneert indien aanwezig, anders een uitzondering aanroept.

Een NotFoundException maken als er geen book_id is

Als orElseThrow-methode een NotFound-uitzondering genereert. Het volgende is het gedeelte Exception Handling. Maak een BookNotFoundException.java bestand in uitzonderingspakket.

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

De gemaakte klasse breidt de Superclass of Exception uit. In de constructor geef ik de book_id door en drukt de uitzondering af.

Dus dat was het...

We zijn klaar met het REST API-gedeelte. Nu kun je de app bouwen (wat werd uitgelegd in deel 1) en wat testen doen met Postman.

Verbinding maken met MySql Database

Binnen de application.properties van uw bronnen map, voeg het volgende toe:

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

Dat is het.

We hebben een basis REST API gebouwd in Spring Boot. Gefeliciteerd!

Als er iets mis is of moet worden gecorrigeerd, laat het me dan weten in het opmerkingengedeelte.

Neem contact met me op via twitter.

Veel plezier met coderen!