MACRO NEPAL
Spring Data JPA Fundamentals in Java
awiskar acharya
November 5, 2025
2:19 pm

Introduction to Spring Data JPA

Spring Data JPA is part of the larger Spring Data family that makes it easy to implement JPA-based repositories. It reduces the amount of boilerplate code required to implement data access layers for both relational and non-relational databases.

Key Benefits

  • Reduced Boilerplate: Automatic repository implementation
  • Built-in CRUD Operations: Common operations out of the box
  • Dynamic Query Generation: From method names
  • Pagination and Sorting: Built-in support
  • Integration with Spring Ecosystem: Seamless Spring integration

Project Setup

Maven Dependencies

<dependencies>
<!-- Spring Boot Starter Data JPA -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<!-- Database Driver (H2 for example) -->
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<!-- Alternatively, for PostgreSQL -->
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<scope>runtime</scope>
</dependency>
<!-- Spring Boot Starter Web (for REST controllers) -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Validation -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
</dependency>
</dependencies>

Application Configuration

# application.properties
# H2 Database Configuration
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
# JPA Configuration
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
# H2 Console (for development)
spring.h2.console.enabled=true
# For PostgreSQL
# spring.datasource.url=jdbc:postgresql://localhost:5432/mydatabase
# spring.datasource.username=postgres
# spring.datasource.password=password
# spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect
# spring.jpa.hibernate.ddl-auto=update

Entity Modeling

Basic Entity

package com.example.entity;
import javax.persistence.*;
import java.time.LocalDateTime;
import java.util.Objects;
@Entity
@Table(name = "users")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "username", unique = true, nullable = false, length = 50)
private String username;
@Column(name = "email", unique = true, nullable = false)
private String email;
@Column(name = "first_name", nullable = false, length = 50)
private String firstName;
@Column(name = "last_name", nullable = false, length = 50)
private String lastName;
@Column(name = "age")
private Integer age;
@Enumerated(EnumType.STRING)
@Column(name = "status")
private UserStatus status = UserStatus.ACTIVE;
@Column(name = "created_at")
private LocalDateTime createdAt;
@Column(name = "updated_at")
private LocalDateTime updatedAt;
// Default constructor (required by JPA)
public User() {}
// Constructor for required fields
public User(String username, String email, String firstName, String lastName) {
this.username = username;
this.email = email;
this.firstName = firstName;
this.lastName = lastName;
this.createdAt = LocalDateTime.now();
this.updatedAt = LocalDateTime.now();
}
// Pre-persist and pre-update callbacks
@PrePersist
protected void onCreate() {
createdAt = LocalDateTime.now();
updatedAt = LocalDateTime.now();
}
@PreUpdate
protected void onUpdate() {
updatedAt = LocalDateTime.now();
}
// Getters and Setters
public Long getId() { return id; }
public void setId(Long id) { this.id = id; }
public String getUsername() { return username; }
public void setUsername(String username) { this.username = username; }
public String getEmail() { return email; }
public void setEmail(String email) { this.email = email; }
public String getFirstName() { return firstName; }
public void setFirstName(String firstName) { this.firstName = firstName; }
public String getLastName() { return lastName; }
public void setLastName(String lastName) { this.lastName = lastName; }
public Integer getAge() { return age; }
public void setAge(Integer age) { this.age = age; }
public UserStatus getStatus() { return status; }
public void setStatus(UserStatus status) { this.status = status; }
public LocalDateTime getCreatedAt() { return createdAt; }
public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; }
public LocalDateTime getUpdatedAt() { return updatedAt; }
public void setUpdatedAt(LocalDateTime updatedAt) { this.updatedAt = updatedAt; }
// equals and hashCode
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof User)) return false;
User user = (User) o;
return Objects.equals(id, user.id) && 
Objects.equals(username, user.username);
}
@Override
public int hashCode() {
return Objects.hash(id, username);
}
// toString
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", email='" + email + '\'' +
", firstName='" + firstName + '\'' +
", lastName='" + lastName + '\'' +
", age=" + age +
", status=" + status +
'}';
}
}
enum UserStatus {
ACTIVE, INACTIVE, SUSPENDED
}

