Java  EE vs Spring Framework
Upcoming SlideShare
Loading in...5
×
 

Java EE vs Spring Framework

on

  • 22,268 views

This session compares the Spring and Java EE stacks in terms of Web frameworks. It re-examines the motivations behind the Spring framework and explores the emergence of the Java EE programming model ...

This session compares the Spring and Java EE stacks in terms of Web frameworks. It re-examines the motivations behind the Spring framework and explores the emergence of the Java EE programming model to meet the challenges posed. The presentation provides insight into when Spring and/or Java EE is appropriate for a building Web applications and if they can coexist.

Statistics

Views

Total Views
22,268
Views on SlideShare
20,866
Embed Views
1,402

Actions

Likes
11
Downloads
536
Comments
0

41 Embeds 1,402

http://wasdynacache.blogspot.com 875
http://wasdynacache.blogspot.in 128
http://wasdynacache.blogspot.de 52
http://wasdynacache.blogspot.ca 52
http://wasdynacache.blogspot.co.uk 32
http://wasdynacache.blogspot.com.au 31
http://wasdynacache.blogspot.it 23
http://wasdynacache.blogspot.fr 22
http://wasdynacache.blogspot.com.br 20
http://wasdynacache.blogspot.com.es 19
http://wasdynacache.blogspot.be 14
http://wasdynacache.blogspot.nl 13
http://wasdynacache.blogspot.hk 11
http://wasdynacache.blogspot.se 9
http://wasdynacache.blogspot.mx 8
http://wasdynacache.blogspot.jp 7
http://wasdynacache.blogspot.co.at 7
http://wasdynacache.blogspot.sg 7
http://wasdynacache.blogspot.ru 7
http://wasdynacache.blogspot.tw 6
http://wasdynacache.blogspot.no 5
http://www.twylah.com 5
http://wasdynacache.blogspot.ie 4
http://wasdynacache.blogspot.sk 4
http://wasdynacache.blogspot.kr 4
http://wasdynacache.blogspot.fi 4
http://wasdynacache.blogspot.cz 3
http://wasdynacache.blogspot.ch 3
http://webcache.googleusercontent.com 3
http://wasdynacache.blogspot.com.ar 3
http://wasdynacache.blogspot.ro 3
http://wasdynacache.blogspot.co.il 3
http://wasdynacache.blogspot.ae 2
http://wasdynacache.blogspot.dk 2
http://www.blogger.com 2
http://wasdynacache.blogspot.gr 2
https://twitter.com 2
http://wasdynacache.blogspot.co.nz 2
http://wasdynacache.blogspot.pt 1
http://translate.googleusercontent.com 1
https://si0.twimg.com 1
More...

