Spring Boot JPA @Transient Example

1. Introduction

Spring Boot, along with Spring Data JPA, provides a full-stack development experience that simplifies data access while working with relational databases. However, sometimes we need to have fields in our entities that are calculated or derived and should not be persisted to the database. This is where the @Transient annotation comes into play. In this blog post, we'll discuss the @Transient annotation and provide a practical example of its use in a Spring Boot application.

Key Points:

1. @Transient marks a field in an entity class as transient, meaning it will not be persisted in the database.

2. It is useful for calculated fields that should only exist in the application's context, not in the database.

3. @Transient can also be used to avoid persisting sensitive information that should not be stored.

4. This annotation helps keep the domain model aligned with business logic rather than database design.

5. Fields marked as @Transient are ignored during JPA's lifecycle, including persist, merge, refresh, and remove operations.

2. Implementation Steps

1. Set up a Spring Boot project with Spring Data JPA.

2. Create an entity class with various fields, including at least one that should not be persisted.

3. Annotate the non-persistent field with @Transient.

4. Implement a repository interface extending JpaRepository for the entity.

5. Use the repository in a service or controller to interact with the entity.

6. Run the application and observe that @Transient fields are not stored in the database.

3. Implementation Example

// Step 1: Create an entity class with both persistent and transient fields
public class Customer {
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String firstName;
    private String lastName;

    // Step 2: Mark the field as transient
    private String fullName;

    // Standard getters and setters

    // Step 3: Implement a method to update the transient field before retrieval
    private void updateFullName() {
        this.fullName = this.firstName + " " + this.lastName;

// Step 4: Create a repository for the entity
public interface CustomerRepository extends JpaRepository<Customer, Long> {

// Step 5: Use the repository in a service
public class CustomerService {
    private final CustomerRepository customerRepository;

    public CustomerService(CustomerRepository customerRepository) {
        this.customerRepository = customerRepository;

    public Customer getCustomer(Long id) {
        return customerRepository.findById(id).orElse(null);

    // Additional service methods

// Step 6: Optionally, create a REST Controller to expose customer details
public class CustomerController {
    private final CustomerService customerService;

    public CustomerController(CustomerService customerService) {
        this.customerService = customerService;

    public ResponseEntity<Customer> getCustomer(@PathVariable Long id) {
        Customer customer = customerService.getCustomer(id);
        return ResponseEntity.ok(customer);

// Step 7: Run the application
public class JpaTransientExampleApplication {
    public static void main(String[] args) {
        SpringApplication.run(JpaTransientExampleApplication.class, args);

// Accessing the customer via the REST controller will show the fullName field, but it won't be present in the database.


// The JSON response for a GET request to /customers/1 might look like:
    "id": 1,
    "firstName": "John",
    "lastName": "Doe",
    "fullName": "John Doe"
// The `fullName` is present in the JSON response but not stored in the database.


1. @Entity: Specifies that the class is an entity and is mapped to a database table.

2. @Id and @GeneratedValue: Annotations that specify the primary key of the entity and the generation strategy for its value.

3. @Transient: Applied to the fullName field to indicate that it should not be persisted in the database.

4. CustomerRepository: Extends JpaRepository, providing CRUD operations for the Customer entity.

5. @PostLoad: A JPA lifecycle annotation that specifies the updateFullName method should be called after an entity is loaded from the database.

6. CustomerService: A service class that uses CustomerRepository to perform operations related to Customer entities.

7. @Service: Marks CustomerService as a Spring-managed service bean.

8. CustomerController: A controller class that maps HTTP requests to handler methods related to customer operations.

9. @RestController and @GetMapping: Annotations to define RESTful endpoints.

10. @Autowired: Enables dependency injection of the CustomerRepository and CustomerService into the controller and service classes, respectively.

11. JpaTransientExampleApplication: The main class of the Spring Boot application with @SpringBootApplication for configuration and bootstrap.

12. SpringApplication.run(): Launches the application.