Customer Reviews

Seam in Action

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

 

 

I'll be honest. I reviewed this book for Manning before it came out. Look at the back cover. There I am. I cannot stress this enough. If you want to learn Seam (and if you're building web applications, you want to learn Seam), you should buy this book. I reviewed it because I work with Seam daily, on multiple projects. From simple Crud stuff to trading systems. I do not lie in my quote on the back cover. I learned a lot of stuff reviewing this book. I have read all the other Seam books out there, at least up to the time I reviewed this one. Other books are good, and I won't get into specific comparisons, but I learned a lot reviewing this one. However, its well organized, so if you know nothing, you'll be able to learn it from this book. So, you know, buy it.

FYI I was not paid to review the book, and will certainly get nothing if you buy it.

It's clear a lot of work went into this book. But even so, the result isn't very useful. A quick run-down of the pros and cons...

Pros
1. Broad coverage of Seam features. It's clear that Allen knows his stuff.
2. Lots of background information, explaining motivations and reasoning for Seam design

Cons
1. This book was written entirely for people who already know JSF and Facelets. If you want to know how to program a view template in JSF/Facelets/Seam, this book won't help. There's one chapter on Ajax, but it's light on the view layer and instead focuses on integration with Seam's component model. There's also a chapter on file uploading, PDF's, charting, and email support, but once again there's nothing on the basics of using JSF and Seam together in the view layer.

The author does a good job of discussing JSF's lifecycle shortcomings, and also explains how Seam fills those gaps. That's pretty good information, but it's really just theory, and shouldn't require a whole chapter.

2. The chapters on persistence are disorganized and very confusing. There's no single clear explanation of what's needed to configure persistence in Seam. I was hoping for a short narrative on what it would take to bootstrap a real-world application, including JPA's persistence.xml, Seam's components.xml, Hibernate's hibernate-cfg.xml, and all the settings needed to integrate with JBoss, all in one place. But that's not in the book. Instead the author spreads the explanation over three chapters, filling in with lots and lots of background theory. You're left having to read and absorb the whole book before you can write the most basic real-world application. And even then, things are so spread out that it's very, very difficult putting it all together and making it work. And unfortunately, the theory stuff just isn't that helpful, at least not to someone new to Seam who needs to get up and running quickly.

If you already have a solid understanding of JPA, JTA, and JBoss, you'll probably learn something useful, but if you're new to JPA and JBoss (like myself), you'll probably be more frustrated than anything.

3. The persistence chapters are also a bit schizophrenic when it comes to JPA vs. Hibernate. There's a section explaining framework's advantages, but it's rather small (which is interesting, considering how much the author likes theoretical discussion). More confusingly, the author tries to explain both Seam's integration with JPA and Hibernate all at the same time. You get a brief section on JPA, followed by a brief section on Hibernate, followed by another brief section on JPA, etc. It winds up being very scattered. It would have been better for the author to start with the basics of Seam persistence, and then explain Seam/JPA integration in full, followed by Seam/Hibernate integration in full.

Also, there's only the briefest mention of other JPA providers (e.g. TopLink, OpenJPA), and no discussion of how to integrate them.

4. There are two chapters missing from the book that must be downloaded as PDF: Chapter 14 covers JBPM, and chapter 15 covers Spring integration. They're not listed in the TOC, nor are they mentioned in the introduction. But the author refers to them throughout the book. And as it turns out, JBPM plays a rather significant role in Seam.

The JBPM chapter is in fact one of the reasons I bought the book, since there's very little good documentation online. I think it's rather flaky that the publisher left this chapter out of the book without mentioning it on the cover.

Overall, I give the book two stars because it contains a lot of good information. But no more, because there's important information missing, and because much of the information is lost in disorganization or non-practical theorizing.

There's a line in Appendix A that crystallizes my reaction to the book. The author writes on page 557, "Second to this book (sorry, I'm biased), the best resource you have for using Seam is the Seam reference documentation, which weighs in at 500-plus pages." As it turns out, I find that I completely prefer the online Seam documentation to this book, even though the online docs are lacking in many regards. I also find it rather ironic that, when the author wrote the above line, he was unaware that his own book would also weigh in "at 500-plus pages."

I'm very much wishing I hadn't invested $45 and several hours in this book. It's now parked on my shelf, and I doubt I'll be using it much in the future.

