Onetomany manytoone bidrectional mapping

Question

How do I accomplish this;
Here is my code. I have both a onetoone where 1 telephone number is mandatory for 1 customer.
But the customer can have many telephone numbers other than the mandatory one.
Customer.java
package testonetoone;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collection;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.SequenceGenerator;
@Entity
@NamedQueries( { @NamedQuery(name = "Customer.findAll", query = "select o from Customer o") })
public class Customer implements Serializable {
@Id
@Column(name = "CUSTOMER_ID", nullable = false)
@GeneratedValue(generator = "CustomerSeq")
@SequenceGenerator(name = "CustomerSeq", sequenceName = "ISATS.CUSTOMER_SEQ", allocationSize = 1)
private BigDecimal customerId;
@Column(name = "CUSTOMER_NAME", length = 20)
private String customerName;
// @Column(name="PHONES_ID", nullable = false)
// private String phonesId;
@OneToOne(optional = false, cascade = CascadeType.ALL, fetch = FetchType.EAGER)
@JoinColumn(name = "PHONES_ID", unique = true, nullable = false, updatable = false)
private Phones telephoneNumber;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "customerTelephones", orphanRemoval = true, fetch = FetchType.EAGER)
// @JoinColumn(name = "PHONES_ID", unique = true, nullable = false, updatable = false)
private Collection<Phones> telephoneNumbersList = new ArrayList<Phones>();
public Customer() {
public BigDecimal getCustomerId() {
return customerId;
public void setCustomerId(BigDecimal customerId) {
this.customerId = customerId;
public String getCustomerName() {
return customerName;
public void setCustomerName(String customerName) {
this.customerName = customerName;
public void setTelephoneNumber(Phones telephoneNumber) {
this.telephoneNumber = telephoneNumber;
public Phones getTelephoneNumber() {
return telephoneNumber;
public void setTelephoneNumbersList(Collection<Phones> telephoneNumbersList) {
this.telephoneNumbersList = telephoneNumbersList;
public Collection<Phones> getTelephoneNumbersList() {
return telephoneNumbersList;
Phones.java
package testonetoone;
import java.io.Serializable;
import java.math.BigDecimal;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToOne;
import javax.persistence.SequenceGenerator;
@Entity
@NamedQueries( { @NamedQuery(name = "Phones.findAll", query = "select o from Phones o") })
public class Phones implements Serializable {
// @Column(name = "CUSTOMER_ID")
// private BigDecimal customerId;
@Id
@Column(name = "PHONES_ID", nullable = false)
@GeneratedValue(generator = "PhonesSeq")
@SequenceGenerator(name = "PhonesSeq", sequenceName = "ISATS.PHONES_SEQ", allocationSize = 1)
private BigDecimal phonesId;
@Column(name = "PHONE_NUMBER", length = 20)
private String phoneNumber;
@OneToOne(optional = false, cascade = CascadeType.ALL, fetch = FetchType.EAGER, mappedBy = "telephoneNumber")
// @JoinColumn(name = "CUSTOMER_ID", unique = true, nullable = false, insertable = false, updatable = false)
private Customer customer;
@ManyToOne(optional = false,cascade = CascadeType.ALL, fetch = FetchType.EAGER)
@JoinColumn(name = "CUSTOMER_ID", nullable = false)
private Customer customerTelephones;
public Phones() {
// public BigDecimal getCustomerId() {
// return customerId;
// public void setCustomerId(BigDecimal customerId) {
// this.customerId = customerId;
public BigDecimal getPhonesId() {
return phonesId;
public void setPhonesId(BigDecimal phonesId) {
this.phonesId = phonesId;
public String getPhoneNumber() {
return phoneNumber;
public void setPhoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
public void setCustomer(Customer customer) {
this.customer = customer;
// @JoinColumn(name = "CUSTOMER_ID", unique = true, nullable = false, insertable = false, updatable = false)
public Customer getCustomer() {
return customer;
public void setCustomerTelephones(Customer customerTelephones) {
this.customerTelephones = customerTelephones;
public Customer getCustomerTelephones() {
return customerTelephones;
testonetoone.java
package testonetoone;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.Persistence;
public class TestOneToOne {
public TestOneToOne() {
super();
public static void main(String[] args) {
TestOneToOne testOneToOne = new TestOneToOne();
EntityManager em = null;
em = Persistence.createEntityManagerFactory("TestOneToOne", new java.util.HashMap()).createEntityManager();
// 1) Create customer, create phones, set add mapping
// EntityManager em = emf.createEntityManager();
Phones p = new Phones();
p.setPhoneNumber("5716120001");
Customer c = new Customer();
c.setCustomerName("Toyota");
p.setCustomer(c);
c.setTelephoneNumber(p);
Phones p2 = new Phones();
p2.setPhoneNumber("5716120002");
List<Phones> telephoneNumbersList = new ArrayList<Phones>();
telephoneNumbersList.add(p2);
p2.setCustomer(c);
c.setTelephoneNumbersList(telephoneNumbersList);
// Query query = em.createQuery("SELECT e FROM CUSTOMER e");
// List<Customer> list = (List<Customer>) query.getResultList();
// System.out.println(list);
// query= em.createQuery("SELECT d FROM PHONES d");
// List<Phones> dlist = (List<Phones>) query.getResultList();
// System.out.println(dlist);
try {
em.getTransaction().begin();
em.persist(c);
em.flush();
em.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
} finally {
em.close();
}

Answer 1

This is not a bidirectional relationship (well, the OneToMany and ManyToOne form one), it is a circular reference. I am not sure how you can possibly do this in the database without making one of the foreign key fields nullable, or delaying constraint checking until the transaction completes.
Which ever relationship you make nullable will have to be set after the persist calls are flushed to the database. If you are able to delay constraint checking in the database, this isn't neccessary.
Best Regards,
Chris