Setting up a persistence layer with Hibernate is quit easy. Actually it even improved with the annotations. A couple of years ago, when this technique was introduced, there was quite a discussion about the fact if a bean could be self persistent or not. In my personal opinion I dont like self persistent beans. But i do like annotated beans. And I believe there is a difference.
An example
A small version of the hibernate.cfg.xml based on a postgres database:
<?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>
<property name="dialect">org.hibernate.dialect.PostgreSQLDialect</property>
<property name="connection.driver_class">org.postgresql.Driver</property>
<property name="connection.url">jdbc:postgresql://localhost:5432/mydb</property>
<property name="connection.username">postgres</property>
<property name="connection.password">postgres</property>
<property name="cache.provider_class">org.hibernate.cache.HashtableCacheProvider</property>
<property name="transaction.factory_class">org.hibernate.transaction.JDBCTransactionFactory</property>
<property name="current_session_context_class">thread</property>
<property name="hibernate.show_sql">false</property>
</session-factory>
</hibernate-configuration>
In the following example I did not use this but if you have multiple databases you can create more then one configuration file and read them as followed:
SessionFactory sessionFactory = new Configuration()
.configure(<PATH>hibernate.cfg.xml).buildSessionFactory();
an examples of a annotated hibernate beans:
package com.shops.data.layer.info;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;
@Entity
@Table(name = "customers")
public class LoginInfo {
private String username;
private String password;
private long id;
@Column(name = "password")
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
@Column(name = "username" )
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Id
@Column(name = "id")
long getId() {
return id;
}
void setId(long id) {
this.id = id;
}
}
This bean is actually filled with data coming from a service and is used to create an Criteria.
The next piece of code is an interface that is the template for every class that is going to act as a database controller.
package com.shops.data.layer.session;
public interface ShopsPersistenceController {
/**
* This method adds a customer to the database.
* @param customer contains the data from the customer.
*/
void addData(Object customer, Class annotatedClass);
/**
* This method retreives a customer from the database.
* @param loginInfo contains the login info needed for retreival.
* @param customer the customer retreived from the database.
*/
Object getData(Object selectionData, Class returnTypeClass);
/**
* updates the customer in the database.
* @param customer contains the new data for the database.
*/
void updateData(Object updataData, Class annotatedClass);
/**
* sets the flag deleted on true.
* @param customer the data needed for the database to select the right customer.
*/
void deleteData(Object deleteData, Class annotatedClass);
}
As you can see all the databaseactions as select (get) updated and delete are in place.
The implementation class:
package com.shops.data.layer.session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
public class ShopsPersistenceControllerImpl implements ShopsPersistenceController{
private SessionFactory sessionFactory;
public ShopsPersistenceControllerImpl(){
}
/**
* {@inheritDoc}
*/
public void addData(Object addData, Class annotatedClass) {
Configuration configuration = new AnnotationConfiguration().configure().addAnnotatedClass(annotatedClass);
sessionFactory = configuration.buildSessionFactory();
Session session = sessionFactory.openSession();
session.beginTransaction();
session.save(addData);
close(session);
}
/**
* {@inheritDoc}
*/
public Object getData(Object selectionData, Class returnTypeClass) {
Configuration configuration = new AnnotationConfiguration().configure()
.addAnnotatedClass(returnTypeClass);
sessionFactory = configuration.buildSessionFactory();
Session session = sessionFactory.openSession();
SqlSelector selectUserByCredentials = new SelectUserByCredentials(session);
SqlSelector sqlSelector = selectUserByCredentials.whoami(selectionData);
Object info = sqlSelector.getData(selectionData, returnTypeClass);
close(session);
return info;
}
/**
* {@inheritDoc}
*/
public void updateData(Object selectData, Class annotatedClass) {
Configuration configuration = new AnnotationConfiguration().configure().addAnnotatedClass(annotatedClass);
sessionFactory = configuration.buildSessionFactory();
Session session = sessionFactory.openSession();
session = sessionFactory.openSession();
session.beginTransaction().commit();
session.update(selectData.getClass());
close(session);
}
/**
* {@inheritDoc}
*/
public void deleteData(Object deleteData, Class annotatedClass) {
Configuration configuration = new AnnotationConfiguration().configure().addAnnotatedClass(annotatedClass);
sessionFactory = configuration.buildSessionFactory();
Session session = sessionFactory.openSession();
session.update(deleteData.getClass());
close(session);
}
private void close(Session session){
if(session.getTransaction().isActive()){
Transaction transaction = session.getTransaction();
transaction.commit();
}
session.flush();
session.close();
sessionFactory.close();
}
}
As you can see: the parameters used in all the database action methods have two parameters. One is the bean that needs to handled by the database for example deleteData. the other is annotatedClass. This is the annotated classe that is the class file needed to build the sessionFactory. this way you dont need different methods for diffent beans.
If you have a closer look in the getData method you find the SqlSelector. This is a separate small class that contains one particular selection. This class has a method called whoami. This method is a part of the chain of responsibility pattern. This way I can chain different selections. This way I keep my contract to the outside world sain. All the services that need this persistence layer talk to it in the same way. They dont have any knowlegde about the query that is executed. This is a good thing. They should be only interested in the results.
The sql selector example:
The interface which is a part of the pattern:
package com.shops.data.layer.session;
public abstract class SqlSelector {
abstract SqlSelector whoami(Object bean);
abstract Object getData(Object selectionData, Class returnTypeClass);
}
The implementing class:
package com.shops.data.layer.session;
import org.hibernate.criterion.Restrictions;
import com.shops.data.layer.info.LoginInfo;
import org.hibernate.classic.Session;
class SelectUserByCredentials extends SqlSelector {
private Session session;
SelectUserByCredentials(Session session){
this.session = session;
}
/**
* finds out which bean is needed for what selection.
**/
SqlSelector whoami(Object bean) {
SqlSelector returnSelector = null;
if(bean instanceof LoginInfo){
returnSelector = this;
}else{
//TODO create the next sqlSelector.
}
return returnSelector;
}
/**
*the actual selection
**/
Object getData(Object selectionData, Class returnTypeClass) {
LoginInfo loginInfo = (LoginInfo)selectionData;
Object info = session.createCriteria(returnTypeClass)
.add(Restrictions.eq("username", loginInfo.getUsername()))
.add(Restrictions.eq("password", loginInfo.getPassword())).uniqueResult();
return info;
}
}
The created restrictions in the criteria are an equivalent of the where clause in SQL.
the unique result gives back only one result (which is handy when people log on to your applicaton)
The Selector classes will be scoped as package. This for the simple reason that there is no reason to make them visible for the outside world.
Conclusion:
Building a persistence tier with any ORM tool can save you a lot of work. It even can save you more work and miles of code if you take care of your design.
Try it and Have fun!
