This is a many-to-many relationship table design, a STOCK table has more than one CATEGORY, and CATEGORY can belong to more than one STOCK, the relationship is linked with a third table called STOCK_CATEGORY.

Hibernate implementation

In Hibernate, this “many-to-many” relationship can implemented in two ways :

• Hibernate XML Mapping file
• Hibernate Annotation

1. Hibernate XML mapping file

In XML mapping way, you need three Java classes to hold the table data,

• Stock.java -> STOCK table
• Category.java -> CATEGORY table
• StockCategory.java -> STOCK_CATEGORY table

and three XML mapping files to describe the table relationship.

• Stock.hbm.xml -> STOCK table
• Category.hbm.xml -> CATEGORY table
• StockCategory.hbm.xml -> STOCK_CATEGORY table

Stock.java

public class Stock implements java.io.Serializable {
   private Set<StockCategory> stockCategories = new HashSet<StockCategory>(0);
   ...
   public Set<StockCategory> getStockCategories() {
	return this.stockCategories;
   }

   public void setStockCategories(Set<StockCategory> stockCategories) {
	this.stockCategories = stockCategories;
   }

Category.java

public class Category implements java.io.Serializable {
   private Set<StockCategory> stockCategories = new HashSet<StockCategory>(0);
   ...
   public Set<StockCategory> getStockCategories() {
	return this.stockCategories;
   }

   public void setStockCategories(Set<StockCategory> stockCategories) {
	this.stockCategories = stockCategories;
   }

StockCategory.java

public class StockCategory implements java.io.Serializable {
   private Integer stockCategoryId;
   private Stock stock;
   private Category category;
   ...

Stock.hbm.xml

...
<class name="com.mkyong.common.Stock" table="stock" ...>
   <id name="stockId" type="java.lang.Integer">
      <column name="STOCK_ID" />
      <generator class="identity" />
   </id>
   ...
   <set name="stockCategories" inverse="true" lazy="true" 
       table="stock_category" ...>
       <key>
         <column name="STOCK_ID" not-null="true" />
       </key>
          <one-to-many class="com.mkyong.common.StockCategory" />
   </set>
...

Set inverse=”true” in set variable, Stock does not want to maintain the relationship.

Category.hbm.xml

...
<class name="com.mkyong.common.Category" table="category" ...>
   <id name="categoryId" type="java.lang.Integer">
       <column name="CATEGORY_ID" />
       <generator class="identity" />
   </id>
   ...
   <set name="stockCategories" inverse="true" lazy="true" 
       table="stock_category" ...>
      <key>
         <column name="CATEGORY_ID" not-null="true" />
      </key>
         <one-to-many class="com.mkyong.common.StockCategory" />
   </set>
...

Set inverse=”true” in set variable, Category does not want to maintain the relationship also.

StockCategory.hbm.xml

...
<class name="com.mkyong.common.StockCategory" table="stock_category" ...>
   <id name="stockCategoryId" type="java.lang.Integer">
      <column name="STOCK_CATEGORY_ID" />
      <generator class="identity" />
   </id>
   <many-to-one name="stock" class="com.mkyong.common.Stock" ...>
       <column name="STOCK_ID" not-null="true" />
   </many-to-one>
   <many-to-one name="category" class="com.mkyong.common.Category" ...>
        <column name="CATEGORY_ID" not-null="true" />
    </many-to-one>
</class>
...

StockCategory maintain the relationship between Stock and Category, see inverse=”true” explanation.

2. Hibernate annotation

In annotation way, three classes are required, all the relationships are declared inside the Java classes.

• Stock.java -> STOCK table
• category.java -> CATEGORY table
• StockCategory.java -> STOCK_CATEGORY table

Stock.java

...
@Entity
@Table(name = "stock", catalog = "mkyong", uniqueConstraints = {
		@UniqueConstraint(columnNames = "STOCK_NAME"),
		@UniqueConstraint(columnNames = "STOCK_CODE") })
public class Stock implements java.io.Serializable {
	private Set<StockCategory> stockCategories =
                                         new HashSet<StockCategory>(0);
	...
	@Id
	@GeneratedValue(strategy = IDENTITY)
	@Column(name = "STOCK_ID", unique = true, nullable = false)
	public Integer getStockId() {
		return this.stockId;
	}
        ...
	@OneToMany(fetch = FetchType.LAZY, mappedBy = "stock")
	public Set<StockCategory> getStockCategories() {
		return this.stockCategories;
	}

