Java In Nutshell

2009-02-17T18:03:00.000-08:00

Spring2 JPA Hibernate Tutorial

About this tutorial

This tutorial helps you to set up a simple application using Spring 2, JPA and Hibernate. It guides you to learn the steps involved in installing, configuring, developing, testing and deploying. It covers only the basic functionality of Spring 2, JPA and Hibernate.

Prerequisite

This tutorial requires knowledge or work experience in the following areas.

· Java

· Java Enterprise Environment (J2EE)

· Spring and Hibernate

· Relational Database Management System (RDBMS)

System Requirements

In order to develop this sample project, the following software is needed.

The system with at least of 500 MB memory.
JDK 1.5
Spring framework with dependencies – 2.5.6 or later can be used.
Hibernate distribution – 3.3.1 or above
Hibernate Entity Manager – 3.4.0 or above
Hibernate Search - 3.1.0 or above
Lucene -2.4.0
DB2 Express - C
Eclipse EE editior
JBoss – 5.0.0 or later

About the project

This tutorial creates a very simple project. The functionality of this application is to store, retrieve and delete the address information in the Database.

Spring

Spring is a collection of frameworks that provides features to develop distributed applications. It provides the security, transaction, mailing, look up services (JNDI) and other services. The framework is not vendor specific. It can be developed and deployed in standalone and web applications.

The Spring consists of Spring core, Aspect, context, Data Access, ORM and Web, Web MVC. It supports other frameworks to blend in with it. For example, the hibernate can be plugged in for data access and struts for web access. The hibernate is used for data access in this tutorial.

Hibernate

Hibernate is an ORM (Object Relational Mapping) framework to manage the data access. It provides consistent way of accessing and managing data in the relational database. The framework is independent from the database and it hides the complexity of creating the database specific queries.

Java Persistence API

The JPA is an object oriented approach with annotation to the data persistence. It is introduced as part of EE 5.0. But it can be used in java SE also.

In this tutorial, we will be using the power of Spring, Hibernate and JPA.

Setup Workspace

Creating the workspace is the first step in any project. Point your Eclipse IDE to the workspace folder once it is created. And create a Java project for DAO (Data Access Object) and Web project. The IDE automatically creates the EAR projects and associates the DAO and Web projects with it.

Required libraries

The Data access project should be configured to have all the required spring jar files. The jar files are normally located under spring-framework\dist\modules\ or spring-framwork\lib\.

Design domain model

The Address domain consists of the following attributes Id, Number and Street. You can use the following SQL script to create the table in the DB2.

   CREATE TABLE ADDRESS (

      ID INTEGER NOT NULL,

      NUM INTEGER,

      STNAME VARCHAR(25),

      PRIMARY KEY (ID)

);

Define the Java POJO for the above table.

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.Id;

