Spring Boot - CRUD Operations
Last Updated : 08 Nov, 2023
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 or there is a term for this called HTTP action verbs. HTTP has a few action verbs or methods that work as CRUD operations and do note they are vital from a developmental point perspective in programming that also helps us relate better web development and also aids us while dealing with databases. In this article, we will be discussing the CRUD operations in Spring Boot, before that let us understand what are standard CRUD Operations:
- 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
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 Database
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
Spring Boot CrudRepository
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)
Spring Boot JpaRepository
JPA stands for Java Persistence API. It is a specific extension of repository. JpaRepository defined in the package org.springframework.data.jpa.repository. It provides Jpa related methods such as flushing the persistence context and deleting records in a batch. JpaRepository contains APIs for basic CRUD operations, pagination and sorting. By using JpaRepository, we do not need to write DDL/DML queries instead we can use XML/annotations.
Syntax:
public interface JpaRepository<T, ID>
extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T>
Spring Data Repository Interface
Difference between CRUD Repository and Jpa Repository
|
CRUD Repository extends Repository interface | JpaRepository extends PagingAndSortingRepository. |
It performs all CRUD operations. It has methods such as save(), saveAll(), findById(), findAll() etc. | It contains API of CrudRepository and PagingandSortingRepository. It has methods such as flush(), saveAllAndFlush(), deleteInBatch() etc. |
CrudRepository works as a base interface. | JpaRepository extends both CrudRepository and PagingAndSortingRepository. |
Syntax: public interface CrudRepository<T, ID> extends Repository<T, ID> | Syntax: public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> |
Example of Spring Boot - CRUD Operations
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 modules package com.amiya.springbootdemoproject.entity; // Importing required classes import 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 // Class public 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; @Repository public 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 packages package com.amiya.springbootdemoproject.service; import com.amiya.springbootdemoproject.entity.Department; // Importing required classes import java.util.List; // Class public 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 packages package com.amiya.springbootdemoproject.service; import com.amiya.springbootdemoproject.entity.Department; import com.amiya.springbootdemoproject.repository.DepartmentRepository; // Importing required classes import java.util.List; import java.util.Objects; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; // Annotation @Service // Class implementing DepartmentService class public 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 modules package com.amiya.springbootdemoproject.controller; import com.amiya.springbootdemoproject.entity.Department; import com.amiya.springbootdemoproject.service.DepartmentService; import java.util.List; // Importing required classes import javax.validation.Valid; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.*; // Annotation @RestController // Class public 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.
Testing the Endpoint in Postman
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:
Similar Reads
Spring Boot JpaRepository with Example 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 of its rapid production-ready environment which enables the developers to directly focus on the logic instead of struggling with the configuration and se
9 min read
Spring Boot - CRUD Operations using MongoDB 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 develo
5 min read
Spring Boot - Spring Data JPA Spring Data JPA or JPA stands for Java Persistence API, so before looking into that, we must know about ORM (Object Relation Mapping). So Object relation mapping is simply the process of persisting any java object directly into a database table. Usually, the name of the object being persisted become
6 min read
Upload Multiple Files in Spring Boot using JPA, Thymeleaf, Multipart 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 of its rapid production-ready environment which enables the developers to directly focus on the logic instead of struggling with the configuration and se
8 min read
Spring Boot - Difference Between CrudRepository and JpaRepository 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 of its rapid production-ready environment which enables the developers to directly focus on the logic instead of struggling with the configuration and se
3 min read
Spring Boot - CrudRepository with Example 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 of its rapid production-ready environment which enables the developers to directly focus on the logic instead of struggling with the configuration and se
6 min read
Spring Boot - application.yml/application.yaml File Spring is widely used for creating scalable applications. For web applications Spring provides. In Spring Boot, whenever we create a new Spring Boot Application in spring starter, or inside an IDE (Eclipse or STS) a file is located inside the src/main/resources folder named as application.properties
4 min read
Spring Boot - CRUD Operations using MySQL Database 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 develop
7 min read
How to Implement One to Many Mapping in Spring Boot? Spring Boot is built on the top of the spring and contains all the features of spring. Spring also provides JPA and hibernate to increase the data manipulation efficiency between the spring application and the database. In very simple terms we can say JPA (Java persistence API) is like an interface
3 min read
How to Run Your First Spring Boot Application in Eclipse IDE? 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 of its rapid production-ready environment which enables the developers to directly focus on the logic instead of struggling with the configuration and se
3 min read