Customer Reviews

Enterprise JavaBeans 3.0 (5th Edition)

5 star:		(16)
4 star:		(7)
3 star:		(3)
2 star:		(2)
1 star:		(2)

 

 

I didn't count'em, but there's like 50 mistakes in the example code
very unprofessional
apart from that, the book is ok
it's a shame though
because I paid good money for it and
I would expect someone to revise the code thoroughly before going to print
after all... it's a programming book!
If you buy this book, don't expect a masterpiece

----------------------------------------------------

In regards to the technical errors...
halfway through the book, it was disappointing
then they're annoying,
by the end of the book it was just sad


I'll give just one of many examples, just to illustrate:

"Only session beans and message-driven beans that define
a javax.ejb.TransactionManagementType of Bean
using the @javax.ejb.TransactionManager annotation
can manage their own transactions."

... later in that same page (388):

[...]
...you won't know which is which unless you go to the API!
Like I said, it's just disappointing, annoying and sad.


It was around chapter 17, when I started wondering:
"Where this guys drinking while they were reviewing the code?"

Mistakes in the last chapter were just plain insulting:
"Figure 21-7. Stateless version of ReservationManager"
is the stateful version! Jesus Christ!
Who edited this book!

Not even the index got away clean (p. 708):
"builing and deplying example programs, 538"

and this is O'Reilly

This book was released in May 2006, so all reviews earlier than that are talking about an earlier edition of this book, which is a completely different animal than this edition.

This book explains and demonstrates the fundamentals of the EJB 3.0 and Java Persistence programming models. Although EJB makes application development much simpler, it is still a complex technology that requires a great deal of time and study to master. This book provides a straightforward, no-nonsense explanation of the underlying technology, Java classes and interfaces, the component model, and the runtime behavior of EJB. It does not include material on previous versions of the specification, however.

Although this book focuses on the fundamentals, it's not an easy read. EJB is an extremely complex and ambitious enterprise technology. While using EJB may be fairly simple, the amount of work required to understand and master EJB is significant. Before reading this book, you should be fluent in the Java language and have some practical experience developing business solutions. Experience with distributed object systems is not required, but you will need some experience with JDBC to follow the examples in this book. I review this book in the context of its table of contents:

1. Introduction - Defines component transaction monitors and explains how they form the underlying technology of the EJB component model.

2. Architectural Overview - Defines the architecture of the EJB component model and examines the differences between the three basic types of enterprise beans: entity beans, session beans, and message-driven beans.

3. Resource Management and Primary Services - Explains how the EJB-compliant server manages an enterprise bean at runtime.

4. Developing Your First Beans - Walks you through the development of some simple enterprise and entity beans.

5. Persistence: EntityManager - Explains how entity beans interact with the new entity manager service. This chapter focuses on the details of the persistence service and how it can be accessed within Java EE and with regular Java programs that run outside of a Java EE environment.

6. Mapping Persistent Objects - Defines the basic relational database mapping provided by the Java Persistence specification. This chapter takes a thorough look at the process of developing entity beans--specifically, mapping them to a relational database.

7. Entity Relationships - A continuation of chapter six that expands your understanding of persistence and complex bean-to-bean relationships.

8. Entity Inheritance - Discusses entity bean inheritance and how an object hierarchy can be mapped to a relational database. This chapter modifies the Customer entity defined in earlier chapters to make it fit into an inheritance hierarchy. It extends a base class called Person and define an Employee class that extends a Customer class.

9. Queries and EJB QL - Addresses the Enterprise JavaBeans Query Language (EJB QL), which is used to query entity beans and to locate specific entity beans in Java Persistence.

10. Entity Callbacks and Listeners - This chapter discusses how you register your entity bean classes for life cycle callbacks as well as how to write entity listeners that can intercept life cycle events on your entities.

11. Session Beans - Shows how to develop stateless and stateful session beans.Session beans fill the gaps left by entity beans. They are useful for describing interactions between other beans (taskflow) and for implementing particular tasks. Unlike entity beans, session beans do not represent data in the database, but they can access data. This means that session beans can read, update, and insert data in a business process.