	public void setStockCategories(Set<StockCategory> stockCategories) {
		this.stockCategories = stockCategories;
	}
...

Category.java

...
@Entity
@Table(name = "category", catalog = "mkyong")
public class Category implements java.io.Serializable {
	private Set<StockCategory> stockCategories =
                                       new HashSet<StockCategory>(0);
        ...
	@Id
	@GeneratedValue(strategy = IDENTITY)
	@Column(name = "CATEGORY_ID", unique = true, nullable = false)
	public Integer getCategoryId() {
		return this.categoryId;
	}
	...
	@OneToMany(fetch = FetchType.LAZY, mappedBy = "category")
	public Set<StockCategory> getStockCategories() {
		return this.stockCategories;
	}

	public void setStockCategories(Set<StockCategory> stockCategories) {
		this.stockCategories = stockCategories;
	}
...

StockCategory.java

@Entity
@Table(name = "stock_category", catalog = "mkyong",
        uniqueConstraints = @UniqueConstraint(columnNames = {
        "STOCK_ID", "CATEGORY_ID" }))
public class StockCategory implements java.io.Serializable {
	private Integer stockCategoryId;
	private Stock stock;
	private Category category;
	...
	@Id
	@GeneratedValue(strategy = IDENTITY)
	@Column(name = "STOCK_CATEGORY_ID", unique = true, nullable = false)
	public Integer getStockCategoryId() {
		return this.stockCategoryId;
	}

	@ManyToOne(fetch = FetchType.LAZY)
	@JoinColumn(name = "STOCK_ID", nullable = false)
	public Stock getStock() {
		return this.stock;
	}

	@ManyToOne(fetch = FetchType.LAZY)
	@JoinColumn(name = "CATEGORY_ID", nullable = false)
	public Category getCategory() {
		return this.category;
	}
...

The code is self-explanatory, all the @annotation are the XML mapping tag substitution.

Test It

Run the example, both annotation and XML mapping file will generate the same output. Hibernate inserts a row into the STOCK table, a row into the CATEGORY table, and both relationship in STOCK_CATEGORY table.

        Stock stock = new Stock();
        Category category = new Category();
        ...
        session.save(stock);
        session.save(category);
        ...
        StockCategory stockCategory = new StockCategory(stock, category);
        session.save(stockCategory);

Output

Hibernate:
    insert into mkyong.stock
    (STOCK_CODE, STOCK_NAME)
    values (?, ?)

Hibernate:
    insert into mkyong.category
    (`DESC`, NAME)
    values (?, ?)

Hibernate:
    insert into mkyong.stock_category
    (CATEGORY_ID, STOCK_ID)
    values (?, ?)

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

In the one-to-many example, many developers declared the JPA cascade options as following :

...
@Entity
@Table(name = "stock", catalog = "mkyong", uniqueConstraints = {
		@UniqueConstraint(columnNames = "STOCK_NAME"),
		@UniqueConstraint(columnNames = "STOCK_CODE") })
public class Stock implements java.io.Serializable {
    ...
    private Set<StockDailyRecord> stockDailyRecords =
                                              new HashSet<StockDailyRecord>(0);

    @OneToMany(fetch = FetchType.LAZY,
       cascade = {CascadeType.PERSIST,CascadeType.MERGE },
       mappedBy = "stock")
    public Set<StockDailyRecord> getStockDailyRecords() {
	return this.stockDailyRecords;
    }

    public void setStockDailyRecords(Set<StockDailyRecord> stockDailyRecords) {
	this.stockDailyRecords = stockDailyRecords;
    }
    ...

Save it with Hibernate session.

        stockDailyRecords.setStock(stock);
        stock.getStockDailyRecords().add(stockDailyRecords);

        session.save(stock);
        session.getTransaction().commit();

What the code trying to do is when you save a “stock”, it will save the associated stockDailyRecords as well. Everything look fine, but THIS IS NOT WORKING, the cascade options will not execute and save the stockDailyRecords. Can you spot the mistake?

Explanation

Look in the code, @OneToMany is from JPA , it expected a JPA cascade – javax.persistence.CascadeType. However when you save it with Hibernate session, org.hibernate.engine.Cascade will do the following checking …

