JPA - 什么时候使用关系？

Question

I am still not a stage where I feel completely comfortable with JPA.

Right now I am torn between using relationship annotations or simply retrieving the related objects when I need them with queries.

For instance I have a User who owns Projects. I can use a .netomany relationship and retrieve the projects in an object fashion way OR I can simply query the user's projects when I need them.

The latter solution involves more code but somehow I have more freedom and control over what I want to do, or at least it is my impression. The former will obviously take care of quite a fair amount of boiler plate code such as create/delete/update of objects, but there are quite a few tricks to learn along the way.

I would greatly appreciate if someone could come up with a simple rule of thumb on when to use relationship annotations in JPA, preferably based on her/his experience.

Thanks,

Thomas

Answer 1

The basic rule is that you should create a relationship when you need it.

For one-to-one and many-to-one relationships it's quite easy: you need them almost always. For example, when you display Project information you almost always need to display its owner information as well, thus creating a relationship is a good choice here.

One-to-many and many-to-many relationships require more care, since overuse of them can cause performance problems.

My personal rule of thumb is the following: if you don't need to display all Project s of User at once without pagination or filtering (or at least don't need to do it often), don't create a relationship. Otherwise you can create it (for example, you usually need all OrderLine s of Order at once, thus you need a one-to-many relationship in this case).

Answer 2

Your issues are valid, relationships are hard in JPA-compliant ORMs. However the benefit of relationships is the ability to use them in JPA QL queries. Eg when you want to fetch all projects created by user with a given name you can write:

SELECT p
FROM Project p
WHERE p.user.name = 'Smith'

You cannot do this when instead of:

@ManyToOne
private User user

in the Project relationship you have a simple:

private int userId;

Also investigate various fetching strategies to feel more comfortable with relationships.

Answer 3

when there is a relationship between two entities and you expect to use it, use JPA relationship annotations. One of the main advantages exactly is to not have to manually make extra queries when there is a relationship between entities.

Answer 4

I would go for the annotation. Its simpler and produces less code and it's kind of the whole point of using JPA. And also the one-to-many sets are lazy fetched by default, so you don't risk fetching stuff from the database that you don't need.

But I recommend reading up on lazy/eager fetching and learning how that works.

Answer 5

It all depends on how your application works with regards to retrieving data and the instances it needs them. Although JPA can be used anywhere, even outside a Java EE container (which is a huge advantage to use in a standard Java SE app, or with Spring etc.) I find that its 'way of thinking' is very much oriented towards Request - Response style interactions, mapping to web applications and the like (which to be fair is the most popular type of enterprise server-side application these days). However, unless you have some very specific needs I would definitely invest in learning the JPA relationship annotations.

In JPA everything goes around the EntityManager session. If you have an EntityManager instance managing your entities throughout the workflow you are mentioning where you need to get Users, Projects etc., all within one request-response then definitely go for using @OneToMany etc. because it will take care of getting the child entities whenever you need them without caring about how to join foreign keys and also carries with it optimisations on when to retrieve what. Even if you need to have the same Entity carried across requests, its pretty simple with refresh() and merge() .

I agree with you that the annotations tend to get a bit hairy with FetchType, CascadeType etc. and you might also face the occasional infamous cannot simultaneously fetch multiple bags PersistenceException, so its a bumpy ride, but once you get the hang of it I think its worth the investment.