Expand Authors Top

If you have a few years of experience in the Java ecosystem and you’d like to share that with the community, have a look at our Contribution Guidelines.

Expanded Audience – Frontegg – Security (partner)
announcement - icon User management is very complex, when implemented properly. No surprise here.

Not having to roll all of that out manually, but instead integrating a mature, fully-fledged solution - yeah, that makes a lot of sense.
That's basically what Frontegg is - User Management for your application. It's focused on making your app scalable, secure and enjoyable for your users.
From signup to authentication, it supports simple scenarios all the way to complex and custom application logic.

Have a look:

>> Elegant User Management, Tailor-made for B2B SaaS

NPI – JPA Buddy – JPA (partner)
announcement - icon

JPA is huge! It covers nearly every aspect of communication between relational databases and the Java application and is deeply integrated into all major frameworks.

If you're using IntelliJ, JPA Buddy is super helpful. The plugin gently guides you through the subtleties of the most popular JPA implementations, visually reminds you of JPA features, generates code that follows best practices, and integrates intelligent inspections to improve your existing persistence code.

More concretely, it provides powerful tooling to generate Spring Data JPA repositories and methods, Flyway Versioned Migrations, Liquibase Differential Changelogs, DDL and SQL statements, DTO objects, and MapStruct interfaces.

Oh, and it actually generates JPA entities from an existing database and gradually update the data model as the database evolves! Yeah.

>> Become a lot more productive with JPA Buddy

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:

@Table(name = "Users")
public class User {

    private Integer id;
    private String email;
    private String password;
    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:

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

    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.

Persistence bottom

Get started with Spring Data JPA through the reference Learn Spring Data JPA course:

Persistence footer banner
Comments are closed on this article!