Update bidirectional ManyToMany from both sides

Question

referring the question Saving bidirectional ManyToMany i want to obtain exacltly what accepted answer explain as incorrect:

A a1 = new A();
A a2 = new A();
B b = new B();
a1.getB().add(b);
b.getA().add(a2);

If this state could be persisted, you would end up with the following entries in the join table:

a1_id, b_id
a2_id, b_id

But upon loading, how would JPA know that you intended to only let b know about a2 and not a1 ? and what about a2 that should not know about b ?

in my case it is correct that b knows about a1 and a2 in EVERY situation.

think about parent-child relation:

b is parent of a1 AND a1 is child of b (naturally)

and for me it is erroneous to define only one direction:

b is parent of a1 AND NOT a1 is child of b (???)

to obtain what accepted answer is explaining i think i need TWO join tables:

a_has_b:
a1_id, b_id

b_has_a
b_id, a2_id

am i wrong??

however, how to obtain a "synchronized" bidirectional relation (not just ManyToMany)?
is it possible with standard JPA features?
otherwise, is there any specific provider implementation?

i think that implementing

...
public void addB(A a)
{
    getA().add(a);
    a.getB().add(this);
}

is a really ugly hack...

and using two unidirectional OneToMany on both sides does not work in EclipseLink 2.2.0 (not so sure, i'm currently trying)

thx :)

What's the problem with the two unidirectional connection? For me that seems the best way. — palacsint, Sep 25 '11 at 16:13
you're right, this works. i was confused because i didn't call "refresh" — Michele Mariotti, Sep 25 '11 at 16:23

score 3 · Answer 1 · answered Jul 09 '13 at 13:28

Using,

public void addA(A a)
{
    getA().add(a);
    a.getB().add(this);
}

Is not a hack. This is good object-oriented programming. In any Java model, ignoring persistence, if you have a bi-directional relationship, you must add to both sides to correct related anything. Your code should not change just because you are, or are not, using persistence.

If you want to maintain the relationships separately, you need to have two different join tables. If you want a single ManyToMany relationship (it seems you do), then you must use @ManyToMany and set the mappedBy on one side.

See, http://en.wikibooks.org/wiki/Java_Persistence/ManyToMany

i'm sorry, but i disagree. you are putting a business logic method (it is minimal, but it IS) into a "storage" object, IMO breaking MVC. moreover to have the bidirectional relation to be concrete, you should create it on EVERY instance of involved objects. i prefer a centralized approch, where my central point is database. — Michele Mariotti, Aug 04 '13 at 12:38

score 3 · Accepted Answer · answered Aug 04 '13 at 12:41

using two unidirectional OneToMany will do the trick:

@Entity
@Table
public class A implements Serializable
{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Basic(optional = false)
    @Column(name = "id", nullable = false)
    private Long id;

    @OneToMany
    @JoinTable(name="a_b", 
        joinColumns = @JoinColumn(name = "a_id", nullable = false), 
        inverseJoinColumns = @JoinColumn(name = "b_id", nullable = false)
    )
    private List<B> bList = new ArrayList<B>();
}

---------------------------------------------------------------------------------

@Entity
@Table
public class B implements Serializable
{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Basic(optional = false)
    @Column(name = "id", nullable = false)
    private Long id;

    @OneToMany
    @JoinTable(name="a_b", 
        joinColumns = @JoinColumn(name = "b_id", nullable = false), 
        inverseJoinColumns = @JoinColumn(name = "a_id", nullable = false)
    )
    private List<A> aList = new ArrayList<A>();
}

refreshing entity will fill list

Defining JoinTable for both sides does the trick. But, instead of OneToMany, ManyToMany annotation should be used. Otherwise JPA will automatically define unique constraints on a_id and b_id separately. However (a_id and b_id) together must be unique on such ManyToMany relationship. — vahapt, Apr 16 '15 at 16:55

score 1 · Answer 3 · answered Jul 09 '13 at 08:59

1

I faced the problem on updating via the non-owning side. I put @ManyToMany and @JoinTable on both side (no mappedBy). It is working nicely. I am using Hibernate 4.1.10.Final. As per wiki documents, it is not right. Confused ??

answered Jul 09 '13 at 08:59

Basanta Raj Onta

21
1
5

the only difference between your solution and my updated part is that you are using `@ManyToMany`, and i'm using `@OneToMany`. – Michele Mariotti Jul 09 '13 at 10:10

Update bidirectional ManyToMany from both sides

3 Answers3