Entity Relationships

package com.example.entity;
import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;
@Entity
@Table(name = "departments")
public class Department {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "name", unique = true, nullable = false)
private String name;
@Column(name = "description")
private String description;
// One-to-Many relationship with Employee
@OneToMany(mappedBy = "department", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private List<Employee> employees = new ArrayList<>();
// Constructors
public Department() {}
public Department(String name, String description) {
this.name = name;
this.description = description;
}
// Helper methods for bidirectional relationship
public void addEmployee(Employee employee) {
employees.add(employee);
employee.setDepartment(this);
}
public void removeEmployee(Employee employee) {
employees.remove(employee);
employee.setDepartment(null);
}
// 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; }
public String getDescription() { return description; }
public void setDescription(String description) { this.description = description; }
public List<Employee> getEmployees() { return employees; }
public void setEmployees(List<Employee> employees) { this.employees = employees; }
}
@Entity
@Table(name = "employees")
public class Employee {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "employee_id", unique = true, nullable = false)
private String employeeId;
@Column(name = "first_name", nullable = false)
private String firstName;
@Column(name = "last_name", nullable = false)
private String lastName;
@Column(name = "email")
private String email;
@Column(name = "salary")
private Double salary;
// Many-to-One relationship with Department
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "department_id")
private Department department;
// Many-to-Many relationship with Project
@ManyToMany
@JoinTable(
name = "employee_project",
joinColumns = @JoinColumn(name = "employee_id"),
inverseJoinColumns = @JoinColumn(name = "project_id")
)
private List<Project> projects = new ArrayList<>();
// Constructors
public Employee() {}
public Employee(String employeeId, String firstName, String lastName, String email) {
this.employeeId = employeeId;
this.firstName = firstName;
this.lastName = lastName;
this.email = email;
}
// Getters and Setters
public Long getId() { return id; }
public void setId(Long id) { this.id = id; }
public String getEmployeeId() { return employeeId; }
public void setEmployeeId(String employeeId) { this.employeeId = employeeId; }
public String getFirstName() { return firstName; }
public void setFirstName(String firstName) { this.firstName = firstName; }
public String getLastName() { return lastName; }
public void setLastName(String lastName) { this.lastName = lastName; }
public String getEmail() { return email; }
public void setEmail(String email) { this.email = email; }
public Double getSalary() { return salary; }
public void setSalary(Double salary) { this.salary = salary; }
public Department getDepartment() { return department; }
public void setDepartment(Department department) { this.department = department; }
public List<Project> getProjects() { return projects; }
public void setProjects(List<Project> projects) { this.projects = projects; }
}
@Entity
@Table(name = "projects")
public class Project {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "name", nullable = false)
private String name;
@Column(name = "description")
private String description;
@Column(name = "budget")
private Double budget;
// Many-to-Many relationship with Employee (inverse side)
@ManyToMany(mappedBy = "projects")
private List<Employee> employees = new ArrayList<>();
// Constructors, Getters and Setters
public Project() {}
public Project(String name, String description, Double budget) {
this.name = name;
this.description = description;
this.budget = budget;
}
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; }
public String getDescription() { return description; }
public void setDescription(String description) { this.description = description; }
public Double getBudget() { return budget; }
public void setBudget(Double budget) { this.budget = budget; }
public List<Employee> getEmployees() { return employees; }
public void setEmployees(List<Employee> employees) { this.employees = employees; }
}

Repository Interfaces

Basic Repository Interface

package com.example.repository;
import com.example.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
// Basic CRUD operations are inherited
}

Custom Repository with Query Methods

