JavaBeat » JSF http://www.javabeat.net Java Technology News Mon, 13 May 2013 20:10:23 +0000 en-US hourly 1 http://wordpress.org/?v=3.5.1 Enterprise Push Server in ICEFaces http://www.javabeat.net/2011/06/enterprise-push-server-in-icefaces/ http://www.javabeat.net/2011/06/enterprise-push-server-in-icefaces/#comments Fri, 10 Jun 2011 13:45:56 +0000 JavaBeat http://www.javabeat.net/examples/?p=299 Connect to us ( @twitter | @facebook )

Enterprise Push Server in ICEFaces What is Enterprise Push Server? In ICEfaces EE 2, the Enterprise Push Server (EPS) is built to manage singleAjax Push blocking connection(s) with the client browser and share it with any number of deployed ICEfaces applications and portlets, in both stand-alone and clustered deployments. The Enterprise Push Server delivers key [...]

]]> Connect to us ( @twitter | @facebook )

Enterprise Push Server in ICEFaces

What is Enterprise Push Server?

In ICEfaces EE 2, the Enterprise Push Server (EPS) is built to manage singleAjax Push blocking connection(s) with the client browser and share it with any number of deployed ICEfaces applications and portlets, in both stand-alone and clustered deployments. The Enterprise Push Server delivers key additional features targeted at large-scale and high-availability enterprise deployments. Specifically, the Enterprise Push Servers:

  • Integrates with major open source and commercial application servers to provide high-scalability and fail-over support for clustered Ajax Push-enabled ICEfaces applications.
  • Provides distributed management of Push blocking connection to any number of deployed ICEfaces applications and portlets in both a stand-alone and clustered environments.
  • Designed to Load-balance for failover of blocking push connections.
  • Supports Servlet 3.0 Asynchronous Request Processing (ARP) integration for thread-level scalability.

Enterprise Push Server is required for deploying multiple Ajax Push applications to the same domain. It delivers push server capabilities and key features targeted at enterprise deployments in either stand-alone or cluster deployment environments.

5 Things to Know About Enterprise Push Server

  1. Enterprise Push Server enables the delivery of collaborative rich web applications through Ajax Push.
  2. It integrates with major open source and commercial application servers to provide high-scalability and fail-over support for clustered Ajax Push-enabled ICEfaces applications.
  3. Provides distributed management of Push blocking connection to any number of deployed ICEfaces applications and portlets in both a stand-alone and clustered environments.
  4. Designed to Load-balance for failover of blocking push connections.
  5. Supports Asynchronous Request Processing (ARP) integration for thread-level scalability.

More Details

email
]]> http://www.javabeat.net/2011/06/enterprise-push-server-in-icefaces/feed/ 0 ICEfaces EE 2.0 is Now Available! http://www.javabeat.net/2011/06/icefaces-ee-2-0-is-now-available/ http://www.javabeat.net/2011/06/icefaces-ee-2-0-is-now-available/#comments Fri, 10 Jun 2011 13:44:45 +0000 JavaBeat http://www.javabeat.net/examples/?p=297 Connect to us ( @twitter | @facebook )

ICEfaces EE 2.0 is Now Available! ICEfaces Enterprise Edition (EE) 2.0 is a JSF 2 ready, enterprise-grade development framework, designed to allow enterprise application developers to quickly design, test and deploy rich collaborative web applications. ICEfaces EE 2.0 provides enterprise-grade features and capabilities not available in ICEfaces 2 open-source releases. It includes additional enterprise technologies, [...]

]]> Connect to us ( @twitter | @facebook )

ICEfaces EE 2.0 is Now Available!

ICEfaces Enterprise Edition (EE) 2.0 is a JSF 2 ready, enterprise-grade development framework, designed to allow enterprise application developers to quickly design, test and deploy rich collaborative web applications.

ICEfaces EE 2.0 provides enterprise-grade features and capabilities not available in ICEfaces 2 open-source releases. It includes additional enterprise technologies, features, and advanced documentation designed to simplify and enhance your ICEfaces project lifecycle from development and testing, to deployment.

ICEfaces EE 2.0 is certified and fully tested against an extensive matrix of open source and commercial Java EE technologies. Key features of ICEfaces EE 2.0 include:

  • Certified Code-base
  • Commercial Technology Integrations
  • Enterprise Components
  • Testing Resources
  • Enterprise Push Server (EPS)
  • Enterprise Deployment Guides
  • Enterprise-Level Support Options

