Those of you who are Infragistics customers will by now have read their notice that they are discontinuing their JSF efforts. The 9.2 version of NetAdvantage for JSF is the last. They will continue support for a year.

I have left Infragistics and am currently involved in developing a large JSF application using Tomahawk.

I will continue this blog but with a greater emphasis on the larger JSF world. If you have questions about NetAdvantage feel free to post them here. I will do what I can to help you.

Introduction

Quite some time back I had wrote an article about “Charts in JSF using Primefaces”, where I had specified the ways to construct the commonly used charts for a web application. But in this article let us learn how to construct a chart that displays the live data. Primefaces charts has built in support for ajax-polling and provides a feature for diplaying live, dynamic, real-time data which is based on flash. This feature may be used in our real time application to indicate the changing temperatures or to show the profit/loss in a stock market. Before proceeding in to this article, you need to configure Primefaces along with JSF in your favourite IDE. I hope the article “Step by step tutorial to setup Primefaces in Netbeans” would be helpful to do so, and also we should have the prerequisites stated below,

Things You’ll Need

• Your Favourite IDE
• Tomcat 6.x/Glassfish/Jboss
• JDK 1.5 and above

I assume that you had configured the primefaces in your favourite IDE and now let us start constructing live charts for a JSF application using Primefaces. Thanks for the excellent resource provided in the Primefaces wiki and the charts are,

1. Live Pie Chart
2. Live Column Chart
3. Live Bar Chart

Live Pie Chart

A pie chart illustrates percentage and shows the proportional size of items that make up a data series to the sum of the items. it always shows only one data series and is useful when you want to emphasize a significant element. Inorder to construct Live Pie charts in JSF using Primefaces, we shall construct a sample page which shows the “Lunch sales of a shop”. Let us begin by creating a backing bean for the pie chart, and it requires two backing bean named PieChartLiveBean and LunchSalesBean.

PieChartLiveBean.java

This backing bean contains the actual data to be feeded in the Live Pie Chart.

package com.sample.primefaces;

/**
 *
 * @author Giftsam
 */
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

public class PieChartLiveBean implements Serializable
{

 private List<LunchSalesBean> lunchSalesList;

 public PieChartLiveBean()
 {
 lunchSalesList = new ArrayList<LunchSalesBean>();
 lunchSalesList.add(new LunchSalesBean("Beverages", 10));
 lunchSalesList.add(new LunchSalesBean("Desserts", 8));
 lunchSalesList.add(new LunchSalesBean("Soup", 4));
 lunchSalesList.add(new LunchSalesBean("Sandwiches", 6));
 }

 public List<LunchSalesBean> getLunchSalesList()
 {
 int beveragesPercent = (int) (Math.random() * 100);
 int dessertsPercent = (int) (Math.random() * 100);
 int soupPercent = (int) (Math.random() * 100);
 int sandwitchesPercent = (int) (Math.random() * 100);

 lunchSalesList.get(0).setSalesPercentage(beveragesPercent);
 lunchSalesList.get(1).setSalesPercentage(dessertsPercent);
 lunchSalesList.get(2).setSalesPercentage(soupPercent);
 lunchSalesList.get(3).setSalesPercentage(sandwitchesPercent);
 return lunchSalesList;
 }
}

LunchSalesBean.java

This class contains the details of the dishes available in the shop. (ie) the dish name and the sales percent of the particular dish, which is to be feeded by PieChartLiveBean Class.

package com.sample.primefaces;

/**
 *
 * @author Giftsam
 */
public class LunchSalesBean
{

 private String dishName;
 private int salesPercentage;

 public LunchSalesBean()
 {
 }

 public LunchSalesBean(String dishName, int salesPercentage)
 {
 this.dishName = dishName;
 this.salesPercentage = salesPercentage;
 }

 /**
 * @return the dishName
 */
 public String getDishName()
 {
 return dishName;
 }

 /**
 * @param dishName the dishName to set
 */
 public void setDishName(String dishName)
 {
 this.dishName = dishName;
 }

 /**
 * @return the salesPercentage
 */
 public int getSalesPercentage()
 {
 return salesPercentage;
 }

 /**
 * @param salesPercentage the salesPercentage to set
 */
 public void setSalesPercentage(int salesPercentage)
 {
 this.salesPercentage = salesPercentage;
 }
}

Now we had created the Data for the chart and next we need a write a managed bean for PieChartLiveBean class in the faces-config.xml.

<managed-bean>
<managed-bean-name>PieChartLiveBean</managed-bean-name>
<managed-bean-class>com.sample.primefaces.PieChartLiveBean</managed-bean-class>
<managed-bean-scope>session</managed-bean-scope>
</managed-bean>

And finally we need to create a JSP document. Let us name the JSP document as pieChartLive.jsp and it contains the following code,

pieChartLive.jsp

<%--
 Document   : pieChartLive
 Author     : Giftsam
--%>

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
 pageEncoding="ISO-8859-1"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
 "http://www.w3.org/TR/html4/loose.dtd">
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<%@ taglib uri="http://richfaces.org/a4j" prefix="a4j"%>
<%@ taglib uri="http://richfaces.org/rich" prefix="rich"%>
<%@ taglib uri="http://primefaces.prime.com.tr/ui" prefix="p" %>

<f:view>
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>PieChartLive</title>
 <p:resources/>
 </head>
 <body>
 <h:form id="livePieChartForm">
 <p:pieChart id="votes" value="#{PieChartLiveBean.lunchSalesList}" var="lunchSalesBean"
 live="true" refreshInterval="3000"
 categoryField="#{lunchSalesBean.dishName}" dataField="#{lunchSalesBean.salesPercentage}" />
 </h:form>
 </body>
 </html>
</f:view>

Attributes Used

Attributes used for the above live pie chart are

categoryField – used to specify the pie section of the chart.

dataField – holds the value of the corresponding categoryField.

live – Set to true inorder to get live/dynamic datas.

refreshInterval – specifies the polling, values should be given in milliseconds.

Now the construction of  live pie chart is completed and now the datas in the pie chart will be dynamically changed for every 3 seconds interval. For online demos visit the Primefaces demo site. Now let us have look on the snap of our chart.

Live PieChart Snap(Lunch Sales)

Now its time to move on to construct the next chart type (ie) the live column chart.

Live ColumnChart

A column chart is used to demonstrate the data changes over a period of time or exemplifies comparisons among  the items. Categories are organized horizontally, values vertically, to emphasize variation over time. In this example we shall construct a sample page which shows the sales of the managers in two quarters. Let us begin by creating a backing bean for the live column chart, and it requires two backing bean named LiveChartBean and salesBean.

LiveChartBean.java

This backing bean contains the actual data to be feeded in the Live Column Chart.

package com.sample.primefaces;

import java.util.ArrayList;
import java.util.List;

/**
 *
 * @author Giftsam
 */
public class LiveChartBean
{
 private List<SalesBean> salesBeanList;

 public LiveChartBean()
 {
 salesBeanList = new ArrayList<SalesBean>();
 salesBeanList.add(new SalesBean("Peter", 1000, 500));
 salesBeanList.add(new SalesBean("Kumar", 400, 600));
 salesBeanList.add(new SalesBean("Jack", 700, 600));
 }

 /**
 * @return the salesBeanList
 */
 public List<SalesBean> getSalesBeanList()
 {
 int peterFirstQuaterProfit = (int) (Math.random() * 100000);
 int peterSecondtQuaterProfit = (int) (Math.random() * 100000);
 int kumarFirstQuaterProfit = (int) (Math.random() * 100000);
 int kumarSecondQuaterProfit = (int) (Math.random() * 100000);
 int jackFirstQuaterProfit = (int) (Math.random() * 100000);
 int jackSecondQuaterProfit = (int) (Math.random() * 100000);

 salesBeanList.get(0).setFirstQuaterSales(peterFirstQuaterProfit);
 salesBeanList.get(0).setSecondQuaterSales(peterSecondtQuaterProfit);
 salesBeanList.get(1).setFirstQuaterSales(kumarFirstQuaterProfit);
 salesBeanList.get(1).setSecondQuaterSales(kumarSecondQuaterProfit);
 salesBeanList.get(2).setFirstQuaterSales(jackFirstQuaterProfit);
 salesBeanList.get(2).setSecondQuaterSales(jackSecondQuaterProfit);
 return salesBeanList;
 }
}

SalesBean.java

This class contains the sales details of the three managers Peter, Kumar and Jack. (ie) the manager name and the sales profit details of the relevant manager in two quaters, which is to be feeded by LiveChartBean Class.

package com.sample.primefaces;

/**
 *
 * @author Giftsam
 */
public class SalesBean
{
private String managerName;
 private int firstQuaterSales;
 private int secondQuaterSales;

 public SalesBean()
 {
 }

 public SalesBean(String managerName, int firstQuaterSales, int secondQuaterSales)
 {
 this.managerName = managerName;
 this.firstQuaterSales = firstQuaterSales;
 this.secondQuaterSales = secondQuaterSales;
 }

 /**
 * @return the managerName
 */
 public String getManagerName()
 {
 return managerName;
 }

 /**
 * @param managerName the managerName to set
 */
 public void setManagerName(String managerName)
 {
 this.managerName = managerName;
 }

 /**
 * @return the firstQuaterSales
 */
 public int getFirstQuaterSales()
 {
 return firstQuaterSales;
 }

 /**
 * @param firstQuaterSales the firstQuaterSales to set
 */
 public void setFirstQuaterSales(int firstQuaterSales)
 {
 this.firstQuaterSales = firstQuaterSales;
 }

