JavaBeat » Database

Hibernate Many-To-Many Mapping Example Using Annotations

Manisha Patil — Fri, 22 Mar 2013 12:21:33 +0000

In this tutorial we will write a simple Java project to demonstrate Hibernate Many to Many Mapping using Java Annotations. We will first create a Java project using Maven and then will add Hibernate on it. If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here. If you are beginner for hibernate, please read the articles about introduction to hibernate, interceptors in hibernate and spring & hibernate integration. We also recommend good reference books for learning hibernate in our post about hibernate books.

Many To Many Relationship

A ManyToMany relationship in Java is where the source object has an attribute that stores a collection of target objects and (if) those target objects had the inverse relationship back to the source object it would also be a ManyToMany relationship.

All ManyToMany relationships require a JoinTable. The JoinTable is defined using the @JoinTable annotation and XML element. The JoinTable defines a foreign key to the source object’s primary key (joinColumns), and a foreign key to the target object’s primary key (inverseJoinColumns). Normally the primary key of the JoinTable is the combination of both foreign keys. Let’s see an example of person and phone relationship as in the below structure:

Each person can have more than one phone and each phone can have more than one person assoiated with it.

Technologies Used:

Following are the tools and technologies required for this project:

Java JDK 5 or above
Eclipse IDE 3.2 or above
Maven 3.0 or above
Hibernate 3.0 or above (Hibernate Downloads)
MySQL 5 above (MySql Downloads)

1.Environment Setup

Refer post Hibernate, Maven and HSQL – Example Project (XML Mapping) for environment setup (follow steps 1,2 and 3). Pass the following command in the step.1, to create a java project using Maven:

mvn archetype:generate
-DgroupId=net.javabeat.hibernate
-DartifactId=HibernateManyToManyAnnotations
-DarchetypeArtifactId=maven-archetype-quickstart
-DinteractiveMode=false

2. Adding dependencies to pom.xml

We need to add the Hibernate, MYSQL and some other dependencies to the Maven pom.xml as shown below:

 <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>net.javabeat.hibernate</groupId>
   <artifactId> HibernateManyToManyAnnotations</artifactId>
   <packaging>jar</packaging>
   <version>1.0-SNAPSHOT</version>
   <name> HibernateManyToManyAnnotations</name>
   <url>http://maven.apache.org</url>
   <dependencies>
     <!-- Hibernate library dependency start -->
 		<dependency>
 			<groupId>org.hibernate</groupId>
 			<artifactId>hibernate</artifactId>
 			<version>4.1.9.Final</version>
 		</dependency>

 		<dependency>
 			<groupId>mysql</groupId>
 			<artifactId>mysql-connector-java</artifactId>
 			<version>5.1.10</version>
 		</dependency>
 		<dependency>
 			<groupId>org.hibernate</groupId>
 			<artifactId>hibernate-annotations</artifactId>
 			<version>3.3.1.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>asm</groupId>
 			<artifactId>asm</artifactId>
 			<version>4.0</version>
 		</dependency>
 		<dependency>
 			<groupId>dom4j</groupId>
 			<artifactId>dom4j</artifactId>
 			<version>1.6.1</version>
 		</dependency>
 		<dependency>
 			<groupId>ehcache</groupId>
 			<artifactId>ehcache</artifactId>
 			<version>1.2.3</version>
 		</dependency>
 		<dependency>
 			<groupId>hibernate-tools</groupId>
 			<artifactId>hibernate-tools</artifactId>
 			<version>3.2.3.GA</version>
 		</dependency>
 		<dependency>
 			<groupId>jta</groupId>
 			<artifactId>jta</artifactId>
 			<version>1.1</version>
 		</dependency>
 		<dependency>
 			<groupId>log4j</groupId>
 			<artifactId>log4j</artifactId>
 			<version>1.2.11</version>
 		</dependency>
 		<dependency>
 			<groupId>oscache</groupId>
 			<artifactId>oscache</artifactId>
 			<version>2.1</version>
 		</dependency>
 		<dependency>
 			<groupId>persistence-api</groupId>
 			<artifactId>persistence-api</artifactId>
 			<version>1.0</version>
 		</dependency>
 		<!-- Hibernate library dependecy end -->
   </dependencies>
 </project>

As a next step, let’s execute the following command so that maven will download all the required JARs and add the same to eclipse classpath. The command line point to the directory C:\HibernateProject\ HibernateManyToManyAnnotations and execute the following command:

mvn eclipse:eclipse

3. Create Model Classes

As we should be using annotations, we need to only write the model classes:
src\main\java\net\javabeat\hibernate\Person.java and src\main\java\net\javabeat\hibernate\Phone.java.
The contents of the model classes are as below

Person.java

package net.javabeat.hibernate;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
import javax.persistence.UniqueConstraint;

/**
 * Model class for Person
 */
@Entity
@Table(name = "Person", uniqueConstraints = {
		@UniqueConstraint(columnNames = "ID"),
		@UniqueConstraint(columnNames = "NAME") })
public class Person implements Serializable {

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	@Column(name = "ID", unique = true, nullable = false)
	private Long id;

	@Column(name = "NAME")
	private String name;

	@ManyToMany(cascade = CascadeType.ALL)
	@JoinTable(name = "PERSON_PHONE",
	joinColumns = { @JoinColumn(referencedColumnName = "ID") },
	inverseJoinColumns = { @JoinColumn(referencedColumnName = "ID") })
	private Set<Phone> personPhoneNumbers = new HashSet<Phone>();

	public Person(String name, Set<Phone> personPhoneNumbers) {
		super();
		this.name = name;
		this.personPhoneNumbers = personPhoneNumbers;
	}

	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 Set<Phone> getPersonPhoneNumbers() {
		return personPhoneNumbers;
	}

	public void setPersonPhoneNumbers(Set<Phone> personPhoneNumbers) {
		this.personPhoneNumbers = personPhoneNumbers;
	}

	public void addPhone(Phone phone) {
		this.personPhoneNumbers.add(phone);
	}

}

Phone.java

package net.javabeat.hibernate;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

import javax.persistence.ManyToMany;

import javax.persistence.Table;
import javax.persistence.UniqueConstraint;

@Entity
@Table(name = "PHONE", uniqueConstraints = { @UniqueConstraint(columnNames = "ID") })
public class Phone implements Serializable {
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	@Column(name = "ID", unique = true, nullable = false)
	private Long id;

	@Column(name = "CONTACTNUMBER", unique = true, nullable = false, length = 100)
	private String contactnumber;

	@Column(name = "PHONETYPE")
	private String phonetype;

	@ManyToMany(mappedBy = "personPhoneNumbers")
	private Set<Person> persons = new HashSet<Person>();

	public Phone() {

	}

	public Phone(String contactnumber, String phonetype) {
		super();
		this.contactnumber = contactnumber;
		this.phonetype = phonetype;

	}

	public Long getId() {
		return id;
	}

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

	public String getContactnumber() {
		return contactnumber;
	}

	public void setContactnumber(String contactnumber) {
		this.contactnumber = contactnumber;
	}

	public String getPhonetype() {
		return phonetype;
	}

	public void setPhonetype(String phonetype) {
		this.phonetype = phonetype;
	}

	public Set<Person> getPersons() {
		return persons;
	}

	public void setPersons(Set<Person> persons) {
		this.persons = persons;
	}

}

Details of the above files are as below:

@JoinTable annotation has been used to make the making the association between the tables PERSON and PHONE through PERSON_PHONE table as follows:

@ManyToMany(cascade = CascadeType.ALL)
@JoinTable(name = "PERSON_PHONE",
joinColumns = { @JoinColumn(referencedColumnName = "ID") },
inverseJoinColumns = { @JoinColumn(referencedColumnName = "ID") })
private Set<Phone> personPhoneNumbers = new HashSet<Phone>();

As mentioned in the section Many to Many Relationship the JoinTable defines a foreign key to the source object’s primary key joinColumns, and a foreign key to the target object’s primary key inverseJoinColumns.

We then map the Phone entity to the Person entity using the mappedBy attribute in Phone.java:

@ManyToMany(mappedBy = "personPhoneNumbers")
private Set<Person> persons = new HashSet<Person>();

4. Adding Hibernate Configuration file

As a next step let’s add the hibernate.cfg.xml to the directory:/src/main/resources . Write the new file hibernate.cfg.xml in this directory. The hibernate.cfg.xml is as follows:

<?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>
         <!-- Database connection settings, Connect to MYSQL -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
		<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/manisha</property>
		 <property name="connection.username">root</property>
        <property name="connection.password">root</property>

        <!-- JDBC connection pool (use the built-in) -->
        <property name="connection.pool_size">1</property>
        <property name="show_sql">true</property><property name="format_sql">true</property>

        <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
        <!--create the database schema on startup if required -->
        <property name="hbm2ddl.auto">create</property>
       <mapping class="net.javabeat.hibernate.Person"></mapping>
       <mapping class="net.javabeat.hibernate.Phone"></mapping>

  </session-factory>
</hibernate-configuration>

In the above file we have set the database connection to MYSQL database . The show_sql option, if set to true will display all the executed SQL queries on the console. The property hbm2ddl.auto , if set to create, creates the schema, destroying the previous data. At the end of the file we add model classes, Person and Phone to the configuration.

Note : In case you want to use any other database then, you need to change these properties – “dialect”, “connection.driver_class”, “connection.url”, “connection.username”, and “connection.password”.

5. Create Utility class

Next, we will write a utility class to take care of Hibernate start up and retrieve the session easily. We will write the file src\main\java\net\javabeat\hibernate\HibernateUtil.java as below:

package net.javabeat.hibernate;

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

public class HibernateUtil {
	private static final SessionFactory sessionFactory;
	static {
		try {
			sessionFactory = 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;
	}
}

6. Revise the App class

Next we will revise the App.java (generated by Maven). This class tests the many-to-many relationship by creating and listing the person names and corresponding phone numbers as below:

package net.javabeat.hibernate;

import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

/**
 * Main class
 *
 */
public class App {
	public static void main(String[] args) {
		System.out
		.println("Maven + Hibernate + SQL  Many to Many Using Annotations ");
		Session session = HibernateUtil.getSessionFactory().openSession();
		session.beginTransaction();
		App app = new App();

		app.savePersonInfo("Manisha");

		app.listPersonInfo();

	}

