Level 2.2 CBT Course on Advanced Programming With Spring

7/28/2019 Level 2.2 CBT Course on Advanced Programming With Spring

1/45

Oct 13 2008 TPG Confidential1

Technology Practices GroupJava Competency Framework

"Incubate, Nurture and Deploy Technology Experts

Innovate, Build and Deliver Technology Solutions


2/45


Document Details

Business Unit BFSIGroup Technology Practices Group

Practice Java Practice

Sub-Practices Java CoE technologies

Initiative Competency Framework

Competency Level 2.2 Level 3

Experience Level 3 Years

Pre-Requisite J2EE

Version 1.1

Author MuthuVeerappan Krishnamoorthy

Baskar Muniyandi

Total number of slides 45

Duration of learning 24hrs


3/45


Revision History

Version

(x.yy)

Date of

Revision

Description of Change Reason for

Change

Affected

Sections

Approved By

1.0 September

2007

Initial Version

1.1 January

2009

Content on new templates.

Review and updation.


4/45


Objective

** Please read the objective of this content clearly **

This presentation is essentially to set the context oflearning on this topic. The content deals with thecoverage( both depth and width applicable) for thisparticular topic in a concise format, providing an overviewof the elements that makes up this Topic level.

While this content provides with a high levelunderstanding of the topic to the level of depth that is

expected at this particular level( Levels 1.1, 2.1 etc ) , it ishighly recommended to have a detailed in depth learningusing the resources mentioned in the AdditionalResources section.


5/45


Agenda

Introduction to Spring What is Spring? Spring Components Overview of Spring Components

Integrating with other web frameworks

Accessing and Implementing EJBs

JMX Support Sending Email with Spring

Scheduling Jobs using Quartz or Timer

Exception Handling

Testing

Features of Spring Framework Architectural Layers in a typical Spring Application

Advantages

Summary


6/45


1.1 What is Spring?

A J2EE Framework designed to make building applicationseasier.

Provides a means to manage your business objects and their

dependencies.

Inversion of Control allows classes to be loosely coupled and

dependencies written in XML. Spring is a Lightweight Appl icat ionFramework.

Where Struts, WebWork and others can be considered Web

frameworks, Spring addresses all tiers of an application.


7/45Oct 13 2008 TPG Confidential7

1.2 Spring Components

CoreSupporting UtilitiesBean Container

AOPSource level

metadata

AOP

infrastructure

ORMHibernate/IBatis/JDO

Support

DAOTransaction Infrastructure

JDBC / DAO Support

WebWebApplicationContext

Multipart resolver

Web utilities

ContextApplication context

UI support / Validation

JNDI,EJB support and

Remoting mail

Web MVCWeb MVC

FrameworkWeb Views

JSP / Velocity

PDF / Excel



1.3 Overview of Spring Components

Core + Context = Framework

IoC bean container

Application context, message sources, resource loading, wiringinfrastructure.

DAO

JDBC Templates taking care of connections, statements,exceptions.

DataAccessException Hierarchy. Transaction Infrastructure

Programmatic

Declarative through IoC & AOP

Pluggable strategies (e.g. JDBC, JTA, JDO)

ORM

Extends DAO, integrates O/R Mapper with Spring concepts Transaction SPI

Templates

Factories

Hibernate, JDO, OJB, iBATIS



1.3 Overview of Spring Components (Cont..)

AOP

Method Interception Adding functionality before, after and around a method call or in case of an

exception

Introduction

Adding methods or fields to an existing class or interface

Useful for declarative enterprise services

Transaction management

Security

Thread management

Tracing, auditing, notification Web

Web application context

Binding & validation and web utilities

Multipart resolver for file upload

Supports Struts, JSF, WebWorks, Tapestry, Web MVC

Springs IoC web framework

Generic DispatcherServlet and controller

Designed for any view technology (JSP, JSTL )

Theme support (CSS/Images/HTML bundles)



2.1 Integrating with Other Frameworks

Spring can be easily integrated into any Java-based web framework like

JavaServer Faces

Struts

Tapestry

WebWork

Spring integrates nicely with other web frameworks with two methodologies:

Look up Spring beans within Controllers/Actions via the conveniencestatic method:WebApplicationContextUtils.getWebApplicationContext(servletContext).getBean(beanName)