ICEfaces 2.0.1 is an official maintenance release featuring over 110 fixes and improvements.

Notable changes included in this release are:

  • New Supported Platforms?
  • - Chrome 10, Firefox 4.0, IE 9
  • - GlassFish 3.1, JBoss 6.0 and Liferay Portal 5 and 6
  • - CDI / Weld
  • Optimized JavaScript for the ICEfaces Components
  • Faster Page Loading
  • Mojarra JSF 2.1 and associated support updates
  • Optimized Window Scope initialization
  • Various Single Submit Improvements
  • Updated Tutorials & Sample Applications

ICEfaces 2.0 Training

ICEsoft offers online training options to fit your specific needs. ICEfaces Training is developer led using experienced ICEfaces developers with several years of JSF and ICEfaces development experience. All our courses include hands-on exercises and labs to ensure knowledge transfer.

Introduction to ICEfaces and JSF (updated to ICEfaces 2 and JSF 2)

This 9 hour online course provides overview into Java Server Faces (JSF) and teaches the basics of developing Rich Enterprise Applications using ICEfaces and JSF. Students will be introduced to the MVC (Model View Controller) architecture of JSF, event-handling, data binding and validation. The course walks attendees through the ICEfaces architecture, component library and unique features such as Ajax push and page level design. Students will learn how to install, and configure their local environment and will develop and deploy a basic ICEfaces application.

More Details for IceFaces 2.0

]]> http://www.javabeat.net/2011/06/icefaces-ee-2-0-is-now-available/feed/ 0 ICEfaces in Portals with PortletFaces Bridge http://www.javabeat.net/2011/06/icefaces-in-portals-with-portletfaces-bridge/ http://www.javabeat.net/2011/06/icefaces-in-portals-with-portletfaces-bridge/#comments Mon, 06 Jun 2011 13:47:04 +0000 JavaBeat http://www.javabeat.net/examples/?p=303 Connect to us ( @twitter | @facebook )

ICEfaces in Portals with PortletFaces Bridge ICEfaces 2 uses the open source PortletFaces Bridge project to provide a much improved portal development experience. The PortletFaces Bridge is based in part on the JSR 329 standard, and provides advanced support for JSF 2.0 Portal applications. Using the improvements in both JSF 2 and Portlet 2, the [...]

]]> Connect to us ( @twitter | @facebook )

ICEfaces in Portals with PortletFaces Bridge

ICEfaces 2 uses the open source PortletFaces Bridge project to provide a much improved portal development experience. The PortletFaces Bridge is based in part on the JSR 329 standard, and provides advanced support for JSF 2.0 Portal applications. Using the improvements in both JSF 2 and Portlet 2, the PortletFaces Bridge now directs all Ajax requests to ICEfaces without bypassing the portlet container while maintaing a rich UI experience by avoiding full page renders.

With the PortletFaces Bridge, ICEfaces Ajax portal integration adheres to the Portlet 2.0 specification and supports most of the JSR 286 Portlet 2.0 API.

The PortletFaces Bridge is tested and shipped with the ICEfaces 2 distribution and can be used to develop portlet applications with ICEfaces.

ICEfaces 1.x Brings Ajax and JSF to Portals

ICEfaces 1.x introduces easy, transparent use of Ajax in JavaServer Faces (JSF) applications. ICEfaces 1.x provides the same “Ajax over JSF” benefits to portlet developers by providing a simple, generic mechanism for bridging the portlet and JSF lifecycles. By using ICEfaces 1.x, developers can build JSF portlets with automatic support for Ajax, providing a rich user experience where portlets can be smoothly updated without disruption to other portlets on the page. In addition, using Ajax Push, an action in one portlet can be used to trigger changes and updates in other portlets, allowing for a form of Inter-Portlet Communication (IPC) that was unavailable in the Portlet 1.x API. In addition, all these features are available and supported across several leading portal platforms.

ICEfaces 2 and the PortletFaces Bridge

The advent of the Portlet 2.x and JSF 2.x specifications ushered in a host of new features that were previously unavailable in the older portlet and JSF implementations. JSF 2.x now provides native support for Ajax and Portlet 2.x now supports IPC. There are also standard specifications for JSF portal bridges which are designed to be transferrable across portal platforms.