	if ( style.doCascade( action ) ) {
		cascadeProperty(
	          persister.getPropertyValue( parent, i, entityMode ),
		  types[i],
    	          style,
	          anything,
	          false
		);
	}

The Hibernate save process will causing a ACTION_SAVE_UPDATE action, but the JPA will pass a ACTION_PERSIST and ACTION_MERGE, it will not match and causing the cascade failed to execute.

@see source code

• org.hibernate.engine.Cascade
• org.hibernate.engine.CascadeStyle
• org.hibernate.engine.CascadingAction

Solution

Delete the JPA cascade – javax.persistence.CascadeType, replace it with Hibernate cascade – org.hibernate.annotations.Cascade, with CascadeType.SAVE_UPDATE.

...
@Entity
@Table(name = "stock", catalog = "mkyong", uniqueConstraints = {
		@UniqueConstraint(columnNames = "STOCK_NAME"),
		@UniqueConstraint(columnNames = "STOCK_CODE") })
public class Stock implements java.io.Serializable {
    ...
    private Set<StockDailyRecord> stockDailyRecords =
                                              new HashSet<StockDailyRecord>(0);

    @OneToMany(fetch = FetchType.LAZY, mappedBy = "stock")
    @Cascade({CascadeType.SAVE_UPDATE})
    public Set<StockDailyRecord> getStockDailyRecords() {
	return this.stockDailyRecords;
    }

