Expert One-on-One J2EE Development without EJB by Rod Johnson, Juergen Hoeller
Paperback: 576 pages
Publisher: Wrox (June 21, 2004)
I’ve read this book several times since the day it shipped and I have to say that this is an excellent book for anyone working as a developer or architect working in the Enterprise Java arena. I absolutely love this book given my bias – I guess I should start by stating my bias. EJB bashing is a favorite past time of a lot of people. I happen to love EJB’s, with the exception of entity beans and think EJB’s are a great way to create software solutions are remotable, loosely coupled and powerful. I will agree that EJB’s are way too complicated with all the stupid artifacts that you need to create to create and deploy an EJB. Having worked with EJB’s since 1999, I guess I am so used to all of nuances of EJB’s, I can write up deployment descriptors in my sleep. Having said that, I approached this book with a little apprehension as I hate these EJB-sucks book that don’t really offer any intelligent discussion about the shortcomings of EJB nor do they offer a viable alternative. Another assumption I brought to the book was that this was just a Spring book with a little EJB bashing thrown in for good measure.
To my pleasant surprise, Rod Johnson and Juergen Hoeller have written an awesome book. This book does not take cheap shots – Instead there is a intelligent, thought provoking discussion about the pros and cons of EJB. In fact, the first 120 pages (Chapter 1-5) are just a great breakdown of application architecture with a through treatment of EJB. I loved this section and re-read it several times and I found myself agreeing with pretty much everything in this section. I would equate this to a great meaningful discussion you would have with someone who really understood application architecture and development and you could debate the pros and cons of the many alternative approaches that exist today.
Chapter 6 starts the discussion of Lightweight Containers and the idea of Inversion of Control (IoC). This is not a chapter on Spring; rather it is an overview of Inversion of Control and strategies like Dependency Injection in the context of Spring and PicoContainer.
The next chapter offers a quick introduction to the Spring Framework. As everyone already knows, the Spring Framework is a very popular open source application framework created by Rod Johnson. The co-author Juergen Hoeller is another lead developer of Spring. The chapter is Spring is fairly light and people hoping for a in-depth Spring tutorial will be disappointed. Instead this chapter offers a rather high-level overview that will get you some basic understanding of the Spring Framework. I guess it’s hard to cover Spring in 43 pages.
After the cursory introduction to Spring, the book moves into Aspect-Orientated programming (AOP) concepts. This section starts with a very introduction to AOP before jumping into AOP implementation strategies. After a brief discussion of AspectJ, AspectWerkz, and JBoss AOP, the authors move into SpringAOP. After AOP, the books moves into Transaction Management where current J2EE approaches are discussed and then contrasted with the Spring approach.
Persistence is the next item tackled in the book and this section includes a really nice discussion of why you need a persistence strategy, when to choose O/R mapping vs. straight JDBC. After a walkthrough of the Java persistence technologies, the book moves into practical items and discusses Persistence in detail. Starting with JDBC, the authors contrast that approach with iBATIS SQL Maps, JDO, and Hibernate. The section on Data Access Object (DAO) pattern discusses the J2EE pattern and discusses some of the common design issues faced by developers. After the discussion, the book moves into discussing how data access works with the Spring framework and discusses Spring’s DAO framework and how it works transparently with persistence technologies including iBATIS, Hibernate, JDO and straight JDBC. As an aside, if you haven’t looked at Spring or just it’s DAO framework, you should explore it as it simplifies the development process and minimizes the amount of code you write. I just rewrote some of my POC applications using Spring’s DAO framework that used iBATIS and Hibernate under the covers. By using the template classes provided by Spring, I wrote about 30-40% of the code I would have normally written using iBATIS or Hibernate by themselves. The Spring Framework includes a reworked version of the original JPetStore application that uses Spring’s DAO framework along with iBATIS SQL Maps.
After persistence, the book moves to Remoting and the idea of exposing business logic or services to remote client. One of the major benefits of EJB is the ability to remote anything exposed at the bean layer. This chapter starts off by discussing how to access an EJB from a Spring application using the JndiObjectFactoryBean. The setup is so simple and IoC makes lookup, creation of home, etc so easy with the declarative configuration. After EJB, the chapter moves to Web Services and JAX-RPC. Again the authors walk through the steps needed to consume JAX-RPC via. JNDI and demonstrate the elegance and simplicity with which Spring integrates into and consumes existing J2EE services. This chapter also includes discussion of Hessian and Burlap and the concept of lightweight remoting.
The next chapter in the book discusses the other EJB services that the container provides and talks about how to replace them. This section breaks down the do’s and don’ts in terms of threading and pooling that is typically provided by an EJB container. There is a brief mention of security in this chapter.
The next section of the book discusses web tier design and dives into the current state of Web Model2 MVC frameworks. The section starts off with a look at Struts before jumping into WebWork. After the intros, the authors describe the Web MVC framework built into Spring. One of the things that I absolutely love about this book is the use of the dark gray boxes to summarize a topic, offer tips and advice or offer a best practice.
The next chapter is one of my favorite chapters in this book and it deals with the idea of unit testing and testability. Anyone that has written a J2EE application will attest to the fact that J2EE apps are really hard to test. There are a lot of testing frameworks in the market now but they require either too much setup or are really cumbersome to use and end up diluting the value they were supposed to offer. This section discusses some of the anti-patterns that are the de-facto standards in J2EE. I love the techniques offered in this section to improve testability. After an overview of testing, the book moves into a discussion of Mock Objects and the how, why and when of using Mock Objects in your development/testing lifecycle. The book then moves into Test-driven development (TDD) and offers a case study of how TDD has helped with the development of the Spring framework itself.
The last section before the sample application is on performance and scalability. This is another great chapter that should be mandatory reading for every developer. In this chapter, the authors discuss the challenges faced in building distributed multi-tier applications. There is a section that breaks down the architectural tiers and some of the common issues faced by every application developer. Very nicely written chapter and I glad the authors included a section on Profiling.
After performance, the book jumps into the sample JPetStore application that ships with the Spring Framework. The authors start off by discussing some of the shortcomings on the JPetStore application and then employ Spring to solve some of those issues. The JPetStore application is a great tutorial application for anyone learning Spring.
The book closes out with the conclusion section where the authors wrap-up and summarize some of their points outlined throughout the book.
Having read this book several times, I have to say that this has to be one of my favorite books of 2004. I love the clear, concise writing style of the authors. This is a great book and a must for every developer’s library. While this is not a Spring tutorial book, you will learn enough about Spring to want more, a lot more. I highly recommend this book and encourage you to run to your local bookstore or computer and get this book.
If you are looking for a Spring book from the source, you’ll have to wait for Rod’s new book entitled Professional Java Development with the Spring Framework co-authored with Juergen Hoeller, Alef Arendsen, Thomas Risberg, Dmitriy Kopylenko or wait for Keith Donald’s Spring book.