Configure the Controllers/Actions for the web framework in a SpringBeanFactory and then use Spring provided proxies in the actual web

framework configuration When available, this methodology is preferred

This approach lets you design your Controllers/Actions withdependency injection and makes your Controller/Actions moretestable



2.1 Integrating with other web frameworks

All you need to do is to declare the ContextLoaderListenerin your web.xml and use acontextConfigLocation to set which context files to load.

The :

The :

If you don't specify the contextConfigLocation context parameter, theContextLoaderListener will look for a/WEB-INF/applicationContext.xmlfile to load.Once the context files are loaded, Spring creates a WebApplicationContext objectbased on the bean definitions and puts it into the ServletContext.

contextConfigLocation

/WEB-INF/applicationContext*.xml

org.springframework.web.context.ContextLoaderListener


12/45Oct 13 2008TPG Confidential 12

2.2 Web Integration - JSF

The easiest way to integrate your Spring middle-tier with your JSF web layer is to use the

DelegatingVariableResolver

org.springframework.web.jsf.DelegatingVariableResolver

en

en

es

messages

..

The DelegatingVariableResolverwill first delegate value lookups to the default resolver of

the underlying JSF implementation, and then to Spring's root WebApplicationContext.

This allows you to easily inject dependencies into your JSF-managed beans.


13/45Oct 13 2008 TPG Confidential

13

2.3 Web Integration - Struts

To integrate your Struts application with Spring, you have two options:

Configure Spring to manage your Actions as beans, using the ContextLoaderPlugin, and set theirdependencies in a Spring context file.

Subclass Spring'sActionSupportclasses and grab your Spring-managed beans explicitly using a

getWebApplicationContext() method.

public class UserAction extends DispatchActionSupport {

public ActionForward execute(ActionMapping mapping, ActionForm form,

HttpServletRequest request, HttpServletResponse response) throws Exception {

..WebApplicationContext ctx = getWebApplicationContext();

UserManager mgr = (UserManager) ctx.getBean("userManager");

// talk to manager for business logic

return mapping.findForward("success");

}

}



14

3.1 Accessing & Implementing EJB

EJB Access With EJBs it is usual to have

A ServiceLocator

Takes care of JNDI, initial context, EJB home lookup

A Business Delegate

Reducing coupling, hides the implementation Spring Access

Spring approach is to allow the creation and use of proxy objects,

normally configured inside a Spring ApplicationContext or

BeanFactory, which act as code-less business delegates.

You do not need to write another Service Locator, another JNDIlookup, or duplicate methods in a hand-coded Business Delegate

unless youre adding real value.



15

To obtain the controller object out of a Spring ApplicationContext or BeanFactory,

configure a LocalStatelessSessionProxyFactoryBeaninstance, which will be EJB

proxy object.

To use a Local, Stateless, Session bean, the spring config entry would be

The myComponentbean definition creates a proxy for the EJB, which implements the

business method interface. The EJB local home is cached on startup, so theres only a single JNDI lookup.

You can swap the bean implementation with a POJO or mock objects without

changing the client code.

You dont have to write a single line of JNDI lookup or other EJB plumbing code as

part of the application.

3.2 Accessing a Local SLSB (StateLess Session

Beans)



16

3.3 Accessing a Remote SLSB

Accessing remote EJBs is essentially identical to accessing localEJBs, except that theSimpleRemoteStatelessSessionProxyFactoryBean is used.

To use a Remote, Stateless, Session bean

myComponent

com.mycom.MyComponent



17

3.4 EJB Implementation classes

To implement a Stateless or Stateful session bean, or Message Driven

bean, you derive your implementation class from

AbstractStatelessSessionBean, AbstractStatefulSessionBean, and

AbstractMessageDrivenBean/AbstractJmsMessageDrivenBean,

respectively.

AbstractEnterpriseBean

Loads a BeanFactory

EJB environment variable ejb/BeanFactroyPath specifies the

location on the classpathof an XML bean factory definition

E.g. /com/mycom/mypackage/mybeans.xml

Default bean factory is XmlApplicationContext

Applications should use the EJB only as a facade

Business logic deferred to beans in BeanFactory



