Bidirectional @oneToOne example

@Entity
public class EntityA {
  @Id
  @GeneratedValue
  private int myIdA;
  @OneToOne
  private EntityB refEntityB;
    .............
  @Override
  public String toString() {
      return "EntityA{" +
              "myIdA=" + myIdA +
              '}';
  }
  //getters/setters
}

@Entity
public class EntityB {
  @Id
  @GeneratedValue
  private int myIdB;
  @OneToOne(mappedBy = "refEntityB")
  private EntityA refEntityA;
  private String str;
    .............
  @Override
  public String toString() {
      return "EntityB{" +
              "myIdB=" + myIdB +
              ", str='" + str + '\'' +
              '}';
  }
  //getters/setters
}

public class ExampleMain {

  public static void main(String[] args) {
      EntityManagerFactory emf = Persistence.createEntityManagerFactory("test1");
      EntityManager em = emf.createEntityManager();
      try {
          nativeQuery(em, "SHOW TABLES");
          nativeQuery(em, "SHOW COLUMNS from EntityA");
          nativeQuery(em, "SHOW COLUMNS from EntityB");

      } finally {
          em.close();
          emf.close();
      }
  }

  public static void nativeQuery(EntityManager em, String s) {
      System.out.printf("---------------------------%n'%s'%n", s);
      Query query = em.createNativeQuery(s);
      List list = query.getResultList();
      for (Object o : list) {
          if (o instanceof Object[]) {
              System.out.println(Arrays.toString((Object[]) o));
          } else {
              System.out.println(o);
          }
      }
  }
}

Output

---------------------------
'SHOW TABLES'
[ENTITYA, PUBLIC]
[ENTITYB, PUBLIC]
---------------------------
'SHOW COLUMNS from EntityA'
[MYIDA, INTEGER(10), NO, PRI, NULL]
[REFENTITYB_MYIDB, INTEGER(10), YES, , NULL]
---------------------------
'SHOW COLUMNS from EntityB'
[MYIDB, INTEGER(10), NO, PRI, NULL]
[STR, VARCHAR(255), YES, , NULL]

H2 database SHOW statements

Following diagram gives a quick overview of the bidirectional relationship:

Persisting data

public class ExampleMain2 {

  public static void main(String[] args) {
      EntityManagerFactory emf = Persistence.createEntityManagerFactory("test1");
      try {
          persistEntity(emf);
          nativeQueries(emf);
          loadEntityA(emf);
          loadEntityB(emf);
      } finally {
          emf.close();
      }
  }

  private static void nativeQueries(EntityManagerFactory emf) {
      EntityManager em = emf.createEntityManager();
      ExampleMain.nativeQuery(em, "Select * from EntityA");
      ExampleMain.nativeQuery(em, "Select * from EntityB");
  }

  private static void persistEntity(EntityManagerFactory emf) {
      System.out.println("-- Persisting entities --");
      EntityManager em = emf.createEntityManager();
      EntityA entityA = new EntityA();
      EntityB entityB = new EntityB();
      entityB.setStr("testStringB");
      entityB.setRefEntityA(entityA);
      entityA.setRefEntityB(entityB);

      em.getTransaction().begin();
      em.persist(entityA);
      em.persist(entityB);
      em.getTransaction().commit();

      em.close();
  }

  private static void loadEntityA(EntityManagerFactory emf) {
      System.out.println("-- Loading EntityA --");
      EntityManager em = emf.createEntityManager();
      EntityA entityA = em.find(EntityA.class, 1);
      System.out.println(entityA);
      System.out.println(entityA.getEntityB());
      em.close();
  }

  private static void loadEntityB(EntityManagerFactory emf) {
      System.out.println("-- Loading EntityB --");
      EntityManager em = emf.createEntityManager();
      EntityB entityB = em.find(EntityB.class, 2);
      System.out.println(entityB);
      System.out.println(entityB.getRefEntityA());
      em.close();
  }
}

Output

-- Persisting entities --
---------------------------
'Select * from EntityA'
[1, 2]
---------------------------
'Select * from EntityB'
[2, testStringB]
-- Loading EntityA --
EntityA{myIdA=1}
EntityB{myIdB=2, str='testStringB'}
-- Loading EntityB --
EntityB{myIdB=2, str='testStringB'}
EntityA{myIdA=1}

Note that in above example, we didn't have to 'find' EntityA and it's reference EntityB separately . Loading the 'owner' entity will load the other one as well. The same is true for the reverse association.