Not too many months ago, I was evaluating a number of Java frameworks for a project I was starting. One of those frameworks was JBoss Seam. Seam brings together J2EE technologies such as Enterprise Java Beans 3.0, Java Server Faces, POJOs, and a wealth of rich web components.

Many of us are familiar with the "In Action" series of books from Manning. They are quite simply some of the most highly respected technology books available. I purchased this book knowing the kind of quality I could expect, and I wasn't let down. The presentation and quality of the material was as I expected. Some of the key areas of focus were those that are most important in Seam; the Seam life cycle, inversion of control, state management, persistence, and transactions. Obviously many of these topics exist outside of Seam but what the Seam framework does is provide added features for these key items. The book focuses heavily on each and really drills into the improvements made.

I've done a lot of scrounging around the web for tutorials, guides, and articles about Seam. This book is far and away the best resource I've found. Everything else has been a mere reference. If you are like me, and want a real resource on the topic, you'll be happy with this purchase.

A seam is a joining of 2 things, like 2 fabrics for example. But for 3 years now, it has had another meaning for developers since it also refers to a framework. It is a rather new framework, the 1.0.0 Beta version was released in September 2005, the project leader was Gavin King (one of the creators of Hibernate), it uses JSF and EJB 3, and so it is with some big interest and curiosity that i read this book. The author, Dan Allen, knows what he is talking about since he is a committer on the project. We learn that the term Seam was chosen to refer to the work put on to facilitate the collaboration between JSF and EJB 3. JBoss Seam applications may run on Websphere, Weblogic, Tomcat. The book has a practical approach since it is based on an application centered on the game of golf (Open 18), to illustrate the features of Seam. The book is divided into 4 parts.

In the 1st part (chapters 1, 2), the seam-gen tool is explained and used from the beginning to set up the development environment, using a Hypersonic H2 database.

In the 2nd part (chapters 3, 4, 5, 6), the author explains what Seam brings to JSF, correcting some defects, such as a verbose XML file (faces-config.xml), by removing the <managed-bean> tags from the file. With Seam it is possible to define the backed beans in an XML file. The life cycle of JSF with Seam is also detailed to explain the advantages of Seam. Chapter 4 introduces the components, its related annotations (@Name, @Scope ...), the life cycle of components, etc. In chapter 5, the tags of the configuration file components.xml (the alternative to annotations) are explained in details. Chapter 6 is about interceptors and the concept of bijection (= injection + outjection, with annotations @In, @Out) by introducing the new term outjection which refers to the possibility of injecting the property of a component into a context variable, which can be re-used inside another component, a JSF view ... With bijection, the values are injected from context variables when the component is called and injected again into the context variables. A clear distinction is made between static injection (the value is injected when the component instance is created) and dynamic injection (the value is injected when a method on the component is executed).

In the 3rd part (chapters 7, 8, 9, 10), an entire chapter (chapter 7) is dedicated to the Conversation scope, one of the 2 scopes/contexts introduced by Seam (the other scope being business process, which is longer than the session), as an addition to the 4 classic scopes which are Request, Page, Session, Application. This scope ties together individual requests. So the 6 scopes ordered by ascending scope are : Request (event), Page, Conversation, Session, Business Process, Application. The term of conversation, page flows and related annotations (@Begin, @Conversational, @End, etc) are systematically and largely explained with code snippets around the Open 18 application. Chapter 8 is a necessary reminder of JPA and Hibernate. I have particularly liked the quick presentation on extended persistence context and the differences between these 2 APIs because it is well explained. The next chapter is about the persistence and the transactions with Seam, in particular within the conversation, and is largely illustrated with code snippets. Chapter 10 explains the Seam Application Framework with an exercise.

In the 4th part (chapters 11, 12, 13), we learn that Seam relies on JAAS for authentication (chapter 11). A sample with a JSF login page form is used. A clear distinction is made between role-based authorizations and rule-based authorisations. The rules engine Drools (the name Drools is derived from the term "dynamic rules") is explained and used to create the rules. A quick sample of use of the org.jboss.seam.captcha component to display CAPTCHA inside a web page is explained. AJAX and existing solutions (Ajax4jsf, ICEfaces, GWT ...) are empasized in chapter 12. Finally, chapter 13 introduces a few Seam components such as <s:fileUpload> to upload files from a JSF form, <s:graphicImage> for the dynamic rendering of images, UI components to generate PDF files using facelets templates, but also the Seam module for graphic generation based on JFreeChart, composing email with a Seam component mail etc