18

3.4.1 Implementing a SLSB

Stateless Session Beans

Extend AbstractStatelessSessionBean Save the session context

Empty implementation of ejbRemove()

ejbCreate() method

Throws exception in ejbActivate() and ejbPassivate()

Subclasses must implement onEjbCreate()

Example

class MySlsb extends AbstractStatelessSessionBean {

protected void onEjbCreate() throws CreateException {

...

}

public void businessMethod() {BeanFactory bf = getBeanFactory();

MyBusinessBean mbb = bf.getBean("myBusinessBean");

...

}

}


19/45


3.4.2 Implementing a SFSB

Stateful Session Beans

Extend AbstractStatefulSessionBean Save the session context

Empty implementation of ejbRemove()

ejbCreate() method

Subclasses must implement onEjbCreate(), ejbActivate() and ejbPassivate()

Example

class MySfsb extends AbstractStatefulSessionBean {

public void ejbCreate() throws CreateException {

loadBeanFactory();

...

}

public void ejbActivate() { . }

public void ejbPassivate() { . }public void businessMethod() {

BeanFactory bf = getBeanFactory();

MyBusinessBean mbb = bf.getBean("myBusinessBean");

...

}

}


20/45


3.4.3 Implementing a MDB

Exampleclass MyMdb extends AbstractJmsMessageDrivenBean {

protected void onEjbCreate() throws CreateException {

...

}

public void onMessage(Message message) {

BeanFactory bf = getBeanFactory();

MyBusinessBean mbb =

bf.getBean("myBusinessBean");

...}

}


21/45


4.1 Spring JMX Support

Automatic registration of any Spring bean as a JMX MBean Flexible control of the management interface

Flexible control of Object Names

Declarative exposure of MBeans over remote, JSR-160

connectors

Proxying of both local and remote MBeans Control of MBean registration behavior (Spring 2.0)

Notification support (Spring 2.0)


22/45


4.2 Exporting your Beans to JMX

Core class MBeanExporter:

Registers Spring beans as JMX MBeans with the JMX MBeanServer.

Explicit registration of any Spring bean:

Valid JMX MBeans

POJOs

Automatic detection / registration of valid JMX MBeans.

Example


23/45


4.3 Automatic Registration

MBeans can be automatically detected by the MBeanExporter bysetting the autodetect property to true


24/45


4.4 Management Interface Control

Powerful and comprehensive facilities Many ways to control the exposed interface

MBeanExporterdelegates to implementations of

MBeanInfoAssemblerfor creating management interfaces at

runtime.

Reflection-based (default, exposes everything)

Source Level Annotationbased

Commons Attributes

JDK 5.0 Annotations

Java Interface-based Method name-based


25/45


4.5 Object Name Control

Many ways to control ObjectNames as well MBeanExporterdelegates to implementations of

ObjectNamingStrategy for creating ObjectNames

Based on key from beans property map (default)

Based on external Properties file

Based on JVMs notion of object identity

Based on source-level annotation


26/45


4.6 JSR 160 Connectors / Proxies

Spring JMX supports creating both server and client Connector beans.

A client Connector bean could point to any remote MBeanServer

Spring can proxy remote objects:


27/45


5.1 Sending Email with Spring

SimpleMailMessage - Creating a message

SimpleMailMessage msg = new SimpleMailMessage();

msg.setFrom("[email protected]");

msg.setTo("[email protected]");

msg.setCc(new String[] {"[email protected]", "[email protected]"});

msg.setBcc(new String[] {"[email protected]", "[email protected]"});

msg.setSubject("my subject");

msg.setText("my text");


28/45


5.2 MessageSender

Defining a message sender

smtp.mail.org

joeabc123

Sending the messageMailSender sender = (MailSender) ctx.getBean("mailSender");

sender.send(msg);


29/45


6.1 Scheduling Jobs using Quartz or Timer

Built-in support for Java 2 Timer

Timer

TimerTask

Quartz Schedulers

JobDetails

Triggers


30/45


6.2 ScheduledTimerTask

The task that we want to runpublic class MyTask extends TimerTask {

public void run() {

// do something

}

}

60000

1000

Java bean that wraps a scheduled

java.util.TimerTask


