extending spring for custom usage

• Josh Long, SpringSource, a division of VMware

1

Tailoring Spring for Custom Usage

Sunday, February 19, 12

@[email protected]

2

About Josh Long

this is important!

(Spring Developer Advocate)


mailto:[email protected]


Agenda

Explore the value of a framework Exploit some of the lesser known, but powerful, extension

hooks in the core Spring frameworkQA

3


Spring’s aim:

bring simplicity to java development

4

web tier &

RIAservice tier batch

processing

integration &

messaging

data access

/ NoSQL / Big Data

mobile

tc ServerTomcatJetty

lightweightCloudFoundry

VMForce Google App Engine

Amazon Web Services

the cloud: WebSphereJBoss ASWebLogic

(on legacy versions, too!)

traditional

The Spring framework


The Spring ApplicationContext

• Spring Manages the beans you tell it to manage– use annotations (JSR 250, JSR 330, native)– XML– Java configuration– component scanning

• You can of course use all of them! Mix ‘n match

• All configuration styles tell the ApplicationContext how to manage your beans

5


Spring, a walking tour

• Demos:– introduce the tool chain– how to “setup” Spring– basic dependency injection

• annotations (JSR 250, JSR 330, native)• xml• java configuration

6


Not confidential. Tell everyone. 7

Spring Integration rules!!


8

...what if it doesn’t do what I want?...but??!?


Not confidential. Tell everyone. 9

What is Spring Integration?FLEXIBLE

v


10


11

do NOT reinvent the Wheel!


The Open/Closed Principle

"software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification”

-Bob Martin

12


Working with Lots of Beans

• One way to selectively augment beans at the lower level:– BeanPostProcessor

• are regular beans and are run after the configured beans have been created, but before the context is finished setting up

– BeanFactoryPostProcessor• is run before any of the beans definitions are realized • comes before BPP

• A more natural alternative is Spring’s AOP support– built on top of AspectJ– provides a very convenient, powerful way to solve cross

cutting problems

13



• Demos:– Bean*PostProcessor– AspectJ

14


Life Cycles

• Life Cycles for different folks – “safe and consistent” - use the interfaces

• InitializingBean, DisposableBean• correspond to init-method and destroy-method attributes

– Simple and component-centric : use the annotations• @PostConstruct, @PreDestroy• correspond to init-method and destroy-method attributes

– More power: SmartLifecycle• gives you the ability to dynamically start and stop beans in a

certain order as well as to query whether the bean’s been started or not.

15


Scopes

• Spring beans have scopes– default: singleton– can be:

• prototype• HTTP session• HTTP request• HTTP application (servlet, basically)• “step” in Spring batch• thread-local • Spring Web Flow “flow” scoped• Spring Web Flow “conversation scoped”• Spring Web Flow “view” scoped (in JSF)• Activiti BPMN2 process-scoped

16


public interface Scope {

Object get(String name, ObjectFactory<?> objectFactory); Object remove(String name); void registerDestructionCallback(String name, Runnable callback); Object resolveContextualObject(String key);

String getConversationId();}

Scopes– Implement o.s.beans.factory.config.Scope– register the scope with a o.s.beans.factory.config.CustomScopeConfigurer

17


map-like lookup of beans in a given scope





17



well known beans like the HttpServletRequest ‘request’ for ‘request’ scope





17


null, or storage specific ‘conversation’ ID


well known beans like the HttpServletRequest ‘request’ for ‘request’ scope





17



• Demos:– life cycle callbacks– scopes

• using• creating your own

18


Getting Beans from Strange Places

• FactoryBeans• Spring Expression Language

– convenient way to get at values and inject them• Spring environment specific beans (profiles)

– introduced in Spring 3.1– make it easy to conditionally define an object based on

some sort of runtime condition

19



• FactoryBeans– interface that’s used to provide a reusable definition of how

to create a complicated object with many dependencies– Related: Java configuration, and builders

• prefer both over FactoryBeans where possible

20



• Spring Expression Language– convenient way to get at values and inject them– Andy Clement’s a genius – like the Unified JSF EL, on steroids – Can be used in Java, XML

