Spring Boot – CRUD Operations using MySQL Database

24 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 MySQL Database. So here is a brief explanation of What’s Spring Boot and What’s MySQL 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.
MySQL Database
MySQL is an RDBMS (Relational Database Management System) based on the SQL (Structured Query Language), which is the popular language for accessing and managing the records in the database. MySQL is open-source and free software under the GNU license. It is supported by Oracle Company. The data in a MySQL database are stored in tables. A table is a collection of related data, and it consists of columns and rows. Some of the features of MySQL are listed below:
It is a database system used on the webIt runs on a serverIt is ideal for both small and large applicationsIt is very fast, reliable, and easy to useIt uses standard SQLIt is free to download and use
It is a database system used on the web
It runs on a server
It is ideal for both small and large applications
It is very fast, reliable, and easy to use
It uses standard SQL
It is free to download and use
So to connect and perform CRUD operation with the MySQL DB with Spring Boot application we have to just configure it inside the application.properties file as follows:
# Configuration for MySQL Database

spring.jpa.hibernate.ddl-auto=update

spring.datasource.url = jdbc:mysql://localhost:3306/schooldb 
(Datasource URL of your DB and "schooldb", here is your schema name)

spring.datasource.username=amiya559 (Your MySQL Workbench user name)
spring.datasource.password=password.123 (Your MySQL Workbench password)
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.show-sql:true
JpaRepository is a JPA (Java Persistence API) specific extension of Repository. It contains the full API of CrudRepository and PagingAndSortingRepository. So it contains API for basic CRUD operations and also API for pagination and sorting.
Syntax:
public interface JpaRepository<T,ID> extends PagingAndSortingRepository<T,ID>, QueryByExampleExecutor<T> 
Where
T: Domain type that repository manages (Generally the Entity/Model class name)
ID: 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)
Illustration:
public interface DepartmentRepository extends JpaRepository<Department, Long> {}
Example: We will be having a Spring Boot application that manages a Department entity with JpaRepository. The data is saved in the MySQL database. We use a RESTful controller.
Step 1: Create a Spring Boot project with say it be IntelliJ
Step 2: Add the following dependency as listed below as follows:
Spring Web
MySQL Database
Lombok
Spring Data JPA
Below is the complete code for the pom.xml file.
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 for MySQL Database -->        <dependency>            <groupId>mysql</groupId>            <artifactId>mysql-connector-java</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 as listed and create some classes and interfaces inside these packages as seen in the below image as shown:
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
It is done via creating a simple POJO class inside the Department.java file. 
Java
//  Java Program to Illustrate Department File // Importing package module to code fragmentpackage com.amiya.springbootdemoproject.entity; // Importing required classesimport lombok.AllArgsConstructor;import lombok.Builder;import lombok.Data;import lombok.NoArgsConstructor; import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.persistence.Id; // Annotations@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 JpaRepository as we have discussed above.  
Example 
Java
// Java Program to Illustrate DepartmentRepository File // Importing package module to this codepackage com.amiya.springbootdemoproject.repository;// Importing required classesimport com.amiya.springbootdemoproject.entity.Department;import org.springframework.data.jpa.repository.JpaRepository;import org.springframework.stereotype.Repository; // Annotation@Repository // Interfacepublic interface DepartmentRepository    extends JpaRepository<Department, Long> {}
 Step 6: Inside the service package
Example 1-A Inside the package create one interface named as DepartmentService and one class named as DepartmentServiceImpl.  
Java
// Java Program to Illustrate DepartmentService File // Importing package to this code fragmentpackage com.amiya.springbootdemoproject.service;import com.amiya.springbootdemoproject.entity.Department;// Importing required classesimport java.util.List; // Interfacepublic 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);}
 Example 1-B  
Java
// Java Program to Illustrate DepartmentServiceImpl File // Importing package module to this codepackage 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 // 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 File // Importing package module to this codepackage com.amiya.springbootdemoproject.controller; import com.amiya.springbootdemoproject.entity.Department;import com.amiya.springbootdemoproject.service.DepartmentService;import java.util.List;import javax.validation.Valid;// Importing required classesimport org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.*; // Annotation@RestController // Classpublic class DepartmentController {     // Annotation    @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

# Configuration for MySQL Database
spring.jpa.hibernate.ddl-auto=update
spring.datasource.url=jdbc:mysql://localhost:3306/schooldb
spring.datasource.username=amiya559
spring.datasource.password=password.123
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.show-sql:true
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 
MySQL Workbench will appear as shown below: 
 
arorakashish0911
Java-Spring-Boot
mysql
Java
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
List Interface in Java with Examples
Different ways of Reading a text file in Java
Constructors in Java
Strings in Java
HashMap containsKey() Method in Java
How to Create Array of Objects in Java?
Hashtable in Java
Compare two Strings in Java
HashSet in Java
How to remove an element from ArrayList in Java?