/**

* @author Elangovan Mohan

@Entity // Indicates that it is a table.

public class Address {

@Id // Primary key.

private int id;

@Column(name = "NUM") //Integer column.

private int number;

@Column(name = "STNAME") //String column.

private String street;

/**

* @return the id

public int getId() {

return id;

}

/**

* @param id the id to set

public void setId(int id) {

this.id = id;

}

/**

* @return the number

public int getNumber() {

return number;

}

/**

* @param number the number to set

public void setNumber(int number) {

this.number = number;

}

/**

* @return the street

public String getStreet() {

return street;

}

/**

* @param street the street to set

public void setStreet(String street) {

this.street = street;

}

Define the service

The service interface provides the data access functionality. It uses the JPA EntityManager to manage the address data. The EntityManager implementation is injected by spring during the server startup.

import javax.persistence.EntityManager;

import javax.persistence.PersistenceContext;

import com.springtutorial.vo.Address;

/**

* @author Elangovan Mohan

public class EmployeeServiceImpl implements IEmployeeService {

@PersistenceContext(unitName="application2Jpa") EntityManager entityManager; // The Unit name is defined at persistence.xml.

@Override

public void delete(Address address) {

Address addressToDelete=(Address) entityManager.getReference(Address.class, address.getId());

entityManager.remove(addressToDelete);

}

@Override

public Address findByID(Integer addressId) {

Address address=(Address) entityManager.find(Address.class, addressId);

return address;

}

@Override

public Address save(Address address) {

entityManager.persist(address);

return address;

}

Configure persistence.xml

The persistence.xml is required as per JPA implementation. It describes the persistence unit related information. The Persistence.xml resides under the <>/src/META-INF folder.

org.hibernate.ejb.HibernatePersistence
com.springtutorial.vo.Address

Configure spring application-services.xml

The spring creates and instantiates the beans during the server startup based on the configuration details defined in the service xml. The spring creates the entity manager proxy with entity manager, JPA vendor adapter, data source and persistence unit information. The transaction boundaries can be also declared for the bean.

version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop="http://www.springframework.org/schema/aop"

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-2.0.xsd

http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">

<bean

class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />

<property name="transactionManager"><ref local="transactionManager"/>property>

<props>

<prop key="*">PROPAGATION_REQUIREDprop>

props>

property>

bean>

bean>

property>

bean>

<bean id="entityManagerFactory" class=

"org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">

bean>

property>

<value>classpath:/META-INF/persistence.xmlvalue>

property>

bean>

<bean id="dataSource"

class="org.springframework.jdbc.datasource.DriverManagerDataSource">

bean>

<bean id="transactionManager"

class="org.springframework.orm.jpa.JpaTransactionManager">

bean>

beans>

Test Case

The AbstractJPATests can be used to test the service implementation class. The method getConfigLocations informs the Spring runtime to load the application-services.xml. The spring injects the EmployeeServiceImpl proxy at runtime.

import org.springframework.test.jpa.AbstractJpaTests;

import com.springtutorial.dao.EmployeeServiceImpl;

import com.springtutorial.vo.Address;

/**

* @author Elangovan Mohan

public class EmployeeServiceTest extends AbstractJpaTests {

public EmployeeServiceImpl employeeService;

/**

* @param employeeService the employeeService to set

public void setEmployeeService(EmployeeServiceImpl employeeService) {

this.employeeService = employeeService;

}

protected String[] getConfigLocations() {

return new String[] { "classpath:/com/springtutorial/dao/application-services.xml" };

}

protected void onSetUpInTransaction() {

Address employee=new Address();

employee.setId(300);

employee.setNumber(3);

employee.setStreet("Southside Blvd");

employeeService.save(employee);

}

public void testAdd() {

// Address employee=new Address();

// employee.setId(300);

// employee.setNumber(3);

// employee.setStreet("Southside Blvd, Jacksonville,FL");

// employeeService.save(employee);

// Address address=employeeService.findByID(new Long(100));

// assertNotNull(address);

}

Test service implementation

The AbstractJPATests automatically rolls back all the data upon test completion. It makes sure that the data is not persisted in the database. This provides opportunity to test the methods multiple times.

References:

https://www6.software.ibm.com/developerworks/education/j-spring2/section3.html

http://struts.sourceforge.net/struts-spring/index.html

http://www.hibernate.org/hib_docs/entitymanager/reference/en/html/

http://docs.huihoo.com/spring/2.0.x/en/transaction.html#transaction-declarative

http://forum.hibernate.org/viewtopic.php?p=2400801

http://www.netbeans.org/kb/60/web/web-jpa-part2.html

Problems and Troubleshooting

Server timeout

The default time out is 50ms for the most of the freeware app servers such as jboss or tomcat. You need to increase the time out period at the server console. The time out parameter is configurable in Eclipse 3.4.1 or above versions.

Jar compatibility

Make sure all the jar files are compatible. For example, slf4j-api-1.5.6.jar and slf4j-log4j12-1.5.6.jar requires log4j-1.2.15.jar.

java.lang.ClassNotFoundException: <>

It is the most common problem that you come across when you run the test case. You need to make sure all the compile time and runtime jars are configured at the class path and Java EE module dependencies.

org.hibernate.LazyInitializationException: could not initialize proxy - no Session

This happens when the EntityManager is not configured correctly. You need to make sure the persistence unit name is defined in the dao and persistence.xml.

5. Can not convert object[your object, proxoy] … happens during the injection….

The possible cause could be the implementation class is configured for the dependency injection at your client code. All you need to do is change the implementation class to the interface.

2007-08-18T17:17:00.000-07:00

Spring

Spring is a light weight frame work to develop enterprise applications. It can be used to configure declarative transactions, web services, mailing facilities and other configuration information.

Spring Architecture

The architecture consists of seven modules.

1. AOP (Aspect oriented programming)

The OO programming addressed designing complex systems as group of entities and interaction among the components. But the changes in requirement have impact on developing applications. The AOP allows the developers to dynamically modify the OO model to create new system. It consists of fours features,

1. Cross-Cutting concerns:

The OO model performs primary functions along with secondary functions. The secondary functions are shared across other models. Example, we need to add logging code with in DAO class, Servlet whenever the thread enters and exists.

2. Advice:

This is the additional code that you need to apply to your existing model.

3. Point-Cut:

It is a point of execution where the Cross-Cutting concerns needs to be applied. In our example, the point cut is reached when the thread enters and thread exists.

4. Aspect:

The combination of advice and point-cut is called aspect. In our example, we add aspect to our application by defining point-cut and giving correct advice.

2. ORM (Object Related Model)

The ORM is related to database access. It provides the integration layers for Hibernate, JDO and iBatis.

3. DAO (Data Access Object)

It is primarily for standardizing the data access work using Hibernate, JDO and others.

4. Context

It provides consistent of accessing the applications resources.

5. Web

It is a part of web application development.

6. Web MVC

These modules provide the MVC implementation.

7. Core

The core is important modules of Spring framework. It provides Dependency Injection features. The BeanFactory separates the object creation, initialization and access of the objects.

How Spring is configured?

The spring listener is configured in the web.xml. The listener initializes when the server starts up. It looks for a parameter contextConfigLocation in the web.xml.

org.springframework.web.context.ContextLoadListener

contextConfigLocation

WEB-INF/sampleContext.xml

How Hibernate is configured?

· A hibernate mapping file has to be created for each POJO (Plain Old Java Object).

This mapping file has to be defined in the applicationcontext.xml.

· Hibernate mapping file will be defined in the applicationcontext.xml file.

"http://www.springframework.org/dtd/spring-beans.dtd">

class="org.springframework.jdbc.datasource.DriverManagerDataSource">

org.hsqldb.jdbcDriver

jdbc:hsqldb:db/appfuse

class="org.springframework.orm.hibernate.LocalSessionFactoryBean">

org/appfuse/model/User.hbm.xml

net.sf.hibernate.dialect.HSQLDialect

create

class="org.springframework.orm.hibernate.HibernateTransactionManager">

JNDI Data source

class="org.springframework.jndi.JndiObjectFactoryBean">

java:comp/env/jdbc/appfuse

Implementing Hibernate with DAO

The DAO class has to implement the HibernateDAOSupport class.

Public SampleDAO extends HibernateDAOSupport implements ISampeDAO {

Public List getUsers(int userId) {

Return (List) getHibernateTemplate().find(“from user”);

}

Public UserVO getUser(int userId) {

Return (UserVO) getHibernateTemplate().get(UserVO.class,userid);

}

public void deleteUser(UserVO user) {

getHibernateTemplate().delete(user);

}

public void saveUser(UserVO user) {

getHibernateTemplate().save(user);

}

public void updateUser(UserVO user) {

getHibernateTemplate().update(user);

}

The VO object has to implement three methods.

public abstract String toString();

public abstract boolean equals(Object o);

public abstract int hashCode();

Business Delegate With Hibernate

The Spring framework allows layering the components. So the presentation layer does not need to access the DAO layer directly. The business delegate pattern facilitates separating the layers. It accesses the DAO to retrieve and store the data and the presentation layer interacts with the business delegate.

class="org.appfuse.service.UserManagerImpl">

class="org.springframework.transaction.interceptor.TransactionProxy

FactoryBean">

PROPAGATION_REQUIRED

PROPAGATION_REQUIRED,readOnly

2006-06-21T15:52:00.000-07:00

Introduction

This is my first effort to prepare notes about the basic java for Dummies. I may not claim that it covers everything but I try to cover the some of the important areas that beginners need to know. Please note that this is not a guide for java but it may give you an overall view. You may need to visit http://www.java.sun.com/ to get the language specification and documentation. It may be useful for those who have experience in client server technologies and willing to switch over to J2EE world.

1. Object Oriented Programming Principles

Before you start studying Java you may need to know the principles of the OOPs.

The Open/Closed Principle: Software entities (classes, modules, etc) should be open for extension, but closed for modification.

The Liskov Substitution Principle: Derived classes must be usable through the base class interface without the need for the user to know the difference.
The Dependency Inversion Principle: Details should depend upon abstractions. Abstractions should not depend upon details.

The Interface Segregation Principle: Many client specific interfaces are better than one general purpose interface/

The Reuse/Release Equivalency Principle: The granule of reuse is the same as the granule of release. Only components that are released through a tracking system can be effectively reused.

The Common Closure Principle: Classes that change together, belong together.

The Common Reuse Principle: CClasses that aren't reused together should not be grouped together.

The Acyclic Dependencies Principle: The dependency structure for released components must be a directed acyclic graph. There can be no cycles.

The Stable Dependencies Principle: Dependencies between released categories must run in the direction of stability. The dependee must be more stable than the depender.

The Stable Abstractions Principle: The more stable a class category is, the more it must consist of abstract classes. A completely stable category should consist of nothing but abstract classes.

2. OOPs Concepts

2.1. Object

Object is an instance of a class. The instance is an executable copy of a class is called Object. It maintains the state in its variable. The behavior is implemented in the method.

Example,
A bicycle is an object.

2.2. Class

Class is a structure that defines the data and method that work on that data.

Example,
Bicycle is a family of bicycles; it has state (gear and two wheels) and behavior (change gear and break). The bicycle state and behavior is different from other bicycles.

2.3. Encapsulation

The object (instance) state and behavior are hidden from the other classes that use it. To achieve the good encapsulation, all the variables have to be declared private and accessed via (assessors and mutators).

Example;
public class TestClass {
/* declare name */
private String name; /* The object state is protected from outsiders */
public class() {
this.name=null;
}