    public void setStockDailyRecords(Set<StockDailyRecord> stockDailyRecords) {
	this.stockDailyRecords = stockDailyRecords;
    }
    ...

Now, it work as what you expected.

Conclusion

It look like an incompatible issue between JPA and Hibernate cascade annotation, if Hibernate is a JPA implementation, what may causing the misunderstand in between?

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

This example is the same as the first example except that it uses annotations. There we first started by creating the .hbm.xml file, here there is no need to create it instead we will use annotations to do the object relational mapping.

In addition to the already existing jar files you need to add the following jar files to the classpath.
1.hibernate-commons-annotations.jar
2.ejb3-persistence.jar
3.hibernate-annotations.jar

Here we first start by creating the Course class. The Course class is shown below.

01.package com.vaannila.course;
02.
03.import javax.persistence.Column;
04.import javax.persistence.Entity;
05.import javax.persistence.GeneratedValue;
06.import javax.persistence.Id;
07.import javax.persistence.Table;
08.
09.
10.@Entity
11.@Table(name=“COURSES“)
12.public class Course {
13.
14. private long courseId;
15. private String courseName;
16.
17. public Course() {
18. }
19.
20. public Course(String courseName) {
21. this.courseName = courseName;
22. }
23.
24. @Id
25. @GeneratedValue
26. @Column(name=“COURSE_ID“)
27. public long getCourseId() {
28. return this.courseId;
29. }
30.
31. public void setCourseId(long courseId) {
32. this.courseId = courseId;
33. }
34.
35. @Column(name=“COURSE_NAME“, nullable=false)
36. public String getCourseName() {
37. return this.courseName;
38. }
39.
40. public void setCourseName(String courseName) {
41. this.courseName = courseName;
42. }
43.
44.}

As you can see we have used annotations in the code to do the object relational mapping. Hibernate supports EJB 3 persistence annotations. The EJB 3 annotations are contained in the javax.persistence package. If you avoid using Hibernate specific features in your application, then you will have the freedom to deploy your application in any environment that supports EJB 3. Anything imported from javax.persistence package tree is EJB 3 supported and anything imported from org.hibernate package tree is Hibernate specific.

The @Entity annotation is used to mark this class as an Entity bean. So the class should atleast have a package scope no-argument constructor.

The @Table annotation is used to specify the table to persist the data. The name attribute refers to the table name. If @Table annotation is not specified then Hibernate will by default use the class name as the table name.

The @Id annotation is used to specify the identifier property of the entity bean. The placement of the @Id annotation determines the default access strategy that Hibernate will use for the mapping. If the @Id annotation is placed over the field, then filed access will be used. Instead if it placed over the getter method of that field, then property access will be used. Here we use property access.

The @GeneratedValue annotation is used to specify the primary key generation strategy to use. If the strategy is not specified by default AUTO will be used.

The @Column annotation is used to specify the details of the column to which a field or property will be mapped. Here the courseId property is mapped to COURSE_ID column in the COURSES table. If the @Column annotation is not specified by default the property name will be used as the column name.

The next change you need to do here is, instead of adding the .hbm.xml file to the hibernate.cfg.xml file, we add the fully qualified name of the annotated class to the mapping element.

01.
02. 03. "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
04. "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
05.
06.
07. org.hsqldb.jdbcDriver 08. jdbc:hsqldb:hsql://localhost 09. sa 10. 11. 1 12. org.hibernate.dialect.HSQLDialect 13. true 14. create 15.
16.
17.

The SessionFactory should be configured using the AnnotationConfiguration object instead of the Configuration object used with XML mappings.

01.package com.vaannila.util;
02.
03.import org.hibernate.SessionFactory;
04.import org.hibernate.cfg.AnnotationConfiguration;
05.
06.public class HibernateUtil {
07. private static final SessionFactory sessionFactory;
08. static {
09. try {
10. sessionFactory = new AnnotationConfiguration().configure()
11. .buildSessionFactory();
12. } catch (Throwable ex) {
13. System.err.println(„Initial SessionFactory creation failed.“ + ex);
14. throw new ExceptionInInitializerError(ex);
15. }
16. }
17.
18. public static SessionFactory getSessionFactory() {
19. return sessionFactory;
20. }
21.}

These are the only few changes you need to do to make the example work using annotations. Now the big question is should you use annotations?

If your answer is yes to the following questions then you can use annotations in your project.

* Do you have the flexibility to use Java 5 Environment?
* Do you have the knowledge of which production database you are going to use? If yes, you can use annotations, this brings in strong coupling. Inorder to support multiple databases, it is better to have the mapping information in a seperate xml file rather than using annotations. You can easily have multiple xml files each specific for a particular database rather than having a different sets of source codes.

Instead than keeping the mapping informations in a seperate file, using annotations you can always keep them along with the source code, in this way the soure code and mapping information will always be in sync.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

In this tutorial you will see how to persist the java objects using the Hibernate Object/Relational Mapping (ORM) framework. Hibernate automates ORM and considerably reduces the number of lines of code needed to persist the object in the database. This example demonstrates how to automatically generate code from the object/relational mapping file, thus saving the developers time. This helps the developers to focus on the business problem rather than doing repetitive coding work.

Hibernate uses XML document or the properties file to define the object/relational mapping. The object/relational mapping file contains the mapping between the Java object and the corresponding database table. This example illustrates how to create the ORM using the XML document.

First let’s setup the environment. I am using

• Eclipse IDE 3.4
• Hibernate Core 3.3
• Hibernate Tools 3.2
• HSQLDB 1.8

You can download the Hibernate Core and Hibernate Tools here. HyperSQL DataBase is a 100% lightweight Java SQL Database Engine. You can download HSQLDB from this site http://hsqldb.org/ .

To install the Hibernate Tools, extract the HibernateTools-3.X.zip file and move all the files inside the features folder into the features folder of the eclipse installation directory and move all the files inside the plugins folder into the plugins folder of the ecilpse installation directory. Restart the eclipse.

First create a new Java project. Add the following lib files on the java build path.

The hibernate3.jar contains all the core hibernate files. The hsqldb.jar is used, to connect with the HSQL database, if you are using someother database then you need to include that jar file instead of this. The slf4j-api-1.5.6 jar file is used for logging the informations, you can also use other alternatives like log4j, to do that include that jar file instead of slf4j-simple-1.5.6 jar file to your classpath.

Once you have installed the hibernate tools, you will have the option to change to Hibernate prespective. Go to Window -> Open Prespective -> Other, the following dialog box appears, select Hibernate and click the Ok button.

Now let’s see how to define the object/relational mapping using the XML document. This document has hbm.xml extension. We will now create the object/relational mapping for the simple class that holds course related details. To do that create a package com.vaannila.course in the src directory. The Hibernate XML mapping file will be created in this directory. To create the mapping file, switch to Hibernate prespective, right click the project folder and select New -> Hibernate XML Mapping File(hbm.xml)

In the pop up window select the course folder, enter the file name as Course.hbm.xml and click Next. In the next window click Finish.

Add the following code to the Course.hbm.xml file.

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 and the database table name is specified using the table attribute of the class element. The meta element is used to create the class description. The id element is used to create the primary key. The name attribute of the id element refers to the property in the Course class and the column attribute refers to the column in the COURSES 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. When the class attribute of the generator element is set to native, hibernate picks either identity, sequence or hilo algorithm depending upon the capabilities of the underlying database. The property element is used to link a property in the Java class to a column in the database table.

The next step is to create the Hibernate configuration file. On startup, Hibernate looks for a file called hibernate.cfg.xml in the root of the classpath. To create the Hibernate Configuration File, right click the project, select New -> Hibernate Configuration File (cfg.xml)

By default the file name will be hibernate.cfg.xml, select the src directory and click Next.

Select the database dialect as HSQL. This property indicates the particular SQL variant that Hibernate generates. Select the „org.hsqldb.jdbcDriver“ option for the driver class. Enter the connection url „jdbc:hsqldb:hsql://localhost„. Enter the user name as „sa“ and click Finish. These properties specifies the necessary configuration for the JDBC connection.

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, will drop and re-create the database schema on startup.

In the end we add the Course.hbm.xml file to the configuration. The implementation of the hibernate.cfg.xml file is shown below.

Once the Hibernate configuration file is created we need to create a Hibernate console configuration. To do this right click the project folder, select New -> Hibernate Console Configuration.

The Hibernate Console configuration wizard appears.

By default the wizard will load the Hibernate configuration file information. Just click the Finish button to create the Hibernate console configuration.

Once the Hibernate console configuration is created, you can generate code by selecting the Hibernate Code Generation Configurations option form the toolbar.

The Hibernate Code Generation wizard will be displayed. Now select the output directory as the src directory.

In the Exporters tag select the „Use Java 5 Syntax“ option and „Domain Code(.java)“ option.

In the Refresh tab select the options as shown below and click the Run button to generate the code.

The following Course.java class will be generated from the Course.hbm.xml mapping file.

Now create the HibernateUtil class. The HibernateUtil class helps in creating the SessionFactory from the Hibernate configuration file. The SessionFactory is threadsafe, so it is not necessary to obtain one for each thread. Here the static singleton pattern is used to instantiate the SessionFactory. The implementation of the HibernateUtil class is shown below.

Now we will create a class with the main() method to run the application.

The first call to the openSession() method begins the session. The session.beginTransaction() method is used to start a new transaction. Here we have four different methods to perform the CRUD operations.

The saveCourse() method is used to save a new Course object to the database. In the saveCourse()method a new object of the Course class is created and the courseName value is set, the courseId value is auto generated so the value needn’t 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 courseId value is of type long so we typecast the returned value to Long. 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 listCourse() method is used to list all the courses. 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 Course“ returns a list of all the courses in the COURSES 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 courses and display them on the console.

The updateCourse() method is used to update the course name. It takes the courseId and the new courseName as input parameters. The courseId is used to retrive the actual course object using the session.get() method. The session.get() method takes the class name and the id value as the input parameter and returns the corresponding Object. Here we set the new course name to the Course object and commit the transaction. We need not explicitly call the session.save() method to persist the object. Hibernate will automatically update the database when the state of the persistant object is modified inside a transaction. This feature of Hibernate is called automatic dirty checking.

The deleteCourse() method is used to delete a Course object. This method is similar to the updateCourse() method, here instead of updating the object we call the session.delete() method to delete a persistant object.

The figure below shows the final directory structure of the example.

To run the example, first start the HSQLDB server. To start the HSQLDB server, run the command prompt, go to the hsqldb directory and execute the following command.

After starting the server, run the Main class. On startup the database schema will be created and the following actions will happen.

Each time on startup the database schema will be droped and recreated, if you want to use the existing one change the value of 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.

Now let’s check whether the database schema is created and the data is inserted into the COURSES table or not. Open a new command prompt, go to the hsqldb installed directory and type the following command.

The following dialog box pops up. Select the Type as „HSQL Database Engine Server“ and click Ok.

The HSQL Databse Manager window opens. Here you can enter the following SQL statement, and see the data is successfully stored in the COURSES table.

To shutdown the HSQLDB properly enter „shutdown“ and click the Execute button. Alternatively you can also shutdown programmatically by closing the SessionFactory, using HibernateUtil.getSessionFactory().close() method.

You can download the source code of this example by clicking the Download link below.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

A one-to-one relationships occurs when one entity is related to exactly one occurrence in another entity.

“One-to-one” example

This is a one-to-one relationship table design, a STOCK table contains exactly one record in STOCK_DETAIL table. Both tables have the same Stock_Id as primary key. In STOCK_DETAIL table, Stock_Id is the primary key and also a foreign key to STOCK table. This is one of the common ways to define one-to-one relationship. More detail…

Hibernate implementation

In Hibernate, this “one-to-one” relationship can implemented in two ways :

• Hibernate XML Mapping file
• Hibernate Annotation

1. Hibernate XML mapping file

In XML mapping way, you need two Java classes to hold the table data.

• Stock.java -> STOCK table
• StockDetail.java -> STOCK_DETAIL table

and two XML mapping files to describe the table relationship.

• Stock.hbm.xml -> STOCK table
• StockDetail.hbm.xml -> STOCK_DETAIL table

Stock.java

...
public class Stock implements java.io.Serializable {
	private StockDetail stockDetail;
	...
	public StockDetail getStockDetail() {
		return this.stockDetail;
	}
	public void setStockDetail(StockDetail stockDetail) {
		this.stockDetail = stockDetail;
	}

StockDetail.java

...
public class StockDetail implements java.io.Serializable {
	private Stock stock;
        ...
        public Stock getStock() {
		return this.stock;
	}

