Transcript SpringOverview
Open Source Enterprise Frameworks
Spring
Emerged as lightweight alternative to over-engineered “J2EE” Now suite of OSGi modules "Transparent" dependency injection and transaction management Ala carte services
Hibernate
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
SiteMesh
Like Struts Tiles, but easier to configure
High-Level View of Frameworks
Spring
• Key design principles/implementation techniques totally "mainstream" • Configuring/using
Spring
this...
still is not simple –
Grails
manages
Hibernate
• "Industrial strength" • Should compare against commercial products like Oracle • As subtle and complex as what it simplifies?- this...
Grails
manages
SiteMesh
• Just infrastructure, transparently available to use
Where to Download
Spring
http://www.springsource.com/download/community Projects:
–
Spring
Framework
–
Spring
Grails
–
Spring
Web Flow
Hibernate
http://www.hibernate.org/downloads
SiteMesh
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 ${…} placeholders
dynamic #{…}
expressions or static – "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 Language)
Unified EL
( JSTL Expression
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.5
Deprecated
(but still useable) – "Legacy" MVC Controllers like SimpleFormController – JUnit 3 Spring-customized test classes New 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
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")
; …
13
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)
14
References on Dependency Injection
"
A beginners' guide to Dependency Injection": http://www.theserverside.com/tt/articles/article.tss?l=IOCBegi nners "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.html
http://edudev.hfoss.org/index.php/Spring_Framework_ Part_I-The_Context 15
Guice
Other frameworks: Dependency Injection/ Inversion of Control
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.shtml
http://hivemind.apache.org/
16
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.MBeanServerFactoryBean
import
org.springframework.jmx.export.MBeanExporter
import
org.hibernate.jmx.StatisticsService
Beans = { ….
} // Hibernate statistics collection.
hibernateStats(StatisticsService) { statisticsEnabled = true sessionFactory = ref("sessionFactory") ...
17
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)
18
Comparing Spring xml vs. Grails for DI
(1)
spring-app.xml
: ” > 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 ” spring-app.xml : ” > resources.groovy: } somelist (x.y.List) { Items =[ 1, 2, 3 ] spring-app.xml : ” > factory-method= ” create ” /> ” > factory-bean= ” someFactory ” factory-method= ” create ” /> resources.groovy: beanWithStaticFactoryMethod (x.y. ExSrF) b.factory-method= ” create ” { b → } beanWithFactoryMethod( someFactory: ” create ” ) ( from Smith and Ledbrook, Grails inAction) ...19
Comparing Spring xml vs. Grails for DI
(2)
20
Comparing Spring xml vs. Grails for DI
(3)
21
Spring xml can still help in Grails for DI
(1)
22
Spring xml can still help in Grails for DI
(2)