Spring Boot - CrudRepository with Example - GeeksforGeeks

22 Dec, 2021
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 setup. Spring Boot is a microservice-based framework and making a production-ready application in it takes very little time. Following are some of the features of Spring Boot:
It allows avoiding heavy configuration of XML which is present in spring
It provides easy maintenance and creation of REST endpoints
It includes embedded Tomcat-server
Deployment is very easy, war and jar files can be easily deployed in the tomcat server
For more information please refer to this article: Introduction to Spring Boot. In this article, we are going to discuss how to use CrudRepository to manage data in a Spring Boot application.
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. 
Syntax: 
public interface CrudRepository<T, ID> extends Repository<T, ID>
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 CrudRepository<Department, Long> {}
Now let us discuss some of the most important methods that are available inside the CrudRepository are given below as follows:
Method 1: save(): Saves a given entity. Use the returned instance for further operations as the save operation might have changed the entity instance completely.
Syntax:
 <S extends T> S save(S entity)
Parameters: entity – must not be null.
Returns: the saved entity; will never be null.
Throws: IllegalArgumentException – in case the given entity is null.
Method 2: findById(): Retrieves an entity by its id.
Syntax:
Optional<T> findById(ID id)
Parameters: id – must not be null.
Returns: the entity with the given id or Optional#empty() if none found.
Exception Thrown: IllegalArgumentException is thrown if the ‘id’ is null.
Method 3: findAll(): Returns all instances of the type.
Syntax: 
Iterable<T> findAll()
Return Type: All entities
Method 4: count(): Returns the number of entities available.
Syntax:
long count()
Return Type: the number of entities.
Method 5: deleteById(): Deletes the entity with the given id.
Syntax:
void deleteById(ID id)
Parameters: Id (must not be null)
Exception Thrown: IllegalArgumentException in case the given id is null.
Example
The following Spring Boot application manages a Department entity with CrudRepository. The data is saved in the H2 database. We use a RESTful controller.
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 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. Below is the code for the Department.java file
Java
package com.amiya.springbootdemoproject.entity;  import 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;  @Entity@Data@NoArgsConstructor@AllArgsConstructor@Builderpublic 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. 
Java
// Java Program to Illustrate DepartmentRepository.java File  // Importing package module to this codepackage com.amiya.springbootdemoproject.repository;// Importing required classesimport com.amiya.springbootdemoproject.entity.Department;import org.springframework.data.repository.CrudRepository;import org.springframework.stereotype.Repository;  // Annotation@Repository  // Classpublic 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. Below is the code for the DepartmentService.java file.
Example 1-A
Java
package com.amiya.springbootdemoproject.service;  import com.amiya.springbootdemoproject.entity.Department;  import java.util.List;  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);}
Example 1-B 
Java
// Below is the code for the DepartmentServiceImpl.java file.package com.amiya.springbootdemoproject.service;  import com.amiya.springbootdemoproject.entity.Department;import com.amiya.springbootdemoproject.repository.DepartmentRepository;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;  import java.util.List;import java.util.Objects;  @Servicepublic 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 modulepackage com.amiya.springbootdemoproject.controller;// Importing required classesimport com.amiya.springbootdemoproject.entity.Department;import com.amiya.springbootdemoproject.service.DepartmentService;import java.util.List;import javax.validation.Valid;import 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

# 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
H2 Database is as depicted in below media
Java-Spring-Boot
Java
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Stream In Java
Exceptions in Java
Constructors in Java
Different ways of Reading a text file in Java
Functional Interfaces in Java
Generics in Java
Comparator Interface in Java with Examples
Introduction to Java
PriorityQueue in Java
How to remove an element from ArrayList in Java?