Rating: 
Summary: Good book for jumping in
Review: All you need to jump in, for more details go for 'Special Edition Using Enterprise JavaBeans 2.0', rare case when O'Reilly's book is not a head above the rest. 'Special edition' is deepier and a better choice for advanced programmers.
Rating: 
Summary: Outstanding Coverage of a Large Subject
Review: 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!
Rating:
Summary: Recommended
Review: 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.
Rating:
Summary: Excellent Book for new and intermediate EJB developers
Review: This book is aim at Java developers wishing to learn the fundamentals of Enterprise Javabeans.
Knowledge of Java and JDBC is assumed. If you ask to any EJB developer which are the best books about EJB, many will respond with two;
Mastering EJB (Ed Roman) and this one. Mastering EJB also covered JDBC, RMI and other topics.
The 1st and 2nd editions of Enterprise Javabeans (Richard Monson-Haefel, Orielly) focus specifically on
understanding and using EJB. Both are very good and worth reading. The book is made up of 17 chapters, covering the all basics, intermediate topics and some advanced.
The first chapter introduces distributed object architectures and component models.
This chapter gives the reader an understanding of RMI and CORBA, the technologies that EJB was originally built on. Chapters 2 and 3 present the EJB architecture and the main services provided by the architecture.
These chapters are very important to read because they cover essentially what is an EJB,
the advantages of EJB and a few differences between EJB 1.1 and EJB 2.0.
If you have read either of the previous two editions, you will like the EJB 2.0 specifics
(e.g. Message Driven Beans) introduced in these chapters. A TravelAgent EJB is used as an example through out chapters 2 and 3. Chapter 4 gives the reader their first introduction to EJB source code.
We recommend you download the workbook and source code examples (...)
Currently only Web Logic 6.1 and Web Sphere 4.0 versions are available. Chapter 5 present Session and Entity beans with a quick overview of JNDI and Java RMI-IIOP.
The chapter focuses on the Remote and Local (EJB 2.0) client APIs.
The author also shows how to redesign an EJB to use a Local Interface instead of a Remote interface.
What we really like are the code snippets used to demonstrate the theory.
Chapters 6 and 7 go into detail about Entity Beans (CMP 2.0).
Chapter 8 covers EJB QL, similar to SQL but designed to work with the abstract persistence schema of EJB 2.0 Entity Beans.
Again, there are lots of code examples and helpful class diagrams.
Chapter 9 provides a useful guide to differences between CMP in EJB 1.1 and EJB 2.0.
Chapter 10 and 11 describe BMP and Entity-Container contracts (primary key class).
These are explained quite clearly considering these are not simple topics.
Chapter 12 focuses on explaining Stateless and Stateful Session Beans. Chapter 13 presents Message-Driven Beans. After an overview of JMS, a ReservationProcessor EJB is described.
This chapter shows sending messages between client and message bean.
Chapter 14 covers transactions with some example EJB code. In chapter 15, the author gives some design strategies that should be followed.
These include passing objects by value and implementing a common interface.
Chapter 16 is all about XML deployment descriptors. The last chapter (17) gives an idea of what to expect in future releases. There has been alot added to this book since the previous editions. We recommend this book to all developers that would like
to learn about EJB step by step. It would have been nice to have more EJB Design Patterns, however, there is enough in this book
to keep most developers happy. Go buy it now!
Rating: 
Summary: Horribly Writen, useless information
Review: I buy discount software books whenever I can, and I picked this up for 8 or 9 bucks somewhere. Man, what a waste. I learned more about EJB from SUN's website and from reading on the internet. The examples were useless, and the chapters were disjointed.
Rating:
Summary: great!!!
Review: This book was my first exposure to EJB/J2EE and I have found it to be very helpfull. I have read it from cover to cover and I am about to use the knowledge I obtained to rewrite our existing thick client to a JBoss client/server. I strongly recommend this book.
Rating: 
Summary: Not for beginners...
Review: This is a very well designed and written book covering EJB technology in a complete and in-depth manner. There's a quick intro to the subject, and then the rest of the book builds on that knowledge in tutorial fashion. You will build a cruise reservation system using beans, and in the process you'll learn a lot. It does assume that you have a solid foundation in Java skills before you dive in, so don't get this book unless you're already well on your way to learning Java. It's not for beginners. Another very nice feature is the companion workbook that you can buy for this book. It translates many of the exercises into more specific instructions for running them on the Websphere platform. This is an extremely valuable addition to the learning process. All too often, a writer has to assume a certain platform or system to be able to cover the material. If you also use that same system, you're OK. If you're not using what the author had, then there can be a translation process that can be frustrating at times. Having a workbook focused on your specific platform will speed up the learning and avoid the hassles involved in debugging your errors. If you're a Domino developer just getting into Java and J2EE technology, hold off on this book. While you may well get to this point in your career sometime in the future, it will be of little use to you right now. There isn't much that is applicable to the pure Domino world, and you'll need to be very well grounded in the Websphere world before this will start to gel for you. Conclusion
I would recommend this book to a good Java developer needing to learn EJB technology for their jobs. It's very complete and comprehensive. If you're just trying to get started in Java, this book is still aways off for you. I was pretty well lost through most of it, so I need to come back to it in a year or so once I have some more experience.
Rating:
Summary: waste of pages
Review: I just started to read this book from the very beginning as an intro book for EJB. The first chapter is like an overview of the component model architecture. The author repeats the same ideas couple of times, except using differnt wordings. When my spare time is very limited, I would rather pay twice or three-times of the price if the author would cut off half of the length but still convey the same amount of info(which is not too difficult to do if readers' time was really put into consideration). Unfortunately this lengthiness(or selling by pages) seems to be a pretty popular pattern with most IT books nowadays anyway.
Rating:
Summary: Has been a great help
Review: I have used this book for some time and I still have a good impression on the book. I refer it in my day to day work. I admit this book cant be used solely as the only guide especially for newbie but it serve as a good complement with other guides.
Rating:
Summary: Nice book hard to come by
Review: All in all, this book is very well written, especially if compared to other books in similar titles. Concepts are explained concisely and no extra irrelevant materials covered. That said, it still can be improved in two areas:
1. This book is very useful if you read it together with the companion wookbooks. The book I read was for weblogic, which, unfortunately, was kind of out dated. It took a while to get the first example up and running. After that, the rest is quite smooth.
2. The later part of the book, starting from chapter 12, seems to be done more in a rush. Even the writing style was kind of different from earlier chapters. Also there were quite some repetitions that probably could be omitted and replaced with more elaboration and examples of the topics.
| 
