JSF vs Stripes, which is better?

Question

Which is best, or, in other words, easiest to use? Bands or JSF.

Although I did not use both in anger, I need to evaluate what works best for launching new projects and transforming existing Struts projects.

I have a fear that the JSF will not look as good as I want, but what are others worried about? Stripes seems to be much more straightforward, am I correct in this assumption?

Answer 1

Which is best, or, in other words, easiest to use? Bands or JSF.

What's better? Well, Stripes and JSF are different. The first is an action-based structure (e.g., Struts), and the later is component-based (e.g., Wicket). So the answer will depend on your experience and knowledge of the action-based flow and the component-based hierarchy, and both have their own strengths and weaknesses. Which one is the easiest? Stripes, no doubt about it.

What I like about Stripes:

• It is simple and easy, i.e. has a low learning curve.
• I like his setup agreement.
• It is light weight.
• This is well documented (and you don’t need a ton of documentation because of its simplicity).
• It has a small but responsive community (you will receive answers to the mailing lists ).

If you are new to myself, I would go for Stripes. If you want to learn the basics of component-based, I think it’s easier to start with Wicket (also see what Gavin King says How to start learning Java EE 6 ).

Answer 2

JSF does not have a good press, and a bad reputation is unfortunately justified (another missed opportunity of the late Sun Microsystems). But BUT has changed a lot since the question was asked - a new version of JSF 2.0 was released.

So what happened to JSF 1.X, which made him think in comparison with Stripes, Spring MVC or Wicket, Play, Click, etc.?

• Only POST requests were supported, which caused performance problems (GET requests can be cached efficiently), it’s hard to get bookmarks and other URLs
• JSF 1.X was based on JSP pages that were not suitable for handling the more complex JSF page life cycle.
• Component creation was complex and cumbersome.
• The definition of navigation rules was far from flexible and very detailed.
• Mandatory XML configuration
• There is no clean resource management method

It’s good that all these shortcomings were resolved by the new version of JSF.

• GET and POST requests are equally well supported.
• Configuration can be done using annotations (we can stick with XML, where is the best solution), definitions of navigation rules are simplified, we can even use a customization convention.
• Creating components is very simple.
• New and very useful areas have appeared: the scope and flash memory (similar to what is known from Ruby on Rails), which allow users to handle more complex threads.
• There is a standard resource management method and an improved error handling mechanism.
• We can define the stages of a project to simplify project management in various environments (testing, production, etc.).
• XHTML-based Facelets have replaced JSP as the best alternative to view definition
• Support for embedded AJAX requests
• JSF is part of the Java EE standard, which means they are not going to fade overnight if bored developers decide to move on to the next brilliant and more fashionable structure.

And last, a huge advantage of JSF 2.X: tones of well-designed, great looking and well-prepared components (RichFaces, PrimeFaces, ICEFaces). These libraries provide hundreds of commonly used pages on WWW pages that are accessible without writing a single line of JavaScript or CSS. This is a huge increase in productivity.

However, JSF may have performance issues compared to action-based frames such as Stripes, which work more closely with HTTP requests without building a component model (which uses more memory, more network bandwidth).

But for an application that should not be extremely efficient, JSF 2.0 is a very good and rational choice. The learning curve is no longer as steep as it is plus the ability to reuse existing components makes it really attractive. Looking from this point of view, stripes are not so attractive.

So, for example, for a corporate intranet application used by 2,000 employees, JSF 2.0 would be a great choice.

Answer 3

Best web framework? How often does this question lead to the answer "it depends."

Another question: "what is the easiest way to use in the framework." Easier to answer that Strip. JSF has the infamous steep learning curve. Strips, on the other hand, are easy to set up and easy to learn.

The Stripes frame is similar to the Struts, but only better. For example , it uses annotations instead of XML configuration files. Just like the Struts framework, this is an action-based framework, only more elegant. This means that it closely monitors the nature of stateless HTTP event processing. This is good if you want high performance and maximum flexibility in how your pages are generated.

A structure like JSF is not an action-based structure, but a component-based foundation. This means that it moves the abstraction layer between HTTP and your application. This layer allows you to program JSF applications as if you were programming a Swing application. Thus, JSF basically handles the paradigm mismatch between the component model and the idle HTTP lifecycle. However, this level of abstraction will cost some work; it will also give you a slightly lower degree of control over the generated HTML.

Answer 4

jsf is much more used, so you need to have better support if something strange happens. There are enough reasons for using it.

Answer 5

I would use JSF. It is used much more widely and iceFaces is a very convenient package for JSF-based applications.

Answer 6

JSF is part of Java EE 6+. This means that it will be available and maintained for a very long time, which is important for us.

Various implementations may also arise that will allow you to choose the best for this purpose.

Answer 7

Seam is a good JSF application development stack, not sure about Stipes.

• Conversion
• Nice ajax support
• Rich set of components
• XML configuration annotations

One thing I don't like about JSF is the learning curve, especially if you are new to JSF.

Answer 8

Stripes like Struts don't really do much for your application. In addition to elementary routing and filling out forms and performing actions, it does practically nothing. The last time I checked most (all) of the bands, the tags are mostly facets for the equivalent html tag with little or no extras. This suggests that JSF provides more, but if you need real technology that didn't get stuck in 2000, consider GWT.