"
Beginning Java™ EE 6 Platform with GlassFish™ 3: From Novice to Professional " by Antonio Goncalves provides 15 chapters concentrating on the most important APIs and features of Java EE 6. The book is almost 500 pages long and provides a good level of detail and many code samples and UML diagrams for each topic being discussed.
The book starts by introducing Java EE 6. A brief history of Java EE is provided showing how it has changed from inception through to the latest version of the specification. A brief description is provided for the major parts of Java EE describing what containers are used for and what APIs are relevant to each container (Web, EJB, Applet and Application Client). After describing the basic architecture of Java EE 6, the book explains what is different in EE 6 over previous versions giving code samples and details of the new APIs involved. Finally in the introduction, details are given of the working environment used to develop code samples throughout the book. This includes Maven, JUnit, Derby DB and GlassFish v3. I would have liked to see some samples of EE6 applications using NetBeans 6.8, but because this is still under development I can understand why this was not included in the book.
Chapters 2 through 5 of the book cover Java Persistence using JPA. This section of the book starts by providing an overview of JPA and describing what is new in JPA 2.0. ORM, queries and JPA lifecycles are all introduced before a full chapter is provided on each subject. In each of these chapters (Java Persistence, Object-Relational Mapping, Managing Persistent Objects and Callbacks and Listeners), the subject is described in detail with many code samples and UML and database diagrams where appropriate. The different APIs used for persistence are detailed in depth, for example, @MappedSuperclass is described together with why it should be used. When discussing querying JPA objects, details are provided on both SQL and JPQL for comparison. I think this would be useful to developers who are new to JPQL but are familiar with SQL. The book really assumes little or no knowledge of JPA querying and discusses dynamic queries, named queries and native queries.
The final chapter on persistence covers callbacks and listeners detailing annotations such as @PrePersist, @PostPersist, @PostRemove and @PostLoad. Again, as is standard thorughout the entire book, valuable UML diagrams are displayed to help explain the section in question along with numerous code samples as both Java code and XML where necessary.
The next section of the book, chapters 6 through 9, covers what many consider to be one of the main aspects of Java EE - Enterprise Java Beans. This section starts by taking a look at EJB - what is it and how has it changed in this latest release of the specification. For many of the code samples in the book, a CD Book Store type application is developed progressively throughout the book. This process is continued throughout the chapters about EJB. The book shows how to write EJBs, how to call them from client code , how to compile and package them with Maven and then how to deploy to GlassFish using the command line asadmin tool.
Stateless, Stateful and Singleton session beans are described along with techniques for invoking EJBs including dependency injection, the timer service and unit testing. Next, lifecycle events of EJBs are described including details of the different annotation to make this process simpler. The book introduces lifecycle annotations such as @PostContruct and @PreDestroy before describing how interceptors can be applied to EJB using the @Interceptors annotation.
The final section on EJB covers transactions and security. A thorough description of transactions is provided including details on XA and distributed transactions explaining two-phase commit - something that is not always included in Java EE texts. As expected, both container and bean managed transactions are detailed along with details of the APIs used and reasons as to why one should use the different types of transactions in the EJB container.
The final third of the book covers the technologies usually found in the web container in Java EE applications. This covers Java Server Faces 2.0, message sending and SOAP and RESTful web services.
The section on web technologies is my favorite part of the book as it covers so much information. It covers the basics of web page development and includes details on HTML, XHTML, CSS, DOM, JSP, scripting, JSTL, JSF, Facelets and much more. I would have liked to see more information on Facelets however as I believe templating of components has great benefits, but is quite often missed by programmers in favor of copy and paste web design. Having said that, there is sufficient information on Facelets to describe what it is and how it should be used.
The final two chapters of the book describe SOAP and RESTful web services. These technologies are traditionally difficult to understand and develop, however these chapters provide clear details of how to develop against and deploy these technologies against GlassFish.
All in all, this is a very comprehensive book on Java EE 6 and is thoroughly recommended. The writing style is easy to understand even when complex subjects are being described. I would recommend this book to anyone that does Java Enterprise development whether they are intending to use EE 6 technologies or not.
Thanks to Twitter, I found out from
@alexismp that the latest code for the book is available from Antonio's
web site.
