Hogyan készítsünk egy Rest API-t Spring Boot alkalmazással a MySQL és a JPA segítségével

Sziasztok! Az elmúlt évben megtanultam a JavaScript-et a teljes verem webfejlesztéshez. Változásképpen elkezdtem elsajátítani a Java-t - a hatékony objektumorientált nyelvet.

Ebben az esetben találtam egy nagyon tiszta és elegáns keretet Spring Boot néven, hogy felépítsem a hátulját.

Korábban a JavaScript fejlesztésében a következőket használtam:

  1. Mongúz - ORM (Object Relational Mapping) a Mongo DB-hez
  2. Folytatás - ORM a MySQL-hez

A Java-val kapcsolatos fejlesztésekhez sok olyan ORM van, mint a hibernálás, a JPA (Java Persistence API) és a Java objektumorientált lekérdezés.

Úgy döntök, hogy a JPA-val építem, amelyet hagyományosan a Java alkalmazásokban használnak.

Nagyon érdekes volt, és körülbelül egy hétig tartott a befejezés, mivel meg kellett tanulnom a Spring Boot-ot (sok „ @ ” jelölést és más jóféle dolgot kell megtanulni), a JPA-t és a Hibernate-t.

Mindezt a varázslatot leginkább a Spring Boot-ban használt annotációk („ @ ” szimbólum) végzik .

Tavaszi Boot Maven projekt létrehozása

Hozzunk létre egy Spring Boot Maven Project alkalmazást ezen a linken keresztül.

A „ Maven ” egy projektmenedzsment eszköz, amelyet a függőségkezelés kezelésére használnak. Pontosan olyan, mint a Node Package Manager ( NPM ) a JS fejlesztői környezetben.

A NodeJS-ben van a package.json a függőségkezeléshez és a pom.xml a Spring Boot-ban a függőségkezeléshez.

Írja be a Csoportba a kívánt nevet. Általában a szervezet domainnevét jobbról balra írják.

Például a domain nevünk a www.javaAPI.com , tehát a csoport neve com.javaAPI.www lehet

Ezután az Artifact mezőbe írja be a kívánt mappa nevét .

A jobb oldalon adja hozzá a következő függőségeket:

  1. WEB - A Spring függőségeinek használata (A Spring Boot régebbi keretrendszere webalkalmazások fejlesztésére szolgál)
  2. JPA - Java Persistence API
  3. MYSQL

Ezután kattintson a „Projekt létrehozása” gombra. Talál egy rar fájlt - bontsa ki. Ezután nyissa meg azt a mappát a kedvenc IDE-jében.

Kattintson a com.rest.API gombra, és az alábbiak szerint talál egy ApiApplication.java fájlt:

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

Ez a kód elég a szerver indításához. Normál esetben a tavaszi csomagtartó a localhoston fut : 8080 .

Írja be a terminált az alábbiak szerint:

mvn spring-boot: fut

Nézze meg a helyi hostját a 8080-as porton a webböngészőben. Ez üresnek tűnik, mivel még nem tettünk semmit.

Fedezzük fel a fájlokat és azok címkéit

Ha megnézi a pom.xml fájlt, észreveheti, hogy a tavaszi inicializálás során az alkalmazás létrehozásakor megadott függőségek, például a MySQL, a JPA és a Web egy cy> tag.

Az indító és a tesztelő függőségek jelentik a Spring Boot alkalmazás létrehozásának alapját a kiszolgálón.

Most térjünk át az APIApplication.java fájlra, amely a fő fájl.

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

Itt a csomag neve szerepel a kód első sorában. A csomagnév használatával bármilyen osztályt, metódust vagy példányt importálhat egy másik csomagfájlba.

Ezt követően két modult importálunk az „org.springframework.boot” csomagból.

  1. SpringApplication
  2. SpringBootApplication

Mivel a Spring boot a Spring legújabb alkalmazásfejlesztő keretrendszere, ezért szüksége van a Spring Application csomagjaira, valamint a speciális csomagokra.

Ezt követően @SpringBootApplication Annotation kerül felhasználásra. Ez a kommentár a tavasszal használt kommentárokból áll:

  1. @Component - Elmondja a fordítónak, hogy a következő osztály egy olyan összetevő, amelyet fel kell venni a teljes alkalmazás fordításakor.
  2. @ComponentScan - Ez azt vizsgálja, hogy mely csomagokat fogjuk használni a következő Java osztályban.
  3. @EnableAutoConfiguration - lehetővé teszi a Spring Boot automatikus konfigurációs mechanizmusával a Spring Boot futtatásához szükséges fontos modulok importálását.

Ezekkel a feljegyzésekkel indították a Spring Boot alkalmazást egy szerveren való futtatáshoz.

Itt van egy cikk, amelyet a Jegyzetekről és azok Java használatáról írtam.

Hozzunk létre modellt az adatainkhoz

Hozzunk létre egy Model osztályt a könyv részleteinek mentéséhez, letöltéséhez, frissítéséhez és törléséhez.

Ehhez létre kell hoznom egy új csomagot, amelynek neve modell, és azon belül létrehozni egy Book.java osztályt a kódom felhelyezéséhez.

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

Itt a JPA-t (Java Persistence API) használom, amely osztályok és módszerek gyűjteménye az adatok folyamatos tárolásához egy adatbázisban.

@Entity - annak jelzésére szolgál, hogy ez az osztály Entitás lesz az adatbázisban.

@ Táblázat - amely néhány olyan értéket vesz fel, mint például a táblázat megnevezésére szolgáló név

@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…

We have finished the REST API part. Now you can build the app (which was explained in Part 1) and do some Testings with Postman.

Connecting with MySql Database

Inside the application.properties of your resources folder, add the following:

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

That’s it.

We have built a basic REST API in Spring Boot. Congrats!

If anything is wrong or need to be corrected, please let me know in the comments section.

Get in touch with me on twitter.

Happy Coding!