package com.example.repository;
import com.example.entity.User;
import com.example.entity.UserStatus;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
// Derived Query Methods (automatically implemented by Spring Data JPA)
// Find by exact match
Optional<User> findByUsername(String username);
Optional<User> findByEmail(String email);
// Find by multiple conditions
List<User> findByFirstNameAndLastName(String firstName, String lastName);
List<User> findByFirstNameOrLastName(String firstName, String lastName);
// Find with comparison operators
List<User> findByAgeGreaterThan(int age);
List<User> findByAgeLessThanEqual(int age);
List<User> findByAgeBetween(int startAge, int endAge);
// Find with null checks
List<User> findByLastNameIsNull();
List<User> findByLastNameIsNotNull();
// Find with like/contains
List<User> findByFirstNameContaining(String firstName);
List<User> findByFirstNameLike(String pattern);
List<User> findByFirstNameStartingWith(String prefix);
List<User> findByFirstNameEndingWith(String suffix);
// Find with ordering
List<User> findByStatusOrderByFirstNameAsc(UserStatus status);
List<User> findByStatusOrderByCreatedAtDesc(UserStatus status);
// Find with limit
List<User> findTop5ByOrderByCreatedAtDesc();
List<User> findFirst10ByStatus(UserStatus status);
// Count operations
long countByStatus(UserStatus status);
boolean existsByUsername(String username);
boolean existsByEmail(String email);
// Delete operations
void deleteByStatus(UserStatus status);
long deleteByLastName(String lastName);
// Custom JPQL Queries
@Query("SELECT u FROM User u WHERE u.email LIKE '%@gmail.com'")
List<User> findGmailUsers();
@Query("SELECT u FROM User u WHERE u.firstName = :firstName AND u.age > :age")
List<User> findUsersByFirstNameAndMinAge(@Param("firstName") String firstName, 
@Param("age") int minAge);
@Query("SELECT u.firstName, u.lastName FROM User u WHERE u.status = :status")
List<Object[]> findUserNamesByStatus(@Param("status") UserStatus status);
// Native SQL Query
@Query(value = "SELECT * FROM users u WHERE u.created_at > :date", nativeQuery = true)
List<User> findUsersCreatedAfter(@Param("date") LocalDateTime date);
// Update query
@Modifying
@Query("UPDATE User u SET u.status = :status WHERE u.lastLogin < :date")
int deactivateInactiveUsers(@Param("status") UserStatus status, 
@Param("date") LocalDateTime date);
// Complex query with aggregation
@Query("SELECT u.status, COUNT(u) FROM User u GROUP BY u.status")
List<Object[]> countUsersByStatus();
}

Employee Repository with Relationships

package com.example.repository;
import com.example.entity.Department;
import com.example.entity.Employee;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional;
@Repository
public interface EmployeeRepository extends JpaRepository<Employee, Long> {
// Basic queries
Optional<Employee> findByEmployeeId(String employeeId);
List<Employee> findByFirstNameContainingIgnoreCase(String firstName);
List<Employee> findByLastNameContainingIgnoreCase(String lastName);
// Relationship queries
List<Employee> findByDepartment(Department department);
List<Employee> findByDepartmentName(String departmentName);
// Salary-based queries
List<Employee> findBySalaryGreaterThan(Double salary);
List<Employee> findBySalaryBetween(Double minSalary, Double maxSalary);
// Complex queries with joins
@Query("SELECT e FROM Employee e JOIN e.department d WHERE d.name = :deptName AND e.salary > :minSalary")
List<Employee> findEmployeesInDepartmentWithMinSalary(@Param("deptName") String departmentName, 
@Param("minSalary") Double minSalary);
// Project count for employees
@Query("SELECT e, SIZE(e.projects) FROM Employee e")
List<Object[]> findEmployeesWithProjectCount();
// Employees working on specific project
@Query("SELECT e FROM Employee e JOIN e.projects p WHERE p.name = :projectName")
List<Employee> findEmployeesByProjectName(@Param("projectName") String projectName);
// Average salary by department
@Query("SELECT d.name, AVG(e.salary) FROM Employee e JOIN e.department d GROUP BY d.name")
List<Object[]> findAverageSalaryByDepartment();
}

