This was actually the first book on Enterprise JavaBeans that came into the market. Enterprise JavaBeans was released in June and made its debut at JavaOne this year. This is a pretty good book for developers who like to see a lot of code. The examples in the book are used to develop a fairly complex application and the code isn't meant for novices. Tom Valesky presents many examples. I like the fact that the book takes an example and builds its complexity in successive chapters. There's good coverage of distributed architectures and transactions. The author has also dedicated a chapter to provide some excellent guidelines for building distributed systems. For readers just starting out in distributed applications, the author provides the appropriate background. This book isn't for everyone, though. Readers already familiar with distributed systems and transactions may not want to go through the tutorial style followed in the book and may find the detailed code discussions irritating.
The book is written in an easy, informal, tutorial style. It's well organized and easy to follow. In some places the discussion becomes pretty terse, so you may want to take a few breaks when reading. My suggestion to readers who go out and purchase this book: get the software for running the code, install it and then read the book. Test out the examples and read the book in sequence.
Chapters 1 and 2 focus on introducing the reader to the concepts that form the basis of this book. The first chapter provides an excellent discussion on the evolution of computer architectures from the single-tier mainframe model to the n-tier distributed architecture. In this discussion the author also covers the basics of distributed transaction processing. The chapter ends by showing how Enterprise JavaBeans fit into the big picture. A brief introduction to the EJB spec is provided. Chapter 2 discusses the Enterprise JavaBeans architecture.
The concepts are explained well, with the right level of detail. It makes a good stand-alone chapter for reading without requiring the reader to read the rest of the book. The author introduces the appropriate number of class methods to give an overview without confusing the reader. The code is developed using WebLogic and EJBHome software packages.
Chapters 3-6 focus on the various types of EJB development. These chapters follow a pattern: an introduction to the concept, followed by design choice for the example, then a detailed discussion of the example as it is built in parts. It concludes with an analysis of what goes on behind the scenes. As mentioned earlier, a tutorial style is followed, with Chapter 3 focusing primarily on creating a simple client for a "hello, world" example. The design, implementation and deployment of software are explained in detailed, concise steps. The last section of this chapter summarizes what really went on behind the scenes as the reader developed this example. This is again typical of the author's tutorial style. Chapter 4 provides a good overview of session beans. The example in this chapter successfully brings out the main features and functionality offered by session beans. It also discusses transactions vis--vis EJBs. An online shopping example is developed using stateful session beans, followed by an example using stateless session beans. The next chapter (Chapter 5) discusses entity beans and persistence management in EJBs. The examples offered in this chapter reuse code from the previous chapter to illustrate design with container-managed persistence as well as bean-managed persistence.
Chapter 6 deals with the topic of developing EJB clients. The author purposely deferred discussions on writing the client till this chapter. Instead of implementing a complicated client, he gives examples of "small" single-purpose clients that bring out different points he's trying to make.
This makes the code and the discussion very easy to follow. The example gets a little long, but is appropriate at this stage. Chapter 7 goes into some depth about a few necessary but pretty boring parts of the EJB spec: deployment. The author does a good job of providing the requisite information for the reader to get a handle on this topic. The chapter ends with a discussion on deployment issues that developers may face such as caching and persistence. The author also provides a set of guidelines for developers to follow when dealing with EJB containers.
Chapter 8 is a unique chapter that shows the author's grasp of distributed systems. It encapsulates a lot of hard-won technical experience, which is useful to the developer of distributed systems. This is a rare and valuable commodity. Guidelines on transaction design, business logic design, databases, testing and application design are provided in concise discussions.
Chapter 9 sums up all the concepts in the book by walking the reader through a complex example. The "time tracker" example is well picked. It uses the major features from the EJB spec in a real-world system. It demonstrates the use of both session and entity beans. There is also a session bean (TimeTrackerBean) that in turn uses an entity bean (EmployeeBean). The design is well explained. This chapter is useful since it's hard to find an example that illustrates the different aspects of EJBs. Most tutorial classes fail to provide such examples. This chapter alone makes the book worth buying. Chapter 10 briefly talks about existing EJB vendors and future directions for EJB. Of course, you can compare the predictions with what has really happened since the book is a few months old. An Appendix carries complete code listings. These are also available in the accompanying CD.
In conclusion, this is a good book for programmers and developers who are trying to get an introduction to EJBs and like playing around with plenty of code.
Developing Component-Based Distributed Applications
by Thomas C. Valesky
352 pages, Addison Wesley.
He can be reached at: [email protected]