Java EE 6 & Spring: A Lover's Quarrel
Download as PPT, PDF6 likes2,355 views
The document discusses Java EE 6 and the Spring Framework. It provides an overview of the evolution of both technologies and compares their features side-by-side. The document discusses how Java EE 6 and Spring can coexist and be integrated, with options ranging from pure Java EE 6 to pure Spring, with various hybrid approaches in between. It notes that there is no need to choose one over the other, as balanced competition is good, and the technologies integrate well.
Java EE 6 & Spring: A Lover's Quarrel
- 2. Java EE 6 & Spring: A Lover’s Quarrel Derrick Kittler Mauricio “Maltron” Leal Vamsi Chemitiganti
- 3. Agenda o The goal of this talk o Evolution of Spring o Evolution of Java EE 6 o Side-by-Side o Migrating o Java EE 6 and Spring Coexistence o Conclusion
- 5. Fair Comparison: NOT Specification Java EE 6 Technology Framework
- 6. Fair Comparison Java EE 6 Approach to a Enterprise Solution !!
- 7. If can’t beat them, join them !!!! Java EE 6 Sometimes, a join solution can be the best approach
- 8. Java EE 6 The goal of this talk is NOT… Compare both technologies and declare a winner
- 9. The goal of this talk is… • How to deliver a good enterprise application • Evaluate both technologies • Show some migration path (only when makes sense)
- 10. Technology Choice: The big picture Java EE 6
- 12. Evolution of Spring Dependecy Injection POJO oriented development Declarative AOP & transactions MVC Framework Proble Specific XML Extensible Configuration Bean Scoping Groovy, JRuby and BeanShell JSP tag library Java 5 autoboxing and generics Annotation driving wiring Automatic bean configuration New annotation driven MVC framework JUnit 4-based integration testing JSR 300 “at inject” New Spring Expression Language First-class REST support Java based configuration Several new Spring MVC features Support for JSR 303 declarative validation Scheduled Jobs A new “C” namespace Configuration profiles Unified property resolution Java configuration features Servlet 3.0 support Declarative caching Spring MVC enhancements Mobile features Modern Web Data Access Social Security Cloud Ready
- 13. What is Spring ? • Explicit Configuration • Aspect oriented • Ease-of-use abstractions over lower-level, general purpose API’s like JDBC, JMS and JavaMail • More flexibility for fine grained control, but more complexity • Deployment/Runtime complexity • Uses a Java EE container underneath
- 14. Spring Data Spring for Apache Hadoop Google App Engine AWS Beanstalk Heroku Cloud Foundry OpenShift Tomcat 5+ GlassFish 2.1+ WebLogic 9+ WebSphere 6.1+ Hive SI/Batch Spring Batch Spring AMQP Spring Web Flow Spring Integration Spring Roo Spring Web Services Spring Security Spring Secure OAuth Java EE 1.4+ / SES+ JMX 1.0+JDBC 4.1JTAJSR 303JSR 330JSR 250JSF 2.0JPA 2.0 Spring Framework Schedulin g OXM Expressio n ORM Profiles JDBC Caching JMS Testing TX JMX AOP REST DI MVC MapReduce Cascading HDFS Pig QueryDSL Splunk JPA JDBC GemFire Soir HBase Neo4j Redis MongoDB Spring Social FaceBoo k LinkedInTwitter
- 16. Java EE 6
- 17. Evolution of J2EE (later Java EE) May’98 Dec’99 Sep’01 Nov’03 May’06 Dec’09 EJB 1.0 Servlet 2.1 EJB 1.1 Servlet 1.1 JSP 1.1 JMS 1.0.2 JDBC 2.0 JNDI 1.2 JAF 1.0 JTA 1.0 JTS 0.95 JavaMail 1.1 Enterprise Application Robust Scalable Web Services Ease Development Productivity & HTML 5 Apr’13 Lightweight Project JPE J2EE 1.2 J2EE 1.3 J2EE 1.4 Java EE 5 Java EE 6 Java EE 7 10 specs 13 specs 20 specs 24 specs 28 specs 32 specs EJB 2.0 (CMP, MDB, local EJB) Servlets 2.3 (Event, Filters) JSP 1.2 JDBC 2.1 JCA 1.0 JAAS 1.0 JAXP 1.0 EJB 2.1 Servlet 2.4 JSP 2.0 Web Services JMX J2EE Deploy JACC JAAS JAX-RPC JAXR JSTL EJB 3.0 JPA 1.0 JSF 1.2 Servlets 2.5 JSP 2.1 (Common EL) JAXB, SAAJ, WebService Injection Prunning Extensibility CDI JAX-RS Servlet 3.0 EJB 3.1 Lite JMS 2.0 Batch Caching TX Interceptor WebSocket JSON JAX-RS 2.0
- 18. Project JPE J2EE 1.2 J2EE 1.3 J2EE 1.4 Java EE 5 Java EE 6 Java EE 7 • One monolitic server • Hard to decouple technologies • Heavyweight Lessons learned with Spring • Lightweight and Heavyweight servers (separated by Profiles) • Technologies doesn’t depend solely on containers • CDI is a gamer changer • Arquilian is ALSO a gamer changer
- 19. Java EE 6 Highlights Java EE 6 • Extensibility • Enhanced easy of Development • JSF 2.1 • Built-In AJAX • Expanded View Model • Profiles • Vendor Support • CDI (Contexts & Dependency Injection)
- 20. What is CDI anyway ? MyInterface hello = new MyImplementation(); How is going to workWhat I want
- 21. What is CDI anyway ? @Inject MyInterface hello; • Less coding = More Productivity • Server (Container) “injects” the other part FOR YOU • Loose coupling • Refactoring easy • Easy Maintenance Hollywood Principle: “Don’t call us, we will call you”
- 22. Java EE 6
- 23. Java EE 6 Side-by-Side • Java EE 6 and Spring are both capable middleware solutions • Functionally equivalent for the most part, with very different approaches • For very vanilla applications, code is almost identical
- 24. Java EE vs Spring Framework Features Dependency Injection AOP Persistence Transactions Presentation Framework Web Services Messaging Testing Java EE 6 Spring Framework Spring IoC Container JSR 330JSR 250 AspectJ Spring AOP JDOiBATISJDBCHibernateJPA 2 JDOHibernateJPAJDBCJTA WebWorkTapestry Spring MVC StrutsJSF 2 JAX- RPC Spring MVC RESTXFireJAX-WS JMS TestNGJUnit CDIJSR 330JSR 250 DecoratorInteceptor JPA 2 EJB 3.1JTA JSF 2 JAX-RSJAX-WS EJB 3.1JMS JPA 2EJB 3.1CDI
- 25. Spring Framework and Java EE 6 (Side-by-Side) Components Server File Size JARs/ XMLs Configuration Lines Pre-Deploy Memory Post-Deploy Memory Memory (100 Threads) Response Time JSF/CDI/JAAS/JPA/JAX-RS/JAX-WS JBoss EAP 6 11 Kb (WAR file) 0 / 4 37 33 Mb Heap / 48 Mb Perm 41 Mb Heap / 84 Mb Perm 71 Mb Heap / 92 Mb Perm 2459 ms (average) Spring MVC/IoC/Security/JPA/JAX-WS Tomcat 7 32,153 Kb (WAR file) 36 / 5 92 23 Mb Heap / 21 Mb Perm 107 Mb Heap/ 52 Mb Perm 81 Mb Heap/ 47 Mb Perm 1100 ms (average)
- 26. Should I migrate my current Spring application to Java EE 6 ? Why ?
- 27. Java EE 6 To migrate or not to migrate ? • Application is a legacy (written in early versions of Spring) • A real benefit will come from a migration • Faster • More secure • Easy to manage • Support from multiple vendors
- 28. Java EE 6
- 29. CDI and IoC @Named @RequestScoped public class PersonBean { @Inject private SocialID social; @Controller @Scope(“request”) public class PersonBean { @AutoWired private SocialID social; Java EE 6
- 30. Persistence @Stateless public class PersonDAO { @PersistenceContext private EntityManager em; Java EE 6 @Repository public class PersonDAO { @PersistenceContext private EntityManager em;
- 31. Persistence @Stateless public class PersonDAO { @Resource private DataSource ds; public void save(Person p) { try { Connection c = ds.getConnection(); PreparedStatement ps = c.prepareStatement(“… ps.setString(1, p.name()); ps.setInt(2, p.age()); ps.execute(); … Java EE 6 @Repository public class PersonDAO { @Autowired private JdbcTemplate temp; public void save(Person p) { temp.update( “insert … values (?,?)”, p.name(), p.age()); } }
- 32. Transaction and Exception @TransactionAttribute(…) @Stateless public class PersonDAO { @PersistenceContext private EntityManager em; Java EE 6 @Transactional(…) @Repository public class PersonDAO { @PersistenceContext private EntityManager em;
- 33. Transaction and Exception @ApplicationException(rollback=tr ue) public class DAOException extends Exception { Java EE 6 @Transactional(rollbackFor=DaoExc eption.class) public class PersonController {
- 34. Web @Named @RequestScoped public class PersonMBean { private Person p; private List<Person> ls; @Inject private PersonDAO dao; public void save() { dao.save(p); resetForm(); } … Java EE 6 @Controller @Transactional public class PersonController { @Autowired private PersonDAO dao; @RequestMapping(“/add”) public ModelAndView add(Person p) { dao.save(p); ModelAndView mv = new ModelAndView(“ok”); mv.addObject(“person”, dao.list); return mv;
- 35. WebService (SOAP) @WebService public class PersonWS { @Inject private PersonDAO dao; public List<Person> list() { return dao.list(); } … Java EE 6 @WebService public class PersonWS extends SpringBeanAutowiringSupport { @Autowired private PersonDAO dao; public List<Person> list() { if(dao == null) injectionContext(this); … …
- 36. WebService (REST) @Path(“/”) public class PersonResource { @Inject private PersonDAO dao; @GET @Path(“/person/{id}”) @Produces(“application/json”) public Person load(@PathParam(“id”)Long ID) { return dao.seek(ID); } … Java EE 6 @Controller public class PersonResource { @Autowired private PersonDAO dao; @RequestMapping( value=“/person/{id}”, produces={“application/json”} method=RequestMethod.GET) @ResponseBody public Person load(@PathVariable(“ID”)Long ID) { return dao.seek(ID); …
- 37. Messaging Queue InitialContext ic = … ConnectionFactory cf = … Connection c = … Session s = c.createSession(… TextMessage m = s.createText( “hello”); Queue q = (Queue)ic.lookup(… QueueSender sender = … Sender.send(m); c.close(); Java EE 6 @Autowired JmsTemplate t; @Autowired Queue q; public void sendMessage() { this.t.send(q, new MessageCreator() { public Message createMessage(Session s) throws JMSException { return s.createTextMessage(“hello”); }}); }
- 38. Java EE 6
- 39. Java EE 6 and Spring coexistence • Integration with Java EE API’s • 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 MDB especially JCA rather than JMS listeners • Hibernate validator standardized as Bean Validation (JSR 303) • Spring 3 supports excellent bi-directional integration with EJB’s • CDI and Spring Integration through the Spring Bridge to CDI • Native support for Java EE • Java EE 6 annotations supported by Spring • Spring can use JPA / Hibernate natively • Application Server Integration • DataSources can use application Server QoS pooling, transactions, statement caching, debugging, monitoring and security Java EE 6
- 40. Java EE 6 and Spring coexistence Java EE 6 Java EE 6 + CDI PlugIns Java EE 6 + Spring Modules CDI + Spring Spring + CDI Plugins Spring + Java EE 6 API’s Spring • Preference for Standardization • Vendor Neutrality • Simplicity • XML Aversion • Annotations • Type-Safety • Near Zero Configuration • Streamlined Stack • Early Adopters • Some Risk Tolerance • Preference for Standardization • Vendor Neutrality • Simplicity • XML Aversion • Annotations • Type-Safety • Near Zero Configuration • Streamlined Stack • Early Adopters • Some Risk Tolerance
- 41. Java EE 6 and Spring coexistence Java EE 6 Java EE 6 + CDI PlugIns Java EE 6 + Spring Modules CDI + Spring Spring + CDI Plugins Spring + Java EE 6 API’s Spring • Some specialized integration needs • Interim technology updates • Slight less vendor neutral, but • Standards compatible • Some specialized integration needs • Interim technology updates • Slight less vendor neutral, but • Standards compatible
- 42. Java EE 6 and Spring coexistence Java EE 6 Java EE 6 + CDI PlugIns Java EE 6 + Spring Modules CDI + Spring Spring + CDI Plugins Spring + Java EE 6 API’s Spring • Specialized integration needs • Existing skill set • Some sacrifices to vendor neutrality • Specialized integration needs • Existing skill set • Some sacrifices to vendor neutrality
- 43. Java EE 6 and Spring coexistence Java EE 6 Java EE 6 + CDI PlugIns Java EE 6 + Spring Modules CDI + Spring Spring + CDI Plugins Spring + Java EE 6 API’s Spring • Gradual migration • Skill set transfer • Technology agnosticism • Highly advanced integration needs • Aggressive technology adoption • Gradual migration • Skill set transfer • Technology agnosticism • Highly advanced integration needs • Aggressive technology adoption
- 44. Java EE 6 and Spring coexistence Java EE 6 Java EE 6 + CDI PlugIns Java EE 6 + Spring Modules CDI + Spring Spring + CDI Plugins Spring + Java EE 6 API’s Spring • Technology agnosticism • Advanced integration needs • Likely using JSF • Technology agnosticism • Advanced integration needs • Likely using JSF
- 45. Java EE 6 and Spring coexistence Java EE 6 Java EE 6 + CDI PlugIns Java EE 6 + Spring Modules CDI + Spring Spring + CDI Plugins Spring + Java EE 6 API’s Spring • Existing skill set • Low risk tolerance • Standardization • Technology agnosticism • Uses Tomcat or more likely a Java EE Server • Likely using JSF, JPA, JMS, JAX-RS maybe EJB • Existing skill set • Low risk tolerance • Standardization • Technology agnosticism • Uses Tomcat or more likely a Java EE Server • Likely using JSF, JPA, JMS, JAX-RS maybe EJB
- 46. Java EE 6 and Spring coexistence Java EE 6 Java EE 6 + CDI PlugIns Java EE 6 + Spring Modules CDI + Spring Spring + CDI Plugins Spring + Java EE 6 API’s Spring • Highly specialized custom system, likely on Tomcat • Established skill set • Wide deployment • Open Source activism • Some vendor lock-in risk • Highly specialized custom system, likely on Tomcat • Established skill set • Wide deployment • Open Source activism • Some vendor lock-in risk
- 47. Java EE 6
- 48. Java EE 6 Conclusion • There is no practical reason to choose between the two • Balanced competition in server-side Java is good for both developers and vendors • There is excellent integration possibilities