Spring Boot CRUD With PostgreSQL + REST API + Spring Data JPA

 Hi All,

Greeting of the day !.

Today we will look at how we can develop a simple REST API for performing CRUD operations with PostgreSQL and Spring Data JPA.

So let's start.

First of all, we will need PostgreSQL installed in our system, if you have not installed it yet you can refer to my below post for the installation guide and details of creating a database on the PostgreSQL server.

Download And Install PostgreSQL

Once you have installed PostgreSQL go to Spring Initializr and configure our spring boot application as shown below.

Next click on generate and one zip file of the project will be downloaded. Now unzip the project and open it in your IDE.

The next step is to add the PostgreSQL dependency so we will add the following dependency in pom.xml 

<dependency>

    <groupId>org.postgresql</groupId>

    <artifactId>postgresql</artifactId>

    <version>42.2.20</version>

</dependency>

Next, we will add our database-related properties to the application.properties as shown below.

spring.datasource.url=jdbc:postgresql://localhost:5432/postgres

spring.datasource.username=add_user_name

spring.datasource.password=add_password

spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect

spring.jpa.hibernate.ddl-auto = update

Now, let's configure the model entity class which will be used for creating tables by spring data JPA.

Student.java

package com.demo.student.mgt.model; import lombok.*; import javax.persistence.*; @Entity @Table @AllArgsConstructor @NoArgsConstructor @Builder @Getter @Setter public class Student { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column private String name; @Column private String mobileNumber; }

Next, we create ResponseDTO which we will use to send a response from API to the caller.

ResponseDTO.java

package com.demo.student.mgt.dto; import lombok.*; @AllArgsConstructor @NoArgsConstructor @Getter @Setter @Builder public class ResponseDTO<T> { private String userMsg; private String detailMsg; private T responseJson; }

Now we will create StudentDTO which will be used for getting the request payload and sending the response payload to the caller.

StudentDTO.java

package com.demo.student.mgt.dto; import lombok.*; @Builder @AllArgsConstructor @NoArgsConstructor @Getter @Setter @ToString public class StudentDTO { private Long id; private String name; private String mobileNumber; }

Here we have not used validations if you want to learn how to validate REST API Requests refer to Spring Boot REST API Validation Using Annotations

Next, we will create a mapper class that will map StudentDTO to the Student entity class and vice versa.

StudentMapper.java

package com.demo.student.mgt.mapper; import com.demo.student.mgt.dto.StudentDTO; import com.demo.student.mgt.model.Student; import org.springframework.stereotype.Component; import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; @Component public class StudentMapper { public Student map(StudentDTO studentDTO){ return Student.builder().name(studentDTO.getName()) .mobileNumber(studentDTO.getMobileNumber()) .id(studentDTO.getId()) .build(); } public StudentDTO map(Student student){ return StudentDTO.builder().id(student.getId()) .mobileNumber(student.getMobileNumber()) .name(student.getName()).build(); } public List<StudentDTO> map(List<Student> studentList){ List<StudentDTO> studentDTOList=new ArrayList<>(); studentList.stream() .map(student -> studentDTOList.add(map(student))) .collect(Collectors.toList()); return studentDTOList; } }

Now we will create a repository layer by extending JpaRepository which will provide us all inbuild methods used in CRUD operation.

StudentRepository.java
package com.demo.student.mgt.repository; import com.demo.student.mgt.model.Student; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; @Repository public interface StudentRepository extends JpaRepository<Student,Long> { }

Now we will create a service layer which will be called by the controller and its responsibility is to manage transactions & we will also add all business logic in the service layer.

StudentService.java
package com.demo.student.mgt.service; import com.demo.student.mgt.dto.StudentDTO; import java.util.List; public interface StudentService { public void addStudent(StudentDTO studentDTO); public List<StudentDTO> listStudent(); public StudentDTO getStudent(Long id); public void deleteStudent(Long id); public void updateStudent(StudentDTO studentDTO); }

 

Now let's create an implementation for StudentService in which we will implement all of the above methods that we have declared.

StudentServiceImpl.java
package com.demo.student.mgt.service.impl; import com.demo.student.mgt.dto.StudentDTO; import com.demo.student.mgt.exeption.StudentNotFoundException; import com.demo.student.mgt.mapper.StudentMapper; import com.demo.student.mgt.model.Student; import com.demo.student.mgt.repository.StudentRepository; import com.demo.student.mgt.service.StudentService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import java.util.List; import java.util.Optional; @Service @Transactional(readOnly = true) public class StudentServiceImpl implements StudentService { @Autowired private StudentRepository studentRepository; @Autowired private StudentMapper studentMapper; @Override @Transactional(readOnly = false) public void addStudent(StudentDTO studentDTO) { Student student=studentMapper.map(studentDTO); studentRepository.save(student); } @Override public List<StudentDTO> listStudent() { List<Student> studentList=studentRepository.findAll(); return studentMapper.map(studentList); } @Override public StudentDTO getStudent(Long id) { Optional<Student> optionalStudent=studentRepository.findById(id); if(optionalStudent.isPresent()){ return studentMapper.map(optionalStudent.get()); }else{ throw new StudentNotFoundException("Student not found"); } } @Transactional(readOnly = false) public void deleteStudent(Long id) { studentRepository.deleteById(id); } @Override @Transactional(readOnly = false) public void updateStudent(StudentDTO studentDTO) { Student student=studentMapper.map(studentDTO); studentRepository.save(student); } }