 /**
 * @return the secondQuaterSales
 */
 public int getSecondQuaterSales()
 {
 return secondQuaterSales;
 }

 /**
 * @param secondQuaterSales the secondQuaterSales to set
 */
 public void setSecondQuaterSales(int secondQuaterSales)
 {
 this.secondQuaterSales = secondQuaterSales;
 }
}

Now we had created the Data for the chart and next we need a write a managed bean for LiveChartBean class in the faces-config.xml.

<managed-bean>
 <managed-bean-name>LiveChartBean</managed-bean-name>
 <managed-bean-class>com.sample.primefaces.LiveChartBean</managed-bean-class>
 <managed-bean-scope>session</managed-bean-scope>
 </managed-bean>

And finally we need to create a JSP document. Let us name the JSP document as columnChartLive.jsp and it contains the following code,

columnChartLive.jsp

<%--
 Document   : columnChartLive
 Author     : Giftsam
 --%>

 <%@ page language="java" contentType="text/html; charset=ISO-8859-1"
 pageEncoding="ISO-8859-1"%>
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
 "http://www.w3.org/TR/html4/loose.dtd">
 <%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
 <%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
 <%@ taglib uri="http://richfaces.org/a4j" prefix="a4j"%>
 <%@ taglib uri="http://richfaces.org/rich" prefix="rich"%>
 <%@ taglib uri="http://primefaces.prime.com.tr/ui" prefix="p" %>

 <f:view>
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Live ColumnChart</title>
 <p:resources/>
 </head>
 <body>
 <h:form>
 <p:columnChart value="#{LiveChartBean.salesBeanList}" live="true" refreshInterval="3000" var="salesBean" xfield="#{salesBean.managerName}">
 <p:chartSeries label="First Quater" value="#{salesBean.firstQuaterSales}" />
 <p:chartSeries label="Second Quater" value="#{salesBean.secondQuaterSales}" />
 </p:columnChart>
 </h:form>
 </body>
 </html>
 </f:view>

Attributes Used

Attributes used for the above live column chart are,

xfield – denotes the x-axis of the chart.

<p:chartSeries> tag – used to construct the horizontal lines for the chart.

live – Set to true inorder to get live/dynamic datas.

refreshInterval – specifies the polling, values should be given in milliseconds.

Now the construction of  live column chart is completed and let us have look on the snap of our chart.

Live ColumnChart Snap(Sales of the managers in two quaters)

By invoking the above code the column chart will have dynamic datas for every 3 seconds interval. Now let us learn how to construct the live bar chart.

Live BarChart

A bar chart is used to illustrate comparison among individual items. In bar chart categories are organized vertically and values horizontally inorder to focus on comparing values and to place less emphasis on time. Now for live bar chart, let us conjure the same backing bean which we invoked for live column chart. Only thing we need to create a JSP document. Let us name the JSP document as barChartLive.jsp and it contains the following code,

barChartLive.jsp

<%--
 Document   : barChartLive
 Author     : Giftsam
 --%>

 <%@ page language="java" contentType="text/html; charset=ISO-8859-1"
 pageEncoding="ISO-8859-1"%>
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
 "http://www.w3.org/TR/html4/loose.dtd">
 <%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
 <%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
 <%@ taglib uri="http://richfaces.org/a4j" prefix="a4j"%>
 <%@ taglib uri="http://richfaces.org/rich" prefix="rich"%>
 <%@ taglib uri="http://primefaces.prime.com.tr/ui" prefix="p" %>

 <f:view>
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Live BarChart</title>
 <p:resources/>
 </head>
 <body>
 <h:form>
 <p:barChart value="#{LiveChartBean.salesBeanList}" live="true" refreshInterval="3000"
 var="salesBean" yfield="#{salesBean.managerName}">
 <p:chartSeries label="First Quater" value="#{salesBean.firstQuaterSales}" />
 <p:chartSeries label="Second Quater" value="#{salesBean.secondQuaterSales}" />
 </p:barChart>
 </h:form>
 </body>
 </html>
 </f:view>

Attributes Used

Attributes used for the above live bar chart are,

yfield – denotes the y-axis of the chart.

<p:chartSeries> tag – used to construct the horizontal lines for the chart.

live – Set to true inorder to get live/dynamic datas.

refreshInterval – specifies the polling, values should be given in milliseconds.

Now the construction of  live bar chart is completed and now  its value will be refreshed for every 3 seconds interval. Let us have look on the snap of our chart.

Live BarChart Snap(Sales of the managers in two quaters)

Thats all folks. I hope this article clearly explains the construction of live charts for a JSF application using Primefaces. If you find this article is useful for you, dont forget to give me your valuable comments. Have a joyous code day.

Esses dias quando estava desenvolvendo minha primeira aplicação com o JSF fiquei na duvida de como realizar a comunicação entre backbeans com escopo de sessão.

Acabei utilizando a solução de colocar os beans nas propriedades da sessão, sendo que quando outro backbean precisar se comunicar o mesmo acessa as propriedades da sessão buscando o bean desejado.

Hoje descobri que existe uma segunda alternativa para resolver esse problema,  basta acessar a própria instancia criada pelo framework JSF, da seguinte maneira:

FacesContext context = FacesContext.getCurrentInstance();
//trocar o backBean pelo tipo do bean será buscado Ex: LoginManagerBean
backBean bean = (backBean) context.getExternalContext().getSessionMap().get("nome do backbean no faces-config");

Essa segunda alternativa me parece mais interessante, pois, não é necessário ficar gerenciando a criação dos beans nas propriedades da sessão. O um dos únicos cuidados é se certificar que no momento em que o bean for acessado/buscado, o mesmo já tenha sido “instanciado”/construído pelo sistema.

Referência AQUI:

Introduction

In this article we shall learn how to export the data from the web page to a PDF, xls, xml and csv format in a JSF application, that may be very useful while generating a report for a web application project. Now we are going to use a component library named Primefaces, which has more than 70+ ajax powered components that enriches our web application with rich look and feel. So here we are going to invoke a Primefaces component named Data Exporter which is used to export the datas in the web page to a  PDF, xls, xml and csv format. I am damn sure, Primefaces reduces the complexity for the developers while constructing a report for a web application.

Prerequisites

• IDE – Your favourite IDE
• Tomcat 6.x/Glassfish/Jboss
• JDK 1.5 and above

I assume that you had configured the Primefaces in your favourite IDE and now in this article let us learn by a sample “Seven wonders of the world” represented in a datatable and let us see how the datas in the data table are exported  in to a PDF, xls, xml and csv format. First let  us begin by creating a backing bean class named DataExporterBean and DataTableBean.

DataExporterBean.java

This is the backing bean class for the data exporter.

package com.shunmuga.primefaces;

import java.util.ArrayList;
import java.util.List;

/**
 *
 * @author shunmuga
 */
public class DataExPorterBean
{

 private List<DataTableBean> dataTableBeanList = new ArrayList<DataTableBean>();

 /**
 * Create new Instance of the class
 */
 public DataExPorterBean()
 {
 initialzeComponents();
 }

 /**
 * This method is used to populate the required data table
 * data when the constructor is initialized.
 */
 private void initialzeComponents()
 {
 if (!dataTableBeanList.isEmpty())
 {
 dataTableBeanList.clear();
 }
 DataTableBean dataTableBean = new DataTableBean();
 dataTableBean.setWonders("Machu Picchu");
 dataTableBean.setCountry("Peru");
 dataTableBean.setDateOfConstruction("1460-1470");
 dataTableBeanList.add(dataTableBean);

 dataTableBean = new DataTableBean();
 dataTableBean.setWonders("Giza Pyramid Complex");
 dataTableBean.setCountry("Egypt");
 dataTableBean.setDateOfConstruction("2584-2561 BC");
 dataTableBeanList.add(dataTableBean);

 dataTableBean = new DataTableBean();
 dataTableBean.setWonders("Taj Mahal");
 dataTableBean.setCountry("Agra,India");
 dataTableBean.setDateOfConstruction("1630 A.D.");
 dataTableBeanList.add(dataTableBean);

 dataTableBean = new DataTableBean();
 dataTableBean.setWonders("Petra");
 dataTableBean.setCountry("Jordan");
 dataTableBean.setDateOfConstruction("9 B.C. – 40 A.D.");
 dataTableBeanList.add(dataTableBean);

 dataTableBean = new DataTableBean();
 dataTableBean.setWonders("Great Wall of China");
 dataTableBean.setCountry("China");
 dataTableBean.setDateOfConstruction("220 B.C and 1368 – 1644 A.D.");
 dataTableBeanList.add(dataTableBean);

 dataTableBean = new DataTableBean();
 dataTableBean.setWonders("Christ the Redeemer");
 dataTableBean.setCountry("Brazil");
 dataTableBean.setDateOfConstruction("1931");
 dataTableBeanList.add(dataTableBean);

 dataTableBean = new DataTableBean();
 dataTableBean.setWonders("Colosseum");
 dataTableBean.setCountry("Rom Italy");
 dataTableBean.setDateOfConstruction("70 – 82 A.D");
 dataTableBeanList.add(dataTableBean);

 }

 /**
 * @return the dataTableBeanList
 */
 public List<DataTableBean> getDataTableBeanList()
 {
 return dataTableBeanList;
 }

 /**
 * @param dataTableBeanList the dataTableBeanList to set
 */
 public void setDataTableBeanList(List<DataTableBean> dataTableBeanList)
 {
 this.dataTableBeanList = dataTableBeanList;
 }
}

DataTableBean.java

This class contains the required data to populate the data table such as wonder, country and the details of the seven wonders construction.

package com.shunmuga.primefaces;

/**
 *
 * @author shunmuga
 */
