Spring – Power to the POJO Introductie tot het Spring Framework

1Oracle Consulting – Java Professional Community – 29 augustus 2005

Spring – Power to the POJOIntroductie tot het Spring Framework

Lucas Jellema

Oracle Consulting – Java Professional Community,

maandag 29 augustus 2005


Agenda

Introductie Spring – History, Background Hoe kom je aan nieuwe objecten

BeanFactory en Inversion of Control + Dependency Injection Hoe laat je bestaande objecten naar je pijpen dansen?

Aspect Oriented Programming (AOP) Business Tier & Architectuur Test Driven Development Spring Persistence & Spring DAO Spring Remoting Losse eindjes, conclusies, discussie Workshop


Where we’ve come from

EJB as we know it… Resembles the original JavaBeans specification in name only. Heavyweight:

• Requires application server• Difficult to unit-test• Intrusive (must implement EJB interfaces)

Complex• Home/Remote/Local/LocalHome interfaces• Deployment descriptors

Non-intuitive


The future of EJB…

Spilling the beans… EJB 3.0 will embrace simplicity Based on POJO/POJI (? Well, maybe) Employ dependency injection instead of LDAP Declarative services (transactions, security) will be

aspects Entity beans will be POJOs, persisted via Hibernate-

like framework


The future is NOW!

Spring is a lightweight container framework Build applications based on POJO/POJI. Wire beans together using dependency injection. Declaratively apply transactions and security using

aspect. Integrates cleanly with Hibernate for persistence.

EJB 3.0=Spring + Hibernate + Metadata


Spring History

J2EE Design and Development – by Rod Johnson, 2002 Introducing the i21 framework

First release of Spring: Spring 2004 Spring 1.2.4: August 2005 Open Source

Interface21 – small company with most core committers

Contributions from Oracle and otherparties

Spawned many sub-projects


Power to the POJO

Consis

tent S

ervic

e Abs

tracti

ons

(Tem

plate

Patte

rn)

AOP

IoC (Dependency Injection)


Spring’s modules


What’s more… Remoting support via RMI, JAX-RPC, and

Hessian/Burlap Metadata (ala, JSR-175 or Commons Attributes) Persistence via TopLink, Hibernate, JDO, or iBatis

support E-mail support EJB support JMX Support (Spring 1.1) JMS support Spring Rich Client Platform (Spring 1.1) Spring .Net


Spring is HOT!


Many books available

J2EE without EJB The starting point

Spring Live Pro Spring Spring in Action Professional Spring Development

By The Team


Spring Home: http://www.springframework.org


Core SpringInversion of Control & Dependency Injection


Coupling

Highly coupled code is… Hard to test Hard to maintain Exhibits “whack-a-mole” style bugs

• Here one pops up, when you solve it, another one appears

Uncoupled code is… Code that doesn’t do anything

Coupling is somewhat necessary… …but should be controlled


Dependency Injection

The “Hollywood Principle”: Don’t call me, I’ll call you.

Collaborators aren’t asked for…they’re received. Also known as “Dependency Injection”, thanks to

Martin Fowler.


Benefits of IoC

Objects are more cohesive because they are no longer responsible for obtaining their own collaborators.

When used with interfaces, code is very loosely coupled.


Elements of a Spring app

Beans Not EJBs. Actually, not necessarily JavaBeans. Just

POJOs Bean wiring

Typically an XML file. A bootstrap class

A class with a main() method. A servlet.

The bootstrap class uses a BeanFactory (or IoC Container) to retrieve POJOs That have been ‘wired’ and ‘dependency injected’


IoC Container in ActionApplication Class needs POJOs

Application

IoC ContainerxmlPOJO 1

pojo 1

pojo 2

pojo 3getBean(“POJO1”)

POJO 2

POJO 3


IoC Container in ActionApplication Class needs POJOs

HrmClient

xml

HrmServiceImpl

hrmService

employeeDao

dataSourceDBDirect

getBean(“hrmService”)

EmployeeJdbcDAO

DriverManagerDataSource

IoC Container

Hrm

Service

DataS

ource

Em

pDA

O


Wiring beans in XML

Root elements is <beans> Contains one or more <bean> elements

id (or name) attribute to identify bean class attribute to specify class