12. Message-Driven Beans - The message-driven bean was introduced in EJB 2.0 to support the processing of asynchronous messages from a JMS provider. EJB 2.1 expanded the definition of the message-driven bean so that it can support any messaging system, not just JMS through the JCA. EJB 3.0 does not really expand on the feature set of earlier specification versions, but it does simplify configuration with the use of annotations. This chapter examines both JMS-based message-driven beans as well as the expanded message-driven bean model available to EJB 3.0 developers.

13. Timer Service - The Timer Service is a facility of the EJB container system that provides a timed-event API, which can be used to schedule timers for specified dates, periods, and intervals. A timer is associated with the enterprise bean that set it. The rest of this chapter describes the EJB Timer Service API and its use with stateless session and message-driven beans, as well as providing some criticism of and suggested improvements for the Timer Service.

14. The JNDI ENC and Injection - Every EJB container that is deployed in an application server has its own personal internal registry called the Enterprise Naming Context (ENC). This ENC is implemented by JNDI and is a sandbox where the EJB container can hold specific references to its environment. Think of it as the EJB container's personal address book, where it writes down addresses to various Java EE services that it wants to look up and use within its business logic. This chapter shows how you can populate the ENC and use it as your own JNDI registry, and also how to use it to inject environment references into bean fields.

15. Interceptors - Interceptors are objects that are able to interpose themselves on method calls or the life cycle events of session and message-driven beans. They allow you to encapsulate common behavior that cuts across large parts of your application. This behavior is usually in common code that you don't want in your business logic. Where most of the changes to the EJB 3.0 specification were designed to make EJB easier to use for application developers, interceptors are an advanced feature that provide you another way to modularize your application or even extend your EJB container. This chapter shows how to write an interceptor and shows various real-world examples of where interceptors can be used.

16. Transactions - In business software, a transaction embodies the concept of a commercial exchange. This chapter provides an in-depth explanation of transactions and describes the transactional model defined by EJB.

17. Security - Although a small programmatic API is available for interacting with Java EE security services, users rarely have to write any code to secure their applications because setting up security is usually a static declarative process. Only session beans can be secured in the world of EJB. Java Persistence does not yet have a mechanism to secure access, but it is possible--depending on the RDBMS system you are using--to assign privileges at the database level. This chapter focuses on how to set up authentication and authorization for your session beans.

18. EJB 3.0: Web Services Standards -Explains the XML, SOAP, WSLD, and UDDI web services standards.

19. EJB 3.0 and Web Services - Discusses how the JAX-RPC API supports web services in EJB.

20. Java EE - Provides an overview of Java EE 5 and explains how EJB 3.0 fits into this new platform.

21. EJB Design in the Real World - Provides some basic design strategies that can simplify your EJB development efforts and make your EJB system more efficient.

The rest of the book, chapters 22 through 37, consist of an applied workbook for the first part of the book. Chapters 22 and 23 discuss the installation of JBOSS, an open source Java EE application server. Chapters 24 through 37 consist of exercises that cover the material in chapters 4 through 19. This workbook is based on the production release of JBoss 4.0.4 and many of the EJB 3.0 examples from Enterprise JavaBeans 3.0, Fifth Edition. All of the examples will work properly with JBoss 4.0.4 and above, but not with earlier versions of JBoss.

This is truly a very densely packed but informative book. A good companion to it is "JBOSS At Work" which is pretty good at explaining Enterprise Java. I highly recommend this book to the Java professional who is already familiar with developing business solutions.

This book covers almost everything related to EJBs in their new reincarnation. Its author have rightfully chosen to scrap any information concerning EJB 2.1. This is the right path to take as the new 3.X standard is so radically different (read much more useful) from the earlier versions.

The book starts out with a fairly detailed introduction to JPA 1.0 persistence mappings, entity relations and inheritance. It then moves on to covering session beans, interceptors, JAX-WS/RPC, the JNDI ENC and JTA.