	public void setStock(Stock stock) {
		this.stock = stock;
	}

Stock.hbm.xml

...
<class name="com.mkyong.common.Stock" table="stock" ...>
        <id name="stockId" type="java.lang.Integer">
            <column name="STOCK_ID" />
            <generator class="identity" />
        </id>
        ...
        <one-to-one name="stockDetail" class="com.mkyong.common.StockDetail" 
         cascade="save-update"></one-to-one>
        ...

StockDetail.hbm.xml

...
<class name="com.mkyong.common.StockDetail" table="stock_detail" ...>
        <id name="stockId" type="java.lang.Integer">
            <column name="STOCK_ID" />
            <generator class="foreign">
                <param name="property">stock</param>
            </generator>
        </id>
        <one-to-one name="stock" class="com.mkyong.common.Stock" 
        constrained="true"></one-to-one>
        ...

The main difficulty with one-to-one relationship is ensuring both are assigned the same primary key. In StockDetail.hbm.xml, a special foreign identifier generator is declared, it will know get the primary key value from STOCK table. With constrained=”true”, it ensure the Stock must exists.

2. Hibernate annotation

In annotation way, only two classes are required, all the relationships are declared inside the Java classes.

• Stock.java -> STOCK table
• StockDetail.java -> STOCK_DETAIL table

Stock.java

...
@Entity
@Table(name = "stock", catalog = "mkyong", uniqueConstraints = {
		@UniqueConstraint(columnNames = "STOCK_NAME"),
		@UniqueConstraint(columnNames = "STOCK_CODE") })
public class Stock implements java.io.Serializable {
	private StockDetail stockDetail;
        ...
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "STOCK_ID", unique = true, nullable = false)
	public Integer getStockId() {
		return this.stockId;
	}