/**
Sets the name
@param String name
*/
public void setName(String name) { /* Set the state through the set method */
this.name=name;
}

/**
Gets the name
@return String name
**/
public String getName() { /*Get the state through the get method */
return this.name;
}
}

2.4. Inheritance

A class inherits state and behavior from the base class. It helps to reuse the code and code organization

2.5. Polymorphism

It is used to redefine the method behavior especially in the derived class.

2.6. Composition, Aggregation, Association and Generalization

Composition is a “is a” relationship. It is implemented by using the inheritance.
Example,
Public class Employee extends Person { /** it is a “is a relationship **/

}

2.7. Aggregation is a “has a” relationship. It is implemented using containment.
Example,
public class Car {
Engine engine; /** It is a “has a” relationship. **/
Vector wheel;
Vector seats;
}

2.8 Association

Class A has a path to Class B as an attribute or in a method call that returns the class B. Class A has an association with the class B.

2.9 Generalization

Generalization is a super class-subclass relationship.

InputStream is a Generalization of FilterInputStream, which is a generalization of DataInputStream.

3. Opps in Java

3.1 Inheritance

A class will be automatically containing the variable and methods defined in their super types and all of its ancestors.

Java does not support multiple class inheritance.

Subclass inherits the following,
· The public or protected variables
· Access the variable with no access specifier as long as the subclass is in the same package.
· Subclass does not inherit the super class member if the subclass declares the member with the same name.

