Last week IceFaces has released its new version 2.0.0. It was long been in the beta version and finally came out to final version. In the release notes it is specified as "JSPs are not supported by ICEfaces 2.0 - use Facelets". What does that mean?. Are we not suppose to write any JSP's?. What about the existing projects running on JSP files.
Please advise me.
It's not that IceFaces specifically doesn't support JSPs. It's the fact that IceFaces 2.0.0 is based on JSF 2.0 and it takes advantage of a couple of JSF 2.0 specific features.
A lot of the new JSF 2.0 specific features are simply not supported in JSP. So if any technology depends on those features, it automatically doesn't support JSP. (this is one reason why it's so important for legacy JSF projects to migrate from JSP to Facelets ASAP).
I put some references to authoritative sources on the wikepedia article about Facelets (http://en.wikipedia.org/wiki/Facelets). This is the one from the official specification (emphasis mine).
JSF 2.0 (JSR 314, http://jcp.org/en/jsr/detail?id=314) specification, maintenance release 2, section 10.1:
Facelets is a replacement for JSP that was designed from the outset with JSF in mind. New features introduced in version 2 and later are only exposed to page authors using Facelets. JSP is retained for backwards compatibility.
From JSF 2.0, Facelets is the official view technology. Even if JSP is supported it will be minimal. Read more here
Related
I'm trying to move our application from an old JSF 2.2 version to JSF 3.0 (part of the Jakarta EE 9 platform). In the transition we want to replace the Mojarra implementation of JSF and want to replace it with the standard jakarta.faces-api. In the past we used explicit implementaions of JSF, servlet and other technologies, part of the Java EE specification. Now we want to use the standard-api approach.
I have a problem with a class that don't exist in the standard api but in the Mojarra implementation of JSF, the AbstractTagLibrary.
We use a Websphere-Liberty in the newest version, so with activated JSF features the application useses MyFaces.
What i tried so far was to replace the AbractTagLibrary with an own implementation. Bot i got an error that AbractTagLibrary should be of type org.apache.myfaces.view.facelets.tag.AbractTagLibrary.
The AbractTagLibrary is used to create custom EL functions. Like in this article.
My question is, how can i replace the AbstractTagLibrary with the standard jsf-api approach? Is there a good way to approach such a problem?
As BalusC said in his comment, the approach is JSF 1.x minded and can be solved by a JSF 2.0 approach explained here: https://stackoverflow.com/a/7080174.
Hi I have an application that needs to be migrated from jsf1.1 to jsf2.0. I have read the answers posted in Migrating from JSF 1.2 to JSF 2.0 by BalusC.
I have thought not to go ahead converting JSP to facelets.Retain the JSP2.x as the view technology.
I would request someone to clarify couple of my doubts.
As a part of migrating the custom components is it a must to create a new custom-taglib.xml file ? Can't I retain .tld files as it is.
Since JSF implementations like JSF 2.0 provides backward compatibility with older versions, Is it necessary to change the custom compoent code, for the deprecated methods and replace it with the appropriate methods from JSF 2.0? because we are not migrating it completely to facelets.
Do I need to create a new taglib.xml file when migrating JSF 1.1 to JSF 2.0 while keeping JSP as view technology?
No. The *.taglib.xml files are for Facelets what *.tld files are for JSP.
When I tried to add <a4j:support> tag to JSF 2.0, I got the following error
Tag Library supports namespace: https://ajax4jsf.dev.java.net/ajax, but no tag was defined for name: support
How is this caused and how can I solve it?
The namespace URI https://ajax4jsf.dev.java.net/ajax is recognizable as the one from Ajax4jsf 1.x which existed in the prehistory, long before Ajax4jsf was acquired by RichFaces 3.x at 2006. Ajax4jsf 1.x is an ancient tag library which was targeted at JSF 1.1 on JSP, long before JSF 2.0 was introduced with builtin ajax functionality.
Even more, currently with JSF 2.0, JSP is deprecated and succeeded by Facelets (which a lot of starters overgeneralize as "XHTML"). JSP targeted tag libraries like Ajax4jsf 1.x are not compatible with Facelets. You basically need a JSF 2.0 compatible tag library instead. If you're looking for Ajax4jsf functionality, then you should be looking for RichFaces 4.x. Note that <a4j:support> has since RichFaces 4.x been renamed to <a4j:ajax> to be in line with JSF 2.0 standard <f:ajax>.
However, as said, JSF 2.0 thus already offers builtin ajax functionality in flavor of <f:ajax>. Given that you're attempting to use Ajax4jsf 1.x on JSF 2.0, you were perhaps reading a hopelessly outdated JSF book/tutorial/resource. I strongly recommend to put that aside and look for a more recent one, preferably not older than 2010 if you want a JSF 2.0 targeted one. You can find several sane tutorials linked somewhere in the bottom of our JSF wiki page.
Good luck.
I have been looking for a JSF extension (Richfaces, IceFaces, and more) but all seem to be according to JSF1.x and ones for JSF2.0 are still alpha or in development and most of the documentation assumes you're using JSF1.2.
Is there any production well known extension available?
RichFaces 3.3.3 is compatible with JSF 2.0. It has however no full JSF 2.0 integration yet.
PrimeFaces 2.0 is already JSF 2.0 ready for months, it was the first to do so.
My opinion would be biased if I say PrimeFaces I guess :) So for real life experiences please see: http://www.primefaces.org/whyprimefaces.html
Even though i spend whole days developing a JSF application, i've never had any training on the matter and I have to admin I am a still confused how the whole JSF puzzle fits together. JSF just looks a bit thrown together to me.
jsf-api
jslt
facelets
myfaces
trinidad
tobago
jsp api
I'd be very grateful if anyone could give me a quick description of these components, which ones are standard, which ones can be left out, which ones can/need to be used together
JSP and JSTL
JSP has undergone many iterations, but this is the core Java EE dynamic page technology. This is a servicable API, but working with JSPs often means more manual management of code/resources.
JSTL is the JSP Standard Template Library. This is a set of standard JSP tags. Do not mix these tags with JSF tags; they belong to a different programming model.
JSF API
The JSF specification. This is the core of the JSF Model-View-Presenter framework. This specifies a simple set of core components and the core lifecycle artefacts. There are two widely known implementations: Mojarra (the open sourced Sun API) and Apache MyFaces. Part of Java EE 5 and above.
Facelets
A view technology designed for JSF. Use this instead of JSPs. You cannot use JSP tags in Facelets views. This is not standard in Java EE 5, but is standardized in JSF2 (and therefore the upcoming Java EE 6). The better templating provided by Facelets often means you can rely less on 3rd party libraries.
Facelets provides some tags that look like JSP JSTL tags, but don't share any code. These tags should generally be avoided too (see Facelets doc for advice).
Apache Trinidad and Tobago
These are JSF libraries that provide components and other facilities. Because the core set of controls is rather basic, it is common to use such libraries, especially if Facelets is not used. These are not part of the Java EE standard. Library compatibility varies. See also jsfmatrix.net.
jsf-api are the interfaces and classes in javax.faces
jstl is a standard set of tags (used primarily in JSP) - most of them are replaced with JSF-tags, btw
facelets is a presentation and templating framework (like jsp)
myfaces is an implementation of the JSF standard. The other possibility if JSF RI (reference implementation)
trinidad and tobago are component libraries - some goodies that aren't included in the default set of jsf components
jsp is the alternative to facelets (or vice versa), which is as well a presentation framework.
UEL - (you didn't ask, but it's important) - Unified Expression Language - the set of rules for your #{..} expressions