Service Layer

User Service

package com.example.service;
import com.example.entity.User;
import com.example.entity.UserStatus;
import com.example.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;
@Service
@Transactional
public class UserService {
@Autowired
private UserRepository userRepository;
// Basic CRUD operations
public User createUser(User user) {
return userRepository.save(user);
}
public Optional<User> getUserById(Long id) {
return userRepository.findById(id);
}
public List<User> getAllUsers() {
return userRepository.findAll();
}
public User updateUser(User user) {
if (!userRepository.existsById(user.getId())) {
throw new RuntimeException("User not found with id: " + user.getId());
}
return userRepository.save(user);
}
public void deleteUser(Long id) {
userRepository.deleteById(id);
}
// Custom business logic methods
public Optional<User> getUserByUsername(String username) {
return userRepository.findByUsername(username);
}
public Optional<User> getUserByEmail(String email) {
return userRepository.findByEmail(email);
}
public List<User> getUsersByStatus(UserStatus status) {
return userRepository.findByStatus(status);
}
public List<User> searchUsersByName(String name) {
return userRepository.findByFirstNameContainingOrLastNameContaining(name, name);
}
public List<User> getUsersByAgeRange(int minAge, int maxAge) {
return userRepository.findByAgeBetween(minAge, maxAge);
}
public long countActiveUsers() {
return userRepository.countByStatus(UserStatus.ACTIVE);
}
public boolean usernameExists(String username) {
return userRepository.existsByUsername(username);
}
public boolean emailExists(String email) {
return userRepository.existsByEmail(email);
}
// Pagination and sorting
public Page<User> getUsers(Pageable pageable) {
return userRepository.findAll(pageable);
}
public Page<User> getActiveUsers(Pageable pageable) {
return userRepository.findByStatus(UserStatus.ACTIVE, pageable);
}
// Bulk operations
@Transactional
public void deactivateInactiveUsers(LocalDateTime cutoffDate) {
userRepository.deactivateInactiveUsers(UserStatus.INACTIVE, cutoffDate);
}
// Complex business logic
@Transactional
public User registerUser(User user) {
if (usernameExists(user.getUsername())) {
throw new RuntimeException("Username already exists: " + user.getUsername());
}
if (emailExists(user.getEmail())) {
throw new RuntimeException("Email already exists: " + user.getEmail());
}
user.setStatus(UserStatus.ACTIVE);
return userRepository.save(user);
}
@Transactional
public void deactivateUser(Long userId) {
User user = userRepository.findById(userId)
.orElseThrow(() -> new RuntimeException("User not found with id: " + userId));
user.setStatus(UserStatus.INACTIVE);
userRepository.save(user);
}
}

Department Service with Relationships

package com.example.service;
import com.example.entity.Department;
import com.example.entity.Employee;
import com.example.repository.DepartmentRepository;
import com.example.repository.EmployeeRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
import java.util.Optional;
@Service
@Transactional
public class DepartmentService {
@Autowired
private DepartmentRepository departmentRepository;
@Autowired
private EmployeeRepository employeeRepository;
public Department createDepartment(Department department) {
return departmentRepository.save(department);
}
public Optional<Department> getDepartmentById(Long id) {
return departmentRepository.findById(id);
}
public List<Department> getAllDepartments() {
return departmentRepository.findAll();
}
public Department updateDepartment(Department department) {
if (!departmentRepository.existsById(department.getId())) {
throw new RuntimeException("Department not found with id: " + department.getId());
}
return departmentRepository.save(department);
}
public void deleteDepartment(Long id) {
departmentRepository.deleteById(id);
}
// Relationship management
@Transactional
public void addEmployeeToDepartment(Long departmentId, Employee employee) {
Department department = departmentRepository.findById(departmentId)
.orElseThrow(() -> new RuntimeException("Department not found"));
department.addEmployee(employee);
departmentRepository.save(department);
}
@Transactional
public void removeEmployeeFromDepartment(Long departmentId, Long employeeId) {
Department department = departmentRepository.findById(departmentId)
.orElseThrow(() -> new RuntimeException("Department not found"));
Employee employee = employeeRepository.findById(employeeId)
.orElseThrow(() -> new RuntimeException("Employee not found"));
department.removeEmployee(employee);
departmentRepository.save(department);
}
public List<Employee> getEmployeesInDepartment(Long departmentId) {
Department department = departmentRepository.findById(departmentId)
.orElseThrow(() -> new RuntimeException("Department not found"));
return department.getEmployees();
}
// Business logic
public Optional<Department> getDepartmentByName(String name) {
return departmentRepository.findByName(name);
}
public List<Object[]> getDepartmentStatistics() {
return departmentRepository.getDepartmentStatistics();
}
}

