Kā izveidot Rest API ar Spring Boot, izmantojot MySQL un JPA

Sveiki visiem! Pagājušajā gadā es mācījos JavaScript pilnvērtīgas tīmekļa izstrādei. Pārmaiņas pēc es sāku apgūt Java - spēcīgo uz objektu orientēto valodu.

Tādā gadījumā es atradu ļoti tīru un elegantu ietvaru ar nosaukumu Spring Boot, lai izveidotu aizmuguri.

Iepriekš JavaScript izstrādē es izmantoju:

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

Ar Java saistītai izstrādei ir daudz tādu ORM kā Hibernate, JPA (Java Persistence API) un Java Object Oriented Querying.

Es izvēlos veidot ar JPA, kas tradicionāli tiek izmantots Java lietojumprogrammās.

Tas bija ļoti interesanti, un līdz pabeigšanai bija vajadzīga apmēram viena nedēļa, jo man vajadzēja iemācīties Spring Boot (ir jāmācās daudz anotāciju “ @ ” un cita veida dažādu lietu), JPA un hibernāciju.

Visu šo burvību galvenokārt veic anotācijas (“ @ ” simbols), kas tiek izmantotas Spring Boot.

Pavasara Boot Maven projekta izveide

Izveidosim Spring Boot Maven projekta lietojumprogrammu, izmantojot šo saiti.

Maven ” ir projekta vadības rīks, ko izmanto atkarības pārvaldībai. Tas ir tāpat kā Node Package Manager ( NPM ) JS izstrādes vidē.

Mums ir NodeJS pakete.json atkarības pārvaldībai un pom.xml Spring Boot - atkarības pārvaldībai.

Grupā ierakstiet vēlamo vārdu. Parasti organizācijas domēna nosaukums tiek rakstīts no labās uz kreiso pusi.

Piemēram, mūsu domēna nosaukums ir www.javaAPI.com, tāpēc grupas nosaukums varētu būt com.javaAPI.www

Pēc tam Artefact ierakstiet vajadzīgās mapes nosaukumu .

Labajā pusē pievienojiet šādas atkarības:

  1. WEB - lai izmantotu pavasara atkarības (vecāka programma Spring Boot tika izmantota tīmekļa lietojumprogrammu izstrādei)
  2. JPA - Java noturības API
  3. MYSQL

Pēc tam noklikšķiniet uz “Ģenerēt projektu”. Jūs atradīsit rar failu - izvelciet to. Pēc tam atveriet šo mapi iecienītākajā IDE.

Noklikšķiniet uz com.rest.API, un jūs atradīsit ApiApplication.java failu šādi:

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

Šis kods ir pietiekams, lai palaistu serveri. Parasti pavasara bagāžnieks darbojas uz localhost: 8080 .

Ierakstiet termināli šādi:

mvn spring-boot: palaist

Skatiet vietējo hostingu, kas darbojas tīmekļa pārlūkprogrammā portā 8080. Tas izskatās tukšs, jo mēs vēl neko neesam izdarījuši.

Izpētīsim failus un to tagus

Ja ieskatāties failā pom.xml, iespējams, pamanīsit, ka atkarības, kuras ievietojāt, pavasarī inicializējot lietojumprogrammu, piemēram, MySQL, JPA un Web, ievietosiet cy> tags.

Startera un testētāja atkarības ir pamatā, lai izveidotu pavasara sāknēšanas lietojumprogrammu, kas kalpo serverim.

Tagad pārejam uz APIApplication.java, kas ir galvenais fails.

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

Šeit pakas nosaukums ir koda pirmajā rindā. Izmantojot šo pakotnes nosaukumu, jūs varat importēt jebkuru klasi, metodi vai gadījumus citā pakotnes failā.

Pēc tam no paketes “org.springframework.boot” tiek importēti divi moduļi.

  1. Pavasara pieteikums
  2. SpringBootApplication

Tā kā pavasara sāknēšana ir jaunākā pavasara lietojumprogrammu izstrādes sistēma, tai ir nepieciešamas gan Spring Application paketes, gan īpašās paketes.

Pēc tam tiek izmantota @SpringBootApplication Anotācija. Šī anotācija sastāv no anotācijām, kuras tiek izmantotas pavasarī:

  1. @Component - paziņo kompilatoram, ka šāda klase ir komponents, kas jāiekļauj, sastādot visu lietojumprogrammu.
  2. @ComponentScan - Šis pārbauda , kuras paketes mēs izmantosim nākamajā Java klasē.
  3. @EnableAutoConfiguration - ļauj Spring Boot automātiskās konfigurācijas mehānismam importēt svarīgus pavasara sāknēšanas palaišanas moduļus.

Šīs ir anotācijas, kas tiek izmantotas, lai palaistu Spring Boot lietojumprogrammu, lai tā darbotos serverī.

Šeit ir raksts, ko esmu uzrakstījis par anotāciju un to lietošanu Java.

Izveidosim modeli saviem datiem

Izveidosim modeļu klasi, lai saglabātu, izgūtu, atjauninātu un izdzēstu grāmatas detaļas.

Lai to izdarītu , man ir jāizveido jauns pakotne ar nosaukumu modelis un tajā jāveido Book.java klase, lai ievietotu kodu.

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

Šeit es izmantoju JPA (Java Persistence API), kas ir klašu un metožu kolekcija, lai nepārtraukti saglabātu datus datu bāzē.

@Entity - tiek izmantots, lai apzīmētu, ka šī klase būs Entītija datu bāzē.

@Table - kam nepieciešamas dažas vērtības, piemēram, nosaukums, kuru nosauksit par savu tabulu

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

Mēs esam pabeiguši REST API daļu. Tagad jūs varat izveidot lietotni (kas tika paskaidrots 1. daļā) un veikt dažus testus ar Pastnieku.

Savienojuma izveide ar MySql datu bāzi

Inside application.properties jūsu resursu mapi, pievieno šādu tekstu:

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

Tieši tā.

Mēs esam izveidojuši pamata REST API Spring Boot. Apsveicu!

Ja kaut kas nav kārtībā vai ir jālabo, lūdzu, informējiet mani komentāru sadaļā.

Sazinieties ar mani twitter.

Priecīgu kodēšanu!