Question

I am writing an application using the Play framework, which uses JPA annotations and Hibernate as part of the included Ebean ORM persistence layer. I’m having some trouble figuring out the JPA annotations related to foreign keys. In my MySQL database, there is one main table called Locations that stores addresses (street, city, state, zip, etc). Many many other tables in the database use this table in either one-to-one or many-to-many relationships. The problem is, I get an error when I try to map multiple fields to the id field in Locations.

For example, Docks and LineItems are two models that contain references to a Location. Each Dock has a Location, and each LineItem has two Locations: an origin and a destination.

So, in Dock, I have the code:

@OneToOne(optional=false)
@JoinColumn(name="loc_id")
public Location location;

and in LineItem, I have:

@OneToOne(optional=false)
@JoinColumn(name="origin")
public Location origin;

@OneToOne(optional=false)
@JoinColumn(name="destination")
public Location destination;

but I can’t map them all to the id field in Locations because JPA won’t allow me to do this:

@Id
@GeneratedValue
@OneToOne(mappedBy="location", fetch=FetchType.EAGER)
@OneToOne(mappedBy="origin", fetch=FetchType.EAGER)
@OneToOne(mappedBy="destination", fetch=FetchType.EAGER)
@Column(name="loc_id")
public Long id;

I have a feeling that I’m just going about this the wrong way. Is there a simpler way to have a foreign key constraint in JPA? I don’t really want to use a work-around like creating a bunch of extra columns in my tables because Locations really is referenced a LOT. Any advice to set me straight would be appreciated.

Answer 1

The Location config you’ve shown doesn’t make any sense. Here’s what it would mean to JPA if it could be interpreted with your full intent:

1. Location has a Long “id” property which is a generated value and is mapped to the column loc_id.
2. The “id” property is a Dock and is the non-owning end of a one-to-one, bidirectional relationship between Dock and Location.
3. It’s also a LineItem that’s the non-owning end of a one-to-one, bidirectional relationship from LineItem as both the origin and the destination.

Obviously that doesn’t make any sense, right? If you were going to have all these @OneToOne annotations in Location, each one would need to be on its own field: one Dock and two LineItems, plus more for all of the other relationships to Location that you mentioned. That’s obviously not desirable because a Location is just that, and it doesn’t matter what other things reference it. So what you really want is a bunch of unidirectional relationships to Location. Since you’ve already got Location mapped as the non-owning end (via the “mappedBy” parameter), all you have to do is remove the @OneToOnes from Location. All you need is, for example:

@OneToOne
@JoinColumn(name="origin")
public Location origin;

That says that the “origin” property is the Location whose primary key is stored in the “origin” field of the table this entity is mapped to.

On that note, I expect all of these aren’t really one-to-one relationships. At least the LineItem ones are one-to-many. I can’t imagine that two line items would never have the same origin or destination.

And by the way, optional=false is the default, but if you’re thinking it prevents that field from being null, it doesn’t. The optional parameter just tells JPA whether or not to throw an exception if the row referenced by the foreign key is missing.

That’s kind of a high-level overview. Ask further questions if you don’t understand some of it. The Hibernate Annotations guide should help you understand a lot of it, and it can also be very helpful to have hibernate generate a database schema for you so you can see if it’s understanding what you’re telling it as far as table structure.