REST Controllers

User Controller

package com.example.controller;
import com.example.entity.User;
import com.example.entity.UserStatus;
import com.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.List;
import java.util.Optional;
@RestController
@RequestMapping("/api/users")
public class UserController {
@Autowired
private UserService userService;
@GetMapping
public ResponseEntity<List<User>> getAllUsers() {
List<User> users = userService.getAllUsers();
return ResponseEntity.ok(users);
}
@GetMapping("/paged")
public ResponseEntity<Page<User>> getUsersPaged(
@RequestParam(defaultValue = "0") int page,
@RequestParam(defaultValue = "10") int size,
@RequestParam(defaultValue = "id") String sortBy,
@RequestParam(defaultValue = "asc") String sortDirection) {
Sort sort = sortDirection.equalsIgnoreCase("desc") 
? Sort.by(sortBy).descending() 
: Sort.by(sortBy).ascending();
Pageable pageable = PageRequest.of(page, size, sort);
Page<User> users = userService.getUsers(pageable);
return ResponseEntity.ok(users);
}
@GetMapping("/{id}")
public ResponseEntity<User> getUserById(@PathVariable Long id) {
Optional<User> user = userService.getUserById(id);
return user.map(ResponseEntity::ok)
.orElse(ResponseEntity.notFound().build());
}
@GetMapping("/username/{username}")
public ResponseEntity<User> getUserByUsername(@PathVariable String username) {
Optional<User> user = userService.getUserByUsername(username);
return user.map(ResponseEntity::ok)
.orElse(ResponseEntity.notFound().build());
}
@GetMapping("/status/{status}")
public ResponseEntity<List<User>> getUsersByStatus(@PathVariable UserStatus status) {
List<User> users = userService.getUsersByStatus(status);
return ResponseEntity.ok(users);
}
@PostMapping
public ResponseEntity<User> createUser(@Valid @RequestBody User user) {
try {
User createdUser = userService.registerUser(user);
return ResponseEntity.status(HttpStatus.CREATED).body(createdUser);
} catch (RuntimeException e) {
return ResponseEntity.badRequest().build();
}
}
@PutMapping("/{id}")
public ResponseEntity<User> updateUser(@PathVariable Long id, @Valid @RequestBody User user) {
user.setId(id);
try {
User updatedUser = userService.updateUser(user);
return ResponseEntity.ok(updatedUser);
} catch (RuntimeException e) {
return ResponseEntity.notFound().build();
}
}
@DeleteMapping("/{id}")
public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
if (userService.getUserById(id).isPresent()) {
userService.deleteUser(id);
return ResponseEntity.noContent().build();
}
return ResponseEntity.notFound().build();
}
@PatchMapping("/{id}/deactivate")
public ResponseEntity<Void> deactivateUser(@PathVariable Long id) {
try {
userService.deactivateUser(id);
return ResponseEntity.ok().build();
} catch (RuntimeException e) {
return ResponseEntity.notFound().build();
}
}
@GetMapping("/search")
public ResponseEntity<List<User>> searchUsers(@RequestParam String name) {
List<User> users = userService.searchUsersByName(name);
return ResponseEntity.ok(users);
}
@GetMapping("/count/active")
public ResponseEntity<Long> countActiveUsers() {
long count = userService.countActiveUsers();
return ResponseEntity.ok(count);
}
}