31/45


6.3 TimeFactoryBean

Creating the scheduler

The Timer starts at bean creation time

Creates ajava.util.Timer object


32/45


7.1 Exception Handling

In general you want to allow fatal exceptions to propagate upthe stack.

These exceptions can be handled by a last ditch handler

Log the error

Notify an administrator

Display a friendly error-page for the user.

Use an implementation of the HandlerExceptionResolver

interface


33/45


7.2 HandlerExceptionResolver interface

public interface HandlerExceptionResolver {

ModelAndView resolveException(

HttpServletRequest request,

HttpServletResponse response,Object handler,

Exception ex);

}


34/45


7.3 Configuring the HandlerExceptionResolver

Special bean, resolved by type Single implementation out of the box

SimpleMappingExceptionResolver

Map Exception types to view names

Puts the Exception into the model automatically.

Useful out of the box, even better for extension


35/45


7.4 Configuring SimpleMappingExceptionResolver

java.lang.Exception=error

All exceptions are mapped to the error view


36/45


Rather than build your ownHandlerExceptionResolver extend the

SimpleMappingExceptionResolver

Simple process

Override the resolveException() method

Call super.resolveException()

Perform custom processing

Return (potentially modified) ModelAndView

7.5 Extending SimpleMappingExceptionResolver


37/45


8.1 Spring and Testing

Easier test driven development (TDD)

Unit testing

Allows you to test outside the container without using theSpring container.

Integration testing

Can use a standalone Spring configuration with mock

objects for testing. Consider XMLApplicationContext or

FileSystemApplicationContext.

Correct wiring of your Spring contexts.

Data access using JDBC or ORM tool--correctness of SQL

statements. For example, you can test your DAOimplementation classes

Easy to test POJOs


38/45


8.2 Testing outside the container

Spring MVC is easy to test outside the container Support classes in spring-mock.jar

MockHttpServletRequest

MockHttpServletResponse Unit testing

Use EasyMock/JMock

Test exception handling

Test ModelAndView creation Integration testing

Extend AbstractTransactionalDataSourceSpringContextTests

Use real service/data tier objects


39/45


9.1 Features of Spring Framework

Transaction Management: Spring framework provides a generic abstraction

layer for transaction management. This allowing the developer to add the

pluggable transaction managers, and making it easy to demarcate transactions

without dealing with low-level issues. Spring's transaction support is not tied to

J2EE environments and it can be also used in container less environments.

JDBC Exception Handling: The JDBC abstraction layer of the Spring offers

a meaningful exception hierarchy, which simplifies the error handling strategy Integration with Hibernate, JDO, and iBATIS: Spring provides best

Integration services with Hibernate, JDO and iBATIS.

AOP Framework: Spring is best AOP framework

MVC Framework: Spring comes with MVC web application framework,

built on core Spring functionality. This framework is highly configurable via

strategy interfaces, and accommodates multiple view technologies like JSP,

Velocity, Tiles, iText, and POI. But other frameworks can be easily used instead

of Spring MVC Framework.

10 1 A hit t l L i t i l S i


40/45


10.1 Architectural Layers in a typical Spring

Application

JSPs or other views

Generate HTML

Web tier actions

Process user input

Call Service layer,

choose view to display,

Remote service

exporters:

Web services or other

protocols

Business Services Layer:Exposes key functionality.Manages transaction boundaries,includes business logic.No knowledge of persistence specifics.

Declarative services typically used here.

DAO Interface implementing layer

Retrieves,Saves entities using ORM tool,

JDBC

DAO interface layer

Defines persistence operations,

independent of implementing

technology O/R Mapping layer

Persistent domain object

(entity)

Core OO Model

J

D

B

C

RDBMS

10 1 Architectural Layers in a typical Spring


41/45


10.1 Architectural Layers in a typical Spring

Application

Presentation Layer:This is most likely to be a web tier. It should be

possible to have alternative presentation layers-such as a web tier orremote web services faade-on a single, well-designed middle tier.

Business Services Layer: This is responsible for transactionalboundaries and providing an entry point for operations on the system as awhole. This layer should have no knowledge of presentation concerns,and should be reusable.

