Customer Reviews

Enterprise JavaBeans (Java Series)

5 star:		(74)
4 star:		(17)
3 star:		(8)
2 star:		(9)
1 star:		(4)

 

 

I thoroughly enjoyed this book. Every chapter was excellent.

The book starts with a chapter that explains distributed objects, components, server-side components, and transaction monitors in a way that makes total sense and is fun to read.

The next couple of chapters give you an in-depth look at the EJB architecture removing all the mystery from the technology -- these chapters are pure gold.

Chapters 3 through 7 show how to develop stateless, stateful, CMP and BMP entity beans. These chapters explain how to write beans and how to use them. The examples are very excellent.

Chapter 8 is a very long but necessary chapter on transactions and how they work in EJB. I'm glad they saved this for after Chapters 3 -7 because it's complicated.

Chapter 9 is a priceless Design Strategies chapter that gives you more punch in the first 10 pages then most books give in 100. Even experienced EJB developers will learn new tricks from this chapter.

Chapter 10 is on XML deployment descriptors. This is an excellent reference and the way its organized makes it much simpler to understand.

Chapter 11 covers J2EE. It's short but excellent. The author tells you exactly how EJB fits into J2EE, which is all I wanted to know.

Appendix A - D are an invaluable reference for developers. They include a complete class reference, UML state diagrams and charts, vendor listing and finally a summary of the changes from EJB 1.0 to EJB 1.1.

This is the best EJB book available and will continue to be the best for a long time. Its too solid and too well organized not to be.

I've read two EJB books and this is, by far, the best one. I started with Ed Romans book, which I never finished because I quickly realized the author knows very little about distributed computing. I found refuge in the Monson-Haefel book, which I found to be concise, detailed, and extremely well written. Richard Monson-Haefel is man who obviously knows his business. The book starts out with a basic chapter on distributed computing. I didn't need it, but it was probably the best introduction to the subject I've ever read. Novices will love it. The rest of the book gives you a unique insight to the inner workings of EJB servers while keeping the language straightforward so that everyone can understand it. Everything is covered including entity, session, transactions, and J2EE. I give this book my highest recommendation.

We have been using this book on a large EJB project and have been very happy with it. Monson-Haefel addresses the most complex parts of the EJB platform with a style that makes the book enjoyable to read and EJB fairly easy to learn.

The first three chapters of the book explain the purpose, architecture, and implementation of EJB servers. This really helps our people to understand what was going on under the hood and why beans behave the way they do. Without this material, EJB would be a mysterious black box. We now understand EJB at it lowest levels, which makes our people more productive.

The rest of the book provides a detailed explanation of how to develop each kind of bean (stateless, stateful, and entity beans) using an example application. As the book proceeds it builds on the example increasing the complexity incrementally. What's especially appealing is that example is not so large that it's distracting. The book is very focused and the examples add rather then detract from the book.

One of the books greatest strengths is the way it covers Enterprise JavaBeans in detail. Chapter 8, for example, goes into detail about transactions, database locking, isolation levels, and how transactions are propagated. In addition, the same chapter explains how exceptions impact transactions -- a very real issue when developing large-scale projects.

There is also a great chapter on "design strategies" which introduces ideas like the business interface and bulk accessors. While these designs strategies are invaluable to our project, we would like to see a lot more of them. In particular a section on design patterns in EJB would be very helpful. Hopefully this kind of material will be added in a future edition.

EJB is fairly complex, so a good book like this one is a gold mine. We now have about 20 developers working on our EJB project. Every time we add a developer to our project, they are handed a new copy of this book and told to read it. Without out this book most of our new developers would be hopelessly lost. If you are going to use EJB in your project, then you absolutely must have this book -- its essential.

Now in a new and completely updated edition, Enterprise Javabeans continues to be an essential reference book for all Java users. Richard Monson-Haefel covers Enterprise JavaBeans 1.1 and 1.0; developing entity beans and session beans; container-managed and bean-managed persistence; XML deployment descriptors; the JNDI Enterprise Naming Context (ENC); transaction management; design strategies; bean life cycle; and the relationship between EJB and Java 2, Enterprise Edition (J2EE). Enterprise Javabeans is thoroughly "user friendly" and will enable even the novice to build complex, mission-critical systems using snap-together software components that model business object sand processes addressing such issues as object persistence, security, and transaction management on entrepreneurial, informational, and personal websites. Highly recommended for all Java users.

