Friend Relationships with JPA

Question

I'm having a hard time creating the optimal JPA representation of a relationship. Seems like there is a bunch of ways to do it and I'm not sure which is most optimal. Without JPA I might represent the structure as a PERSON table and a FRIEND table. Let's say the PERSON table just has an ID and NAME. The FRIEND table has an OWNER_ID, a PERSON_ID, and a settable boolean IS_ACTIVE field. OWNER_ID and PERSON_ID both refer to the PERSON table. A person can have many friends so the unique primary key would be on OWNER_ID and PERSON_ID. In my code I would like the PersonEntity to control the relationship. Operations in Java might look like this:

person1.getFriends().add( new Friend( person2, isActive ) );
Friend friend = person1.findFriend( person2ID );

Something like that. Note that I would like JPA to implicitly assign the OWNER of the friend relationship. In the above code I do not pass it in the Friend constructor, I only pass the PERSON part of the composite key.

Here was my first guess at this:

@Entity
public class Person {
   @Id
   @GeneratedValue
   private Long id;

    @OneToMany( mappedBy="key.owner", cascade=CascadeType.ALL, orphanRemoval = true)
    private Set<Friend> friends = new HashSet<>();

    // getter and setter for Friends
    ...
}

@Entity
public class Friend {
   @EmbeddedId
   private Key key = new Key();

   private boolean isActive;

   ...

   @Embeddable
   public static class Key implements Serializable {
      @ManyToOne
      private Person owner;

      @OneToOne
      private Person person;

      ...
   }
}

But when I use this code I get stack overflow errors. I'm assuming it is confused by the OneToOne relationship.

What is the best way to model this sort of relationship in JPA 2.0? I suppose the simplest thing would be to introduce a generated long key in Friend. But that seems like it will make the query more complex for "find friends for john" since I will be introducing a third mapping table, basically mapping the relationship twice in SQL. Another approach is to make it a unidirectional OneToMany relationship and not even specify OWNER explicitly in Friend. That would introduce another table for the mapping and make queries a little convoluted. Using ElementCollection instead of OneToMany seems straight forward but then my understanding is that I could not manage Friend as an entity?

Let me know if you guys need anymore detail or requirements. BTW, I tried putting a MapsId in Friend for the Owner part of the PKEY but that gave me runtime errors.

Any help is appreciated.

NOTE: Even if I add a generated key to Friend I would like to enforce the uniqueness on the combination of {owner,person} in the Friend entity.

Answer 1

Alright, so if you want a solution to this problem that creates the sort of table one would want to in pure SQL - that is no artificial surrogate key and application data as a compound key - you can definitely do it. However, using JPA makes this a little bit messier than you might want it to be.

Thanks to @JB Niznet for his great input, you can definitely also do this by introducing a surrogate key as he suggests. The solution below just removes that need and as far as I can tell has no drawbacks.

@Entity
public class Person {
   @Id
   @GeneratedValue
   private Long id;

   @OneToMany( mappedBy="owner", cascade=CascadeType.ALL, orphanRemoval = true)
   private Set<Friend> friends = new HashSet<>();

   // getter and setter for Friends
   ...
}

@Entity
public class Friend {
   @EmbeddedId
   private Key key = new Key();

   @ManyToOne
   @Maps("ownerId")
   private Person owner;

   @ManyToOne
   @MapsId("personId")
   private Person person;

   private boolean isActive;

   ...

   @Embeddable
   public static class Key implements Serializable {
      private Long ownerId;
      private Long personId;

      ...
   }
} 

Answer 2

You have to think about the Design: Entities will be classes and have tables. Relations will ONLY have tables, since relations are just connecting 2 Entities! (except a relation has attributes, like "friend-rating" in this case etc..)

While Person is clearly a Entity, friend is a relation. More than that, friend is a bidirectional relation. (A is friend of B => B is friend of A)

So, you simple need to extend your Person Object, by a List of Persons - called friends:

@Entity
public class Person {
   @Id
   @GeneratedValue
  private Long id;

  @OneToMany
  @JoinTable(name="friends")
  @JoinColumn(name="person_A_id", referencedColumnName="id"), @JoinColumn(name="person_B_id", referencedColumnName="id")) 
  private Set<Person> friends = new HashSet<>();

}

This is untestet, but should give you a table like this:

person_a_id | person_b_id
1             2
1             6
2             7

then you simple can work with your entity like

Person A = new Person();
Person B = new Person();
A.friends.add(B);

However, keep in Mind that JPA will not be able to thread this bidirectional: So if you add B to A'S friends, you wont find A in the List of Friends of B. You have to take care for that!

Answer 3

I would indeed add an auto-generated ID to the Friend entity. It would make things much simpler (no composite key containing associations). I don't see how adding such an ID (and thus such an additional column in the Friend table) would make any query more complex, or introduce a new table. It won't. You'll simply have an additional column, being the primary key of the friend table.

Once you have that, you'll need to fix your mapping:

1. the association between Friend and Person is not a OneToOne, but a ManyToOne, since several persons can be the friends of another one.
2. mappedBy is supposed to hold the name of the field, in the other entity, which represents the other side of the association. In your case, it's thus "key.owner". If you stop using a composite key, it will simply be "owner".

And finally, in a bidirectional OneToMany association, the owner is always the Many side (i.e. Friend, in this case). So you must initialize the friend.owner field in order to persist the association. But if you encapsulate the list of friends rather than letting it accessible from the oustide, it will be simple. Instead of doing

person1.getFriends().add( new Friend( person2, isActive ) );

simply do

person1.addFriend( new Friend( person2, isActive ) );

and make sure that the addFriend() method contains the following instruction:

friendToAdd.setOwner(this);