DAO interface Layer: This is a layer of interfaces independent of anydata access technology that is used to find and persist persistent objects.This layer effectively consists of strategy interfaces for the businessservices layer. This layer should not contain business logic.Implementations of these interfaces will normally use an O/R Mappingtechnology or Springs JDBC abstraction.

Persistent domain objects: These model real objects or concepts suchas a bank account.

Databases and legacy systems: By far the most common case is asingle RDBMS.However,there may be multiple databases, or mix ofdatabases and other transactional or non-transactional legacy systems orother enterprise resources.


42/45


Advantages

Spring is an application frame work. Unlike single tier frameworks

such as struts or Hibernate, Spring aims to help structure whole

applications in a consistent, productive manner, pulling together best-

of-breed single tier frameworks to create a coherent architecture.

Spring enables you to enjoy the key benefits of J2EE, while

minimizing the complexity encountered by application code.

The essence of spring is in providing enterprise services to Plain OldJava Objects(POJOs).This is particularly variable in a J2EE

environment, but application code delivered as POJOs is naturally in

a variety of runtime environments.

Spring is both the most popular and most ambitious of the lightweight

frameworks. It is the only one to address all architectural tiers of a

typical J2EE application, and the only one to offer a comprehensive

range of services, as well as a lightweight container.


43/45


Summary

Spring integrates existing good solutions and does not compete with

them

Spring makes it much easier to access EJBs and implement EJBs and

functionality within them.

The JMX support in Spring provides you with the features to easily and

transparently integrate your Spring application into a JMX

infrastructure. Spring provides a higher level of abstraction for sending electronic mail

which shields the user from the specifics of underlying mailing system

and is responsible for a low level resource handling on behalf of the

client.

Spring supports the Timer, part of the JDK since 1.3, and the Quartz

Scheduler (http://www.quartzscheduler.org).

Applications built using Spring are very easy to test.


44/45


References

http://www.springframework.org/

http://www.theserverside.com

Spring Framework Documentation

http://static.springframework.org/spring/docs


45/45

Additional Resources

SL # Topic Element Resource Location/Link Remarks

1

Accessing and

implementing EJBs

http://static.springframework.org/spring/docs/

1.2.x/reference/ejb.html

2 JMX Support


1.2.x/reference/jmx.html

3

Sending Email with

Spring mail

abstraction layer


1.2.x/reference/mail.html

4

Scheduling jobs

using Quartz or Timer


1.2.x/reference/scheduling.html

5 Testing


1.2.x/reference/testing.html
http://static.springframework.org/spring/docs/1.2.x/reference/ejb.htmlhttp://static.springframework.org/spring/docs/1.2.x/reference/ejb.htmlhttp://static.springframework.org/spring/docs/1.2.x/reference/jmx.htmlhttp://static.springframework.org/spring/docs/1.2.x/reference/jmx.htmlhttp://static.springframework.org/spring/docs/1.2.x/reference/mail.htmlhttp://static.springframework.org/spring/docs/1.2.x/reference/mail.htmlhttp://static.springframework.org/spring/docs/1.2.x/reference/scheduling.htmlhttp://static.springframework.org/spring/docs/1.2.x/reference/scheduling.htmlhttp://static.springframework.org/spring/docs/1.2.x/reference/testing.htmlhttp://static.springframework.org/spring/docs/1.2.x/reference/testing.htmlhttp://static.springframework.org/spring/docs/1.2.x/reference/testing.htmlhttp://static.springframework.org/spring/docs/1.2.x/reference/testing.htmlhttp://static.springframework.org/spring/docs/1.2.x/reference/scheduling.htmlhttp://static.springframework.org/spring/docs/1.2.x/reference/scheduling.htmlhttp://static.springframework.org/spring/docs/1.2.x/reference/mail.htmlhttp://static.springframework.org/spring/docs/1.2.x/reference/mail.htmlhttp://static.springframework.org/spring/docs/1.2.x/reference/jmx.htmlhttp://static.springframework.org/spring/docs/1.2.x/reference/jmx.htmlhttp://static.springframework.org/spring/docs/1.2.x/reference/ejb.htmlhttp://static.springframework.org/spring/docs/1.2.x/reference/ejb.html

Level 2.2 CBT Course on Advanced Programming With Spring

Documents