JPA Many-To-One Relationships (Unidirectional and Bidirectional)

This post illustrates simple many-to-one relationships between two classes.

Unidirectional

@Entity
@AutoProperty
public class ManyToOneUnidirectionalA implements Serializable {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private long id;
 
    @ManyToOne
    private ManyToOneUnidirectionalB b;
 
    private String s;

    // Setters, Getters, Constructors, Pojomatic...

}


@Entity
@AutoProperty
public class ManyToOneUnidirectionalB implements Serializable {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private long id;
 
    private String s;

    // Setters, Getters, Constructors, Pojomatic...

}

The following:

ManyToOneUnidirectionalA a1 = new ManyToOneUnidirectionalA("AA1");
ManyToOneUnidirectionalA a2 = new ManyToOneUnidirectionalA("AA2");
  
ManyToOneUnidirectionalB b = new ManyToOneUnidirectionalB("BBB");
  
a1.setB(b);
a2.setB(b);
  
JPA.INSTANCE.save(b);
JPA.INSTANCE.save(a1);
JPA.INSTANCE.save(a2);
JPA.INSTANCE.clear();
  
ManyToOneUnidirectionalA retrA1
    = JPA.INSTANCE.get(ManyToOneUnidirectionalA.class, a1.getId());
  
System.out.println("Retrieving ManyToOne Unidirectional A's");
System.out.println(retrA1);
  
ManyToOneUnidirectionalA retrA2
    = JPA.INSTANCE.get(ManyToOneUnidirectionalA.class, a2.getId());
  
System.out.println(retrA2);

System.out.println("Retrieving ManyToOne Unidirectional B");
ManyToOneUnidirectionalB retrB
    = JPA.INSTANCE.get(ManyToOneUnidirectionalB.class, b.getId());
  
System.out.println(retrB);

Generates:

Retrieving ManyToOne Unidirectional A's
ManyToOneUnidirectionalA{id: {1}, b: {ManyToOneUnidirectionalB{id: {1}, s: {BBB}}}, s: {AA1}}
ManyToOneUnidirectionalA{id: {2}, b: {ManyToOneUnidirectionalB{id: {1}, s: {BBB}}}, s: {AA2}}
Retrieving ManyToOne Unidirectional B
ManyToOneUnidirectionalB{id: {1}, s: {BBB}}

Bidirectional

A owns the relationship. We need to avoid Pojomatic circular reference issues too:

@Entity
@AutoProperty
public class ManyToOneBidirectionalA implements Serializable {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private long id;
 
    @Property(policy=PojomaticPolicy.NONE) 
    @ManyToOne
    private ManyToOneBidirectionalB b;
 
    private String s;

    // Setters, Getters, Constructors, Pojomatic...

}


@Entity
@AutoProperty
public class ManyToOneBidirectionalB implements Serializable {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private long id;
 
    @Property(policy=PojomaticPolicy.NONE) 
    @OneToMany(cascade=CascadeType.ALL, mappedBy="b")
    private Collection<ManyToOneBidirectionalA> a;
   
    private String s;

    // Setters, Getters, Constructors, Pojomatic...

}

The following:

ManyToOneBidirectionalA a11 = new ManyToOneBidirectionalA("BiAAA");
ManyToOneBidirectionalA a22 = new ManyToOneBidirectionalA("BiAAA");
ManyToOneBidirectionalB b2 = new ManyToOneBidirectionalB("BiBBB");
  
Collection<ManyToOneBidirectionalA> c
    = new ArrayList<ManyToOneBidirectionalA>();
c.add(a11);
c.add(a22);
b2.setA(c);
  
a11.setB(b2);
a22.setB(b2);
  
JPA.INSTANCE.save(b2);
JPA.INSTANCE.clear();

ManyToOneBidirectionalB retrB
    = JPA.INSTANCE.get(ManyToOneBidirectionalB.class, b2.getId());
  
System.out.println("Retrieving ManyToOne Bidirectional B");
System.out.println(retrB);
  
for (ManyToOneBidirectionalA orig : b2.getA()) {
    ManyToOneBidirectionalA retrA
        = JPA.INSTANCE.get(
     ManyToOneBidirectionalA.class, orig.getId());
    System.out.println(retrA);
}  
  
System.out.println("Retrieving ManyToOne Bidirectional A's");
  
ManyToOneBidirectionalA retrA11
    = JPA.INSTANCE.get(ManyToOneBidirectionalA.class, a11.getId());
  
System.out.println(retrA11);
System.out.println(retrA11.getB());
  
ManyToOneBidirectionalA retrA22
    = JPA.INSTANCE.get(ManyToOneBidirectionalA.class, a22.getId());
  
System.out.println(retrA22);
System.out.println(retrA22.getB());

Generates:

