Spring Boot Restful Web Services CRUD Example Download

In this tutorial, you will see spring boot restful web services crud example with MySQL and JPA. Spring Boot will allow you to set up a tiny configuration in a quick way to create your application. That provides the jar files facility to include your custom jar file packages as well as the built-in Tomcat Server for executing your application, we don't have to include external servers.

Let's start the tutorial we do to build Spring Restful Web Service CRUD application using JPA.

Spring Boot Restful Web Services CRUD Example Download

Table Content

1. What is CrudRepository Interface

2. The API we’ll build

3. Database and Table Creating

4. Creating New Spring Boot Project

5. pom.xml

6. application.properties

7. Student.java

8. StudentRepository.java

9. StudentController.java

10. SpringBootRestfulCrudApplication.java

11. Let’s the test application

What is CrudRepository Interface

CrudRepository is an interface which arrives from Spring Framework. CrudRepository extends Spring Data Repository which is a core marker interface for the repository. CrudRepository offers the formulaic method for the operation creating, reading, updating, and deleting.

CrudRepository contains a total of 11 CRUD operation methods, some of which are listed below which we will be using in this application:

<S extends T> S save(S entity): Save and update a given entity. The entity must not be null and the saved entity; will never be null.

Iterable<T> findAll(): Returns all entities.

Optional<T> findById(ID id): Retrieves an entity by its ID. The ID must not be null.

void deleteById(ID id): Deletes the entity with the given ID. The ID must not be null.

Note: note took above all methods from docs.spring.io

The API we'll build

We'll create a Student Resource which uses Restful API (URIs) and HTTP methods to consume three services.

URLs	Method	Description
/students/add	@PostMapping	Create a new student
/students/all	@GettMapping	Retrieve all students
/students/student/{id}	@GettMapping	Get records of a particular student
/students/update/{id}	@PuttMapping	Update existing student records
/students/delete/{id}	@DeleteMapping	Delete a particular student record

Database and Table Creating

Database Credentials. In this tutorial, I will store the first name and last name of the student. Import the code below into your PHPMyAdmin.

CREATE TABLE `tbl_student` (
  `student_id` int(11) NOT NULL,
  `student_firstname` varchar(15) NOT NULL,
  `student_lastname` varchar(15) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

Creating New Spring Boot Project

Project directory structure of Spring Boot Restful Web Service CRUD example in STS tool

Note: You must have an enabled internet connection.

Step 1 – Start Spring Too Suite. Go to File -> New -> Spring Starter Project. Choose Spring Starter Project according to the figure below.

Step 2 – In the second step, the configuration of the project is typed below. Click to the next button after fill-up.

Name – SpringBootRestfulCRUD

Group – com.onlyxcodes

Description – Spring Boot Restful CRUD JPA and MySQL

Package – com.onlyxcodes.app

configuration of the spring boot project. Fill-up name, group and description

Step 3 – In the third step to select packages with custom jar files. MySQL Driver, Spring Data JPA, and Spring Web. Click the next button below.

Step 4 – Finally, the last step to set up a project. Select the Finish button.

pom.xml

To build Spring Boot Restful CRUD application by following necessary dependencies.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.2.4.RELEASE</version>
  <relativePath/> <!-- lookup parent from repository -->
 </parent>
 <groupId>com.onlyxcodes</groupId>
 <artifactId>SpringBootRestfulCRUD</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <name>SpringBootRestfulCRUD</name>
 <description>Spring Boot Restful CRUD JPA MySQL</description>

 <properties>
    <maven-jar-plugin.version>3.1.1</maven-jar-plugin.version>
 </properties>

 <dependencies>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
  </dependency>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
  </dependency>

  <dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <scope>runtime</scope>
  </dependency>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
   <exclusions>
    <exclusion>
     <groupId>org.junit.vintage</groupId>
     <artifactId>junit-vintage-engine</artifactId>
    </exclusion>
   </exclusions>
  </dependency>
 </dependencies>

 <build>
  <plugins>
   <plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
   </plugin>
  </plugins>
 </build>

</project>

application.properties

To connect the MySQL database and set up a configuration of JPA properties by following the codes. Inside src/main/resources/application.properties we will import these codes.

# MySQL database connecting utility
spring.datasource.url=jdbc:mysql://localhost:3306/springbootrestcrud_db
spring.datasource.username=root
spring.datasource.password=

# JPA property utility
spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.show_sql=true

Create JPA Entity or Model class

Student.java

In the com.onlyxcodes.app.model package, create a Student model class. We describe five attributes for the annotation in this class.

@Entity and @Table establish top of class annotation. @Entity proves that the class is a persistent Java class and @Table annotation used to map your existing database table.

@Id use primary key annotation. @GeneratedValue annotation can be used to specify the primary key generation strategy. GenerationType.AUTO, the default generation type AUTO that the table field auto Increment. @Coulmn annotation used to map columns from the table.

Note: If your database doesn't have a table, @Entity annotation informs Hibernate to create a table out of that class.

package com.onlyxcodes.app.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "tbl_student")
public class Student {
 