<beans> <bean id=“foo” class=“com.habuma.foobar.Foo”>  </bean></beans>

The bean’s ID

The bean’s fully-qualified classname


Wiring a property

Use <property> element name attribute specifies name of property

<beans> <bean id=“foo” class=“com.habuma.foobar.Foo”>

<property name=“bar”>  </property>

</bean></beans>

Maps to a setBar() call


Property values

Strings and numbers:

Null

Lists and arrays:

<property name=“bar”><value>42</value></property>

<property name=“bar”><value>Hello</value></property>

<property name=“bar”> <list> <value>ABC</value> <value>123</value> </list></property>

<property name=“bar”><null/></property>


Property values

Sets:

Maps:

<property name=“bar”> <set> <value>ABC</value> <value>123</value> </set></property>

<property name=“bar”> <map> <entry key=“key1”><value>ABC</value></entry> <entry key=“key2”><value>123</value></entry> </set></property>


Property values

Property sets:

Other beans:

<property name=“bar”> <props> <prop key=“prop1”>ABC</prop> <prop key=“prop2”>123</prop> </set></property>

<property name=“bar”> <ref bean=“bar”/></property>


Auto-wiring

You can auto-wire… “byName”: Property names are matched to bean

names “byType”: Property names are matched to bean types “constructor”: Pico-like constructor wiring. Like

“byType” except using constructor. “autodetect”: Uses reflection to decide whether to

use “byType” or “constructor”


Auto-wiring

<bean id=“foo” class=“com.habuma.foobar.Foo” autowire=“byName”/>

<bean id=“foo” class=“com.habuma.foobar.Foo” autowire=“byName”> <property name=“bar”><value>bar</value></property></bean>

<beans default-autowire=“byType”> </beans>


BeanFactory vs. ApplicationContext

A BeanFactory is the Spring container. Loads beans and wires beans together. Dispenses beans as requested. XmlBeanFactory is the most commonly used.

An ApplicationContext is a BeanFactory, but adds “framework” features such as: I18N messages Event notification


IoC Examples


Example of a IoC based programming


Core SpringAspect Oriented Programming

AOP – a programming technique that promotes separation of concerns within a software system

Recurring – often infrastructural – concerns can easily be duplicatedin many objects Security Transaction

Management Logging Profiling

AOP suggestsseparation Concerns are applied

at compile or run-time


AOP in a nutshell Aspect: A modularization of a cross-cutting concern. Implemented in

Spring as Advisors or interceptors Joinpoint: Point during the execution of execution. Advice: Action taken at a particular joinpoint. Pointcut: A set of joinpoints specifying where advice should be

applied. Advisor: Fully represents an aspect, including both advice and a

pointcut. Introduction: Adding methods or fields to an advised class. Weaving: Assembling aspects into advised objects.


Without AOP


With AOP


Implementing AOP

Compile time – modify the source code during compilation Requires a customized Java Compiler For example AspectJ; Spring does not do compile time AOP

Run time – byte injection Change the class when loaded, generating a subclass that

contains the aspects Uses CGLib library

Run time – using the JDK 1.3 Dynamic Proxy Instead of getting an object instance, the application receives a

proxy object The proxy implements the same interface

• And maybe something else as well• Besides, it can intercept and wrap method calls


IoC Container hides AOP implementation from POJO consumer

Application

IoC Container

xml Pojo1Impltarget=pojo1Impl

pojo1 = proxyTargetinterceptorNames=> AspectA, AspectB

getBean(“POJO1”)

POJO 1(interface)

implements

Proxy

implements

target

Aspect Ainvoke()

Aspect Bbefore()

AspectA

AspectB


Different types of Advice Before advice

Calls to advised methods are intercepted before the method is called. After returning advice

Calls to advised methods are intercepted after a successful return. After throws advice

Calls to advised methods are intercepted after an exception is thrown. Around advice/interception

Calls to advised methods are intercepted. Call must be explicitly made to target method.

Introduction advice Allows a class (or rather its proxy) to implement additional interfaces Calls to methods are intercepted…even when the target bean doesn’t have the

method!• Actually, just a special case of around advice


Creating Advise

Create a class that implements one or more of the Spring AOP interfaces MethodInterceptor BeforeAdvice AfterReturningAdvice ThrowsAdvice

