spring framework - iii

of 58© People Strategists www.peoplestrategists.com

Spring Framework -III


Objectives

In this session, you will learn to:

Introduce annotation based Configuration

Identifying stereotypes

Explore validation

Introduce Spring DAO Support

Identify advantages of spring over JDBC

Identify Spring JPA

Implement Spring JPA

Integrate Spring with Hibernate

With the advent of Spring 3 there has been an widespread use of annotations and annotations based configurations.

To turn annotation based configuration on you need to write <context:annotation-config/> into ApplicationContext.xml.

The following code snippet illustrates how to do annotation based configuration:

Introducing Annotation Based Configuration

<?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">

<context:annotation-config/>



</beans>


Introducing Annotation Bases Configuration (Contd.)

@Value

@PreDestroy@Qualifier

@PostConstruct @Component

@AutoWired

The Spring MVC framework provides following annotations:


Use of @Autowired:

You can implement autowiring by specifiying it in bean classes using the

@Autowired annotation.

To use @Autowired annotation in bean classes, you must first enable the

annotation in spring application using below configuration.

The beans dependencies can be autowired in following three ways:

@Autowired on properties

@Autowired on property setters

@Autowired on constructors

Introducing Annotation Based Configuration (Contd.)

<context:annotation-config/>

OR <bean class ="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>


@Autowired on properties:

It is equivalent to autowiring by byType in configuration file.

The following code snippet illustrates an example:


public class EmployeeBean

{

@Autowired

private DepartmentBean departmentBean;

public DepartmentBean getDepartmentBean() {

return departmentBean;

}

public void setDepartmentBean(DepartmentBean

departmentBean) {

this.departmentBean = departmentBean;

}

}


@Autowired on property setters:

It is also equivalent to autowiring by byType in configuration file.




{




}

@Autowired


departmentBean) {


}

}


@Autowired on constructors:

It is equivalent to autowiring by constructor in configuration file.




{

@Autowired

public EmployeeBean(DepartmentBean departmentBean)

{


}




}


departmentBean) {


}

}

Use of @Qualifier:

You may have similar properties in two different beans.

In this case, spring will not be able to choose correct bean.

Consider the example:


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

<beans>

<context:annotation-config />



<bean id="humanResource" class="com.bean.DepartmentBean">

<property name="name" value="Human Resource" />

</bean>



<bean id="finance" class="com.bean.DepartmentBean">

<property name="name" value="Finance" />

</bean>

</beans>

Conflict


To avoid the conflict, you can use the @Qualifier annotation along with

@Autowired.




{

@Autowired

@Qualifier("finance")




}

public void setDepartmentBean(DepartmentBean departmentBean) {


}

//More code

}

Specified


Use of @Component:

The @Component annotation marks a java class as a bean.

Use of @Value:

You can also use the @Value annotation to inject values from a property

file into a bean’s attributes.



@Component

public class AutowiredFakaSource {

@Value("${jdbc.driverClassName}")

private String driverClassName;

@Value("${jdbc.url}")

private String url;

public String getDriverClassName() {

return driverClassName;

}

public String getUrl() {

return url;

}

}


Activity: Implementing Autowiring Using byName

Let us see how to implement@Autowired using byName by

importing the embedded project in Eclipse.


Activity: Implementing Autowiring Using byType

Let us see how to implement@Autowired using byType by

importing the embedded project in Eclipse.


Activity: Implementing Autowiring Using Constructor

Let us see how to implement@Autowired using constructor

by importing the embedded project in Eclipse.


Use of @PostConstruct:

@PostConstruct is used for a method in a bean.

The annotated method gets called just after the invocation of constructor.

It can be used perform operations that you need perform before executing

any other method.

Use of @PreDestroy:

@PreDestroy is also used for a method in a bean.

The annotated method gets called just before an object is garbage collected.

It can be used to perform operations at the final moment.





package com.customer.services;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

public class CustomerService

