Spring Boot – CRUD Operations

17 Dec, 2021
CRUD stands for Create, Read/Retrieve, Update and Delete and these are the four basic operations that we perform on persistence storage. CRUD is data-oriented and the standardized use of HTTP methods. HTTP has a few methods which work as CRUD operations and do note they are very vital from a developmental point perspective in programming that also does helps us relate better web development and also aids us while dealing with databases. So, standard CRUD Operations is as follows:
POST: Creates a new resource
GET: Reads/Retrieve a resource
PUT: Updates an existing resource
DELETE: Deletes a resource
As the name suggests 
CREATE Operation: Performs the INSERT statement to create a new record.
READ Operation: Reads table records based on the input parameter.
UPDATE Operation: Executes an update statement on the table. It is based on the input parameter.
DELETE Operation: Deletes a specified row in the table. It is also based on the input parameter.
So in this article, we are going to perform some basic CRUD Operations by creating a Spring Boot Application and using the H2 Database. So here is a brief explanation of What’s Spring Boot and What’s H2 Database. 
Spring Boot is built on the top of the spring and contains all the features of spring. And is becoming a favorite of developers these days because it’s a rapid production-ready environment that enables the developers to directly focus on the logic instead of struggling with the configuration and setup. Spring Boot is a microservice-based framework and making a production-ready application in it takes very little time.
H2 is a relational database management system written in Java. It can be embedded in Java applications or run in client-server mode. The main features of H2 are:
Very fast, open-source, JDBC API
Embedded and server modes; in-memory databases
Browser-based Console application
Small footprint: around 2.5 MB jar file size
There is an interface available in Spring Boot named as CrudRepository that contains methods for CRUD operations. It provides generic Crud operation on a repository. It is defined in the package org.springframework.data.repository and It extends the Spring Data Repository interface. If someone wants to use CrudRepository in the spring boot application he/she has to create an interface and extend the CrudRepository interface. 
Illustration:
public interface DepartmentRepository extends CrudRepository<Department, Long> { }
Where:
Department: Domain type that repository manages (Generally the Entity/Model class name)
Long: Type of the id of the entity that repository manages (Generally the wrapper class of your @Id that is created inside the Entity/Model class)
Example:
Step 1: Refer to this article How to Create a Spring Boot Project with IntelliJ IDEA and create a Spring Boot project. 
Step 2: Add the following dependency
Spring Web
H2 Database
Lombok
Spring Data JPA
Below is the complete code for the pom.xml file. Please check if you have missed something.
XML
<?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.5.5</version>        <relativePath/> <!-- lookup parent from repository -->    </parent>    <groupId>com.amiya</groupId>    <artifactId>Spring-Boot-Demo-Project</artifactId>    <version>1.0.0-SNAPSHOT</version>    <name>Spring-Boot-Demo-Project</name>    <description>Demo project for Spring Boot</description>    <properties>        <java.version>11</java.version>    </properties>    <dependencies>        <dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-starter-web</artifactId>        </dependency>         <dependency>            <groupId>com.h2database</groupId>            <artifactId>h2</artifactId>            <scope>runtime</scope>        </dependency>         <dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-devtools</artifactId>            <scope>runtime</scope>            <optional>true</optional>        </dependency>         <dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-starter-data-jpa</artifactId>        </dependency>         <dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-starter-test</artifactId>            <scope>test</scope>        </dependency>         <dependency>            <groupId>org.projectlombok</groupId>            <artifactId>lombok</artifactId>            <optional>true</optional>        </dependency>     </dependencies>     <build>        <plugins>            <plugin>                <groupId>org.springframework.boot</groupId>                <artifactId>spring-boot-maven-plugin</artifactId>                <configuration>                    <excludes>                        <exclude>                            <groupId>org.projectlombok</groupId>                            <artifactId>lombok</artifactId>                        </exclude>                    </excludes>                </configuration>            </plugin>        </plugins>    </build> </project>
Step 3: Create 4 packages and later create some classes and interfaces inside these packages as seen in the below image:
entity
repository
service
controller
Note:
Green Rounded Icon ‘I’ Buttons are Interface
Blue Rounded Icon ‘C’ Buttons are Classes
Step 4: Inside the entity package
Create a simple POJO class inside the Department.java file. 
Example
Java
// Java Program to Illustrate Department.java File // Importing required package modulespackage com.amiya.springbootdemoproject.entity; // Importing required classesimport javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.persistence.Id;import lombok.AllArgsConstructor;import lombok.Builder;import lombok.Data;import lombok.NoArgsConstructor; @Entity@Data@NoArgsConstructor@AllArgsConstructor@Builder // Classpublic class Department {     @Id    @GeneratedValue(strategy = GenerationType.AUTO)    private Long departmentId;    private String departmentName;    private String departmentAddress;    private String departmentCode;}
Step 5: Inside the repository package
Create a simple interface and name the interface as DepartmentRepository. This interface is going to extend the CrudRepository as we have discussed above. Below is the code for the DepartmentRepository.java file
Example
Java
package com.amiya.springbootdemoproject.repository; import com.amiya.springbootdemoproject.entity.Department;import org.springframework.data.repository.CrudRepository;import org.springframework.stereotype.Repository; @Repositorypublic interface DepartmentRepository extends CrudRepository<Department, Long> {     }
Step 6: Inside the service package
Inside the package create one interface named as DepartmentService and one class named as DepartmentServiceImpl.
Example 1
Java
// Java Program to Illustrate DepartmentService.java File // Importing packagespackage com.amiya.springbootdemoproject.service;import com.amiya.springbootdemoproject.entity.Department;// Importing required classesimport java.util.List; // Classpublic interface DepartmentService {     // Save operation    Department saveDepartment(Department department);     // Read operation    List<Department> fetchDepartmentList();     // Update operation    Department updateDepartment(Department department,                                Long departmentId);     // Delete operation    void deleteDepartmentById(Long departmentId);}
Below is the code for the DepartmentServiceImpl.java file
Example 2
Java
// Java Program to Illustrate DepartmentServiceImpl.java// File // Importing required packagespackage com.amiya.springbootdemoproject.service; import com.amiya.springbootdemoproject.entity.Department;import com.amiya.springbootdemoproject.repository.DepartmentRepository;// Importing required classesimport java.util.List;import java.util.Objects;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service; // Annotation@Service// Class implementing DepartmentService classpublic class DepartmentServiceImpl    implements DepartmentService {     @Autowired    private DepartmentRepository departmentRepository;     // Save operation    @Override    public Department saveDepartment(Department department)    {        return departmentRepository.save(department);    }     // Read operation    @Override public List<Department> fetchDepartmentList()    {        return (List<Department>)            departmentRepository.findAll();    }     // Update operation    @Override    public Department    updateDepartment(Department department,                     Long departmentId)    {         Department depDB            = departmentRepository.findById(departmentId)                  .get();         if (Objects.nonNull(department.getDepartmentName())            && !"".equalsIgnoreCase(                department.getDepartmentName())) {            depDB.setDepartmentName(                department.getDepartmentName());        }         if (Objects.nonNull(                department.getDepartmentAddress())            && !"".equalsIgnoreCase(                department.getDepartmentAddress())) {            depDB.setDepartmentAddress(                department.getDepartmentAddress());        }         if (Objects.nonNull(department.getDepartmentCode())            && !"".equalsIgnoreCase(                department.getDepartmentCode())) {            depDB.setDepartmentCode(                department.getDepartmentCode());        }         return departmentRepository.save(depDB);    }     // Delete operation    @Override    public void deleteDepartmentById(Long departmentId)    {        departmentRepository.deleteById(departmentId);    }}
Step 7: Inside the controller package
Inside the package create one class named as DepartmentController
Java
// Java Program to Illustrate DepartmentController.java File // Importing packages modulespackage com.amiya.springbootdemoproject.controller; import com.amiya.springbootdemoproject.entity.Department;import com.amiya.springbootdemoproject.service.DepartmentService;import java.util.List;// Importing required classesimport javax.validation.Valid;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.*; // Annotation@RestController// Classpublic class DepartmentController {     @Autowired private DepartmentService departmentService;     // Save operation    @PostMapping("/departments")     public Department saveDepartment(        @Valid @RequestBody Department department)    {        return departmentService.saveDepartment(department);    }     // Read operation    @GetMapping("/departments")     public List<Department> fetchDepartmentList()    {        return departmentService.fetchDepartmentList();    }     // Update operation    @PutMapping("/departments/{id}")     public Department    updateDepartment(@RequestBody Department department,                     @PathVariable("id") Long departmentId)    {        return departmentService.updateDepartment(            department, departmentId);    }     // Delete operation    @DeleteMapping("/departments/{id}")     public String deleteDepartmentById(@PathVariable("id")                                       Long departmentId)    {        departmentService.deleteDepartmentById(            departmentId);        return "Deleted Successfully";    }}
Step 8: Below is the code for the application.properties file
server.port = 8082

# H2 Database
spring.h2.console.enabled=true
spring.datasource.url=jdbc:h2:mem:dcbapp
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
Now run your application and let’s test the endpoints in Postman and also refer to our H2 Database.
Endpoint 1: POST – http://localhost:8082/departments/
Endpoint 2: GET – http://localhost:8082/departments/
Endpoint 3: PUT – http://localhost:8082/departments/1
Endpoint 4: DELETE – http://localhost:8082/departments/1
Lastly, H2 Database is as depicted in the below media as follows:
surindertarika1234
Java-Spring-Boot
Picked
Java
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Interfaces in Java
ArrayList in Java
Stream In Java
Collections in Java
Multidimensional Arrays in Java
Singleton Class in Java
Stack Class in Java
Initializing a List in Java
Introduction to Java
Constructors in Java