@JsonIgnore vs @Transient

Last updated: January 8, 2024

Written by: Ana Peterlić

Reviewed by: Saajan Nagendra

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Overview

In this short tutorial, we’ll learn the difference between the @JsonIgnore and @Transient annotations.

2. @JsonIgnore

We use the @JsonIgnore annotation to specify a method or field that should be ignored during serialization and deserialization processes. This marker annotation belongs to the Jackson library.

We often apply this annotation to exclude fields that may not be relevant or could contain sensitive information. We use it on a field or a method to mark a property we’d like to ignore.

Firstly, let’s create a simple Person class with several fields:

class Person implements Serializable {

    private Long id;

    private String firstName;

    private String lastName;

    // getters and setters
}

Now, let’s suppose we don’t want to show the id field in the JSON representation of the Person object. Let’s exclude the field using the @JsonIgnore annotation:

class Person implements Serializable {

    @JsonIgnore
    private Long id;

    private String firstName;

    private String lastName;

    // getters and setters
}

Finally, let’s write a test to make sure ObjectMapper ignores the id field:

@Test
void givenPerson_whenSerializing_thenIdFieldIgnored() 
  throws JsonProcessingException {

    Person person = new Person(1L, "My First Name", "My Last Name");
    String result = new ObjectMapper().writeValueAsString(person);

    assertThat(result, containsString("firstName"));
    assertThat(result, containsString("lastName"));
    assertThat(result, not(containsString("id")));
}

3. @Transient

On the other hand, we use the @Transient annotation to indicate the Java Persistence API (JPA) should ignore the field when mapping objects to a database. When we mark a field with this annotation, the JPA won’t persist the field and it won’t retrieve its value from the database.

Now, let’s create a User class:

@Entity
@Table(name = "Users")
class User implements Serializable {

    @Id
    private Long id;

    private String username;

    private String password;

    private String repeatedPassword;

    // getters and setters
}

Let’s exclude the repeatedPassword field from the database representation of a User object with the @Transient annotation:

@Entity
@Table(name = "User")
class User implements Serializable {

    @Id
    private Long id;

    private String username;

    private String password;

    @Transient
    private String repeatedPassword;

    // getters and setters
}

When we persist a User object to the database, the JPA won’t save repeatedPassword value to the database. Additionally, JPA ignores the field when loading objects from the database:

@Test
void givenUser_whenSave_thenSkipTransientFields() {
    User user = new User(1L, "user", "newPassword123", "newPassword123");
    User savedUser = userRepository.save(user);

    assertNotNull(savedUser);
    assertNotNull(savedUser.getPassword());
    assertNull(savedUser.getRepeatedPassword());
}

However, the @Transient annotation won’t exclude a field from serialization:

@Test
void givenUser_whenSerializing_thenTransientFieldNotIgnored() throws JsonProcessingException {

    User user = new User(1L, "user", "newPassword123", "newPassword123");
    String result = new ObjectMapper().writeValueAsString(user);

    assertThat(result, containsString("user"));
    assertThat(result, containsString("repeatedPassword"));
}

4. Conclusion

In this article, we learned the differences between the @JsonIgnore and @Transient annotations.

To sum up, both annotations are used to indicate fields that should be ignored when performing certain operations. The @JsonIgnore annotation excludes the fields from the JSON representation. The @Transient annotation omits them from the database representation.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.