• @Value(“#{ ... }”) or value = “#{ .. }”

21



• Spring profiles• @Profile(“production”) @Configuration ... • <beans profile = ‘production’> ... </beans>

– Use System properties or simply specify the active profile on the environment

– Use ApplicationContextInitializer in web applications

22



• An ApplicationContextInitializer

23

public interface ApplicationContextInitializer <C extends ConfigurableApplicationContext> {

void initialize(C applicationContext);}



• Demos:– FactoryBeans– SpEL– Profiles

• ApplicationContextInitializers

24


Using Spring’s Resources

• Spring supports out of the box ClassPathResource, FileResource system, etc.

• Writing your own Resource implementations

25

public interface Resource extends InputStreamSource { boolean exists(); boolean isReadable(); boolean isOpen(); URL getURL() throws IOException; URI getURI() throws IOException; File getFile() throws IOException; long contentLength() throws IOException; long lastModified() throws IOException; Resource createRelative(String relativePath) throws IOException; String getFilename(); String getDescription();}


Object to XML Marshallers

• Easy to add your own Marshaller (and Unmarshaller)

26

public interface Marshaller {

boolean supports(Class<?> clazz); void marshal(Object graph, Result result) throws IOException, XmlMappingException;}


Object to XML Marshallers

• Demos:– a custom object-to-XML marshaller

27


REST

• Spring MVC for the server

28

@RequestMapping( value = “/crm/customers/{id}” , method =HttpMethod.GET)public @ResponseBody Customer lookupCustomerById( @PathVariable(“id”) long customerId ) { ... return customer; }


REST

• RestTemplate for the client (Android, SE, web applications, etc.)

29

RestTemplate rt = new RestTemplate() ;

String url = “http://mysvc.cloudfoundry.com/crm/customer/{id}”;

Customer customer = rt.getForObject( url, Customer.class, 22);


http://mysvc.cloudfoundry.com

http://mysvc.cloudfoundry.com

REST

• Both need o.s.http.converter.HttpMessageConverters• Spring supports:

– object-to-XML (JAXB as well as any Spring OXM impl)– object-to-JSON– binary data (o.s.resource.Resource references or byte[])– ATOM/RSS– images

• Easy to add your own

30


Registering a custom HttpMessageConverter

31

@EnableWebMvcpublic class WebConfiguration extends WebMvcConfigurerAdapter {

@Override public void configureMessageConverters( List<HttpMessageConverter<?>> converters) {

}

}


REST

• Demos:– Writing and using a customer HttpMessageConverter

32


Transactions

• Spring supports declarative transaction management– @EnableTransactionManagement or

<tx:annotation-driven/>

• PlatformTransactionManager implementations used to manage transactions– lots of options out of the box:

• AMQP, JMS, JTA, JDBC, JDO, JPA, WebLogic-specific, WebSphere-specific, OC4J-specific, etc.

33


Transactions

• PlatformTransactionManager abstracts the notion of a transactional “unit of work.”

34

public interface PlatformTransactionManager { TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException; void commit(TransactionStatus status) throws TransactionException; void rollback(TransactionStatus status) throws TransactionException;}


Caching

• CacheManager’s maintain Caches.– CacheManagers are like ‘connections’– Caches are like regions of a cache

35

public interface CacheManager { Cache getCache(String name); Collection<String> getCacheNames();}

public interface Cache {

interface ValueWrapper { Object get(); }

String getName(); Object getNativeCache(); ValueWrapper get(Object key); void put(Object key, Object value); void evict(Object key); void clear();}


Writing a custom View and View Resolver

36



• Easy to add your own View – supported views out of the box: FreeMarker, Velocity,

Excel, PDFs, JasperReports, XSLT, Jackson, JSTL, etc. – Lots of contributions from the open source community:

• Thymeleaf http://www.thymeleaf.org/

• Mustache by Sean Scanlon https://github.com/sps/mustache-spring-view

37


http://www.thymeleaf.org

http://www.thymeleaf.org

https://github.com/sps/mustache-spring-view

https://github.com/sps/mustache-spring-view


38

public interface ViewResolver { View resolveViewName(String viewName, Locale locale) throws Exception;}



39

public interface View {

String RESPONSE_STATUS_ATTRIBUTE = View.class.getName() + ".responseStatus"; String getContentType(); void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception;

}


if ‘detectAllViewResolvers’ is true, all ViewResolvers types will be registered.


40

@Beanpublic ViewResolver myCustomViewResolver(){ ... }

@Beanpublic MyCustomViewResolver viewResolver(){ ... }


if ‘detectAllViewResolvers’ is true, all ViewResolvers types will be registered.

if ‘detectAllViewResolvers’ is false, it’ll lookup a bean by a well known name


40

@Beanpublic ViewResolver myCustomViewResolver(){ ... }

@Beanpublic MyCustomViewResolver viewResolver(){ ... }



• Demo: writing a custom view/view resolver

41


Writing Adapters in Spring Integration

42



• MessageSource for inbound adapters• MessageHandler for outbound adapters

43

MessageHandlerMessageSource



44

package org.springframework.integration.core;

public interface MessageSource<T> { org.springframework.integration.Message<T> receive();}

<int:channel id = “in” />

<int:inbound-channel-adapter channel = “in” ref = “myCustomMessageSource” > <int:cron-trigger ... /></int:inbound-channel-adapter>

• Inbound channel adapter “receives” message from external system inward relative to Spring Integration code



45

<int:channel id = “out” />

<int:outbound-channel-adapter channel = “out” ref = “myCustomMessageHandler” />

package org.springframework.integration.core;

public interface MessageHandler { void handleMessage( org.springframework.integration.Message<?> message) throws org.springframework.integration.MessagingException;

}

• Outbound channel adapter “publishes” message from Spring Integration outward relative to Spring Integration code


Spring Integration File System Adapters

• Spring Integration provides rich file system adapters– FTP, SFTP, FTPS, files in general – But... what about SMB/CIFS?

46


Writing Readers and Writers in Spring Batch

• ItemReader for inbound adapters• ItemWriters for outbound adapters

47


Summary / Questions

• code: git.springsource.org:spring-samples/spring-samples.git

• blog.springsource.org • [email protected] • springsource.com/developer/sts

48






extending spring for custom usage

Technology

scopes spring beans

known beans

lookupof beans

lookup of beans

regular beans

beans denitions

tailoring spring

congured beans havebeen