I started out knowing very little about EJB's when I picked up this book. I'm happy to say I wasn't disappointed!

The first three chapters give a 10,000 foot view about the role of EJB's in J2EE. Bean lifecycles are covered, container interaction, deploytment processes, etc. is all covered in a general and friendly manner. A little bit of code is presented to illustrate key points and help you start thinking about how to write code.

The chapters following really drill down into the guts of entity, session (state and stateless), and message driven EJBs. Simple code examples are presented and taken apart, with detailed explanation about why certain things are the way they are, and how things work. Outstanding theory here! You get down into the nitty gritty about deployment descriptors, state diagrams, the works.

There are also nice reference Appendices providing state transition diagrams, API references, etc.

What impressed me most about this book is the author's careful distinction between EJB 1.1 and EJB2.0 specifications, including code samples of each, and the raw level of detail about how beans work.

The bad part about this book is it assumes you know a lot of other fundamental technologies such as XML, JNDI, and JMS. I highly recommend you have references available on these technologies during reading if you're trying to learn the big picture at the same time. People who are really into code examples and not theory may also be a little disappointed by the simplicity of the examples given.

All in all a great buy!

In my part of our company we have around a dozen people coding EJBs. All are self taught and all used one of two books, either this one or Ed Roman's Mastering EJBs. Each book has its adherants but personally I'm inclined to give this one the edge. It's slightly smaller and more concise and yet probably covers a little more ground than the other one without any loss in detail.

The book is particularly stong on both the overview of EJBs and the differences between versions 1.0 and 1.1. I'd recommend it for anyone who needs to get up to speed quickly on EJBs and can't call on other local expertise for help over the first few hurdles.

I was looking for a good, serious, indepth EJB book and found couple of them in stores. Read this one and Mastering EJBs (by Ramon) but found that this one is serious, indepth reading than the other one. The other one pumps more words and reaches to the same point where this book finishes by saying in simple and finishes in few lines. The downside of this book over others is that it doesnt cover other J2EE components (after all its just titled EJBs) w.r.t. EJBs. Overall it is a winner for coverage of the subject.

The author covers all of the important aspects of EJB, but he does it in a gradual way so that the reader is not overwhelmed by too much detail early on. He starts off with an excellent introductory chapter which explains why you might want to use distributed programming in the first place and gives a simple example that gives the reader a solid perspective on the big picture. Too many books dive right into the details without ever taking the time to give the reader that frame of reference.

Some readers may find the material a little repetitive because concepts are restated in subsequent chapters with more detail added. I personally liked this approach because it helped to reinforce the concepts in my mind by hearing many of them more than once.

One small negative about the book is the way it attempts to cover both EJB 1.1 and 1.0. I was not interested in learning about the old standard and I thought having it in the book cluttered it up, and in some cases it was difficult to tell where the 1.0 discussion ended and the 1.1 discussion resumed.

I think this book is the "definitive" book on EJB and it should be a part of any EJB developers library. What really sets this author apart from others is his ability to "teach" the material rather than just presenting facts and sample code for the reader to analyze.

This book gives an excellent overview of Enterprise JavaBeans and their applications. At all times the author does an effective job of relating to the reader the concepts behind this new methodology. Even performance issues involved with the utilization of Enterprise JavaBeans is discussed briefly in the book and both versions 1.0 and 1.1 are covered. The reader is expected to be an expert in the Java programming language, and have familiarity with the JDBC API or SQL.

The author begins Chapter 1 with an introduction to distributed objects, server-side components, and component transaction monitors (application servers). Enterprise JavaBeans is defined as a server-side component model for component transaction monitors. The standard 3-tier architecture is illustrated, along with definitions of stub and skeleton, and the RMI protocol. Effective diagrams and Java source code are used to describe the distributed object model. The chapter ends with a defense of using server-side components and the author employs an imaginary business application as an illustration of the concepts. This example is expanded upon throughout the rest of the book.

