How oneToMany relationship will look on a ERD diagram?

How OneToMany relationship will look on sql tables creation statements?

The below is the sql statement which shows on how to make oneToMany relationship tables. But we won’t be needing this. The persistence.xml used for this exercise is configured to create the table based on the annotated classes.

create table `Country` (
    `country_id` INT(5) not null primary key auto_increment,
    `name` VARCHAR(100),
    `currency` VARCHAR(30)
)
 
create table `citizen` (
    `citizen_id` INT(14) not null primary key auto_increment,
    `name` varchar(100),
    `address` varchar(200),
    `nationality` int(5) not null,
    Foreign key(nationality) references `country` (country_id)
)

How to code oneToMany relationship using javax.persistence.api annotation?

There has been 3 classes created for this:

1. Citizen.java

   : represent the citizen table. Many citizen can belong to one country. citizen has many to one relationship with country.

   package org.world.entity;
   
   import javax.persistence.Column;
   import javax.persistence.Entity;
   import javax.persistence.Id;
   import javax.persistence.JoinColumn;
   import javax.persistence.Column;
   import javax.persistence.ManyToOne;
   
   /**
    * @see http://docs.oracle.com/javaee/6/api/javax/persistence/Entity.html
    */
   @Entity(name = "citizen")
   public class Citizen implements java.io.Serializable {
   
       /**
        * @see http://docs.oracle.com/javaee/6/api/javax/persistence/Id.html
        * @see http://docs.oracle.com/javaee/6/api/javax/persistence/Column.html
        */
       @Id
       @Column(insertable=true, unique=true, length=225, updatable=true)
       private Integer citizen_id;
   
       /**
        * @see http://docs.oracle.com/javaee/6/api/javax/persistence/ManyToOne.html
        * @see http://docs.oracle.com/javaee/6/api/javax/persistence/JoinColumn.html
        */
       @ManyToOne
       @JoinColumn(name = "country_id")
       private Country country;
       @Column
       private String name;
       @Column
       private String address;
   
       public Citizen() {
       }
   
       public Integer getCitizen_id() {
           return citizen_id;
       }
   
       public void setCitizen_id(Integer citizen_id) {
           this.citizen_id = citizen_id;
       }
   
       public Country getCountry() {
           return country;
       }
   
       public void setCountry(Country country) {
           this.country = country;
       }
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public String getAddress() {
           return address;
       }
   
       public void setAddress(String address) {
           this.address = address;
       }
   }
   

2. Country.java

   : represent country table. One country have many citizen, hence country has one to many relationship with citizen table.

   package org.world.entity;
   
   import java.util.Set;
   import javax.persistence.CascadeType;
   import javax.persistence.Column;
   import javax.persistence.Entity;
   import javax.persistence.Id;
   import javax.persistence.OneToMany;
   
   @Entity
   public class Country implements java.io.Serializable {
   
       @Id
       @Column(name="country_id")
       private Integer country_id;
       
       /**
        * @See http://docs.oracle.com/javaee/6/api/javax/persistence/OneToMany.html"
        */
       @OneToMany(cascade={CascadeType.ALL}, mappedBy = "country")
       private Set citizen;
   
       @Column
       String name;
   
       @Column
       String currency;
   
       public Country(){}
   
       public String getCurrency() {
           return currency;
       }
   
       public void setCurrency(String currency) {
           this.currency = currency;
       }
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public Integer getCountry_id() {
           return country_id;
       }
   
       public void setCountry_id(Integer country_id) {
           this.country_id = country_id;
       }
   
       public Set getCitizen() {
           return citizen;
       }
   
       public void setCitizen(Set citizen) {
           this.citizen = citizen;
       }
   }
   

