Open Source Enterprise Frameworks

Spring Spring Emerged as lightweight alternative to over-engineered

“J2EE”

Now suite of OSGi modules

"Transparent" dependency injection and transaction management

Ala carte services

HibernateHibernate

ORM ("Object Relational Mapping" for RDBMS to Object mapping)

Robust, best-in-class product

Sophisticated optimization and customization (with learning curve)

Reverse engineering of legacy databases

SiteMeshSiteMesh

Like Struts Tiles, but easier to configure

Open Symphony is no more.. “You will now be redirected...”:

High-Level View of Frameworks

Spring Spring • Key design principles/implementation techniques

totally "mainstream"

• Configuring/using Spring still is not simple – Grails manages this...

HibernateHibernate

• "Industrial strength"

• Should compare against commercial products like Oracle

• As subtle and complex as what it simplifies?-- Grails manages this...

SiteMeshSiteMesh

• Just infrastructure, transparently available to use

Where to DownloadSpring Spring

http://www.springsource.com/download/community

Projects:– SpringSpring Framework– SpringSpring Grails– SpringSpring Web Flow

HibernateHibernate

http://www.hibernate.org/downloads

SiteMeshSiteMesh

https://github.com/sitemesh/sitemesh2

Spring: "Strategic" considerations

• "The original" J2EE alternative• Enterprise apps need Lightweight Containers• Keeps on sprouting new modules (e.g., Batch, Web

Flow, LDAP...)• OSGI-enabled Spring may be the “new” WJB4 …• SpringSource seems to be doing just fine

– Groovy and Grails– SpringSourceToolsSuite– WaveMaker: “WYSIWYG Java studio” – vFabric tc Server: “Enterprise Tomcat server”– VMWare vFabric: “Develop virtual and cloud

applications faster using the Spring framework; deploy to runtime optimized for Spring