Retrieving ManyToOne Bidirectional B
ManyToOneBidirectionalB{id: {1}, s: {BiBBB}}
ManyToOneBidirectionalA{id: {1}, s: {BiAAA}}
ManyToOneBidirectionalA{id: {2}, s: {BiAAA}}
Retrieving ManyToOne Bidirectional A's
ManyToOneBidirectionalA{id: {1}, s: {BiAAA}}
ManyToOneBidirectionalB{id: {1}, s: {BiBBB}}
ManyToOneBidirectionalA{id: {2}, s: {BiAAA}}
ManyToOneBidirectionalB{id: {1}, s: {BiBBB}}

The above examples are available from Github in the JPA directory. They rely on Pojomatic too. Some errors messages will be displayed because of a known and harmless issue.

JPA One-To-Many Relationships (Unidirectional and Bidirectional)

This post illustrates simple one-to-many relationships between two classes.

Unidirectional

We set the cascade type (i.e., propagation of operations) to ALL:

@Entity
@AutoProperty
public class OneToManyUnidirectionalA implements Serializable {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private long id;
 
    @OneToMany(cascade=CascadeType.ALL)
    private Collection<onetomanyunidirectionalb> b;
 
    private String s;

    // Setters, Getters, Constructors, Pojomatic...

}


@Entity
@AutoProperty
public class OneToManyUnidirectionalB implements Serializable {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private long id;
 
    private String s;

    // Setters, Getters, Constructors, Pojomatic...

}

The following:

OneToManyUnidirectionalA a = new OneToManyUnidirectionalA("AAA");
  
Collection<OneToManyUnidirectionalB> setB
    = new ArrayList<OneToManyUnidirectionalB>();
  
setB.add(new OneToManyUnidirectionalB("BBB"));
setB.add(new OneToManyUnidirectionalB("CCC"));

a.setB(setB);
  
JPA.INSTANCE.save(a);
JPA.INSTANCE.clear();
  
OneToManyUnidirectionalA retrA
    = JPA.INSTANCE.get(OneToManyUnidirectionalA.class, a.getId());
  
System.out.println("Retriving OneToMany Unidirectional A");
System.out.println(retrA);
  
System.out.println("Retriving OneToMany Unidirectional B's");
for (OneToManyUnidirectionalB origB : a.getB()) {
    OneToManyUnidirectionalB retrB
        = JPA.INSTANCE.get(
            OneToManyUnidirectionalB.class, origB.getId());
    System.out.println(retrB);
}

Generates:

Retriving OneToMany Unidirectional A
OneToManyUnidirectionalA{id: {1}, b: {[OneToManyUnidirectionalB{id: {1}, s: {BBB}}, OneToManyUnidirectionalB{id: {2}, s: {CCC}}]}, s: {AAA}}
Retriving OneToMany Unidirectional B's
OneToManyUnidirectionalB{id: {1}, s: {BBB}}
OneToManyUnidirectionalB{id: {2}, s: {CCC}}

Bidirectional

A owns the relationship:

@Entity
@AutoProperty
public class OneToManyBidirectionalA implements Serializable {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private long id;
 
    @OneToMany(cascade=CascadeType.ALL, mappedBy="a")
    private Collection<OneToManyBidirectionalB> b; 
 
    private String s;

    // Setters, Getters, Constructors, Pojomatic...

}


@Entity
@AutoProperty
public class OneToManyBidirectionalB implements Serializable {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private long id;

    @Property(policy=PojomaticPolicy.NONE) 
    @ManyToOne
    private OneToManyBidirectionalA a;

    // Setters, Getters, Constructors, Pojomatic...

}

The following:

OneToManyBidirectionalB b2 = new OneToManyBidirectionalB("BiBBB");
OneToManyBidirectionalB c2 = new OneToManyBidirectionalB("BiCCC");
  
Collection<OneToManyBidirectionalB> setB2
    = new ArrayList<OneToManyBidirectionalB>();
  
setB2.add(b2);
setB2.add(c2);

a2.setB(setB2);
b2.setA(a2);
c2.setA(a2);
  
JPA.INSTANCE.save(a2);
JPA.INSTANCE.clear();
  
OneToManyBidirectionalA retrA2
    = JPA.INSTANCE.get(OneToManyBidirectionalA.class, a2.getId());
  
System.out.println("Retriving OneToMany Bidirectional A");
System.out.println(retrA2);

System.out.println("Retriving OneToMany Bidirectional B's");
    for (OneToManyBidirectionalB origB : a2.getB()) {
        OneToManyBidirectionalB retrB
     = JPA.INSTANCE.get(
         OneToManyBidirectionalB.class, origB.getId());
        System.out.println(retrB);
}

Generates:

