Mongo Auditing: @CreatedDate field gets set to null on updates with Spring Data Rest [DATAREST-1204]

Explanation of the problem

Troubleshooting with the Lightrun Developer Observability Platform

Getting a sense of what’s actually happening inside a live application is a frustrating experience, one that relies mostly on querying and observing whatever logs were written during development.
Lightrun is a Developer Observability Platform, allowing developers to add telemetry to live applications in real-time, on-demand, and right from the IDE.

• Instantly add logs to, set metrics in, and take snapshots of live applications
• Insights delivered straight to your IDE or CLI
• Works where you do: dev, QA, staging, CI/CD, and production

Start for free today

Problem solution for: Mongo Auditing: @CreatedDate field gets set to null on updates with Spring Data Rest [DATAREST-1204]

import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;

@Entity
public class YourEntity {

    @CreatedDate
    private Date createdDate;

    @LastModifiedDate
    private Date lastModifiedDate;

    // Rest of the entity definition
    // ...
}

// Remove public getters and setters for insert and update fields
public class YourEntity {

    @CreatedDate
    private Date createdDate;

    @LastModifiedDate
    private Date lastModifiedDate;

    // Rest of the entity definition
    // ...
}

Other popular problems with spring-data-rest

1. Circular Reference Serialization Error: Problem Description: When working with entities that have bidirectional relationships, such as a parent-child relationship, Spring Data REST may encounter a circular reference serialization error. This occurs when serializing the entities to JSON and can lead to an infinite loop or incomplete serialization.

Solution: To resolve this issue, you can use Jackson’s @JsonIgnoreProperties annotation to exclude the circularly referenced properties during serialization. Here’s an example:

@Entity
public class Parent {

    // Other fields and annotations
    
    @OneToMany(mappedBy = "parent")
    @JsonIgnoreProperties("parent")
    private List<Child> children;
    
    // Getters and setters
}

@Entity
public class Child {

    // Other fields and annotations
    
    @ManyToOne
    @JsonIgnoreProperties("children")
    private Parent parent;
    
    // Getters and setters
}

By annotating the circularly referenced properties with @JsonIgnoreProperties, Spring Data REST will exclude those properties during serialization, avoiding the circular reference error.

2. Customizing Endpoint Paths: Problem Description: Spring Data REST generates default endpoint paths based on entity names, which may not always align with the desired API structure. Developers may want to customize the endpoint paths to better match their application’s requirements.

Solution: To customize the endpoint paths, you can use the @RepositoryRestResource annotation on the repository interface associated with the entity. Here’s an example:

@RepositoryRestResource(path = "custom-entities")
public interface CustomEntityRepository extends JpaRepository<CustomEntity, Long> {
    // Custom repository methods
}

In this example, the @RepositoryRestResource annotation is used with the path attribute set to “custom-entities”. This will change the endpoint path for the CustomEntity to “/custom-entities” instead of the default path based on the entity name.

3. Handling Pagination and Sorting: Problem Description: When working with large collections of entities, it becomes important to handle pagination and sorting efficiently. Spring Data REST provides support for pagination and sorting out of the box, but developers may encounter challenges in configuring and using these features effectively.

Solution: To enable pagination and sorting for an endpoint, you can use the PagingAndSortingRepository interface provided by Spring Data. Here’s an example:

@RepositoryRestResource
public interface ProductRepository extends PagingAndSortingRepository<Product, Long> {
    // Repository methods
}

By extending the PagingAndSortingRepository interface, you gain access to methods for pagination and sorting, such as findAll(Pageable pageable) and findAll(Sort sort). Additionally, Spring Data REST automatically exposes these features through the generated REST endpoints. Clients can use query parameters like page, size, sort, etc., to control the pagination and sorting behavior of the API.

By addressing circular reference serialization errors, customizing endpoint paths, and handling pagination and sorting effectively, developers can overcome some of the common challenges encountered while using Spring Data REST. These solutions help ensure a smooth and tailored experience when building RESTful APIs with Spring Data.

Spring Data REST is a powerful framework that simplifies the development of RESTful APIs by combining the capabilities of Spring Data and Spring MVC. It provides a convenient way to expose CRUD operations and query endpoints for entities in a Spring Data repository. With Spring Data REST, developers can quickly create a fully functional API with minimal boilerplate code and benefit from automatic resource mapping, content negotiation, and hypermedia support.

At its core, Spring Data REST leverages the concepts of HATEOAS (Hypermedia as the Engine of Application State) to enrich the API responses with links and metadata, enabling clients to navigate and discover related resources. It automatically generates RESTful endpoints for each repository, following REST conventions. For example, given a Person entity and its corresponding repository, Spring Data REST automatically exposes endpoints such as /persons for retrieving all persons, /persons/{id} for retrieving a specific person, and /persons/search for executing custom queries.

In addition to basic CRUD operations, Spring Data REST provides advanced features such as pagination, sorting, filtering, and projection out of the box. These features can be easily customized and extended to meet specific requirements. With pagination, for example, clients can request a specific page size and navigate through large result sets efficiently. Sorting allows clients to specify the desired ordering of the results, and filtering enables them to narrow down the data based on specific criteria. Moreover, Spring Data REST supports projections, which allow clients to retrieve a subset of properties from an entity, reducing network overhead and improving performance. Overall, Spring Data REST empowers developers to build robust and discoverable RESTful APIs with ease.

Most popular use cases for spring-data-rest

@RepositoryRestResource
public interface CustomerRepository extends JpaRepository<Customer, Long> {
    // Custom query methods
}

With this setup, Spring Data REST automatically exposes endpoints such as /customers for retrieving all customers, /customers/{id} for retrieving a specific customer, and /customers/search for executing custom queries.

2. Customizing API Endpoints and Querying: Spring Data REST provides flexibility in customizing API endpoints and querying data. Developers can define custom query methods in the repository interface and expose them as RESTful endpoints. For instance, suppose we want to retrieve all customers with a specific last name:

@RepositoryRestResource
public interface CustomerRepository extends JpaRepository<Customer, Long> {
    List<Customer> findByLastName(@Param("lastName") String lastName);
}

With this custom query method, Spring Data REST generates an endpoint /customers/search/findByLastName that can be used to retrieve customers based on the provided last name. This allows clients to perform fine-grained queries against the exposed data.

3. Enabling HATEOAS and Hypermedia Support: Spring Data REST embraces the principles of HATEOAS and provides hypermedia support in API responses. By including hypermedia links and metadata in the API responses, clients can navigate and discover related resources dynamically. Spring Data REST automatically generates hypermedia links for relationships between entities, allowing clients to follow links and traverse the API. Here’s an example of how hypermedia links can be included in the API response:

{
  "firstName": "John",
  "lastName": "Doe",
  "_links": {
    "self": {
      "href": "http://example.com/customers/1"
    },
    "orders": {
      "href": "http://example.com/customers/1/orders"
    }
  }
}

In this response, the _links field provides links to the current resource (self) and related resources (orders). This hypermedia support enhances the discoverability and navigability of the API, making it easier for clients to interact with the exposed data entities.