ICEfaces 2 now ties all of these together for an even better portlet development experience. ICEfaces 2 uses the PortletFaces Bridge, a portlet bridge based in part on theJSR-329 standard, including advanced support for JSF 2.0, to provide a much improved portal development experience. The PortletFaces Bridge cleanly isolates the work of meshing the Portlet 2 API and lifecycle with the JSF 2 API and lifecycle.

Read More Details

]]> http://www.javabeat.net/2011/06/icefaces-in-portals-with-portletfaces-bridge/feed/ 0 What is Shale Web Framework? http://www.javabeat.net/2008/09/what-is-shale-web-framework/ http://www.javabeat.net/2008/09/what-is-shale-web-framework/#comments Thu, 25 Sep 2008 01:07:46 +0000 JavaBeat http://www.javabeat.net/examples/?p=390 Connect to us ( @twitter | @facebook )

Apache Shale is a Java Server Faces based Web Application Framework from the Apache software foundation. Shale is talked of as the “heir” Apache struts framework. We all know that struts is the most used Java Web Framework so far. While shale is the successor of Struts, there is a significant departure of architecture from [...]

]]> Connect to us ( @twitter | @facebook )

Apache Shale is a Java Server Faces based Web Application Framework from the Apache software foundation. Shale is talked of as the “heir” Apache struts framework. We all know that struts is the most used Java Web Framework so far. While shale is the successor of Struts, there is a significant departure of architecture from sturts to shale. Firstly, while struts is based on a monolithic Request Processor, Shale is set of fine-grained services that can be combined as needed to meet particular application needs. Secondly, while sturts can be integrated with Java Server Faces, Shale is built upon JSF. The major features of the Shale Framework are:

  • View Controller – Convenient mechanism to associate a “backing” Java class with each JavaServer Faces view (a JSF WebPage) in an application, with predefined event handers for events significant to an application developer.
  • Dialog Manager – Mechanism to define a “conversation” with a user that requires multiple HTTP requests to implement, modeled as a state diagram.
  • Application Manager – Traditional application wide front controller features that should be applied to every request.
  • Validation – Integration with the Jakarta Commons Validator Framework, supporting both client side and server side validations based on a single set of configured validation rules.
  • Remoting – Server side support for applications that employ AJAX (Asynchronous JavaScript and XML) style interactions.
  • Spring Integration – Integration with the Spring Framework, allowing the use of Spring’s dependency injection framework to create JavaServer Faces managed beans.
  • Clay – An alternative to JSP where you define views in pure HTML, in a fashion similar to Tapestry and Facelets. An innovative sub-framework for supporting the configuration of reusable subtrees of JavaServer Faces components for customizable reuse.
  • Test Framework – Set of mock objects and JUnit test case base classes suitable for testing both the framework classes themselves, as well as application components built on top of the framework.
  • Java 5 Extensions – Optional add-on library that adds additional ease-of-use features for Shale applications that run on Java Standard Edition 5 (popularly known by its code name during development, “tiger”).

This article is originally published in Abhi Vuyyuru’s Blog.

]]> http://www.javabeat.net/2008/09/what-is-shale-web-framework/feed/ 0 Advantages and Disadvantages – JSF http://www.javabeat.net/2008/09/advantages-and-disadvantages-jsf/ http://www.javabeat.net/2008/09/advantages-and-disadvantages-jsf/#comments Wed, 24 Sep 2008 01:02:51 +0000 JavaBeat http://www.javabeat.net/examples/?p=380 Connect to us ( @twitter | @facebook )

JSF is becoming more popular framework for user interface layer development, many architects and companies assuming that Struts is becoming outdated and JSF is catching up the market. I am not sure whether it is true at this point of time. However I would like express my critic on the advantages and disadvantages of JSF. [...]

]]> Connect to us ( @twitter | @facebook )

JSF is becoming more popular framework for user interface layer development, many architects and companies assuming that Struts is becoming outdated and JSF is catching up the market. I am not sure whether it is true at this point of time. However I would like express my critic on the advantages and disadvantages of JSF.

Advantages of JSF

  • 1. Big vendors (Oracle, IBM, JBoss, etc) backing JSF implementation like EJB. Can expect good level of support and quality components from these vendors.
  • 2. By design and concept it allows to create reusable components. That will help to improve productivity and consistency.
  • 3. Many quality and ready to use components are available from Apache, Richfaces, Infragistics, Oracle, etc.
  • 4. The concept of action and action listener for button invocation is good.
  • 5. Has very good support for EL expression that improves the user interface code readability.
  • 6. The concept the validator and converter is excellent. Unlike struts JSF keeps the validation logic very close to the component
  • declaration.
  • 7. JavaScript code are embedded as part of the component; this keep less confusion for developers and more re-usability on JavaScript code.

