Also Read

1. One To One Mapping

Let's create two entities/domains Employee and Department such that they have the following relation between them.

Department has-many Employees which means an Employee can belong to only one Department and a Department can have many Employee and Department is the owner of the relation between the two.

Owner of the relation means that Owner can exist without the dependent entity but dependent entity cannot stay without the owner entity.

Dependent Entity of Relationship will containes the 'foreign key' ID of the Owner entity. In this case, Address will contian the Employee Id in >its table as shown in the table structure below.

So a Department can exist without Employee but an Employee cannot be there without a Department. If you

1. on deleting an Employee, the Employee-Department mapping will be removed
2. on deleting a Department, all the employees in the department should be deleted.

Employee.java

package com.ekiras.domain;

import javax.persistence.*;
import java.util.Date;

/**
 * @author ekiras
 */
@Entity
public class Employee {

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

    @Temporal(TemporalType.TIMESTAMP)
    protected Date dateCreated;

    @Temporal(TemporalType.TIMESTAMP)
    protected Date lastUpdated;

    private String email;
    private String name;
    private String password;
    
    @OneToOne(mappedBy = "employee",optional = false,cascade = CascadeType.ALL)
    private Address address;

    @ManyToOne(fetch = FetchType.EAGER)
    private Department department;

    // getters and setters

Department.java

package com.ekiras.domain;

import javax.persistence.*;
import java.util.Date;
import java.util.List;

/**
 * @author ekiras
 */
@Entity
public class Department {

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

    @Temporal(TemporalType.TIMESTAMP)
    protected Date dateCreated;

    @Temporal(TemporalType.TIMESTAMP)
    protected Date lastUpdated;

    private String name;

    @OneToMany(cascade = CascadeType.ALL,mappedBy = "department", fetch = FetchType.LAZY)
    private List<Employee> employees;

    // getters and setters
}

Following Tables will be created from the Entities defined above.

mysql> show tables;
+-----------------------+
| Tables_in_jpa_mapping |
+-----------------------+
| address               |
| department            |
| employee              |
+-----------------------+
3 rows in set (0.00 sec)

mysql> desc employee;
+---------------+--------------+------+-----+---------+----------------+
| Field         | Type         | Null | Key | Default | Extra          |
+---------------+--------------+------+-----+---------+----------------+
| id            | bigint(20)   | NO   | PRI | NULL    | auto_increment |
| date_created  | datetime     | YES  |     | NULL    |                |
| email         | varchar(255) | YES  |     | NULL    |                |
| last_updated  | datetime     | YES  |     | NULL    |                |
| name          | varchar(255) | YES  |     | NULL    |                |
| password      | varchar(255) | YES  |     | NULL    |                |
| department_id | bigint(20)   | YES  | MUL | NULL    |                |
+---------------+--------------+------+-----+---------+----------------+
7 rows in set (0.00 sec)

mysql> desc department;
+--------------+--------------+------+-----+---------+----------------+
| Field        | Type         | Null | Key | Default | Extra          |
+--------------+--------------+------+-----+---------+----------------+
| id           | bigint(20)   | NO   | PRI | NULL    | auto_increment |
| date_created | datetime     | YES  |     | NULL    |                |
| last_updated | datetime     | YES  |     | NULL    |                |
| name         | varchar(255) | YES  |     | NULL    |                |
+--------------+--------------+------+-----+---------+----------------+
4 rows in set (0.00 sec)

mysql> desc address;
+--------------+--------------+------+-----+---------+----------------+
| Field        | Type         | Null | Key | Default | Extra          |
+--------------+--------------+------+-----+---------+----------------+
| id           | bigint(20)   | NO   | PRI | NULL    | auto_increment |
| address      | varchar(255) | YES  |     | NULL    |                |
| date_created | datetime     | YES  |     | NULL    |                |
| last_updated | datetime     | YES  |     | NULL    |                |
| employee_id  | bigint(20)   | YES  | MUL | NULL    |                |
+--------------+--------------+------+-----+---------+----------------+
5 rows in set (0.01 sec)

Following are the images that show the working of the One-To-Many mapping.

List of Departments

Adding Employee

Employee Details

List of all Employees

List of Employees in a Department

Also Read

1. One To Many Mapping

Let's create two classes Employee and Address, such that they have the following relation between them.

Employee has-a Address which means a one-to-one mapping between the two and Employee is the owner of the relation.

1. Owner of the relation means that Owner can exist without the dependent entity but dependent entity cannot stay without the owner entity.
2. Dependent Entity of Relationship will containes the 'foreign key' ID of the Owner entity. In this case, Address will contian the Employee Id in its table as shown in the table structure below.

This means that Employee can stay without an Address but Address cannot stay without the Employee. In even more simpler words, If employee is deleted his address should also be deleted, but if address is deleted employee should not be deleted.

Employee.java

package com.ekiras.domain;

import javax.persistence.*;
import java.util.Date;

/**
 * @author ekiras
 */
@Entity
public class Employee {

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

