Customer Reviews

Beginning EJB 3 Application Development: From Novice to Professional (Beginning: From Novice to Professional)

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

 

 

This book is targeted at developers who are experienced with Java and have built multi-tier applications using earlier versions of EJB. In order to work out the examples in this book, you should be very proficient in using the command line and/or Ant. Working knowledge of the GlassFish application server is also needed.

If you have already worked with the previous versions of the EJB specifications and want to migrate to EJB3 - or even just want to find out how it works - this will be the perfect guide for you. The examples throughout the book should give the reader a very good understanding of EJB3. It should be easy to migrate your earlier versions of EJB applications to EJB3 with this book in your library.

The only issue I had with the book was with the build files (Ant scripts) provided. I have been using Ant for several years and didn't feel they were up to the level of the rest of the book. For example, the book suggests you set an environment variable for GLASSFISH_HOME, but this value isn't used in the build files: instead, a property is set in the properties file for chapter 1. If you skip reading the readme file (and who doesn't?), you will spend a lot of time probing what went wrong before you find it.

Once you finish reading this book, you will agree with me that the new EJB 3 specification (JSR-220) offers great improvements over the earlier EJB versions in terms of simplifying development, adding new features, facilitating test-driven development, and focusing more on POJOs rather than on complex APIs.

While the material covered in this book is outstanding, there are more mistakes than I would expect in the samples. On the other hand, the authors do have a link on the Apress web site for corrections. While working on the examples, I recommend you have a printed copy of these corrections. I would recommend this book to developers who want to migrate to EJB3 or those who want to build applications using this new simplified EJB3 architecture.

With EJB 3 gaining momentum, there are a number of books now available in the market. I read two of the books "Beginning EJB(tm) 3 Application Development: From Novice to Professional" from Apress and "Enterprise Java Beans 3.0, Fifth Edition"from O'Reilly.

If you have had previous experience with earlier versions of the EJB specification, or plan to migrate to the new spec, then the book "Beginning EJB(tm) 3 Application Development: From Novice to Professional" would be an excellent choice. On the other hand, if you would like to see what EJB 3.0 offers, "Enterprise Java Beans 3.0, Fifth Edition" sets the standard.

If technical material is of great importance, both books provide this equally well. However "Enterprise Java Beans 3.0, Fifth Edition " gets a little tedious if you continue reading for a long time when compared to "Beginning EJB(tm) 3 Application Development: From Novice to Professional". In contrast, if you want good working examples then I would suggest you look at "Enterprise Java Beans 3.0, Fifth Edition".

In conclusion, both books have some strong and weak points, get a book buddy or your colleague and buy both of them. That way, you get the benefits of both books.

The book is a good summary of the specs and gives a nice introduction to the new things in the world of EJB 3. The section on converting your v2 apps to v3 was particularly useful. Appropriately marked "From Novice to Professional" the book touches on many aspects of the J2EE world in a manner that treats the novice with care and the professional with grace and insight/direction.

On the negative side... The book has a lot of repetition. Many pages are nearly identical (especially the sample building) and could have been condensed and made more useful by sticking to use of Ant and examination of the scripts. The same can be said for the "copy-and-paste nature" of some of the writing. However, one can tack that up to "consistency in writing style."

The book is not what I would call an "easy read," but was informative none-the-less. It serves as a starting point and base reference.

The authors have provided a generally well-rounded book and I would definitely recommend this to others.

I found this book very useful, but it is not for developers new to EJB. If you have a previous experience with EJB 2.x, this would be a very good choice. In my opinion, the coverage of the Java Persistence API (JPA) is a little bit shallow. I prefer Pro EJB 3: Java Persistence API by Mike Keith in JPA. Other than that, I found it a very good book specially the chapter that is talking about performance testing.

I've bought the electronic version of this book from the APRESS site.
I'm going to use this book, together with the SUN EJB3 specs, for preparing the future SCBCD 5.0 exam.
I admit that i have read only the first two chapter of the book, but i found the style of writing and layout very comprehensible.
Only one note: too many errors!
Some errors is only about mispelling (pag 72, "PreActivate" instead of "PostActivate") and are easy to dicover. But there are some errors that are more difficult to find and, worst of all, lead to a wrong understanding of the materials: pag 67, "InvocationContext" is in the "javax.interceptor" package not in the "javax.ejb" one, "InvocationContext" has no "getBean" method, but a "getTarget" method.
Well, maybe at the time of writing the EJB3 specs and API were not in their final release, but i admit i'd liked to find a much more detailed ERRATA on the APRESS site.

I asked a friend how to start EJB he suggested this one and it was a great recommendation.
I started with the forword which written by Floyed Marinescu you should read it.
The first chapter as usual begins with introduction to the EJB,History, benefits of EJB3, how this book organized, and who is the expected readers,and how to install the Glassfish application server which the authors recommend to run the examples. The second chapter introduces the session EJB3 it walks with you till you deploy your 1st EJB3 session bean.
Next 3rd chapter "Entities and the JAVA persistence API" start explaining the entity beans and the O/R Mapping, EJB quarry language you should have a good knowledge about the ORM to take full advantage of this chapter.
The 4th chapter tackle some advanced topics about Persistence Features like inheritance, abstract entities,using native SQL,locking,composite primary key ,and auto generated Primary key.
The next chapter introduces the Message-Driven, beans it turned to be really easy Smiley.
The 6th chapter teach you how to expose your beans as a web service, you can depend on this chapter as an introduction to web services.
Chapter seven gather them all, it integrate all types of beans into a fully sample application, it is an important chapter.
Chapter 8 is all about transaction support in EJB3.
The "EJB3 performance and testing" chapter provide you with ways to measure the performance of your EJB3 components and which options in EJB3 suitable for you.
Chapter ten is dedicated to the legacy EJB3 users it show how to migrate from EJB2.x to the new EJB3.
After you learned how to develop EJB3 components chapter 11 "EJB3 Deployment" gives the "how to" to deploy these components on you application server.
Last chapter provide a client look to the EJB3, it develop complete web application using JSF as a web tier and EJB3 in the back, this chapter is great it makes you see a real results of EJB3.
don't ignore the appendix which compare the performance between EJB2 and EJB3.
As a conclusion this book is very good it really made me love to work with EJB3,it let you see the code not just theories and concepts. Now i can tell you that EJB3 is not a thing to be afraid of,it is easy,light,even fun.
but make sure you are familiar with JAVA 5 new features annotations before you work on this book.

I thoroughly enjoyed reading the "Beginning EJB 3 Application Development" book. (I'm a senior programmer, have been using Java since 1995 and am co-founder and co-leader of the Austin Java Users Group.) The book started off with a nice executive overview of EJB 3 and the usability problems with EJB 2 that it solved.

On a side note, I have been impressed by the EJB 3 working group for making such a bold move forward while remaining backward compatible with the old specification. Typically as a given software technology matures and becomes well established, the software infrastructure and APIs develop a lot of inertia that leads to significant resistance to large improvements. The EJB 3 working group overcame this pressure and produced a bold new elegant design that should be a pleasure to work with. It always takes time and a lot of work to create a clean simple design and I think the team has done that finally with EJB 3.0. The authors captured the advantages of the new specification and leveraged the new capabilities and simplified approaches.

I appreciated the section on setting up the environment and the mechanics of compiling and deploying the EJBs using the free GlassFish application server. Just enough detail of the incantations to work with the server was given in order to get started without getting bogged down in lengthy setup descriptions. The authors provide examples up front to get you quickly up to speed with the new paradigms. They continuously mix clear examples with explanations to ensure that you gain an incremental understanding quickly.

Stateful and stateless session beans are covered. Comparisons are made between annotations and the XML descriptor files and the rules to override are clearly defined. I enjoyed the section on interceptors and was impressed how easy it is with annotations to intervene with preinvoke or postinvoke operations. I liked that the authors are succinct with their explanations. The authors get to the point quickly, which I appreciate given the volumes of material one needs to absorb to keep current in this industry. The examples start off simply and gain complexity as more features of the spec are added to the application. Useful process flow and database schema diagrams typically accompany the examples to clarify the problem.

Early on I found a couple of small bugs in the sample code (mostly caused by a moving specification), but the authors have been very proactive about posting erratas on the website.

JMS and message driven beans are discussed as well. A quick overview of JMS and MDB is given with a succinct, but very relevant status-notification example. The mechanics of setting up a JMS topic and a JavaMail resource is described, as well compiling and deploying the MDB.

There is a nice brief overview of web services and the associated standards. A useful credit card verification example is provided complete with the mechanics of compiling and running the code.

I thought the sections on the Java persistence API were well done. I felt the authors covered most of the typical issues that you run into when mapping Java objects to a relational database schema. Advanced sections covers hierarchical modeling and the advantages of user-defined primary keys for instance. Concrete table definitions and their associated Java mappings are illustrated.

The authors demonstrated that they have solid design experience since they intermingle practical sage advice and admonishments througout the book.

I thought that there should be more advice on forward versus reverse engineering of the database schema since there are a lot of lousy database schemas out there that have been generated directly from the Java object model.

The authors provide a good overview of container versus bean managed transactions. The mechanics of using each approach and the associated trade offs are illustrated. I like that the authors included some of the basic information on transactions such as the definition of ACID for instance. (I need to refresh my memory every so often.)

The performance benchmarking section was very well done. A clearly thought out methodical approach to performance testing is given with what I thought were surprising results between the two mapping approaches (single table inheritance and inheritance through joins). An overview of a very useful load testing tool is given as well. Salient performance comparisons between EJB 2 and 3 are also presented.

For the seasoned EJB 2 folks, there is a chapter on migrating the EJB 2 applications to EJB 3. This chapter may help in understanding what EJB 3 does for you compared to EJB 2 as well.

In summary, the book was definitely worth my time to read. Beginner and advanced programmers will learn from this book. I'd definitely recommend getting the book and I look forward to working with EJB 3 in practice.

EJB 3 took its time to get mass acceptance, primarily because many Java developers did not have great memories of earlier versions of EJB. EJB 3 is however now gaining momentum and a number of EJB 3 books have hit the market. Beginning EJB 3 is a Beginner - Intermediate level book from Apress.

In their letter to readers, the authors say that "With EJB3, the EJB spec developers had at last settled upon a model that really made sense. Coming from EJB 2.x world, it was like a breath of fresh air.." So EJB 3, is widely believed to be a significant step forward in simplifying enterprise Java development.

The book uses several examples to demonstrate the new found simplicity of EJB 3. The free, open source application server GlassFish, which is the reference implementation for all specifications in Java EE 5 is used in the book.
One of the important changes in EJB 3 was the introduction of annotations. However XML descriptors are still very much around. Java development has a tradition of always taking the most complex approach and if there isn't one, it works at complicating the simple approach. So after the initial excitement about annotations, there's again uncertainty. It's now (Annotations) vs (XML) vs (Annotations & XML mix). On this, the authors say "A simple rule we follow is this - If we need to decouple our entity and bean classes from their EJB 3 metadata, as when we want to use the same entity classes with two different inheritance strategies, we put our metadata in XML. Otherwise, we stick with annotations" "And don't forget...whenever metadata is specified for an element using both XML and annotations, the XML always wins"

Chapter 1 introduces EJB 3 and gives us a quick overview of all that's changed in EJB 3.0. Chapter 2 looks at session beans and dives into using dependency injection in session beans, interceptors, callbacks, local vs remote access even before a session bean example is deployed. So the book kind of works with the assumption that you have tried your hand or as some would say "burnt your fingers" with an earlier version of EJB. The book runs the risk of being too fast for someone who might be trying EJB for the first time.

Chapters 3 and 4 look at entity beans and persistence and Chapter 5 looks at message driven beans. Chapter 6 begins with the basics of Web Services and then moves on to the various web services specs and how you can use the @WebService nd @WebMethod annotations to quickly get your app web services ready.

Chapter 6 to 11 deal with web services, integration, transaction, performance and migration from version 2.1. The good thing about these chapters is that the authors first introduce the concept, the need and the basics and then delve into the actual development. Problems while deploying EJB across applications servers were commonly reported with earlier EJB versions, so it's good that the authors have dedicated a chapter to EJB 3 deployment and planning.

JSF has become more or less the standard for new Java web development. So Chapter 12 is a useful one as it shows EJB client development using a simple JSF + EJB 3 application.

Overall, for a beginner-level book I think it would have been good if there was more content and hand-holding in the initial chapters, as Apress has a book "Pro EJB 3" which could look at the advanced EJB topics in detail. But if you have been on the enterprise Java scene for some time and have tried out EJB earlier, this book will get you going with EJB 3 in no time.

I've found it complete! It covers all topics related to EJB3 application development: persistence API, message-driven, entity and session beans, web-services, transactions, testing, deployment and client applications. For novices, it is a good book to understand the whole matter. For more advanced developers, it is a good reference to look for a specific subject. Mainly if you are a professional and, like me, have neglected one or other specific topic.

Excellent to developers used to work with EJB version 2. Actually, there is a whole chapter about EJB 2.x to EJB 3 migration and it really gets things easier.

For me, the chapter 8 ("Transaction Support in EJB3) was the one that bring me more new knowledge. I have been developing some small EJB3 applications without worrying to much with transactions and I was always postponing more advanced study about this subject. This book give me the opportunity to start understand deeply how EJB 3 transactions works.

The authors also included a chapter dedicated to testing performance. I've found it great! Normally, this topic are neglected by others books and searching into Google or into some on line Forums is the only way to find out some tips. Of course, since the book is not about performance, the authors do not give a deep explanation; but, they give the directions to follow and it can save some precious hours to start understand how to improve your EJB applications performance.

Another interesting chapter is the chapter 12 ("EJB 3 Client Applications"). The authors show how to use JSF to write web client applications. For developers who do not have studied JSF yet, it is good place to begin understand how to implement JSF pages in conjunction with EJB. Sure enough, another JSF book is necessary to master it; but the examples in the book shows easily how a JSF client application can interact with EJB back-end server.

Well! In general terms, a great EJB3 book. For novices, among the others books I have already had a look, the number one recommendation. For professionals who feels that have some lack in EJB 3 knowledge, a must have book.

Over the course of a couple weeks I read the entire book. I found that the book provides the most value by doing this. I had some limited experience working on existing EJB 1/2.x apps and have developed some prototype apps using EJB 3 also. The book really filled in some gaps in my knowledge including the history of the specs. I don't know that I would use the book for a reference though. I will probably refer to the spec to get the details.

Although I didn't follow the directions provided to get the code samples running in the Glassfish server I appreciate the detail the authors went through to help the reader. The directions seemed to be complete. I didn't feel like I had to go through this step because I already have code up and running deployed to Glassfish using Netbeans.

Sometimes I felt like the book didn't provide enough detail using nontrivial examples in certain areas such as the lifecycle and interceptor methods. Other times it provided too much detail such as the examples using JSF. I'm about to start a project using EJB3 and JSF so I found the discussion of integrating JSF into an EJB3 app interesting but the average reader would probably be better of referring to a book specifically on JSF.

The sections on performance testing were some of the best in the book. They explained how to set up the tests and the important statistics to look for. I was looking for some information on unit testing EJB3 outside of the container and was disappointed not to find any.

Overall I thought the book was excellent and would recommend it to both developers new to EJB3 and more experienced ones that either want a good overview of the subject or are looking to migrate apps using the older specs. The book didn't blow me away but I still found it hard to find even minor points to be critical of. The book has definitely given me the confidence to apply the new technology appropriately.

This book is relatively short. Much of its content are pieces of code. You don't have to read 1000 pages of blah blah blah. The book is not too clear and not well written, some of its explanations are rather vague. You have to work it through carefully with a pencil. However if you work it through, you get the idea. That is good and I cannot say that about any book. So, it is sort of a boring and dry textbook, not an exciting fiction. But it works.