Advanced Features

Custom Repository Implementation

// Custom repository interface
package com.example.repository;
import com.example.entity.User;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import java.util.List;
public interface CustomUserRepository {
List<User> findUsersWithComplexCriteria(String name, Integer minAge, Integer maxAge);
Page<User> findUsersWithPagination(String searchTerm, Pageable pageable);
}
// Implementation
package com.example.repository.impl;
import com.example.entity.User;
import com.example.repository.CustomUserRepository;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Repository;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.ArrayList;
import java.util.List;
@Repository
public class CustomUserRepositoryImpl implements CustomUserRepository {
@PersistenceContext
private EntityManager entityManager;
@Override
public List<User> findUsersWithComplexCriteria(String name, Integer minAge, Integer maxAge) {
CriteriaBuilder cb = entityManager.getCriteriaBuilder();
CriteriaQuery<User> query = cb.createQuery(User.class);
Root<User> user = query.from(User.class);
List<Predicate> predicates = new ArrayList<>();
if (name != null && !name.isEmpty()) {
Predicate firstNamePredicate = cb.like(user.get("firstName"), "%" + name + "%");
Predicate lastNamePredicate = cb.like(user.get("lastName"), "%" + name + "%");
predicates.add(cb.or(firstNamePredicate, lastNamePredicate));
}
if (minAge != null) {
predicates.add(cb.greaterThanOrEqualTo(user.get("age"), minAge));
}
if (maxAge != null) {
predicates.add(cb.lessThanOrEqualTo(user.get("age"), maxAge));
}
query.where(predicates.toArray(new Predicate[0]));
return entityManager.createQuery(query).getResultList();
}
@Override
public Page<User> findUsersWithPagination(String searchTerm, Pageable pageable) {
CriteriaBuilder cb = entityManager.getCriteriaBuilder();
CriteriaQuery<User> query = cb.createQuery(User.class);
Root<User> user = query.from(User.class);
if (searchTerm != null && !searchTerm.isEmpty()) {
Predicate searchPredicate = cb.or(
cb.like(cb.lower(user.get("firstName")), "%" + searchTerm.toLowerCase() + "%"),
cb.like(cb.lower(user.get("lastName")), "%" + searchTerm.toLowerCase() + "%"),
cb.like(cb.lower(user.get("email")), "%" + searchTerm.toLowerCase() + "%")
);
query.where(searchPredicate);
}
TypedQuery<User> typedQuery = entityManager.createQuery(query);
typedQuery.setFirstResult((int) pageable.getOffset());
typedQuery.setMaxResults(pageable.getPageSize());
List<User> result = typedQuery.getResultList();
// Get total count for pagination
CriteriaQuery<Long> countQuery = cb.createQuery(Long.class);
Root<User> countRoot = countQuery.from(User.class);
countQuery.select(cb.count(countRoot));
if (searchTerm != null && !searchTerm.isEmpty()) {
Predicate searchPredicate = cb.or(
cb.like(cb.lower(countRoot.get("firstName")), "%" + searchTerm.toLowerCase() + "%"),
cb.like(cb.lower(countRoot.get("lastName")), "%" + searchTerm.toLowerCase() + "%"),
cb.like(cb.lower(countRoot.get("email")), "%" + searchTerm.toLowerCase() + "%")
);
countQuery.where(searchPredicate);
}
Long total = entityManager.createQuery(countQuery).getSingleResult();
return new PageImpl<>(result, pageable, total);
}
}
// Extend the main repository interface
public interface UserRepository extends JpaRepository<User, Long>, CustomUserRepository {
// ... other methods
}