Accessibility

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment
  • http://www.ibm.com/developerworks/websphere/library/techarticles/0707_barcia/0707_barcia.htmlhttp://en.wikipedia.org/wiki/Java_EE_version_historyA brief history of J2EE / Java EEBefore J2EE (Mid 1990s)Many competing products, In-house frameworks, Fragmented server side market, real danger of vendor lock-in, expensive solutionsGlory days of J2EE (1999-2003)Release of J2EE 1.2, 1.3 & 1.4Specifying first and then implementingStandardization of server side java enterprise technologiesEnterprise Java gains a reputation of complexityDecline of J2EE (2004- 2008)Projects fail due to flaws in platformRise of open source – Spring Framework, Seam, AspectJ, HibernateMove towards lighter weight solutionsRise of Java EE (2007 - Present)Emphasis on user Component model not just a deployment platformDeveloper productivity & ease of use enhancements Extensibility and right sizingTraps that created complexityDesign by committeeEverything has to be standardizedTools can make complexity acceptableLack of openness to other platforms, sources of ideasLack of developer freedom to hack the platformIvory tower architectureEJB Programming model was the worst offenderNaïve ORM solution & Broken persistence modelIdea that all business objects should be distributedRigid API interfaces, Difficult to unit test, Needed IDE toolingGlutton for XML & boilerplateJSF 1.2 ShortcomingsNo integration with EJBsNo templating support (before 1.2) Transparent to HTTP RequestsDifficult to create custom componentsLacks conversation scope & advanced componentsWeak page oriented supportOverly complex lifecycleJSP & JSF inherent mismatchJava EE pioneers innovations in server-side JavaA widely deployed but much maligned platformSpring, along with Hibernate, brings POJO programming, IoC and testability to the mainstreamJava EE 5 adopts ideas, as well as annotations and convention-over-configurationHibernate standardized into JPA, Spring remains nonstandard but adopts Java EE features to a degreeJava EE 6 matures ideas in Java EE 5 in addition to pruning and profilesCDI, JSF 2, JPA 2, EJB 3.1, Servlet 3, JAX-RS major API changes
  • Context abuse HttpSessionSo many beans so little common groundAddresses long standing challenges with Java EE
  • http://blog.springsource.com/2011/02/11/spring-framework-3-1-m1-released/Bean definition profilesUnified property management through Spring's new Environment abstractionEnhancements to Java-based configuration with @Feature methodsExpanded MVC namespace support and a Java-based configuration equivalentStreaming support and new interception model for the RestTemplate APIComprehensive caching supportNew c: XML namespace for concise configuration of constructor injection
  • Applications developed against commonframework(s)– common programming model– common configuration model• Adapted onto target platform at runtime– using common service abstractions– thread pooling, service lookups, etc• Strict separation between applicationcomponent model and platform services– clear boundaries and separation of responsibilitieshttp://www.springsource.org/aboutThe most complete lightweight container, providing centralized, automated configuration and wiring of your application objects. The container is non-invasive, capable of assembling a complex system from a set of loosely-coupled components (POJOs) in a consistent and transparent fashion. The container brings agility and leverage, and improves application testability and scalability by allowing software components to be first developed and tested in isolation, then scaled up for deployment in any environment (J2SE or J2EE). A common abstraction layer for transaction management, allowing for pluggable transaction managers, and making it easy to demarcate transactions without dealing with low-level issues. Generic strategies for JTA and a single JDBC DataSource are included. In contrast to plain JTA or EJB CMT, Spring's transaction support is not tied to J2EE environments. A JDBC abstraction layer that offers a meaningful exception hierarchy (no more pulling vendor codes out of SQLException), simplifies error handling, and greatly reduces the amount of code you'll need to write. You'll never need to write another finally block to use JDBC again. The JDBC-oriented exceptions comply to Spring's generic DAO exception hierarchy. Integration with Toplink, Hibernate, JDO, and iBATIS SQL Maps: in terms of resource holders, DAO implementation support, and transaction strategies. First-class Hibernate support with lots of IoC convenience features, addressing many typical Hibernate integration issues. All of these comply to Spring's generic transaction and DAO exception hierarchies. AOP functionality, fully integrated into Spring configuration management. You can AOP-enable any object managed by Spring, adding aspects such as declarative transaction management. With Spring, you can have declarative transaction management without EJB... even without JTA, if you're using a single database in Tomcat or another web container without JTA support. A flexible MVC web application framework, built on core Spring functionality. This framework is highly configurable via strategy interfaces, and accommodates multiple view technologies like JSP, Velocity, Tiles, iText, and POI. Note that a Spring middle tier can easily be combined with a web tier based on any other web MVC framework, like Struts, WebWork, or Tapestry.
  • Both are competent middleware stacks with mostly equivalent functionality but very different approachesJava EE provides a well-integrated solution stack that makes sensible default choices for you and minimizes the amount of configuration requiredSpring is a pluggable framework with explicit configuration, fine grained control and wide-variety of integration with overlapping technologiesJava EE is an open standard, while Spring is an open source tool from a commercial vendorCDI and 3rd party Extensions have provided a standard compliant way to hack the Java EE platformSpring framework weakens integration with application server runtime QoS, such as security, workload management, and high availabilitySeveral implementations of Java EE specifications are available whereas Spring has only ONE implementationPace of innovation is faster in the Spring Framework since Spring is Community driven vs Java EE that is driven by the JCP
  • MyFaces CODI is your best friend for CDI based projects.The Apache MyFaces Extensions CDI project (aka CODI) hosts portable extensions for Contexts and Dependency Injection (CDI - JSR 299) for the Java-Platform (SE and EE). CODI is a toolbox for your CDI application (it provides advanced and convenient features e.g. for JSF and Bean-Validation). Like CDI itself CODI is focused on type-safety. It is a modularized and extensible framework. So it's easy to choose the needed parts to facilitate the daily work in your project.The main focus is to provide superior tools which will support you on solving your daily needs of software development with CDI, JSF, BV and JPA. However, you will also find modules which are independent of JSF as well as modules which improve the compatibility with other MyFaces frameworks like MyFacesExtVal. Maybe the most important feature of MyFaces CODI is that it allows you to build a concise and efficient application-architecture.

