Hibernate One To One annotation mapping example

Hibernate One To One annotation mapping example

This demo will show you how to use hibernate annotation which is enhance feature over using XML configuration to do ORM mapping with database.

Step 1: Create table database script:

CREATE TABLE address ( 
    Steet_Name  varchar(50) NULL,
    Location    varchar(25) NULL,
    City        varchar(25) NULL,
    Zip         varchar(25) NULL,
    State       varchar(25) NULL,
    id          int(11) NOT NULL AUTO_INCREMENT,
    PRIMARY KEY (id)
    )
GO
CREATE TABLE person ( 
    First_Name  varchar(50) NULL,
    Last_Name   varchar(50) NULL,
    id          int(11) NOT NULL AUTO_INCREMENT,
PRIMARY KEY (id),
    FOREIGN KEY (id)
    REFERENCES address (id) )

Step 2: Once you created table in database generate all files using below note:

Step 3: Final project structure:

Hibernate One To One annotation mapping example

Step 4: pom.xml file:

<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 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.javahonk</groupId>
    <artifactId>HibernateOneToOneAnnotation</artifactId>
    <packaging>war</packaging>
    <version>0.0.1-SNAPSHOT</version>
    <name>HibernateOneToOneAnnotation Maven Webapp</name>
    <url>http://maven.apache.org</url>
    <dependencies>

        <!-- MySQL database -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.9</version>
        </dependency>

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-annotations</artifactId>
            <version>3.5.6-Final</version>
        </dependency>

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate</artifactId>
            <version>3.2.3.ga</version>
        </dependency>


        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>

        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.1.1</version>
        </dependency>

        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>3.2.1</version>
        </dependency>

        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.2</version>
        </dependency>

        <dependency>
            <groupId>javax.transaction</groupId>
            <artifactId>jta</artifactId>
            <version>1.1</version>
        </dependency>

        <dependency>
            <groupId>asm</groupId>
            <artifactId>asm</artifactId>
            <version>3.1</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.5.0</version>
        </dependency>
        
        <dependency>
            <groupId>javassist</groupId>
            <artifactId>javassist</artifactId>
            <version>3.12.1.GA</version>
        </dependency>


    </dependencies>
    <build>
        <finalName>HibernateOneToOneAnnotation</finalName>
    </build>
</project>

Step 5: HibernateUtil.java file:

package com.javahonk.util;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;

public class HibernateUtil {
    private static final SessionFactory sessionFactory = 
        buildSessionFactory();

