Java EE 6 Development with NetBeans 7

One Minute Bottom Line

Introduction to version 6 of Java EE development and how it can be boosted with the latest version of the NetBeans IDE. The tight integration of the new features of the platform (JPA, CDI, etc.) is shown in a fast pace, yet not with the lack of necessary detail.

Review

Some time ago I stumbled upon this interview via Twitter, and I thought: “Wow! At last a book that deserves serious attention.” At that time, I didn't know this is some kind of second edition with the most recent versions of the Java EE platform and the IDE in mind. I never had a chance to see the first book, but thanks to PACKT Publishing I had the chance to go through this one in whole.

As many similar books in the IT industry, this one is focused on certain massively adopted technology and one of the major tools that helps you be productive with it. Although seemingly narrow in its thematic, in its own right this writing is a little masterpiece. Every book has a goal, and this one has achieved it with such ease.

In short this is very fine balanced and fast paced introduction to the world of creating enterprise Java applications. Reading it (actually working through it) feels better than going through a set of cleverly compiled video tutorials. Better, because the book gives you a significant bit more than that.

The contents of the book are well structured and although it starts with presenting the powers and sweet spots of the NetBeans IDE, it generally dedicated to the Java EE 6 SDK features. It follows these features along with giving direct connection to their integration in the IDE. I have some experience with the enterprise Java, but I'm always happy to read some more good explanations of the technology. Here you have a lot of them.

• The really slim introduction to building Java Server Faces applications in chapter 4, complemented with the equally small example of PrimeFaces component library integration into NetBeans in chapter 5.

• The more extensive and full with code snippets explanations of the Java Persistence API in chapter 6. Here is one of my personal favorites – NetBeans is quite good in prototyping JSF applications through the JPA. That's possible and much easier thanks to the out-of-the-box Java BD integration. Even this chapter alone is a cornerstone tutorial on JPA with NetBeans.

• The hyped new feature of Java EE 6, Context Dependency Injection, is covered in chapter 8. It represents almost seamless transition between the two chapters that discuss the integration of the two types of Enterprise JavaBeans left in the version 3.0 of the EJB specification – the Session and the Message-Driven ones. In these chapters you can see how ready NetBeans is for aspect-oriented development and how trivial can become creation of the code for JMS messaging enterprise applications.

• The SOAP and RESTful web services implementations are explained through their current APIs (JAX-WS and JAX-RS correspondingly) in the last two chapters. Again – lots of code generation by the IDE (including for WS clients), and especially for the web services it has a comfortable graphical designer.

Every given wizard is complemented not only with descriptions of its fields, why do you need them and what's the right thing to put in them. Beyond the bare minimum, you can find really helpful background information for the underlying technology. And once the intricacies of the API at hand were cleared, you are given the feeling that NetBeans really helps you in the best way to apply that API as soon as possible to your code.

What I really miss in this book is a bit more in-depth NetBeans. I think the author really had to show some template extension through the Template Manager. You know, when you open the standard file templates in an editor and modify them to be closer to your needs every time you create new files. After all NetBeans itself is designed to encourage you for this.

Another core thing I didn't see here is the ability for making custom palettes with the Palette Manager. There is an extensive chapter-wide explanation of using the built in ones (even for the almost obsolete SQL JSP tags), but you haven't been shown the way to make your own palette from a library of your choice. Actually the Palette Manager is designed to help you create palettes for desktop components (Swing, etc.) and these are out of the scope of this book. But previously I've seen a plugin that creates palette for the IceFaces JSF components. Code completion for custom tags rocks, but the ability to create a palette for them at least deserves mentioning.

I think these both “missing” parts could form a nice, small Appendix C, besides the ones for Enterprise Applications Debugging and for the NetBeans Profiler (the IDE's integrated tool for code performance fine-tuning). But on the other hand (despite my wish), if the book was a little more dedicated to NetBeans than to Java EE 6, this would be a distraction from its focus and maybe it wouldn't achieve its primary goal so well.

All in all the book is great, because it's true to its purpose. I will definitely use it as a first class reference along with the knowledge base gathered at the site of the NetBeans IDE. And I'm sure that for the next major versions of the both technologies, we'll be well covered.