Java  EE vs Spring Framework Java EE vs Spring Framework Presentation Transcript

  • Java EE and Spring Framework Shootout
    Rohit Kelapure IBM Advisory Software Engineer, http://wasdynacache.blogspot.com/
    Reza RahmanIndependent Consultant, Author, Java EE Expert http://www.rahmannet.net/
    Presentation can be downloaded from http://db.tt/1q9us2JH
  • Important Disclaimers
    THE INFORMATION CONTAINED IN THIS PRESENTATION IS PROVIDED FOR INFORMATIONAL PURPOSES ONLY.
    WHILST EFFORTS WERE MADE TO VERIFY THE COMPLETENESS AND ACCURACY OF THE INFORMATION CONTAINED IN THIS PRESENTATION, IT IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED.
    ALL PERFORMANCE DATA INCLUDED IN THIS PRESENTATION HAVE BEEN GATHERED IN A CONTROLLED ENVIRONMENT. YOUR OWN TEST RESULTS MAY VARY BASED ON HARDWARE, SOFTWARE OR INFRASTRUCTURE DIFFERENCES.
    ALL DATA INCLUDED IN THIS PRESENTATION ARE MEANT TO BE USED ONLY AS A GUIDE.
    IN ADDITION, THE INFORMATION CONTAINED IN THIS PRESENTATION IS BASED ON IBM’S CURRENT PRODUCT PLANS AND STRATEGY, WHICH ARE SUBJECT TO CHANGE BY IBM, WITHOUT NOTICE.
    IBM AND ITS AFFILIATED COMPANIES SHALL NOT BE RESPONSIBLE FOR ANY DAMAGES ARISING OUT OF THE USE OF, OR OTHERWISE RELATED TO, THIS PRESENTATION OR ANY OTHER DOCUMENTATION.
    NOTHING CONTAINED IN THIS PRESENTATION IS INTENDED TO, OR SHALL HAVE THE EFFECT OF:
    - CREATING ANY WARRANT OR REPRESENTATION FROM IBM, ITS AFFILIATED COMPANIES OR ITS OR THEIR SUPPLIERS AND/OR LICENSORS
    2
  • Copyright and Trademarks
    © IBM Corporation 2011. All Rights Reserved.
    IBM, the IBM logo, and ibm.com are trademarks or registered trademarks of International Business Machines Corp., and registered in many jurisdictions worldwide.
    Other product and service names might be trademarks of IBM or other companies.
    A current list of IBM trademarks is available on the Web – see the IBM “Copyright and trademark information” page at URL: www.ibm.com/legal/copytrade.shtml
    3
  • Outline
    Evolution of Java EE and Spring
    Java EE 6 & Spring 3.0, 3.1 highlights
    Spring 3.1 feature comparison with Java EE 6
    CDI and Spring ecosystem
    Spring and Java EE coexistence
    Conclusion
    4
  • J2EE Java EE Specifications
    * Introduced in spec.
  • Evolution of J2EEJava EE6 (Dec 09)
    New specs (JAX-RS, CDI, Bean Validation)
    Prune dead wood
    EJB 2.x, JAX-RPC, JAXR, JEE App. Deploy, JEE App mgmt.
    Extensibility
    Easy Framework Pluggability (web fragments & CDI Extensions)
    Enhanced ease of development
    POJO annotation based Servlets,
    Asynchronous processing (Servlet 3.0 & EJB 3.1)
    EJB 3.1
    EJB-in-WAR, No-interface view, Singleton, EJB-lite, Timers
    Contextual Dependency Injection (CDI)
    RESTful services
    Portable JNDI names
    JSF2.0
    Facelets, built-in-AJAX, Skins, Annotations, Resource handling
    Simplified Navigation, Easier custom components, View & Page scopes
    Bookmarkable pages, Project Stage, Expanded event model
    JPA 2.0
    Mapping enhancements, JPAQL, Criteria Query API, Pessimistic locking
    Profiles reduce platform size
    Web Profile 12 specs
    Vendor support
    WebSphere AS 8
    JBOSS AS 7
    Oracle WebLogic 11g
    Glassfish 3
    6
  • JSR 299 Contexts and Dependency Injection (CDI)
    • Adds dependency injection to JEE and makes it type-safe.
    • Hollywood principle - Don’t call us, we will call you
    • No hard coded dependencies on other specifications
    Assists in unifying the Bean model
    Well defined contexts, the ability to bind beans statefully to them & manage their lifecycle.
    Introduces an event notification system to decouple producers & consumers
    Uses interceptors to foster loose coupling
    Extend behavior with type safe interceptor bindings
    Refines interceptors into decorators for finer grained control
    Integrates with the Unified EL to bridge JSF
    Enables use of EJB 3.0 components as JSF managed beans
    Introduces an SPI to extend JEE – Roll your own JEE7!
    Not only an API but also a SPI
    Rich ecosystem of CDI extensions
    Adds the Web conversation context
    Spring does NOT provide support for CDI
    7
  • Evolution of Spring [ 1.0, 2.0, 2.5, 3.0, 3.1]
    8
  • Spring Framework
    9
    Lightweight dependency injection
    Aspect oriented
    Layered application & container framework
    Well defined modules on top of the core container
    NOT an all-or-nothing solution
  • Birds Eye View
    10
  • Java EE vs. Spring Framework Features/APIs Overview
    11
  • Java EE vs. Spring Business Component
    12
  • Spring XML for Business Component Injection
    13
  • Spring XML for Business Component Injection
    14
  • Spring Java Based Configuration
    15
  • Spring Java Based Configuration
    16
  • Java EE Interceptor vs. Spring Aspects
    17
  • Java EE vs. Spring Injection
    18
  • Java EE vs. Spring Injection – Spring configuration
    19
  • Facelet Component
    20
    JSF 2 vs. Spring MVC Front Controller
  • 21
    JSF 2 vs. Spring MVC Front Controller
    Facelet
  • 22
    JSF 2 vs. Spring MVC Front Controller
    Entity
    JSF Event Handler
  • JSF 2 vs. Spring MVC
    23
    Spring MVC JSP
  • Spring MVC Configuration
    24
  • Spring Controller
    25
  • Spring MVC web.xml configuration
    26
  • Java EE vs. Spring Scheduling
    27
  • Java EE vs. Spring Scheduling
    28
  • Java EE vs. Spring Messaging
    29
  • Spring JMS Configuration
    30
  • Spring Message Producer
    31
  • Java EE Message Producer & JMS Abstraction
    32
  • Java EE Message Producer & JMS Abstraction
    33
  • Hacking the Java EE Platform - CDI Extensions
    Activated by dropping jars on the application classpath
    Loaded by the java.util.ServiceLoader SPI
    Integrate with container through container lifecycle events by
    Register additional beans, interceptors and decorators
    Injecting dependencies into its own objects
    Introduce custom scope with backing context
    Augment or override bean annotation-based metadata with other source
    Tools/utilities, extending Java EE, integration with Java EE APIs, integrating with non-standard APIs, making Java EE features available in non-Java EE
    34
  • Spring Ecosystem
    35
  • CDI Ecosystem Snapshot
    36
    Runtimes
    Implementations
    Portable Extensions
    Weld
    CanDI
    Tools
  • Spring & Java EE Coexistence
    Integration with Java EE APIs
    Spring beans can be injected into JSF Managed Beans
    Spring beans can be referenced in EL with no JSF Backing beans
    Spring JmsTemplate can be used on top of raw JMS API for convenience
    Spring Listeners similar to EJB MDBs especially JCA rather than JMS listeners
    Hibernate validator standardized as Bean Validation (JSR 303)
    Spring 3 supports excellent bi-directional integration with EJBs
    CDI and Spring Integration through the Spring Bridge to CDI
    Native support for Java EE
    Java EE5 and Java EE6 annotations supported by Spring
    Spring can use JPA / Hibernate natively
    Application server integration
    DataSourcescan use application server QoS like pooling, transactions, statement caching, debugging, monitoring and security
    37
  • Java EE coexistence with Spring
    38
  • Birds Eye View
    39
  • References
    Evolution of Java EE http://en.wikipedia.org/wiki/Java_EE_version_history
    Java EE 6 Tutorial http://download.oracle.com/javaee/6/tutorial/doc/
    Spring Docs http://static.springsource.org/spring/docs/3.1.x/spring-framework-reference/
    Spring Projects http://www.springsource.org/projects
    Miscellaneous CDI Extensions https://github.com/softwaremill/softwaremill-common
    Migrating Spring to Java EE
    https://github.com/paulbakker/migrating-spring-to-javaee
    http://ocpsoft.com/java/spring-to-java-ee-a-migration-guide-cdi-jsf-jpa-jta-ejb/
    CDI- Spring Bridge
    http://rick-hightower.blogspot.com/2011/04/cdi-and-spring-living-in-harmony.html
    http://niklasschlimm.blogspot.com/2011/08/jsr-299-cdi-interceptors-for-spring.html
    http://niklasschlimm.blogspot.com/2011/08/jsr-299-cdi-decorators-for-spring-beans.html
    Best practices integrating Spring with WebSphere Application Server
    http://www.ibm.com/developerworks/websphere/techjournal/0609_alcott/0609_alcott.htm
    What’s new in Spring 3.1 http://static.springsource.org/spring/docs/3.1.x/spring-framework-reference/htmlsingle/spring-framework-reference.html#new-in-3.1
    40
  • References continued
    SEAM 3 http://seamframework.org/Seam3
    CODI http://myfaces.apache.org/extensions/cdi/
    Weld http://seamframework.org/Weld
    CanDIhttp://www.caucho.com/resin/candi/
    OpenWebBeanshttp://openwebbeans.apache.org/owb/index.html
    41