Project to Implement One-To-One Mapping in JPA

Step 1: Create the new JPA project using the IntelliJ Idea named jpa-one-to-one-mapping. After creating the project, the file structure looks like the below image.

file structure


Step 2: Open the pom.xml and add the below dependencies into the project.

        <dependency>
<groupId>org.hibernate.orm</groupId>
<artifactId>hibernate-core</artifactId>
<version>6.0.2.Final</version>
</dependency>
<dependency>
<groupId>org.glassfish.jaxb</groupId>
<artifactId>jaxb-runtime</artifactId>
<version>3.0.2</version>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.28</version>
</dependency>


Step 3: Open the persistence.xml and put the below code into the project and it can configure the database of the project.

XML
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<persistence xmlns="https://jakarta.ee/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="https://jakarta.ee/xml/ns/persistence https://jakarta.ee/xml/ns/persistence/persistence_3_0.xsd"
             version="3.0">
    <persistence-unit name="jpa-example">

        <properties>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/example"/>
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value=""/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/>
            <property name="hibernate.hbm2ddl.auto" value="update"/>
        </properties>

    </persistence-unit>
</persistence>


Step 4: Create the Java package named as the model in that package create the Java class named as the Person. Go to src > main > java > model > Person and put the below code.

Java
package model;

import jakarta.persistence.*;

@Entity
public class Person {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @OneToOne(mappedBy = "person", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private Address address;

    // Constructors, getters, and setters
    public Person() {}

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }
}


Step 5: Create the Java package named as the model in that package create the Java class named as the Address. Go to src > main > java > model > Address and put the below code.

Java
package model;

import jakarta.persistence.*;

@Entity
public class Address {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @OneToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "person_id")
    private Person person;

    private String city;

    // Constructors, getters, and setters
    public Address() {}

    public Long getId() {
        return id;
    }

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

    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }
}


Step 6: Create the Java class named as the MainApplication. Go to src > main > java > MainApplication and put the below code.

Java
import jakarta.persistence.*;
import model.Address;
import model.Person;

public class MainApplication {
    public static void main(String[] args) {
        // Create EntityManagerFactory
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("jpa-example");
        EntityManager em = emf.createEntityManager();

        // Begin transaction
        em.getTransaction().begin();

        // Create a person
        Person person = new Person();
        person.setName("Mahesh");
        em.persist(person);

        // Create an address
        Address address = new Address();
        address.setPerson(person);
        address.setCity("Hyderabad");
        em.persist(address);

        // Commit transaction
        em.getTransaction().commit();

        // Retrieve person and address
        Person retrievedPerson = em.find(Person.class, person.getId());

        // Check if person and associated address exist
        if (retrievedPerson != null && retrievedPerson.getAddress() != null) {
            Address retrievedAddress = retrievedPerson.getAddress();
            System.out.println("Person: " + retrievedPerson.getName());
            System.out.println("Address: " + retrievedAddress.getCity());
        } else {
            System.out.println("Person or associated Address not found.");
        }

        // Close EntityManager
        em.close();
        emf.close();
    }
}

pom.xml:

Below is the XML file after adding all dependencies at the time of project creation.

XML
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>jpa-one-to-one-mapping</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>jpa-one-to-one-mapping</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.target>11</maven.compiler.target>
        <maven.compiler.source>11</maven.compiler.source>
        <junit.version>5.9.2</junit.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.hibernate.orm</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>6.0.2.Final</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.jaxb</groupId>
            <artifactId>jaxb-runtime</artifactId>
            <version>3.0.2</version>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
        </plugins>
    </build>
</project>


Step 7: Once the project is completed, run the application, it will show person name and address as output. Refer the below output image for the better understanding of the concept.

JPA One-to-One Mapping

In Java, JPA can define the Java Persistence API, One-to-one mapping is the common association relationship where one instance of the entity is associated with exactly one instance of another entity.

Similar Reads

Understanding of the JPA – One-to-One Mapping

One-to-one mapping can establish the relationship between the two entities where each instance of the one entity is associated with exactly one instance of the other entity. Let’s illustrate the example of the Person entity having a one-to-one relationship with an Address entity....

Steps to Implementation

1. Define the Entities:...

Subtopics:

Shared Primary Key:...

Project to Implement One-To-One Mapping in JPA

Step 1: Create the new JPA project using the IntelliJ Idea named jpa-one-to-one-mapping. After creating the project, the file structure looks like the below image....

Conclusion

One-To-One mapping in the JPA can enables the developers to represent the relationship between the entities where the each instance of the one entity is associated with the exactly one instance of the another entity. By the understanding of the concept, implementing the mapping and developers can effectively can manage the one-to-one relationship into the JPA applications....

Contact Us