Java records are a new feature introduced in Java 14 that provides a concise way to declare classes that are meant to hold immutable data. Spring Data is a popular framework for building data access layers in Java applications. In this answer, we will explain how to use Java records as models in Spring Data.

To use a Java record as a model in Spring Data, you can follow these steps:

  1. Define the record class: Define a record class with the fields you need for your model. For example:
public record Customer(String firstName, String lastName, String email) {}

This record class defines a customer model with three fields: firstName, lastName, and email. Since records are immutable by default, the Customer class is automatically final and its fields are final as well.

  1. Define the Spring Data repository: Define a Spring Data repository interface that extends JpaRepository or one of its sub-interfaces. For example:
@Repository 
public interface CustomerRepository extends JpaRepository<Customer, Long> {}

This repository interface defines a Spring Data repository for the Customer model. The JpaRepository interface provides basic CRUD operations for the model, and you can define additional custom methods if needed.

  1. Use the model in your application: You can now use the Customer model in your Spring application, for example in a service or controller class. For example:
@Service 
public class CustomerService {
	private final CustomerRepository customerRepository;      
	public CustomerService(CustomerRepository customerRepository) {
	   this.customerRepository = customerRepository;     
	}
	
	public List<Customer> findAllCustomers() {
		return customerRepository.findAll();
	}
	
	public Customer createCustomer(Customer customer) {         
		return customerRepository.save(customer);
	}
}

This service class uses the CustomerRepository to find and create customers. Since the Customer model is defined as a record, you can easily create instances of it using its constructor syntax, for example:

Customer customer = new Customer("John", "Doe", "john.doe@example.com"); customerService.createCustomer(customer);

Updating records in Spring Data when your models are Java records can be done using the save method provided by the Spring Data repository interface.

When you use a Java record as a model, its fields are immutable by default, so you can’t change them directly. Instead, you can create a new instance of the record with the updated values and use the save method to persist the changes to the database.

Here’s an example of how to update a record in Spring Data when your models are Java records:

  1. Define the record class: Define a record class with the fields you need for your model, as explained in the previous answer.

javaCopy code

public record Customer(String firstName, String lastName, String email) {}
  1. Define the Spring Data repository: Define a Spring Data repository interface that extends JpaRepository or one of its sub-interfaces, as explained in the previous answer.

javaCopy code

@Repository 
public interface CustomerRepository extends JpaRepository<Customer, Long> {}
  1. Update a record: To update a record, you can retrieve it from the repository, create a new instance with the updated values, and save the new instance using the save method.
@Service 
public class CustomerService {
	private final CustomerRepository customerRepository;      
	
	public CustomerService(CustomerRepository customerRepository) {         
		this.customerRepository = customerRepository;     
	}
	
	public Customer updateCustomer(Long id, Customer updatedCustomer) {         
		Customer customer = customerRepository.findById(id)
			.orElseThrow(() -> 
				new EntityNotFoundException("Customer not found with id: " + id));
		Customer newCustomer = new Customer(updatedCustomer.firstName(), 
			updatedCustomer.lastName(), updatedCustomer.email());         
			
			newCustomer = customerRepository.save(newCustomer);
		return newCustomer;
	}
}

In this example, the updateCustomer method retrieves a customer from the repository using its ID, creates a new instance of the Customer record with the updated values, and saves it to the database using the save method.

Note that in this example, we are creating a new instance of the record instead of updating the existing instance. This is because records are immutable by default, so we can’t change the values of an existing instance. Instead, we create a new instance with the updated values and save it to the database.

By Jeffery Miller

I am known for being able to quickly decipher difficult problems to assist development teams in producing a solution. I have been called upon to be the Team Lead for multiple large-scale projects. I have a keen interest in learning new technologies, always ready for a new challenge.