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.AutowiredAnnotationBeanPostPr
ocessor"/>

@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.
The following code snippet illustrates an example:
{
@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
@Autowired using byType by
importing the embedded
project in Eclipse.

Activity: Implementing Autowiring Using Constructor
@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
@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 controller
component. 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:
Validator
Custom
Validator
Bean 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.validation
package.
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 Validator
interface:
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
validation.

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
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 following
the framework strategy is
automatically 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 e
transaction management is
possible. Declarative
transaction management
works 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
Annotations
Entity
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.xml
Implemented
client side code
via EntityManager

Implementing Spring JPA (Contd.)
Download Hibernate
Components
Prepare Database, and
Download JDBC Driver
1. Hibernate Core
2. Hibernate EntityManager
3. Hibernate Annotations
http://www.hibernate.org/
MySQL JDBC Driver
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

Recommended

More Related Content

What's hot (18)

Similar to Spring Framework - III (20)

More from People Strategists (20)

Recently uploaded (20)

Spring Framework - III