This is a massive amount of stuff and still the author manages to convey its primary use, pitfalls and corner cases in an engaging technical style. So from a topical point of view you get what you pay for (and then some). The book is however not without some problems. First of all it contains some annoying errors, like:

1) In the interceptor chapter, the author fails to inform you that EJB interceptors are only used on direct invocations. That is if you put a interceptor on EJB A and inject it into EJB B, then delegated method invocations on EJB A from B are not intercepted. This is annoying at best, and at worst it could be considered an enormous flaw in the EJB spec.

2) Some JPA information is just plain wrong (like the use of named parameters in native queries). Most of these errors can be traced back to the fact that the author uses Hibernate which indeed supports this non-standard functionality. While understandable, it does confuse you some when confronted with strange errors in other containers

Many other errors exists and this book badly needs a review from some of the other EJB/JPA spec members, preferably someone not involved with the JBoss container. Another and more grave problem is the fact that the book presents most technologies as separate entities, and thereby you fail to see the complete picture. I really miss a complete real life EJB applications including:

1) Security (propagation of client role to the server (i.e. getCallerPrincipal)).
2) Interceptors (for logging and security).
3) Use of EJBs from a web application.
4) Testing of EJBs (best practices for easy unit testing).
5) Packaging and compiling (these days you cannot write a JEE book without a complete Maven sample)

This might sound like allot of grief, but I still choose to give the book four stars from the simple fact that it is complete, contains allot of useful samples (like the .NET SOAP application client) and manages to make many hard topics easy to understand.

In general a well written and useful book with a heap of information, written in a pragmatic style without to much fluff.

At the time of this writing (June 2007) this is for me the best book for the EJB 3.0 specification currently available. It covers all the grounds and it is very, very dettailed. Session, Entity and Message Driven beans are very well explained, as well as new new JPA (Java Persistence API); other chapters focus on the services provided by the container (Timer Service, Interceptors, JNDI ENC, Transactions, Security and Web Services).
The books closes with an overview of J2EE and EJB for the Real World (when/how to use them).