    private static SessionFactory buildSessionFactory() {
        try {           

            return new AnnotationConfiguration().configure()
                .buildSessionFactory();
        } catch (Throwable ex) {
            System.err.println("Initial SessionFactory"
                + " creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public static void shutdown() {
        // Close caches and connection pools
        getSessionFactory().close();
    }
}

Step 6: hibernate.cfg.xml file:

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.bytecode.use_reflection_optimizer">false</property>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.password">admin</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/javahonk</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.search.autoregister_listeners">false</property>
        
        <property name="show_sql">true</property>
        <mapping class="com.javahonk.bean.Person" />
        <mapping class="com.javahonk.bean.Address" />
    </session-factory>
</hibernate-configuration>

Step 7: Person.java class:

package com.javahonk.bean;

// Generated May 21, 2014 7:25:48 PM by Hibernate Tools 3.4.0.CR1

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.Parameter;

/**
 * Person generated by hbm2java
 */
@Entity
@Table(name = "person", catalog = "javahonk")
public class Person implements java.io.Serializable {

    private Integer id;
    private Address address;
    private String firstName;
    private String lastName;

    public Person() {
    }

    public Person(Address address) {
    this.address = address;
    }

    public Person(Address address, String firstName, String lastName) {
    this.address = address;
    this.firstName = firstName;
    this.lastName = lastName;
    }

    @GenericGenerator(name = "generator", strategy = "foreign", parameters = @Parameter(name = "property", value = "address"))
    @Id
    @GeneratedValue(generator = "generator")
    @Column(name = "id", unique = true, nullable = false)
    public Integer getId() {
    return this.id;
    }

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

    @OneToOne(fetch = FetchType.LAZY)
    @PrimaryKeyJoinColumn
    public Address getAddress() {
    return this.address;
    }

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

    @Column(name = "First_Name", length = 50)
    public String getFirstName() {
    return this.firstName;
    }

    public void setFirstName(String firstName) {
    this.firstName = firstName;
    }

    @Column(name = "Last_Name", length = 50)
    public String getLastName() {
    return this.lastName;
    }

    public void setLastName(String lastName) {
    this.lastName = lastName;
    }

}

Step 8: Address.java class:

package com.javahonk.bean;

// Generated May 21, 2014 7:25:48 PM by Hibernate Tools 3.4.0.CR1

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import static javax.persistence.GenerationType.IDENTITY;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;

/**
 * Address generated by hbm2java
 */
@Entity
@Table(name = "address", catalog = "javahonk")
public class Address implements java.io.Serializable {

    private Integer id;
    private String steetName;
    private String location;
    private String city;
    private String zip;
    private String state;
    private Person person;

    public Address() {
    }

    public Address(String steetName, String location, String city, String zip, String state,
        Person person) {
    this.steetName = steetName;
    this.location = location;
    this.city = city;
    this.zip = zip;
    this.state = state;
    this.person = person;
    }

    @Id
    @GeneratedValue(strategy = IDENTITY)
    @Column(name = "id", unique = true, nullable = false)
    public Integer getId() {
    return this.id;
    }

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

    @Column(name = "Steet_Name", length = 50)
    public String getSteetName() {
    return this.steetName;
    }

    public void setSteetName(String steetName) {
    this.steetName = steetName;
    }

    @Column(name = "Location", length = 25)
    public String getLocation() {
    return this.location;
    }

    public void setLocation(String location) {
    this.location = location;
    }

    @Column(name = "City", length = 25)
    public String getCity() {
    return this.city;
    }

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

    @Column(name = "Zip", length = 25)
    public String getZip() {
    return this.zip;
    }

    public void setZip(String zip) {
    this.zip = zip;
    }

    @Column(name = "State", length = 25)
    public String getState() {
    return this.state;
    }

    public void setState(String state) {
    this.state = state;
    }

    @OneToOne(fetch = FetchType.LAZY, mappedBy = "address")
    public Person getPerson() {
    return this.person;
    }

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

}

Step 9: Main test class: OneToOneInsert.java

package com.javahonk;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import com.javahonk.bean.Address;
import com.javahonk.bean.Person;
import com.javahonk.util.HibernateUtil;

public class OneToOneInsert {

    public static void main(String[] args) {
        
    SessionFactory sf = HibernateUtil.getSessionFactory();
        Session session = sf.openSession();
        session.beginTransaction();
 
        Address address=new Address();
        address.setSteetName("Main St."); 
        address.setLocation("NY");
        address.setCity("NY");
        address.setZip("12345");
        address.setState("NY"); 
         
        Person person=new Person();
        person.setFirstName("Java");
        person.setLastName("Honk");
        person.setAddress(address);
        address.setPerson(person);
        
         
        session.save(person); 
         
        List<Address> address3 = session.createQuery("from Address")
            .list();
        for (Address address2 : address3) {
            System.out.println("Address table data:");
            System.out.println("Stree Name: "+address2.getSteetName()
                +" Location: "+address2.getLocation()+" City: "
                +address2.getCity()+" State: "+address2.getState()
                +" Zip: "+address2.getZip());
            System.out.println("Person table data:");
            System.out.println("First Name: "
            +address2.getPerson().getFirstName()
            +" Last name: "+address2.getPerson().getLastName()+"\n");
        }
 
        session.getTransaction().commit();
        session.close();

    }

}

Step 10: Now run it. To run — right click OneToOneInsert.java –> Run As –> Java Application. You will see data inserted into the table and also it will retrieve inserted data from table and show to the console as below:

Hibernate One To One annotation mapping example

Step 11: Below data inserted to the table:

Hibernate One To One annotation mapping example

 

download2 Download project: HibernateOneToOneAnnotation

That’s it Hibernate One To One annotation mapping example . For more information read this hibernate tutorial

Leave a Reply

Your email address will not be published. Required fields are marked *

I am not Robot *