Spring Data JPA

➢ Spring Data is an umbrella project that contains multiple sub-projects for data access,
supporting multiple types of databases (both relational, NoSQL databases like
MongoDB). This reduces the amount of boilerplate code developers need to write.
➢ Spring Data JPA is a module within the Spring Data project specifically designed to
simplify JPA (Java Persistence API) access.
➢ JPA is a specification for data access in Java applications, specifically designed for
object-relational mapping (ORM).
➢ Hibernate (ORM tool) is a popular implementation of the JPA specification.
➢ JPA Repository simplifies and replaces the need for a custom DAO pattern.still DAO
can be used
Example of JPA Providers (Implementations):
✓ Hibernate
✓ EclipseLink
✓ OpenJPA
 Spring Data JPA

Spring Data JPA is a part of the Spring Framework

it simplifies database operations by providing easy-to-use methods for CRUD, custom

queries, and transaction management using JPA (Java Persistence API).

✓ Hibernate is an ORM tool Object-Relational Mapping.It is a framework

✓ Java Persistence API (JPA) is a specification
✓ Hibernate is one of the implementations of that specification.
✓ Spring Data JPA works with Hibernate as its default JPA implementation.
✓ Purpose: Simplifies database access using JPA with less boilerplate code through
repositories and derived query methods.

Advantages

1. Simplified Data Access:

✓ Repository Support: you can easily create repositories without writing
complex DAO code. It generates queries automatically based on method
names (e.g., findByName()).
✓ No Boilerplate Code: You don’t need to write implementation for standard
CRUD operations. (The JpaRepository interface provides built-in methods like
save(), findAll(), findById(), and deleteById())
2. Custom Queries: Allows custom queries using the @Query annotation.
3. Automatic Pagination & Sorting: Built-in support for pagination and sorting.
4. Declarative Transactions: Simplifies transaction management using @Transactional.

Note: Additional information

Optimized Performance
• Caching: It integrates well with caching solutions like Hibernate’s second-level
cache to improve performance.
• Lazy Loading and Eager Loading: You can control how related entities are
loaded (lazily or eagerly), optimizing performance based on your requirements.
Steps to Create a Spring Data JPA Application

1. Create a Maven project using Spring Initializr by adding the dependencies

1. Spring Web
2. Spring Data JPA
3. MySQL Driver
4. Lombok (Optional)

2. Create Directory Structure:

1. controller
2. service
3. repository
4. entity

3. Set Up the Database

1. Create the database(e.g. testdb)

2. Configure database connection settings in application.properties
4. Create an Entity Class

o Define a class annotated with @Entity use @Id and @GeneratedValue to define the
primary key.

5. Create a Repository Interface

o Extend the JpaRepository interface for the entity to enable built-in CRUD
operations.

6. Create a Service Layer (Optional but Recommended)

o Define a service interface and a ServiceImpl class which Implement the service
interface for business logic

7. Create a Controller

o Create a REST controller to define endpoints for CRUD operations. Use annotations
like @GetMapping, @PostMapping, @PutMapping, and @DeleteMapping.

8. Run and Test the Application

Start the application and test it with use tools like Postman, cURL, or a browser to
test the API endpoints.
// Application Entry Point
package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

public static void main(String[] args) {

SpringApplication.run(DemoApplication.class, args);
}
}

application.properties

spring.datasource.url=jdbc:mysql://localhost:3306/testdb
spring.datasource.username=root
spring.datasource.password=root

spring.jpa.hibernate.ddl-auto=update

Employee Entity

package com.example.entity;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Employee {

@Id
// @GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
// Constructors getters and setters

public Employee() {
}

// Getters and Setters

public Long getId() {
return id;
}

public void setId(Long id) {

 this.id = id;
}

public String getName() {

return name;
}

public void setName(String name) {

this.name = name;
}
}
Note: If you're using @GeneratedValue(strategy = GenerationType.IDENTITY), you don't need to
pass the id value when creating the employee object in the request. The database will handle it.

//Employee Repository

package com.example.repository;

import com.example.demo.entity.Employee;
import org.springframework.data.jpa.repository.JpaRepository;

@Repository //Not needed

public interface EmployeeRepository extends JpaRepository<Employee, Long> {
}

Employee Controller without Service directly using repo

