One to Many Hibernate/JPA example

In this article we will learn how to implement a One to Many Entity Relation between two objects in an Hibernate/JPA application.

One to Many overview

In RDBMS terms, a one-to-many relationship exists when one record in table A may be linked with many records in table B. On the other hand, one record in table B is linked to only one Record in table A.

Here’s an example which uses a One-to-Many mapping between the Table Customer (ONE) and Request (MANY).

For the sake of simplicity, we will use H2 Database in our example application. On the other hand, if you want to use an external DB like MySQL, you can create the following Table structure for the example:

mysql> desc customer;
+--------------+--------------+------+-----+---------+----------------+
| Field        | Type         | Null | Key | Default | Extra          |
+--------------+--------------+------+-----+---------+----------------+
| id           | int(11)      | NO   | PRI | NULL    | auto_increment |
| name         | varchar(25)  | YES  |     | NULL    |                |
| phone_number | int(11)      | YES  |     | NULL    |                |
| address      | varchar(100) | YES  |     | NULL    |                |
| email        | varchar(50)  | YES  |     | NULL    |                |
+--------------+--------------+------+-----+---------+----------------+
5 rows in set (0.07 sec)

mysql> desc request;
+-------------+---------+------+-----+---------+----------------+
| Field       | Type    | Null | Key | Default | Extra          |
+-------------+---------+------+-----+---------+----------------+
| id          | int(11) | NO   | PRI | NULL    | auto_increment |
| quantity    | int(11) | YES  |     | NULL    |                |
| id_customer | int(11) | YES  | MUL | NULL    |                |
+-------------+---------+------+-----+---------+----------------+

Coding the Entity Classes

To represent the One to Many Relation, we will create two Entity Classes in our project. Here’s the Customer class:

@Entity

public class Customer implements Serializable {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Long id;

    @NotNull
    private String name;

    @NotNull
    private String email;

    @NotNull
    private String address;

    @NotNull
    @Column(name = "phone_number")
    private String phoneNumber;
  
    //bi-directional many-to-one association to Request
    @OneToMany(mappedBy="customer", cascade = CascadeType.ALL,  orphanRemoval = true)
    private List<Request> requests = new ArrayList();
 
  // getters/setters omitted for brevity
}

Next, let’s add also the Request class:

@Entity

public class Request implements Serializable {
 
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Long id;

    @Column
    private int quantity;

    //bi-directional many-to-one association to Customer
    @ManyToOne
    private Customer customer;
 
}

As you can see, in this example the Bidirectional Many to One annotation is explicit also in the target Entity Class.

We can persist and fetch data with this simple Stateless Bean:

@Stateless

public class ServiceBean {

    @PersistenceContext
    private EntityManager em;

    public String create() {
        Customer customer = new Customer();
        customer.setAddress("15th Avenue New York");
        customer.setName("John Smith");
        customer.setPhoneNumber("328/1145678");
        customer.setEmail("johnsmith@gmail.com");

        Request request = new Request();
        request.setCustomer(customer);
        request.setQuantity(125);

        List<Request> list = new ArrayList();
        list.add(request);

        customer.setRequests(list);
        em.persist(customer);

        return "Created!";
    }

    public List<Request> findAll() {

        Query query = em.createQuery("FROM Request");
        List<Request> list = query.getResultList();
        return list;

    }

}

In order to use the default H2 Database, we will include in the persistence.xml a reference to the ExampleDS Datasource:

<persistence-unit name="primary">
        <jta-data-source>java:jboss/datasources/ExampleDS</jta-data-source>
        <properties>
            <!-- Properties for Hibernate -->
            <property name="hibernate.hbm2ddl.auto" value="create-drop" />
            <property name="hibernate.show_sql" value="true" />
        </properties>
</persistence-unit>

AnnotationException: @Column(s) not allowed on a @ManyToOne property

This error can happen if you use @JoinColumn and @Column annotation together.

@ManyToOne
@Column(name="CustomerFK")
private Customer customer;

It will return the following error:

org.hibernate.AnnotationException: @Column(s) not allowed on a @ManyToOne property

You can apply the JPA @Column annotation only for basic entity attributes (e.g. String, Integer, Date) if the entity attribute name differs from the underlying column name.

In the above example, you should rather use the @JoinColumn annotation:

@ManyToOne(fetch=FetchType.LAZY)
@JoinColumn(name="CustomerFK")
private Customer customer;

The @JoinColumn annotation allows to customize a Foreign Key column name, and it can only be used with an entity association.

Source code for this tutorial is available here: https://github.com/fmarchioni/mastertheboss/tree/master/hibernate/OneToMany