{

String message;

public String getMessage() { return message; }

public void setMessage(String message) {

this.message = message;

}

@PostConstruct

public void init() throws Exception {

System.out.println("Init method after properties are set :" +

message);

}

@PreDestroy

public void cleanUp() throws Exception {

System.out.println("Spring Container is destroy! Customer clean

up");

}

}


The following code snippet configures the bean in spring config file:


<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">

<bean

class="org.springframework.context.annotation.CommonAnnotationBean

PostProcessor" />

<bean id="customerService"

class="com.customer.services.CustomerService">

<property name="message" value="i'm property message" />

</bean>

</beans>


Activity: Implementing @PreDestroy and @PostConstruct

Let us see how to implement@PreDestroy and @PostConstruct.


@Controller

Identifying Stereotypes

@Repository@Service@Component

The Spring MVC framework provides following stereotypes:

With the @Autowired annotation you need to define the beans in the xml file so that the container is aware of them and can inject them for you.

Spring provides Stereotype annotations that frees you from defining beans explicitly with XML.


Identifying Stereotypes (Contd.)

The following table describes the various stereotype annotations:

Annotation Description

@Component It is a basic auto component scan annotation, it indicates annotated class is a auto scan component.

@Repository You need to use this annotation with in the persistance layer, which acts like database repository.

@Service It indicates annotated class is a Service component in the business layer.

@Controller It is used to create controllercomponent. It is mainly used at presentation layer.



The following code snippet illustrates an example of @Controller:

The following code snippet illustrates an example of @Service:

@Controller ("employeeController")

public class EmployeeController

{

@Autowired

EmployeeManager manager;

//use manager

}

@Service ("employeeManager")

public class EmployeeManager{

@Autowired

EmployeeDAO dao;

public EmployeeDTO createNewEmployee(){

return dao.createNewEmployee();

}

}



The following code snippet illustrates an example of @Component:

The following code snippet illustrates an example of @Repository:

@Component

public class EmployeeService

{

@Autowired

EmployeeDAO empDAO;

@Override

public String toString() {

return empDAO;

}

}

@Repository ("employeeDao")

public class EmployeeDAO {

public EmployeeDTO createNewEmployee()

{

EmployeeDTO e = new EmployeeDTO();

e.setId(1);

e.setFirstName(“Jack");

e.setLastName(“Mathew");

return e;

}

}


Spring provides validation support to validate the entered value.

It provides a simplified set of APIs and supporting classes for validating domain objects.

It also allows one to code the validation logic for custom validator.

Introducing Spring Validation Framework

The Spring MVC framework supports following validation implementation:

ValidatorCustom

ValidatorBean Validation

APi


Spring provides the Validator interface to perform validation.

The Validator interface can be used to validate an Object.

It uses Error Object to report any validator error while validating an Object.

The interface is available in the org.springframework.validationpackage.

It has following two main methods:

supports(Class):

Returns a boolean indicating whether or not the target class can be validated by this

validator.

validate(Object, org.springframework.validation.Errors):

In charge of actually performing validation.

Introducing Spring Validation Framework (Contd.)


The following code snippet shows implementation of the Validatorinterface:


public class PersonValidator implements Validator {

/**

* This Validator validates just Person instances

*/

public boolean supports(Class clazz) {

return Person.class.equals(clazz);

}

public void validate(Object obj, Errors e) {

ValidationUtils.rejectIfEmpty(e, "name", "name.empty");

Person p = (Person) obj;

if (p.getAge() < 0) {

e.rejectValue("age", "negativevalue");

} else if (p.getAge() > 110) {

e.rejectValue("age", "too. old");

}

}

}


Spring provides the several annotations for data validation.

It provides Bean Validation API to validate values of in a form tag.

It has following validation annotation:

@Size

@NotEmpty

@Email



The following code snippet declares the model class:


import javax.validation.constraints.Size;

import org.hibernate.validator.constraints.Email;

import org.hibernate.validator.constraints.NotEmpty;

public class User {

@NotEmpty

@Email

private String email;

@NotEmpty(message = "Please enter your password.")

@Size(min = 6, max = 15, message = "Your password must between

6 and 15 characters")

private String password;

public String getEmail() {

return email;

}

public void setEmail(String email) {

this.email = email;

}

public String getPassword() {

return password;

}

public void setPassword(String password) {

this.password = password;

}

}


Activity: Implementing the Bean Validation API

Let us see how to implementvalidation.


Spring allows you to create custom validator.

You can use Validator interface to implement custom validation.

The following code snippet shows an example:


import org.springframework.validation.Errors;

import org.springframework.validation.ValidationUtils;

import org.springframework.validation.Validator;

public class StudentValidator implements Validator {

public boolean supports(Class<?> clazz) {

return Student.class.isAssignableFrom(clazz);

}

public void validate(Object target, Errors errors) {

ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name",

"name.required");

ValidationUtils.rejectIfEmptyOrWhitespace(errors, "degree",

"degree.required");

ValidationUtils.rejectIfEmpty(errors, "mark", "mark.required");

ValidationUtils.rejectIfEmpty(errors, "address", "address.required");

ValidationUtils.rejectIfEmptyOrWhitespace(errors, "mail",

"mail.required");

Student user = (Student) target;

}

}


Activity: Implementing Custom Validation

Let us see how to implement custom validation.


The Data Access Object (DAO) support in Spring is aimed at making it easy to work with database technologies.

It allows one to switch between the aforementioned persistence technologies fairly easily.

It also allows one to code without worrying about catching exceptions that are specific to each technology.

Introducing Spring DAO

The Spring MVC framework makes use of the following components while processing a user request:

JDBC Hibernate JPA JDO


Identifying Advantages of Spring DAO Over JDBC

Advanntage JDBC Spring

Connections Need to explicitly open

and close connections.

Need a separate strategy

for making code reusable

in a variety of

environments.

Uses a DataSource with the framework managing connections. Code followingthe framework strategy isautomatically reusable.

Exceptions Must catch SQLExceptions

and interpret database

specific SQL error code

or SQL state code.

Framework translates exceptions to a common hierarchy based on configurable translation mappings.

Testing Hard to test standalone

if code uses JNDI lookup

for connection pools.

Can be tested standalone since a DataSource is easily configurable for a variety of environments

Transaction Programmatic transaction

management is possible

but makes code less

reusable in systems with

varying transaction

requirements. CMT

is available for EJBs.

Programmatic or declarativ etransaction management is possible. Declarative transaction managementworks with single data source or JTA without any code changes.


Identifying Spring JPA

JPA (Java Persistent API) is the sun specification for persisting objects in the enterprise application.

It is currently used as the replacement for complex entity beans.

Spring supports Java Persistence API (JPA).

Spring JPA is a library / framework that adds an extra layer of abstraction on the top of our JPA provider.

If you use Spring Data JPA, the repository layer of your application contains

following three layers:


Identifying Spring JPA (Contd.)

Features of JPA

POJO-based persistence

model

Support for enriched domain

modeling

Expanded query

language

Standardized object/relational

mapping

Usable in Java EE and Java SE

environments

Support for pluggable

persistence providers

Inheritance, polymorphism, etc.

Using annotations and/or XML



JPA Main Components

AnnotationsEntity

manager

To label artifacts (classes, methods etc.) for persistence or persistence related operations

A “gateway” to the persistence classes

Allow access to persistent objects, transaction context, query language etc.



Java Application Java Persistence API

Hibernate TopLink Kodo (OpenJPA)

Everyone can use their own favorite persistence technology

Architecture of JPA.


Implementing Spring JPA

Download Hibernate

Components

Prepare Database, and Download

JDBC Driver

Implemented POJO entities and add annotations

Persistence.xmlImplemented

client side code via EntityManager


Implementing Spring JPA (Contd.)

Download HibernateComponents

Prepare Database, and Download JDBC Driver

1. Hibernate Core2. Hibernate EntityManager3. Hibernate Annotationshttp://www.hibernate.org/

MySQL JDBC Driverhttp://tinyurl.com/ymt6rb

http://www.hibernate.org/

http://tinyurl.com/ymt6rb



Implemented POJO entities and add annotations



Configuring Persistence.xml

Entity classes

JDBC Driver

JDBC URL

User name

password

EntityManagerFactory Name



JPA uses following annotations:

@Entity: It signifies that a class is persistent and is attached to a class.

@Id: It is an identity to of an entity class. It can be auto generated.

@Column: It is put on getter of a class variable. It has functionalities such as, Updateable, Nullable, and Length .

For example:



Entity Manager:

It is a gateway to persistent classes

It enables queries to retrieve records.

It provides transaction facility outside the session beans.



Implemented client side code via EntityManager

Persistence EntityManagerFactory

EntityManagerDepartment

Create

Create

Operates

Persistence.xml



Creating Entity:



Finding an Entity:



Updating an Entity:


Integrating Spring with Hibernate

The database layer is used to communicate with the relational database, and provides data persistence.

To access data from a database, you need to implement a tool, such as Hibernate.

Hibernate is a powerful Object Relation Mapping (ORM) tool that lies between the database layer and the business layer.

It enables the application to access data from any database and provides data persistence.

The Spring framework is placed between the application classes and the ORM tool.

Spring enables you to use its features, such as DI and AOP, to configure objects in your application.

Therefore, integration of Hibernate with Spring helps you use the Hibernate objects as Spring beans.


Integrating Spring with Hibernate (Contd.)

RDBMS

Business Layer (Spring)

Database Layer (Hibernate)

Bean Management

Declarative Transaction Management

Hibernate Integration

Service Beans Business Object

Resource Management DAO Object

Hibernate O/R Mapping Transaction Management


Introducing ORM

Most of the object-oriented applications use relational databases to store and manage the application data.

The relational databases represent data in a tabular format, whereas data in object-oriented applications is encapsulated in a class.

You can access a class by using its objects.

However, to access the tabular data, you need to use a query language.

Therefore, it is not possible to directly store the objects in a relational database.

This difference between the object-oriented and relational database paradigms is called impedance mismatch.

ORM is a process to map data representations in an object model having Java data types to a relational data model having SQL data type.


Introducing ORM (Contd.)

It is not possible to directly store the objects in a relational database.

This difference between the object-oriented and relational database paradigms is called impedance mismatch.

ORM is a process to map data representations in an object model having Java data types to a relational data model having SQL data type.

Relational Databases Object-oriented applications

Classes

Tables

Object



Configure the SessionFactory

object in Spring

Access and update data using Data Access Object

To integrate Spring with Hibernate



Configuring the SessionFactory Object in Spring

Create a Spring configuration file (spring-hibernate.xml)

Declare a session factory by using the following code snippet:

<bean id="mySessionFactory"

class="org.springframework.orm.hiber

nate4.LocalSessionFactoryBean">

<property name="configLocation"

value="hibernate.cfg.xml"/>

</bean>



Accessing and Updating Data Using DAO

Create a DAO class and the sessionFactory object

using DI

Declare DAO as a bean in the configuration file

Access DAO class’ methods, similar to other

Spring beans



The following code snippet creates a DAO class:

The following code snippet declares it as bean:

The following code snippet accesses the methods of DAO class:

The DAO class:

.....................

public class CourseDetailsDAO {

private SessionFactory sessionFactory;

..................... }

<bean id="courseDetailsDao" class="university.CourseDetailsDAO">

<property name="sessionFactory" ref="mySessionFactory"/> </bean>

ApplicationContext apc=new

ClassPathXmlApplicationContext("university/spring-

hibernate.xml");

CourseDetailsDAO courseDao

=(CourseDetailsDAO)apc.getBean("courseDetailsDao");


Summary

In this session, you learned that:

You can implement autowiring by specifiying it in bean classes using the @Autowired annotation.

With the @Autowired annotation you need to define the beans in the xml file so that the container is aware of them and can inject them for you.

Spring provides Stereotype annotations, such as:

@Component

@Controller

@Repository

@Service

@Component is a basic auto component scan annotation, it indicates annotated class is a auto scan component.

@Repository is used to signify a persistence layer.


Summary (Contd.)

JPA is the sun specification for persisting objects in the enterprise application.

It is currently used as the replacement for complex entity beans.

If you use Spring Data JPA, the repository layer of your application contains following three layers:

Spring Data JPA

Spring Data Commons

JPA Provider

The database layer is used to communicate with the relational database, and provides data persistence.

To access data from a database, you need to implement a tool, such as Hibernate.


Summary (Contd.)

Hibernate is a powerful Object Relation Mapping (ORM) tool that lies between the database layer and the business layer.

The Spring framework is placed between the application classes and the ORM tool.

Spring enables you to use its features, such as DI and AOP, to configure objects in your application.

spring framework - iii

Technology