Next, we will create the exception class StudentNotFoundException which we have used in the above code in case we don't find students with the required ids.

package com.demo.student.mgt.exeption; import lombok.AllArgsConstructor; import lombok.ToString; @AllArgsConstructor @ToString public class StudentNotFoundException extends RuntimeException { private String msg; }

Next, we will need to create a handler for our application that will catch all exceptions thrown from our code and will return a proper response to the API caller.

package com.demo.student.mgt.controlleradvice; import com.demo.student.mgt.dto.ResponseDTO; import com.demo.student.mgt.exeption.StudentNotFoundException; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.ControllerAdvice; import org.springframework.web.bind.annotation.ExceptionHandler; @ControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(value = {StudentNotFoundException.class}) public ResponseEntity<Object> handle(StudentNotFoundException e){ return new ResponseEntity<>(ResponseDTO.builder() .userMsg("Student not found.").build(), HttpStatus.BAD_REQUEST); } @ExceptionHandler(value = {Exception.class}) public ResponseEntity<Object> handle(Exception e){ System.out.println(e); return new ResponseEntity<>(ResponseDTO.builder() .userMsg("Unknown error occurred.").build(), HttpStatus.BAD_REQUEST); } }

As a final step, we will create our controller which will have endpoints for CRUD operation, and from the controller, we will call StudentService as shown below.

API Would be using the following HTTP methods 

POST --Create Student

PUT --Update Student

GET--Find Student

GET-- List Student

DELETE --Delete Student

package com.demo.student.mgt.controller; import com.demo.student.mgt.dto.ResponseDTO; import com.demo.student.mgt.dto.StudentDTO; import com.demo.student.mgt.service.StudentService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import java.util.List; @RestController @RequestMapping("/student") public class StudentController { @Autowired private StudentService studentService; @PostMapping public ResponseEntity<ResponseDTO<Object>> addStudent(@RequestBody StudentDTO studentDTO){ studentService.addStudent(studentDTO); return new ResponseEntity(ResponseDTO.builder().userMsg("Student added successfully") .build(), HttpStatus.CREATED); } @GetMapping("list") public ResponseEntity<ResponseDTO<List<StudentDTO>>> listStudent(){ List<StudentDTO> studentDTOList = studentService.listStudent(); return new ResponseEntity(ResponseDTO.builder().responseJson(studentDTOList). userMsg("Students retrieved successfully").build(),HttpStatus.OK); } @GetMapping("/{id}") public ResponseEntity<ResponseDTO<StudentDTO>> getStudent(@PathVariable("id") Long id){ StudentDTO studentDTO = studentService.getStudent(id); return new ResponseEntity(ResponseDTO.builder().responseJson(studentDTO). userMsg("Student retrieved successfully").build(),HttpStatus.OK); } @DeleteMapping("/{id}") public ResponseEntity<ResponseDTO<StudentDTO>> deleteStudent(@PathVariable("id") Long id){ studentService.deleteStudent(id); return new ResponseEntity(ResponseDTO.builder(). userMsg("Student deleted successfully").build(),HttpStatus.OK); } @PutMapping public ResponseEntity<ResponseDTO<Object>> updateStudent(@RequestBody StudentDTO studentDTO){ studentService.updateStudent(studentDTO); return new ResponseEntity(ResponseDTO.builder(). userMsg("Student updated successfully").build(), HttpStatus.CREATED); } }

Below are details of the endpoint with payload for testing purposes.

Add Student--Http Method Post --End point -- localhost:8080/student

Payload 

{

    "name":"Akash",

    "mobileNumber":"123457"

}

List Student --Get End Point localhost:8080/student/list

Get Student --Http Method Get --End Point localhost:8080/student/1

Update Student --Http Method Put -- End Point localhost:8080/student

Payload 

{

    "id":1,

    "name":"Akash",

    "mobileNumber":"123457"

}

Delete Student --Http Method Delete --End Point localhost:8080/student/1

Also below is the attached project structure for your reference.

If you have any questions let me know in the comment section.

Other articles you can refer

Spring Boot JDBC Template CRUD Operation

Spring REST API Authentication Using JWT + Spring Security JWT Authentication With Spring Boot

Hibernate CRUD Example Using JSP & Servlet + MySQL + Maven

Spring MVC CRUD + Spring Boot + Oracle + Thymeleaf

Spring Rest API + CRUD Example + Spring Boot + Oracle Database + Spring JPA

Thank you & Happy Learning.