public class DataTableBean
{

 public DataTableBean()
 {
 }
 private String wonders;
 private String country;
 private String dateOfConstruction;

 /**
 * @return the country
 */
 public String getCountry()
 {
 return country;
 }

 /**
 * @param country the country to set
 */
 public void setCountry(String country)
 {
 this.country = country;
 }

 /**
 * @return the wonders
 */
 public String getWonders()
 {
 return wonders;
 }

 /**
 * @param wonders the wonders to set
 */
 public void setWonders(String wonders)
 {
 this.wonders = wonders;
 }

 /**
 * @return the dateOfConstruction
 */
 public String getDateOfConstruction()
 {
 return dateOfConstruction;
 }

 /**
 * @param dateOfConstruction the dateOfConstruction to set
 */
 public void setDateOfConstruction(String dateOfConstruction)
 {
 this.dateOfConstruction = dateOfConstruction;
 }
}

Now the datas are populated in the data table and now let us construct a managed bean for the DataExporterBean class in the faces-config.xml

<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">
<managed-bean>
 <description>Managed bean for Export type </description>
 <managed-bean-name>DataExporterBean</managed-bean-name>
 <managed-bean-class>com.shunmuga.primefaces.DataExPorterBean</managed-bean-class>
 <managed-bean-scope>request</managed-bean-scope>
</managed-bean>

</faces-config>

Only one thing is left to export, (ie) we need create a JSP page. Let us name the JSP document as dataExporter.jsp and it contains the following code

<%@page contentType="text/html" pageEncoding="UTF-8"%>

<%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%>
<%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%>
<%@ taglib uri="http://richfaces.org/a4j" prefix="a4j"%>
<%@ taglib uri="http://richfaces.org/rich" prefix="rich"%>
<%@taglib uri="http://primefaces.prime.com.tr/ui" prefix="p" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
 "http://www.w3.org/TR/html4/loose.dtd">

<f:view>
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
 <title>Data Exporter</title>
 <p:resources/>
 </head>
 <body>
 <h:form id="dataExporterPageForm">

 <p:panel header="New Seven Wonders of the World" style="position:relative; width: 532px;">
 <f:facet name="tittle">
 <h:outputText value="DataExporterSample"/>
 </f:facet>

 <%--DataTable contains seven wonders details --%>

 <p:dataTable value="#{DataExporterBean.dataTableBeanList}"
 id="Wonders"
 rows="7"
 var="dataTableBean">

 <%-- country name column --%>

 <p:column>
 <f:facet name="header">
 <h:outputText value="Wonders" />
 </f:facet>
 <h:outputText value="#{dataTableBean.wonders}" />
 </p:column>

 <%-- country name column --%>

 <p:column>
 <f:facet name="header">
 <h:outputText value="Country" />
 </f:facet>
 <h:outputText value="#{dataTableBean.country}" />
 </p:column>

 <%-- dateOfConstruction column --%>

 <p:column resizable="true">
 <f:facet name="header">
 <h:outputText value="Date OF Construction" />
 </f:facet>
 <h:outputText value="#{dataTableBean.dateOfConstruction}"/>
 </p:column>

 </p:dataTable>
 <h:panelGrid columns="4">

 <%--This is PDF Exporting command link --%>
 <h:commandLink>
 <h:outputText  value="PDF" />
 <p:dataExporter type="pdf" target="Wonders"  fileName="SevenWonders"/>
 </h:commandLink>

 <%--This is XLs Exporting command link --%>
 <h:commandLink>
 <h:outputText  value="XL" />
 <p:dataExporter type="xls" target="Wonders"  fileName="SevenWonders"/>
 </h:commandLink>

 <%--This is XML Exporting command link --%>
 <h:commandLink>
 <h:outputText  value="XML" />
 <p:dataExporter type="xml" target="Wonders"  fileName="SevenWonders"/>
 </h:commandLink>

 <%--This is CSV Exporting command link --%>
 <h:commandLink>
 <h:outputText  value="CSV" />
 <p:dataExporter type="csv" target="Wonders"  fileName="SevenWonders"/>
 </h:commandLink>
 </h:panelGrid>
 </p:panel>
 </h:form>
 </body>
 </html>
</f:view>

By now we had completed the coding part and now let us have a look on the snap shot of our sample DataExporter application.

Snap Shot

In the preceding window, you can export the datas from the data table by clicking the relevant command link specified in the bottom of the data table. I believe this article clearly explains how to use the Primefaces Data Exporter component to export the datas from the web application. If you find this article is useful to you, dont forget to give your valuable comments. Have a joyous day.

This page describes the process of integrating the Spring framework with JSF. We will take an application that already has JSF and Spring components fully initialized and ready to go. We will prove this by displaying 2 links that allow those 2 frameworks to draw a page.

The integration will consist of having the user submit a JSF page. The JSF framework will handle the page submit and pass the information on to a spring enabled beans.

Spring MVC is not absolutely required to get this to work. You could have only used the core spring (DI) container but for the purposes of this page we will have it hang around.

Requirements

• Maven2
• Basic understanding of IOC and The Spring
• Basic understanding of JSF

Having JSF Managed Beans Delegate to Spring Managed Beans

We will be using the popular “DelegatingVariableResolver” to integrate these two frameworks together. The DelegatingVariableResolver class provides the ability for Spring managed beans to be injected into JSF manged beans. This is a powerful technique to allow business logic that is managed in the spring container  available for JSF applications to use.

Creating the Project

We will create this project using an archetype and walk thru the different parts that make this all work.

generate

mvn archetype:generate -DarchetypeGroupId=org.vtechfw -DarchetypeArtifactId=springmvc-jsf-archetype -DarchetypeVersion=1.0-SNAPSHOT -DarchetypeRepository=http://www.vermatech.com/m2repo

Maven will prompt you for some information. It is best to answer like the following.

groupId: testpackage
artifactId: springJSF

Hit enter for defaults for the rest of the questions.

Run

cd to the project’s directory. (cd springJSF)

mvn jetty:run

View the project

Navigate to the following page: http://localhost:8080/

1. The spring mvc configuration is read applicationContext.xml and spring-servlet.xml
2. The faces configuration file is read faces-config.xml

The system completes the initialization and the web application is ready to serve requests at http://localhost:8080

The application displays a welcome page with 2 links. One points to the Faces JSP file that displays a text box that allows the user to enter values and submit. The second link displays a welcome page that is rendered by the SpringMVC framework.

How to get JSF to use Spring Beans Works

Enable the JSF system to use DelegatingVariableResolver.

Add the following in the faces-config.xml

<application>
   <variable-resolver>org.springframework.web.jsf.DelegatingVariableResolver</variable-resolver>
</application>

Create a Spring Managed Bean

Actually you dont need to create one if you already generated the project. For documentation purposes the bean is listed here.

package testpackage.quickstart.springmvc;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

import org.springframework.stereotype.Service;

@Service("datePrintModel")
public class DatePrintModelImpl implements DatePrintModel {
	private DateFormat dateFormat = new SimpleDateFormat("EEE, d MMM yyyy HH:mm:ss Z");

	public String getDateAsString() {
		System.out.println("getDataAsString called.");
		return dateFormat.format(new Date());
	}
}

Setup the JSF Managed Bean

Add the DatePrintModel and its setters and getters to the managed been below.

After the change it should look something like this.

package testpackage.jsftest;

import javax.faces.event.ValueChangeEvent;

import testpackage.quickstart.springmvc.DatePrintModel;

public class MessageModel {

	private DatePrintModel datePrintModel;

	public DatePrintModel getDatePrintModel() {
		return datePrintModel;
	}

	public void setDatePrintModel(DatePrintModel datePrintModel) {
		this.datePrintModel = datePrintModel;
	}

	public void printMessage(ValueChangeEvent e) {
		System.out.println("old value was: " + e.getOldValue());
		System.out.println("new value is: " + e.getNewValue());
	}

	public void callSpringModel() {
		System.out.println("calling the spring model...");
		datePrintModel.getDateAsString();
	}
}

Modify the faces-config.xml to look like this…

<?xml version='1.0' encoding='UTF-8'?>
<faces-config 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"
              version="1.2">

<managed-bean>
	<managed-bean-name>message</managed-bean-name>
	<managed-bean-class>java.lang.String</managed-bean-class>
	<managed-bean-scope>session</managed-bean-scope>
</managed-bean>
<managed-bean>
	<managed-bean-name>messageModel</managed-bean-name>
	<managed-bean-class>testpackage.jsftest.MessageModel</managed-bean-class>
	<managed-bean-scope>session</managed-bean-scope>
	<managed-property>
		<property-name>datePrintModel</property-name>
		<value>#{datePrintModel}</value>
	</managed-property>
</managed-bean>
</faces-config>

As you can see above the managed-bean property has been added.

Modify the JSP

helloWorld.jsp

<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="f" uri="http://java.sun.com/jsf/core" %>
<%@ taglib prefix="h" uri="http://java.sun.com/jsf/html" %>

<f:view>
    <html>
    <head>
        <title>Hello World JSF Example</title>
    </head>
    <body>
    <h:form>
		<p>This is a simple hello world page using Faces.</p>
		<p>Enter your message here: <br/>
		<h:inputText valueChangeListener="#{messageModel.printMessage}" value="#{message}" size="35"/></p>
		<h:commandButton value="Submit" action="#{messageModel.callSpringModel}"/>
    </h:form>
    <p>after submit check server console for output.</p>
    </body>
    </html>
</f:view>

Run and view The Project

mvn jetty:run

http://localhost:8080

That’s all for now!