3. PersistentOperator.java

   : This class has the java main method which creates and inserts mock data into citizen and country tables.

   package org.world.manager;
   
   import org.world.entity.Citizen;
   import org.world.entity.Country;
   import javax.persistence.EntityManager;
   import javax.persistence.EntityManagerFactory;
   import javax.persistence.EntityTransaction;
   import javax.persistence.Persistence;
   
   public class PersistentOperator {
       /**
        * @See http://docs.oracle.com/javaee/6/api/javax/persistence/EntityManagerFactory.html
        * @See http://docs.oracle.com/javaee/6/api/javax/persistence/Persistence.html
        * @See http://docs.oracle.com/javaee/6/api/javax/persistence/EntityManager.html
        */
       EntityManagerFactory emf = Persistence.createEntityManagerFactory("JpaExample");
       EntityManager em;
   
       public void insert() {
   
           //--------------Sample data --------------
           Citizen citizen1 = new Citizen();
           Citizen citizen2 = new Citizen();
           Citizen citizen3 = new Citizen();
           Citizen citizen4 = new Citizen();
   
           Country country1 = new Country();
           country1.setCountry_id(123);
           country1.setName("Brazil");
           country1.setCurrency("Brazilian real");
   
           Country country2 = new Country();
           country2.setCountry_id(234);
           country2.setName("Ghana");
           country2.setCurrency("Ghana cedi");
   
           citizen1.setName("William");
           citizen1.setCitizen_id(345);
           citizen1.setCountry(country1);
           citizen1.setAddress("No 1, Street 1.");
   
           citizen2.setName("Sophie");
           citizen2.setCitizen_id(456);
           citizen2.setCountry(country1);
           citizen2.setAddress("No 2, Street 2.");
   
           citizen3.setName("Julia");
           citizen3.setCitizen_id(567);
           citizen3.setCountry(country2);
           citizen3.setAddress("No 3, Street 3.");
   
           citizen4.setName("Len");
           citizen4.setCitizen_id(678);
           citizen4.setCountry(country2);
           citizen4.setAddress("No 4, Street 4.");
   
           //--------------Sample data --------------
   
           em = emf.createEntityManager();
           EntityTransaction entityTransaction = em.getTransaction();
   
           try {
               entityTransaction.begin();
   
               em.persist(country1);
               em.persist(country2);
               em.persist(citizen1);
               em.persist(citizen2);
               em.persist(citizen3);
               em.persist(citizen4);
   
               entityTransaction.commit();
           } catch (Exception e) {
               e.printStackTrace();
               entityTransaction.rollback();
           }
       }
   
       public static void main(String[] args) {
           PersistentOperator po = new PersistentOperator();
   
           po.insert();
       }
   }
   

The configuration is managed in persistence.xml file:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" 
             xmlns="http://java.sun.com/xml/ns/persistence" 
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
  <persistence-unit name="JpaExample" transaction-type="RESOURCE_LOCAL">
    <provider>org.hibernate.ejb.HibernatePersistence</provider>
    <class>org.world.entity.Citizen</class>
    <class>org.world.entity.Country</class>
    <properties>
      <property name="hibernate.connection.username" value="root"/>
      <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver"/>
      <property name="hibernate.connection.password" value=""/>
      <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/world?zeroDateTimeBehavior=convertToNull"/>
      <property name="hibernate.cache.provider_class" value="org.hibernate.cache.NoCacheProvider"/>
      <property name="hibernate.hbm2ddl.auto" value="create-drop"/>
    </properties>
  </persistence-unit>
</persistence>

For this exercise, mysql database has been used. Once the PersistentOperator.java class was run, data will be populated into world database schema. The world database has to be created in mysql before running PersistetOperator.java. But the table is not necessarily has to be created. It won’t harm if the tables were already exist as well. The data in the tables would look like below.

Country table:

country_id	currency	name
123	Brazil real	Brazil
234	Ghana cedi	Ghana

Citizen table:

citizen_id	address	name	country_id
345	No 1, Street 1.	William	123
456	No 2, Street 2.	Sophie	123
567	No 3, Street 3.	Julia	234
678	No 4, Street 4.	Len	234

End.

References:

• http://stackoverflow.com/questions/10145321/one-to-many-relationship-in-database-design-concept
• http://office.microsoft.com/en-001/training/table-that-data-RZ006149432.aspx?section=25
• http://www.teach-ict.com/as_a2_ict_new/ocr/AS_G061/315_database_concepts/attributes_entities/miniweb/pg7.htm
• http://www.javaworld.com/javaworld/jw-01-2008/jw-01-jpa2.html

NOTE! The sample maven project used for this exercise can be downloaded from jpa-world