Implement the interface method before (Method method, Object[] args) afterReturning(Object returnValue, Method method,

Object[] args) invoke(MethodInvocation invocation)


Defining Pointcuts in Spring(specify where to apply which Advice)

Programmatically No BeanFactory required Can be used independently of the rest of Spring

Declaratively In the bean container configuration file

(applicationContext.xml)


Applications of AOP by Spring itselfalways in conjunction with IoC/DI

Remoting Support Proxy references a remote object

Transaction Management Service method is wrapped in around advice that

opens and closes the transaction Security JMX

Proxy implements the MBean interfaces for its target object

Mock Testing Tested objects are injected with Mock objects that are

dynamically created (made up)


Future of AOP – according to Rod Johnson

Programming Aspects and composing an Application from Aspects will become widely accepted Various orthogonal concerns can be dealt with in

parallel Maintaining a single – cross application concern – is

done by maintaining a single aspect Tool and Runtime support for AOP will further increase

Development of IBM WebSphere & WSAD is heavily done in an AOP fashion


Spring’s recommended Application Guidelines and Architecture

Program against interfaces For example Service Interface, DAO Interfaces Typically no interfaces for Domain Classes

No configuration “plumbing” in your classes Have configuration details injected

Domain Classes are used through all tiers No Struts ActionForms to wrap domain classes Controllers use Business Service methods to create or

manipulate Domain Objects Practice “Test driven development”


Spring’s recommended architecture

RDBMS

Presentation Tier

Business Tier

Data Tier

Business Services LayerInterfaces and Container Managed

Implementations

DAO Interface LayerInterfaces, independent of

implementing DAO Technology

DAO Implementation layerRetrieves, saves entities using ORM tool or JDBC

PersistentDomainObjects

O/R Mapping LayerJDB

C

Remote Service ExportersUsing SOAP, RMI, JAX-RPC etc.Web Tier Actions

(Controllers)

View ComponentsGenerate HTML or PDF

JDB

C


Spring and Test Driven Development

Agile Software Engineering methods, such as XP First design and develop a test based on

interfaces Before implementing the interfaces Before starting to resolve a bug

Automated Unit Testing for every class in the application At every stage of development, the test can be rerun!

Unit Testing usually based on JUnit Great integration in Eclipse and JDeveloper 10.1.3

(10.1.2 is somewhat sparse)


Spring and Test Driven Development

Challenges include Container Dependencies (HttpServlet object) Dependencies on external objects (not a unit test)

• Especially objects that are hard to configure, e.g. DAO Impl Dependencies on objects that have not yet been

implemented


Spring support for Test Driven Development

When all objects (Service and DAO Impl) are Spring Beans They get dependency injected by the container

During a test, instead of injecting them with real objects We can inject them with Mock Objects, that will return

the values we specify when called The real objects do not need to exist

• even when they do exist, using mock objects ensures we are performing a true UNIT test


Unit Testing HrmServiceImpl using Mock objects

Unit Test

Business Tier

Data Tier

HrmServiceImpl

EmployeeDAO Interfaces, independent of

implementing DAO Technology

EmployeeDAOImpl(does not yet exist)

PersistentDomainObjects

HrmServiceTest(JUnit TestCase)

MockEmployeeDAOImpl