	@OneToOne(fetch = FetchType.LAZY, mappedBy = "stock")
	@Cascade({CascadeType.SAVE_UPDATE})
	public StockDetail getStockDetail() {
		return this.stockDetail;
	}

StockDetail.java

@Entity
@Table(name = "stock_detail", catalog = "mkyong")
public class StockDetail implements java.io.Serializable {
	private Stock stock;
        ...
	@GenericGenerator(name = "generator",
            strategy = "foreign",
            parameters = @Parameter(name = "property", value = "stock"))
	@Id
	@GeneratedValue(generator = "generator")
	@Column(name = "STOCK_ID", unique = true, nullable = false)
	public Integer getStockId() {
		return this.stockId;
	}

	@OneToOne(fetch = FetchType.LAZY)
	@PrimaryKeyJoinColumn
	public Stock getStock() {
		return this.stock;
	}

The code is self-explanatory, all the @annotation are the XML mapping tag substitution.

Test It

Run the example, both annotation and XML mapping file will generate the same output. Hibernate inserts a row into the STOCK table and a row into the STOCK_DETAIL table.

        Stock stock = new Stock();

        stock.setStockCode("4715");
        stock.setStockName("GENM");

        StockDetail stockDetail = new StockDetail();
        stockDetail.setCompName("GENTING Malaysia");
        stockDetail.setCompDesc("Best resort in the world");
        stockDetail.setListedDate(new Date());