What I liked about this book : The author's tone. It makes you feel like you are attending a live presentation on Seam, the author spends a lot of time introducing things, weighs the pros and the cons of existing solutions and then explains how Seam can be a possible solution. I also liked the golf theme, omnipresent, and instructive ;-)

What I liked the least in this book :The referring to an older version of JBoss AS : 4.2 instead of 5 (Java EE 5)

The source code of the book is of course available on the book's website, along with 2 extra chapters in PDF format regarding the integration with Spring and the use of business process (jBPM) : http://www.manning.com/dallen/

The author's website : http://www.mojavelinux.com/ An errata is also available at http://www.manning.com/dallen/excerpt_errata.html

Finally, the code source of the book is also available at : http://code.google.com/p/seaminaction/

Pros:

1. A lot of information is covered.
2. Makes an attempt to get the developer going.
3. In action books are generally very thorough and so is this one.

Cons:

1. Some of the metaphors and comparison to Spring are very distracting. I found the tone very annoying sometimes.
2. Seems to have been written to accentuate the selling point of SEAM and not to provide a meaningful introduction to the framework along with the potential pitfalls.
3. The text is very terse and the approach is to cover every thing at once rather than presenting topics in a broken down fashion keeping real life concerns in mind.

This book is written for J2EE experts and not mid-level developers like myself.
I had to learn SEAM in a matter of weeks and for that this book was only OK. I had to refer to other sources to get going quickly and to begin to understand the real implications of using SEAM, even as it continues to evolve.

That said, I have never written a book, so kudos to the author and I am generally a fan of In Action books. I would recommend that in the future that you include more visual depictions of concepts and you cover the pitfalls of using SEAM or any other framework that you may write about.

I like in action books so much because they always give you enough hands-on experience. But this book is not even I am an experienced J2EE web application developer. The author try to sell you everything from beginning but forget learning curve for a new comer. A good book should organize chapters from basic to advance and no one wants to know how to repair a car before he can drive a car.

Seam is a technology to fill the gap of j2ee not a core technology itself. The ideal number of pages of this book may be 400 pages instead of 600 pages.

But, I believe this is a good handbook for developers who already practiced a little bit in their projects. It does provide a deep understanding of SEAM.

I am completely new to Seam and I found this book to be really helpful.

Just browsing the seamgen section convinced me and the rest of the chapters are also top quality.
The level of technical detail is appropriate and the examples help you understand the concepts discussed.
Highly recommended!

If you're looking to learn Seam, it doesn't get any better than this book. Even if you already know Seam it works very well as a reference. Dan has gone to extreme lengths to make this the best Seam book (excluding the Seam Reference docs) out there (he also talks about some of the Seam 2.1 features).

All of the source code is available as well [...] There are also some bonus chapters on his site at Manning as well [...]. You can also see the links that he has compiled also [...]

As I said, Dan has gone to great lengths to make this the best it can be. You'll find his code easy to follow, the examples concise, and his humor refreshing. Again, very excellent read and a necessary book to own if you are doing Seam work.

Seam in Action begins with a slow introduction and an explanation why Seam is different and why Seam is important, especially in an ocean of web frameworks. The book's difficulty then increases slowly from showing how to set up the basic web applications quickly using seam-gen and reverse engineering to how to manage stateful page transition processes, Ajax, and transaction management.

Even at the most difficult concepts like conversations, rule-engine development, and Spring integration this book does a great job delineating the topic so that you as the reader can fully understand what you need.

This book is so well researched, you will likely consider it the complete guide to Seam, and will continue to use it as a reference long after reading it.

I am still in the process of reading this book. Maybe once I am finished (if I get that far), I'll change my mind.

The book is quite painful to read. I am coming from a non JSF background, having spent the last year programming with Spring and Webflow. The author has spent much of his time talking about the problems with JSF and how Seam "fixes" them. Not coming from a JSF background, I am not interested in a very detailed and long winded discussion about the problems with JSF.

If there are so many problems with JSF, why use it at all? JSF seems to be another embarrassment for Java along the lines of EJB pre version 3. Why not wait until Sun "gets it right" in JSF v 3?

Another frustration with the book is the reliance on using XHTML in place of JSP. It would have been nice if JSP versions of the views were presented in addition to the XHTML versions. I do not find the XHTML easier to read.