Customer Reviews

EJB 3 Developer Guide: A Practical Guide for developers and architects to the Enterprise Java Beans Standard.

5 star:		(3)
4 star:		(2)
3 star:		(0)
2 star:		(1)
1 star:		(0)

 

 

Books on EJB technology tend to be fairly weighty. There are tomes of over 500
pages that deal solely with the persistence manager. And here we have a slim
(by EJB standards) volume that claims to offer a complete overview in a mere
240-or-so pages including, incredibly, EJB Web Services. Is that possible?

Well, up to a point it is. The trick is to focus ruthlessly on the information
needed to make things work, while skimming over technicalities. The book claims
to provide a `fast-paced tutorial' and that is, I think, exactly the way to
look at it. If you're interested in investigating the possibility of using EJB
in a particular project, and know little about the technology, then this book
would provide a great introduction. It's easy to read, liberally scattered with
code examples, and nicely presented. An experienced Java developer could read
it cover-to-cover in a few hours and understand most of it in one reading.
That's pretty unusual for a book on this subject.

Chapter 1 deals with the EJB architecture (very briefly indeed) and how to
obtain and set up the GlassFish application server.

Chapter 2 is more meaty, covering session beans and EJB clients. It is notable
that Java annotations are used here and throughout the book -- there is little
reference to the earlier ways of doing things. Knowledge of how annotations
work is assumed -- there is no technical explication. Another simplifying
factor is the use of client containers to invoke EJB code. This means that the
author doesn't need to explain in detail how JNDI works, and the reader doesn't
have to try to follow the explanation. But, again, there is a world of detail
here that developers will have to get to grips with at some point.

Chapters 3-5 deal with entities, OR mapping, and the query language. These
subjects are closely related and the chapters really form a single chunk of
material. There's certainly enough detail here to be able to build a
straightforward application.

Chapter 6 is a bit of an anomaly. It deals with the entity manager, and is
surprisingly technical compared to the preceeding content. That, in itself, is
not unwelcome -- this is a highly technical area. But since a lot of this
material is relevant to stand-alone persistent applications, and not
specifically to EJBs, I was rather surprised to find this level of detail at
this stage.

Chapter 7 deals with transations and, again, provides enough information to get
started.

Chapter 8 deals with JMS and message-driven beans (MDBs). Little or no
knowledge is assumed of JMS and, in fact, only about four pages of this chapter
actually deal with MDBs. That's fair enough, I think -- if you have the basics
of JMS under control, MDBs are straightforward enough. But there is only a half
a page on transaction handling in MDBs, which (in my view) isn't enough, even
at an introductory level.

Chatper 9 deals with timer services and is pretty clear.

Chapter 10 deals with interceptors, which are a new feature in EJB3. Again, the
material is straightforward and well illustrated with examples.

Chapter 11 describes Web Services in the EJB world. I have mixed feelings about
this chapter. There's certainly enough information in the chapter that a person
with no experience of Web services could follow the examples. But Web Services
is a massive area of technology, and I'm not sure it's profitable to try to
deal with it in a single chapter. But I'm not sure what the alternative would
be, other than leaving it out. It's not a bad chapter, but I think it will be
very difficult to follow what's going on for people who don't have a background
in Web services.

Chapter 12 is about security, and is pretty straightforward.

I think that this book should appeal to developers who are new to EJB, and just
want to get straight to coding, without reading too much theory. In the long
term, any developer who works with EJB extensively is going to have to
get to grips with the theory, and the inpenetrable EJB Specification, but
a gentle introduction ought to be welcome.

In addition, I would recommend the book to experienced EJB2 developers, who
specifically want a rapid introduction to the new features of EJB3.

In short, this is a good book and I recommend it; but developers shouldn't
get the idea that this is the only thing they'll ever need to read on the
subject of EJB3.

I've been developing Java for several years, but have not used or required Enterprise JavaBeans until recently. I first purchased the O'Reily book, "Enterprise JavaBeans 3.0", but before reading it, stumbled upon the PACKT Publishing book, "EJB 3 Developer Guide". Michael Sikora has an excellent writing style. I won't go into the chapter by chapter iteration that some of the other reviewers have done so well, but you get an excellent and rapid start on learning EJB, JPA, annotations, etc.

If you're a Java developer and want to get up to speed in just a few weeks on EJB 3.0, my suggestion is to purchase both books. Start with "EJB 3 Developer Guide", which you should be able to do in a weekend, or faster if you don't actually run the samples, then move to the in-depth look at EJB with the O'Reilly book. I actually used the O'Reilly book as a reference when I wanted to know more about a certain topic, then went back to the PACKT book as the pace was pretty nice and fast. You then have a good starting point when diving into the second book.

Trimming down the typical EJB 3 guides and documentation out there did not seem to be the goal of the author. However, he did so by trimming all the fluff out of the book and presenting things in an organized, succinct manner that prove he took his time while writing the text.

Possibly what I enjoyed most about this book was the fact that the author took the time to carefully choose each word he used. This resulted in a clear understanding without rambling or going off-point as even the EJB 3 books published from O'Reilly do (of which I am a supporter). The sheer clarity and careful nature of the author really shines through and makes it a fast, easy reader from beginner to advanced offering your much more clarity than any other book it currently competes with.

Well organized as well, this book presents EJB 3 development using concrete examples and in a logical, real-world order. Many of its competitors use a very academic approach, which is good for reference, but lack this author's obvious understanding of solving a real-world solution from the ground-up. The book's author has written and organized the text in such a way that you won't find yourself doing a lot of rework and/or revisiting to pieces of code as much as you find in other books which makes for a much clearer picture of how EJB 3 can be applied to your specific problem domain.

Simple illustrations/diagrams make things easy to follow as well. The author, again, took the time to create simple but meaningful designs for this information rather than relying on flashy graphics or over-done diagrams to attract your attention (as I am sure we have all seen in many company presentations, lectures, etc. etc. etc.). This allows for easy explanation not only to the reader, but also provides the reader with succinct, clear examples of implementation and strategy that can be taken to decision makers that are a step above development and/or architecture.

The book also focuses on very generic solutions. This allots the user with the ability to research the wide variety of options available to them in the EJB 3 and J2EE world. While not directly stated in the book, it does, in fact, list many key points to use while evaluating the pieces to the puzzle that you use for completing your EJB 3 solution as well as touching on points that cover "is EJB 3 really right for my problem?".

Overall: Extremely impressive. Less of a reference and more of a front-to-back walk-through. Despite that, it is valuable for all to read from not even knowing what EJB 3 actually is to working with the solution in your day-to-day professional career.

I look forward to more titles from the author and, immediately after completing this review, will be searching Amazon.com for some to purchase on other topics of interest. Huzzah to the author for a wonderful text.

EJB version 2 became notorious for its sheer unwieldiness. Programming the various session and entity beans was a miserable experience, noted for its complexity and the verbosity of the source code and deployment descriptors. Much better is EJB 3 as Sikora explains.

To fully appreciate his book, you should have tried coding EJB 2. But here are the main advantages. There is no entity bean. Instead, we have what are called simply entities. These are Plain Old Java Objects with some extra requirements. Which leads immediately to the idea that an existing java class which is a POJO can be converted to an entity with minor changes. Whereas the EJB 2 entity beans need a remote or local interface and a home or local interface, along with an XML deployment descriptor file. In a similar way, the new EJB 3 session beans can drop the home interface.

Another change is the use of Java annotations. These are special lines beginning with "@" that appear in the source code. What these do is let you avoid writing a deployment descriptor file for that java class. Those files are typically longwinded and manually editing them is error prone. The annotations are remarkably concise and a joy to use, by contrast.

Granted, some readers might think that annotations look like an ugly kludge and clutter up the source code. But overall, you gain, simply by being able to discard many of the descriptor files. The complexity of maintaining those in tandem with the associated source files can be (and perhaps often is) a cause of bugs.

The other big improvement described in the book is the use of an Entity Manager. It hooks up an entity with a database, using java Persistence. And the JPQL aids the mapping to and from the object oriented approach of java to the relational features of SQL databases. Instead of doing the traditional query to the latter and getting back a ResultSet, from which you might to have java objects. The latter involved grubby low level parsing of the ResultSet. Now JPQL lets you think and code at the level of objects. Giving simpler, more robust code.

The stated purpose of this book is to serve as a tutorial. In that it succeeds extremely well. Within a week of reading this book I was a competent EJB developer. The book is very focused, it also engages the mind and keeps one going. Of course it is not comprehensive - for that one should get the Panda book.

I was deeply disappointed with this book.

Nothing was described in details. Everything is described very-very roughly. The author did not show readers his own understanding on EJB at all. If you know the basics of EJB2/3 on every topic and have skills at writing, I have no doubt that you may write a book like this.

Anyway, don't buy it! The only reason I gave 2 stars instead of 1 star is that the author did try his best to spend only 300 pages to describe a complex topic.