Disadvantages of JSF

  • 1. There is no benchmarking report or promise from Sun Microsystems about the performance of JSF framework. By seeing their concept I believe it is not suitable for high performance application.
  • 2. The specification doesn’t consider bookmarking facility.
  • 3. Hardly a very few examples available for developing dynamic pages including new component and removing a component from a page based on business rule.
  • 4. Every button or link clicked results in a form post. That’s just wrong – why can’t I have true links like the web is supposed to? Form submission for page navigation make complex coding for simple requirement like Cancel button. Read here to know the work around.
  • 5. Datatable component requires same data from bean on restore view phase. If the data retrieved from database, this will have impact on performance. Click here to know more about this issue.
  • 6. There is no tight coupling between managed bean and phase listener. This is a major drawback of JSF which makes JSF phase listener feature unusable.
  • 7. Default error message is not good. Need to customize the default error message.
  • 8. Not Scalable. It uses session object to store the component state across the request. In server farm environment it is too costly to replicate the session data.

Is JSF matured?

JSF simplifies user interface development, and increases complexity on request processing lifecycle. At this point of time I don’t see JSF as a matured solution.

]]> http://www.javabeat.net/2008/09/advantages-and-disadvantages-jsf/feed/ 0 Custom DateTimeConverter in JSF http://www.javabeat.net/2008/09/custom-datetimeconverter-in-jsf/ http://www.javabeat.net/2008/09/custom-datetimeconverter-in-jsf/#comments Wed, 24 Sep 2008 01:01:56 +0000 JavaBeat http://www.javabeat.net/examples/?p=377 Connect to us ( @twitter | @facebook )

By default JSF using GMT timezone to convert the date into display format. Here is a simple solution where you can provide your custom date time converter. 1) Write a new custom converter by extending existing DateTimeConverter class. 1 2 3 4 5 6 7 8 9 10 11 package com.company.project.converter; import java.util.TimeZone; import javax.faces.convert.DateTimeConverter; [...]

]]> Connect to us ( @twitter | @facebook )

By default JSF using GMT timezone to convert the date into display format.

Here is a simple solution where you can provide your custom date time converter.

1) Write a new custom converter by extending existing DateTimeConverter class. 

1
2
3
4
5
6
7
8
9
10
11

package com.company.project.converter;
import java.util.TimeZone;
import javax.faces.convert.DateTimeConverter;
public class CustomDateTimeConverter extends DateTimeConverter {
public CustomDateTimeConverter() {
super();
setTimeZone(TimeZone.getDefault());
// here you can set your custom date pattern for your project
// setPattern("M/d/yy");
}
}

Bind your new converter as default converter for object of type java.util.Date 

1
2
3
4

<converter>
<converter-for-class>java.util.Date</converter-for-class>
<converter-class>com.company.project.converter.CustomDateTimeConverter</converter-class>
</converter>
]]> http://www.javabeat.net/2008/09/custom-datetimeconverter-in-jsf/feed/ 1 h:graphicImage in JSF http://www.javabeat.net/2008/09/hgraphicimage-in-jsf/ http://www.javabeat.net/2008/09/hgraphicimage-in-jsf/#comments Mon, 22 Sep 2008 13:05:36 +0000 JavaBeat http://www.javabeat.net/examples/?p=254 Connect to us ( @twitter | @facebook )

The h:graphicImage tag renders an HTML image tag. 1 <h:graphicImage id="jsfimage" value="/images/jsfimage.gif" width="200" height="50" /> h:graphicImage Tag Attributes alt The alt attribute is a standard HTML attribute that sets the alternate textual description rendered by this component. binding The value-binding expression linking this component tag to a backing bean property. dir The dir attribute is [...]

]]> Connect to us ( @twitter | @facebook )

The h:graphicImage tag renders an HTML image tag. 

1

<h:graphicImage id="jsfimage" value="/images/jsfimage.gif" width="200" height="50" />

h:graphicImage Tag Attributes

alt

The alt attribute is a standard HTML attribute that sets the alternate textual description rendered by this component.

binding

The value-binding expression linking this component tag to a backing bean property.

dir