Down sides:
- lot of tiny errors; while they are not deal breaker, it'd be nice if ALL the code presented was truly functional. It's usually little things that can be solved by googling the topic (like forgot to implement Serializable, a variable's name mispelled, etc.).
- where's the source code? No CD comes witht he book (thumb down) and following the link provided in the book takes you to the JBoss source, rather than the examples's source.
- Web Service chapters (2), try to zip a 800+ topic in 60 pages. While it's true that web services are a HUGE topic, maybe dedicating a little less time to XML semanthics and focusing on a *runnable* web service example would definetly be a pro. The web service was the only chapter I couldn't make the example work.
- Sometimes it looks more like a reference guide; author could definetly learn from the Head First guys about didactic AND fun!

The theory part of the book is general in nature, specifying which behaviors are specs dictated and which are vendor implementation dependant. The practice part is JBoss specific, which is one of the main reasons I bought this book.

The Head First EJB (3.0) is still unannounced (estimated Spring-Summer 2008), and there isn't yet a SCBCD specific book available; so your best chance is to get this book, find any extra material online and you'll be ready to go!

Are fluent in the Java language and have some practical experience in developing business solutions? If you are, then this book is for you. Authors Bill Burke and Richard Monson-Haefel, have done an outstanding job of writing a 5th edition of a book that provides a straight forward, no-nonsense explanation of the underlying technology, Java classes and interfaces, the component model, and the runtime behavior of EJB.

Burke and Monson-Haefel, begin by defining component transaction monitors and explain how they form the underlying technology of the EJB component model. Then, the authors defines the architecture of the EJB component model and examine the differences between the three basic types of enterprise beans: entity beans, session beans, and message-driven beans. Next, they explain how the EJB-compliant server manages an enterprise bean at runtime. The authors then walk you through the development of some simple enterprise and entity beans. They continue by explaining how entity beans interact with the new entity manager service. Then, they define the basic relational database mapping provided by the Java Persistence specifications. Next, the authors expand your understanding of persistence and complex bean-to-bean relationships. The authors then discuss entity bean inheritance and how an object hierarchy can be mapped to a relational database. They continue by addressing the EJB QL, which is used to query entity beans and to locate specific entity beans in Java Persistence. Then, the authors cover the life cycle of an entity bean and how you can write classes that can intercept entity life cycle events. Next, they show you how to develop stateless and stateful session beans. The authors then show you how to develop message-driven beans. They continue by showing you how to use the Timer Service in EJB 3.0. Then, the authors explain the JNDI ENC as well as the new injection annotations and their XML equivalents. Next, they discuss EJB interceptors and how you can use them to extend the behavior of your EJB container. The authors then provide an in-depth explanation of transactions and describe the transactional model defined by EJB. Then, they walk you through the basics of EJB security. Next, the authors explain the XML, SOAP, WSLD, and UDDI web services standards. They continue by discussing how the JAX-RPC API supports web services in EJB. Then, the authors provide an overview of Java EE 5 and explain how EJB 3.0 fits into this new platform. Finally, they provide the basic design strategies that can simplify your EJB development efforts and make your EJB system more efficient.

This most excellent book is organized into two parts: the technical manuscript (of which I have just covered), which is followed by the JBoss workbook. More importantly, the JBoss workbook provides step-by-step instructions for installing, configuring, and running the examples from the manuscript on the JBoss 4.0 Application Server.

Good book.

Easy to read and contains comprehensive examples and excercises for JBOSS App Server.

Does not contain enough examples on creating EJB architectures, which is ok as that was not the intention of the book.

The one thing that threw me off every now and then is the book's coding conventions, like calling "Data Transfer Objects" "Dependent Objects", naming such objects with DO in the end instead of DTO, which is the way done in NetBeans 5.0 IDE when creating EJBs.

Overall, it's a very good starters' book. Looking forward to the next book about EJB 3.0

This is an excelent book to learn all aspects of EJB 3 and also to be used as a reference.

The author covers all the topics related to enterprise application development, including, as well, the necessary background to develop web services.

The explanations are great and easy to follow. If you have never developed enterprise applications before, this book is a good start point.

There is also a great workbook for those who wants to work with JBoss. By the way, you do not need to have any earlier JBoss knowledge. This workbook is easy enough to follow. Even a chapter with installation and configuration instructions is provided.

I recommend this book for anyone interested in EJB 3.

I began to learn EJB 3.0 from JBoss EJB 3.0 tutorial and demo examples, and found that the EJB 3.0 is really a amazing technology in Java evolution. After finishing half of the book, I feel much more confident on EJB3.0. The book has more detailed explanations and examples comparing to the tutorial. If you want to learn and practice Java EE 5, the book should be the best start.

I found this book very helpful getting me up to date with the latest version of EJB. I had used EJB 2.1 before, but this book is good even for complete beginners. The first couple hundred pages are about the new Java Persistence Architecture. The last couple hundred pages are on using EJB 3.0 in JBoss AS. The middle of the book covers the rest of EJB 3.0. I still reference this book from time to time when working with JPA and complex relationships. I highly recommend this book.

If you are buying a book on EJB 3, this should be it.
This book has no equal.

Interesting/Relevant examples, no "stretching" to prove/illustrate a point/concept, straight-forward, smothered in suggestions for constructive thought process in your designs, filled with reference to methodologies and their value, etc. etc. etc.

I cannot speak highly enough for this book.

From beginner to advanced EJB developer, you will find this as not only a valuable reference, but a wonderful insight into how to go about designing your Java-based enterprise applications.

The wide variety of topics covered do not take away from the primary focus of the book: Entities, Session Beans and MDBeans. These core principals are beautifully illustrated in this book in a wonderfully architected example.

The book touches briefly on the principals of Web Services, WARs, packaging, JBoss, etc. etc. etc. These brief touches show that while all of these aspects are involved in Java enterprise systems, that the core of all of them is the powerful ESbMDb structure. The author leaves it to specialized books to speak of these topics rather than trying to munge them into his in-depth coverage of their core principals.