Start reading EJB 3 Developer Guide on your Kindle in under a minute. Don't have a Kindle? Get your Kindle here or start reading now with a free Kindle Reading App.

Deliver to your Kindle or other device


Try it free

Sample the beginning of this book for free

Deliver to your Kindle or other device

Anybody can read Kindle books—even without a Kindle device—with the FREE Kindle app for smartphones, tablets and computers.
EJB 3 Developer Guide

EJB 3 Developer Guide [Kindle Edition]

Michael Sikora
4.0 out of 5 stars  See all reviews (1 customer review)

Print List Price: £24.99
Kindle Price: £15.44 includes VAT* & free wireless delivery via Amazon Whispernet
You Save: £9.55 (38%)
* Unlike print books, digital books are subject to VAT.


Amazon Price New from Used from
Kindle Edition £15.44  
Paperback £22.67  
Kindle Daily Deal
Kindle Daily Deal: At least 60% off
Each day we unveil a new book deal at a specially discounted price--for that day only. Learn more about the Kindle Daily Deal or sign up for the Kindle Daily Deal Newsletter to receive free e-mail notifications about each day's deal.

Special Offers and Product Promotions

  • Purchase any Kindle Book sold by and receive £1 credit to try out our Digital Music Store. Here's how (terms and conditions apply)

Product Description

Product Description

This book is a fast-paced tutorial that explores the key features of EJB 3 with many accompanying examples. This book is not a complete reference guide, but a concise exploration of EJB 3's core elements. This book is primarily aimed at professional developers who already have a working knowledge of Java. Enterprise architects and designers with a background in Java would also find this book of use. Previous experience of working with Java is essential and knowledge of relational databases is desirable. As this book is an introduction to EJB 3, it is aimed at those who are new to EJB 3. As the new version of EJB is so radically different from the previous version (EJB 2.x), the book is suitable for and should be of interest to those who have had experience working with EJB 2.x. The text makes it clear where the differences between the versions of EJB lie, although they are not explored in detail.

About the Author

Michael Sikora is an enterprise architect with a background in the Unified Process and JEE. He has a particular interest in object oriented and database technology. He has worked for many large UK clients such as ICL Fujitsu, Mercury Communications, Vodafone and BUPA. He has used Java since 2000. Before that he spent a decade designing and developing database and datawarehouse systems. He has experience of Oracle, PL/SQL and C. In the 1980s he worked for Shell developing exploration software. He graduated in Mathematics from Essex University and has Masters degrees from London University and Imperial College. Michael currently resides in London, England and enjoys mountaineering and still hopes to complete the seven summits. His website is

Product details

  • Format: Kindle Edition
  • File Size: 870 KB
  • Print Length: 259 pages
  • Publisher: Packt Publishing (23 May 2008)
  • Sold by: Amazon Media EU S.à r.l.
  • Language: English
  • ASIN: B0057X6694
  • Text-to-Speech: Enabled
  • X-Ray:
  • Average Customer Review: 4.0 out of 5 stars  See all reviews (1 customer review)
  • Amazon Bestsellers Rank: #685,936 Paid in Kindle Store (See Top 100 Paid in Kindle Store)
  •  Would you like to give feedback on images?

More About the Author

Discover books, learn about writers, and more.

Customer Reviews

5 star
3 star
2 star
1 star
4.0 out of 5 stars
4.0 out of 5 stars
Most Helpful Customer Reviews
3 of 3 people found the following review helpful
4.0 out of 5 stars Very good introduction to the subject 19 Jan 2009
This book is aimed at the Java developer with relatively little exposure to EJB 3, and in general is executed very well. Introductory level books are sometimes very hit and miss as it can be challenging to find a level that is easy enough for the uninitiated to pick up, but at the same time interesting enough to want the reader to carry on learning using more advanced material. This book manages to achieve that, is structured well and has an intuitive text convention.

Chapter 1 offers a crash course to the JEE and EJB 3 architecture and guides the reader through the installation and configuration of the environment all code samples will be executed in. It will be useful to download the code samples from the publisher's website as examining and running the samples reinforces the messages in the book.

Chapter 2 introduces the session bean and uses a couple of code samples to describe the client and the lifecycles of both forms of session bean.

Chapters 3 to 5 build on the various bean concepts and the author begins to create the building blocks for a conceptually simple banking application, with code organised and layered in a familiar way (using session and entity beans). This fits comfortably within the capabilities of the target audience, and holds no real surprises. Readers with some exposure to EJB3 will also get some benefit as the various strategies and alternatives around concepts are explored, thereby offering an insight into the possible options available (e.g. primary key strategies, the set of annotations that can be used etc.)

Chapters 6 & 7 look at how the container plays a part in an application's lifecycle - the entity manager and transactions are explored.
Read more ›
Comment | 
Was this review helpful to you?
Most Helpful Customer Reviews on (beta) 4.2 out of 5 stars  6 reviews
9 of 9 people found the following review helpful
4.0 out of 5 stars An EJB3 book with fewer than 700 pages? Impossible! 3 Dec 2008
By Kevin Boone - Published on
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

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.
4 of 4 people found the following review helpful
5.0 out of 5 stars Use this book first when starting with EJB 3 7 Jun 2009
By Roger Dunn - Published on
Format:Paperback|Verified Purchase
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.
2 of 2 people found the following review helpful
5.0 out of 5 stars No Fluff... all Buff!!!!! 29 Dec 2008
By J. Brutto - Published on
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 for some to purchase on other topics of interest. Huzzah to the author for a wonderful text.
1 of 1 people found the following review helpful
4.0 out of 5 stars vast improvement over EJB 2 7 Dec 2008
By W Boudville - Published on
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.
5.0 out of 5 stars Very good introduction to EJB 3 14 Dec 2008
By Indikos - Published on
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.
Were these reviews helpful?   Let us know
Search Customer Reviews
Only search this product's reviews

Popular Highlights

 (What's this?)
In EJB 3 a session bean component consists of a bean interface and a bean class. &quote;
Highlighted by 4 Kindle users
We have no guarantee that the same stateless session bean instance will be invoked between method calls. &quote;
Highlighted by 3 Kindle users
@Stateless annotation. This indicates to the EJB container that the session bean is stateless. &quote;
Highlighted by 3 Kindle users

Customer Discussions

This product's forum
Discussion Replies Latest Post
No discussions yet

Ask questions, Share opinions, Gain insight
Start a new discussion
First post:
Prompts for sign-in

Search Customer Discussions
Search all Amazon discussions

Look for similar items by category