The dir attribute is a standard HTML attribute that overrides the default text directionality for this component. The values accepted for this component are “LTR” (left-to-right) and “RTL” (right-to-left).

height

The height attribute sets the height of the image.

id

The unique identifier value for this component. The value must be unique within the closest naming container.

ismap

The ismap attribute is a boolean flag that indicates that this image is to be used as a server side image map. If so, the image must be contained within a hyperlink (“a”) element.

lang

The lang attribute is a standard HTML attribute that sets the code describing the language to be used in the markup generated by this component.

longdesc

The longdesc attribute provides a long description of the image rendered by this tag.

onclick

The onclick attribute sets the JavaScript code to execute when the mouse pointer is clicked over this element.

ondblclick

The ondblclick attribute sets the JavaScript code to execute when the mouse pointer is double-clicked over this element.

onkeydown

The onkeydown attribute sets the JavaScript code to execute when a key is pressed down over this element.

onkeypress

The onkeypress attribute sets the JavaScript code to execute when a key is pressed and released over this element.

onkeyup

The onkeyup attribute sets the JavaScript code to execute when a key is released over this element.

onmousedown

The onmousedown attribute sets the JavaScript code to execute when the mouse pointer is pressed down over this element.

onmousemove

The onmousemove attribute sets the JavaScript code to execute when the mouse pointer is moved within this element.

onmouseout

The onmouseout attribute sets the JavaScript code to execute when the mouse pointer is moved away from this element.

onmouseover

The onmouseover attribute sets the JavaScript code to execute when the mouse pointer is moved onto this element.

onmouseup

The onmouseup attribute sets the JavaScript code to execute when the mouse button is released over this element.

rendered

A value-binding expression that evaluates to a Boolean condition indicating if this component should be rendered.

style

The style attribute sets the CSS style definition to be applied to this component when it is rendered.

styleClass

The styleClass attribute sets the CSS class to apply to this component when it is rendered.

title

The title attribute is a standard HTML attribute that sets the tooltip text to display for the rendered component.

url

The url attribute is an alias for the value attribute. It accepts a context-relative URL to the image to be displayed.

usemap

The usemap attribute sets the name of a client-side image map (the HTML “map” element) for which this tag provides the image.

value

The value attribute set the context-relative URL to the image to be displayed.

width

The width attribute sets the width of the image.

]]> http://www.javabeat.net/2008/09/hgraphicimage-in-jsf/feed/ 0 Life Cycle of JSF Components http://www.javabeat.net/2008/08/life-cycle-of-jsf-components/ http://www.javabeat.net/2008/08/life-cycle-of-jsf-components/#comments Tue, 12 Aug 2008 12:58:12 +0000 JavaBeat http://www.javabeat.net/examples/?p=236 Connect to us ( @twitter | @facebook )

Restore View The JSF servlet builds the view of the requested page as a component tree that contains the information associated with all components. It also saves the view in a FacesContext instance, thereby making it possible to repopulate the page if necessary—for example, when the user doesn’t fill out a form as required. If [...]

]]> Connect to us ( @twitter | @facebook )

Restore View

The JSF servlet builds the view of the requested page as a component tree that contains the information associated with all components. It also saves the view in a FacesContext instance, thereby making it possible to repopulate the page if necessary—for example, when the user doesn’t fill out a form as required. If the same page was displayed before and component states were saved, that information would also be taken into account. In this phase, JSF wires event handlers and validators (if any) to the components.

Apply Request Values

The JSF servlet goes through the component tree and executes each component’s decode method, which extracts values from the request parameters and stores them locally in the component. It also automatically converts the parameters that are associated with object properties of non-string types. Conversion errors cause error messages to be queued to the FacesContext object. In some cases, typically when the user clicks on controls, the servlet also generates request events and queues them to FacesContext.

Process Request Events

The servlet calls the processEvent method for each component with one or more queued events. Each component decides to handle the events or delegate their handling to event handlers. In any case, the servlet proceeds with the next phase if all executed processEvent methods return false. Otherwise, it jumps directly to the Render Response phase.

Process Validation

The servlet invokes the validate methods of the validators that had been registered during the Restore View phase. For each validate method that returns false, the servlet queues an error message to the FacesContext.

Process Events

If validation or conversion errors are generated during the Process Validation phase, control jumps directly to the Render Response phase.

Update Model Values

Each UI component can be linked to a field in a Java object called the model object. During this phase, the values of the linked components are copied to the corresponding fields of the model object by executing the component method updateModel, which also does type conversions when necessary. Conversion errors cause error messages to be queued to FacesContext.

