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

Hej allesammen! I det forløbne år har jeg lært JavaScript til fuld-stack webudvikling. For en ændring begyndte jeg at mestre Java - det kraftfulde objektorienterede sprog.

I så fald fandt jeg en meget ren og elegant ramme kaldet Spring Boot til at bygge en back-end.

Tidligere, i JavaScript-udvikling, brugte jeg:

  1. Mongoose - en ORM (Object Relational Mapping) til Mongo DB
  2. Sequelize - en ORM til MySQL

Til Java-relateret udvikling er der mange ORM'er som Hibernate, JPA (Java Persistence API) & Java Object Oriented Querying.

Jeg vælger at bygge med JPA, som traditionelt bruges i Java-applikationer.

Det var meget interessant, og det tog omkring en uge at afslutte, da jeg var nødt til at lære Spring Boot (Der er mange kommentarer " @ " og andre seje slags ting at lære), JPA og dvale undervejs.

Al denne magi udføres for det meste af kommentarerne (“ @ ” symbolet), der bruges i Spring Boot.

Oprettelse af et Spring Boot Maven-projekt

Lad os oprette en Spring Boot Maven Project-applikation ved hjælp af dette link.

" Maven " er et projektstyringsværktøj, der bruges til at styre afhængighedsstyring. Det er ligesom Node Package Manager ( NPM ) i JS-udviklingsmiljøet.

Vi har package.json i NodeJS til afhængighedsstyring og pom.xml i Spring Boot til afhængighedsstyring.

Skriv det ønskede navn i gruppe. Normalt er organisationens domænenavn skrevet fra højre mod venstre.

For eksempel er vores domænenavn www.javaAPI.com, så gruppenavnet kan være com.javaAPI.www

Skriv derefter navnet på den ønskede mappe i artefakten .

På højre side skal du tilføje følgende afhængigheder:

  1. WEB - At bruge afhængighederne af Spring (Den ældre ramme for Spring Boot bruges til at udvikle webapplikationer)
  2. JPA - Java Persistence API
  3. MYSQL

Klik derefter på "Generer projekt". Du finder en rar fil - udpak den. Åbn derefter den mappe i din foretrukne IDE.

Klik på com.rest.API, og du finder en ApiApplication.java- fil som følger:

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

Denne kode er nok til at starte din server. Normalt kører forårstøvlelocalhost: 8080 .

Indtast din terminal som følger:

mvn spring-boot: løb

Se din lokale vært køre i webbrowseren i port 8080. Det ser blankt ud, da vi ikke har gjort noget endnu.

Lad os udforske filerne og deres tags

Hvis du ser på pom.xml-filen, bemærker du muligvis, at de afhængigheder, du lægger i, når du opretter applikationen i foråret, initialiser som MySQL, JPA og Web, vil være inde i en cy> tag.

Start- og testerafhængigheden er kernen i oprettelsen af ​​Spring Boot-applikationen til servering 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 hjælp af dette pakkenavn kan du importere en hvilken som helst klasse, metode eller forekomst i en anden pakkefil.

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

  1. SpringApplication
  2. SpringBoot-applikation

Da Spring boot er den seneste applikationsudviklingsramme for Spring, har den brug for pakkerne til Spring Application såvel som dens specifikke pakker.

Derefter bruges @SpringBootApplication Annotation. Denne kommentar består af en kommentar, der bruges i foråret:

  1. @Komponent - Fortæller kompilatoren, at følgende klasse er en komponent, der skal medtages, når hele applikationen kompileres.
  2. @ComponentScan - Denne scanner hvilke pakker vi skal bruge i følgende Java-klasse.
  3. @EnableAutoConfiguration - gør det muligt for Spring Boot's autokonfigurationsmekanisme at importere vigtige moduler, som Spring Boot kan køre.

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

Her er en artikel, jeg har skrevet om kommentar og deres anvendelse i Java.

Lad os oprette model til vores data

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

Til det er jeg nødt til at oprette en ny pakke med navnet model og inde i 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.

@Table - som tager nogle værdier som det navn, du skal navngive din tabel

@Id — denotes that the id is the primary key / identifying key for this table

@NotBlank — is used to say that these attributes should not be blank.

Other than that there is an empty constructor which has a super method to satisfy the JPA customs. Getter and setter methods are usually in a POJO class (Plain old Java object).

Creating the Repository

Next, we are going to create a repository package to deal with database management in Java.

Create an Interface called BookRepository.java inside the repository package.

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

I have imported the JpaRepository package to use that repository in the BookRepository interface by connecting my most recently coded Book model to do CRUD operations.

There are already built-in methods in those repositories to do CRUD operations.

Eg:

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

Inside the tag we are taking the Model name we are going to use and the Primary key’s datatype.

@Repository: Annotation used to Indicate the DAO (Data Access Object) component in the persistence layer.

It tells the compiler that the interface is going to use the Repository to do database activities.

Creating Controller and Exception Handling

Create a new package called controller, andinside that create a BookController.java file which contains the endpoints.

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

The first imported package is for the Book Not Found exception (for which we are going to create a file in a bit).

Explanation of Annotations we used here:

  1. RestController: This annotation is used to denote every method in the annotated class as Domain Object.

So what is Domain Object…?

It simply says that Domain Object == Business Object.

They are usually represented by entities and value objects related to the endpoint we are giving to get the data from the database.

2. Autowired: This annotation is used to wire the bean classes automatically.

For that, you need to know about “What is a bean Class..?

Basically, a Java Bean Class is a simple class which encapsulates many objects into it.

This is an article I wrote on Java Bean Classes.

The following are the Mapping Annotations for the endpoints to perform CRUD Operations.

3. GetMapping: This is an interface which contains the path of the endpoint to perform a Get method. This GetMapping interface uses the RequestMapping interface which can have the “path, value, params, headers” method to perform the Get method in earlier Spring versions.

Now it’s simplified by using GetMapping.

4. PostMapping: This is an interface which contains the path of the endpoint to perform the Post method.

5. PutMapping: This is an interface which contains the path of the endpoint to perform the Put method to Update.

6. DeleteMapping: This is an interface which contains the path of the endpoint to perform the Delete method.

In the final lines, you probably noticed the “ResponseEntity” keyword.

What is that…??

It’s a Java class which inherits HttpEntity class to manipulate the HTTP Responses. Whether the request of the connection is “OK” or if there are any problems, throw an exception from the HttpEntity class.

orElseThrow(): This is a method found in the Optional class in Java8 which was introduced to handle Exceptions. The optional class provides various utility methods to check the presence or absence of an object, which helps to deal with NullPointerException.

orElseThrow is a method that Returns value if present, otherwise invokes an exception.

Creating a NotFoundException if there is no such book_id

As orElseThrow method throws a NotFound Exception. The following is the Exception Handling part. Create a BookNotFoundException.java file inside exception package.

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

The created class extends the Superclass of Exception. In the constructor, I’m passing the book_id & prints the exception.

So, that’s it…

Vi er færdige REST API-delen. Nu kan du oprette appen (som blev forklaret i del 1) og lave nogle test med Postman.

Opretter forbindelse til MySql-database

Inde i application.properties i din ressourcemappe 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 galt eller skal rettes, så lad mig det vide i kommentarfeltet.

Kontakt mig på twitter.

Glad kodning!