Spring: part of VMware (http://www.vmware.com/products/)

Spring: Key Design Approaches/Features

• POJOs rule! Even EJB3 is built around POJOs.• DI (Dependency Injection) instead of Service Locator

("Lookup")• "Convention, not configuration"• Mechanisms/conventions should not dominate coding

efforts• Java code annotations can replace external XML• Declarative services, like transactions• "Modular" functionality; as in real OSGi• Don't reinvent, provide adapters to reuse "best-of-breed"

available solutions• Enable pluggability at core subsystem level (for example,

view layer) as well as for add-on features like security• Support for testing throughout the development life cycle

is crucial

Spring 3.0 (NOT xml...)

• Supports specs Java SE 5 and above; Servlet 2.4 and above• Annotations not XML!

– Annotation-based components:

• @Value expressions, referring to dynamic #{…} expressions or static ${…} placeholders

– "Meta-Annotations":

• custom @MyService annotation for @Service, @Scope("request") and @Transactional(readOnly=true)

– Standardized dependency injection annotations:

• @inject, @Autowired, ...

– Declarative model validation based on constraint annotations

• @NotNull, @Min(1), ...

– Enhanced binding and annotation-driven formatting

• @DateTimeFormat, ...

Spring 3.0: SpEL, Portlets, OXM, etc.• Spring expression language (SpEL): like Unified EL ( JSTL

Expression Language)

• REST support

– URI variable extraction through @PathVariable parameters

– RestTemplate for Client-side REST support

• Portlet 2.0 support

– @ActionMapping, @RenderMapping, @ResourceMapping, @EventMapping, ...

• Object/XML Mapping (OXM)

– From Spring Web Services

– Support for JAXB 2, Castor, etc.

• Enhanced scheduling capabilities

– TaskScheduler and Trigger mechanisms

– @Async and @Scheduled annotations now. T

– Supports both native and server-managed thread pools

Spring3

Spring expression language (SpEL):

@Component

public class CountryAwareLogic {

...

@Autowired

public void setCountry(

@Value("#{systemProperties.country}") String country) {

this.country=country;

}

}

Spring3

Excellent support for REST by annotatiions

@RequestMapping(value = "/reward/{id}", method = GET)

public Reward show(@PathVariable("id") long id) {

return rewardsAdminService.findReward(id);

}

Support for "web conversations"

Should be more like what Seam offers

Incorporated current Spring Web Flow project which continue to add more extensions

Spring3 Changes

Mostly backwards-compatible with Spring2/Spring 2.5Deprecated (but still useable)

– "Legacy" MVC Controllers like SimpleFormController

– JUnit 3 Spring-customized test classesNew coding should use instead

– "Legacy" MVC Controllers like SimpleFormController

– JUnit 4 Spring-customized test classes

No single distribution package "spring.jar:"

– Modular jars were always an alternative

– Deploy using Maven2, Ivy, or OSGi (somewhat "bleeding edge")

What does Spring contribute to Grails?

Dependency Injection – (solving “wiring-at-startup”)

AOP (Aspect Oriented Programming) – for automating services

Spring MVC as Web framework

13

Simple example: Dependency Injection

(from http://martinfowler.com/articles/injection.html#InversionOfControl)

public interface MovieFinder { List findAll();}

class MovieLister { … public Movie[] moviesDirectedBy(String arg) { List allMovies = finder.findAll(); for (Iterator it = allMovies.iterator(); it.hasNext();) { Movie movie = (Movie) it.next(); if (!movie.getDirector().equals(arg)) it.remove(); } return (Movie[]) allMovies.toArray(new Movie[allMovies.size()]); } private MovieFinder finder; public MovieLister() { finder = new ColonDelimitedMovieFinder("movies1.txt"); …}

14

What is Dependency Injection?

"...For this new breed of containers the inversion is about how they lookup a plugin implementation. In my naive example the lister looked up the finder implementation by directly instantiating it. This stops the finder from being a plugin. The approach that these containers use is to ensure that any user of a plugin follows some convention that allows a separate assembler module to inject the implementation into the lister.

As a result I think we need a more specific name for this pattern. Inversion of Control is too generic a term, and thus people find it confusing. As a result with a lot of discussion with various IoC advocates we settled on the name Dependency Injection."

(from http://martinfowler.com/articles/injection.html#InversionOfControl)

15

References on Dependency Injection

"A beginners' guide to Dependency Injection": http://www.theserverside.com/tt/articles/article.tss?

l=IOCBeginners"DI: What's all the hype (Green Paper)" http://www.manning.com/prasanna/Comparison of IOC (Inversion of Control) containers: http://www.picocontainer.org/comparisons.html

Tutorials on Spring DI: http://learnspringframework.blogspot.com/2006/10/what-is-ioc.htmlhttp://edudev.hfoss.org/index.php/Spring_Framework_Part_I-The_Context

16

Other frameworks: Dependency Injection/Inversion of Control

Guice http://.code.google.com/p/google-guice

Picocontainer http://www.picocontainer.org/introduction.html code snippet showing use in web application: http://www.picocontainer.org/web-frameworks.html code snippet showing use from main: http://www.picocontainer.org/component-configuration.html

http://nanocontainer.codehaus.org/http://www.keelframework.org/index.shtmlhttp://hivemind.apache.org/

17

How does Grails leverage Spring for DI? (1)

NOT xml! Just regular Groovy script file that contains Spring DSL

… grails-app/conf/spring/resources.groovy example:import org.springframework.jmx.support.MBeanServerFactoryBeanimport org.springframework.jmx.export.MBeanExporterimport org.hibernate.jmx.StatisticsService

Beans = { ….

// Hibernate statistics collection. hibernateStats(StatisticsService) { statisticsEnabled = true sessionFactory = ref("sessionFactory") } ...

18

How does Grails leverage Spring for DI? (2)

… grails-app/conf/spring/resources.groovy example:

Beans = { …. (con.)

mbeanServer(MBeanServerFactoryBean) { locateExistingServerIfPossible = true }

exporter(MBeanExporter) { server = mbeanServer beans = ["org.hibernate:name=statistics":

hibernateStats] }}

(from Smith and Ledbrook, Grails inAction)

19

Comparing Spring xml vs. Grails for DI (1)

spring-app.xml:

<bean id=”somebean” class=”x.y.Ex”> scope=”prototype” autowire=”byType” init-method=”init” destroy-method=”finish” >

resources.groovy: somebean(x.y.Ex) { b → b.scope=”prototype” b.autowire=”byType” b.init-method=”init” b.destroy-method=”finish” }

20

Comparing Spring xml vs. Grails for DI (2)

spring-app.xml:

<bean id=”somelist” class=”x.y.List”> <property name=”items”> <list> <value>1</value> <value>2</value> <value>3</value> </list> </property></bean>

resources.groovy: somelist(x.y.List) { Items =[ 1, 2, 3 ]}

21

Comparing Spring xml vs. Grails for DI (3)

spring-app.xml:

<bean id=”beanWithStaticFactoryMethod” class=”x.y.ExSrF”>

factory-method=”create” />

<bean id=”beanWithFactoryMethod” class=”x.y.ExF”> factory-bean=”someFactory” factory-method=”create” />

resources.groovy:

beanWithStaticFactoryMethod(x.y.ExSrF) { b → b.factory-method=”create” }beanWithFactoryMethod(someFactory:”create” )

(from Smith and Ledbrook, Grails inAction)

22

Spring xml can still help in Grails for DI (1)

<?xml version="1.0" encoding="UTF-8"?><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.0.xsd">

<!-- more bean definitions go here... --><!-- Mail service --><bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">

<property name="host" value="smtp.mac.com"/><property name="port" value="587"/><property name="username" value="mikesalera"/><property name="password" value="**************************" /> ...

23

Spring xml can still help in Grails for DI (2)

...

<property name="javaMailProperties"><props><!-- Use SMTP-AUTH to authenticate to SMTP server -->

<prop key="mail.debug">false</prop><prop key="mail.smtp.auth">true</prop><!-- Use TLS to encrypt communication with SMTP server -->

<prop key="mail.smtp.starttls.enable">true</prop></props></property></bean></beans>

24

What is Aspect-Oriented Programming?

The "next buzzword" after "Objects" and "Components" and "SOA" and ...

A meta-framework for EJB- (or .NET-) like frameworks which provide infrastructure "services" to applications

"... clean modularization of crosscutting concerns, such as error checking and handling, synchronization, context-sensitive behavior, performance optimizations, monitoring and logging, debugging support, and multi-object protocols..." (from the AspectJ homepage)

25

What is Aspect-Oriented Programming?

Object Oriented Programming does NOT address "cross-cutting concerns"

• Concerns which "cut across" object boundaries

• Tend to be the responsbility of MANY classes,and must be handled the same way, in order to work correctly

• Need "separation of concerns" to modularize these aspects

Extrafunctional features should NOT be coded by applications programmers

• Extrafunctionality tends to be omnipresent; maintenance burden• Infrastructure should be supplied by infrastructure experts• Applications programmers should code domain functionality

How extrafunctionality gets"blended in" without hard-coding everywhere

• Declarative, not imperative, specification of extrafunctionality

– Think A + 5.2 = 100; not A = 100 - 5.2

– "Policy versus mechanism"

– Separated from code;

– Reconfigurable for different environments or even dynamically• Automated "weaving" at compile and/or run time

26

"History" of AOP for Java

• Original implementation in AspectJ only for fanatics

– AspectJ introduced a "preprocessor" which augmented the standard Java language

– After JDK 1.5 introduced annotations, AspectJ converted to use standard JDK annotations

• AspectWerkz emerged as the "lightweight" alternative; later merged into AspectJ

• JBoss-AOP is specific to JBOSS EJB3 application server• As AOP became more mainstream and numerous AOP

alternatives emerged, AOP Alliance created a standard

27

Spring Support for wider/other AOP

• Spring is compliant with the AOP Alliance interface for around advice using method interception

• "Injected AspectJ aspects"

– Spring can weave into an application's class files as they are being loaded into the Java virtual machine

– called Load-Time Weaving (LTW)

– see Spring Reference Doc. (Sec. 6.8.4 in Spring 2.5.5; Sec. 7.8 in Spring 3.0)

28

AOP: Basic Concepts

• Aspect: a crosscutting or extrafunctional concern (e.g., transaction management).

• Join point: a recognizable point during the execution of a program, such as the execution of a method or the handling of an exception.

• Advice: action taken by an aspect at a particular join point.• Pointcut: a set of join points; a language to describe matching join

points. • Target object: object being advised by one or more aspects. Also

referred to as the advised object.• AOP proxy: an object created by the AOP framework in order to

implement the aspect contracts (advise method executions and so on).

• Weaving: linking aspects with other application types or objects to create an advised object.

• Introduction: declaring additional methods or fields on behalf of a type.

29

AOP: Meter reading analogy (SIA 2 book)

• Aspect: meter reader's daily combination of what to do, where• Join point: which devices to read • Advice: recording the reading; re-marking the device• Pointcut: which premises to visit. • Introduction: ad hoc actions, based on phoning headquarters.

But it's hard to get these to work in the real-world analogy, since they are implementation mechanisms.

• Target object• AOP proxy• Weaving

30

AOP Architecture

• Low-level implementation layer

– Mechanisms to implement weaving on the target platform

– Environment-specific• Middle-level functionality layer

– Declarative specification or meaning, plus

– Mechanisms to implements these semantics

– Bound to a particular environment• Application-level development layer

– Language (UI/modeling tool?) to customize the specification

– Other tools such as type-checking, trace/visualization tools, debuggers...

31

AOP Concepts in Spring

• Aspect: POJOs; may implement Aspect interfaces or be annotated with @Aspect.

• Join point: intercepting method execution. • Advice: method; may have reflection-like signature; Spring

establishes a chain of interceptors around the join point.• Pointcut: AspectJ pointcut expression language by default;

alsoJdkRegexp and Default Pointcuts. • Target object: an object which is wrapped by a runtime proxy.• AOP proxy :JDK dynamic proxy or a CGLIB proxy, implemented

by Spring.• Weaving: performed at runtime during Spring container

intialization.• Introduction: for example, Spring can introduce the IsModified

interface to make a bean support a caching strategy.

32

Kinds of Spring Advice

• Before– org.springframework.aop.MethodBeforeAdvice

• After returning– org.springframework.aop.AfterReturningAdvice

• After throwing– org.springframework.aop.AfterReturningAdvice

• Around– org.aopalliance.intercept.MethodInterceptor

• Introduction– org.springframework.aop.IntroductionInterceptor

33

Spring AOP Options • "Classic" Spring AOP

(ProxyFactoryBean/AutoProxyCreator)– all versions of Spring

– can use table-like Java code, or code-like sections in Spring config

– "Spring AOP Support/Classic Spring proxy-based AOP"

• XML AOP (Auto Created Proxy)– Spring 2.x+ only

– No footprint in POJO's

– "Schema-based AOP Support/Pure POJO Aspects" • @AspectJ AOP (Auto Created Proxy)

– Spring 2.x+ only

– Advice, pointcuts are in Java annotations (includes needed)

– "@AspectJ Support/@AspectJ annotation-driven aspects"

34

"Classic" Proxy-based Spring AOP Mechanism

• During bean post processing phase of Spring setup, the ProxyFactory will create and hook in the Proxy

• Core functionality applies Advice (regular Java code) at Pointcuts (specified methods) through intercepting when the advised class implements an interface

• This works using the JDK Proxy mechanism, which intercepts interface methods)

• The bean needs to be a ProxyFactory which hooks up the the "Advice" to the "Advised"

• This can be done in code (which implies it can be done on-the-fly if desired) OR in Spring xml config

35

Implementation-Level Spring AOP Alternatives (1)

• Mechanism: "traditional" JDK Proxy versus CGLIB

proxies

• What is the difference?– CGLIB dynamically generates bytecode for new subclass

which overrides advised methods

– Only CGLIB-generated proxies can provide exact type match to proxied object

– CGLIB restrictions:• cannot override final methods

• must configure added CGLIB jar file

36

Implementation-Level Spring AOP Alternatives (2)

• Which is more efficient?

– JDK Proxy intercepts every method, whether or not code needs injected; CGLIB will only override methods that need code injection

– For CGLIB, constructor invoked twice: on both actual proxied object and an instance of generated subclass that implements the advice.

– Both potentially optimizable by HotSpot JVM• Which will Spring choose?

– JDK dynamic proxies are preferred if there's a choice

– Spring 2.0: JDK Proxy for target objects that implement at least one interface; otherwise CGLIB