1. Introduction
When persisting Java objects into database records using an Object-Relational Mapping (ORM) framework, we often want to ignore certain fields. If the framework is compliant with the Java Persistence API (JPA), we can add the @Transient annotation to these fields.
In this tutorial, we’ll demonstrate proper usage of the @Transient annotation. We’ll also look at its relationship with Java’s built-in transient keyword.
2. @Transient Annotation vs. transient Keyword
There is generally some confusion over the relationship between the @Transient annotation and Java’s built-in transient keyword. The transient keyword is primarily meant for ignoring fields during Java object serialization, but it also prevents these fields from being persisted when using a JPA framework.
**In other words, the transient keyword has the same effect as the @Transient annotation when saving to a database. However, the @Transient annotation does not affect Java object serialization.
**
3. JPA @Transient Example
Let’s say we have a User class, which is a JPA entity that maps to a Users table in our database. When a user logs in, we retrieve their record from the Users table, and then we set some additional fields on the User entity afterward. These extra fields don’t correspond to any columns in the Users table because we don’t want to save these values.
For example, we’ll set a timestamp on the User entity that represents when the user logged in to their current session:
@Entity
@Table(name = "Users")
public class User {
@Id
private Integer id;
private String email;
private String password;
@Transient
private Date loginTime;
// getters and setters
}
When we save this User object to the database using a JPA provider like Hibernate, the provider ignores the loginTime field because of the @Transient annotation.
If we serialize this User object and pass it to another service in our system, the loginTime field will be included in the serialization. If we didn’t want to include this field, we could replace the @Transient annotation with the transient keyword instead:
@Entity
@Table(name = "Users")
public class User implements Serializable {
@Id
private Integer id;
private String email;
private String password;
private transient Date loginTime;
//getters and setters
}
Now, the loginTime field is ignored during database persistence and object serialization.
4. Conclusion
In this article, we have investigated how to properly use the JPA @Transient annotation in a typical use case. Be sure to check out other articles on JPA to learn more about persistence.
As always, the full source code of the article is available over on GitHub.