A few days ago I wrote a post about the F-35 Lightning II is a fifth-generation, single-seat, single-engine, stealth multirole fighter, that will also equip the Aeronautica Militare (Italian Air Force, ItAF) and the Marina Militare, that will use the F-35B from the new Cavour STOVL aircraft carrier. In spite of a carrier variant designated F-35C, the RAF and Royal Navy will use the B variant from aircraft carriers and the U.S. Marines Corps are investigating the use of the Ship-borne Rolling and Vertical Landing (SRVL) method to operate F-35Bs from the aircraft carrier without disrupting carrier operations as the landing method uses the same pattern of approach as wire arrested landings. The F-35C carrier (whose only user will be the US Navy to replace the “legacy Hornets” and complement the Super Hornets) variant will be much similar to the A and B versions, but will have larger, folding wings and larger control surfaces for improved low-speed control. The aircraft will also be equipped with a stronger landing gear and hook for the stresses of carrier trap landings.

The following front, side and top views of the three variants will give an idea of the main differences among the F-35A, B and C.

There seems to be a lot of fuss going on about JSF partner nations not getting to have access to the software code to the F-35. This has come up before and really isn’t all that new of an issue.

First, is this a loss of soveriengty to non-U.S. F-35 users? You bet it is. The countries that signed on for the F-35 knew this for a long time. It is part of the agreement. Not only that but the U.S. will have all the access they need to the embedded logistics and maintenance metrics for every mission. This gives LM knowns for not only better supporting the customer but to have a large advantage for any replacement down the line. This is great metrics for future sales.

But it goes further than deskilling home industry and loss of soveignty.

The whole idea is that everyone goes to war with the same jet and just as important the same software version maintained to the same standard. Don’t like it? Buy another jet. You sign up for the program that is what you get. And within reason it makes a lot of sense as long as undue advantage isn’t taken as mentioned above.

But there is more. That is security and what defines safely exportable U.S. technology. Buy letting just anyone have access to the software, one has better knowledge to the method of the madness that makes up the predictive surviability in the aircraft. That is in part those expanding and deminishing threat circles on the display showing an enemy emitter and how much exposure your low observables can tollerate before you are seen by the enemy.

Keeping the software closed-access is how the F-35 can be allowed to be exported within the confines of U.S. law. As this article explains, while there may not be different F-35 variants for different countries based on “their requirements”, a case can be made that there are certainly different configurations and not everyone will have an F-35 like the USAF.

.

This page will describe the process of creating a JSF application and running it within 10 minutes.

Requirements

• Maven 2

Generate the web application

First we start with a maven archetype

mvn archetype:generate

Choose option 18 which is a (maven-archetype-webapp)

For the group id enter: test

For the artifactId enter: jsfTestWeb

cd to the project directory and modify the pom.xml file. It should look like this…

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>test</groupId>
	<artifactId>jsfTestWeb</artifactId>
	<packaging>war</packaging>
	<version>1.0-SNAPSHOT</version>
	<name>jsfTestWeb Maven Webapp</name>
	<url>http://maven.apache.org</url>
	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>3.8.1</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>javax.faces</groupId>
			<artifactId>jsf-api</artifactId>
			<version>1.2_02</version>
		</dependency>
		<dependency>
			<groupId>javax.faces</groupId>
			<artifactId>jsf-impl</artifactId>
			<version>1.2-b19</version>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
			<version>1.1.2</version>
		</dependency>
		<dependency>
			<groupId>taglibs</groupId>
			<artifactId>standard</artifactId>
			<version>1.1.2</version>
		</dependency>
	</dependencies>
	<build>
		<finalName>jsfTestWeb</finalName>
		<plugins>
			<plugin>
				<groupId>org.mortbay.jetty</groupId>
				<artifactId>jetty-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

Modify the WEB-INF/web.xml

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <servlet>
  	<servlet-name>Faces Servlet</servlet-name>
  	<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
  	<load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
  	<servlet-name>Faces Servlet</servlet-name>
  	<url-pattern>*.faces</url-pattern>
  </servlet-mapping>

  <welcome-file-list>
  	<welcome-file>index.jsp</welcome-file>
  </welcome-file-list>

</web-app>

Create a WEB-INF/faces-config.xml

<?xml version='1.0' encoding='UTF-8'?>
<faces-config 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"
              version="1.2">

<managed-bean>
	<managed-bean-name>message</managed-bean-name>
	<managed-bean-class>java.lang.String</managed-bean-class>
	<managed-bean-scope>session</managed-bean-scope>
</managed-bean>
<managed-bean>
	<managed-bean-name>messageModel</managed-bean-name>
	<managed-bean-class>test.MessageModel</managed-bean-class>
	<managed-bean-scope>session</managed-bean-scope>
</managed-bean>
</faces-config>

Create a jsp helloWorld.jsp

<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="f" uri="http://java.sun.com/jsf/core" %>
<%@ taglib prefix="h" uri="http://java.sun.com/jsf/html" %>

<f:view>
    <html>
    <head>
        <title>Hello World JSF Example</title>
    </head>
    <body>
    <h:form>
		<p>This is a simple hello world page using Faces.</p>
		<p>Enter your message here: <br/>
		<h:inputText valueChangeListener="#{messageModel.printMessage}" value="#{message}" size="35"/></p>
		<h:commandButton value="Submit" action="submit"/>
    </h:form>
    </body>
    </html>
</f:view>

Create a managed Bean

src/main/java/test.MessageModel.java

package test;

import javax.faces.event.ValueChangeEvent;

public class MessageModel {
	public void printMessage(ValueChangeEvent e) {
		System.out.println("old value was: " + e.getOldValue());
		System.out.println("new value is: " + e.getNewValue());
	}
}

Run the JSF application

Save all files and run the application in jetty.

mvn jetty:run

The application should come up when you point your browser to http://localhost:8080

Type in some text and you should see some output on the console window.

Right click on the page and click view source. You will notice JSF generated code.

That’s all for Now!

Que nos ofrece un framework de desarrollo como JSF. Estos son algunos de los puntos calves que nos ofrece afrontar nuestros desarrollos con JSF como base.

• Modelo de componentes reutilizables
• Control de datos asociados a cada componente de interfaz
• Focalizar los esfuerzos en la aplicación
• Gestion de mensajes
• Gestion de Errores
• Definición de un método para crear nuevos componentes
• Separación de la capa de presentación
• Diferenciación de roles
• Estandarización
• Gestión de las navegaciones
• Validaciones

Independientemente de JSF, un framework siempre nos debería aportar

• Productividad
• Best practices y patrones de diseño
• Calidad, estructuracion
• Mantenibilidad
• Flexibilidad
• Apertura en el mercado

Mas info: Framework

Hi,

if you want to make a 4 dependent selectonemenus with ajax, you can use the following code :

and that is it. The java part is not also easy. you just have getters setters for country,city …. just do not forget to put your bean in view scope or session scope.

Introduction

In the Previous days the charts can be created in the JSF application with the use of JSF Chart Creator, But now while surfing the net the peoples suggested to get rid of JSF Chart Creator and to focus on Primefaces charts. Definitely I am sure Primefaces provides the easiest ways to create charts components in a JSF application which is based on flash based YUI charts. In this article we are going to construct the most commonly used chart types in a JSF application with the use of Primefaces. Before proceeding to the construction of charts first we need to configure Primefaces for a JSF application. I hope the article “Step by step tutorial to setup Primefaces in Netbeans” would be helpful to do so, and also we should have the prerequisites stated below,

Things You’ll Need

• Your Favourite IDE
• Tomcat 6.x/Glassfish/Jboss
• JDK 1.5 and above

I assume that you had configured the primefaces in your favourite IDE and now let us start constructing some of the commonly used charts types. Thanks for the excellent resource provided in the Primefaces wiki and the charts are,

1. Pie Chart
2. Line Chart
3. Column Chart

Pie Chart

Pie charts are useful for showing relationship (percentage) of parts to a whole. In this example we shall construct a sample page which shows the average page hits of four bloggers A, B, C and D. Let us begin by creating a backing bean for the pie chart, and it requires two backing bean named PieChartBean and PieChartContentBean.

PieChartBean.java

This backing bean contains the actual data to be feeded in the Pie Chart.

package com.sample.primefaces;

import java.util.ArrayList;
import java.util.List;
/**
 *
 * @author Giftsam
 */
public class PieChartBean
{

 private List<PieChartContentBean> pieChartContentBeanList;

 public PieChartBean()
 {
 pieChartContentBeanList = new ArrayList<PieChartContentBean>();
 pieChartContentBeanList.add(new PieChartContentBean("Blogger A", 192));
 pieChartContentBeanList.add(new PieChartContentBean("Blogger B", 762));
 pieChartContentBeanList.add(new PieChartContentBean("Blogger C", 245));
 pieChartContentBeanList.add(new PieChartContentBean("Blogger D", 661));
 }

 /**
 * @return the pieChartContentBeanList
 */
 public List<PieChartContentBean> getPieChartContentBeanList()
 {
 return pieChartContentBeanList;
 }
}

PieChartContentBean.java

This class contains the details of the four bloggers A, B, C and D, (ie) the blogger name and the number of page hits values which is to be feeded by PieChartBean Class.

package com.sample.primefaces;
/**
 *
 * @author Giftsam
 */
public class PieChartContentBean
{
 private String bloggerName;
 private int numberOfHits;

 public PieChartContentBean()
 {
 }

 public PieChartContentBean(String bloggerName, int numberOfHits)
 {
 this.bloggerName = bloggerName;
 this.numberOfHits = numberOfHits;
 }

 /**
 * @return the bloggerName
 */
 public String getBloggerName()
 {
 return bloggerName;
 }