Override
Providing different implementation in the subclass of the class that originally defined the method.

Overriding Member Variables(Hiding)
public class Super {
Number aNumber;
}

public class Base extends {
Float aNumber; // The member variable aNumber hides the Super.aNumber. But the base variable can be accessed by super.aNumber.
}

Overriding Methods

Thumb rules when overriding the methods,

· The return type, method name, number and type of arguments must match those in the overridden method.
· The overriding method can have different throws clause as long as the overridden method does not declare any throws clause.
· The access specifier for the overriding method can allow more access, but not less. Example, protected method in the super class can be made public not private.

A subclass cannot override in the following scenario,
· If the super class method is final and static.

3.2 Polymorphism
It allows derived class to redefine the methods. It is achieved through the overloading.

The method overloading can be achieved by providing different no.of arguments or data types with same return type and method name.

3.3 Abstract Class

An abstract class is a class that can only be subclassed-- it cannot be instantiated.
abstract classname {
}

The abstract class can define the methods without any implementation. So the base class will implement the method.

3.4 Final Class and Methods

A class can be declared as a final to provide the security, that the class cannot be inherited or subclassed.

The methods also can be protected from being overridden.
Example,
public final Test {
public final void printX() {
System.out.println(“X”);
}
}

3.5 Interface

An interface is a named collection of method definitions (without implementations). It can also declare the constants.

