A project using Netbeans 7, JUnit, Maven, HSQLDB, Spring and Hibernate

Post to Twitter

I was reading a blog article the other day and decided to try the code out myself, however, I wanted to do it my way so I changed several things along the way. This article will outline what I did to get Netbeans 7 working with Spring, Hibernate, HSQLDB, JUnit and Maven all working together. The original code for the original article can be found here.


I began my project by creating a new Maven project called: SimpleSpringHibernate.

I added the following dependencies:

Note: Keep in mind you only really need to add Hibernate, Spring Framework, JUnit, HSQLDB, and the rest will be pulled in by Maven. I’ve included the above screen shot though just to to show everything as I had it configured.

I created just one entity called Employee which takes an id, name and a department. It is wired up for Hibernate and fairly simple to understand.

Employee.java

package com.giantflyingsaucer.simplespringhibernate.entity;

import javax.persistence.*;
import java.io.Serializable;
import org.hibernate.annotations.GenericGenerator;

@Entity
@Table(name = "Employees")
public class Employee implements Serializable {

	private String employeeId;
	private String name;
	private String department;

	@Id
	@GeneratedValue(generator = "system-uuid")
	@GenericGenerator(name = "system-uuid", strategy = "uuid")
	@Column(name = "EmployeeId", nullable=false)
	public String getEmployeeId() {
		return this.employeeId;
	}

	public void setEmployeeId(String employeeId) {
		this.employeeId = employeeId;
	}
	@Column(name = "Name", nullable=false)
	public String getEmployeeName() {
		return this.name;
	}

	public void setEmployeeName(String name) {
		this.name = name;
	}
	@Column(name = "Department", nullable=false)
	public String getEmployeeDepartment() {
		return this.department;
	}

	public void setEmployeeDepartment(String department) {
		this.department = department;
	}
}

After that and according to the original article I built the interface for the EmployeeDAO.

EmployeeDAO.java

package com.giantflyingsaucer.simplespringhibernate.dao;

import java.util.List;
import com.giantflyingsaucer.simplespringhibernate.entity.Employee;

public interface EmployeeDAO {
	public void saveEmployee(Employee employee);
	public List<Employee> getAllEmployees(Employee employee);
	public Employee getEmployeeById(String employeeId);
	public void deleteEmployee(Employee employee);
}

The actual implementation code looks like this:

EmployeeDAOImpl.java

package com.giantflyingsaucer.simplespringhibernate.dao;

import com.giantflyingsaucer.simplespringhibernate.entity.Employee;

import java.util.List;

import org.hibernate.SessionFactory;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

@Repository("EmployeeDAO")
@Transactional
public class EmployeeDAOImpl implements EmployeeDAO {
	private HibernateTemplate hibernateTemplate;

	@Autowired
	public void setSessionFactory(SessionFactory sessionFactory) {
		hibernateTemplate = new HibernateTemplate(sessionFactory);
	}

	@Transactional(readOnly = false)
	public void saveEmployee(Employee employee) {
		hibernateTemplate.saveOrUpdate(employee);
	}

	@Transactional(readOnly = false)
	public void deleteEmployee(Employee employee) {
		hibernateTemplate.delete(employee);
	}

	@SuppressWarnings("unchecked")
	public List<Employee> getAllEmployees(Employee employee) {
		return (List<Employee>) hibernateTemplate.find("from "
				+ Employee.class.getName());
	}

	public Employee getEmployeeById(String employeeId) {
		return hibernateTemplate.get(Employee.class, employeeId);
	}
}

My JUnit test code looks like this:

EmployeeTest.java

package com.giantflyingsaucer.simplespringhibernate;

import java.util.List;

import org.junit.Test;
import org.junit.Assert;
import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.giantflyingsaucer.simplespringhibernate.dao.*;
import com.giantflyingsaucer.simplespringhibernate.entity.Employee;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration( { "/app-config.xml" })
public class EmployeeTest {
	private EmployeeDAO dao;

	@Autowired
	public void setDao(EmployeeDAO dao) {
		this.dao = dao;
	}

	@Test
	public void testCreateData() {
		int expectedResult = 1;
		Employee employee = new Employee();
		employee.setEmployeeDepartment("Human Resources");
		employee.setEmployeeName("Barry Jones");
		dao.saveEmployee(employee);
		Assert.assertEquals(expectedResult, dao.getAllEmployees(new Employee()).size());
	}

	@Test
	public void testRetrieveData() {
		List<Employee> employeeList = dao.getAllEmployees(new Employee());
		Assert.assertEquals(1, employeeList.size());
		Employee employeeExpected = employeeList.get(0);
		Employee employeeResult = dao.getEmployeeById(employeeExpected.getEmployeeId());
		Assert.assertEquals(employeeExpected.getEmployeeId(), employeeResult.getEmployeeId());
	}

	@Test
	public void testUpdateData() {
		List<Employee> employeeList = dao.getAllEmployees(new Employee());
		Assert.assertEquals(1, employeeList.size());
		Employee employeeExpected = employeeList.get(0);
		employeeExpected.setEmployeeName("Jim Jones");
		dao.saveEmployee(employeeExpected);
		Employee employeeResult = dao.getEmployeeById(employeeExpected.getEmployeeId());
		Assert.assertEquals(employeeExpected.getEmployeeName(), employeeResult
				.getEmployeeName());
	}

	@Test
	public void testDeleteData() {
		List<Employee> employeeList = dao.getAllEmployees(new Employee());
		Assert.assertEquals(1, employeeList.size());
		Employee employeeExpected = employeeList.get(0);
		dao.deleteEmployee(employeeExpected);
		Employee employeeResult = dao.getEmployeeById(employeeExpected.getEmployeeId());
		Assert.assertEquals(employeeResult, null);
	}
}

All that’s left is three configuration files needed mostly by Spring. These files go into the resources folder.

app-config.xml

<?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:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">

	<bean id="propertyConfigurer"
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<list>
				<value>/configuration.properties</value>
			</list>
		</property>
	</bean>

	<context:component-scan base-package="com.giantflyingsaucer.simplespringhibernate" />
	<import resource="db-config.xml" />
</beans>

db-config.xml

<?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:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
	">
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
		destroy-method="close">

		<property name="driverClass">
			<value>${jdbc.driver.className}</value>
		</property>
		<property name="jdbcUrl">
			<value>${jdbc.url}</value>
		</property>
		<property name="user">
			<value>${jdbc.username}</value>
		</property>
		<property name="password">
			<value>${jdbc.password}</value>
		</property>
	</bean>
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
		<property name="dataSource">
			<ref bean="dataSource" />
		</property>
		<property name="packagesToScan" value="com.giantflyingsaucer.simplespringhibernate.entity" />
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">${jdbc.hibernate.dialect}</prop>
				<prop key="hibernate.hbm2ddl.auto">create-drop</prop>
				<prop key="hibernate.show_sql">false</prop>
			</props>
		</property>
	</bean>
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory">
			<ref bean="sessionFactory" />
		</property>
	</bean>
	<tx:annotation-driven />
</beans>

Note: I’m using HSQLDB here but you could swap that out for any of the Hibernate supported databases.

configuration.properties

jdbc.driver.className=org.hsqldb.jdbcDriver
jdbc.url=jdbc:hsqldb:file:consoledb;shutdown=true
jdbc.username=sa
jdbc.password=
jdbc.hibernate.dialect=org.hibernate.dialect.HSQLDialect

My project layout looks like this:

Clean and build the project and all four tests should pass.

You can find the project files here.

Post to Twitter

This entry was posted in Java, Netbeans, Open Source. Bookmark the permalink.

2 Responses to A project using Netbeans 7, JUnit, Maven, HSQLDB, Spring and Hibernate

  1. Mike says:

    Hi. Nice post. I’ve tried running this in Netbeans, using your code and I consistently get a ‘java.lang.ClassNotFoundException: org.hsqldb.jdbcDriver’ error when I build.

    For some reason, it is not able to load this driver. I have the jar in my dependencies. Any idea on why this would happen?

    Thanks,
    Mike

  2. Víctor says:

    Nice Post.

    I have some problems with “Failed to load ApplicationContext”, but I have learned a lot from your sample.

    Thanks,
    Víctor

Comments are closed.