DataSource and SessionFactoryThe blog describes how to effectively use hibernate 3 with spring2.5 without using hibernateTemplate or HibernateDaoSupport.
Blog will walk you through setting up spring and hibernate. Using SessionFactory and session to access tables. Then it will show you how to use contextual sessions.
You need to start with a spring project. Create a Spring context.xml
Below is the header:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
Create session factory
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="configLocation" value="classpath:/hibernate.cfg.xml" />
<property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
<property name="hibernateProperties">
<props>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.generate_statistics">true</prop>
<prop key="hibernate.use_sql_comments">true</prop>
<prop key="hibernate.cache.provider_class">net.sf.ehcache.hibernate.SingletonEhCacheProvider</prop>
<prop key="hibernate.cache.use_query_cache">true</prop>
<prop key="hibernate.cache.provider_configuration">classpath:/ehcache.cfg.xml</prop>
<prop key="hibernate.query.factory_class">org.hibernate.hql.classic.ClassicQueryTranslatorFactory</prop>
<prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>
</props>
</property>
</bean>
Create DataSource:
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName"><value>oracle.jdbc.driver.OracleDriver</value></property>
<property name="url">
<value>${db-url}</value>
</property>
<property name="username"><value>${db-username}</value></property>
<property name="password"><value>${db-password}</value></property>
</bean>
The properties db-url, db-username, db-password are in the app.properties file. Spring will be able to read them using PropertyPlaceholderConfigurer which takes the location propety. Below is the bean definition in spring context:
<bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<value>classpath:/app.properties</value>
</property>
</bean>
You can use Jndi instead of maintaining the connection properties. Define dataSource as a JndiObjectFactoryBean instead of DriverManagerDataSource.
<bean id="dataSource"
class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName" value="${datasource.jndi.name}" />
<property name="jndiEnvironment">
<props>
<prop key="java.naming.provider.url">${provider.url}</prop>
</props>
</property>
</bean>
Why JNDI?
1. Database url, username is not hard coaded inside in the war, so easy for deployment. Set up jndi on realted environment.
2. Connection pool size is managed by the jndi provider. If we are using DriverManager, it will allow you to create as many connections limited at the database. With Jndi provider, it is easy to figure out sessions left open.
Hibernate Configuration and Bean Annotations Create hibernate configuration file under 'war/WEB-INF/classes/'. This file points to the beans that will be mapped to the tables.
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<mapping class="com.test.eip.domain.ExampleBean1" />
<mapping class="com.test.eip.domain.ExampleBean2" />
</session-factory>
</hibernate-configuration>
The beans will be mapped to the tables using annotations from package 'javax.persistence.'
The annotations at the begining of the class : @Entity @Table(name='MyEntity' schema='')
Fields are mapped by the @Column(name='') annotations at the getters or at the field declarations.
@Entity
@Table(name = “ExampleBean1″, schema = “”)
public class Equipment implements java.io.Serializable {
private static final long serialVersionUID = 2959455667770311499L;
private long id;
@Id
@Column(name = “ID”, unique = true, nullable = false, precision = 38, scale = 0)
public long getId() {
return id;
}
With above 3 things, you should be able to get the entity from Database using command like session.get(MyEntity.class, id)
Using the SessionFactoryBelow is the sample to get the Objects.
final Session session = sessionFactory.openSession();
try{
Equipment equipment = (Equipment) session.get(Equipment.class, id);
.
.
}finally{
session.close();
}
Below is the sample to execute the raw SQL
final Session currentSession = sessionFactory.openSession();
final Query query = currentSession.createSQLQuery("select ID_SEQ.nextval from dual");
try{
final String id = query.uniqueResult()).toPlainString();
}finally{
currentSession.close();
}
Contextual SessionsYou can use contextual sessions with sessionFactory.getCurrentSession(). For this you will have to define transactionManger.
Pass the sessionFactory to the transactionManager.
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
Add the tx namespace to context.xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
.
.
.
<tx:annotation-driven />
Place the annotations above the methods you are going to use the sessionFactory.
@Transactional
public Equipment getEquipmentById(final long id) {
final Session session = sessionFactory.getCurrentSession();
final Equipment equipment = (Equipment) session.get(Equipment.class, id);
return equipment;
}
You no longer need to close the session or open the session with SessionFactory. getCurrentSession will check if there is an active session and return it. If there is no active session it will create new.
If the method in transaction calls other methods that use sessionFactory, all will use the same transaction provided you have '@Transaction' annotation over all the methods called. Same hibernate session will be kept alive for you by the SessionFactory.