Auditing with Spring Data JPA

// Configuration
@Configuration
@EnableJpaAuditing
public class AuditingConfig {
@Bean
public AuditorAware<String> auditorProvider() {
return new SpringSecurityAuditorAware();
}
}
// AuditorAware implementation
@Component
public class SpringSecurityAuditorAware implements AuditorAware<String> {
@Override
public Optional<String> getCurrentAuditor() {
// Get current username from Spring Security
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
if (authentication == null || !authentication.isAuthenticated()) {
return Optional.empty();
}
return Optional.of(authentication.getName());
}
}
// Auditable entity
@EntityListeners(AuditingEntityListener.class)
@MappedSuperclass
public abstract class Auditable {
@CreatedDate
@Column(name = "created_date")
private LocalDateTime createdDate;
@LastModifiedDate
@Column(name = "last_modified_date")
private LocalDateTime lastModifiedDate;
@CreatedBy
@Column(name = "created_by")
private String createdBy;
@LastModifiedBy
@Column(name = "last_modified_by")
private String lastModifiedBy;
// Getters and Setters
}

Testing

package com.example.repository;
import com.example.entity.User;
import com.example.entity.UserStatus;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import java.util.List;
import java.util.Optional;
import static org.junit.jupiter.api.Assertions.*;
@DataJpaTest
public class UserRepositoryTest {
@Autowired
private UserRepository userRepository;
@Test
public void testSaveUser() {
User user = new User("testuser", "[email protected]", "John", "Doe");
user.setAge(30);
User savedUser = userRepository.save(user);
assertNotNull(savedUser.getId());
assertEquals("testuser", savedUser.getUsername());
}
@Test
public void testFindByUsername() {
User user = new User("testuser", "[email protected]", "John", "Doe");
userRepository.save(user);
Optional<User> foundUser = userRepository.findByUsername("testuser");
assertTrue(foundUser.isPresent());
assertEquals("John", foundUser.get().getFirstName());
}
@Test
public void testFindByAgeGreaterThan() {
User user1 = new User("user1", "[email protected]", "Alice", "Smith");
user1.setAge(25);
User user2 = new User("user2", "[email protected]", "Bob", "Johnson");
user2.setAge(35);
userRepository.saveAll(List.of(user1, user2));
List<User> users = userRepository.findByAgeGreaterThan(30);
assertEquals(1, users.size());
assertEquals("Bob", users.get(0).getFirstName());
}
@Test
public void testPagination() {
// Create test data
for (int i = 1; i <= 15; i++) {
User user = new User("user" + i, "user" + i + "@example.com", "User" + i, "Test");
userRepository.save(user);
}
PageRequest pageable = PageRequest.of(0, 10, Sort.by("username").ascending());
Page<User> page = userRepository.findAll(pageable);
assertEquals(15, page.getTotalElements());
assertEquals(2, page.getTotalPages());
assertEquals(10, page.getContent().size());
}
@Test
public void testCustomQuery() {
User user = new User("testuser", "[email protected]", "John", "Doe");
userRepository.save(user);
List<User> gmailUsers = userRepository.findGmailUsers();
assertFalse(gmailUsers.isEmpty());
assertTrue(gmailUsers.get(0).getEmail().endsWith("@gmail.com"));
}
}

Best Practices

  1. Use Lazy Loading for relationships to avoid N+1 query problems
  2. Implement equals() and hashCode() correctly for entities
  3. Use @Transactional appropriately in service layer
  4. Avoid Entity in DTO - use separate DTO classes for API
  5. Use Pagination for large datasets
  6. Implement Proper Error Handling
  7. Use Projections for read-only operations
  8. Monitor SQL Queries in development
  9. Use Connection Pooling in production
  10. Implement Caching where appropriate

This comprehensive guide covers the fundamentals of Spring Data JPA, from basic entity mapping to advanced features like custom repositories, auditing, and testing.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper