Struts, Spring, Tapestry, oh my!

Erich Pletsch erich at
Wed Aug 10 17:58:00 MDT 2005


If you prefer simple, but have a bunch of Java developers at your 
disposal, consider JSF.

JSF is a relatively new standard that is being highly touted by Sun 
Microsystems.  They hired the creators of Struts to create the JSF 
standard and to help write the reference framework.  Please note that 
JSF is a standard, not a framework, and that several competing 
implementations of JSF are available.  Sun's JSF implementation is Open 
Source, as is "my faces" (see SourceForge), but Oracle's ADF faces is 
not and requires licensing.

The idea behind JSF is to take the pain out of creating the view 
component of the ever popular MVC framework and binding it to the 
model.  Struts focuses on the controller, JSF has a controller that is 
very similar to the struts controller (after all it was created by the 
same programmers) but it also has the view components that struts is 
missing - an easy to use tag library that ties the view component to the 
model and controller seamlessly. 

Six months ago JSF was relatively unknown and was not worth much because 
it was very shallow (in terms of components and support).  However, IDEs 
for JSF have come a long way (especially Sun's new beta version of Java 
Studio Creator and Oracle's ADF IDE).  And, the result is that adoption 
is gaining momentum very rapidly.  The latest version of Sun's reference 
implementation even has AJAX enabled components!

Why is JSF gaining so much momentum right now?  Three big reasons:
1.  Java has long needed an easy to use web framework (like ruby on 
rails) that still allows for a complex and independent back end (model) 
and JSF is starting to fit that description very well.
2.  JSF extends the "write once run anywhere" mentality to web apps.  
The UI components are designed to be smart enough to render for multiple 
device types without the need for a rewrite or customization-devices 
meaning regular browsers, wireless devices, etc.
3.  Several IDEs are already available which write the XML structures 
for you and allow you to do WYSIWYG page layout.

Now, if you choose to use JSF, I would suggest using an IDE.  
Programming JSF by hand is just as painful as programming Struts by 
hand.  However, just because you can ignore the internals doesn't mean 
that you should!  As with everything else, you will get the best results 
after you learn about what you're doing.  Learning how to manipulate the 
back end by hand is an important step to understanding how JSF works and 
also to learn about it's many very powerful features.  If you just 
WYSIWYG everything, you'll never have more than a basic understanding of 
the potential that JSF provides.

Which IDE to use?  Well, I've had my programming team try four and this 
is what we decided:
1.  First we tried Java Studio Creator version 1.  It worked o.k., but 
it didn't have all the components we wanted.
2.  We looked at Oracle's JDeveloper which has a lot of great components 
(but realized that you have to license the ADF objects if you aren't 
running it on OAS so we dumped it)
3.  We used an eclipse plug in.  It did the XML stuff o.k., but it 
didn't have WYSIWYG page editing.
4.  A few weeks ago Sun announced Studio Creator 2 in beta.  So we 
switched and has been a lot better.

Studio Creator 2 beta is a huge memory hog, and it's a little sluggish 
at times (hopefully they fix that before they release it).  However, 
it's worth it.  Studio Creator version 2 has almost 3 times as many 
components as the first version (including AJAX components), it can 
effectively recognize manual changes to the XML files that drive the 
application, it supports refactoring, It has support for web services 
and it's based on the new NetBeans IDE so it's actually fairly easy to use.

If you'd like to learn more about JSF, you might attend the UJUG next 
time they meet ( and talk to some other people who 
are using JSF.  You might also visit JSFCentral (a site dedicated to 
JSF) at or Sun's Java Studio Creator (Version 
1) tutorial site at

Whatever you do, pick something and stick with it for a while.  Don't 
change course mid development.

Good luck!


Kimball Larsen wrote:

> On Aug 10, 2005, at 4:23 PM, Jonathan Ellis wrote:
>> On Wed, 10 Aug 2005 15:29:50 -0600, "Bryan Sant"  <bryan.sant at>
>> said:
>>> You need to use XDoclet or Java 5 annotations.  You only maintain  Java
>>> source files (who happen to have to struts config embedded).  It
>>> really is simple.
>> Mostly for my own amusement, I'd like to take this space to note
>> parenthetically how vastly different the J2EE community's  definition of
>> "simple" is from mine. :)
> heh.  I prefer simple simple, not j2EE simple any day.
> So, it appears most of the plug is divided - java vs. other goop.
> I have a lot of java experience.
> I have some other goop experience.
> Besides denouncing and pointing out the failings of the various java  
> based approaches, what merits are there to something like ruby on rails?
> I'm not forced into anything yet, but my dev team is comprised  
> completely of java coders for now.  What sorts of learning curve can  
> they expect in moving to something like Ruby?  If they quit/get fired/ 
> hit by a truck, how hard will it be to find someone proficient in  
> Ruby to replace them?
> -- Kimball .-----------------------------------.
> | This has been a P.L.U.G. mailing. |
> |      Don't Fear the Penguin.      |
> |  IRC: #utah at   |
> `-----------------------------------'

More information about the PLUG mailing list