        stock.setStockDetail(stockDetail);
        stockDetail.setStock(stock);

        session.save(stock);

Output

Hibernate:
    INSERT INTO mkyong.stock
    (STOCK_CODE, STOCK_NAME)
    VALUES (?, ?)

Hibernate:
    INSERT INTO mkyong.stock_detail
    (COMP_NAME, COMP_DESC, REMARK, LISTED_DATE, STOCK_ID)
    VALUES (?, ?, ?, ?, ?)

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Different between session.get() and session.load()

Actually, both functions are use to retrieve an object with different mechanism, of course.

1. session.load()

• It will always return a “proxy” (Hibernate term) without hitting the database. In Hibernate, proxy is an object with the given identifier value, its properties are not initialized yet, it just look like a temporary fake object.
• If no row found , it will throws an ObjectNotFoundException.

2. session.get()

• It always hit the database and return the real object, an object that represent the database row, not proxy.
• If no row found , it return null.

It’s about performance

Hibernate create anything for some reasons, when you do the association, it’s normal to obtain retrieve an object (persistent instance) from database and assign it as a reference to another object, just to maintain the relationship. Let’s go through some examples to understand in what situation you should use session.load().

1. session.get()

For example, in a Stock application , Stock and StockTransactions should have a “one-to-many” relationship, when you want to save a stock transaction, it’s common to declared something like below

    	   Stock stock = (Stock)session.get(Stock.class, new Integer(2));
           StockTransaction stockTransactions = new StockTransaction();
           //set stockTransactions detail
           stockTransactions.setStock(stock);
           session.save(stockTransactions);

Output

Hibernate:
    select ... from mkyong.stock stock0_
    where stock0_.STOCK_ID=?
Hibernate:
    insert into mkyong.stock_transaction (...)
    values (?, ?, ?, ?, ?, ?)

In session.get(), Hibernate will hit the database to retrieve the Stock object and put it as a reference to StockTransaction. However, this save process is extremely high demand, there may be thousand or million transactions per hour, do you think is this necessary to hit the database to retrieve the Stock object everything save a stock transaction record? After all you just need the Stock’s Id as a reference to StockTransaction.

2. session.load()

In above scenario, session.load() will be your good solution, let’s see the example,

    	   Stock stock = (Stock)session.load(Stock.class, new Integer(2));
           StockTransaction stockTransactions = new StockTransaction();
           //set stockTransactions detail
           stockTransactions.setStock(stock);
           session.save(stockTransactions);

Output

Hibernate:
    insert into mkyong.stock_transaction (...)
    values (?, ?, ?, ?, ?, ?)

In session.load(), Hibernate will not hit the database (no select statement in output) to retrieve the Stock object, it will return a Stock proxy object – a fake object with given identify value. In this scenario, a proxy object is enough for to save a stock transaction record.

Exception

In exception case, see the examples

session.load()

Stock stock = (Stock)session.load(Stock.class, new Integer(100)); //proxy

 //initialize proxy, no row for id 100, throw ObjectNotFoundException
System.out.println(stock.getStockCode());

It will always return a proxy object with the given identity value, even the identity value is not exists in database. However, when you try to initialize a proxy by retrieve it’s properties from database, it will hit the database with select statement. If no row is found, a ObjectNotFoundException will throw.

org.hibernate.ObjectNotFoundException: No row with the given identifier exists:
[com.mkyong.common.Stock#100]

session.get()

//return null if not found
Stock stock = (Stock)session.get(Stock.class, new Integer(100));
System.out.println(stock.getStockCode()); //java.lang.NullPointerException

It will always return null , if the identity value is not found in database.

Conclusion

There are no always correct solution, you have to understand the differential in between, and decide which method is best fix in your application.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.