 @Id
 @GeneratedValue(strategy = GenerationType.AUTO)
 @Column(name = "student_id")
 private int id;
 
 @Column(name = "student_firstname")
 private String firstname;
 
 @Column(name = "student_lastname")
 private String lastname;

 public int getId() {
  return id;
 }

 public void setId(int id) {
  this.id = id;
 }

 public String getFirstname() {
  return firstname;
 }

 public void setFirstname(String firstname) {
  this.firstname = firstname;
 }

 public String getLastname() {
  return lastname;
 }

 public void setLastname(String lastname) {
  this.lastname = lastname;
 }
 
}

Create Repository Interface

StudentRepository.java

Create a StudentRepository interface underneath in com.onlyxcodes.app.repository package. And extends CrudRepository which Spring Boot implemented auto into a Bean called a studentrepository.

package com.onlyxcodes.app.repository;

import org.springframework.data.repository.CrudRepository;

import com.onlyxcodes.app.model.Student;

public interface StudentRepository extends CrudRepository<Student, Integer>{

}

Create the Controller

StudentController.java

Finally, inside the package com.onlyxcodes.app.controller creates StudentController class. This class handles the user-desired operation of creating, reading, updating, and deleting.

package com.onlyxcodes.app.controller;

import java.util.List;
import java.util.Optional;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.onlyxcodes.app.model.Student;
import com.onlyxcodes.app.repository.StudentRepository;

@RestController
@RequestMapping("students")
public class StudentController {

 @Autowired
 StudentRepository studentrepository;
 
 // retrieve all student from database
 @GetMapping("all")
 public List<Student> getAllStudent()
 {
  List<Student> student=(List<Student>) studentrepository.findAll(); 
  return student;
 }
 
 // insert new student into database
 @PostMapping("add")
 public Student addStudent(@RequestBody Student student)
 {
  return studentrepository.save(student);
 }
 
 // get particular student by their ID
 @GetMapping("student/{id}")
 public Optional<Student> getStudentId(@PathVariable int id)
 {
  return studentrepository.findById(id);
 }
 
 // update existing student 
 @PutMapping("update/{id}")
 public Student updateStudent(@RequestBody Student student)
 {
  return studentrepository.save(student);
 }
 
 // delete particular student from database
 @DeleteMapping("delete/{id}")
 public void deleteStudent(@PathVariable int id)
 {
  studentrepository.deleteById(id);
 }
}

@RequestMapping("/students") specifies that in this controller the URL of the REST API must begin with /students, so that we can use http://localhost:8080/students as our endpoint.

We use @Autowired for StudentRepository Interface class object injection.

The annotation @RequestBody indicates that a method parameter will be attached to the body of the web request. That means the method expects the following information in JSON format from the submission.

In spring the @PathVariable annotation binds the URI template variables to a controller's handler method parameters. A URI template contains the following variables of one or more paths enclosed by braces ({ }).

Note: the name of the template variable (between the curly braces) and the name of the parameter should match up.

The @RestController annotation contains the @Controller and @ResponseBody annotations. The @Controller annotation represents a class with endpoints and the @ResponseBody indicates a method return value should be bound to the web response body (according to documentation ).

SpringBootRestfulCrudApplication.java

See our application executing App Class.

package com.onlyxcodes.app;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringBootRestfulCrudApplication {

 public static void main(String[] args) {
  SpringApplication.run(SpringBootRestfulCrudApplication.class, args);
 }

}

Let's the test application

Now all of the codes are done perfectly. Let's check this application in the Postman. Friends this tool also available on Google Chrome extension.

1. Create a new Student.

First, by adding a new student to this URL http://localhost:8080/students/ add, selecting the POST method, selecting the raw radio button in the Body tab, setting Content-Type="application/json" in the Headers tab and pasting the following JSON code.

Note: If you want to insert a new record, we don't need to type the Id number because the Hibernate automatically generates the sequence number in the database.

{
    "firstname": "hamid",
    "lastname": "shaikh"
}

Create a new Student record in postman tool

See also record created in a database table.

check record created in a database table.

2. Read student record

By this URL http://localhost:8080/students/all, we retrieve student record. Choose the GET method, and click the Send button.

3. Update student record

We update the existing student record using this URL http://localhost:8080/students/update/1, select the PUT method, select the raw radio button in the Body tab, set Content-Type="application/json" in the Headers tab, and then paste the following JSON code.

Note: URL end 1 is your table Id. Since I change the record of 1 Id number.

{
    "id": 1,
    "firstname": "ankit",
    "lastname": "patel"
}

update the existing student record in postman tool

See also the updating of I d 1 record on the table

4. Delete student record

Finally with this URL http://localhost:8080/students/delete/1 we delete the student record, select the DELETE method and click the send button.

Note: Your table Id is the end of URL 1 Because I want to delete the record of 1 Id number.

On the table, too, the record was removed.

I hope you are enjoying Spring Boot Restful Web Service CRUD example Happy Coding :)

Related Articles –

Sending Email using Spring Boot Rest API

Spring Boot MVC CRUD Example With MySQL

Consuming (CRUD) Restful Web Service in Java

Download Codes

Wednesday, 19 February 2020