Process Events

If it turns out that conversion errors were generated during phase 6,control jumps directly to the Render Response phase.

Invoke Application

During this phase, the servlet processes the application-level events by executing the corresponding handlers. When the user submits a form or clicks on a link of a JSF application, the JSF servlet generates a corresponding application-level event. One of the tasks you have to do when developing a JSF application is to assign a handler (e.g., a JSP page) to each one of the possible application events.

Render Response

The servlet creates a response component tree and delegates the rendering of the page to Tomcat. Each component renders itself as Tomcat goes through the corresponding JSF tags. At the end of this phase, the state of the response is saved so that the servlet can access it during the Restore View phase of subsequent requests to the same page.

]]> http://www.javabeat.net/2008/08/life-cycle-of-jsf-components/feed/ 0 New Features in JSF 2.0 http://www.javabeat.net/2008/07/new-features-in-jsf-2-0/ http://www.javabeat.net/2008/07/new-features-in-jsf-2-0/#comments Thu, 31 Jul 2008 12:47:35 +0000 JavaBeat http://www.javabeat.net/examples/?p=216 Connect to us ( @twitter | @facebook )

JSF 2.0 New Features JSF 2.0 proposal has been posted on March 2007 and planned for the release in last quarter of 2008. It will be shipped with JEE 6.0 release. Looking into the features lits of the JSF 2.0, it is added lots of interesting features in the list and also they are aiming [...]

]]> Connect to us ( @twitter | @facebook )

JSF 2.0 New Features

JSF 2.0 proposal has been posted on March 2007 and planned for the release in last quarter of 2008. It will be shipped with JEE 6.0 release. Looking into the
features lits of the JSF 2.0, it is added lots of interesting features in the list and also they are aiming to attract more new developers to use JSF technology.

JSF 2.0 Features

Some of the interesting features includes Bookmarking for URLs, expanding the existing lifecycle mechanism, more support
for the AJAX requests, use annotations instead of faces-config.xml, introducing JSFTemplating concepts and much more. It seems
the list size is big it will be great to see when the final version is released. Basically it is categorized into four parts:
Ease of development, New Features, Performance and Adoption. We will look into the each category with brief explanation. This tips based on the JSR 314 and the features list is taken from the original JSR document.

Ease of development

  • Component aggregation. Allow development of custom component with little or no Java coding. [A] Perhaps consider a standard set of aggregations.
  • Allow for “zero configuration” web applications. No faces-config.xml, no web.xml. If necessary, annotations will be used to supplement the configuration data.
  • Vastly improve the developer experience with regard to error messages that happen during iterative development, and even during deployment of the application. For example the EG will consider options including, allowing the developer to tell the runtime what stage of development the web application is in, and take action accordingly: Development, Test, Deployment. Line precise error reporting. Pluggable Exception Handling.
  • Provide default exception handling mechanisms. For example, all runtime errors get forwarded to an error page.
  • Eliminate the need to author a JSP tag handler when writing JSF components.
  • Leverage annotations to declare JSF artifacts (components, managed beans, navigation rules, etc) to the runtime.
  • Declarative Renderers, otherwise known as Renderers without resorting to out.println().
  • Real world, production view description technology, including templating: include something influenced by Facelets, JSFTemplating or Tiles in the specification.
  • Make it very easy to create CRUD based applications.

New Features

  • Expand the request processing lifecycle to be aware of Ajax. This may include describing a small developer-contract footprint JavaScript library as part of the JavaServer Faces specification.
  • Separate the “build the tree” and “render the tree” processes into two separate lifecycle phases.
  • Allow for partial tree traversel during lifecycle execution via Ajax.
  • Allow for bookmarkable JSF pages. More broadly, if HTTP GET can be used, it should be used.
  • Decent client side, inter-component and form-level validation (leveraging JSR-303 validation if possible).
  • First class support for bundling and delivering static resources associated with a component: images, stylesheets, scripts, etc. Should be able to specify default locations for resources.
  • Strategic additions to the Standard HTML RenderKit: Date Picker, Tree, Tab View, File Upload components.
  • Provide a mechanism to minimize the “Lost Update” and “Duplicate Button Press” problems. These mechanisms must be pluggable or customizable from the user.
  • Page actions: The ability to say, “when this page loads, invoke this action (via Ajax if necessary).”
  • Provide a mechanism to easily access persistent store.

Performance

  • Saving and restoring page deltas rather than saving and restoring the full view state each time.
  • Re-do UIComponent state saving with a view towards making stateless components the default.
  • Allow for moving as much of the event processing and inter-page component interaction into the client as possible. This may imply specifying client side controller framework.
  • Streamline the rendering process via caching if possible.
  • Improve the interceptor mechanism delivered via the PhaseListener feature so that the developer can control exactly what kinds of requests are allowed to be processed by each PhaseListener instance.

Adoption

  • Enable components to have a client based lifecycle in addition to, or instead of the server based request/response lifecycle. Such a client based lifecycle would enable use-cases such as drag-and-drop, master-detail and sub-dialogs on a single page interface web application.
  • Improve the UIComponent specification to allow an increase in the interoperability of UIComponent libraries from arbitrary vendors.
  • Enable applications to use features that are defined in the JavaServer Faces specification but are intended for use in the Java EE platform as a whole. For example, the managed bean facility is useful even in an application that only uses Servlets from Java EE but provides the rest of the web application features from software outside of the platform.
  • Allow JSF application resources to be accessed via REST.
  • Enable components that publish events via RSS/Atom.
  • Add support for REST (JSR 311)
  • Broad and pervasive support for scripting at all levels of the specification. It will be possible to use a scripting language to write all executable artifacts in a JSF application.
  • Specify command line interface for authoring JSF applications.
  • Support for passing values from page to page. This will be a standardization of the many different Dialog/Conversation/Scope/Flash ideas currently in use.
  • “Skinning”, or “Themeing” of components.
  • An important target user for JavaServer Faces technology is the developer who relies on an Internet Service Provider (ISPv) to host their application, as well as hosting their development environment. It must be easy to iteratively develop a JavaServer Faces application that is hosted entirely on an ISP.
]]> http://www.javabeat.net/2008/07/new-features-in-jsf-2-0/feed/ 0 Implement Internationalization and Localization in JSF http://www.javabeat.net/2008/07/implement-internationalization-and-localization-in-jsf/ http://www.javabeat.net/2008/07/implement-internationalization-and-localization-in-jsf/#comments Thu, 24 Jul 2008 10:53:44 +0000 JavaBeat http://www.javabeat.net/examples/?p=186 Connect to us ( @twitter | @facebook )

Internationalization and Localization Internationalization and Localization are important features for an web based application. Internationalization is implementing the features in your application to support multiple languages. Localization is creating text in a specific language that is presented through an internationalized application The following example program demonstrates very simple program for implementing this concepts. if you [...]

]]> Connect to us ( @twitter | @facebook )

Internationalization and Localization

Internationalization and Localization are important features for an web based application. Internationalization is implementing the features in your application to support multiple languages. Localization is creating text in a specific language that is presented through an internationalized application

The following example program demonstrates very simple program for implementing this concepts. if you llok into the faces-config.xml file,locale-config element is used for specifying the default locale and supported locale information. In this sample application we have provided default as English and supported as French.

Use resource-bundle element to specify the name of the properties file to be used. For exmaple if you create a resource bundle name as Messages, then all the language letters will be suffixed with the file name.In our case French locale is named as “Messages_fr”.The default will be “en”, it is not required to specify explicitly.

1
2
3
4
5
6
7
8
9
10
11
12
13

 
<%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%>
<%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%>
<html>
    <body>
        <f:view>
            <h:form>
                <h:commandButton value="#{msg.cancel}" action="fail"/>
                <h:commandButton value="#{msg.submit}" action="success"/>
            </h:form>
        </f:view>
    </body>
</html>

faces-config.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

 
<?xml version='1.0' encoding='UTF-8'?>
<faces-config version="1.2"
    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-facesconfig_1_2.xsd">
    <application>
        <locale-config>
            <default-locale>en</default-locale>
            <supported-locale>fr</supported-locale>
            <supported-locale>de</supported-locale>
        </locale-config>
        <resource-bundle>
            <base-name>javabeat.net.messages.Messages</base-name>
            <var>msg</var>
        </resource-bundle>
    </application>
</faces-config>

Messages.properties

1
2

cancel=Cancel
submit=Submit

Messages_fr.properties

1
2

cancel=annuler
submit=envoyer
]]> http://www.javabeat.net/2008/07/implement-internationalization-and-localization-in-jsf/feed/ 0