	public Long savePersonInfo(String personName) {
		Session session = HibernateUtil.getSessionFactory().openSession();
		session.beginTransaction();
		Long personId = null;
		Transaction transaction = null;
		try {
			transaction = session.beginTransaction();
			Person person = new Person();
			person.setName(personName);

			Phone ph1 = new Phone();
			Phone ph2 = new Phone();
			ph1.setContactnumber("4100000");
			ph1.setPhonetype("Landline");

			ph2.setContactnumber("988000045");
			ph2.setPhonetype("Mobile");
			person.addPhone(ph1);
			person.addPhone(ph2);
			session.save(person);

			transaction.commit();
		} catch (HibernateException e) {
			transaction.rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
		return personId;
	}

	/*
	 * Lists the person's from database table
	 */
	public void listPersonInfo() {
		Session session = HibernateUtil.getSessionFactory().openSession();
		Transaction transaction = null;
		try {
			transaction = session.beginTransaction();
			@SuppressWarnings("unchecked")
			List<Person> personList = session.createQuery("FROM Person").list();

			System.out.println("List size: " + (personList).size());
			for (Iterator iterator = personList.iterator(); iterator.hasNext();) {
				Person person = (Person) iterator.next();
				Set<Phone> ph = new HashSet<Phone>();
				ph = person.getPersonPhoneNumbers();
				for (Phone p : ph) {
					System.out.println("***************************");
					System.out.println(person.getName());
					System.out.println(" Phone Type: " + p.getPhonetype());
					System.out
					.println(" Phone Number: " + p.getContactnumber());
					System.out.println("***************************");
				}
			}
			transaction.commit();
		} catch (HibernateException e) {
			transaction.rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
	}

}

Here the savePersonInfo() method is used to save a new Person object and Phone object to the database.

The listPersonInfo() method is used to list name of each person in PERSON table and their corresponding phone numbers and type from PHONE table. Here we use Hibernate Query Language (HQL). The query “from Person” returns a list of all the data in the PERSON table and their corresponding phone numbers from PHONE table through PERSON_PHONE table (check the select query in the output section ). Note that in the HQL we only specify the java class names and not the table names. Later, using the for loop we iterate the list the data from Person and corresponding Phone table and hence display them on the console.

8. Final project structure

Once you have created all these source files, your project structure should look like following:

9. Execution of the above code

Now let us execute the code we created above. Let’s run the App class.
Right click on App.java >Run As > Java Application.
On start of each thread, a database schema will be created and the following actions will happen.

Output on the console:
Following output is displayed on the console:

Maven + Hibernate + SQL  Many to Many Using Annotations
log4j:WARN No appenders could be found for logger (org.hibernate.cfg.annotations.Version).
log4j:WARN Please initialize the log4j system properly.
Hibernate:
    insert
    into
        Person
        (NAME)
    values
        (?)
Hibernate:
    insert
    into
        PHONE
        (CONTACTNUMBER, PHONETYPE)
    values
        (?, ?)
Hibernate:
    insert
    into
        PHONE
        (CONTACTNUMBER, PHONETYPE)
    values
        (?, ?)
Hibernate:
    insert
    into
        PERSON_PHONE
        (persons_ID, personPhoneNumbers_ID)
    values
        (?, ?)
Hibernate:
    insert
    into
        PERSON_PHONE
        (persons_ID, personPhoneNumbers_ID)
    values
        (?, ?)
Hibernate:
    select
        person0_.ID as ID0_,
        person0_.NAME as NAME0_
    from
        Person person0_
List size: 1
Hibernate:
    select
        personphon0_.persons_ID as persons1_1_,
        personphon0_.personPhoneNumbers_ID as personPh2_1_,
        phone1_.ID as ID1_0_,
        phone1_.CONTACTNUMBER as CONTACTN2_1_0_,
        phone1_.PHONETYPE as PHONETYPE1_0_
    from
        PERSON_PHONE personphon0_
    left outer join
        PHONE phone1_
            on personphon0_.personPhoneNumbers_ID=phone1_.ID
    where
        personphon0_.persons_ID=?
***************************
Manisha
 Phone Type: Mobile
 Phone Number: 988000045
***************************
***************************
Manisha
 Phone Type: Landline
 Phone Number: 4100000
***************************

Summary

In this post we demonstrated many-to-many relation using Java annotation. We initially created a Java project using Maven, made it compatible with eclipse. Then we created model classes using annotations. We then set the values in our main class(App.java), which in turn added the values to respective tables. We also listed the data from the tables. If you are interested in receiving the future articles on Java topics, please subscribe here

Hibernate Many-To-Many Mapping Example (XML Mapping)

Manisha Patil — Thu, 21 Mar 2013 12:19:11 +0000

Connect to us ( @twitter | @facebook )

In this tutorial we will write a simple Java project to demonstrate Hibernate Many to Many Mapping using XML mapping. We will first create a Java project using Maven and then will add Hibernate on it. If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here. If you are beginner for hibernate, please read the articles about introduction to hibernate, interceptors in hibernate and spring & hibernate integration. We also recommend good reference books for learning hibernate in our post about hibernate books.

Many To Many Relationship

Each person can have more than one phone and each phone can have more than one person associated with it.
Technologies Used:

Following are the tools and technologies required for this project:

Java JDK 5 or above
Eclipse IDE 3.2 or above
Maven 3.0 or above
Hibernate 3.0 or above (Hibernate Downloads)
MySQL 5 above (MySql Downloads)

1.Environment Setup

Refer post Hibernate, Maven and HSQL – Example Project (XML Mapping) for environment setup (follow steps 1,2 and 3). Pass the following command in the step.1, to create a java project using Maven:

mvn archetype:generate
-DgroupId=net.javabeat.hibernate
-DartifactId=HibernateManyToManyXML
-DarchetypeArtifactId=maven-archetype-quickstart
-DinteractiveMode=false

2. Adding dependencies to pom.xml

We need to add the Hibernate, MYSQL and some other dependencies to the Maven pom.xml as shown below:

 
   4.0.0
   net.javabeat.hibernate
   HibernateManyToManyXML
   jar
   1.0-SNAPSHOT
   HibernateManyToManyXML
   http://maven.apache.org
   
     
 		
 			org.hibernate
 			hibernate
 			4.1.9.Final
 		

 		
 			mysql
 			mysql-connector-java
 			5.1.10
 		
 		
 			org.hibernate
 			hibernate-annotations
 			3.3.1.GA
 		
 		
 			dom4j
 			dom4j
 			1.6.1
 		
 		
 			commons-logging
 			commons-logging
 			1.1.1
 		
 		
 			commons-collections
 			commons-collections
 			3.2.1
 		
 		
 			cglib
 			cglib
 			2.2
 		
 		
 			asm
 			asm
 			4.0
 		
 		
 			dom4j
 			dom4j
 			1.6.1
 		
 		
 			ehcache
 			ehcache
 			1.2.3
 		
 		
 			hibernate-tools
 			hibernate-tools
 			3.2.3.GA
 		
 		
 			jta
 			jta
 			1.1
 		
 		
 			log4j
 			log4j
 			1.2.11
 		
 		
 			oscache
 			oscache
 			2.1
 		
 		
 			persistence-api
 			persistence-api
 			1.0

As a next step, let’s execute the following command so that maven will download all the required JARs and add the same to eclipse classpath. The command line point to the directory C:\HibernateProject\HibernateManyToManyXML and execute the following command:

mvn eclipse:eclipse

3. Create Model Classes and hibernate mapping files

Next let’s write Hibernate XML Mapping files to the directory: /src/main/resources . Create the resources directory as follows: Right click on Project > New > Source Folder > Give folder name “/src/main/resources/” and click Finish.
Write the file src\main\resources\net\javabeat\hibernate\Person.hbm.xml for the model Person and src\main\resources\net\javabeat\hibernate\Phone.hbm.xml for the model class Phone. The contents of these files are as below:

Person.hbm.xml

Phone.hbm.xml

Model classes

As a next step let’s create the model classes src\main\java\net\javabeat\hibernate\Person.java and src\main\java\net\javabeat\hibernate\Phone.java. The contents of the model classes are as below

Person.java

package net.javabeat.hibernate;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

/**
 * Model class for Person
 */
public class Person implements Serializable {
	private Long id;
	private String name;
	private Set personPhoneNumbers = new HashSet();

	public Person(String name, Set personPhoneNumbers) {
		super();
		this.name = name;
		this.personPhoneNumbers = personPhoneNumbers;
	}

	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 Set getPersonPhoneNumbers() {
		return personPhoneNumbers;
	}

	public void setPersonPhoneNumbers(Set personPhoneNumbers) {
		this.personPhoneNumbers = personPhoneNumbers;
	}

	public void addPhone(Phone phone) {

		this.personPhoneNumbers.add(phone);
	}

}

Phone.java

package net.javabeat.hibernate;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

public class Phone implements Serializable {
	private Long id;
	private String contactnumber;
	private String phonetype;
	private Set persons = new HashSet();

	public Phone() {

	}

	public Phone(String contactnumber, String phonetype) {
		super();
		this.contactnumber = contactnumber;
		this.phonetype = phonetype;

	}

	public Long getId() {
		return id;
	}

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

	public String getContactnumber() {
		return contactnumber;
	}

	public void setContactnumber(String contactnumber) {
		this.contactnumber = contactnumber;
	}

	public String getPhonetype() {
		return phonetype;
	}

	public void setPhonetype(String phonetype) {
		this.phonetype = phonetype;
	}

	public Set getPersons() {
		return persons;
	}

	public void setPersons(Set persons) {
		this.persons = persons;
	}

}

Details of the above files are as below:

The many-to-many relationship definition in Person.hbm.xml, the set attribute is defined as follows:
```
	
	
```
The cascade=”all” ensures that the INSERT order is appropriate. i.e. the insertion order is in the following fashion PERSON, PHONE and PERSON_PHONE.

The following code in the Phone.hbm.xml, makes the many-to-many association bi-directional.

Corresponding code in the Phone.java class is as follows:

	private Set persons = new HashSet();
	public Set getPersons() {
		return persons;
	}

	public void setPersons(Set persons) {
		this.persons = persons;
	}

4. Adding Hibernate Configuration file

As a next step let’s add the hibernate.cfg.xml to the directory:/src/main/resources . Write the new file hibernate.cfg.xml in this directory. The hibernate.cfg.xml is as follows:




    
         
        org.hibernate.dialect.MySQLDialect
		com.mysql.jdbc.Driver
        jdbc:mysql://localhost:3306/manisha
		 root
        root

        
        1
        truetrue

        org.hibernate.cache.NoCacheProvider
        
        create

In the above file we have set the database connection to MYSQL database . The show_sql option, if set to true will display all the executed SQL queries on the console. The property hbm2ddl.auto , if set to create, creates the schema, destroying the previous data. At the end of the file we add the Person.hbm.xml and Phone.hbm.xml files to the configuration.

5. Create Utility class

Next, we will write a utility class to take care of Hibernate start up and retrieve the session easily. We will write the file src\main\java\net\javabeat\hibernate\HibernateUtil.java as below:

package net.javabeat.hibernate;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
	private static final SessionFactory sessionFactory;
	static {
		try {
			sessionFactory = new Configuration().configure()
					.buildSessionFactory();
		} catch (Throwable ex) {
			System.err.println("Initial SessionFactory creation failed." + ex);
			throw new ExceptionInInitializerError(ex);
		}
	}

	public static SessionFactory getSessionFactory() {
		return sessionFactory;
	}
}

6. Revise the App class

Next we will revise the App.java (generated by Maven). This class tests the many-to-many relationship by creating and listing the person names and corresponding phone numbers as below:

package net.javabeat.hibernate;

import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

/**
 * Main class
 *
 */
public class App {
	public static void main(String[] args) {
		System.out.println("Maven + Hibernate + SQL  Many to Many XML Mapping ");
		Session session = HibernateUtil.getSessionFactory().openSession();
		session.beginTransaction();
		App app = new App();

		app.savePersonInfo("Manisha");

		app.listPersonInfo();

	}

