Contents
About ................................................................................................................................................................................... 1
Chapter 1: Getting started with Hibernate ...................................................................................................... 2
Section 1.1: Using XML Configuration to set up Hibernate ......................................................................................... 2
Section 1.2: Simple Hibernate example using XML ..................................................................................................... 4
Section 1.3: XML-less Hibernate configuration ........................................................................................................... 6
Chapter 2: Fetching in Hibernate .......................................................................................................................... 8
Section 2.1: It is recommended to use FetchType.LAZY. Join fetch the columns when they are needed
.................................................................................................................................................................................. 8
Chapter 3: Hibernate Entity Relationships using Annotations ............................................................ 10
Section 3.1: Bi-Directional Many to Many using user managed join table object ................................................ 10
Section 3.2: Bi-Directional Many to Many using Hibernate managed join table .................................................. 11
Section 3.3: Bi-directional One to Many Relationship using foreign key mapping .............................................. 12
Section 3.4: Bi-Directional One to One Relationship managed by Foo.class ....................................................... 12
Section 3.5: Uni-Directional One to Many Relationship using user managed join table ..................................... 13
Section 3.6: Uni-directional One to One Relationship .............................................................................................. 14
Chapter 4: HQL ............................................................................................................................................................ 15
Section 4.1: Selecting a whole table ........................................................................................................................... 15
Section 4.2: Select specific columns .......................................................................................................................... 15
Section 4.3: Include a Where clause .......................................................................................................................... 15
Section 4.4: Join ........................................................................................................................................................... 15
Chapter 5: Native SQL Queries ............................................................................................................................ 16
Section 5.1: Simple Query ........................................................................................................................................... 16
Section 5.2: Example to get a unique result ............................................................................................................. 16
Chapter 6: Mapping associations ....................................................................................................................... 17
Section 6.1: One to One Hibernate Mapping ............................................................................................................. 17
Chapter 7: Criterias and Projections ................................................................................................................ 19
Section 7.1: Use Filters ................................................................................................................................................. 19
Section 7.2: List using Restrictions ............................................................................................................................. 20
Section 7.3: Using Projections .................................................................................................................................... 20
Chapter 8: Custom Naming Strategy ............................................................................................................... 21
Section 8.1: Creating and Using a Custom ImplicitNamingStrategy ...................................................................... 21
Section 8.2: Custom Physical Naming Strategy ....................................................................................................... 21
Chapter 9: Caching ..................................................................................................................................................... 24
Section 9.1: Enabling Hibernate Caching in WildFly ................................................................................................. 24
Chapter 10: Association Mappings between Entities ................................................................................ 25
Section 10.1: One to many association using XML ................................................................................................... 25
Section 10.2: OneToMany association ....................................................................................................................... 27
Chapter 11: Lazy Loading vs Eager Loading ................................................................................................. 28
Section 11.1: Lazy Loading vs Eager Loading ............................................................................................................ 28
Section 11.2: Scope ....................................................................................................................................................... 29
Chapter 12: Enable/Disable SQL log ................................................................................................................. 31
Section 12.1: Using a logging config file .................................................................................................................... 31
Section 12.2: Using Hibernate properties .................................................................................................................. 31
Section 12.3: Enable/Disable SQL log in debug ........................................................................................................ 31
Chapter 13: Hibernate and JPA ............................................................................................................................ 33
, Section 13.1: Relationship between Hibernate and JPA ........................................................................................... 33
Chapter 14: Performance tuning ........................................................................................................................ 34
Section 14.1: Use composition instead of inheritance .............................................................................................. 34
Credits .............................................................................................................................................................................. 35
You may also like ........................................................................................................................................................ 36
,Chapter 1: Getting started with Hibernate
Version Documentation Link Release Date
4.2.0 http://hibernate.org/orm/documentation/4.2/ 2013-03-01
4.3.0 http://hibernate.org/orm/documentation/4.3/ 2013-12-01
5.0.0 http://hibernate.org/orm/documentation/5.0/ 2015-09-01
Section 1.1: Using XML Configuration to set up Hibernate
I create a file called database-servlet.xml somewhere on the classpath.
Initially your config file will look like this:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">
</beans>
You'll notice I imported the tx and jdbc Spring namespaces. This is because we are going to use them quite heavily
in this config file.
First thing you want to do is enable annotation based transaction management (@Transactional). The main reason
that people use Hibernate in Spring is because Spring will manage all your transactions for you. Add the following
line to your configuration file:
<tx:annotation-driven />
We need to create a data source. The data source is basically the database that Hibernate is going to use to persist
your objects. Generally one transaction manager will have one data source. If you want Hibernate to talk to multiple
data sources then you have multiple transaction managers.
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="" />
<property name="url" value="" />
<property name="username" value="" />
<property name="password" value="" />
</bean>
The class of this bean can be anything that implements javax.sql.DataSource so you could write your own. This
example class is provided by Spring, but doesn't have its own thread pool. A popular alternative is the Apache
Commons org.apache.commons.dbcp.BasicDataSource, but there are many others. I'll explain each of the
properties below:
driverClassName: The path to your JDBC driver. This is a database specific JAR that should be available on
2
, your classpath. Ensure that you have the most up to date version. If you are using an Oracle database, you'll
need a OracleDriver. If you have a MySQL database, you'll need a MySQLDriver. See if you can find the driver
you need here but a quick google should give you the correct driver.
url: The URL to your database. Usually this will be something like
jdbc\:oracle\:thin\:\path\to\your\database or jdbc:mysql://path/to/your/database. If you google
around for the default location of the database you are using, you should be able to find out what this should
be. If you are getting a HibernateException with the message org.hibernate.HibernateException:
Connection cannot be null when 'hibernate.dialect' not set and you are following this guide, there is
a 90% chance that your URL is wrong, a 5% chance that your database isn't started and a 5% chance that
your username/password is wrong.
username: The username to use when authenticating with the database.
password: The password to use when authenticating with the database.
The next thing, is to set up the SessionFactory. This is the thing that Hibernate uses to create and manage your
transactions, and actually talks to the database. It has quite a few configuration options that I will try to explain
below.
<bean id="sessionFactory"
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="packagesToScan" value="au.com.project />
<property name="hibernateProperties">
<props>
<prop key="hibernate.use_sql_comments">true</prop>
<prop key="hibernate.hbm2ddl.auto">validate</prop>
</props>
</property>
</bean>
dataSource: Your data source bean. If you changed the Id of the dataSource, set it here.
packagesToScan: The packages to scan to find your JPA annotated objects. These are the objects that the
session factory needs to manage, will generally be POJO's and annotated with @Entity. For more information
on how to set up object relationships in Hibernate see here.
annotatedClasses (not shown): You can also provide a list of classes for Hibernate to scan if they are not all in
the same package. You should use either packagesToScan or annotatedClasses but not both. The
declaration looks like this:
<property name="annotatedClasses">
<list>
<value>foo.bar.package.model.Person</value>
<value>foo.bar.package.model.Thing</value>
</list>
</property>
hibernateProperties: There are a myriad of these all lovingly documented here. The main ones you will be
using are as follows:
hibernate.hbm2ddl.auto: One of the hottest Hibernate questions details this property. See it for more info. I
generally use validate, and set up my database using either SQL scripts (for an in-memory), or create the
database beforehand (existing database).
hibernate.show_sql: Boolean flag, if true Hibernate will print all the SQL it generates to stdout. You can also
configure your logger to show you the values that are being bound to the queries by setting
3
About ................................................................................................................................................................................... 1
Chapter 1: Getting started with Hibernate ...................................................................................................... 2
Section 1.1: Using XML Configuration to set up Hibernate ......................................................................................... 2
Section 1.2: Simple Hibernate example using XML ..................................................................................................... 4
Section 1.3: XML-less Hibernate configuration ........................................................................................................... 6
Chapter 2: Fetching in Hibernate .......................................................................................................................... 8
Section 2.1: It is recommended to use FetchType.LAZY. Join fetch the columns when they are needed
.................................................................................................................................................................................. 8
Chapter 3: Hibernate Entity Relationships using Annotations ............................................................ 10
Section 3.1: Bi-Directional Many to Many using user managed join table object ................................................ 10
Section 3.2: Bi-Directional Many to Many using Hibernate managed join table .................................................. 11
Section 3.3: Bi-directional One to Many Relationship using foreign key mapping .............................................. 12
Section 3.4: Bi-Directional One to One Relationship managed by Foo.class ....................................................... 12
Section 3.5: Uni-Directional One to Many Relationship using user managed join table ..................................... 13
Section 3.6: Uni-directional One to One Relationship .............................................................................................. 14
Chapter 4: HQL ............................................................................................................................................................ 15
Section 4.1: Selecting a whole table ........................................................................................................................... 15
Section 4.2: Select specific columns .......................................................................................................................... 15
Section 4.3: Include a Where clause .......................................................................................................................... 15
Section 4.4: Join ........................................................................................................................................................... 15
Chapter 5: Native SQL Queries ............................................................................................................................ 16
Section 5.1: Simple Query ........................................................................................................................................... 16
Section 5.2: Example to get a unique result ............................................................................................................. 16
Chapter 6: Mapping associations ....................................................................................................................... 17
Section 6.1: One to One Hibernate Mapping ............................................................................................................. 17
Chapter 7: Criterias and Projections ................................................................................................................ 19
Section 7.1: Use Filters ................................................................................................................................................. 19
Section 7.2: List using Restrictions ............................................................................................................................. 20
Section 7.3: Using Projections .................................................................................................................................... 20
Chapter 8: Custom Naming Strategy ............................................................................................................... 21
Section 8.1: Creating and Using a Custom ImplicitNamingStrategy ...................................................................... 21
Section 8.2: Custom Physical Naming Strategy ....................................................................................................... 21
Chapter 9: Caching ..................................................................................................................................................... 24
Section 9.1: Enabling Hibernate Caching in WildFly ................................................................................................. 24
Chapter 10: Association Mappings between Entities ................................................................................ 25
Section 10.1: One to many association using XML ................................................................................................... 25
Section 10.2: OneToMany association ....................................................................................................................... 27
Chapter 11: Lazy Loading vs Eager Loading ................................................................................................. 28
Section 11.1: Lazy Loading vs Eager Loading ............................................................................................................ 28
Section 11.2: Scope ....................................................................................................................................................... 29
Chapter 12: Enable/Disable SQL log ................................................................................................................. 31
Section 12.1: Using a logging config file .................................................................................................................... 31
Section 12.2: Using Hibernate properties .................................................................................................................. 31
Section 12.3: Enable/Disable SQL log in debug ........................................................................................................ 31
Chapter 13: Hibernate and JPA ............................................................................................................................ 33
, Section 13.1: Relationship between Hibernate and JPA ........................................................................................... 33
Chapter 14: Performance tuning ........................................................................................................................ 34
Section 14.1: Use composition instead of inheritance .............................................................................................. 34
Credits .............................................................................................................................................................................. 35
You may also like ........................................................................................................................................................ 36
,Chapter 1: Getting started with Hibernate
Version Documentation Link Release Date
4.2.0 http://hibernate.org/orm/documentation/4.2/ 2013-03-01
4.3.0 http://hibernate.org/orm/documentation/4.3/ 2013-12-01
5.0.0 http://hibernate.org/orm/documentation/5.0/ 2015-09-01
Section 1.1: Using XML Configuration to set up Hibernate
I create a file called database-servlet.xml somewhere on the classpath.
Initially your config file will look like this:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">
</beans>
You'll notice I imported the tx and jdbc Spring namespaces. This is because we are going to use them quite heavily
in this config file.
First thing you want to do is enable annotation based transaction management (@Transactional). The main reason
that people use Hibernate in Spring is because Spring will manage all your transactions for you. Add the following
line to your configuration file:
<tx:annotation-driven />
We need to create a data source. The data source is basically the database that Hibernate is going to use to persist
your objects. Generally one transaction manager will have one data source. If you want Hibernate to talk to multiple
data sources then you have multiple transaction managers.
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="" />
<property name="url" value="" />
<property name="username" value="" />
<property name="password" value="" />
</bean>
The class of this bean can be anything that implements javax.sql.DataSource so you could write your own. This
example class is provided by Spring, but doesn't have its own thread pool. A popular alternative is the Apache
Commons org.apache.commons.dbcp.BasicDataSource, but there are many others. I'll explain each of the
properties below:
driverClassName: The path to your JDBC driver. This is a database specific JAR that should be available on
2
, your classpath. Ensure that you have the most up to date version. If you are using an Oracle database, you'll
need a OracleDriver. If you have a MySQL database, you'll need a MySQLDriver. See if you can find the driver
you need here but a quick google should give you the correct driver.
url: The URL to your database. Usually this will be something like
jdbc\:oracle\:thin\:\path\to\your\database or jdbc:mysql://path/to/your/database. If you google
around for the default location of the database you are using, you should be able to find out what this should
be. If you are getting a HibernateException with the message org.hibernate.HibernateException:
Connection cannot be null when 'hibernate.dialect' not set and you are following this guide, there is
a 90% chance that your URL is wrong, a 5% chance that your database isn't started and a 5% chance that
your username/password is wrong.
username: The username to use when authenticating with the database.
password: The password to use when authenticating with the database.
The next thing, is to set up the SessionFactory. This is the thing that Hibernate uses to create and manage your
transactions, and actually talks to the database. It has quite a few configuration options that I will try to explain
below.
<bean id="sessionFactory"
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="packagesToScan" value="au.com.project />
<property name="hibernateProperties">
<props>
<prop key="hibernate.use_sql_comments">true</prop>
<prop key="hibernate.hbm2ddl.auto">validate</prop>
</props>
</property>
</bean>
dataSource: Your data source bean. If you changed the Id of the dataSource, set it here.
packagesToScan: The packages to scan to find your JPA annotated objects. These are the objects that the
session factory needs to manage, will generally be POJO's and annotated with @Entity. For more information
on how to set up object relationships in Hibernate see here.
annotatedClasses (not shown): You can also provide a list of classes for Hibernate to scan if they are not all in
the same package. You should use either packagesToScan or annotatedClasses but not both. The
declaration looks like this:
<property name="annotatedClasses">
<list>
<value>foo.bar.package.model.Person</value>
<value>foo.bar.package.model.Thing</value>
</list>
</property>
hibernateProperties: There are a myriad of these all lovingly documented here. The main ones you will be
using are as follows:
hibernate.hbm2ddl.auto: One of the hottest Hibernate questions details this property. See it for more info. I
generally use validate, and set up my database using either SQL scripts (for an in-memory), or create the
database beforehand (existing database).
hibernate.show_sql: Boolean flag, if true Hibernate will print all the SQL it generates to stdout. You can also
configure your logger to show you the values that are being bound to the queries by setting
3