    @Temporal(TemporalType.TIMESTAMP)
    protected Date dateCreated;

    @Temporal(TemporalType.TIMESTAMP)
    protected Date lastUpdated;

    private String email;
    private String name;
    private String password;
    
    @OneToOne(mappedBy = "employee",optional = false,cascade = CascadeType.ALL)
    private Address address;


    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", dateCreated=" + dateCreated +
                ", lastUpdated=" + lastUpdated +
                ", email='" + email + '\'' +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
    // getters and setters
}

Address.java

package com.ekiras.domain;

import javax.persistence.*;
import java.util.Date;

/**
 * @author ekiras
 */
@Entity
public class Address {

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

    @Temporal(TemporalType.TIMESTAMP)
    protected Date dateCreated;

    @Temporal(TemporalType.TIMESTAMP)
    protected Date lastUpdated;

    private String address;

    @OneToOne(fetch = FetchType.LAZY)
    private Employee employee;

    @Override
    public String toString() {
        return "Address{" +
                "id=" + id +
                ", dateCreated=" + dateCreated +
                ", lastUpdated=" + lastUpdated +
                ", address='" + address + '\'' +
                ", employee=" + employee +
                '}';
    }
    // getters and setters
}

Following Tables will be created from the Entities defined above.

mysql> show tables;
+-----------------------+
| Tables_in_jpa_mapping |
+-----------------------+
| address               |
| employee              |
+-----------------------+
2 rows in set (0.00 sec)

mysql> desc employee;
+--------------+--------------+------+-----+---------+----------------+
| Field        | Type         | Null | Key | Default | Extra          |
+--------------+--------------+------+-----+---------+----------------+
| id           | bigint(20)   | NO   | PRI | NULL    | auto_increment |
| date_created | datetime     | YES  |     | NULL    |                |
| email        | varchar(255) | YES  |     | NULL    |                |
| last_updated | datetime     | YES  |     | NULL    |                |
| name         | varchar(255) | YES  |     | NULL    |                |
| password     | varchar(255) | YES  |     | NULL    |                |
+--------------+--------------+------+-----+---------+----------------+
6 rows in set (0.00 sec)

mysql> desc address;
+--------------+--------------+------+-----+---------+----------------+
| Field        | Type         | Null | Key | Default | Extra          |
+--------------+--------------+------+-----+---------+----------------+
| id           | bigint(20)   | NO   | PRI | NULL    | auto_increment |
| address      | varchar(255) | YES  |     | NULL    |                |
| date_created | datetime     | YES  |     | NULL    |                |
| last_updated | datetime     | YES  |     | NULL    |                |
| employee_id  | bigint(20)   | YES  | MUL | NULL    |                |
+--------------+--------------+------+-----+---------+----------------+
5 rows in set (0.00 sec)

You can save the object's as shown in the example below

    public void test(){
    
        // create employee object
        Employee employee = new Employee();
        employee.setName("Ekansh");
        employee.setEmail("ekansh@ekiras.com");
        employee.setPassword("pwd");

        // create Address object
        Address address = new Address();
        address.setAddress("Some Address");

        employee.setAddress(address);
        
        // actual save call for the object
        employeeRepository.save(employee);

    } 

Following are the images that show the working of the One-TO-One mapping.

Points To Remember

1. Your Parent class should be annotated with @MappedSuperclass.
2. Follow the Tutorial : How to handle Inheritence with Entities to know how to wrap common properties of entities to a base class.
3. To override any property you must
   a. Apply the @AttributeOverride annotation on the class that need to override the property
   b. set name property of @AttributeOverride as the name of the field in super class.
   c. set the column property of @AttributeOverride to override the column definition of the attribute.

Let's say our Base class looks as follows

package com.ekiras.domain.base;

import javax.persistence.*;
import java.util.Date;

/**
* @author ekiras
*/
@MappedSuperclass
public abstract class BaseDomain {

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

  @Temporal(TemporalType.TIMESTAMP)
  protected Date dateCreated;

  @Temporal(TemporalType.TIMESTAMP)
  protected Date lastUpdated;

  @Override
  public String toString() {
      return "BaseDomain{" +
              "id=" + id +
              ", dateCreated=" + dateCreated +
              ", lastUpdated=" + lastUpdated +
              '}';
  }
  // getters and setters
}

We can override the id field of the BaseDomain class in inheriting class as follows

package com.ekiras.domain;

import com.ekiras.domain.base.BaseDomain;

import javax.persistence.AttributeOverride;
import javax.persistence.Column;
import javax.persistence.Entity;

/**
 * @author ekiras
 */
@Entity
@AttributeOverride(name = "id",column = @Column(name = "userId"))
public class User extends BaseDomain{

    private String email;
    private String name;
    private String password;

