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

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (8)

Destaque

Destaque (10)

Semelhante a Extending Spring for Custom Usage

Semelhante a Extending Spring for Custom Usage (20)

Mais de Joshua Long

Mais de Joshua Long (20)

Último

Último (20)

Extending Spring for Custom Usage