 /**
 * @param bloggerName the bloggerName to set
 */
 public void setBloggerName(String bloggerName)
 {
 this.bloggerName = bloggerName;
 }

 /**
 * @return the numberOfHits
 */
 public int getNumberOfHits()
 {
 return numberOfHits;
 }

 /**
 * @param numberOfHits the numberOfHits to set
 */
 public void setNumberOfHits(int numberOfHits)
 {
 this.numberOfHits = numberOfHits;
 }
}

Now we had created the Data for the chart and next we need a write a managed bean for PieChartBean class in the faces-config.xml.

<managed-bean>
 <managed-bean-name>PieChartBean</managed-bean-name>
 <managed-bean-class>com.sample.primefaces.PieChartBean</managed-bean-class>
 <managed-bean-scope>session</managed-bean-scope>
 </managed-bean>

And finally we need to create a JSP document. Let us name the JSP document as pieChart.jsp and it contains the following code,

pieChart.jsp

<%--
 Document   : pieChart
 Author     : Giftsam
--%>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
 "http://www.w3.org/TR/html4/loose.dtd">
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<%@ taglib uri="http://richfaces.org/a4j" prefix="a4j"%>
<%@ taglib uri="http://richfaces.org/rich" prefix="rich"%>
<%@ taglib uri="http://primefaces.prime.com.tr/ui" prefix="p" %>

<f:view>
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>PieChart</title>
 <p:resources/>
 </head>
 <body>
 <h:form>
  <p:pieChart value="#{PieChartBean.pageHitBeanList}" var="pieChartContentBean"
 categoryField="#{pieChartContentBean.bloggerName}" dataField="#{pieChartContentBean.numberOfHits}"
 />
  </h:form>
 </body>
 </html>
</f:view>

Attributes Used

Attributes used for the above pie chart are categoryField, which is used to specify the pie section of the chart and the dataField holds the value of the corresponding categoryField. Now the construction of pie chart is completed and let us have look on the snap of our chart.

Pie Chart Snap

Now its time to move on to construct the next chart type (ie) the line chart.

Line Chart

Line charts are to display trends over a particular timeframe. In this example we shall construct a sample page which shows the students pass and the fail percentages of two class A and B. Let us begin by creating a backing bean for the line chart, and it requires two backing bean named ChartBean and ChartContentBean.

ChartBean.java

This backing bean contains the actual data to be feed in the Line Chart.

package com.sample.primefaces;

import java.util.ArrayList;
import java.util.List;
/**
 *
 * @author Giftsam
 */
public class ChartBean
{

 private List<ChartContentBean> chartContentbeanList;

 public ChartBean()
 {
 chartContentbeanList = new ArrayList<ChartContentBean>();
 chartContentbeanList.add(new ChartContentBean(2006, 25, 20));
 chartContentbeanList.add(new ChartContentBean(2007, 60, 50));
 chartContentbeanList.add(new ChartContentBean(2008, 40, 65));
 chartContentbeanList.add(new ChartContentBean(2009, 70, 60));
 }

 /**
 * @return the chartContentbeanList
 */
 public List<ChartContentBean> getChartContentbeanList()
 {
 return chartContentbeanList;
 }

LineChartContentBean.java

This class contains the pass and failed percentage details of  two classes A and B.

package com.sample.primefaces;
/**
 *
 * @author Giftsam
 */
public class ChartContentBean
{
 private int year;
 private int passPercentage;
 private int failedPercentage;

 public ChartContentBean()
 {
 }

 public ChartContentBean(int year, int passPercentage, int failedPercentage)
 {
 this.year = year;
 this.passPercentage = passPercentage;
 this.failedPercentage = failedPercentage;
 }

 /**
 * @return the year
 */
 public int getYear()
 {
 return year;
 }

 /**
 * @param year the year to set
 */
 public void setYear(int year)
 {
 this.year = year;
 }

 /**
 * @return the passPercentage
 */
 public int getPassPercentage()
 {
 return passPercentage;
 }

 /**
 * @param passPercentage the passPercentage to set
 */
 public void setPassPercentage(int passPercentage)
 {
 this.passPercentage = passPercentage;
 }

 /**
 * @return the failedPercentage
 */
 public int getFailedPercentage()
 {
 return failedPercentage;
 }

 /**
 * @param failedPercentage the failedPercentage to set
 */
 public void setFailedPercentage(int failedPercentage)
 {
 this.failedPercentage = failedPercentage;
 }
}

Now we had created the Data for the line chart and next we need to write a managed bean for the ChartBean class in the faces-config.xml.

<managed-bean>
 <managed-bean-name>ChartBean</managed-bean-name>
 <managed-bean-class>com.sample.primefaces.LineChartBean</managed-bean-class>
 <managed-bean-scope>session</managed-bean-scope>
 </managed-bean>

Only thing left to construct line chart is, we need to create a JSP document. Let us name the JSP document as lineChart.jsp and it contains the following code,

lineChart.jsp

<%--
 Document   : lineChart
 Author     : Giftsam
--%>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
 pageEncoding="ISO-8859-1"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
 "http://www.w3.org/TR/html4/loose.dtd">
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<%@ taglib uri="http://richfaces.org/a4j" prefix="a4j"%>
<%@ taglib uri="http://richfaces.org/rich" prefix="rich"%>
<%@ taglib uri="http://primefaces.prime.com.tr/ui" prefix="p" %>

<f:view>
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>LineChart</title>
 <p:resources/>
 </head>
 <body>
 <h:form>
 <p:lineChart value="#{ChartBean.chartContentbeanList}" var="chartContentBean"
 xfield="#{chartContentBean.year}">
 <p:chartSeries label="Class A" value="#{chartContentBean.passPercentage}" />
 <p:chartSeries label="Class B" value="#{chartContentBean.failedPercentage}" />
 </p:lineChart>
 </h:form>
 </body>
 </html>
</f:view>

Attributes Used

Attributes used for the line chart are xField, which is used to denote the x-axis of the chart and the tag <p:chartSeries> is used to construct the lines for the chart. Now the construction of Column Chart is completed and let us have look on the snap of our chart.

Line Chart Snap

So far we had constructed line chart and next let us learn how to construct a column chart.

Column Chart

Column chart contains vertical Bars which emphasize the differences and values across multiple categories. Now for column chart let us conjure the same backing bean which we invoked for lineChart((ie) the same example). Only thing we need to create a JSP document. Let us name the JSP document as columnChart.jsp and it contains the following code,

columnChart.jsp

<%--
 Document   : columnChart
 Author     : Giftsam
--%>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
 pageEncoding="ISO-8859-1"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
 "http://www.w3.org/TR/html4/loose.dtd">
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<%@ taglib uri="http://richfaces.org/a4j" prefix="a4j"%>
<%@ taglib uri="http://richfaces.org/rich" prefix="rich"%>
<%@ taglib uri="http://primefaces.prime.com.tr/ui" prefix="p" %>

<f:view>
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>ColumnChart</title>
 <p:resources/>
 </head>
 <body>
 <h:form>
 <p:columnChart value="#{ChartBean.chartContentbeanList}" var="chartContentBean" xfield="#{chartContentBean.year}">
 <p:chartSeries label="Class A" value="#{chartContentBean.passPercentage}" />
 <p:chartSeries label="Class B" value="#{chartContentBean.failedPercentage}" />
 </p:columnChart>
 </h:form>
 </body>
 </html>
</f:view>

Attributes Used

Attributes used for the column chart are xField, which is used to denote the x-axis of the chart and the tag <p:chartSeries> is used to construct the verticle bars for the chart. Now the construction of column chart is completed and let us have look on the snap of our chart,

Column Chart Snap

Thats all folks. I hope this article clearly explains the construction of commonly used charts required for our application. If you find this article is useful for you, dont forget to give me your valuable comments. Have a joyous code day.

Introduction:

JSF (Java Server Faces) is an java based  framework  for developing web application . Also component library can be easily incorporated in to the JSF Application. I have listed the most used components libraries by the developers in the below.

• JBoss Richfaces
• Woodstock
• Icefaces
• MyFaces Tomahawk
• MyFaces Tobaco
• Prime Faces
• WebGalileo Faces
• Open Faces
• Vaadin

But this articles explains the Installation guidelines of Richfaces with JSF in Netbeans 6.x. Additionally learn how to create a hello world application in JSF using Richfaces. I assume that you have the requirements which I had mentioned below

Requirements:

• IDE – Netbeans 6.x
• Tomcat 6.x/Glassfish/Jboss
• JDK 1.5 and above

Configuration Steps:

Configuring Richfaces with JSF application in Netbeans6.x can be accomplished by 4 easy steps they are,

1. Create the web application project
2. Required jars(Library)
3. Deployment descriptor configuration(web.xml)
4. Hello world JSP page

Create the web application project:

First Let us create the web application project in JSF, by clicking the File in the menu and select New Project in the Netbeans6.x, I have stated an image for your clear understandings,

Once this window appears choose web application and click next. Now you will have the window which I had mentioned below

In the preceding window, Let us name and location of the project. Since my article explains the creation of  Hello world Application I have given the Name as HelloWorld and then click next. Now you will have the window which I had mentioned below

In the preceding window, Let us select the server(Your favorite Server) and click next

In the preceding window, Let us select the JavaServerFaces framework from the check box and click finish. So far we had created a JSF web application project in Netbeans6.x and next let us configure the Jar files for our web application.

Required jars(Library)

Click here to download the following required latest richfaces jars

• richfaces-api-3.3.1.GA.jar
• richfaces-impl-3.3.1.GA.jar
• richfaces-ui-3.3.1.GA.jar

Deployment descriptor(DD) configuration(web.xml):

<?xml version="1.0" encoding="UTF-8"?>
<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">
 <context-param>
 <param-name>com.sun.faces.verifyObjects</param-name>
 <param-value>false</param-value>
 </context-param>
 <context-param>
 <param-name>com.sun.faces.validateXml</param-name>
 <param-value>true</param-value>
 </context-param>
 <context-param>
 <param-name>javax.faces.STATE_SAVING_METHOD</param-name>
 <param-value>client</param-value>
 </context-param>
 <servlet>
 <servlet-name>Faces Servlet</servlet-name>
 <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
 <load-on-startup>1</load-on-startup>
 </servlet>
 <servlet-mapping>
 <servlet-name>Faces Servlet</servlet-name>
 <url-pattern>/faces/*</url-pattern>
 </servlet-mapping>
 <session-config>
 <session-timeout>
 30
 </session-timeout>
 </session-config>
 <welcome-file-list>
 <welcome-file>index.jsp</welcome-file>
 </welcome-file-list>

 <!-- Rich Faces configuration -->

 <!-- Specify the skin name -->
 <context-param>
 <param-name>org.ajax4jsf.SKIN</param-name>
 <param-value>laguna</param-value>
 </context-param>

 <!--Rich faces skin apply for the standard jsf component also-->
 <context-param>
 <param-name>org.richfaces.CONTROL_SKINNING</param-name>
 <param-value>enable</param-value>
 </context-param>

 <filter>
 <display-name>RichFaces Filter</display-name>
 <filter-name>Ajax4jsf</filter-name>
 <filter-class>org.ajax4jsf.Filter</filter-class>
 </filter>

 <filter-mapping>
 <filter-name>Ajax4jsf</filter-name>
 <servlet-name>Faces Servlet</servlet-name>
 <dispatcher>REQUEST</dispatcher>
 <dispatcher>FORWARD</dispatcher>
 <dispatcher>INCLUDE</dispatcher>
 </filter-mapping>

 <!--End of rich Faces configuration -->

</web-app>

Setup process of Primefaces in Netbeans6.x has been completed and now let us create a hello world page using Richfaces UI components. The following code should be conjured to do so,

Hello world JSP page:

<%--
 Document   : helloWorld
 Created on : Nov 22, 2009, 4:07:09 PM
 Author     : shunmuga
--%>

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
 "http://www.w3.org/TR/html4/loose.dtd">

<%@taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
<%@taglib uri="http://richfaces.org/a4j" prefix="a4j" %>
<%@taglib uri="http://richfaces.org/rich" prefix="rich"%>

<f:view>
<html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>JSP Page</title>
 </head>
 <body>
 <h:form>
 <rich:panel style="position: relative; width: 400px;height: 150px;">
 <f:facet name="header">
 <h:outputText value="Hello world "/>

 </f:facet>
 <h:outputText value="Welcome to rich faces ..."/>
 </rich:panel>
 </h:form>

 </body>
</html>
</f:view>

By invoking the above code, we had created a Hello World demo application which contains a Richfaces panel, Now let us have a look on the snap of our Hello World application.

Screen Shot:

If you find this article is useful to you dont forget to give your valuable comments. Have a joyous day.

During my visit to the USS Nimitz in the Indian Ocean last month, I had the opportunity to see the Boeing F/A-18E/F Super Hornets in action. The Super Hornet is a 4.5+ generation naval multirole aircraft that was delivered to the US Navy in 1999 to replace the F-14, the S-3 and, in the long term, the F/A-18C and D Hornet.
Even if the “Rhino” (as the aircraft has been dubbed to distinguish it from the “legacy Hornet”) is the most advanced aircraft in the USN inventory, its replacement is already flying and undertaking flight testing: on Nov. 15, the first Lockheed F-35B Joint Strike Fighter (JSF) landed at Naval Air Station (NAS) Patuxent River, Md. The test aircraft, known as BF-1, after departing from Lockheed facility in Fort Worth, landed at Pax River after a stop in Dobbins Air Force Base, Ga.
BF-1 is the first of five test F-35B STOVL (Short Take-Off Vertical Landing) variants to be assigned to the air station. BF-2 is expected to arrive by the end of this year and BF-3 will follow shortly behind that, Lockheed spokesman John Kent said. The air station also will be home to three Navy carrier test variants. Before the aircraft can complete its first vertical landing, it must go through a transition phase. When regular airplanes fly, lift is created from the wing. But for hovering jets such as the F-35B, it is created from the jet itself. The transition phase is expected to include a series of flights, during which the aircraft will practice slowing down and transitioning lift from the wing to the jet — a critical step before an actual STOVL flight. Additional testing will include flying with different weight loads and ordnance payloads, according to a Marine release. “I’m anxious to have our engineers, our test pilots and our operators get their hands on this jet, and then see what we can do to turn test points and sorties at a rapid rate during the coming months,” said Lt. Gen. George J. Trautman, the deputy commandant for aviation, in a release. Eventually the Joint Strike Fighter will replace the F/A-18 Hornet, AV-8B Harrier, and the EA-6B Prowler. Marine Fighter/Attack Training Squadron-501, the first squadron that will train Marine JSF pilots and maintainers, is expected to stand up at Eglin Air Force Base, Fla., in April 2010 as part of the Joint Integrated Training Center. The first operational squadron will stand up in 2012. Even the Marina Militare (Italian Navy) is expeceted to receive 22 naval JSF that will replace the AV-8B+ Harrier and will operate from the new Italian aircraft carrier Cavour (that can accomodate 8 – 10 F-35B).

An F/A-18F of the VFA-41 and an E of the VFA-14 overflying USS Nimitz (courtesy USS Nimitz)

The BF-1 arrives at Patuxent River (Lockheed)

The BF-1 arrives at Patuxent River (Lockheed)

Cum sa accesezi corect un managed-bean programatic gasesti aici , sper sa nu dispara pagina si sa am timp sa o adaug pe plogul meu (care de asemenea sper sa nu pateasca nimic);

Alte informatii despre hibernate si JSF, cum sa faci o aplicatie jsf si Hibernate in netBeans, tutorial oficial NetBeans aici, foarte interesant si util.

Totorial Hibernate in eclipse intuitiv gasiti aici .

Acelas exemplu oferit de catre JDeveloper gasiti aici . JDeveloper este un IDE dezvoltat de catre cei de la Oracle.

O alta idee de aplicatie JSF si Hibernate gasiti si aici .

Un tutorial interesant despre Hibernate gasiti aici .

Informatii interesanta despre cum sa golesti o tabela in Hibernate gasesti aici.

Un site interesant despre maparile Hibernate gasiti aici . Mi se pare foarte util pt a intelege mai usor si a dezvolta mai rapid o aplicatie.

O versiune unor probleme care implica hibernate si JSF vor fi adaugate mai tarziu pe acest blog.

Neste artigo irei mostrar como implementar uma página de erro responsavel por responder a todos os erros inesperados do sistema como (Nullpointer Exception, ClassNotFount, etc…) ou seja qualquer erro que você não quer que aparece na cara do usuário.

Exemplo:
/**
* Classe responsável por tratar erros inesperados do sistema.
*
* @author Fernando Coelho da Silva
*/
public class ExceptionHandler extends ActionListenerImpl implements SimCart {

//Endereço da página de Erro.
public static final String erroPage = “/paginaErro.jsf”;

@Override
public void processAction(ActionEvent event) {

try {
// Executa o método da classe Pai
super.processAction(event);

} catch (Exception e) {
ExternalContext context1 = FacesContext.getCurrentInstance().getExternalContext();
HttpServletRequest request = (HttpServletRequest) context1.getRequest();

try {
//Redireciona para página de erro apartir do contexto da aplicação.
context1.redirect(request.getContextPath() + erroPage);

} catch (IOException ex) {
logger.error(“Erro ao tentar redirecionar para a página solicitada: ” + ex.toString());
}
}
}
}

O trecho a ser copiado abaixo se refere a chamada da classe action responsável por chamar a página de erro e deve ser aplicado ao view-handler específico. Neste caso, o ViewHandler utilizado é o do projeto facelets que estou utilizando no projeto em questão.

<application>
<!– Aplicação do Listener –>
<action-listener>caixa.sc.simct.util.ExceptionHandler</action-listener>
<view-handler>com.sun.facelets.FaceletViewHandler</view-handler>
<locale-config>
<default-locale>pt_BR</default-locale>
<supported-locale>pt_BR</supported-locale>
<supported-locale>es_AR</supported-locale>
</locale-config>
</application>

JavaServer Faces (JSF) is quickly emerging as the leading solution for rapid user interface development in Java-based server-side applications. Now, Core JavaServer™ Faces–the #1 guide to JSF–has been thoroughly updated in this second edition, covering the latest feature enhancements, the powerful Ajax development techniques, and open source innovations that make JSF even more valuable.

Salutare, în acest articol voi scrie despre JSF (Fava server Faces). Deoarece am descoperit că o aplicație mică la prima vedere poate deveni destul de complexă, o voi structura pe 3 capitole. Si anume, baza de date, middle tier și în final partea de view, adică JSF efectiv. Niste linkuri utile despre JSF gasiti aici: Kickstart, site oficial, articol IBM , tot pe acolo gasiti mai multe articole despre JSF, Developers book. Daca citit toate astea o sa va fie mai usor sa intelegeti aplicatia, sau ati putea chiar sa nu mai cititi de aici.

O aplicație web ar trebui să arate cam asa:

A se observa unde este Faces servlet si de asemenea faptul ca mai sunt niste tehnologii care permit unei aplicatii sa fie modulara si scalabila.  Avand in vedere ca aplicatia este una pur JSF nivelul business nu poate fi reprezentat de o alta tehnologie. Asa ca o sa il scriem de manutza . Nu e greu cand ai 2-3 clase, dar de pe la 20 de clasa in sus, ar cam trebui sa folosim un alt framework care sa ne ajute un pic cu gestionarea. Partea de baze de date nu poate fi evitata orice ai face, si aici o sa folosesc PostgreSQL Este usor de folosit, este gratis, si mai este si performanta (nu ca ar conta pt cateva tabele).

Nu am spus ce face aplicatia, nu mi se pare important atunci cand faci o aplicatie doar pentru a testa un framework, dar pentru logica celor scrise in continuare va spun ca aplicatia o sa “gestinoneze” niste scoruri la meciuri.

Sa incepem cu structura aplicatiei, aceasta asrata cam asa :

Respirati adanc… nu e asa de complicat pe cat pare, am pus clasele in multe pachete pt ca

au diferite functii si am vrut sa le regasesc usor, si sa ma obisnuiesc cu o organizare stricta. Imaginati-va cam a avea 10 convertori si 10 validatori… si asta e doar pt un proiect mediu spre mic . Un tutorial pentru convertori si validatori il puteti vedea aici.

Sa incepem cu beanurile, acestea se afla in pacjetul jsfp si sunt niste clase cu niste campuri care sunt corespunzatoare cu campurile aferente din tabelele din baza de date. De exemplu in baza de date exista tabela score, deci am bean cu acelas nume. Beanul Score arata asa:

package jsfp;

import java.io.Serializable;
import java.util.Calendar;
import java.util.Locale;
import jdba.ScoreService;

public class Score implements Serializable {