package com.example.controller;

import com.example.demo.entity.Employee;
import com.example.demo.repository.EmployeeRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping(“/api”)
public class EmployeeController {

@Autowired
private EmployeeRepository repository;

// Get all employees

@GetMapping("/employees")
public List<Employee> getAllEmployees()
{
return repository.findAll();
}

// Create a new employee

@PostMapping("/employees")
public Employee createEmployee(@RequestBody Employee employee)
{
return repository.save(employee);
}

// Get employee by ID
@GetMapping("/employees/{id}")
public Employee getEmployeeById(@PathVariable Long id)
{
return repository.findById(id).orElseThrow(() -> new RuntimeException("Employee not
found"));
}

// Update an existing employee

@PutMapping("/employees/{id}")
public Employee updateEmployee(@PathVariable Long id, @RequestBody Employee upatedEmp)
{
Employee existingEmp = repository.findById(id).get(); // Assumes the record exists
existingEmp.setName(updatedEmp.getName());
return repository.save(existingEmp);
}

// Delete an existing employee

@DeleteMapping("/employees/{id}")
public String deleteEmployee(@PathVariable Long id) {
repository.deleteById(id);
return "Employee deleted successfully";
}
}

Api endpoints
Operation HTTP Method Complete URL Request Body
Get all employees GET /api/employees None
Create a new employee POST /api/employees { "name": "Tom" }
Get employee by ID GET /api/employees/{id} None
Update an existing employee PUT /api/employees/{id} { "name": "Tom Updated" }
Delete an employee DELETE /api/employees/{id} None
If you want to user Service and ServiceImpl

Employee Service Interface

package com.example.service;
import com.example.entity.Employee;
import java.util.List;

public interface EmployeeService {

List<Employee> getAllEmployees();

Employee getEmployeeById(Long id);

Employee createEmployee(Employee employee);
Employee updateEmployee(Long id, Employee updatedEmp);

void deleteEmployee(Long id);

}

// Employee Service Implementation

package com.example.service;

import com.example.entity.Employee;
import com.example.repository.EmployeeRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class EmployeeServiceImpl implements EmployeeService {

@Autowired
private EmployeeRepository repository;

@Override
public List<Employee> getAllEmployees()
{
return repository.findAll();
}

@Override
public Employee getEmployeeById(Long id)
{
return repository.findById(id).orElseThrow(() -> new RuntimeException("Employee not
found"));
// return repository.findById(id).orElse(null);
}
 @Override
public Employee createEmployee(Employee employee)
{
return repository.save(employee);
}

public Employee updateEmployee(Long id, Employee updatedEmp)

{
Optional<Employee> optionalEmp = repository.findById(id);
if (optionalEmp.isEmpty())
{
return null; // Or handle "not found" case differently
}
Employee existingEmp = optionalEmp.get();
existingEmp.setName(updatedEmp.getName());
return repository.save(existingEmp);
}
}
@Override
public void deleteEmployee(Long id) {
repository.deleteById(id);
}
}

Note: the updateEmployee() can be written like this as well using map() as well
@Override
public Employee updateEmployee(Long id, Employee updatedEmp) {
return repository.findById(id).map(employee -> {
employee.setName(updatedEmp.getName());
return repository.save(employee);
}).orElseThrow(() -> new RuntimeException("Employee not found"));
}
// Employee Controller using Service

package com.example.controller;

import com.example.entity.Employee;
import com.example.service.EmployeeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping(“/api”)
public class EmployeeController {

// You need to modify the controller injecting the employeeService instead of repository
@Autowired
private EmployeeService employeeService;

@GetMapping("/employees")
public List<Employee> getAllEmployees() {
return employeeService.getAllEmployees();
}

@PostMapping("/employees")
public Employee createEmployee(@RequestBody Employee employee) {
return employeeService.createEmployee(employee);
}

// Get employee by ID
@GetMapping("/employees/{id}")
public Employee getEmployeeById(@PathVariable Long id) {
return employeeService.getEmployeeById(id);
}

@PutMapping("/employees/{id}")
public Employee updateEmployee(@PathVariable Long id, @RequestBody Employee
updatedEmployee) {
return employeeService.updateEmployee(id, updatedEmployee);
}

@DeleteMapping("/employees/{id}")
public String deleteEmployee(@PathVariable Long id) {
employeeService.deleteEmployee(id);
return "Employee deleted successfully";
}
}
Controller Using ResponseEntity with
package com.example.demo.controller;
import com.example.demo.entity.Employee;
import com.example.demo.service.EmployeeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping(“/api”)
public class EmployeeController {

@Autowired
private EmployeeService employeeService;

// Get all employees

@GetMapping("/employees")
public ResponseEntity<List<Employee>> getAllEmployees() {
List<Employee> employees = employeeService.getAllEmployees();
return ResponseEntity.ok(employees); // HTTP 200 OK which is default
}

// Get an employee by ID
@GetMapping("/employees/{id}")
public ResponseEntity<Employee> getEmployeeById(@PathVariable Long id) {
Employee employee = employeeService.getEmployeeById(id);
return ResponseEntity.ok(employee);
}

// Create a new employee

@PostMapping("/employees")
public ResponseEntity<Employee> createEmployee(@RequestBody Employee employee) {
Employee createdEmployee = employeeService.createEmployee(employee);
return ResponseEntity.status(201).body(createdEmployee); // HTTP 201 Created
//return ResponseEntity.status(HttpStatus.CREATED).body(createdEmployee); // HTTP 201 Created

// Update an existing employee

@PutMapping("/employees /{id}")
public ResponseEntity<Employee> updateEmployee(@PathVariable Long id, @RequestBody
Employee updatedEmployee) {
Employee employee = employeeService.updateEmployee(id, updatedEmployee);
return ResponseEntity.ok(employee);
}

// Delete an employee
@DeleteMapping("/employees/{id}")
public ResponseEntity<String> deleteEmployee(@PathVariable Long id) {
employeeService.deleteEmployee(id);
return ResponseEntity.ok("Employee deleted successfully.");
//return ResponseEntity.noContent().build();
}
}

Ideal API Design Based on the Code

HTTP
Operation Complete URL Request Body Response Code
Method

Get all
GET http://localhost:8080/api/employees None 200 OK
employees

Create a new { "name":

POST http://localhost:8080/api/employees 201 Created
employee "Tom" }

Get
200 OK (if found), 404
employee by GET http://localhost:8080/api/employees/{id} None
Not Found (if not found)
ID

Update { "name":
200 OK (if found), 404
employee by PUT http://localhost:8080/api/employees/{id} "Tom
Not Found (if not found)
ID Updated" }

204 No Content (if

Delete
successfully deleted),
employee by DELETE http://localhost:8080/api/employees/{id} None
404 Not Found (if not
ID
found)

Some method of Repository

Method Description Example
save(S entity) Saves or updates an entity. employeeRepository.save(employee);
findById(ID id) Retrieves an entity by its ID. employeeRepository.findById(1L);
findAll() Retrieves all entities from the database. employeeRepository.findAll();
deleteById(ID id) Deletes an entity by its ID. employeeRepository.deleteById(1L);
count() Returns the total number of entities. employeeRepository.count();
existsById(ID id) Checks if an entity with the given ID exists. employeeRepository.existsById(1L);
Additional information:
Note: There are different ways to write updateEmployee() method

1) Using null checking

public Employee updateEmployee(@PathVariable Long id, @RequestBody Employee updatedEmp) {

Employee existingEmp = repository.findById(id).orElse(null); // Use orElse(null) to avoid exception
if (existingEmp != null) {
existingEmp.setName(updatedEmp.getName());
return repository.save(existingEmp);
}
return null; // Return null if not found
}

2) Using map()
@PutMapping("/{id}")
public Employee updateEmployee(@PathVariable Long id, @RequestBody Employee
updatedEmp) {
return repository.findById(id).map(employee -> {
employee.setName(updatedEmp.getName());
return repository.save(employee);
}).orElseThrow(() -> new RuntimeException("Employee not found"));
}

3)Using optional
public Optional<Employee> updateEmployee(@PathVariable Long id, @RequestBody Employee
updatedEmp) {
Optional<Employee> optionalEmpl = repository.findById(id);
if (optionalEmp.isPresent()) {
Employee employee = optionalEmp.get();
employee.setName(updatedEmp.getName());
return Optional.of(repository.save(employee));
}
return Optional.empty();
}