    // getters and setters
}

As shown in the code above we have used @AttributeOverride

@AttributeOverride(name = "id",column = @Column(name = "userId"))

Here, name= "id" states that we are going to override the mapping for the id field of the super class. column = @Column(name = "userId") states the new configuration of the id defined in the super class. Here we simple change the name of the column for table user defined by class User.

This will create the table user as shown below.

mysql> show tables;
+-----------------------+
| Tables_in_jpa_mapping |
+-----------------------+
| user                  |
+-----------------------+
1 row in set (0.00 sec)

mysql> desc user;
+--------------+--------------+------+-----+---------+----------------+
| Field        | Type         | Null | Key | Default | Extra          |
+--------------+--------------+------+-----+---------+----------------+
| user_id      | bigint(20)   | NO   | PRI | NULL    | auto_increment |
| date_created | datetime     | YES  |     | NULL    |                |
| last_updated | datetime     | YES  |     | NULL    |                |
| email        | varchar(255) | YES  |     | NULL    |                |
| name         | varchar(255) | YES  |     | NULL    |                |
| password     | varchar(255) | YES  |     | NULL    |                |
+--------------+--------------+------+-----+---------+----------------+
6 rows in set (0.00 sec)

@AttributeOverride

May be applied to an entity that extends a mapped superclass or to an embedded field or
property to override a basic mapping or id mapping defined by the mapped superclass or embeddable class (or embeddable class of one of its attributes).

May be applied to an element collection containing instances of an embeddable class or to a map collection whose key and/or value is an embeddable class. When AttributeOverride is applied to a map, "key." or "value." must be used to prefix the name of the attribute that is being overridden in order to specify it as part of the map key or map value.

To override mappings at multiple levels of embedding, a dot (".") notation form must be used in the name element to indicate an attribute within an embedded attribute. The value of each identifier used with the dot notation is the name of the respective embedded field or property.

Also Read

1. How to handle inheritance with Entities

Points to Remember

1. Mark your Base Entity class with annotation @MappedSuperclass.
2. Define all common fields and their getter setters in this class.
3. Make the base class abstract.
4. Make all fields as protected so that they can be accessed in inheriting class without getters and setter.
5. You can also define @PrePersist and @PreUpdate in this class.

Fields that should be in the Base Entity

Your Base Entity class should have only those field that need to be common for all your entities that will inherit this class.
Sample Base Entity that you should use might look as follows

package com.ekiras.domain.base;

import javax.persistence.*;
import java.util.Date;

/**
 * @author ekiras
 */
@MappedSuperclass
public class BaseDomain {

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

    @Temporal(TemporalType.TIMESTAMP)
    protected Date dateCreated;

    @Temporal(TemporalType.TIMESTAMP)
    protected Date lastUpdated;

    @Override
    public String toString() {
        return "BaseDomain{" +
                "id=" + id +
                ", dateCreated=" + dateCreated +
                ", lastUpdated=" + lastUpdated +
                '}';
    }
    

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public Date getDateCreated() {
        return dateCreated;
    }

    public void setDateCreated(Date dateCreated) {
        this.dateCreated = dateCreated;
    }

    public Date getLastUpdated() {
        return lastUpdated;
    }

    public void setLastUpdated(Date lastUpdated) {
        this.lastUpdated = lastUpdated;
    }
}

In the above BaseDomain class we have marked it with annotation @MappedSuperclass. This will enforce that no table is created for this class in the database.

@MappedSuperclass

A class designated with the MappedSuperclass annotation can be mapped in the same way as an entity except that the mappings will apply only to its subclasses since no table exists for the mapped superclass itself. When applied to the subclasses the inherited mappings will apply in the context of the subclass tables.

Now, let us inherit this base class in the User Entity class. So the User.java class may be as follows

package com.ekiras.domain;

import com.ekiras.domain.base.BaseDomain;

import javax.persistence.Entity;

/**
 * @author ekiras
 */
@Entity
public class User extends BaseDomain{

    private String email;
    private String name;
    private String password;

    @Override
    public String toString() {
        return super.toString()+" :: User{" +
                "email='" + email + '\'' +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

When we will run the project it will create the following table in the database.

mysql> show tables;
+-----------------------+
| Tables_in_jpa_mapping |
+-----------------------+
| user                  |
+-----------------------+
1 row in set (0.00 sec)

mysql> desc user;
+--------------+--------------+------+-----+---------+----------------+
| Field        | Type         | Null | Key | Default | Extra          |
+--------------+--------------+------+-----+---------+----------------+
| id           | bigint(20)   | NO   | PRI | NULL    | auto_increment |
| date_created | datetime     | YES  |     | NULL    |                |
| last_updated | datetime     | YES  |     | NULL    |                |
| email        | varchar(255) | YES  |     | NULL    |                |
| name         | varchar(255) | YES  |     | NULL    |                |
| password     | varchar(255) | YES  |     | NULL    |                |
+--------------+--------------+------+-----+---------+----------------+
6 rows in set (0.01 sec)

This shows that,

1. No table is created for the BaseDomain class.
2. All the field od the BaseDmain class are included in the inherting class User.