Testen en MockObjectspublic class TestEmployeeDao extends AbstractDependencyInjectionSpringContextTests{ private EmployeeDao employeeDAO;

public void setEmployeeDAO(EmployeeDao employeeDAO) { this.employeeDAO = employeeDAO; }

protected String[] getConfigLocations() { return new String[] {"nl/amis/demo/dao/jdbc/applicationContext-jdbc.xml"}; }

public void testFindEmployeeById () { Employee emp = employeeDAO.getEmployeeById(7839); assertEquals("KING", emp.getName()); assertEquals("PRESIDENT", emp.getJob()); // ... }}

<bean id="employee7839" class="nl.amis.demo.domain.Employee">

<property name="name" value="KING" /> <property name="employeeNumber" value="7839" /> <property name="job" value="PRESIDENT" /></bean>

<bean id="employeeMockDAO" class="nl.amis.demo.dao.EmployeeMockDao">

<property name="emp"> <ref local="employee7839" /> </property></bean>


Spring JDBC and Spring DAO

Properly implementing those Mock DAO objects


Doelen van Spring JDBC

Database acties SQL (Select en Manipulatie) Procedural (stored procedure calls)

Flexibel Externe configuratie van data source Geen Checked Exceptions Out of container testen Database onafhankelijk

Gecontroleerd Exception handling Connection leaking/connection pooling

Productief Geen herhaling van code (tcftc) Vereenvoudigen van Transaction Management


Architectuur

Service

DAO

DomainObject

DomainObject

DomainObject

JNDI


Exampleimport java.sql.*;import javax.sql.*;public class EmpDao { public List getAllEmployees() { Connection con = null; PreparedStatement pstmt = null; ResultSet rs = null; List emps = new ArrayList(); try { con = getConnection(); pstmt = con.prepareStatement ("select * from emp"); rs = pstmt.executeQuery(); while (rs.next()) { Employee e = new Employee(); e.setId (rs.getLong(1)); e.setName (rs.getString(2)); // ... emps.add(e); } } catch (SQLException e) { // handle exception } finally { try { rs.close(); pstmt.close(); con.close(); } catch (SQLException e1) { // no action needed } } return emps; }}

private Connection getConnection() throws SQLException{ try { Context ic = new InitialContext(); DataSource ds = (DataSource) ic.lookup ("java:comp/env/jdbc/myDatabase"); return ds.getConnection(); } catch (NamingException e) { // handle exception return null; }}

private Connection getConnection() throws SQLException{ try { DriverManager.registerDriver (new oracle.jdbc.driver.OracleDriver()); return DriverManager.getConnection ("jdbc:oracle:thin:@localhost:1521:orcl“ ,"scott", "tiger"); } catch (SQLException sqle) { // handle exception return null; }}


Template Pattern

Operation largely follows a standard algorithm At certain steps, specialization or customization is

required Several implementations

Abstract ‘hook’ methods that sub-class may override Parametrize behaviour and have invoker provide the

details• Such as the SQL Query

Spring JDBC Templates Implement all JDBC wiring Parametrize the query and the result-handling


Example of Spring JDBC Template

public interface empDao { public List getAllEmployees ();}

public class EmployeeJdbcDao extends JdbcDaoSupport implements EmpDao { public List getAllEmployees() { JdbcTemplate jt = getJdbcTemplate(); return jt.queryForList (“select * from emp”); }}

<bean id="dataSourceDBDirect" class="org.springframework.jdbc.datasource.DriverManagerDataSource" destroy-method="close"> <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" /> <property name="url" value="jdbc:oracle:thin:@localhost:1521:BAARSJES1" /> <property name="username" value="scott" /> <property name="password" value="tiger" /></bean>

<bean id="employeeDAO" class="nl.amis.demo.dao.jdbc.EmployeeJdbcDao" > <property name="dataSource"> <ref local="dataSourceDBDirect" /> </property></bean>


jdbc helper classes

JdbcTemplate query, queryForList, queryForInt, queryFor.. ArrayList (per row) of HashMaps (column name as

key) RowMapper PreparedStatementCreator/Callback MappingSQLQuery ...


How can Spring help?

Make life easier:

DAO Support JDBC, Hibernate, Toplink, iBatis, JDO,

javax.persistence (“EJB 3.0”) , ... Dependency Injection Jdbc helper classes Exception Handling MockObjects Transaction Management


Spring Architectuur

Service

DAO

DomainObject

DomainObject

DomainObject DAO

Interface

ApplicationContext-jdbc

XXDAOSupport

JdbcDaoSupportHibernateDaoSupportTopLinkDaoSupport...


Exception Handling

RuntimeException ipv checked SQLException DataAccessException

SQLException Translation DataIntegrityViolationException DataRetrievalFailureException CannotGetJdbcConnectionException ...


Spring and Web ApplicationsStruts and other Controller Frameworks

Struts support Auto-Load WebContext (== BeanFactory) in session Make Action Classes Spring aware and have them

reference the WebContext Proxy Action Classes

and Dependency Inject them• Register Actions

as Spring Beans

Similar support for WebWork Tapestry


Spring and Web ApplicationsJava Server Faces

Java Server Faces JSF has managed-beans

Very similar to Spring Beans Though no support for AOP And: do you want low level, persistency related

configuration details in the faces-config.xml JSF-Spring project offers a JSF variable resolver

It takes bean references in faces-config.xml and tries to resolve them in Spring context files


Spring and Web ApplicationsSpring MVC Controller Framework

Positioned to replace Struts Better, more intuitive, modern architecture Full benefits from IoC and AOP

Works with (these are all Spring Beans) Controllers – that process the request, update and prepare the

Model; they also return a result, a symbolic indication of the ModelView to proceed to

ViewResolvers – that decide which View to let render

ViewBeans – thatwrap View Componentssuch as JSP, Velocity Template, FreeMarker page


Spring MVC Controller FrameworkSupport for various View technologies

JSP – using the Spring tag-library (very small, primarily use JSTL)

FreeMarker Velocity Tiles File Download Excel – using Apache POI PDF – using iText XSL-T JasperReports


Spring RemoteSupport for distributed applications

Spring’s number one concept concerning remote, distributed objects (take from Martin Fowler): Do NOT distribute!!!

However, in certain circumstances you probably have to Cross organizational boundaries Rich Clients Remote process

accessing back-end server


Spring’s Remote Façade Philosphy

Remote access for example supporting remote clients over RMI or

publishing a WebService should be regarded as an alternative presentation

layer no different from an standard Browser oriented HTML

interface On well-defined middle tier service interfaces

that are blissfully unaware that they are exposed and consumed remotely

Remoting infrastructure – for example Data Transfer Objects – should be added on top of the well defined, OO, fully POJO based service


Spring support for “remoting”

Spring will Declaratively expose Service interfaces for remote

clients Declaratively expose remote Service interfaces for

local clients Support for these protocols:

RMI Caucho’s Hessian and Burlap Spring’s own HttpInvoker EJB SOAP (based on JAX-RPC, using AXIS or XFire)


Exposing Service to remote clients

ClientCode Proxy for Service(generated by BeanFactory)

Service Interface

Service Implementation

Spring Exporter


Spring Exporters

Declaratively set up in the configuration file Using a specific protocol Spring Service Exporter

defines an End Point where the Service can be invoked• typically linked to a port

translates incoming remote calls to local calls• unmarshalling parameter values• marshalling return values and exceptions

Spring Exporter often works with Spring Remote Client


Details from Server and Client side BeanConfiguration files

Server Side – HttpInvoker Protocol Exporter

Client Side – HttpInvoker Protocol proxy creator


Extra Features

JMX – proxy Spring Beans to register them as MBeans

JMS Email JNDI Scheduling (Quartz) Transaction Management


Spring and the Oracle Java Technology Stack

Spring DAO has TopLink support Since Spring 2005, contributed by Oracle

Spring based POJO business service can be registered with ADF Binding Framework Ideally we can have the registration mechanism honor the

ApplicationContext origin of the Service Object Question: how does ADF currently instantiate its Business

Services? Spring DAO for ADF BC seems pointless

ADF BC is already pretty much wrapped – the API is already fairly high level

The Configurations (bc4j.xcfg) provide a level of decoupling and dependency injection

Spring DAO focuses on POJO – ADF BC does not


Spring and the Oracle Java Technology Stack

Spring MVC on ADF BC Business Service could be done though a lot of the natural benefits are lost

UIX could be used with Spring MVC as View technology losing the Struts ADF LifeCyle management

Shortly ADF Faces can be used with Spring MVC as well Spring Remoting can be used to publish and consume

Somewhat overlapping with JDeveloper WebServices support Spring AOP could be applied to ADF BC objects

If we can find the right hook – does not seem easy!


Sub Projects and initiatives around Spring

Spring Security Spring IDE (for Eclipse) Spring Rich Client Spring Modules & Spring WebFlow Spring BeanDoc Spring .NET – by Rod Johnson et. al.

Focus on C# JSF-Spring XDoclet – Spring Bean Configuration generator Aurora MVC Framework More support for Persistency OO/R Frameworks

EJB 3.0…


Discussion

Ik lust eigenlijk nu ook wel een kop koffie…

Date post:	18-Feb-2016
Category:	Documents
Upload:	keagan
View:	40 times
Download:	0 times

Spring – Power to the POJO Introductie tot het Spring Framework

Documents