    private Long id;
    private Team hoast;
    private Team guest;
    private Integer score1;
    private Integer score2;
    private Calendar date;

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Score)) {
            return false;
        } else {
            Score t = (Score) o;
            if (id != t.getId()) {
                return false;
            } else {
                return true;
            }
        }
    }

    @Override
    public int hashCode() {
        int hash = 3;
        hash = 53 * hash + (this.id != null ? this.id.hashCode() : 0);
        hash = 53 * hash + (this.hoast != null ? this.hoast.hashCode() : 0);
        hash = 53 * hash + (this.guest != null ? this.guest.hashCode() : 0);
        hash = 53 * hash + (this.score1 != null ? this.score1.hashCode() : 0);
        hash = 53 * hash + (this.score2 != null ? this.score2.hashCode() : 0);
        return hash;
    }

    public void persist() {
        ScoreService ss = new ScoreService();
        ss.insert(this);
        score1 = 0;
        score2 = 0;
        date = Calendar.getInstance(new Locale(new Local().getLocale()));
    }

     // getters and setters for every field

}

IMPORTANT Suprascrierea metodelor equals si getHash este obligatorie, pt ca JSF compara obiectele atunci cand lucreaza cu ele.

Clasa Team.java arata cam asa:

package jsfp;

import java.io.Serializable;
import jdba.TeamService;

public class Team implements Serializable {

    private Long id;
    private String name;
    private String manager;
    private String coach;
    private String mood;
    private Integer points;

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Team)) {
            return false;
        } else {
            Team t = (Team) o;
            if (id != t.getId()) {
                return false;
            } else {
                return true;
            }
        }
    }

    @Override
    public int hashCode() {
        int hash = 7;
        hash = 71 * hash + (this.id != null ? this.id.hashCode() : 0);
        hash = 71 * hash + (this.name != null ? this.name.hashCode() : 0);
        hash = 71 * hash + (this.manager != null ? this.manager.hashCode() : 0);
        hash = 71 * hash + (this.coach != null ? this.coach.hashCode() : 0);
        hash = 71 * hash + (this.mood != null ? this.mood.hashCode() : 0);
        hash = 71 * hash + (this.points != null ? this.points.hashCode() : 0);
        return hash;
    }

    public void persist() {
        TeamService ts = new TeamService();
        ts.insert(this);
    }

   // getters and setters for every field

}

Clasa Locale nu are echivalent in baza de date, este folosita doar pentru a stoca variabila de interbationalizare. Ea arata asa:

package jsfp;

public class Local {

    private static String locale = new String("en");

    public String setLocaleRo() {
        locale = new String("ro");
        return "ro";
    }

    public String setLocaleEn() {
        locale = new String("en");
        return "en";
    }

    public String getLocale() {
        return locale;
    }

    public void setLocale(String locale) {
        this.locale = locale;
    }
}

Conectarea la baza de date am realizat-o destul de simplu si ineficient d.p.d.v al scalabilitatii, dar avand in vedere ca asta e doar o tema si nu sunt mai mult de 2-3 utilizatori se accepta . Ideea este urmatoarea: am facut o clasa singleton DbCon care tine o conexiune la baza de date, cand am nevoie de o conexiune de oriunde din aplicatie, apelez aceasta clasa si iau o conexiune. Aceasta clasa arata asa:

package jdba;

import java.sql.Connection;
import java.sql.DriverManager;
import java.util.ResourceBundle;

public class DbCon {

    private static DbCon instance = null;

    private DbCon() {
    }

    public static DbCon getInstance() {
        if (instance == null) {
            instance = new DbCon();
        }
        return instance;
    }

    public Connection getCon() {
        try {
            ResourceBundle rsb = ResourceBundle.getBundle("jdba.DatabaseProps");
            Class.forName(rsb.getString("driver"));
            Connection c = DriverManager.getConnection(rsb.getString("url"), rsb.getString("user"),
                    rsb.getString("pass"));
            return c;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }
}

Pentru a usura optinerea conexiunii am facut o clasa abstracta in care am declarat conexiunea un statement si un String ‘query’, aceasta clasa mai contine si 2 metode de deschidere si inchidere a conexiunii. Aceasta clasa arata asa:

package jdba;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

public abstract class Service {

    Connection c;
    Statement s;
    String q;

    protected void open() {
        try {
            DbCon d = DbCon.getInstance();
            c = d.getCon();
            s = c.createStatement();
            c.setAutoCommit(false);
        } catch (SQLException ex) {
            System.out.println("Error on opening connection");
            ex.printStackTrace();
        }
    }

    protected void close() {
        try {
            c.commit();
            s.close();
            c.close();
        } catch (SQLException ex) {
            System.out.println("Error on closing connection");
            ex.printStackTrace();
        }
    }
}

Clasa ScoreService arata asa:

package jdba;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Calendar;
import java.util.Date;
import java.util.Vector;
import jsfp.Score;

public class ScoreService extends Service {