Retriving OneToMany Bidirectional A
OneToManyBidirectionalA{id: {1}, b: {[OneToManyBidirectionalB{id: {1}, s: {BiBBB}}, OneToManyBidirectionalB{id: {2}, s: {BiCCC}}]}, s: {BiAAA}}
Retriving OneToMany Bidirectional B's
OneToManyBidirectionalB{id: {1}, s: {BiBBB}}
OneToManyBidirectionalB{id: {2}, s: {BiCCC}}

The above examples are available from Github in the JPA directory. They rely on Pojomatic too. Some errors messages will be displayed because of a known and harmless issue.

JPA One-To-One Relationships (Unidirectional and Bidirectional)

This post illustrates simple one-to-one relationships between two classes.

Unidirectional

@Entity
@AutoProperty
public class OneToOneUnidirectionalA implements Serializable {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private long id;

    @OneToOne
    private OneToOneUnidirectionalB b;

    private String s;

    // Setters, Getters, Constructors, Pojomatic...

}


@Entity
@AutoProperty
public class OneToOneUnidirectionalB implements Serializable {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private long id;

    // No reference to OneToOneUnidirectionalA
    // since this is a unidirectional relationship

    private String s;

    // Setters, Getters, Constructors, Pojomatic...

}

The following:

OneToOneUnidirectionalA a = new OneToOneUnidirectionalA("AAA");
OneToOneUnidirectionalB b = new OneToOneUnidirectionalB("BBB");
  
a.setB(b);
  
JPA.INSTANCE.save(b);
JPA.INSTANCE.save(a);
JPA.INSTANCE.clear();
  
OneToOneUnidirectionalA retrA
    = JPA.INSTANCE.get(OneToOneUnidirectionalA.class, a.getId());
  
System.out.println("Retrieved OneToOne Unidirectional A:");
System.out.println(retrA);
System.out.println(retrA.getB());
  
OneToOneUnidirectionalB retrB
    = JPA.INSTANCE.get(OneToOneUnidirectionalB.class, b.getId());
  
System.out.println("Retrieved OneToOne Unidirectional B:");
System.out.println(retrB);

Generates:

Retrieved OneToOne Unidirectional A:
OneToOneUnidirectionalA{id: {1}, b: {OneToOneUnidirectionalB{id: {1}, s: {BBB}}}, s: {AAA}}
OneToOneUnidirectionalB{id: {1}, s: {BBB}}
Retrieved OneToOne Unidirectional B:
OneToOneUnidirectionalB{id: {1}, s: {BBB}}

Bidirectional

A owns the relationship. We need to avoid Pojomatic circular reference issues too:

@Entity
@AutoProperty
public class OneToOneBidirectionalA implements Serializable {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private long id;

    @Property(policy=PojomaticPolicy.NONE)
    @OneToOne
    private OneToOneBidirectionalB b;

    // Setters, Getters, Constructors, Pojomatic...

}


@Entity
@AutoProperty
public class OneToOneBidirectionalB implements Serializable {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private long id;

    @Property(policy=PojomaticPolicy.NONE)
    @OneToOne(mappedBy="b")
    private OneToOneBidirectionalA a;

    // Setters, Getters, Constructors, Pojomatic...

}

The following:

OneToOneBidirectionalA a2 = new OneToOneBidirectionalA("BiAAA");
OneToOneBidirectionalB b2 = new OneToOneBidirectionalB("BiBBB");
  
JPA.INSTANCE.save(b2);
JPA.INSTANCE.save(a2);
  
a2.setB(b2);
b2.setA(a2);
  
JPA.INSTANCE.update(b2);
JPA.INSTANCE.update(a2);
JPA.INSTANCE.clear();
  
OneToOneBidirectionalA retrA2
    = JPA.INSTANCE.get(OneToOneBidirectionalA.class, a2.getId());
  
System.out.println("Retrieved OneToOne Bidirectional A:");
System.out.println(retrA2 + " -> " + retrA2.getB());
  
OneToOneBidirectionalB retrB2
    = JPA.INSTANCE.get(OneToOneBidirectionalB.class, b2.getId());
  
System.out.println("Retrieved OneToOne Bidirectional B:");
System.out.println(retrB2 + " -> " + retrB2.getA());

Generates:

Retrieved OneToOne Bidirectional A:
OneToOneBidirectionalA{id: {1}, s: {BiAAA}} -> OneToOneBidirectionalB{id: {1}, s: {BiBBB}}
Retrieved OneToOne Bidirectional B:
OneToOneBidirectionalB{id: {1}, s: {BiBBB}} -> OneToOneBidirectionalA{id: {1}, s: {BiAAA}}

The above examples are available from Github in the JPA directory. They rely on Pojomatic too. Some errors messages will be displayed because of a known and harmless issue.