tss spring for advanced -...

Spring Update:Implications for the Advanced Developer

Copyright 2008 SpringSource. Copying, publishing or distributing without express written permission is prohibited.

Advanced Developer

Rod Johnson

Founder, SpringCEO, SpringSource

Agenda

• Quick Review: Spring 2.5

• Spring 3.0 Themes and Features

• Spring 3.0 Roadmap

Copyright 2008 SpringSource. Copying, publishing or distributing without express written permission is prohibited. 2

• Special emphasis:

• What does this mean for best practice for advanced developers?

Spring Framework 2.5

• Comprehensive support forannotation-based configuration

– @Autowired (+ @Qualifier or custom qualifiers)

– @Transactional

– @Component, @Service, @Repository, @Controller


– @Component, @Service, @Repository, @Controller

• Common Java EE 5 annotations supported

– @PostConstruct, @PreDestroy

– @PersistenceContext, @PersistenceUnit

– @Resource, @EJB, @WebServiceRef

– @TransactionAttribute

Annotated Bean Component

@Servicepublic class RewardNetworkService

implements RewardNetwork {

@Autowiredpublic RewardNetworkService(AccountRepository ar) {


public RewardNetworkService(AccountRepository ar) {…}

@Transactionalpublic RewardConfirmation rewardAccountFor(Dining d) {…}}

Annotated DAO with Lifecycle

@Repository

public class JdbcAccountRepository

implements AccountRepository {

@Autowired

public JdbcAccountRepository(DataSource ds) { … }


public JdbcAccountRepository(DataSource ds) { … }

@PostConstruct

public initCache() { … }

@PreDestroy

public cleanupCache() { … }

}

Minimal XML Bean Definitions



• Spring no longer requires XML

• Need to use XML only when you need to externalize something


<context:annotation-config/>

<bean class=”com.myapp.rewards.RewardNetworkImpl”/>

<bean class=”com.myapp.rewards.JdbcAccountRepository”/>

Minimal XML Bootstrapping



<context:component-scan


<context:component-scanbase-package=”com.myapp.rewards”/>

Resolving Dependencies: @Autowired in Detail

• Injection at constructor/field/method level

• Supports multi argument methods

• Concise

• Default behavior is Spring’s traditional autowire by type


autowire by type

• Annotations make autowiring more useful

@Autowired

public void createTemplates(DataSource ds,

ConnectionFactory cf) {

this.jdbcTemplate = new JdbcTemplate(ds);

this.jmsTemplate = new JmsTemplate(cf);

}

@Qualifier Annotation

• Autowiring by type may have too many candidates

• Provide hints using qualifiers• @Qualifier annotation


• @Qualifier annotation

• Can be used on fields / parameters or on custom annotations

Resolution of dependencies by name

public class JdbcOrderRepositoryImpl

implements OrderRepository {

@Autowired

public void init(


public void init(

@Qualifier("myDS")

DataSource orderDataSource,

@Qualifier("otherDS")

DataSource inventoryDataSource,

MyHelper autowiredByType) {

// ...

}

Resolution of dependencies by annotation

public class JdbcOrderRepositoryImpl

implements OrderRepository {

@Autowired


@Autowired

public void setOrderServices(

@Emea OrderService emea,

@Apac OrderService apac) {

// ...

}

Association of injection target with annotation: By annotation

@Emea

public class EmeaOrderService

implements OrderService { @Qualifier

@Component

public @interface Emea {


...

}

@Apac

public class ApacOrderService

implements OrderService {

...

}


}

@Qualifier

@Component

public @interface Apac{

}

Association of injection target with annotation: XML

<bean class="example.EmeaOrderService"><qualifier type=“example.Emea“/><!–...

EmeaOrderService need not be annotated-->


--></bean>

<bean class="example.ApacOrderService"><qualifier type=“example.Apac“/>

</bean>

The @Component meta-annotation

• Meta-annotations

• Annotations can annotate other annotations

• Allow extensibility

• Similar to Java inheritance


• Spring stereotypes

• Concept introduced in Spring 2.0, but more stereotypes added later

• Identify classes with a particular purpose

• Help to build a strong semantic model of application

• Not Spring-specific

• Common identifiers for regular code

Spring stereotypeannotations

• @Service• Identifies a stateless service

• @Repository• Identifies a repository (DAO)

• @Aspect• @AspectJ aspect


• @AspectJ aspect

• @Controller• Spring MVC controller

• Can define your own…

• @Component• Meta-annotation

• Annotate your own annotation with @Component and your classes get picked up by scanning

@Qualifier

@Component


}

Component Scanning

• Scans the classpath for annotated classes

• Removes the need for XML definitions unless you want to need to do something you can’t do in annotations


@Service

public class DefaultAccountService { ...

<bean id="defaultAccountService"

class="DefaultAccountService"/>

Component Scan Usage

• Use Spring core context namespace

• Specify package(s) to pick up

• Can coexist with XML bean definitions and namespaces


and namespaces

<context:component-scan

base-package="com.mycompany.myapp"/>

More advanced component scanning usage

• Not limited to annotations

• Can use type or other checks

• Highly customizable, as you expect from Spring

• Can even work without using annotations<context:component-scan base-package="blog"


<context:component-scan base-package="blog"

use-default-filters="false">

<context:include-filter type="annotation"

expression="org.sf.stereotype.Component"/>

<context:include-filter type="regex"

expression="blog\.Stub.*"/>

<context:exclude-filter type="assignable"

expression="blog.JdbcMessageRepository"/>

</context:component-scan>

Component Scan Pros

• No need for XML unless you need the greater sophistication it allows

• Changes are picked up automatically

• Great during development


• Works great with Annotation Driven Injection

• picking up further dependencies with @Autowired

• Highly configurable

Component Scan Cons

• Not a 100% solution

• Can’t do everything with annotations

• Requires classes to be annotated

• Need to take care not to scan an


• Need to take care not to scan an excessive number of classes, using Spring’s filtering mechanism

• Don’t get the valuable application structure blueprints you get with XML configuration

Mix and Match

• All Spring metadata in the end

• Spring component model is independent of metadata

• One approach does not exclude


• One approach does not exclude others

• Can have multiple contributions to a single context

Best Practice Changes

• Emerging best practice

• Use XML for:

• Classes you can’t or won’t annotate, particularly third party components

• Data sources


• Message queues etc.

• Use annotations and classpath scanning for application objects

• Jump into XML for complex injection behavior, per-instance configuration

• Classes you’ll reuse in different ways

• See Spring Web Flow sample applications

• booking-mvc

What if I like XML?

• Externalizing configuration remains very important

• Options include XML, properties files

• Don’t worry if you are an annotation


• Don’t worry if you are an annotation skeptic

• We still love you!

• We aim to provide the best configuration solution whatever your preferences

How do I understand my application blueprint?

• XML blueprint has real value

• Container will merge contributions from different sources

• Spring IDE can help to visualize


• Spring IDE can help to visualize everything together

• Help to navigate model

Spring Servlet MVC 2.5

@Controllerpublic class BookController {

private final BookService bookService;

@Autowired

public MyController(BookService bookService) {


this.bookService = bookService;

}

// Responds to URL http://host/servlet/book/removeBook

@RequestMapping

public String removeBook(@RequestParam("book") String bookId) {this.bookService.deleteBook(bookId);

return "redirect:myBooks";

}

Best Practice Changes

• Do not use old Controller interface, SimpleFormController and friends

• Annotation model is simply superior

• Keeps everything good about Spring


• Keeps everything good about Spring MVC

• More concise

• Should be no need to use XML bean definitions for @Controllers

• Rely on annotation scanning

Test Context Framework

@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(“test-config.xml”) public class RewardSystemIntegrationTests {

@Autowired

• Escape JUnit 3 concrete inheritance hell


@Autowiredprivate RewardNetwork rewardNetwork;

@Test@Transactionalpublic void testRewardAccountForDining() {// test in transaction with auto-rollback

}}

Agenda

• Quick Review: Spring 2.5

• Spring 3.0 Themes and Features

• Spring 3.0 Roadmap

• Groovy and Grails


• Groovy and Grails

Spring 3.0 Themes

• Java 5+ foundation– compatible with J2EE 1.4 and Java EE 5

• Spring Expression Language– Unified EL++

• Comprehensive REST support– and other Spring @MVC additions


– and other Spring @MVC additions

• Support for Portlet 2.0– action/event/resource request mappings

• Declarative model validation– Hibernate Validator, JSR 303

• Early support for Java EE 6– JSF 2.0, JPA 2.0, etc

New Project Layout

• Framework modules revised

– now managed in Maven style

– one source tree per module jar

• spring-beans.jar, spring-aop.jar, etc

– no spring.jar anymore!


– no spring.jar anymore!

• Built with new Spring build system as known from Spring Web Flow 2.0

– consistent deployment procedure

– consistent dependency management

– consistent generation of OSGi manifests

A word on Build

• OSGi provides a rigorous solution for modularization

• We will provide a solution for both Ant and Maven that allows

• pom or Ivy-driven generation of OSGi bundle


• pom or Ivy-driven generation of OSGi bundle metadata

• Transitive dependency resolution driven by OSGimanifests

• Ideal for dm Server, but emerging as best way to handle dependencies in general

• Check out Rob Harrop’s recent blog

Powerful Spring EL Parser

• Custom expression parser implementationshipped as part of Spring 3.0

– package org.springframework.expression

– next-generation expression engine inspired bySpring Web Flow 2.0's expression support


Spring Web Flow 2.0's expression support

• Compatible with Unified EL but significantly more powerful

– navigating bean properties, maps, etc

– method invocations

– construction of value objects

EL in Bean Definitions

<bean class="mycompany.RewardsTestDatabase">

<property name="databaseName"value="“#{systemProperties.databaseName}”/>


<property name="keyGenerator"value="“#{strategyBean.databaseKeyGenerator}”/>

</bean>

EL in Component Annotations

@Repository

public class RewardsTestDatabase {

@Value(“#{systemProperties.favoriteColor}”)

private String favoriteColor;

• Makes annotation model much more powerful

• Minimizes need for recompilation



@Value(“#{systemProperties.databaseName}”)

public void setDatabaseName(String dbName) { … }

@Value(“#{strategyBean.databaseKeyGenerator}”)

public void setKeyGenerator(KeyGenerator kg) { … }

}

EL in Component Annotations (2)

@Repository

public class RewardsTestDatabase {

@Value(“#{systemProperties.favoriteColor}”)



@Autowired

public void init(@Value(“#{systemProperties.databaseName}”) String dbName,

@Value(“#{strategyBean.timeout}”

int timeout) { … }

}

EL Context Attributes

• Example showed access to EL attributes

– "systemProperties", "strategyBean"

• Implicit attributes exposed by default, depending on runtime context


depending on runtime context

– e.g. "systemProperties", "systemEnvironment"

• global platform context

– access to all Spring-defined beans by name

• similar to managed beans in JSF expressions

– extensible through Scope SPI

• e.g. for step scope in Spring Batch 2.0

Web Context Attributes

• Implicit web-specific attributes exposed by default as well

– "contextProperties": web.xml init-params

– "contextAttributes": ServletContext attributes

– "request": current Servlet/PortletRequest


– "request": current Servlet/PortletRequest

– "session": current Http/PortletSession

• Exposure of all implicit JSF objects when running within a JSF request context

– "param", "initParam", "facesContext", etc

– full compatibility with JSF managed bean facility

REST Support

• Spring MVC to provide first-class support for REST-style mappings– extraction of URI template parameters

– content negotiation in view resolver

• Goal: native REST support within Spring MVC, for UI as well as non-UI usage


• Goal: native REST support within Spring MVC, for UI as well as non-UI usage– in natural MVC style

• Alternative: using JAX-RS through integrated JAX-RS provider (e.g. Jersey) – using the JAX-RS component model to build programmatic resource endpoints

REST in MVC - @PathVariable

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

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

return this.rewardsAdminService.findReward(id);

http://rewarddining.com/rewards/show/12345


return this.rewardsAdminService.findReward(id);

}

Similar to @RequestParam, but from URL path

Different Representations

• JSON

• XML

GET http://rewarddining.com/accounts/1 accepts application/json

GET http://rewarddining.com/accounts/1.json


• XML

• ATOM

GET http://rewarddining.com/accounts/1 accepts application/xml

GET http://rewarddining.com/accounts/1.xml

GET http://rewarddining.com/accounts/1 accepts application/atom+xml

GET http://rewarddining.com/accounts/1.atom

@MVC Refinements

• More options for handler method parameters

– in addition to @RequestParam and @PathVariable

– @RequestHeader: access to request headers

– @CookieValue: HTTP cookie access

– supported for Servlet MVC and Portlet MVC


– supported for Servlet MVC and Portlet MVC

@RequestMapping("/show")

public Reward show(@RequestHeader("region") long regionId,@CookieValue("language") String langId) {

...

}

@MVC Extensibility

• Ability to register and handle custom annotations

@RequestMapping("/show")


public Reward show(@RequestHeader("region") long regionId,@CookieValue("language") String langId,

@MyMagicContextValue Magical m) {

...

}

Portlet 2.0 Support

• Portlet 2.0: major new capabilities

– explicit action name concept for dispatching

– resource requests for servlet-style serving

– events for inter-portlet communication

– portlet filters analogous to servlet filters


– portlet filters analogous to servlet filters

• Spring's Portlet MVC 3.0 to support explicit mapping annotations

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

– specializations of Spring's @RequestMapping

Spring Portlet MVC 3.0

@Controller@RequestMapping("EDIT")

public class MyPortletController {

…

@ActionMapping("delete")

public void removeBook(@RequestParam("book") String bookId) {


public void removeBook(@RequestParam("book") String bookId) {this.myService.deleteBook(bookId);

}

@EventMapping("BookUpdate")

public void updateBook(BookUpdateEvent bookUpdate) {

// extract book entity data from event payload objectthis.myService.updateBook(…);

}

}

Conversation Management

• Key problem: isolating concurrent windowsin same browser– shared HTTP session

– several independent conversations going on

• keeping independent state

• Generalized: conversation scope with shorter


• Generalized: conversation scope with shorter lifetime than session– scope="conversation"

• on-demand scoping of conversational Spring beans

• MyFaces Orchestra style

– Spring Web Flow 3 provides moresophisticated flow navigationmanagement on top

Scoped Bean Serializability

• Problem with Spring 2.5: serializability of session and conversation objects

– when referencing shared service objects via Spring dependency injection

– typical situation: scoped bean instance holds on to


– typical situation: scoped bean instance holds on to DataSource or the like

• DataSource reference is not serializable

• -> whole bean not serializable

• Solution: proxies that reobtain references on deserialization

– from current Spring WebApplicationContext

Model Validation

public class Reward {

@NotNull

@ShortDate

private Date transactionDate;

}


In view:

<form:input path="transactionDate">

• Same metadata can be used for persisting, rendering, etc

• Hibernate Validator annotations supported

• JSR 303 (Bean Validation) to be supported as well

Spring 3.0 and Java EE 6

• Early Java EE 6 support in Spring 3.0

– integration with JSF 2.0

• full compatibility as managed bean facility

– integration with JPA 2.0


• support for lock modes, query timeouts, etc

– integration with JAX-RS / Jersey

• using the JAX-RS component model to build programmatic resource endpoints

– JSR 236 WorkManager & TimerManager

• rich standardized access to thread pools

Third-Party Library Update

• Spring 2.5.x proactively tracks the latest versions of third-party libraries

– Hibernate 3.3, EclipseLink 1.0 final, etc

– compatible with J2EE 1.3 (e.g. Servlet 2.3, JSP 1.2)

• Spring 3.0 presents an opportunity to upgrade


• Spring 3.0 presents an opportunity to upgrade to the latest versions

– where it was impossible in the 2.5.x line

– e.g. JUnit 4.5, JRuby 1.1

– J2EE 1.4+ required (e.g. Servlet 2.4+, JSP 2.0+)

– even stronger Java 6 and Java EE 5 focus

Project Rearrangements

• Spring 3.0 will include a revised version of the Object/XML Mapping (OXM) module– known from Spring Web Services

– also useful e.g. for SQL XML access

• Spring 3.0 will also feature revised binding and type conversion infrastructure


• Spring 3.0 will also feature revised binding and type conversion infrastructure– including the capabilities of Spring Web Flow's binding

– stateless type converter objects with EL integration

• Spring 3.0 will include the core functionality of Spring JavaConfig– configuration classes defining managed beans

Spring Java Configuration

• Annotation-centric approach, but unique

• Annotations are in dedicated configuration classes, not application classes

• Preserves centralized configuration model of XML

• Indeed, stronger centralization than with XML


• Indeed, stronger centralization than with XML

• Allows objects to be created and wired in Java

• Research project since 2005

• Available in milestone form as a separate project since 2007

• Core functionality moves to Spring Framework in 3.0

@Configuration

• A configuration class is similar to a <beans/> document

• Specifies a configuration class that creates beans


creates beans

• Defines defaults for the current context

@Configuration(

defaultAutowire = Autowire.BY_TYPE,

defaultLazy = Lazy.TRUE)

@Bean

• Analogous to <bean>

• Indicates a bean creation method

• Supports standard bean attributes from BeanDefinition internal metadata


BeanDefinition internal metadata

• lazy

• scope

• depends-on

• …

@Bean

@Bean (scope = REQUEST)

public Page currentPage() { … }

@Bean (scope = SESSION,


@Bean (scope = SESSION,

destroyMethodName = “shutdown”);

public Preferences prefs() { … }

@Bean (lazy = Lazy.FALSE);

public Admin admin() { … }

Java Configuration Class Example

@Configuration

public abstract class JavaConfig {

@Autowired

private DataSource dataSource;

@Bean

public AccountDAO accountDAO() {

<bean name=“accountDAO”

class=“...JdbcAccountDao”>

Method creates a bean


// return new InMemoryAccountDAO();

JdbcAccountDAO dao = new JdbcAccountDAO();

dao.setDataSource(dataSource);

dao.init();

return dao;

}

@Bean

public AccountService accountService() {

DefaultAccountService service = new DefaultAccountService();

service.setAccountDAO(accountDAO());

return service;

}

<property name=“dataSource”

ref=“dataSource” />

</bean>

@Bean

public AccountDAO accountDAO() { ... }

...

service.setAccountDAO(accountDAO());

Bean-to-Bean Dependencies handled elegantly, with correct lifecycle semantics


service.setAccountDAO(

ctx.getBean(“accountDAO”));

• Easy, elegant way to reference external beans using Spring 2.5 annotation-driven injection

• Strongly typed

@Autowired

Referencing external beans


@Autowired

private DataSource dataSource;

public DataSource dataSource() {

return (DataSource) ctx.getBean(“dataSource”);

}

Java Configuration Benefits

• Pure Java

• Allows visibility control

• Allows use of inheritance in configurations

• Powerful object creation

• Ability to use arbitrary Java code


• Ability to use arbitrary Java code

• Good for configuring existing classes

• Refactoring friendly

• Strongly typed

• Preserves valuable application blueprint

• IDE support with Spring IDE

Likely impact of Java Configuration on best practice

• Provides the ability to provide abstract configurations

• Compiler can enforce definition of missing beans


• Great for third parties

• Great for arbitrary object creation in Java in complex scenarios

• Complements existing configuration options

Annotation configuration vs Spring Java Configuration

• Complementary

• Different philosophies

• Annotation driven injection adds metadata to container identifying components and


to container identifying components and injection methods

• Java Configuration is programmatic object creation on steroids, benefiting from all container features

• Essentially a Java DSL for bean creation

Pruning & Deprecation in 3.0

• Some pruning planned– Commons Attributes support

– traditional TopLink API support

• in favor of JPA (EclipseLink)

– subclass-style Struts 1.x support

• Some deprecation planned


• Some deprecation planned– traditional MVC controller class hierarchy

• superseded by annotated controller style

– traditional JUnit 3.8 test class hierarchy

• superseded by test context framework

– several outdated helper classes

Spring 2.5 Mission Continued

• Spring 3 continues Spring 2.5's mission

– fully embracing Java 5 in the core Spring programming and configuration model

– now with even the core framework requiring Java 5

• all framework classes using Java 5 language syntax


• all framework classes using Java 5 language syntax

• Backwards compatibility with Spring 2.5

– 100% compatibility of programming model

– 95% compatibility of extension points

– all previously deprecated API to be removed

• Make sure you're not using outdatedSpring 1.2 / 2.0 API anymore!

Spring 3.0 Summary

• Spring 3.0 embraces REST and EL

– full-scale REST support

– broad Unified EL++ support in the core

• Spring 3.0 significantly extends and refines annotated web controllers


annotated web controllers

– RESTful URI mappings

– annotation-based model validation

• Spring 3.0 remains backwards compatible with Spring 2.5 on Java 5+

– enabling a smooth migration path

Spring 3.0 Roadmap

• Spring Framework 3.0 M3 releasedat the end of March

• With Java Config features

• Spring Framework 3.0 RC1 scheduled for early May


early May

– after two further milestones

• Spring Framework 3.0 final expected in June

– depending on RC feedback

More capable, but simpler to use

• We remain very focused on simplifying applications

• Each version of Spring has made Spring


has made Spring applications Simpler

• Spring 3.0 continues this tradition

• Pet Clinic sample LOC stats, showing reduction due to Spring 2.0 and 2.5


Q&A

tss spring for advanced -...

Documents