Bidirectional @OneToOne without specifying 'mappedBy'

What will happen, if we don't use 'mappedBy' on the reverse side? Let's try that out.

@Entity
public class EntityC {
  @Id
  @GeneratedValue
  private int myIdC;
  @OneToOne
  private EntityD refEntityD;
    .............
  @Override
  public String toString() {
      return "EntityC{" +
              "myIdC=" + myIdC +
              '}';
  }
  //getters/setters
}

@Entity
public class EntityD {
  @Id
  @GeneratedValue
  private int myIdD;
  @OneToOne
  private EntityC refEntityC;
  private String str;
    .............
  @Override
  public String toString() {
      return "EntityD{" +
              "myIdD=" + myIdD +
              ", str='" + str + '\'' +
              '}';
  }
  //getters/setters
}

public class ExampleMain3 {

  public static void main(String[] args) {
      EntityManagerFactory emf = Persistence.createEntityManagerFactory("test2");
      EntityManager em = emf.createEntityManager();
      try {
          ExampleMain.nativeQuery(em, "SHOW TABLES");
          ExampleMain.nativeQuery(em, "SHOW COLUMNS from EntityC");
          ExampleMain.nativeQuery(em, "SHOW COLUMNS from EntityD");

      } finally {
          em.close();
          emf.close();
      }
  }
}

Output

---------------------------
'SHOW TABLES'
[ENTITYC, PUBLIC]
[ENTITYD, PUBLIC]
---------------------------
'SHOW COLUMNS from EntityC'
[MYIDC, INTEGER(10), NO, PRI, NULL]
[REFENTITYD_MYIDD, INTEGER(10), YES, , NULL]
---------------------------
'SHOW COLUMNS from EntityD'
[MYIDD, INTEGER(10), NO, PRI, NULL]
[STR, VARCHAR(255), YES, , NULL]
[REFENTITYC_MYIDC, INTEGER(10), YES, , NULL]

Both sides generated tables which have their own foreign key columns and both are cross referencing each other. This is bad as per good database design principles.

Let's persist and load data:

public class ExampleMain4 {

  public static void main(String[] args) {
      EntityManagerFactory emf = Persistence.createEntityManagerFactory("test2");
      try {
          persistEntity(emf);
          nativeQueries(emf);
          loadEntityC(emf);
          loadEntityD(emf);
      } finally {
          emf.close();
      }
  }

  private static void nativeQueries(EntityManagerFactory emf) {
      EntityManager em = emf.createEntityManager();
      ExampleMain.nativeQuery(em, "Select * from EntityC");
      ExampleMain.nativeQuery(em, "Select * from EntityD");
  }

  private static void persistEntity(EntityManagerFactory emf) {
      System.out.println("-- Persisting entities --");
      EntityManager em = emf.createEntityManager();
      EntityC entityC = new EntityC();
      EntityD entityD = new EntityD();
      entityD.setStr("testStringD");
      entityC.setRefEntityD(entityD);
      entityD.setRefEntityC(entityC);

      em.getTransaction().begin();
      em.persist(entityC);
      em.persist(entityD);
      em.getTransaction().commit();

      em.close();
  }

  private static void loadEntityC(EntityManagerFactory emf) {
      System.out.println("-- Loading EntityC --");
      EntityManager em = emf.createEntityManager();
      EntityC entityC = em.find(EntityC.class, 1);
      System.out.println(entityC);
      System.out.println(entityC.getEntityD());
      em.close();
  }

  private static void loadEntityD(EntityManagerFactory emf) {
      System.out.println("-- Loading EntityD --");
      EntityManager em = emf.createEntityManager();
      EntityD entityD = em.find(EntityD.class, 2);
      System.out.println(entityD);
      System.out.println(entityD.getRefEntityC());
      em.close();
  }
}

Output

-- Persisting entities --
---------------------------
'Select * from EntityC'
[1, 2]
---------------------------
'Select * from EntityD'
[2, testStringD, 1]
-- Loading EntityC --
EntityC{myIdC=1}
EntityD{myIdD=2, str='testStringD'}
-- Loading EntityD --
EntityD{myIdD=2, str='testStringD'}
EntityC{myIdC=1}

Example Project

Dependencies and Technologies Used:

• h2 1.4.193: H2 Database Engine.
• hibernate-core 5.2.8.Final: The core O/RM functionality as provided by Hibernate.
  Implements javax.persistence:javax.persistence-api version 2.1
• JDK 1.8
• Maven 3.3.9