JSF Trainers or Consultants?

Hi Guys,
Sorry to post this here, but I need your help very badly.
Can anyone give me the details of JSF Trainers/Consultants, available in and around Bangalore, India
Regards

I bought:
The Complete Reference JavaServer Faces (Schalk/Burns), 2007and
JavaServer Faces in Action (Mann), 2005Personally, I'm not 100% convinced by either of them - certainly not from a beginners perspective.
James.

Similar Messages

ANNOUNCE: Speed up your Data-Driven JSF/Seam Application by Two Orders of

Hello,
I am pleased to announce a new article on JSF Central. In the second installment of this two-part article, Dan Allen continues his discussion of some common performance problems you may encounter when using JSF components, Seam components, and the EL. You'll learn about the set of best practices for eliminating them that led to an improvement of two orders of magnitude in the performance of his application.
Here is an excerpt:
In the first part of this article, I began briefing you on optimizations I made to maximize the responsiveness of a JSF application that I developed out in the field. I cited performance problems caused by casually accessing components from a JSF view, then presented a set of best practices to eliminate this unnecessary overhead. Despite the progress made by the end of the first part, you had not yet witnessed the two orders of magnitude in performance improvement that was promised.
In this part, the additional gains will be achieved by leveraging partial page rendering-provided by the RichFaces JSF component library and by slimming the response. Partial page rendering cuts out the overhead of rerendering the entire page after each user interaction, which turns out to be the real bottleneck in most traditional web applications, and instead redraws only the areas of the page that have changed. Naturally, you want the replacement HTML source to be as condensed as possible. These optimizations allow the responsiveness of a web application to measure up to its desktop counterpart.
Read the full article here: [Speed up your Data-Driven JSF/Seam Application by Two Orders of Magnitude Part 2|http://www.jsfcentral.com/articles/speed_up_your_jsf_app_2.html]
Kito D. Mann -- Author, JavaServer Faces in Action
http://twitter.com/kito99 http://twitter.com/jsfcentral
http://www.virtua.com - JSF/Java EE consulting, training, and mentoring
http://www.JSFCentral.com - JavaServer Faces FAQ, news, and info
+1 203-404-4848 x3

Hi,
how can we ensure that every body define the id in jsf page. we are using the jsf 1.0 and I think this artical for jsf 1.2
with IBM extended JFS lib.
if we don't want to change the code of full application,is it possible to speed up the render time with the help of framework or some other way.

[ANNOUNCE] Exadel's Max Katz talks about JSF and AJAX

Hello,
I'm pleased to announce that JSF Central has just published an interview with Exadel senior systems engineer Max Katz. In the interview, Max talks about the key value and benefits of JSF, how it compares to other frameworks, why it is such a good fit for AJAX, and support for JSF technology at Exadel.
Here's a quote:
KM: What do you think is the key value of JSF?
MK: It's definitely the component-based approach to building web applications, and that it's a standard. JSF has introduced a new paradigm to web application development�building applications out of components. It allows developers to concentrate on application business logic rather than on little details of HTML and other plumbing that is common to all web applications.
Being a standard is very important for the community, and it helps vendors like Exadel create advanced visual tools. The component-based approach also gave rise to vendors building web components, which also benefits developers. Instead of spending two weeks on integrating a calendar feature into your application, you can now get a calendar component and concentrate on the business problem you're trying to solve.
KM: Let's talk about AJAX for a moment. What do you think makes JSF such a good fit for AJAX?
MK: It's the component approach that makes AJAX such a good fit for JSF. You develop your application out of JSF components that provide AJAX functionality. This approach hides all the complexity of JavaScript and XML. Developers don't need to work with error-prone JavaScript making sure it works in all browsers. The AJAX JSF components are tested, ready-to-use components. From the developer perspective, there is really no difference between using the commandButton standard component and using the JSF AJAX drag-and-drop components. The AJAX component is simply a lot more sophisticated in what it does. You can add AJAX functionality in a matter of minutes by using such components. It's very powerful.
To see the rest of the article, visit
http://www.jsfcentral.com/articles/katz-06-16-06.html.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Kito D. Mann
Author, JavaServer Faces in Action
http://www.virtua.com - JSF/Java EE consulting, training, and mentoring http://www.JSFCentral.com - JavaServer Faces FAQ, news, and info

The posted link led to a *404*.
I think I found the podcast and transcript under [article on JSFCentral.com|http://www.jsfcentral.com/listings/R2925?link] . Kito: is this the correct location?

ANNOUNCE: Designing JSF Applications: a Storyboard Approach Part 2

Hello,
In the second article of this series on using storyboard design for Web applications, Steven Murray explains how to map the Storyboard design to a JSF implementation, giving special attention to Storyboard Controllers.
Here is an excerpt:
In part 1 of this series we discussed how to create storyboard designs for Web applications. In part 2 we are going to focus on how to map the design to a JSF implementation, giving special attention to Storyboard Controllers.
Controllers are the heart of the presentation tier, where they manage the behavior of the UI and direct the flow of information between the presentation and business models. Almost every article I read on JSF, and even the specification itself, references Model View Controller (MVC) without providing any concrete examples on how to actually use it in a JSF project. I hope to change that with the introduction of the Presentation Model.
Read the full article or download the podcast here: [Designing JSF Applications: a Storyboard Approach Part 2|http://www.jsfcentral.com/articles/storyboard_2.html] =>http://www.jsfcentral.com/articles/storyboard_2.html]
Kito D. Mann -- Author, JavaServer Faces in Action
http://twitter.com/kito99 http://twitter.com/jsfcentral
http://www.virtua.com - JSF/Java EE consulting, training, and mentoring
http://www.JSFCentral.com - JavaServer Faces FAQ, news, and info
+1 203-404-4848 x3

Hello,
In the second article of this series on using storyboard design for Web applications, Steven Murray explains how to map the Storyboard design to a JSF implementation, giving special attention to Storyboard Controllers.
Here is an excerpt:
In part 1 of this series we discussed how to create storyboard designs for Web applications. In part 2 we are going to focus on how to map the design to a JSF implementation, giving special attention to Storyboard Controllers.
Controllers are the heart of the presentation tier, where they manage the behavior of the UI and direct the flow of information between the presentation and business models. Almost every article I read on JSF, and even the specification itself, references Model View Controller (MVC) without providing any concrete examples on how to actually use it in a JSF project. I hope to change that with the introduction of the Presentation Model.
Read the full article or download the podcast here: [Designing JSF Applications: a Storyboard Approach Part 2|http://www.jsfcentral.com/articles/storyboard_2.html] =>http://www.jsfcentral.com/articles/storyboard_2.html]
Kito D. Mann -- Author, JavaServer Faces in Action
http://twitter.com/kito99 http://twitter.com/jsfcentral
http://www.virtua.com - JSF/Java EE consulting, training, and mentoring
http://www.JSFCentral.com - JavaServer Faces FAQ, news, and info
+1 203-404-4848 x3

[ANNOUNCE] JSF Insights from Roger Kitain

I�m pleased to announce the first in JSFCentral�s new podcast series, JSF Insights from Roger Kitain, co-spec lead for JavaServer Faces. In this interview, Roger discusses the current state of JSF, JSF 1.2, and also what's in store for JSF 2.0. The podcast was recorded in December, 2006 at the Javapolis conference in Antwerp, Belgium.
Check out the podcast here: http://www.jsfcentral.com/listings/R2914.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Kito D. Mann - Author, JavaServer Faces in Action
http://www.virtua.com - JSF/Java EE consulting, training, and mentoring
http://www.JSFCentral.com - JavaServer Faces FAQ, news, and info

He haven't rejected any yet. We're still prioritizing and some may be deferred to 2.0.
I've just closed out the issues we did manage to fix. The EL Alignment took the bulk
of the time.
The issues are
18 45 15 21 43 16 9 8 13 35
Ed (JSR-252 Spec co-lead)

ANNOUNCE: Trinidad in Action Part 2

Hello,
In the second installment of the Trinidad series, Matthias Wessendorf shows how Ajax is built into all the Trinidad components. You will also learn how easy it is to use the client- and server-side Ajax API, which gives you a straightforward way to add application-specific Ajax support.
Read the full article here: [Trinidad in Action Part 2| http://www.jsfcentral.com/articles/trinidad_2.html]
Kito D. Mann -- Author, JavaServer Faces in Action
http://twitter.com/kito99 http://twitter.com/jsfcentral
http://www.virtua.com - JSF/Java EE consulting, training, and mentoring
http://www.JSFCentral.com - JavaServer Faces FAQ, news, and info
+1 203-404-4848 x3

adding the following line to my .bash_profile solved the problem. Thanks to Benjamin's clue provided at http://www.puschitz.com/InstallingOracle9i.shtml
LD_ASSUME_KERNEL=2.2.4;export LD_ASSUME_KERNEL

ANNOUNCE: Martin Marinschek on MyFaces 2.0, IRIAN, and Related Topics

Hello,
In this podcast, JSFCentral editor-in-chief Kito D. Mann talks with Martin Marinschek about MyFaces, IRIAN, and related topics. This interview was recorded in December of 2009 at the JSF Summit conference in Orlando, Florida. Here is an excerpt:
Kito: Lets talk a little bit about the project. MyFaces was originally just an implementation but now it has grown into a very large set of projects. Tell us a bit about some of the different projects that are part of the MyFaces umbrella.
Martin: I hope I dont miss anything. Of course there is the core MyFaces implementation and API. For the JSF implementation you have to do the API and the Impl, so it is actually two jars which are developed in the core section. Then there are the three component libraries: Trinidad, Tomahawk, and Tobago. Then there is Orchestra, which is a conversation scope implementation for long running conversations with integration to JPA as well. Then there is the JSF Portlet Bridge, and there is ExtVal validation integration for JSF, where you can put annotations on your managed beans and domain objects. It will directly be converted into JSF converters and validators, pretty nicely done. Now that bean validation has been standardized, it is also an implementation of bean validation, so you can use the bean validation annotations together with ExtVal.
Read the full article here: http://www.jsfcentral.com/articles/marinschek-03-10.html
Kito D. Mann -- Author, JavaServer Faces in Action
http://twitter.com/kito99 http://twitter.com/jsfcentral
http://www.virtua.com - JSF/Java EE consulting, training, and mentoring
http://www.JSFCentral.com - JavaServer Faces FAQ, news, and info
+1 203-404-4848 x3

We are pleased to announce that Target Management 3.0M5 is available for
download.
News for Users include
* UI for viewing and changing file permissions and owner on UNIX
* SSH Keepalive mechanism
* Link with Editor action fixed
* Ctrl+Space Field Assist for history in the Terminal input field
On the internals, TM 3.0M5 provides faster startup and reduced footprint
thanks to improved lazy loading of filter pools; and the SystemRegistry
implementation has moved to non-UI plugins for improved UI/Non-UI
Separation.
See the build notes for more information:
http://download.eclipse.org/dsdp/tm/downloads/drops/S-3.0M5- 200802181400/
As always, the build is available for download and on the TM milestone
update site, and will be on the Ganymede Update Site soon.
Enjoy!
Martin Oberhuber
Wind River Systems, Inc.
Target Management Project Lead, DSDP PMC Member
http://www.eclipse.org/dsdp/tm

ANNOUNCE: Using the RichFaces Queue

Hello,
This article shows you how to control traffic to the server using the RichFaces queue. Here is an excerpt:
When building an Ajax application in JSF, one of the things you need to consider is how to control traffic to the server. Although Ajax applications make the application richer, quicker, and more interactive, in many instances the end user is not aware that the client (browser) is sending Ajax requests to the server. For example, if an input field fires an Ajax event on the onkeyup event, the user can easily flood the server with to many requests without even knowing it. This is also true of a regular button that fires an Ajax request. In a traditional (non-Ajax) application, the user is more aware that a request was sent. In such an application, the browser window could go blank for a fraction of a second while the next page is loaded. In other words, there is visual clue that page was submitted. But if the button fires an Ajax request, the page is not reloaded. The user could be clicking the button every second and not realizing that he or she is firing new requests each time. If multiple requests are fired almost at the same time, there is no guarantee they will be processed in the same order without any additional work on the server.
Read the full article here: [ Using the RichFaces Queue |http://www.jsfcentral.com/articles/richfaces_queue.html] html
Kito D. Mann -- Author, JavaServer Faces in Action
http://twitter.com/kito99 http://twitter.com/jsfcentral
http://www.virtua.com - JSF/Java EE consulting, training, and mentoring
http://www.JSFCentral.com - JavaServer Faces FAQ, news, and info
+1 203-404-4848 x3

Does "weblogic.announce" ever get used?
"Michael Girdley" <[email protected]> wrote in message
news:39eb87d7$[email protected]..
ANNOUNCE: Using newsgroups.BEA.com not WWW4.WebLogic.com
Hi Everyone,
This is a friendly reminder that you should be using newsgroups.BEA.comand
not WWW4.WebLogic.com as your news server for the WebLogic newsgroups.
www4.WebLogic.com is the backup news server and some times lags behind the
main server.
Thanks,
Michael
Michael Girdley
BEA Systems Inc

ANNOUNCE: Jason Lee in depth: Mojarra and Scales

Hello,
I am pleased to announce a new podcast on JSF Central. In this podcast JSFCentral editor-in-chief Kito D. Mann interviews Jason Lee about Mojarra (the JSF reference implementation), the Scales component library, and all things JSF. This was recorded in September of 2008 at JSFOne.
Here is an excerpt:
Kito: Okay, cool. You do work on Mojarra, the implementation, but you also work on Scales which is like a Mojarra sub-project. So tell us a little bit about that.
Jason: Well, Scales started out in what we called at the time the “RI sandbox.” It was an area that Ryan had opened up for Mojarra developers to play in; if they wanted a feature to add to the implementation or that sort of thing they could work on it there. We relaxed the rules a little bit in terms of committing and code reviews. When I started doing the component development I needed a place to put that so Ryan and I got to talking and we stuck them there with the goal of eventually moving that out to the sub-project like we have.
What we found that motivated that to happen earlier is we have fairly strict rules on commit access to Mojarra. The implementation is governed by the Sun contributor agreement which some people kind of balk at. From my understanding it really just says “you retain rights to your code but you also give Sun the right to use it.” I don’t find it particularly onerous but some do, so to kind of ease that a little bit we moved that sandbox to a separate project. That also let us promote that as we got closer to a 1.0 version of that. We were able to manage that externally and hopefully get more external contributions. We have gotten some from that…
Scales is just a set of components that I mostly worked on, either because I really wanted to have that functionality in general, or we have a couple that I developed at a former shop that we needed for our business. We needed multiple file uploads. We were uploading 20-30 files at a time. We didn’t want to click “browse,” find it, and do that over and over, so we developed an applet based approach to that, and it is kind of wrapped up in a JSF component so we didn’t have to worry about all that stuff. You just drop the component on there and off your go. Those were developed at that company, and we were given permission to submit those to the sandbox.
Read the full article or download the podcast here: Jason Lee in depth: [Speed up your Data-Driven JSF/Seam Application by Two Orders of Magnitude – Part 2|Jason Lee in depth: Mojarra and Scales http://www.jsfcentral.com/articles/lee-03-09.html]
Kito D. Mann -- Author, JavaServer Faces in Action
http://twitter.com/kito99 http://twitter.com/jsfcentral
http://www.virtua.com - JSF/Java EE consulting, training, and mentoring
http://www.JSFCentral.com - JavaServer Faces FAQ, news, and info
+1 203-404-4848 x3

Hello,
I am pleased to announce a new podcast on JSF Central. In this podcast JSFCentral editor-in-chief Kito D. Mann interviews Jason Lee about Mojarra (the JSF reference implementation), the Scales component library, and all things JSF. This was recorded in September of 2008 at JSFOne.
Here is an excerpt:
Kito: Okay, cool. You do work on Mojarra, the implementation, but you also work on Scales which is like a Mojarra sub-project. So tell us a little bit about that.
Jason: Well, Scales started out in what we called at the time the “RI sandbox.” It was an area that Ryan had opened up for Mojarra developers to play in; if they wanted a feature to add to the implementation or that sort of thing they could work on it there. We relaxed the rules a little bit in terms of committing and code reviews. When I started doing the component development I needed a place to put that so Ryan and I got to talking and we stuck them there with the goal of eventually moving that out to the sub-project like we have.
What we found that motivated that to happen earlier is we have fairly strict rules on commit access to Mojarra. The implementation is governed by the Sun contributor agreement which some people kind of balk at. From my understanding it really just says “you retain rights to your code but you also give Sun the right to use it.” I don’t find it particularly onerous but some do, so to kind of ease that a little bit we moved that sandbox to a separate project. That also let us promote that as we got closer to a 1.0 version of that. We were able to manage that externally and hopefully get more external contributions. We have gotten some from that…
Scales is just a set of components that I mostly worked on, either because I really wanted to have that functionality in general, or we have a couple that I developed at a former shop that we needed for our business. We needed multiple file uploads. We were uploading 20-30 files at a time. We didn’t want to click “browse,” find it, and do that over and over, so we developed an applet based approach to that, and it is kind of wrapped up in a JSF component so we didn’t have to worry about all that stuff. You just drop the component on there and off your go. Those were developed at that company, and we were given permission to submit those to the sandbox.
Read the full article or download the podcast here: Jason Lee in depth: [Speed up your Data-Driven JSF/Seam Application by Two Orders of Magnitude – Part 2|Jason Lee in depth: Mojarra and Scales http://www.jsfcentral.com/articles/lee-03-09.html]
Kito D. Mann -- Author, JavaServer Faces in Action
http://twitter.com/kito99 http://twitter.com/jsfcentral
http://www.virtua.com - JSF/Java EE consulting, training, and mentoring
http://www.JSFCentral.com - JavaServer Faces FAQ, news, and info
+1 203-404-4848 x3

I can't view dataTable in JSF

Hi, anyone who can help me with java server faces, i want to put data from a resultset to dataTable, i made everithing but my table is not visible.
My code is:
<?xml version='1.0' encoding='windows-1252'?>
<jsp:root xmlns:jsp="http://java.sun.com/JSP/Page" version="2.0"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core">
<jsp:output omit-xml-declaration="true" doctype-root-element="HTML"
doctype-system="http://www.w3.org/TR/html4/loose.dtd"
doctype-public="-//W3C//DTD HTML 4.01 Transitional//EN"/>
<jsp:directive.page contentType="text/html;charset=windows-1252"/>
<f:view>
<html>
<head>
<meta http-equiv="Content-Type"
content="text/html; charset=windows-1252"/>
<title>Consultas</title>
</head>
<body><h:form binding="#{backing_Consultas.form1}" id="form1">
<h:commandButton value="commandButton1"
binding="#{backing_Consultas.commandButton1}"
id="commandButton1"
action="#{backing_Consultas.commandButton1_action}"/>
</p>
<p>
<h:dataTable border="1" var="#{backing_Consultas.dataTable1}"
id="dataTable1">
<h:column binding="#{backing_Consultas.column1}"/>
<h:column binding="#{backing_Consultas.column2}"/>
<h:column binding="#{backing_Consultas.column3}"/>
<h:column binding="#{backing_Consultas.column4}"/>
</h:dataTable>
</h:form></body>
</html>
</f:view>

</jsp:root>
This es a JSPX page.
Please any idea
thanks
alex

Try to disable the hardware acceleration in the Flash Player.
See [[Cannot view full screen Flash videos]]
Flash "Display settings" window:
* http://www.macromedia.com/support/documentation/en/flashplayer/help/help01.html

Is this a fare assessment of JSF (RI 1.1)?

After playing with JSF for a week, I need to tell my manager what I think of JSF. If anyone takes issue with anything I've written below, I'd be interested to hear from you.
David
JSF generates HTML its own way. The commonly adopted process of producing a page design in pure HTML, getting the layout 'just so', then implementing a dynamic version doesn't work with JSF because you can't hope to generate exactly the same HTML. You find yourself having to adapt the screen design to fit in with JSF's way of doing things, or at least come up with a different HTML solution that can be generated by JSF.
The following is a commonly occurring frustration with JSF development: You know how you would achieve something using fundamental principles (e.g. servlets, HTML and scriptlets) but you can't find a way to make JSF achieve the same thing. It often feels like a battle, trying to get JSF to do something that would be quite straightforward if you had more control.
Some of the UI control types are restricted in the ways they may be used. For example, the h:selectOneRadio component, which models a radio button group, assumes all the buttons are located within the same parent element without any interspersed HTML between the buttons. There are many cases where this is too restrictive, e.g. a design where each row of a table begins with a radio button (as a means of allowing the user to select only a single row of the table).
Some control types are not provided (at least in Sun's Reference Implementation), e.g. HTTP file upload. You can implement your own custom components, but this is not trivial.
Quirky behaviour during development slows you down. For example, actions not firing when command buttons are clicked turns out to be due to unreported page translation problems. Have to deduce what's causing the problem by selectively commenting out different portions of the page.
The Sun JSF RI is buggy. After running into a few problems and consulting the Sun JSF forum it becomes clear that the current Sun RI (1.1) suffers from a significant number of awkward bugs.
Limited ability to manipulate the GUI using client side scripting (e.g. to add new rows to a data entry table without the need for a round trip to the server).
JSF is designed to be used with tools but tool support is currently not great. Sun Java Studio Creator looks good on paper but is rather clunky in practise. Its page layout editor only allows components to be positioned absolutely (i.e. fixed size and co-ordinates). This negates one of the great virtues of HTML, i.e. that it can allow content to flow naturally and components can be positioned according to CSS rules.
In summary, the promise of rapid development with JSF is not achieved in practise due to a variety of problems. Many of the problems are to do with the immaturity of JSF. However, the lack of control over the generated HTML (assuming it's impractical to implement custom components to solve each new requirement for custom HTML) seems to be an inherent restriction.
End

Layout is way to restrictive when using tables for rendering in JSF. This is an RI issue, and most likely not the spec as I am sure the spec does not say layout must be implemented with tables.
I am not sure I agree with your comment that a JSP, Servlet, HTML, CSS, javascript developer is less productive than a competent JSF developer. I think JSF is a great prototyping tool, but I don't think it is as flexible as using the fundamental technologies leveraged by JSF. I run into situations where I have to customize components straight from the fundamental tehcnologies. Based on this experience, I will run into situations where the components in JSF will require some sort of customization for a customer. I have found customers that are picky about the presentation and will move components around sometimes as little as a couple pixels. Or they will require slightly different behavior in a component than what is default. The other thing I have learned working in a corporation is that branding changes every couple years. How much investment should it take to rebrand all your JSF pages when you can make it so your pages created in fundamentals leverages one CSS for the entire site? Then when the rebranding comes, all you need to do is modify the CSS and not the JSFs. In particular, I am referring to layout and not look.
Let's say a new javascript or AJAX library comes out with some whiz bang widgets. It is a lot easier to develop with that code in fundamental technologies than in JSF. We can see this with AJAX. AJAX capabilities have been around for a while now, but JSF is playing catchup. That means, if you wanted to take advatage of the benefits of AJAX when it was first around, you would have to write custom code or wait for the widgets to come out. What would have google done for google maps if they had to wait around for JSF to catch up(if hypothetically they are using j2ee)? After all, I am certain they haven't received nice publicity which turned into revenue of some sort by being an example of AJAX design. Where would AJAX be without compelling examples of AJAX? It might still be a side note or we would be using the javascript calls directly to do the asynchronous call back to the server. So, there is something to be said about not having to wait for JSF components to manifest themselves. However, that is not to say that google couldn't have invested in its own set of components, but I am not google and I consume already created components or I put the new widgets directly in the page without leveraging the JSF lifecycle. But your choice in JSF is either to use f:verbatim or create the JSF components. Does your boss want to invest in creating JSF components that may or may not be reused? This is a tough question all bosses should ask whenever venturing down the road of extra development for purposes of reuse. When is the return going to be realized on the investment in creating components? In addition, corporations like to reorganize their business units such that the project may or may not survive the reorg. Where is the investment now? If I was a boss, I would not want my developers creating reusable components as it is a distraction. If I run a second project, I might then look into creating reusable components out of the work from the first project. But I certainly would not do it on the first project. You have no way of knowing if that code will be reused. Essentially, anytime something new that comes out that could be leveraged swiftly in an HTML page, requires more work on the JSF developers part.
By the way, I have to learn how to use f:verbatim correctly. Currently, code that I have stuck in f:verbatim is being rendered outside a subview. I might be using this incorrectly though. I am also using dwr, which I am unsure if I can incorporate into a JSF subview/view without f:verbatim since dwr requires calling a dwr servlet and not the faces servlet. I guess I might be able to get around this by assigning the action on a form dynamically to call dwr instead of faces.
Just my 1/2 cent(I try not to spend my two cents all at once),
TacoEater

Using JSF and Struts

I am a bit of a newbie in terms of UI applications on the JEE platform, so I apologize up front if this question seems silly. I was wondering if someone could comment on the approach below. Is this something that's possible or am I barking up the wrong tree?
We have a vendor application that is written using Struts. We want to add a section of our own pages to this application, but we would rather use a more strategic approach in our pages, so we would like to use JSF for those.
The original web.xml file in the vendor app uses a dtd of version 2.3 as shown below:
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
When I use JSF, I use a DTD version of 2.5 as shown here:
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
The problem is that when I use version 2.3, the elements needed to support JSF are invalid. When I use 2.5, the elements needed to support struts are invalid.
Could someone comment in that, if you had this vendor app and you needed to add your own pages, is it not possible to use JSF in this scenario or if you can, what is the best approach to resolving this issue?
Thank you in advance

First make sure that your application server supports Servlet API 2.5. Whether the desired Servlet API version is supported or not solely depends on the application server implementation and version used. For example Tomcat 5.5 is a Servlet API 2.4 implementation which only supports the API versions up to with 2.4. If you want to use Servlet API 2.5, then you obviously need a Servlet API 2.5 implementation, for example Tomcat 6.0.
Consult the website and/or documentation of the application server in question.

[JSF 1.2 and 2.0/Internationalization] How to propagate the Locale to the entire application

Hi,
do you know how to internationalize an application in a dynamic way in JSF 1.2 ?
I created 2 files msg_fr.properties ( language by default, french) and msg_en.properties ( english)
Then I wrote a methode changeLanguage() in a Managed Bean . This method allows me to switcher the language in the first page of the application.
This method is called in a tag <h:commandLink>
public void changeLanguage() {
        FacesContext context = FacesContext.getCurrentInstance();
        // I test a parameter (currentLanguage) and I switch in consequence
       context.getViewRoot().setLocale(Locale.ENGLISH);
       //or    context.getViewRoot().setLocale(Locale.FRENCH);
       context.getApplication().setDefaultLocale(context.getViewRoot().getLocale()); I have of course modified the file faces-config.xml.
This WORKS but for the current page only. The Locale is not propagated to the next pages of the application.
The Locale by default of my browser is English and so the next pages are always in English, even if i switch the first page to French.
Do you know how to propagate this Locale to all the pages of the application in JSF 1.2 ?
Also, has internationalization been improved in JSF 2.0 ?
thanks

The f:view has a 'locale' attribute. You should make use of it. Feed it with a property of a session scoped bean which you could control/change using for example some language dropdown menu or a request parameter or pathinfo. There is no need to traverse the FacesContext and UIViewRoot yourself.
For more about i18n in JSF, please consult the Sun JSF specification and the Sun Java EE tutorial.

How to use javascript for jsf containg t:htmlTags instead of panel grids

Hi,
i tried out validation in the following manner:
function valid(form){
alert(" 1:Entered valid function ");
var varCritical1=document.form["form:critical1"].checked;
var varHigh1=document.form["form:high1"].checked;
if (varHigh1&&varCritical1){
alert("Select only one option");
document.form["form:critical1"].focus();
document.form["form:high1"].focus();
return false;
return true;
====== the jsf code for the above is:
<t:htmlTag value="td" style="border: 1px solid;">
<h:commandButton id="commit" value="Commit all Changes" action="commit" styleClass="submit-button"
onClick="return valid(this.form)" />
</t:htmlTag>
======
could anyone suggest me how to do this validation..
faster reply is appreciated
-Thanks,
Soumya Desu

When writing JS and you're new to JSF (so new that you don't know out of head which HTML a JSF component generate), you need to base the JS code on the generated HTML output, not on the JSF source code.
For problems and/or support with writing JS code, please consult a JS forum. There are ones at webdeveloper.com and dynamicdrive.com. Please keep in mind that JSF source code is completely irrelevant for the JS forum users (and actually also for you), concentrate on and share the generated HTML output.

Is JSF components changed in RAD 7.0?

Hi,
I see that some of the components like h:commandLink are missing in the RAD 7.0. Is that so?
Also is there any documents which shows the usage of all the JSF components?
Thanks,
Elango

Depends on the JSF implementation used in RAD. Consult the RAD manfacturer and its documentation.

JSF Trainers or Consultants?

Similar Messages

Maybe you are looking for