    public void insert(Score sc) {
        open();
        Date now = sc.getDate().getTime();
        q = "insert into score (hoast,guest,score1,score2,date) " +
                "values (" + sc.getHoast().getId() + "," +
                sc.getGuest().getId() + "," +
                sc.getScore1() + "," +
                sc.getScore2() + ",'" +
                now.getDay() + "/" + now.getMonth() + "/" + (1900 + now.getYear()) + "');";
        try {
            s.executeUpdate(q);
        } catch (SQLException ex) {
            ex.printStackTrace();
        }

        if (sc.getScore1() > sc.getScore2()) {
            q = "update team set points = points + " + 3 + " where id = " + sc.getHoast().getId() + " ;";
        } else if (sc.getScore1() < sc.getScore2()) {
            q = "update team set points = points + " + 3 + " where id = " + sc.getGuest().getId() + " ;";
        } else {
            q = "update team set points = points + " + 1 + "where id in (" + sc.getHoast().getId() + "," + sc.getGuest().getId() + ") ;";
        }

        try {
            s.executeUpdate(q);
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
        close();
    }

    public Vector getAll() {
        open();
        Vector scores = new Vector();
        q = "select hoast,guest,score1,score2,date from score";
        try {
            TeamService ts = new TeamService();
            ResultSet rs = s.executeQuery(q);
            while (rs.next()) {
                Score sc = new Score();
                sc.setHoast(ts.getById(rs.getLong(1)));
                sc.setGuest(ts.getById(rs.getLong(2)));
                sc.setScore1(rs.getInt(3));
                sc.setScore2(rs.getInt(4));
                String[] dts = rs.getString(5).split("/");
                Calendar cl = Calendar.getInstance();
                cl.set(Integer.parseInt(dts[2]), Integer.parseInt(dts[1]), Integer.parseInt(dts[0]));
                sc.setDate(cl);
                scores.add(sc);
            }
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
        close();
        return scores;
    }

    public boolean gameDisputed(long hoast, long guest) {
        boolean flag = false;
        open();
        System.out.println("Hoast = " + hoast + "  Guest = " + guest);
        q = "select * from score where hoast = " + hoast + " and guest = " + guest + ";";
        try {
            ResultSet rs = s.executeQuery(q);
            flag = rs.next();
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
        close();
        return flag;
    }
}

Clasa TeamService arata asa:

package jdba;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Vector;
import jsfp.Team;

public class TeamService extends Service {

    public void insert(Team t) {
        open();
        q = "insert into team (name,manager,coach,mood,points) " +
                "values ( '" + t.getName() + "'," +
                "'" + t.getManager() + "'," +
                "'" + t.getCoach() + "'," +
                "'" + t.getMood() + "',0);";
        try {
            s.executeUpdate(q);
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
        close();
    }

    public Team getByName(String nm) {
        open();
        Team t = null;
        q = "select id,name,manager,coach,mood,points from team where name = '" + nm + "' ;";
        try {
            ResultSet rs = s.executeQuery(q);
            while (rs.next()) {
                t = new Team();
                t.setId(rs.getLong(1));
                t.setName(rs.getString(2));
                t.setManager(rs.getString(3));
                t.setCoach(rs.getString(4));
                t.setMood(rs.getString(5));
                t.setPoints(rs.getInt(6));
            }
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
        close();
        return t;
    }

    public Team getById(Long nm) {
        open();
        Team t = null;
        q = "select id,name,manager,coach,mood,points from team where id = " + nm + " ;";
        try {
            ResultSet rs = s.executeQuery(q);
            while (rs.next()) {
                t = new Team();
                t.setId(rs.getLong(1));
                t.setName(rs.getString(2));
                t.setManager(rs.getString(3));
                t.setCoach(rs.getString(4));
                t.setMood(rs.getString(5));
                t.setPoints(rs.getInt(6));
            }
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
        close();
        return t;
    }

    public Vector getAll() {
        open();
        Vector teams = new Vector();
        q = "select id,name, manager,coach,mood,points from team";
        try {
            ResultSet rs = s.executeQuery(q);
            while (rs.next()) {
                Team t = new Team();
                t.setId(rs.getLong(1));
                t.setName(rs.getString(2));
                t.setManager(rs.getString(3));
                t.setCoach(rs.getString(4));
                t.setMood(rs.getString(5));
                t.setPoints(rs.getInt(6));
                teams.add(t);
            }
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
        close();
        return teams;
    }
}

Fisierul de proprietati ‘DatabaseProps’ contine informatiile necesare pt conexiune la baza de date:
user=user
pass=user
url=jdbc:postgresql://localhost:5432/game
driver=org.postgresql.Driver

Clasa TeamValidator arata asa:
Eu am facut o validare pentru echipe, si am gandit asa: cand este selectata prima echipa se apeleaza acet validator si este setat id-ul acestei echipe, cand se seteaza a doua echipa se apeleaza din nou acest validator si se seteaza id-ul al doilea, apoi se verifica daca aceste id-uri sunt diferite, asta avertizeaza asupra faptului ca o echipa nu poate juca cu ea insesi.

package gui.validators;

import javax.faces.application.FacesMessage;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.validator.Validator;
import javax.faces.validator.ValidatorException;
import jdba.ScoreService;
import jsfp.Team;

public class TeamValidator implements Validator {

    static long t1 = -1;
    static long t2 = -1;

    public void validate(FacesContext context, UIComponent component, Object value) throws ValidatorException {
        Team s = (Team) value;
        if (t1 == -1) {
            t1 = s.getId();
        } else {
            t2 = s.getId();

            ScoreService ss = new ScoreService();
            if (ss.gameDisputed(t1, t2)) {
                t1 = t2 = -1;
                FacesMessage message = new FacesMessage();
                message.setDetail("Game already disputed");
                message.setSummary("Game already disputed");
                message.setSeverity(FacesMessage.SEVERITY_ERROR);
                throw new ValidatorException(message);
            }

            if (t1 == t2) {
                t1 = t2 = -1;
                FacesMessage message = new FacesMessage();
                message.setDetail("Teams must not be equal");
                message.setSummary("Teams must not be equal");
                message.setSeverity(FacesMessage.SEVERITY_ERROR);
                throw new ValidatorException(message);
            }
            t1 = t2 = -1;
        }
    }
}

Clasa TeamGetAll arata asa:

package gui;

import java.util.Vector;
import javax.faces.model.SelectItem;
import jdba.TeamService;
import jsfp.Team;

public class TeamGetAll {

    public Vector
 getAll(){
        Vector
 sis = new Vector
();
        TeamService ts = new TeamService();
        Vector vt = ts.getAll();
        for(Team t:vt){
            SelectItem si = new SelectItem(t,t.getName());
            sis.add(si);
        }
        return sis;
    }

    public Vector getTeams(){
        TeamService ts = new TeamService();
        return ts.getAll();
    }
}

Clasa ScoresGetAll arata asa:

package gui;

import java.util.Vector;
import jdba.ScoreService;
import jsfp.Score;

public class ScoresGetAll {

    public Vector getScores() {
        ScoreService ts = new ScoreService();
        return ts.getAll();
    }
}

Daca inca mai citesti inseamna ca ai vointa . Acum o sa pun si niste poze cu bucatelele importante din paginile jsp:
pagina de index arata asa:

Pagina View arata asa:

Pagina Teams arata asa:

Pagina Edit arata asa:

Cam asta e tot…
cireasa de pe tort: asta e o aplicatie mica :d analiza placuta si cititi cu atentie tutorialele de la linkurile pe care le-am pus la inceputul paginii.
PS: asta e si faces config:

Spor in continuare.

After working on two large-scale, cross contains / platform, web application projects, I’ve come to the conclusion that Java EE is fatally flawed.

If someone asked you to state the most important, guiding principle of the Java language, what would you say? You would would probably say “write once, run anywhere.” Indeed, for Java SE this holds true most all of the time. In Java EE however, it is hopelessly broken. The reality is that every web container is slightly different in ways that force developers work around problems, avoid certain features, or even have different code paths. Different code paths in a language that was never designed for it.

Different aspects of Java EE have different levels of stability. JSP works almost the same across all containers. Things like JSF and Java Persistence (JPA) however are hopeless. My most recent experience is writing a web administration console using JSF for the OpenSSO project. OpenSSO claims to support at at least 8 different web containers. Every container required JSF tweaking that ranged from annoying to just plain terrible. Needless to say I had egg on my face to some degree over the choice to use JSF. It was a no-brainer for me. JSF is the chosen MVC framework for Java EE. My mistake.

The only container where JSF “just worked” was Tomcat. Tomcat isn’t a Java EE container at all.Tomcat doesn’t include JSF or any of it’s dependencies. We might be on to something here. Let’s look at another example: Spring. Spring is essentially a lighter-weight, simpler replacement for Java EE. Why is Spring so popular? One reason is that it is an elegant design. But another, perhaps more important reasons is that no matter what container you are developing on, Spring is Spring. It’s the same JAR, the same code, the same implementation. It makes very few assumptions about the capabilities of the underlying container. Another example is Facelets, a light-weight JSP replacment. I use JSF+Facelets on the OpenSSO project, and it has been flawless (the Facelets part). Why? Because I include the Facelets JAR, it is not provided by the system.

What if Java EE had followed the same model? Java EE should have been nothing more than a plugin framework and some base services. Want to use JSF in your project? Just include it from a managed, networked Java EE module repository. Include the one, common implementation of JSF. Include the approved version for your level of Java EE. If you support Java EE 5, you get JSF version X, across all web containers.

Depois de iniciar minha aplicação JSF e começar a desenvolver algumas paginas JSP, percebi que a media que ia entrado nos links de menu para navegar entre as paginas, a  URL do browser não era atualizada com a pagina corrente, mas sim com a pagina anterior. Depois de pesquisar um pouco descobri uma solução,  segue o resumo da opera:

Problema

Quando é acessado os links/menus do JSF a URL do browser não é atualizada com o endereço da pagina corrente.

Solução:

Colocar nas regras de navegação no arquivo faces-config.xml a tag

<redirect/>

Exemplo

<navigation-rule>

<display-name>downloadChangelog< /display-name>

  <from-view-id>/uncommitedChangeRequestView.jsp< /from-view-id>
  <navigation-case>
   <from-outcome >gotoDownloadChangelogFile</from-outcome>
   <to-view-id >/downloadChangelogFile.jsp</to-view-id>
   <redirect/>
  </navigation-case>
 </navigation-rule>

Problemas da solução
Os seus backbeans com scopo de request perderão os atributos, então antes de aplicar a tag em uma pagina qualquer, certifique-se que não esta usando um bean com scopo de request.

If you want to have View Scope in Spring for JSF, firstly read here and here.

The problem with above was, those needed our @Scope(“view”) beans to be serialized.

We didn’t want to serialize our beans so we did the following workaround:

we defined our Autowired DAO classes as :

@Autowired
private transient DAO myDao;

and based on Rick’s above ViewScope implementation we added those 2 lines of code:

public class ViewScope implements Scope, ApplicationContextAware

….

@Override
public void setApplicationContext(ApplicationContext applicationContext)
throws BeansException {
this.applicationContext = applicationContext;
}

…
and finally in get method, after getting the object we did

applicationContext.getAutowireCapableBeanFactory().autowireBean(objToReturn);

to autowire the dependencies again.

hope it helps for you also…

I’m very pleased to announce that ICEfaces 2.0 – Alpha 1 is now available for download.

This inaugural development milestone release of ICEfaces 2.0 provides the fundamental capability of running the next-generation ICEfaces core on the Mojarra JSF 2.0.1 runtime. You can plug the icefaces.jar into your existing JSF2 application and immediately receive some of the benefits of ICEfaces Direct-to-Dom rendering, such as providing incremental page updates without the need to specify the JSF 2 “f:ajax” tag. A sample application is included demonstrating ICEfaces 2 with JSF 2 (“h:”) standard components, and Ajax Push.

Also included in this release is the initial implementation of the ICEfaces 1.x compatibility libraries, along with sample applications that demonstrate this capability. The ICEfaces 1.x compatibility libraries are used to readily port your existing JSF 1.2 / ICEfaces 1.8 applications to JSF 2.0 / ICEfaces 2.

See the Release Notes for all the details.

We are planning to have another significant ICEfaces 2 milestone release, featuring the beginnings of our all-new ICEfaces 2 component suite, before the end of this year, so stay tuned!

Source: www.icefaces.org

ICEfaces 1.8.2 is now available for download, SVN repository checkout, or via Maven public repository.

ICEfaces 1.8.2 is an official maintenance release that includes 165 fixes and improvements. Notable changes include:

Source: www.icefaces.org