Investigating Hibernate Associations – Many to Many

In my previous posts, we have looked at one-to-one and one-to-many hibernate associations. This one is going to focus on many-to-many hibernate association.

Let’s start with an unidirectional many-to-many association and later move on to bi-directional association. We will continue to use the earlier examples of Person and Phone. Here’s the hibernate.cfg.xml file used for this example:

<hibernate-configuration>

    <session-factory>

        <!-- Database connection settings -->
        <property name="connection.driver_class">
		com.mysql.jdbc.Driver
	</property>
        <property name="connection.url">
		jdbc:mysql://localhost:3306/<dbname>
	</property>
        <property name="connection.username"><dbuser></property>
        <property name="connection.password"><dbpassword></property>

	<property name="transaction.factory_class">
		org.hibernate.transaction.JDBCTransactionFactory
	</property>

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

        <!-- SQL dialect -->
        <property name="dialect">
		org.hibernate.dialect.MySQL5InnoDBDialect
	</property>

        <!-- Enable Hibernate's automatic session context management -->
        <property name="current_session_context_class">thread</property>

        <!-- Disable the second-level cache  -->
        <property name="cache.provider_class">
		org.hibernate.cache.NoCacheProvider
	</property>

        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <property name="hbm2ddl.auto">update</property>
        <property name="hibernate.max_fetch_depth">1</property>

        <mapping resource="com/tutorial/hibernate/simple/Person.hbm.xml"/>
        <mapping resource="com/tutorial/hibernate/simple/Phone.hbm.xml"/>

    </session-factory>

</hibernate-configuration>

Here’s the CREATE TABLE scripts for PERSON, PHONE and PERSON_PHONE:

CREATE TABLE person (ID     varchar(255) NOT NULL,
                     FIRSTNAME     varchar(255),
                     LASTNAME      varchar(255),
                     DOB           date);

CREATE TABLE phone (ID      varchar(255) NOT NULL,
                    CONTACTNUMBER     varchar(10),
                    PHONETYPE         varchar(255));

CREATE TABLE person_phone (PERSONID     varchar(255),
                           PHONEID      varchar(255));

The hibernate configuration files for Person and Phone classes are as follows:

For Person

<hibernate-mapping package="com.tutorial.hibernate.simple">

    <class name="Person" table="PERSON" dynamic-update="true"
	dynamic-insert="true" select-before-update="false">
        <id name="id">
            <generator class="assigned"/>
        </id>
        <property name="firstName"/>
        <property name="lastName"/>
        <property name="dob" type="date" />

	<set name="phones" table="PERSON_PHONE" cascade="all">
		<key column="PERSONID"/>
		<many-to-many column="PHONEID" class="Phone"/>
	</set>

    </class>

</hibernate-mapping>

For Phone:

<hibernate-mapping package="com.tutorial.hibernate.simple">

    <class name="Phone" table="PHONE" dynamic-update="true"
	dynamic-insert="true" select-before-update="false">
        <id name="id">
            <generator class="assigned"/>
        </id>
        <property name="number" column="contactnumber"/>
        <property name="type" column="phonetype"/>
    </class>

</hibernate-mapping>

The Person class will have the following attributes id, firstName, lastName, dob with their getters and setters. Add the following attribute and appropriate getters and setters for the phone collection.

private Set phones = new HashSet();

public Set getPhones() {
	return phones;
}

public void setPhones(Set phones) {
	this.phones = phones;
}

public void addPhone(Phone phone) {
	this.phones.add(phone);
}
</sourcecode>

The Phone class will have the following attributes id, number, type and their getters and setters.

Here's the sample test program for many to many relationship.

	Configuration cfg = new Configuration();
	cfg.configure();
	SessionFactory sessFactory = cfg.buildSessionFactory();
	try {
		Session session = sessFactory.openSession();

		Person p1 = new Person();
		p1.setId("1245");
		p1.setFirstName("Clark");
		p1.setLastName("Kent");
		p1.setDob(new java.util.Date());

		Person p2 = new Person();
		p2.setId("12456");
		p2.setFirstName("Bruce");
		p2.setLastName("Willis");
		p2.setDob(new java.util.Date());

		Phone phone1 = new Phone();
		phone1.setId("451");
		phone1.setNumber("1234567");
		phone1.setType("BUS");
		p1.addPhone(phone1);
		p2.addPhone(phone1);

		Phone phone2 = new Phone();
		phone2.setId("452");
		phone2.setNumber("7654321");
		phone2.setType("PER");
		p1.addPhone(phone2);
		p2.addPhone(phone2);

		Transaction tx = session.beginTransaction();
		session.save(p1);
		session.save(p2);
		tx.commit();

	} catch(Exception e) {
		e.printStackTrace();
	}

The many-to-many relationship definition in Person.hbm.xml, the set attribute is defined as follows:

<set name="phones" table="PERSON_PHONE" cascade="all">
	<key column="PERSONID"/>
	<many-to-many column="PHONEID" class="Phone"/>
</set>

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.

Here’s the SQL output generated:

Hibernate: select phone_.id, phone_.contactnumber as contactn2_2_,
	   phone_.phonetype as phonetype2_ from PHONE phone_
	   where phone_.id=?
Hibernate: select phone_.id, phone_.contactnumber as contactn2_2_,
	   phone_.phonetype as phonetype2_ from PHONE phone_
	   where phone_.id=?
Hibernate: insert into PERSON (firstName, lastName, dob, id)
	   values (?, ?, ?, ?)
Hibernate: insert into PHONE (contactnumber, phonetype, id)
	   values (?, ?, ?)
Hibernate: insert into PHONE (contactnumber, phonetype, id)
	   values (?, ?, ?)
Hibernate: insert into PERSON (firstName, lastName, dob, id)
	   values (?, ?, ?, ?)
Hibernate: insert into PERSON_PHONE (PERSONID, PHONEID) values (?, ?)
Hibernate: insert into PERSON_PHONE (PERSONID, PHONEID) values (?, ?)
Hibernate: insert into PERSON_PHONE (PERSONID, PHONEID) values (?, ?)
Hibernate: insert into PERSON_PHONE (PERSONID, PHONEID) values (?, ?)

Here’s how the data is inserted in the tables:

SELECT * FROM PERSON

ID      FIRSTNAME LASTNAME DOB
-----   --------- -------- -------
1245	Clark	  Kent	   2007-09-25
12456	Bruce	  Willis   2007-09-25

SELECT * FROM PHONE

ID      CONTACTNUMBER PHONETYPE
----    ------------- ---------
451	1234567	      BUS
452	7654321	      PER

SELECT * FROM PERSON_PHONE

PERSONID PHONEID
-------- -------
1245	 452
1245	 451
12456	 452
12456	 451

Moving on, let’s get a bi-directional many-to-many association going. Add the following in the Phone.hbm.xml

<set name="persons" inverse="true" table="PERSON_PHONE">
       	<key column="PHONEID"/>
       	<many-to-many column="PERSONID"
           class="Person"/>
</set>

Add the following code in the Phone class:

private Set persons = new HashSet();

public Set getPersons() {
	return persons;
}

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

Add the following test code in our sample code after the tx.commit() line.

        
        Transaction tx1 = session.beginTransaction();
	Person per = (Person)session.load(Person.class, "12456");
	System.out.println(per.getPhones().size());
	tx1.commit();

Now we have bi-directional relationship working. the attribute definition inverse=”true” informs Hibernate that Person class is responsible for maintaining the relationship.

In my next post I intend do a deep dive in understanding the cascade attribute. Until the next post.