||New Reviews| |Software Methodologies| |Popular Science| |AI/Machine Learning| |Programming| |Java| |Linux/Open Source| |XML| |Software Tools| |Other| |Web| |Tutorials| |All By Date| |All By Title| |Resources| |About||
Keywords: Java, J2EE, EJB, JSP, XML
Title: Guide to J2EE: Enterprise Java
Authors: John Hunt and Chris Loftus
Publisher: Springer Verlag
Level: Beginning J2EE
Verdict: A good introduction to traditional enterprise Java
From the outside the collection of technologies that make up the J2EE platform can appear bewildering even to those Java developers who are experienced using the language in non-J2EE environments (J2SE and J2ME, for example). Partly it is the sheer range of technologies included in the J2EE umbrella that intimidate: JMS, JavaMail, EJB, JNDI, JSP and more. It's more than acronym madness, it's a huge step up in complexity compared to developing desktop or simpler client/server applications.
In this single volume, by experienced Java educators John Hunt and Chris Loftus, we are introduced to all the major parts of the J2EE platform. And, as each technology is introduced, we are shown how it slots in with the other components and how it works together to deliver the functionality that is required.
The book opens with the core infrastructure components: RMI, JAF, JNDI, JMS and CORBA. The authors show how these technologies, which enable communication and inter-operability between objects and processes which are physically (and logically) distributed, provide the glue which is required to piece together a complex distributed application. How these various pieces fit together is explored in some detail, and there are numerous code examples which make use of the various APIs on offer.
Having put together the middleware glue, the book moves on to a chapter on databases, specifically looking in some detail at the primary data access technology in Java (JDBC). Again the authors go down to the API level and provide good coverage using extensive source code. However it's worth noting that newer technologies, such as Java Data Objects (JDO), are not covered. This chapter is firmly focused on traditional database activity - connecting to a database using JDBC, obtaining records, making updates, using meta-data and so on.
XML gets a separate chapter also. This starts at a very high-level, assuming no real knowledge of XML, and then moves quickly into the main Java APIs (JAXP, SAX and DOM). It covers the reading and writing of XML documents and also includes some coverage of transformations using XSLT. This is a big subject, obviously, and the authors provide a useful introduction, though this may need to be supplemented with more detailed material for real-world non-trivial applications.
The final chapter in the first part of the book looks at the JavaMail API. Standard basic operations, including sending and receiving email and handling attachments, are covered. Topics such as MIME types and multi-part messages, handling HTML formatted mail and so on are also included.
Having covered the core infrastructure of J2EE, part two of the book looks in detail at the Enterprise JavaBean (EJB) architecture. The various types of EJB are described in detail, explaining what problems they solve as well as describing how they work. Open-source frameworks, (principally JBoss), are used in the different chapters of this part of the book. In every case the authors give Java source code and the details of the various XML settings files that need to be used.
Part three moves the focus to Servlets, JSP and the whole area of Java web applications. Again open-source frameworks are used to illustrate the workings of the platform, in this case using the Jakarta Tomcat servlet container. The opening chapter of this part of the book does a good job of describing the key issues in web applications and in introducing servlets. The major issue of session management and life-cycle management are covered in a separate chapter, including a good discussion of the different approaches to maintaining state (e.g. URL rewriting, cookies, hidden fields and so on).
JSPs follow, starting with a basic introduction and moving on to more advanced topics including deployment configuration, security, filtering, the use of tag libraries and calling EJBs.
The fourth part of the book looks at miscellaneous issues and technologies, from transaction processing, security, persistence to SVG and web services. The choice of material is a bit odd, it was strange to find a chapter on SVG (scalable vector graphics), in a book on J2EE. However the inclusion of web services was a much better choice.
Finally the last part of the book, entitled 'Design', consists of a chapter of J2EE design patterns and a chapter on a worked example application (a simple fault tracking application). The design patterns chapter was interesting but not essential, and the same goes for the sample application.
Overall the book does provide a wide-ranging introduction to the J2EE platform. That it does so at a reasonably detailed level is a key strength. Entire books have been written about each of the technologies included here, so to have it all in one place makes this a good reference to have around. The book is let down in a few places by poor proof-reading, the number of typos is annoying, but it's not so bad that it spoils the book.
Overall this makes a very good introduction to J2EE.