Customer Reviews

Beginning Java EE 6 with GlassFish 3 (Expert's Voice in Java Technology)

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

 

 

As a long time server side Java developer who has generally steered clear of the J(2)EE standard stack of EJB, JPA and JSF, in favor of Spring, Hibernate and Struts, I nevertheless wanted to take a look at the promise of the emerging Java EE 6 improvements. My goal was to evaluate whether EJB in conjunction with JPA persistence can be developed in a style that I have grown accustomed using Spring and Hibernate. Is it possible to maximize testing and debugging activities outside the EE container with version 6?

The answer to that question for me is mixed, but Beginning Java EE 6 with GlassFish came through in helping me make the evaluation. I didn't need a soup to nuts definitive guide, but a book with some breadth to be able to evaluate the platform without having to become an expert in the process. It provides enough material in each major subject area to get a simple but non-trivial example program running. In fact the chapters on JPA are fairly comprehensive and could be a nearly complete reference for building out a small to medium admin interface for a database.

It is definitely a "Beginning" book for seasoned EJB and JSF developers, as they will likely not find enough new material to warrant purchasing the book. I would not say this book is appropriate for programming beginners in general, or even experienced programmers migrating to server side Java for the first time. (Perhaps 'Introducing' in place of 'Beginning' would have conveyed this better). It can be daunting to simply set up the requisite software packages before you can create your first entity class or session bean. Author Antonio Goncalves does an excellent job outlining the necessary setup steps, and doesn't leave out important aspects, such as assuming the reader already has the JDK installed. You will likely have to consult other resources to complete the set up of your environment, but that's to be expected in today's multi-layered and polyglot programming paradigms.

In the past I have often shied away from Novice to Professional Apress titles, because they often are padded with screen shots and unabridged XML configuration. Goncalves sprinkles in a few screens showing the set up of glassfish, and throughout the book, the example code snippets are concise but complete enough to illustrate the narrative.

A very key piece of technology used throughout the book that is not specified by JEE 6, nor is part of GlassFish, is the use of Maven. As an experienced Maven user, this was a significant advantage for me. I'm not sure how much of a distraction this will be for the many developers with no Maven experience, who want to get up to speed quickly. Using Maven meant the book does not have to devote any space on setting up an IDE, but the reader will be on his own to figure out how to import the mavenized sample code into an IDE.

As for the sample code, the source code is available for download on Apress. It is solid code until chapter 13, 14 and 15. I encountered compilation errors for these chapters' samples, which leaves the impression that not enough time and effort was expended to do justice to the topics of JMS, Web Services and REST.

If I have one important critique of the book (and perhaps it's really a critique of EJB/GlassFish) is that the JUnit tests utilizing embedded GlassFish do not work. This problem lead me to the mixed review I alluded to in evaluating EJB 3.1. My current perception (which may or may not accurately reflect reality) is that testability of EJB is still not up to the level I expect, given my experiences using Spring over the last five years. I doubt this situation is the fault of the author of this book, but not enough discussion was devoted to describing the complexities of running GlassFish in embedded mode, even (or especially) for an introductory level book.

Overall, Beginning Java EE 6 with GlassFish accomplishes its mission, and I can recommend the book for a senior developer or architect doing technology evaluations or other developers needing to get up and running quickly.

The book is nice to read but don't try to follow the examples! They just don't work and you will end up spending a lot of time debugging them (maybe, that is the hidden underlying concept of the book). I made it to chapter six and then gave up ...

I used to develop web applications 7+ years ago with servlets and JSP, but a great deal of improvements have made the technologies much easier to work with so I wanted to take another crack at it. This book was easy to read (very difficult to put it down until I finished it) and covered many of the Java EE 6 technologies I want to learn. The JPA coverage for ORM was quite comprehensive. However, I was surprised the glue of Java EE 6 (CDI) is missing appropriate coverage in the book. I've been using it as a starter book that gets me familiar with the technologies, and then I've been using other books that dig deeper in each of the technologies to help me understand it better.

I've heard the source code doesn't work and it doesn't use CDI, so I've steered away from trying out the examples. If CDI had been covered and the examples worked, I'd have easily given this five stars.

This book covers a wide range of topics (which it should since the title says Java EE 6). There are several first edition font, size, and style mistakes but that's for super picky readers. This is one of those few technical books that you can't set down because it introduces new information at a rapid but not overloading pace. I haven't finished reading the book but so far I have high hopes for the rest of its content.

This book should have been called "Java EE 6 Platform Overview with GlassFish3".

Perfect book to get an easy introduction to Java EE 6 (and all this at a pretty decent level).

I would also recomend it for an architect evaluating the platform.

This is indeed a very good book - which does a superb job of coverage - since Java EE6 by itself has a lot of things to add to.

The book does a very good job of introducing the subject and the changes made to JavaEE6, differences with respect to the prior version.

It has a chapter almost on each and every topic and the contents of each chapter are well organized, written with the right level of granularity - so that a newbie / experienced person would have no difficulty in understanding the concepts and the thoughts the writer is expressing.

Each chapter has examples that weaves together the concepts introduced / covered in the chapter.

Each chapter does a good coverage of - details related to that topic with right examples and right text and most cases the right pictures.

Overall this is a very good book both for beginners into JavaEE6 world or for anyone to understand what JavaEE6 is all about and the changes and new things added to it from JavaEE5

I already read a couple of books about GlassFish 3 and hence was having doubts about Antonio Goncalves's "Beginning Java EE 6 Platform with GlassFish 3, 2nd Edition" from Apress. It's quite common to find books with great, ambitious titles that fall short which further cast doubt on the book. That's why I was deeply worried that the title, with Java EE 6 included, was a sort of a trick to bring more eyes to the book. On the other hand, I was really keen on reading a book about Java EE 6 with all its bells and whistles detailed, but didn't really care about GlassFish.

To make things more complicated, I picked it up right after having finished another book that was written with a slightly more eye-pleasant font. When I saw these squeezed sentences in every chapter's opening section, my first reaction was to not come back to it until I'd really have to. At the long last, with no other books about Java EE 6 on my bookshelf, I had no choice as to have encouraged myself to give it a try regardless of the pain I was suffering from.

I finally began the reading. I promised myself not to have spent much time with the chapters I didn't like. The reading trail started off with the very beginning of the book up to and including the chapter 1 "Java EE 6 at a glance", skipped the chapters 2-5 about Java Persistence (since I had already read an entire book devoted to the topic - "Pro JPA 2: Mastering the Java Persistence API" from Apress), jumped into the reading of the chapters 6-9 about EJB 3.1, skipped the chapters 10-12 about JavaServer Faces (JSF) 2.0 and carried on the reading through the chapter 13 about JMS and EJB MDB, the chapter 14 about JAX-WS and JAXB, the chapter 15 JAX-RS to eventually have come back to the chapters 10-12 about JSF2. It turned out that I left aside the JPA chapters 2-5, but I'm more convinced to do so now.

The chapters were written with a lot of care for right amount of information that's relevant to let me appreciate warm feeling of becoming a Java EE 6 pro or a sort of.

What I missed in the book was hardly any information about the Contexts and Dependency Injection (CDI) specification. In the Preface I could read - "The book concentrates on the most important specifications" which I strongly believe CDI is part of and it would've accounted for its inclusion. I hoped to have found a chapter or more about the specification, but sadly found nothing. That's a huge deficiency of the book that bears the title comprised of "Java EE 6" and "professional".

Despite the lack of CDI coverage, I'm greatly satisfied with the book - it was a kind of a transcript of a presentation about Java EE 6 with Antonio on a scene. While reading the book, I often felt like listening to a seminar about Java EE 6. Each and every chapter encouraged to keep reading. I found every piece of information I really needed (with no CDI whatsoever).

With the other assignments I made every step not to spend much time on the reading. The chapters were concise and the writing style invited for one more chapter at the time. Therefore, I wouldn't consider the Foreword a foreword for the book as it didn't take on the value of the book, but merely Java EE 6 itself. I quite often experienced an entertaining moment where I questioned the explanation and accompanying code snippet to eventually have found that it was done on purpose - people who pay attention to detail may get surprised nicely quite often. The book didn't spend much time on less important bits and moved from a topic to another with non-trivial code samples.

As I'm at the writing style, it wouldn't be fair to refrain from mentioning the English language used in the book - it's utterly perfect and I learnt a lot! Whoever helped Antonio with his English put a lot of effort in the final outcome. It's very tempting to keep on reading just because the way as well as the language the subject was presented with. I wish I could read more books like this.

The book was based on GlassFish 3.0.1, Apache Maven 2.2.1 and JUnit 4.8, so people interested in their practical use may find it helpful to some degree. Don't expect much of it, but enough to get started and be able to follow the samples. Even though I wasn't so much interested in reading about these tools (which I considered well-known to me and hence was about to have skipped the sections) I managed to find a couple of useful tips that influenced my toolbox - a nice pay-off for keeping up.

I really wished the author had explained his decisions with the tools and the technologies so I wouldn't have been left wondering about the reasons - too less why's over how's. Too extensive explanation of the way Maven works and the general idea of using the tools in the beginning of the chapter 6 almost put me off reading any further (esp. in "Compiling and Packaging with Maven"), but after the slight hiccup the reading got more pleasant and steady. I think I might eventually have got used to it and paid no attention to it any more.

I run across a couple of typos in the text as well as the code snippets, but I think they almost harmless since they're easy to spot and fix. A sort of an exercise for the readers.

It saves your time by focusing on the key features of each implied technology. It is a great book!