The architecture of EJB is covered in Chapter 2, with entity beans and session beans the two main components. The author carefully distinguishes between these two bean types. The remote interface, the home interface, the bean class, and the primary key are all described in detail and the author shows how to build a bean with relevant Java code. Deployment descriptors, which enable customization of software behavior at runtime, and JAR files, used for packaging Java classes, are both treated in detail. The author is careful also to distinguish the differences between 1.0 and 1.1.

The resource management capability of component transaction monitors are discussed in the next chapter. Application performance is critically dependent on this capability, and the author stresses the benefits of using EJB servers to meet the heavy load requirements while still maintaining optimum performance. State transition diagrams are effectively employed to explain instance swapping, the activation mechanism, concurrency, and persistence of beans. Security of EJB is also discussed with authentication, access control, and secure communication being supported.

In the next chapter the example business application is used to guide the reader through the actual development of an entity bean and a session bean. Again, two different versions of the beans are developed, depending on whether 1.0 or 1.1 is used.

JNDI is used in the next chapter to give an overview of beans from the clients perspective, and allows the application to view the EJB server as a collection of directories. After locating and obtaining the remote reference to the EJB home using JDNI, a remote reference to the bean can then be obtained. State transition diagrams are again employed to illustrate the Java RMI serialization and remote reference.

The author returns to a more detailed discussion of entity beans in Chapter 6. He outlines the advantages of using entity beans instead of accessing the database directly. Container-managed and bean-managed persistence are thoroughly treated, and the author shows how Create methods come into play for both of these beans. A nice state transition diagram is given for the life cycle of an entity bean along with a detailed description on what causes transitions among the different states.

Session beans are then the topic of Chapter 7, and the author discusses when to use session beans versus entity beans. In addition, the other properties of session beans are discussed and the lifecycles of both a stateless session bean and a stateful session are given in terms of state transition diagrams.

Transactions are discussed in the next chapter, with the concept of declarative transaction management discussed, which allows the transactional behavior to be controlled using the deployment descriptor. The author details the advantages of employing declarative transaction management. Effective diagrams are employed to illustrate transaction attributes. In addition, isolation and database locking is discussed in detail along with explicit transaction management. The later is used with the Java Transaction API used by EJB to deal explicitly with transactions. A very useful state transition diagram is given for the transactional stateful session bean.

The next two chapters are written from a design perspective, and discuss how to solve particular design problems, working with specific databases, and XML deployment descriptors. These chapters are specialized discussions and are geared toward those who are actually involved in the designing and coding of EJB applications. The author does address how to improve performance with session beans, treating in particular the network traffic and latency issues, and resource consumption. Method calls on a remote reference will initiate a remote method invocation loop, which will send streamed data from the stub to the server and then back to the stub, and thus consume bandwidth. Network traffic will mushroom as more clients create more beans, update their states, and request information. Reducing the EJB network traffic is a challenge to the application developer and many proposals have been given on the Web and in the literature for how to best do this. Network modelers have to pay particular attention to these issues when EJB is being deployed in an application to be run over a network.

The last chapter covers the J2EE with discussions of servlets, application client components, and connectivity.

There are very useful appendices inserted at the end, especially Appendix B, which gives the state and sequence UML diagrams for all of the bean types discussed in the book. Appendix D is also useful since it discusses the new features available in EJB 1.1.

It is so refreshing to finally read a book where the author knows what he is talking about AS WELL AS knows how to write. The unfortunate trend in this industry is to write 500++ page monster books filled with brainless examples, attempts at humor, and screen shots ad nauseum. Richard Monson-Haefel (the author) has focused on the topic at hand and avoided unnecessary fluff along the way. He has clearly done his homework, which is obvious just from reading the Acknowledgements. Unlike other books which are filled with pointless graphic images of dialog boxes and enumerated steps on what buttons, keystrokes, and actions the reader should take, this book explains the concepts clearly and in depth, provides complete code listings to show how the concepts work, and accounts for the fact that different platforms require different approaches.

I highly recommend this book, even for the beginner to EJB, as the author starts you from the ground up. In addition to the content being excellent, the author's command of English lends to an easy to read and understand book. It is refreshing to finally read a well written book on current technology. I will now always check for O'Reilly published books first.