The following is the syntax of the Interface.

public interface interfacename
Extends SuperInterface /** Can extend any number of Interfaces. **/
{
Declare constants.
/** public static final variable name **/
Define methods.
/** public abstrace returntype methodname {arguments} throws clause if any; **/
}

The abstract modifier is implicitly used for interface and method declarations within the interface declaration. It should be avoided for interface and method declarations.

The following are the difference between the interface and the abstract class.

4. Class

Class Declaration

public // the class publicly accessible
abstract // instance can not be created
final // class can not be sub classed
class class name
extends
implements
{
//constructors
//member variables
//methods
//finalize block
}

Constructor

The constructor is used to initialize new object of that type. The constructor has the same name as the class.
· Java supports the name overloading for the constructor so that the constructor can have any number of constructors with the same name.
· Default constructor is provided if the constructor is not defined for the class.
· The following are the scope of the constructor,

1. private
No other class can create the instance. It is used in the singleton pattern.
2. protected
Only the subclasses of the class and classes in the same package can create the instance.
3. public
Any class can create the instance.
4. no specifier
Only classes with in the same package can create the instance.

Member Variable

The following is the syntax for the member variable declaration,

Access level
Specifies the access level for other classes,

Specifier Class Subclass Package World

private Class
protected Class Subclass Package
public Class Subclass Package World
package Class Package

if left unspecified

private
It is more restricted access level. The private variables and methods can be used only with in the class.

protected
The member variables and methods can be accessed only with in the family (class, subclass and package).

Example,
package family;
public class SuperClass {
protected int x=0;
protected void printWord(String word){
System.out.println(word);
}
}

package family;
public class BaseClass extends SuperClass {
public void accessMethod(SuperClass s) {
s.x; //legal
s.printlWord(“Hello World”); //legal
}
}

The above code shows that the protected variable and method access is legal with in the same package of the super class.

package outsiders;
import family.SuperClass;
public class Outsider extends SuperClass {
public void accessMethod(SuperClass s) {
s.x; //illegal
s.printWord(“Hello World”); //illegal
}
}
The above code shows that the protected variable and method access is illegal with in the same package of the super class.

public
The member variables and methods are visible to the outsiders.
package
The package scope is used if none of the above specifiers are used.
static
It is used to declare the class variable instance of instance variable.
final
It makes sure that the variable value cannot be changed.
transient

volatile

type

name
The name can be any java identifier and start with lower case letter.

Implementing Methods

The following is the method syntax,

{access specifier} {return type} {method name} {arguments} {throws clause}

access specifier
The access specifier can be public, protected, private and no specifier.
static
It declares the method as a class method instead of instance method.
final
The final methods cannot be overridden.
abstract
An abstract method has no implementation and must be a member of abstract class.
native

synchronized
It makes sure that the method is thread safe.