	public Long savePersonInfo(String personName) {
		Session session = HibernateUtil.getSessionFactory().openSession();
		session.beginTransaction();
		Long personId = null;
		Transaction transaction = null;
		try {
			transaction = session.beginTransaction();
			Person person = new Person();
			person.setName(personName);

			Phone ph1 = new Phone();
			Phone ph2 = new Phone();
			ph1.setContactnumber("4100000");
			ph1.setPhonetype("Landline");

			ph2.setContactnumber("988000045");
			ph2.setPhonetype("Mobile");
			person.addPhone(ph1);
			person.addPhone(ph2);
			session.save(person);

			transaction.commit();
		} catch (HibernateException e) {
			transaction.rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
		return personId;
	}

	/*
	 * Lists the person's from database table
	 */
	public void listPersonInfo() {
		Session session = HibernateUtil.getSessionFactory().openSession();
		Transaction transaction = null;
		try {
			transaction = session.beginTransaction();
			@SuppressWarnings("unchecked")
			List personList = session.createQuery("FROM Person").list();

			System.out.println("List size: " + (personList).size());
			for (Iterator iterator = personList.iterator(); iterator.hasNext();) {
				Person person = (Person) iterator.next();
				Set ph = new HashSet();
				ph = person.getPersonPhoneNumbers();
				for (Phone p : ph) {
					System.out.println("***************************");
					System.out.println(person.getName());
					System.out.println(" Phone Type: " + p.getPhonetype());
					System.out.println(" Phone Number: " + p.getContactnumber());
					System.out.println("***************************");
				}
			}
			transaction.commit();
		} catch (HibernateException e) {
			transaction.rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
	}

}

Here the savePersonInfo() method is used to save a new Person object and Phone object to the database.

The listPersonInfo() method is used to list name of each person in PERSON table and their corresponding phone numbers and type from PHONE table. Here we use Hibernate Query Language (HQL). The query “from Person” returns a list of all the data in the PERSON table and their corresponding phone numbers from PHONE table through the table PERSON_PHONE(check the select query in the output section). Note that in the HQL we only specify the java class names and not the table names. Later, using the for loop we iterate the list the data from Person and corresponding Phone table and hence display them on the console.

8. Final project structure

Once you have created all these source files, your project structure should look like following:

9. Execution of the above code

Now let us execute the code we created above. Let’s run the App class. Right click on App.java >Run As > Java Application. On start of each thread, a database schema will be created and the following actions will happen.

Output on the console:
Following output is displayed on the console:

Maven + Hibernate + SQL  Many to Many XML Mapping
log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
Hibernate:
    insert
    into
        person
        (NAME)
    values
        (?)
Hibernate:
    insert
    into
        phone
        (CONTACTNUMBER, PHONETYPE)
    values
        (?, ?)
Hibernate:
    insert
    into
        phone
        (CONTACTNUMBER, PHONETYPE)
    values
        (?, ?)
Hibernate:
    insert
    into
        person_phone
        (PERSONID, PHONEID)
    values
        (?, ?)
Hibernate:
    insert
    into
        person_phone
        (PERSONID, PHONEID)
    values
        (?, ?)
Hibernate:
    select
        person0_.ID as ID0_,
        person0_.NAME as NAME0_
    from
        person person0_
List size: 1
Hibernate:
    select
        personphon0_.PERSONID as PERSONID1_,
        personphon0_.PHONEID as PHONEID1_,
        phone1_.ID as ID2_0_,
        phone1_.CONTACTNUMBER as CONTACTN2_2_0_,
        phone1_.PHONETYPE as PHONETYPE2_0_
    from
        person_phone personphon0_
    left outer join
        phone phone1_
            on personphon0_.PHONEID=phone1_.ID
    where
        personphon0_.PERSONID=?
***************************
Manisha
 Phone Type: Landline
 Phone Number: 4100000
***************************
***************************
Manisha
 Phone Type: Mobile
 Phone Number: 988000045
***************************

Summary

In this post we demonstrated Many-to-Many relation using hibernate mapping files. We initially created a Java project using Maven, made it compatible with eclipse. Then we created hibernate mapping files and created the corresponding model classes (using join table association). We then set the values in our main class(App.java), which in turn added the values to respective tables. We also listed the data from the tables. In the next post we shall see an example of Hibernate Many-to-Many mapping(using Annotations).If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here

Hibernate One-To-Many Mapping Example Using Annotations

Manisha Patil — Tue, 19 Mar 2013 13:01:26 +0000

Connect to us ( @twitter | @facebook )

In this tutorial we will write a simple Java project to demonstrate Hibernate one to Many Mapping using Java Annotations. In my previous article I have explained Hibernate one to Many Mapping using XML. The main difference between these two examples would be the hibernate configuration files and annotations. Otherwise both the articles trying the same example.

We will first create a Java project using Maven and then will add Hibernate on it. If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here. If you are beginner for hibernate, please read the articles about introduction to hibernate, interceptors in hibernate and spring & hibernate integration. We also recommend good reference books for learning hibernate in our post about hibernate books.

HibernateOneToManyAnnotations (14).

One To Many Relationship

Also known as a many-to-one relationship, this occurs when the maximum of one multiplicity is one and the other is greater than one. An example is the relationship between Person and Phone.
Consider the following relationship:

According to the relationship each Person can have a any number of phone numbers. But each phone number will be associated with only one person. Hence we will need two tables namely PERSON and PHONE to create this relation. In Hibernate, one-to-many relationship between entities can be created by 2 different techniques. These techniques are:

Using foreign key association: In this association, we can have a foreign key column in PHONE table i.i PERSONID. This column will refer to primary key of PERSON table. This way no two phone numbers can be associated with multiple persons. Obviously, phone number needs to be unique for enforcing this restriction. The example below in this post demonstrates this asscociation. The relational model is shown below:
Using a common join table: In this association, we can have a common join table lets say PERSON_PHONE. This table will have two column i.e. PERSON_ID which will be foreign key referring to primary key in PERSON table and similarly PHONE_ID which will be foreign key referring to primary key of PHONE table.
The relational model is shown below:

Technologies Used:

Following are the tools and technologies required for this project:

Java JDK 5 or above
Eclipse IDE 3.2 or above
Maven 3.0 or above
Hibernate 3.0 or above (Hibernate Downloads)
MySQL 5 above (MySql Downloads)

1.Environment Setup

Refer post Hibernate, Maven and HSQL – Example Project (XML Mapping) for environment setup (follow steps 1,2 and 3). Pass the following command in the step.1, to create a java project using Maven:

mvn archetype:generate
-DgroupId=net.javabeat.hibernate
-DartifactId=HibernateOneToManyAnnotations
-DarchetypeArtifactId=maven-archetype-quickstart
-DinteractiveMode=false

2. Adding dependencies to pom.xml

We need to add the Hibernate, MYSQL and some other dependencies to the Maven pom.xml as shown below:

 
   4.0.0
   net.javabeat.hibernate
    HibernateOneToManyAnnotations
   jar
   1.0-SNAPSHOT
    HibernateOneToManyAnnotations
   http://maven.apache.org
   
     
 		
 			org.hibernate
 			hibernate
 			4.1.9.Final
 		

 		
 			mysql
 			mysql-connector-java
 			5.1.10
 		
 		
 			org.hibernate
 			hibernate-annotations
 			3.3.1.GA
 		
 		
 			dom4j
 			dom4j
 			1.6.1
 		
 		
 			commons-logging
 			commons-logging
 			1.1.1
 		
 		
 			commons-collections
 			commons-collections
 			3.2.1
 		
 		
 			cglib
 			cglib
 			2.2
 		
 		
 			asm
 			asm
 			4.0
 		
 		
 			dom4j
 			dom4j
 			1.6.1
 		
 		
 			ehcache
 			ehcache
 			1.2.3
 		
 		
 			hibernate-tools
 			hibernate-tools
 			3.2.3.GA
 		
 		
 			jta
 			jta
 			1.1
 		
 		
 			log4j
 			log4j
 			1.2.11
 		
 		
 			oscache
 			oscache
 			2.1
 		
 		
 			persistence-api
 			persistence-api
 			1.0

As a next step, let’s execute the following command so that maven will download all the required JARs and add the same to eclipse classpath. The command line point to the directory C:\HibernateProject\ HibernateOneToManyAnnotations and execute the following command:

mvn eclipse:eclipse

3. Create Model Classes

As we sould be using annotations, we need to only write the model classes:
src\main\java\net\javabeat\hibernate\Person.java and src\main\java\net\javabeat\hibernate\Phone.java.
The contents of the model classes are as below

Person.java

package net.javabeat.hibernate;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.persistence.UniqueConstraint;

/**
 * Model class for Person
 */
@Entity
@Table(name="Person"
  , uniqueConstraints = {
  @UniqueConstraint(columnNames = "ID"),
  @UniqueConstraint(columnNames = "NAME") })

public class Person implements Serializable {

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	@Column(name = "ID", unique = true, nullable = false)
	private Long id;

	@Column(name = "NAME")
	private String name;

	@OneToMany(cascade = CascadeType.ALL, mappedBy = "person")
	private Set personPhoneNumbers = new HashSet();

	public Person(String name, Set personPhoneNumbers) {
		super();
		this.name = name;
		this.personPhoneNumbers = personPhoneNumbers;
	}

	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 Set getPersonPhoneNumbers() {
		return personPhoneNumbers;
	}

	public void setPersonPhoneNumbers(Set personPhoneNumbers) {
		this.personPhoneNumbers = personPhoneNumbers;
	}

	public void addPhone(Phone phone) {
		phone.setPerson(this);
		this.personPhoneNumbers.add(phone);
	}

}

Phone.java

package net.javabeat.hibernate;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import javax.persistence.UniqueConstraint;

@Entity
@Table(name = "PHONE", uniqueConstraints = { @UniqueConstraint(columnNames = "ID") })
public class Phone implements Serializable {
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	@Column(name = "ID", unique = true, nullable = false)
	private Long id;

	@Column(name = "CONTACTNUMBER", unique = true, nullable = false, length = 100)
	private String contactnumber;

	@Column(name = "PHONETYPE")
	private String phonetype;

	@ManyToOne
	@JoinColumn(name = "personId")
	private Person person;

	public Phone() {

	}

	public Phone(String contactnumber, String phonetype) {
		super();
		this.contactnumber = contactnumber;
		this.phonetype = phonetype;

	}

	public Long getId() {
		return id;
	}

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

	public String getContactnumber() {
		return contactnumber;
	}

	public void setContactnumber(String contactnumber) {
		this.contactnumber = contactnumber;
	}

	public String getPhonetype() {
		return phonetype;
	}

	public void setPhonetype(String phonetype) {
		this.phonetype = phonetype;
	}

	public Person getPerson() {
		return person;
	}

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

}

Details of the above files are as below:

In the file Person.java, we have made the one to many association using the annotation @OneToMany(cascade = CascadeType.ALL, mappedBy = “person”). Here mappedBy attribute is used to define the field that “owns” the relation on the owning side (the side that holds the foreign key i.e. the Many side in a one-to-many. Here it is the person field in Phone entity). @ManyToOne annotation is used in the Phone class.
The @JoinColumn annotation should be defined on the owning side only (in our case it is the Phone entity).

4. Adding Hibernate Configuration file

As a next step let’s add the hibernate.cfg.xml to the directory:/src/main/resources . Write the new file hibernate.cfg.xml in this directory. The hibernate.cfg.xml is as follows:




    
         
        org.hibernate.dialect.MySQLDialect
		com.mysql.jdbc.Driver
        jdbc:mysql://localhost:3306/manisha
		 root
        root

        
        1
        truetrue

        org.hibernate.cache.NoCacheProvider
        
        create

5. Create Utility class

Next, we will write a utility class to take care of Hibernate start up and retrieve the session easily. We will write the file src\main\java\net\javabeat\hibernate\HibernateUtil.java as below:

package net.javabeat.hibernate;

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

public class HibernateUtil {
	private static final SessionFactory sessionFactory;
	static {
		try {
			sessionFactory = 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;
	}
}

6. Revise the App class

Next we will revise the App.java (generated by Maven). This class tests the one-to-many relationship by creating and listing the person names and corresponding phone numbers as below:

package net.javabeat.hibernate;

import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

/**
 * Main class
 *
 */
public class App {
	public static void main(String[] args) {
		System.out
				.println("Maven + Hibernate + SQL  One to Many Using Annotations ");
		Session session = HibernateUtil.getSessionFactory().openSession();
		session.beginTransaction();
		App app = new App();

		app.savePersonInfo("Manisha");

		app.listPersonInfo();

	}

	public Long savePersonInfo(String personName) {
		Session session = HibernateUtil.getSessionFactory().openSession();
		session.beginTransaction();
		Long personId = null;
		Transaction transaction = null;
		try {
			transaction = session.beginTransaction();
			Person person = new Person();
			person.setName(personName);

			Phone ph1 = new Phone();
			Phone ph2 = new Phone();
			ph1.setContactnumber("4100000");
			ph1.setPhonetype("Landline");

			ph2.setContactnumber("988000045");
			ph2.setPhonetype("Mobile");
			person.addPhone(ph1);
			person.addPhone(ph2);
			session.save(person);

			transaction.commit();
		} catch (HibernateException e) {
			transaction.rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
		return personId;
	}

	/*
	 * Lists the person's from database table
	 */
	public void listPersonInfo() {
		Session session = HibernateUtil.getSessionFactory().openSession();
		Transaction transaction = null;
		try {
			transaction = session.beginTransaction();
			@SuppressWarnings("unchecked")
			List personList = session.createQuery("FROM Person").list();

			System.out.println("List size: " + (personList).size());
			for (Iterator iterator = personList.iterator(); iterator.hasNext();) {
				Person person = (Person) iterator.next();
				Set ph = new HashSet();
				ph = person.getPersonPhoneNumbers();
				for (Phone p : ph) {
					System.out.println("***************************");
					System.out.println(person.getName());
					System.out.println(" Phone Type: " + p.getPhonetype());
					System.out
					.println(" Phone Number: " + p.getContactnumber());
					System.out.println("***************************");
				}
			}
			transaction.commit();
		} catch (HibernateException e) {
			transaction.rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
	}

}

Here the savePersonInfo() method is used to save a new Person object and Phone object to the database.

The listPersonInfo() method is used to list name of each person in PERSON table and their corresponding phone numbers and type from PHONE table. Here we use Hibernate Query Language (HQL). The query “from Person” returns a list of all the data in the PERSON table and their corresponding phone numbers from PHONE table. Note that in the HQL we only specify the java class names and not the table names. Later, using the for loop we iterate the list the data from Person and corresponding Phone table and hence display them on the console.

8. Final project structure

Once you have created all these source files, your project structure should look like following:

9. Execution of the above code

Output on the console:
Following output is displayed on the console:

Maven + Hibernate + SQL  One to Many Using Annotations
log4j:WARN No appenders could be found for logger (org.hibernate.cfg.annotations.Version).
log4j:WARN Please initialize the log4j system properly.
Hibernate:
    insert
    into
        Person
        (NAME)
    values
        (?)
Hibernate:
    insert
    into
        PHONE
        (CONTACTNUMBER, personId, PHONETYPE)
    values
        (?, ?, ?)
Hibernate:
    insert
    into
        PHONE
        (CONTACTNUMBER, personId, PHONETYPE)
    values
        (?, ?, ?)
Hibernate:
    select
        person0_.ID as ID0_,
        person0_.NAME as NAME0_
    from
        Person person0_
List size: 1
Hibernate:
    select
        personphon0_.personId as personId1_,
        personphon0_.ID as ID1_,
        personphon0_.ID as ID1_0_,
        personphon0_.CONTACTNUMBER as CONTACTN2_1_0_,
        personphon0_.personId as personId1_0_,
        personphon0_.PHONETYPE as PHONETYPE1_0_
    from
        PHONE personphon0_
    where
        personphon0_.personId=?
***************************
Manisha
 Phone Type: Mobile
 Phone Number: 988000045
***************************
***************************
Manisha
 Phone Type: Landline
 Phone Number: 4100000
***************************

Using a Common Join Table

This technique uses a join table to store the associations between Person and Phone entities (as seen in the entity relation diagram above).
We use @JoinTable annotation to create the one-to-many relationship between the Person and Phone entities. Following needs to be added to the Person entity:

@OneToMany
    @JoinTable(
            name="Person_Phone",
            joinColumns = @JoinColumn( name="person_id"),
            inverseJoinColumns = @JoinColumn( name="phone_id")
    )
    public Set getPersonPhoneNumbers() {

@manytoone annotation need not be set in the Phone entity, hence making it unidirectional.

Summary

HibernateOneToManyAnnotations (14)

In my previous article I have explained Hibernate one to Many Mapping using Java Annotations. The main difference between these two examples would be the hibernate configuration files and annotations. Otherwise both the articles trying the same example.

In this post we demonstrated one-to-many relation using Java annotation. We discussed about various techniques of one-to-many associations. We initially created a Java project using Maven, made it compatible with eclipse. Then we created model classes using annotations (foreign key association). We then set the values in our main class(App.java), which in turn added the values to respective tables. We also listed the data from the tables. In the next post we shall see an example of Hibernate Many-to-Many mapping(using XML mpping).If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here

Hibernate One-To-Many Mapping Example (XML Mapping)

Manisha Patil — Tue, 19 Mar 2013 00:56:37 +0000

Connect to us ( @twitter | @facebook )

In this tutorial we will write a simple Java project to demonstrate Hibernate one to Many Mapping using XML mapping. We will first create a Java project using Maven and then will add Hibernate on it. If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here. If you are beginner for hibernate, please read the articles about introduction to hibernate, interceptors in hibernate and spring & hibernate integration. We also recommend good reference books for learning hibernate in our post about hibernate books.

Source Code Download for HibernateOneToManyXML (13)

One To Many Relationship

Using foreign key association: In this association, we can have a foreign key column in PHONE table i.i PERSONID. This column will refer to primary key of PERSON table. This way no two phone numbers can be associated with multiple persons. Obviously, phone number needs to be unique for enforcing this restriction. The example below in this post demonstrates this association. The relational model is shown below:
Using a common join table: In this association, we can have a common join table lets say PERSON_PHONE. This table will have two column i.e. PERSON_ID which will be foreign key referring to primary key in PERSON table and similarly PHONE_ID which will be foreign key referring to primary key of PHONE table. The relational model is shown below:

Technologies Used:

Following are the tools and technologies required for this project:

Java JDK 5 or above
Eclipse IDE 3.2 or above
Maven 3.0 or above
Hibernate 3.0 or above (Hibernate Downloads)
MySQL 5 above (MySql Downloads)

1.Environment Setup

Refer post Hibernate, Maven and HSQL – Example Project (XML Mapping) for environment setup (follow steps 1,2 and 3). Pass the following command in the step.1, to create a java project using Maven:

mvn archetype:generate
-DgroupId=net.javabeat.hibernate
-DartifactId=HibernateOneToManyXML
-DarchetypeArtifactId=maven-archetype-quickstart
-DinteractiveMode=false

2. Adding dependencies to pom.xml

We need to add the Hibernate, MYSQL and some other dependencies to the Maven pom.xml as shown below:

 
   4.0.0
   net.javabeat.hibernate
   HibernateOneToManyXML
   jar
   1.0-SNAPSHOT
   HibernateOneToManyXML
   http://maven.apache.org
   
     
 		
 			org.hibernate
 			hibernate
 			4.1.9.Final
 		

 		
 			mysql
 			mysql-connector-java
 			5.1.10
 		
 		
 			org.hibernate
 			hibernate-annotations
 			3.3.1.GA
 		
 		
 			dom4j
 			dom4j
 			1.6.1
 		
 		
 			commons-logging
 			commons-logging
 			1.1.1
 		
 		
 			commons-collections
 			commons-collections
 			3.2.1
 		
 		
 			cglib
 			cglib
 			2.2
 		
 		
 			asm
 			asm
 			4.0
 		
 		
 			dom4j
 			dom4j
 			1.6.1
 		
 		
 			ehcache
 			ehcache
 			1.2.3
 		
 		
 			hibernate-tools
 			hibernate-tools
 			3.2.3.GA
 		
 		
 			jta
 			jta
 			1.1
 		
 		
 			log4j
 			log4j
 			1.2.11
 		
 		
 			oscache
 			oscache
 			2.1
 		
 		
 			persistence-api
 			persistence-api
 			1.0

As a next step, let’s execute the following command so that maven will download all the required JARs and add the same to eclipse classpath. The command line point to the directory C:\HibernateProject\HibernateOneToManyXML and execute the following command:

mvn eclipse:eclipse

3. Create Model Classes and hibernate mapping files

Next let’s write Hibernate XML Mapping files to the directory: /src/main/resources . Create the resources directory as follows: Right click on Project > New > Source Folder > Give folder name “/src/main/resources/” and click Finish. Write the file src\main\resources\net\javabeat\hibernate\Person.hbm.xml for the model Person and src\main\resources\net\javabeat\hibernate\Phone.hbm.xml for the model class Phone. The contents of these files are as below:

Person.hbm.xml

Phone.hbm.xml

Model classes

Person.java

package net.javabeat.hibernate;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

/**
 * Model class for Person
 */
public class Person implements Serializable {
	private Long id;
	private String name;
	private Set personPhoneNumbers = new HashSet();

	public Person(String name, Set personPhoneNumbers) {
		super();
		this.name = name;
		this.personPhoneNumbers = personPhoneNumbers;
	}

	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 Set getPersonPhoneNumbers() {
		return personPhoneNumbers;
	}

	public void setPersonPhoneNumbers(Set personPhoneNumbers) {
		this.personPhoneNumbers = personPhoneNumbers;
	}

	public void addPhone(Phone phone) {
		phone.setPerson(this);
		this.personPhoneNumbers.add(phone);
	}

}

Phone.java

package net.javabeat.hibernate;

import java.io.Serializable;

public class Phone implements Serializable {
	private Long id;
	private String contactnumber;
	private String phonetype;
	private Person person;

	public Phone() {

	}

	public Phone(String contactnumber, String phonetype) {
		super();
		this.contactnumber = contactnumber;
		this.phonetype = phonetype;

	}

	public Long getId() {
		return id;
	}

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

	public String getContactnumber() {
		return contactnumber;
	}

	public void setContactnumber(String contactnumber) {
		this.contactnumber = contactnumber;
	}

	public String getPhonetype() {
		return phonetype;
	}

	public void setPhonetype(String phonetype) {
		this.phonetype = phonetype;
	}

	public Person getPerson() {
		return person;
	}

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

}

Details of the above files are as below:

The one-to-many association between person and phone in the following manner (added to Person.hbm.xml):
```
    
    
```
cascade=”all” is used to specify that all operations should be cascaded along the association.
inverse=”true” it tells Hibernate that both mappings(Person and Phone) map to the same single FK relationship. Otherwise, Hibernate will try to update both sides separately, and not in any order. So it might try to insert a child before the parent is inserted, and the database will throw an error. Hence hibernate will not issue sql statements when parent is modified. SQL statements will be issued to the DB only when the association is modified at the child end.

Corresponding code in model class (Person.java) is as follows:

private Set personPhoneNumbers = new HashSet();

public Set getPersonPhoneNumbers() {
		return personPhoneNumbers;
	}

	public void setPersonPhoneNumbers(Set personPhoneNumbers) {
		this.personPhoneNumbers = personPhoneNumbers;
	}

	public void addPhone(Phone phone) {
		phone.setPerson(this);
		this.personPhoneNumbers.add(phone);
}

In Phone.hbm.xml file the following code is added:

Corresponding code in Phone.java is:

private Person person;

public Person getPerson() {
	return person;
}

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

The following addPhone() method in the Person.java, makes sure that personid field in the PHONE table is not set to null.
```
public void addPhone(Phone phone) {
	phone.setPerson(this);
	this.phones.add(phone);
}
```

4. Adding Hibernate Configuration file

As a next step let’s add the hibernate.cfg.xml to the directory:/src/main/resources . Write the new file hibernate.cfg.xml in this directory. The hibernate.cfg.xml is as follows:




    
         
        org.hibernate.dialect.MySQLDialect
		com.mysql.jdbc.Driver
        jdbc:mysql://localhost:3306/manisha
		 root
        root

        
        1
        true
        true

        org.hibernate.cache.NoCacheProvider
        
        create

In the above file we have set the database connection to MYSQL database . The show_sql option, if set to true will display all the executed SQL queries on the console. The property hbm2ddl.auto , if set to create, creates the schema, destroying the previous data. At the end of the file we add the Person.hbm.xml and Phone.hbm.xml files to the configuration.

5. Create Utility class

Next, we will write a utility class to take care of Hibernate start up and retrieve the session easily. We will write the file src\main\java\net\javabeat\hibernate\HibernateUtil.java as below:

package net.javabeat.hibernate;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
	private static final SessionFactory sessionFactory;
	static {
		try {
			sessionFactory = new Configuration().configure()
					.buildSessionFactory();
		} catch (Throwable ex) {
			System.err.println("Initial SessionFactory creation failed." + ex);
			throw new ExceptionInInitializerError(ex);
		}
	}

	public static SessionFactory getSessionFactory() {
		return sessionFactory;
	}
}

6. Revise the App class

Next we will revise the App.java (generated by Maven). This class tests the one-to-many relationship by creating and listing the person names and corresponding phone numbers as below:

package net.javabeat.hibernate;

import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

/**
 * Main class
 *
 */
public class App {
	public static void main(String[] args) {
		System.out.println("Maven + Hibernate + SQL  One to Many XML Mapping ");
		Session session = HibernateUtil.getSessionFactory().openSession();
		session.beginTransaction();
		App app = new App();

		app.savePersonInfo("Manisha");

		app.listPersonInfo();

	}

	public Long savePersonInfo(String personName) {
		Session session = HibernateUtil.getSessionFactory().openSession();
		session.beginTransaction();
		Long personId = null;
		Transaction transaction = null;
		try {
			transaction = session.beginTransaction();
			Person person = new Person();
			person.setName(personName);

			Phone ph1 = new Phone();
			Phone ph2 = new Phone();
			ph1.setContactnumber("4100000");
			ph1.setPhonetype("Landline");

			ph2.setContactnumber("988000045");
			ph2.setPhonetype("Mobile");
			person.addPhone(ph1);
			person.addPhone(ph2);
			session.save(person);

			transaction.commit();
		} catch (HibernateException e) {
			transaction.rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
		return personId;
	}

	/*
	 * Lists the person's from database table
	 */
	public void listPersonInfo() {
		Session session = HibernateUtil.getSessionFactory().openSession();
		Transaction transaction = null;
		try {
			transaction = session.beginTransaction();
			@SuppressWarnings("unchecked")
			List personList = session.createQuery("FROM Person").list();

			System.out.println("List size: " + (personList).size());
			for (Iterator iterator = personList.iterator(); iterator.hasNext();) {
				Person person = (Person) iterator.next();
				Set ph = new HashSet();
				ph = person.getPersonPhoneNumbers();
				for (Phone p : ph) {
					System.out.println("***************************");
					System.out.println(person.getName());
					System.out.println(" Phone Type: " + p.getPhonetype());
					System.out.println(" Phone Number: " + p.getContactnumber());
					System.out.println("***************************");
				}
			}
			transaction.commit();
		} catch (HibernateException e) {
			transaction.rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
	}

}

Here the savePersonInfo() method is used to save a new Person object and Phone object to the database.

The listPersonInfo() method is used to list name of each person in PERSON table and their corresponding phone numbers and type from PHONE table. Here we use Hibernate Query Language (HQL). The query “from Person” returns a list of all the data in the PERSON table and their corresponding phone numbers from PHONE table. Note that in the HQL we only specify the java class names and not the table names. Later, using the for loop we iterate the list the data from Person and corresponding Phone table and hence display them on the console.

8. Final project structure

Once you have created all these source files, your project structure should look like following:

9. Execution of the above code

Now let us execute the code we created above. Let’s run the App class. Right click on App.java >Run As > Java Application. On start of each thread, a database schema will be created and the following actions will happen.

Output on the console:
Following output is displayed on the console:

Maven + Hibernate + SQL  One to Many XML Mapping
log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
Hibernate:
    insert
    into
        person
        (NAME)
    values
        (?)
Hibernate:
    insert
    into
        PHONE
        (CONTACTNUMBER, PHONETYPE, PERSONID)
    values
        (?, ?, ?)
Hibernate:
    insert
    into
        PHONE
        (CONTACTNUMBER, PHONETYPE, PERSONID)
    values
        (?, ?, ?)
Hibernate:
    select
        person0_.ID as ID0_,
        person0_.NAME as NAME0_
    from
        person person0_
List size: 1
Hibernate:
    select
        personphon0_.PERSONID as PERSONID1_,
        personphon0_.ID as ID1_,
        personphon0_.ID as ID1_0_,
        personphon0_.CONTACTNUMBER as CONTACTN2_1_0_,
        personphon0_.PHONETYPE as PHONETYPE1_0_,
        personphon0_.PERSONID as PERSONID1_0_
    from
        PHONE personphon0_
    where
        personphon0_.PERSONID=?
***************************
Manisha
 Phone Type: Landline
 Phone Number: 4100000
***************************
***************************
Manisha
 Phone Type: Mobile
 Phone Number: 988000045
***************************

Using a Common Join Table

This technique uses a join table to store the associations between Person and Phone entities. We use many-to-many element to create the one-to-many relationship between the Person and Phone entities. Since a Person can have any number of phone numbers we use a collection to hold the values. In this case we use Set. Many-to-many element is usually used to create many-to-many relationship, here we place the unique constraint on the PHONE_ID column, this makes the relationship one-to-many.

Summary

Source Code Download for HibernateOneToManyXML (13)

In this post we demonstrated one-to-many relation using hibernate mapping files. We discussed about various techniques of one-to-many associations. We initially created a Java project using Maven, made it compatible with eclipse. Then we created hibernate mapping files and created the corresponding model classes (foreign key association). We then set the values in our main class(App.java), which in turn added the values to respective tables. We also listed the data from the tables. In the next post we shall see an example of Hibernate One-to-Many mapping(using Annotations).If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here

Hibernate One-To-One Mapping Example Using Java Annotations

Manisha Patil — Sat, 16 Mar 2013 14:52:32 +0000

Connect to us ( @twitter | @facebook )

In this tutorial we will write a simple Java project to demonstrate Hibernate one to one Mapping using Java Annotations. We will first create a Java project using Maven and then will add Hibernate on it. If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here. If you are beginner for hibernate, please read the articles about introduction to hibernate, interceptors in hibernate and spring & hibernate integration. We also recommend good reference books for learning hibernate in our post about hibernate books.

Source Code Download for HibernateOneToOneAnnotation (8)

One To One Relationship

A one-to-one relationships occurs when one entity is related to exactly one occurrence in another entity. Consider the following relationship:

According to the relationship each Person should have a unique address. Hence we will need two tables namely PERSON and ADDRESS to create this relation. In Hibernate, one-to-one relationship between entities can be created by 3 different techniques. In each technique though @OneToOne annotation has to be used. These techniques are:

Using shared primary key: In this technique, hibernate will ensure that it will use a common primary key value in both the tables. This way primary key of entity PERSON can safely be assumed the primary key of entity ADDRESS also. The example demonstrated in this post is using shared primary key. The relational model is shown below:
Using foreign key association: In this association, a foreign key column is created in the owner entity. For example, if we make PERSON as owner entity, then a extra column “ADDRESSID” will be created in PERSON table. This column will store the foreign key for ADDRESS table. The relational model is shown below:
Using a common join table: In this association, the join table will have two foreign key columns (i.e) it will have both the primary key columns from the two entity tables (for example PERSONID and ADDRESSID from PERSON and ADDRESS entity tables respectively). One of the foreign keys will serve as the primary key for the join table. An unique constraint will be applied on the remaining foreign key column and hence both the foreign key columns will not have the duplicate values.
The relational model is shown below:

Technologies Used:

Following are the tools and technologies required for this project:

Java JDK 5 or above
Eclipse IDE 3.2 or above
Maven 3.0 or above
Hibernate 3.0 or above (Hibernate Downloads)
MySQL 5 above (MySql Downloads)

1.Environment Setup

Refer post Hibernate, Maven and HSQL – Example Project (XML Mapping) for environment setup (follow steps 1,2 and 3). Pass the following command in the step.1, to create a java project using Maven:

mvn archetype:generate
-DgroupId=net.javabeat.hibernate
-DartifactId=HibernateOneToOneAnnotation
-DarchetypeArtifactId=maven-archetype-quickstart
-DinteractiveMode=false

2. Adding dependencies to pom.xml

We need to add the Hibernate, MYSQL and some other dependencies to the Maven pom.xml as shown below:

 
 	4.0.0
 	net.javabeat.hibernate
 	HibernateOneToOneAnnotation
 	jar
 	1.0-SNAPSHOT
 	HibernateOneToOneAnnotation
 	http://maven.apache.org
 	
 		
 		
 			org.hibernate
 			hibernate
 			4.1.9.Final
 		

 		
 			mysql
 			mysql-connector-java
 			5.1.10
 		
 		
 			org.hibernate
 			hibernate-annotations
 			3.3.1.GA
 		
 		
 			dom4j
 			dom4j
 			1.6.1
 		
 		
 			commons-logging
 			commons-logging
 			1.1.1
 		
 		
 			commons-collections
 			commons-collections
 			3.2.1
 		
 		
 			cglib
 			cglib
 			2.2
 		
 		
 			asm
 			asm
 			4.0
 		
 		
 			dom4j
 			dom4j
 			1.6.1
 		
 		
 			ehcache
 			ehcache
 			1.2.3
 		
 		
 			hibernate-tools
 			hibernate-tools
 			3.2.3.GA
 		
 		
 			jta
 			jta
 			1.1
 		
 		
 			log4j
 			log4j
 			1.2.11
 		
 		
 			oscache
 			oscache
 			2.1
 		
 		
 			persistence-api
 			persistence-api
 			1.0

As a next step, let’s execute the following command so that maven will download all the required JARs and add the same to eclipse classpath. The command line point to the directory C:\HibernateProject\HibernateOneToManyXML and execute the following command:

mvn eclipse:eclipse

3. Create Model Classes (Shared primary key technique)

As a next step let’s create the model classes
src\main\java\net\javabeat\hibernate\Person.java and src\main\java\net\javabeat\hibernate\Address.java using Annotations. @PrimaryKeyJoinColumn is the main annotation to be used in shared primary key technique. The model classes are as below

Person.java

package net.javabeat.hibernate;

import java.io.Serializable;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;
import javax.persistence.UniqueConstraint;

/**
 * Model class for Person
 */
@Entity
@Table(name = "PERSON", uniqueConstraints = { @UniqueConstraint(columnNames = "personId") })
public class Person implements Serializable {
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	@Column(name = "personId")
	private Long personId;

	@Column(name = "name")
	private String name;

	@OneToOne(cascade = CascadeType.ALL)
	@PrimaryKeyJoinColumn
	private Address address;

	public Person() {
	}

	public Person(String name, Address address) {
		super();
		this.name = name;
		this.address = address;
	}

	public Long getPersonId() {
		return personId;
	}

	public void setPersonId(Long personId) {
		this.personId = personId;
	}

	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;
	}

}

In the above file we see that we have used @PrimaryKeyJoinColumn for the Address entity. Following if a piece of code from the above file:

@OneToOne(cascade = CascadeType.ALL)
@PrimaryKeyJoinColumn
private Address address;

Address.java

package net.javabeat.hibernate;

import java.io.Serializable;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import javax.persistence.UniqueConstraint;

import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.Parameter;

@Entity
@Table(name = "ADDRESS", uniqueConstraints = { @UniqueConstraint(columnNames = "personId") })
public class Address implements Serializable {
	@Id
	@Column(name = "personId", unique = true, nullable = false)
	@GeneratedValue(generator = "gen")
	@GenericGenerator(name = "gen", strategy = "foreign",
        parameters = @Parameter(name = "property", value = "person"))
	private Long personId;

	@Column(name = "street")
	private String street;

	@Column(name = "city")
	private String city;

	@Column(name = "state")
	private String state;

	@Column(name = "zipcode")
	private String zipcode;

	@OneToOne(mappedBy = "address", cascade = CascadeType.ALL)
	private Person person;

	public Address() {

	}

	public Address(String street, String city, String state, String zipcode) {
		this.street = street;
		this.city = city;
		this.state = state;
		this.zipcode = zipcode;

	}

	public String getStreet() {
		return street;
	}

	public void setStreet(String street) {
		this.street = street;
	}

	public String getCity() {
		return city;
	}

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

	public String getState() {
		return state;
	}

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

	public String getZipcode() {
		return zipcode;
	}

	public void setZipcode(String zipcode) {
		this.zipcode = zipcode;
	}

	public Person getPerson() {
		return person;
	}

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

	public Long getPersonId() {
		return personId;
	}

	public void setPersonId(Long personId) {
		this.personId = personId;
	}

}

Here we see that Address entity will remain dependent on owner entity for the mapping. Following is a piece of code from the above file:

@OneToOne(mappedBy = "address", cascade = CascadeType.ALL)
	private Person person;

4. Adding Hibernate Configuration file

As a next step let’s add the hibernate.cfg.xml to the directory:/src/main/resources . Write the new file hibernate.cfg.xml in this directory. The hibernate.cfg.xml is as follows:




    
       
        org.hibernate.dialect.MySQLDialect
		com.mysql.jdbc.Driver
        jdbc:mysql://localhost:3306/manisha
		 root
        root

        
        1
        true
        true

        org.hibernate.cache.NoCacheProvider
        
        create

Also we have added the Annotation based entity classes Person.java and Address.java to the above file.

5. Create Utility class

Next, we will write a utility class to take care of Hibernate start up and retrieve the session easily. We will write the file src\main\java\net\javabeat\hibernate\HibernateUtil.java as below:

package net.javabeat.hibernate;

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

public class HibernateUtil {
	private static final SessionFactory sessionFactory;
	static {
		try {
			sessionFactory = 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;
	}
}

6. Revise the App class

Next we will revise the App.java (generated by Maven). This class tests the one-to-one relationship by creating and listing the person names and corresponding addresses as below:

package net.javabeat.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

/**
 * Main class
 *
 */
public class App {
    public static void main(String[] args) {
        System.out.println("Maven + Hibernate + MYSQL One to One Mapping Annotations");
        Session session = HibernateUtil.getSessionFactory().openSession();
        session.beginTransaction();
        App app = new App();

        Address address1 = new Address("M.G.Road", "Bangalore", "Karnataka",
                "56000");
        Address address2 = new Address("Tilak Road", "Pune", "Maharashtra",
                "411207");

        app.savePersonInfo("Jiya", address1);
        app.savePersonInfo("Manisha", address2);

        app.listPersonInfo();

    }

    public Long savePersonInfo(String personName, Address address) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        session.beginTransaction();
        Long personId = null;
        Transaction transaction = null;
        try {
            transaction = session.beginTransaction();
            Person person = new Person(personName, address);

            address.setPerson(person);
            session.save(person);

            transaction.commit();
        } catch (HibernateException e) {
            transaction.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
        return personId;
    }

    /*
     * Lists the person's from database table
     */
    public void listPersonInfo() {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction transaction = null;
        try {
            transaction = session.beginTransaction();
            @SuppressWarnings("unchecked")
            List personList = session.createQuery("from Person").list();
            for (Iterator iterator = personList.iterator(); iterator
                    .hasNext();) {
                Person person = (Person) iterator.next();
                System.out.println(person.getName());
                System.out.println(person.getAddress().getStreet() + " "
                        + person.getAddress().getCity() + " "
                        + person.getAddress().getState() + " "
                        + person.getAddress().getZipcode());
            }
            transaction.commit();
        } catch (HibernateException e) {
            transaction.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

}

Here the savePersonInfo() method is used to save a new Person object and Address object to the database. In the savePersonInfo() method a new object of the Person class is created and the name value and address is set. The personId value is auto generated so the value need not be set here. We then save the Person object to the Address object. The session.save() method is used to persist the value in the database and once the value is saved, the id value (Primary key) is returned. Once the object is saved, the transaction is committed. If any exception occurs then the transaction is rolledback. The transaction ends either through commit or rollback action. Once the transaction ends the session is closed.

The listPersonInfo() method is used to list name of each person in PERSON table and their corresponding addresses from ADDRESS table. Here we use Hibernate Query Language (HQL). The query “from Person” returns a list of all the data in the PERSON table and their corresponding addresses from ADDRESS table. Note that in the HQL we only specify the java class names and not the table names. Later, using the for loop we iterate the list the data from Person and corresponding Address table and hence display them on the console.

8. Final project structure

Once you have created all these source files, your project structure should look like following:

9. Execution of the above code

Output on the console:
Following output is displayed on the console:

Maven + Hibernate + MYSQL One to One Mapping Annotations
log4j:WARN No appenders could be found for logger (org.hibernate.cfg.annotations.Version).
log4j:WARN Please initialize the log4j system properly.
Hibernate:
    insert
    into
        PERSON
        (name)
    values
        (?)
Hibernate:
    insert
    into
        ADDRESS
        (city, state, street, zipcode, personId)
    values
        (?, ?, ?, ?, ?)
Hibernate:
    insert
    into
        PERSON
        (name)
    values
        (?)
Hibernate:
    insert
    into
        ADDRESS
        (city, state, street, zipcode, personId)
    values
        (?, ?, ?, ?, ?)
Hibernate:
    select
        person0_.personId as personId0_,
        person0_.name as name0_
    from
        PERSON person0_
Hibernate:
    select
        address0_.personId as personId1_2_,
        address0_.city as city1_2_,
        address0_.state as state1_2_,
        address0_.street as street1_2_,
        address0_.zipcode as zipcode1_2_,
        person1_.personId as personId0_0_,
        person1_.name as name0_0_,
        address2_.personId as personId1_1_,
        address2_.city as city1_1_,
        address2_.state as state1_1_,
        address2_.street as street1_1_,
        address2_.zipcode as zipcode1_1_
    from
        ADDRESS address0_
    left outer join
        PERSON person1_
            on address0_.personId=person1_.personId
    left outer join
        ADDRESS address2_
            on person1_.personId=address2_.personId
    where
        address0_.personId=?
Hibernate:
    select
        address0_.personId as personId1_2_,
        address0_.city as city1_2_,
        address0_.state as state1_2_,
        address0_.street as street1_2_,
        address0_.zipcode as zipcode1_2_,
        person1_.personId as personId0_0_,
        person1_.name as name0_0_,
        address2_.personId as personId1_1_,
        address2_.city as city1_1_,
        address2_.state as state1_1_,
        address2_.street as street1_1_,
        address2_.zipcode as zipcode1_1_
    from
        ADDRESS address0_
    left outer join
        PERSON person1_
            on address0_.personId=person1_.personId
    left outer join
        ADDRESS address2_
            on person1_.personId=address2_.personId
    where
        address0_.personId=?
Jiya
M.G.Road Bangalore Karnataka 56000
Manisha
Tilak Road Pune Maharashtra 411207

Using Foreign Key Technique

In such a association, refer the Address entity in Person class as follows:

@OneToOne
@JoinColumn(name="addressId")
private Address address;

If no @JoinColumn is declared on the owner entity, the defaults apply. A join column(s) will be created in the owner entity table and its name will be the concatenation of the name of the relationship in the owner side, _ (underscore), and the name of the primary key column(s) in the owned side.

In a bidirectional relationship, one of the sides has to be the owner entity. The owner is responsible for the association column(s) update. To declare a side as not responsible for the relationship, the attribute mappedBy is used. mappedBy refers to the property name of the association on the owner side. Following is the example code:

@OneToOne(mappedBy="address")
private Person person;

Using a Common Join Table

In this technique, main annotation to be used is @JoinTable. This annotation is used to define the new table name (this is mandatory) and foreign keys from both of the tables. Folllowing is the example code:

@OneToOne(cascade = CascadeType.ALL)
@JoinTable(name="PERSON_ADDRESS", joinColumns = @JoinColumn(name="personId"),
inverseJoinColumns = @JoinColumn(name="addressId"))
private Address address;

@JoinTable annotation is used in Person class. It declares that a new table PERSON_ADDRESS will be created with two columns personId (primary key of PERSON table) and addressId (primary key of ADDRESS table).

Summary

Source Code Download for HibernateOneToOneAnnotation (8)

In this post we demonstrated one-to-one relation using Java annotations. We discussed about various techniques of one-to-one associations using annotations. We initially created a Java project using Maven, made it compatible with eclipse. Then we used annotations and created the model classes (primary key sharing association). We then set the values in our main class(App.java), which in turn added the values to respective tables. We also listed the data from the tables. In the next post we shall see an example of Hibernate One-to-Many mapping(XML mapping).If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here

Hibernate One-To-One Mapping(XML mapping)

Manisha Patil — Fri, 15 Mar 2013 08:08:26 +0000

Connect to us ( @twitter | @facebook )

In this tutorial we will write a simple Java project to demonstrate Hibernate one to one Mapping. We shall use HSQL as the database and Maven for creating the project and making it compatible with eclipse. We will first create a Java project using Maven and then will add Hibernate on it. HSQL database is used to make the project simple, as we can use in-memory database and we would need only a JAR file to be included in our project. If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here. If you are beginner for hibernate, please read the articles about introduction to hibernate, interceptors in hibernate and spring & hibernate integration. We also recommend good reference books for learning hibernate in our post about hibernate books.

Source Code Download for HibernateOneToOneXML (6)

One To One Relationship

A one-to-one relationships occurs when one entity is related to exactly one occurrence in another entity. Consider the following relationship:

According to the relationship each Person should have a unique address. Hence we will need two tables namely PERSON and ADDRESS to create this relation. The relational model is shown below:

Hence following points would be included in our example project demonstrating One-to-One relationship :

We will write two POJO classes (Person.java and Address.java ) and corresponding mapping files would be Person.hbm.xml and Address.hbm.xml respectively. Here the relation is, one address is assigned for one person only.
To achieve one to one relationship, both tables have the same PERSON_ID as primary key. In ADDRESS table, PERSON_ID is the primary key and also a foreign key to PERSON table. This is the common way of define “one-to-one” table relationship.

Pre-Requisites

Following are the tools and technologies required for this project:

Java JDK 5 or above
Eclipse IDE 3.2 or above
Maven 3.0 or above
Hibernate 3.0 or above (Download from http://hibernate.org/downloads)
HsqlDB (Download from http://hsqldb.org/)

1. Generating Maven Java project compatible with Eclipse

We will create a Java project using Maven (Refer post Creating Simple Java Project Using Apache Maven). Open the command line window and execute the following command:

mvn archetype:generate
-DgroupId=net.javabeat.hibernate
-DartifactId=HibernateOneToOneXML
-DarchetypeArtifactId=maven-archetype-quickstart
-DinteractiveMode=false

On execution of the above command, a java project HibernateOneToOneXML is created (In our case we have created it in the directory C:\HibernateProject). This java project already has a directory structure (as explained in the post (Refer post Creating Simple Java Project Using Apache Maven). To make this project compatible with eclipse, let’s execute the following command:

mvn eclipse:eclipse

2. Import project into Eclipse

Open Eclipse and import the above Java project as explained below:

File > Import… > General > Existing Projects into Workspace > Choose above Java project

Build-path settings
Goto Window > Preferences… > Java > Build Path > Classpath Variables >

Define new variable M2_REPO pointing to your local maven repository. (In our case it is:C:/Documents and Settings/Manisha/.m2/repository).
Define new variable HSQLDB pointing to the hsqldb.jar. (C:/tools/hsqldb-2.2.9/hsqldb/lib/hsqldb.jar).

3. Adding the Hibernate and HSQLDB Dependency to pom.xml

We need to add the Hibernate, HSQLDB and some other dependencies to the Maven pom.xml as shown below:

 
 4.0.0
 net.javabeat.hibernate
 HibernateOneToOneXML
 jar
 1.0-SNAPSHOT
 HibernateOneToOneXML
 http://maven.apache.org
 
   
     junit
     junit
     3.8.1
     test
   

  
     org.hibernate
     hibernate
     4.1.9.Final
  
  
     org.hsqldb
     hsqldb
     2.2.9
  
  
     org.hibernate
     hibernate-annotations
     3.3.1.GA
  
  
     dom4j
     dom4j
     1.6.1
  
  
     commons-logging
     commons-logging
     1.1.1
  
  
     commons-collections
     commons-collections
     3.2.1
  
  
     cglib
     cglib
     2.2
  
  
     asm
     asm
     4.0
  
  
     dom4j
     dom4j
     1.6.1
  
  
      ehcache
      ehcache
      1.2.3
  
  
      hibernate-tools
      hibernate-tools
      3.2.3.GA
  
  
      jta
      jta
      1.1
  
  
      log4j
      log4j
      1.2.11
  
  
      oscache
      oscache
      2.1
  
  
      persistence-api
      persistence-api
      1.0

As a next step, let’s execute the following command so that maven will download all the required JARs and add the same to eclipse classpath.

mvn eclipse:eclipse

4. Create Model Classes

As a next step let’s create the model classes
src\main\java\net\javabeat\hibernate\Person.java and src\main\java\net\javabeat\hibernate\Address.java as below:

Person.java

package net.javabeat.hibernate;

import java.io.Serializable;

/**
 * Model class for Person
 */
public class Person implements Serializable {
	private Long personId;
	private String name;

	private Address address;

	public Person() {
	}

	public Long getPersonId() {
		return personId;
	}

	public void setPersonId(Long personId) {
		this.personId = personId;
	}

	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;
	}

}

Address.java

package net.javabeat.hibernate;

import java.io.Serializable;

public class Address implements Serializable {
	private String street;
	private String city;
	private String state;
	private String zipcode;
	private Person person;
	private Long personId;

	public Address() {

	}

	public Address(String street, String city, String state, String zipcode) {
		this.street = street;
		this.city = city;
		this.state = state;
		this.zipcode = zipcode;

	}

	public String getStreet() {
		return street;
	}

	public void setStreet(String street) {
		this.street = street;
	}

	public String getCity() {
		return city;
	}

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

	public String getState() {
		return state;
	}

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

	public String getZipcode() {
		return zipcode;
	}

	public void setZipcode(String zipcode) {
		this.zipcode = zipcode;
	}

	public Person getPerson() {
		return person;
	}

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

	public Long getPersonId() {
		return personId;
	}

	public void setPersonId(Long personId) {
		this.personId = personId;
	}

}

Hibernate Mapping Files

Next let’s write a Hibernate XML Mapping files to the directory:/src/main/resources . Create the resources directory as follows: Right click on Project > New > Source Folder > Give folder name “/src/main/resources/” and click Finish.
Write the file src\main\resources\net\javabeat\hibernate\Person.hbm.xml for the model Person and
src\main\resources\net\javabeat\hibernate\Address.hbm.xml for the model class Address.
The contents of these files are as below:

Person.hbm.xml

Address.hbm.xml





	
		This class contains the address of each person
			details.
		
			
			
                person

In the above hibernate mapping file we are implementing One-to-One relationship. For both the model classes we are using a single primary key personId. In Adress hbm file we have defined a foreign identifier generator so that primary it uses primary key of Person table.

5. Adding Hibernate Configuration file

As a next step let’s add the hibernate.cfg.xml to the directory:/src/main/resources . Write the new file hibernate.cfg.xml in this directory. The hibernate.cfg.xml is as follows:




    
        
        org.hibernate.dialect.HSQLDialect
		org.hsqldb.jdbcDriver
        jdbc:hsqldb:mem:test
		 sa
        

        
        1
        truetrue

        org.hibernate.cache.NoCacheProvider
        
        update

In the above file we have set the database connection to HSQL-In memory database (mem is in-memeory, and test is the database name). The show_sql option, if set to true will display all the executed SQL queries on the console. The property hbm2ddl.auto , if set to update, will change the existing database schema on each start up. In the end we add the Person.hbm.xml and Address.hbm.xml files to the configuration.

Note : In case you want to use any other database then, you need to change these properties -
“dialect”, “connection.driver_class”, “connection.url”, “connection.username”, and “connection.password”

6. Create Utility class

Next, we will write a utility class to take care of Hibernate start up and retrieve the session easily. We will write the file src\main\java\net\javabeat\hibernate\HibernateUtil.java as below:

package net.javabeat.hibernate;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
    private static final SessionFactory sessionFactory;
    static {
        try {
            sessionFactory = new Configuration().configure()
            .buildSessionFactory();
        } catch (Throwable ex) {
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

7. Revise the App class

Next we will revise the App.java (generated by Maven). This class tests the one-to-one relationship by creating and listing the person names and coressponding addresses as below:

package net.javabeat.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

/**
 * Main class
 *
 */
public class App {
	public static void main(String[] args) {
		System.out.println("Maven + Hibernate + HSQL XML One to One Mapping ");
		Session session = HibernateUtil.getSessionFactory().openSession();
		session.beginTransaction();
		App app = new App();

		Address address1 = new Address("M.G.Road", "Bangalore", "Karnataka",
				"56000");
		Address address2 = new Address("Tilak Road", "Pune", "Maharashtra",
				"411207");

		app.savePersonInfo("Jiya", address1);
		app.savePersonInfo("Manisha", address2);

		app.listPersonInfo();

	}

	public Long savePersonInfo(String personName, Address address) {
		Session session = HibernateUtil.getSessionFactory().openSession();
		session.beginTransaction();
		Long personId = null;
		Transaction transaction = null;
		try {
			transaction = session.beginTransaction();
			Person person = new Person();
			person.setName(personName);

			person.setAddress(address);
			address.setPerson(person);
			session.save(person);

			transaction.commit();
		} catch (HibernateException e) {
			transaction.rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
		return personId;
	}

	/*
	 * Lists the person's from database table
	 */
	public void listPersonInfo() {
		Session session = HibernateUtil.getSessionFactory().openSession();
		Transaction transaction = null;
		try {
			transaction = session.beginTransaction();
			@SuppressWarnings("unchecked")
			List personList = session.createQuery("from Person").list();
			for (Iterator iterator = personList.iterator(); iterator
					.hasNext();) {
				Person person = (Person) iterator.next();
				System.out.println(person.getName());
				System.out.println(person.getAddress().getStreet() + " "
						+ person.getAddress().getCity() + " "
						+ person.getAddress().getState() + " "
						+ person.getAddress().getZipcode());
			}
			transaction.commit();
		} catch (HibernateException e) {
			transaction.rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
	}

}

8. Final project structure

Once you have created all these source files, your project structure should look like following:

9. Execution of the above code

Output on the console:
Following output is displayed on the console:

Maven + Hibernate + HSQL XML One to One Mapping
log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
Hibernate:
    insert
    into
        person
        (PERSON_ID, NAME)
    values
        (null, ?)
Hibernate:
    insert
    into
        address
        (ADDRESS_STREET, ADDRESS_CITY, ADDRESS_STATE, ADDRESS_ZIPCODE, PERSON_ID)
    values
        (?, ?, ?, ?, ?)
Hibernate:
    insert
    into
        person
        (PERSON_ID, NAME)
    values
        (null, ?)
Hibernate:
    insert
    into
        address
        (ADDRESS_STREET, ADDRESS_CITY, ADDRESS_STATE, ADDRESS_ZIPCODE, PERSON_ID)
    values
        (?, ?, ?, ?, ?)
Hibernate:
    select
        person0_.PERSON_ID as PERSON1_0_,
        person0_.NAME as NAME0_
    from
        person person0_
Hibernate:
    select
        address0_.PERSON_ID as PERSON1_1_0_,
        address0_.ADDRESS_STREET as ADDRESS2_1_0_,
        address0_.ADDRESS_CITY as ADDRESS3_1_0_,
        address0_.ADDRESS_STATE as ADDRESS4_1_0_,
        address0_.ADDRESS_ZIPCODE as ADDRESS5_1_0_
    from
        address address0_
    where
        address0_.PERSON_ID=?
Hibernate:
    select
        address0_.PERSON_ID as PERSON1_1_0_,
        address0_.ADDRESS_STREET as ADDRESS2_1_0_,
        address0_.ADDRESS_CITY as ADDRESS3_1_0_,
        address0_.ADDRESS_STATE as ADDRESS4_1_0_,
        address0_.ADDRESS_ZIPCODE as ADDRESS5_1_0_
    from
        address address0_
    where
        address0_.PERSON_ID=?
Jiya
M.G.Road Bangalore Karnataka 56000
Manisha
Tilak Road Pune Maharashtra 411207

Summary

Source Code Download for HibernateOneToOneXML (6)

In this post we first created a simple Java project using Maven and made it compatible with eclipse. Then we added the Hibernate one to one relation by creating two hibernate XML files Person and Address and relating them uing the one-to-one tag in both the files. We used a simple HSQL database, to insert records into Person and Address table and also listed these records. In the next article we shall look into Hibernate One-To-One Mapping using Java Annotations. If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here

Hibernate, Maven and HSQL – Example Project (Using Annotations)

Manisha Patil — Mon, 11 Mar 2013 14:28:21 +0000

Connect to us ( @twitter | @facebook )

In this tutorial we will write a simple Java project to demonstrate Hibernate, HSQL and Maven using Java 5 Annotations. For this we will use our previous example in the post Hibernate, Maven and HSQL – Example Project (XML Mapping)) as base and convert it from XML Mapping to Annotation.
HSQL database is used to make the project simple, as we can use in-memory database and we would need only a JAR file to be included in our project. If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here. If you are beginner for hibernate, please read the articles about introduction to hibernate, interceptors in hibernate and spring & hibernate integration. We also recommend good reference books for learning hibernate in our post about hibernate books..

Following are the tools and technologies required for this project:

Java JDK 5 or above
Eclipse IDE 3.2 or above
Maven 3.0 or above
Hibernate 3.0 or above (Download from http://hibernate.org/downloads)
HsqlDB (Download from http://hsqldb.org/)

1. Generating Maven Java project compatible with Eclipse

Follow the steps in the post Hibernate, Maven and HSQL – Example Project (XML Mapping)) to create project structure. Or you can directly download the source code from above post in Eclipse and rename the project in eclipse as HibernateHelloWorldAnnotation.

2.Updating the Hibernate dependency in pom.xml

As we are going to use Annotation mapping in Hibernate we will update our existing pom.xml file as below:

 
 4.0.0
 net.javabeat.hibernate
 HibernateHelloWorldXML
 jar
 1.0-SNAPSHOT
 HibernateHelloWorldXML
 http://maven.apache.org
 
   
     junit
     junit
     3.8.1
     test
   

  
     org.hibernate
     hibernate-annotations
     4.1.9.Final
  
  
     org.hsqldb
     hsqldb
     2.2.9
  
  
     dom4j
     dom4j
     1.6.1
  
  
     commons-logging
     commons-logging
     1.1.1
  
  
     commons-collections
     commons-collections
     3.2.1
  
  
     cglib
     cglib
     2.2
  
  
     asm
     asm
     4.0
  
  
     dom4j
     dom4j
     1.6.1
  
  
      ehcache
      ehcache
      1.2.3
  
  
      hibernate-tools
      hibernate-tools
      3.2.3.GA
  
  
      jta
      jta
      1.1
  
  
      log4j
      log4j
      1.2.11
  
  
      oscache
      oscache
      2.1
  
  
      persistence-api
      persistence-api
      1.0

As a next step, let’s execute the following command so that maven will download all the required JARs and update eclipse classpath. Go to the directory of the project (in our case it is C:\HibernateHelloWorldXML) and execute the following command:

mvn eclipse:eclipse

This step is optional. If your Eclipse has Maven plugin installed in your IDE (Latest eclipse comes with this plugin built-in) you can just enable Maven dependencies by following these instructions : Right click on project > Maven > Enable Dependency Management.

3. Delete the unused Hibernate Mapping file

The file src\main\resources\net\javabeat\hibernate\Contact.hbm.xml is not required anymore. Delete this file from the project.

4. Update the Model class file

We will add simple annotations to the model class (src\main\java\net\javabeat\hibernate\Contact.java) as below:

package net.javabeat.hibernate;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 * Model class for Conact
 */
@Entity
@Table(name="CONTACT")
public class Contact implements Serializable {
   @Id
   @GeneratedValue
   private Integer contactId;

   @Column(name="name")
   private String name;

   public Contact() {
   }

   public Integer getContactId() {
      return contactId;
   }

   public void setContactId(Integer contactId) {
      this.contactId = contactId;
   }

   public String getName() {
      return name;
   }

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

}

5.Update the Hibernate Utility class

In our previous post for XML mapping, we were using Configuration class to generate SessionFactory object. In HibernateUtil we had following line of code:

sessionFactory = new Configuration().configure().buildSessionFactory();

We will update this and use AnnotationConfiguration instead of Configuration(). The updated HibernateUtil.java file is as below:

package net.javabeat.hibernate;

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

public class HibernateUtil {
   private static final SessionFactory sessionFactory;
   static {
      try {
	   sessionFactory = 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;
   }
}

6. Update Hibernate Configuration file

The configuration file hibernate.cfg.xml, needs to be changed to add the new Annotation based entity class Contact.java instead of old XML Mapping Contact.hbm.xml. The updated src\main\resources\hibernate.cfg.xml is as below:






  
    
    org.hibernate.dialect.HSQLDialect
    org.hsqldb.jdbcDriver
    jdbc:hsqldb:mem:test
    sa
    

     
     1
     truetrue
     org.hibernate.cache.NoCacheProvider
     
     update

Here we have replaced

with

7. Final project structure

Once you have created all these source files, your project structure should look like following:

8. Execution of the above code

Each time a new thread starts the database schema will change the existing one as we have set hbm2ddl.auto option to update.
The SQL statement generated gets displayed on the console. This is set using the show_sql option in the hibernate configuration file.

Output on the console:

Maven + Hibernate + HSQL
log4j:WARN No appenders could be found for logger (org.hibernate.cfg.annotations.Version).
log4j:WARN Please initialize the log4j system properly.
Hibernate:
    insert
    into
        CONTACT
        (contactId, name)
    values
        (null, ?)
Hibernate:
    insert
    into
        CONTACT
        (contactId, name)
    values
        (null, ?)
Hibernate:
    insert
    into
        CONTACT
        (contactId, name)
    values
        (null, ?)
Hibernate:
    select
        contact0_.contactId as contactId0_,
        contact0_.name as name0_
    from
        CONTACT contact0_
Jiya
Manisha
Riya

Summary

In this post we updated our previous Java project from post Hibernate, Maven and HSQL – Example Project (XML Mapping)) using Maven and made it compatible with eclipse. Then we updated the Hibernate configuration file and also deleted the hibernate mapping file. We also updated our Model class with Java annotations. We used a simple HSQL database, to insert records into CONTACT table and also listed these records. In the next article we shall look into Hibernate Association (One-to-one mapping(XML mapping)). If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here

Hibernate, Maven and HSQL – Example Project (XML Mapping)

Manisha Patil — Sat, 02 Mar 2013 06:12:30 +0000

Connect to us ( @twitter | @facebook )

In this tutorial we will write a simple Java project to demonstrate Hibernate, HSQL and Maven. We will first create a Java project using Maven and then will add Hibernate on it. HSQL database is used to make the project simple, as we can use in-memory database and we would need only a JAR file to be included in our project. If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here. If you are beginner for hibernate, please read the articles about introduction to hibernate, interceptors in hibernate and spring & hibernate integration. We also recommend good reference books for learning hibernate in our post about hibernate books..

Following are the tools and technologies required for this project:

Java JDK 5 or above
Eclipse IDE 3.2 or above
Maven 3.0 or above
Hibernate 3.0 or above (Download from http://hibernate.org/downloads)
HsqlDB (Download from http://hsqldb.org/)

Download Source Code: Hibernate, Maven and HSQL - Example (28)

1. Generating Maven Java project compatible with Eclipse

We will create a Java project using Maven (Refer post Creating Simple Java Project Using Apache Maven). Open the command line window and execute the following command:

mvn archetype:generate
-DgroupId=net.javabeat.hibernate
-DartifactId=HibernateHelloWorldXML
-DarchetypeArtifactId=maven-archetype-quickstart
-DinteractiveMode=false

On execution of the above command, a java project HibernateHelloWorldXML is created (In our case we have created it in the directory C:\HibernateProject). This java project already has a directory structure (as explained in the post (Refer post Creating Simple Java Project Using Apache Maven)). To make this project compatible with eclipse, let’s execute the following command:

mvn eclipse:eclipse

The goal eclipse:eclipse generates the following eclipse configuration files:

.project and .classpath files.
.setting/org.eclipse.jdt.core.prefs with project specific compiler settings.
Various configuration files for WTP (Web Tools Project), if the parameter wtpversion is set to a valid version (WTP configuration is not generated by default).

2. Import project into Eclipse

Open Eclipse and import the above Java project as explained below:

File > Import… > General > Existing Projects into Workspace > Choose above Java project

Once the project is imported the directory structure would be as in the screen below:

Build-path settings
Goto Window > Preferences… > Java > Build Path > Classpath Variables >

Define new variable M2_REPO pointing to your local maven repository. (In our case it is:C:/Documents and Settings/Manisha/.m2/repository).
Define new variable HSQLDB pointing to the hsqldb.jar. (C:/tools/hsqldb-2.2.9/hsqldb/lib/hsqldb.jar).

3. Adding the Hibernate and HSQLDB Dependency to pom.xml

We need to add the Hibernate, HSQLDB and some other dependencies to the Maven pom.xml as shown below:

 
 4.0.0
 net.javabeat.hibernate
 HibernateHelloWorldXML
 jar
 1.0-SNAPSHOT
 HibernateHelloWorldXML
 http://maven.apache.org
 
   
     junit
     junit
     3.8.1
     test
   

  
     org.hibernate
     hibernate
     4.1.9.Final
  
  
     org.hsqldb
     hsqldb
     2.2.9
  
  
     org.hibernate
     hibernate-annotations
     3.3.1.GA
  
  
     dom4j
     dom4j
     1.6.1
  
  
     commons-logging
     commons-logging
     1.1.1
  
  
     commons-collections
     commons-collections
     3.2.1
  
  
     cglib
     cglib
     2.2
  
  
     asm
     asm
     4.0
  
  
     dom4j
     dom4j
     1.6.1
  
  
      ehcache
      ehcache
      1.2.3
  
  
      hibernate-tools
      hibernate-tools
      3.2.3.GA
  
  
      jta
      jta
      1.1
  
  
      log4j
      log4j
      1.2.11
  
  
      oscache
      oscache
      2.1
  
  
      persistence-api
      persistence-api
      1.0

As a next step, let’s execute the following command so that maven will download all the required JARs and add the same to eclipse classpath.

mvn eclipse:eclipse

4. Create Model Class and Hibernate Mapping file

As a next step let’s create the model class (src\main\java\net\javabeat\hibernate\Contact.java) as below:

package net.javabeat.hibernate;
import java.io.Serializable;
/**
   * Model class for Contact
*/
public class Contact implements Serializable {
   private Integer contactId;
   private String name;

   public Contact() {
    }

   public Integer getContactId() {
      return contactId;
   }

   public void setContactId(Integer contactId) {
       this.contactId = contactId;
   }

   public String getName() {
       return name;
   }

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

}

Next let’s write a Hibernate XML Mapping file to the directory:/src/main/resources . Create the resources directory as follows: Right click on Project > New > Source Folder > Give folder name “/src/main/resources/” and click Finish. Write the file src\main\resources\net\javabeat\hibernate\Contact.hbm.xml for the Model class as below:

The details of the above file are as below:

The hibernate-mapping element is the root element.
The class element is used to map the Java class with the database table.
The Java class name is specified using the name attribute of the class element
The database table name is specified using the table attribute of the class element.
The id element is used to create the primary key.
The name attribute of the id element refers to the property in the Contact class and the column attribute refers to the column in the CONTACT table.
The type attribute holds the hibernate mapping type, this mapping types will convert from Java to SQL data type and vice versa.
The generator element within the id element is used to automatically generate the primary key values.
The property element is used to link a property in the Java class to a column in the database table.

5. Adding Hibernate Configuration file

As a next step let’s add the hibernate.cfg.xml to the directory:/src/main/resources . Write the new file hibernate.cfg.xml in this directory. The hibernate.cfg.xml is as follows:






  
    
    org.hibernate.dialect.HSQLDialect
    org.hsqldb.jdbcDriver
    jdbc:hsqldb:mem:test
    sa
    

     
     1
     truetrue
     org.hibernate.cache.NoCacheProvider
     
     update

In the above file we have set the database connection to HSQL-In memory database (mem is in-memeory, and test is the database name). The show_sql option, if set to true will display all the executed SQL queries on the console. The property hbm2ddl.auto , if set to update, will change the existing database schema on each startup. In the end we add the Contact.hbm.xml file to the configuration.

6. Create Utility class

Next, we will write a utility class to take care of Hibernate start up and retrieve the session easily. We will write the file src\main\java\net\javabeat\hibernate\HibernateUtil.java as below:

package net.javabeat.hibernate;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
    private static final SessionFactory sessionFactory;
    static {
        try {
            sessionFactory = new Configuration().configure()
            .buildSessionFactory();
        } catch (Throwable ex) {
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

7. Revise the App class

Next we will revise the App.java (generated by Maven), to create and list the contact names as below:

package net.javabeat.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

public class App {
  public static void main(String[] args) {
     System.out.println("Maven + Hibernate + HSQL");
     Session session = HibernateUtil.getSessionFactory().openSession();
     session.beginTransaction();
     App app = new App();
     app.saveContact("Jiya");
     app.saveContact("Manisha");
     app.saveContact("Riya");
     app.listContact();
   }

   public Integer saveContact(String contactName) {
      Session session = HibernateUtil.getSessionFactory().openSession();
      session.beginTransaction();
      Integer contactId = null;
      Transaction transaction = null;
      try {
           transaction = session.beginTransaction();
           Contact contact = new Contact();
           contact.setName(contactName);
           contactId = (Integer) session.save(contact);
           transaction.commit();
       } catch (HibernateException e) {
           transaction.rollback();
           e.printStackTrace();
       } finally {
           session.close();
       }
       return contactId;
   }

   public void listContact() {
       Session session = HibernateUtil.getSessionFactory().openSession();
       Transaction transaction = null;
       try {
           transaction = session.beginTransaction();
           @SuppressWarnings("unchecked")
           List contactList = session.createQuery("from Contact")
               .list();
           for (Iterator iterator = contactList.iterator(); iterator
                   .hasNext();) {
               Contact contact = (Contact) iterator.next();
               System.out.println(contact.getName());
           }
           transaction.commit();
       } catch (HibernateException e) {
           transaction.rollback();
           e.printStackTrace();
       } finally {
           session.close();
       }
   }

}

Here the saveContact() method is used to save a new Contact object to the database. In the saveContact() method a new object of the Contact class is created and the contactName value is set, the contactId value is auto generated so the value need not be set here. The session.save() method is used to persist the value in the database and once the value is saved, the id value (Primary key) is returned. Here the contactId value is of type Integer so we typecast the returned value to Integer. Once the object is saved, the transaction is committed. If any exception occurs then the transaction is rolledback. The transaction ends either through commit or rollback action. Once the transaction ends the session is closed.

The listContact() method is used to list all the contacts. The session.createQuery() method is used to create a query object which helps in retrieving the persistant objects. Here we use Hibernate Query Language (HQL). “from Contact” returns a list of all the contacts in the CONTACT table. Note that in the HQL we only specify the java class names and not the table names. Later, using the for loop we iterate the list of contacts and display them on the console.

8. Final project structure

Once you have created all these source files, your project structure should look like following:

9. Execution of the above code

Each time a new thread starts the database schema will change the existing one as we have set hbm2ddl.auto option to update.
The SQL statement generated gets displayed on the console. This is set using the show_sql option in the hibernate configuration file.

Output on the console:

Summary

Download Source Code: Hibernate, Maven and HSQL - Example (28)

In this post we first created a simple Java project using Maven and made it compatible with eclipse. Then we added the Hibernate XML mapping to this project. We used a simple HSQL database, to insert records into CONTACT table and also listed these records. In the next article we shall look into creating hibernate project using Java Annotations. If you have any questions, please post it in the comments section. If you are interested in receiving the future articles on Java topics, please subscribe here

Hibernate XML configuration file example

krishnas — Thu, 21 Feb 2013 04:21:51 +0000

Connect to us ( @twitter | @facebook )






    
    

        
        java:/comp/env/jdbc/MyDB
        org.hibernate.dialect.MySQLDialect
        false
        
            org.hibernate.transaction.JTATransactionFactory
        
        java:comp/UserTransaction

List of Hibernate SQL Dialects

krishnas — Thu, 21 Feb 2013 03:40:56 +0000

Connect to us ( @twitter | @facebook )

RDBMS	Dialect
DB2	`org.hibernate.dialect.DB2Dialect`
DB2 AS/400	`org.hibernate.dialect.DB2400Dialect`
DB2 OS390	`org.hibernate.dialect.DB2390Dialect`
PostgreSQL	`org.hibernate.dialect.PostgreSQLDialect`
MySQL	`org.hibernate.dialect.MySQLDialect`
MySQL with InnoDB	`org.hibernate.dialect.MySQLInnoDBDialect`
MySQL with MyISAM	`org.hibernate.dialect.MySQLMyISAMDialect`
Oracle (any version)	`org.hibernate.dialect.OracleDialect`
Oracle 9i/10g	`org.hibernate.dialect.Oracle9Dialect`
Sybase	`org.hibernate.dialect.SybaseDialect`
Sybase Anywhere	`org.hibernate.dialect.SybaseAnywhereDialect`
Microsoft SQL Server	`org.hibernate.dialect.SQLServerDialect`
SAP DB	`org.hibernate.dialect.SAPDBDialect`
Informix	`org.hibernate.dialect.InformixDialect`
HypersonicSQL	`org.hibernate.dialect.HSQLDialect`
Ingres	`org.hibernate.dialect.IngresDialect`
Progress	`org.hibernate.dialect.ProgressDialect`
Mckoi SQL	`org.hibernate.dialect.MckoiDialect`
Interbase	`org.hibernate.dialect.InterbaseDialect`
Pointbase	`org.hibernate.dialect.PointbaseDialect`
FrontBase	`org.hibernate.dialect.FrontbaseDialect`
Firebird	`org.hibernate.dialect.FirebirdDialect`