Enterprise computing, being an essential component of enterprise architecture (EA) for any growing enterprise, is increasingly pervasive and persuasive across all kinds of businesses. However the worrying factor is that it is getting complicated with the consistent incorporation of newer and nimbler features. Further on, the unbridled complexity is becoming murkier with the emergence and adoption of diverse systems. Another noteworthy trend is that silos are paving the way for connected systems with the realization of introspective middleware. Therefore the main challenge before IT professors, pundits and professionals is to unearth competent and compact methods to moderate the rising complexity. Open and industry-strength standardization and versatile technologies are being produced and projected as the most efficient and effective mechanism to arrest the threatening complexity associated with the enterprise IT.   

                                Java EE specifications are being formulated and sustained with the close collaboration among various industry leaders and giants for simplifying and streamlining the varying goals and the increasing complexities of enterprise IT. This book is a kind of tutorial on the Java EE 6 Platform.

                                Step by step and easy to follow, this book describes many of the Java EE 6 specifications and reference implementations, and shows them in action using practical examples. This book uses the new version of GlassFish 3 to deploy and administer the code examples.

What you’ll learn

• Get started with the final version of the new Java EE 6 Platform.
• Explore and use the new EJB 3.1 and JPA 2.0 APIs from entities to session beans to message-driven beans, and more.
• Discover the new web tier development APIs including JSPs, JSTL, and Expression Language, and especially the new JSF 2.0 and Facelets.
• Uncover the new web services, RESTful services, and more available in Java EE 6.
• Create dynamic user interfaces for your enterprise and transactional Java applications.

                                The 1st chapter enumerates a list of new features introduced in Java EE 6. An e-commerce application is developed in the chapters. And the installation of the used softwares is described.  The chosen application server is Glassfish v3.Chapters 2 to 5 deal with the Java Persistence API (JPA), in its version 2.0. The 2nd chapter offers a small sample of persistence of an entity bean, with the help of JUnit for the tests, Maven for the compilation and the execution, Derby for the database.

                                  In the 3rd chapter the author explains numerous ORM annotations of the version 1.0 of the JPA but also the new annotations of the JPA 2.0.  The section on the mapping of relations between entities is well detailed and is certainly very useful for anyone who has forgotten these annotations and wishes to quickly learn them again. The new features of JPA 2.0 are introduced (second-level caching, pessimistic locking ...). The 5th chapter also gives exhaustive explanations on call-back methods and entity listeners. Chapters 6 to 9 focus on session beans and EJB timer services. The author shows the use of an embedded container, a new feature in the 3.1 version. A small example shows the user of the embedded container and the JNDI lookup JNDI through a standard name.

                                 Chapter 7 does a description of stateless and stateful session beans, with examples.
Session beans singletons are explained in detail, with a lot of code to illustrate the features around them (initialisation, chaining, and concurrence). The other features (standardized JNDI, dependency injection, asynchronous calls with session beans, embedded container, and improved timer service) are also rich in examples of code. In chapter 8, the author does a classical description of the lifecycles of session beans and singletons, call-back methods and interceptors (chaining, exclusion).

                               In chapter 9, a classical and exhaustive description of the 2 transaction modes (container or bean) in EJBs is done. And it also provides good explanations about security-related annotations. In chapter 10, there is a presentation of JSF 2.0. An example shows the development of a JSF 2.0 web application using a business tier based on EJB 3.1 and a persistence layer based on JPA 2.0. In chapter 11, the author writes some reminders about HTML, CSS, JSP, EL and JSTL. Facelets are favoured against JSP as PDL (Presentation Declaration Language) for JSF. The author also tells us about the JSF HTML components and shows the creation and use of components / widgets with JSF 2.0.

                               In chapter 12, a lot of explanations support the presentation of the capabilities in JSF 2.0 regarding the treatment of requests (lifecycle), the navigation, conversion and validation of data, as well as AJAX support. Chapter 13 explains the JMS API in detail and about the use of MDB EJBs with OpenMQ, the default messaging provider for Glassfish, and their compilation and deployment with Maven.

                              The main features of Web Services (WSDL, SOAP ...) are explained in chapter 14. The author shows the use of annotations of the JAX-WS model, according to the JSR-181 specification, for the creation and the call of web services by a consumer. Chapter 15 is the last chapter, which does not lack any interest since it introduces the new type of Web Service, RESTful. It is detailed using the annotations of the JAX-RS API which is part of Java EE 6.

                               On concluding, this is a good book for those who have fair amount of knowledge on the technologies associated with older Java EE version. Architects and developers can immensely benefit out of this well-written book. The author having gained enough expertise and experience in different Java EE technologies could come out with a very convincing book on Java EE 6. He has done a good job on producing such a book, which is handy for both beginners as well as experienced engineers.