Extending Spring for Custom Usage

Tailoring Spring for Custom Usage

• Josh Long, SpringSource, a division of VMware

1

Sunday, February 19, 12

About Josh Long (Spring Developer Advocate)

@starbuxman
josh.long@springsource.com

th
s i
is
im
po
rta
nt
!
2


Agenda

Explore the value of a framework
Exploit some of the lesser known, but powerful, extension
hooks in the core Spring framework
QA

3


Spring’s aim:
bring simplicity to java development
data
web tier integration
batch access
& service tier & mobile
processing / NoSQL /
RIA messaging
Big Data

The Spring framework
the cloud: lightweight traditional
CloudFoundry WebSphere
tc Server
VMForce JBoss AS
Tomcat
Google App Engine WebLogic
Jetty
Amazon Web Services (on legacy versions, too!)

4


The Spring ApplicationContext

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

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

• All conﬁguration 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 conﬁguration

6


Spring Integration rules!!

Not confidential. Tell everyone. 7


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

8


What is Spring Integration?
FLEXIBLE

v

Not confidential. Tell everyone. 9


do NOT reinvent
the Wheel!

11


The Open/Closed Principle

"software entities (classes, modules, functions, etc.) should
be open for extension, but closed for modiﬁcation”
-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 “ﬂow” scoped
• Spring Web Flow “conversation scoped”
• Spring Web Flow “view” scoped (in JSF)
• Activiti BPMN2 process-scoped

16


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

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();
}

17


Scopes


Object get(String name, ObjectFactory<?> objectFactory); map-like lookup
of beans in a
Object remove(String name); given scope


Object resolveContextualObject(String key);

String getConversationId();
}

17


Scopes


of beans in a


Object resolveContextualObject(String key); well known beans like the
HttpServletRequest ‘request’ for
String getConversationId(); ‘request’ scope
}

17


Scopes


of beans in a


Object resolveContextualObject(String key); well known beans like the
HttpServletRequest ‘request’ for
String getConversationId(); ‘request’ scope
}
null, or storage specific
‘conversation’ ID

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 deﬁnition of how
to create a complicated object with many dependencies
– Related: Java conﬁguration, 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 Uniﬁed 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

public interface ApplicationContextInitializer
<C extends ConﬁgurableApplicationContext> {

void initialize(C applicationContext);
}

23



• Demos:
– FactoryBeans
– SpEL
– Proﬁles
• ApplicationContextInitializers

24


Using Spring’s Resources

• Spring supports out of the box ClassPathResource,
FileResource system, etc.
• Writing your own Resource implementations
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 lastModiﬁed() throws IOException;
Resource createRelative(String relativePath) throws IOException;
String getFilename();
String getDescription();
}

25


Object to XML Marshallers

• Easy to add your own Marshaller (and Unmarshaller)

public interface Marshaller {

boolean supports(Class<?> clazz);

void marshal(Object graph, Result result)
throws IOException, XmlMappingException;
}

26


Object to XML Marshallers

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

27


REST

• Spring MVC for the server

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

...
return customer;
}

28


REST

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

RestTemplate rt = new RestTemplate() ;

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

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

29


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

@EnableWebMvc
public class WebConfiguration extends WebMvcConfigurerAdapter {

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

}

}

31


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.”

public interface PlatformTransactionManager {

TransactionStatus getTransaction(TransactionDeﬁnition deﬁnition)
throws TransactionException;

void commit(TransactionStatus status) throws TransactionException;

void rollback(TransactionStatus status) throws TransactionException;
}

34


Caching

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

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

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

35


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



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

38



public interface View {

String RESPONSE_STATUS_ATTRIBUTE =
View.class.getName() + ".responseStatus";

String getContentType();

void render(Map<String, ?> model,
HttpServletRequest request,
HttpServletResponse response) throws Exception;

}

39



@Bean
public ViewResolver myCustomViewResolver(){
...
} if ‘detectAllViewResolvers’ is
true, all ViewResolvers types
will be registered.

@Bean
public MyCustomViewResolver viewResolver()
{
...
}

40



@Bean
public ViewResolver myCustomViewResolver(){
...
} if ‘detectAllViewResolvers’ is
true, all ViewResolvers types
will be registered.

@Bean
public MyCustomViewResolver viewResolver()
{
... if ‘detectAllViewResolvers’ is
false, it’ll lookup a bean by a
} well known name

40



• Demo: writing a custom view/view resolver

41


Writing Adapters in Spring Integration

42



• MessageSource for inbound adapters
• MessageHandler for outbound adapters

MessageSource MessageHandler

43



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

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>

44



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

package org.springframework.integration.core;

public interface MessageHandler {

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

}

<int:channel id = “out” />

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

45


Spring Integration File System Adapters

• Spring Integration provides rich ﬁle system adapters
– FTP, SFTP, FTPS, ﬁles 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
• josh.long@springsource.com
• springsource.com/developer/sts

48


Extending Spring for Custom Usage

Recommended

Recommended

More Related Content

What's hot

What's hot (8)

Viewers also liked

Viewers also liked (10)

Similar to Extending Spring for Custom Usage

Similar to Extending Spring for Custom Usage (20)

More from Joshua Long

More from Joshua Long (20)

Recently uploaded

Recently uploaded (20)

Extending Spring for Custom Usage