• 创建属性文件

• 在faces-config.xml中声明属性文件

• 简单消息

• 参数化消息

• 国际化消息

创建、声明属性文件，使用简单消息

1、后缀名.properties

2、内容 keyName = value，成对出现

3、部署位置： WEB-INF/classes或者子目录，如WEB-INF/classes/resources

4、在faces-config.xml中声明，如：

<?xml version="1.0" encoding="UTF-8"?>

<faces-config ......>

 <application>

  <resource-bundle>

    <base-name>messages</base-name>    或    <base-name>resource.messages</base-name>

    <var>msgs</var>

  </resource-bundle>

 </application>

</faces-config>

可以使用多个属性文件：

<application>

<resource-bundle>

<base-name>messages1</base-name>

<var>msgs1</var>

</resource-bundle>

<resource-bundle>

<base-name>messages2</base-name>

<var>msgs2</var>

</resource-bundle>

</application>

5、使用EL输出消息

#{msgs.keyName}

参数化消息

1、属性文件中：someName=blah {0} blah {1}

2、使用：

<h:outputFormat value="#{msgs.someName}">

<f:param value="Literal value for 0th entry"/> --给{0}赋值

<f:param value="#{someBean.calculatedValForEnty1}"/> --给{1}赋值

</h:outputFormat>

国际化

同java基本国际化规则：属性文件同目录下放多个类似属性文件，如： messages.properties、messages_zh.properties等

• 使用expression language的积极因素

– Comparing to the JSF 1.x and JSP 2.0 ELs

• 访问Bean属性

– 直接Direct

– 嵌套Nested

• 提交bean属性Submitting bean properties

– Expressions in output values

– Expressions in submission values

– Expressions for action controllers

• 访问集合元素Accessing collection elements

• 使用隐式对象和操作符Using implicit objects and operators

• 向方法传递参数Passing arguments to methods

Why Expression language（简称EL）？

在facelets(*.xhtml)中不支持jsp scripting，因此需要提供一种直接调用java的方式

举例：

1、#{employee.firstName}

2、<h:inputText value="#{employee.firstName}" />

3、#{employee.addresses[0].zip}

Expression Language（简称EL） 的优点：

1、Bean属性的简化符号（Very Important）

a) #{company.companyName} 

b) #{company.president.firstName}

2、简化了集合元素的访问（Very Important）

a) #{someBean.someProperty[indexOrKey]},#{person friends[2]}

3、小但有用的简单操作集合（Moderately Important）

a) 算数、关系、逻辑、空测试 等操作

4、条件输出（Moderately Important）

a) #{test ? option1 : option2}

b) <h:someElement … rendered="#{test}"/>

c) <ui:fragment rendered="…">…</ui:fragment>

5、预定义变量（Less Important）

a)  request params, cookies, HTTP headers。。。。。。

6、传递参数（Less Important）

a) JSF2.1 EL 允许传递任意参数，仅可在JEE6中得到支持

7、Empty values替代了错误信息（Less Important）

a) 值不存在、Null均返回空字符串，而不是抛出异常

访问Bean属性

1、简单属性

a) #{varName.propertyName}、<h:outputText value="#{varName.propertyName}" …/>

解释： 首先在所有定义的scope（request、session、application，按照如此顺序）中查找“varName”，然后找到Managed Bean的定义并且实例化，最后调用getter方法输出结果。

2、嵌套属性

a) #{var.prop1.prop2.prop3}、<h:outputText value="#{var.prop1.prop2.prop3}" …/>

解释：同上、查找、实例，最后调用getProp1().getProp2().getProp3(),输出结果

提交Bean属性

#{...}的三种用法：

1、指定输出的值：

a) #{employee.address} 或者<h:outputText value="#{employee.address}"/>，任何时候可以调用，意思是输出getAddress();

b) <h:itputText value="#{employee.address}"/>，当form在初始化显示时，调用getAddress()进行预填充，如果返回值不是non-empty，则作为input的值

2、指定提交的值：

a) <h:inputText value="#{employee.address}"/>，当form提交时，传递值到setAddress方法

3、指定提交后调用的方法

a) <h:commandButton value="Button Label" action="#{employee.processEmployee}"/>，当from提交时，指定action handler，processEmployee是其准确方法名，而不是简写。

理解Getter() & Setter()

举例：<h:inputText value="#{myBean.a.b.c.d}"/>

当显示form时：查找并实例myBean，调用myBean.getA().getB().getC().getD(),如果值是non-empty，作为textfield的初始值

当提交form时：查找myBean，调用myBean.getA().getB().setD(value) （假定参数通过验证）

使用EL访问集合

– Array ：theArray[index]

– List ： theList[index]

– Map：theMap.key 或者 theMap["key"]

EL预定义对象

JSF EL 和JSP2具有几乎相同的预定义对象：

– facesContext 如：#{facesContext.externalContext.remoteUser}

– param. Request params，如 #{param.custID}

– header. Request headers，如 #{header.Accept} or #{header["Accept"]} #{header["Accept-Encoding"]}

– cookie Cookie object (not cookie value) ，如：#{cookie.userCookie.value} 或者#{cookie["userCookie"].value}

– request, session，如：#{request queryString} #{session id} • #{request.queryString}, #{session.id}

– initParam. Context initialization param.

– requestScope, sessionScope, applicationScope, 等

问题：有些情况下，需要在java 代码中访问相关预定义对象，而不是EL中。(一般可以通过FacesContext获取)。

      在bean中，FacesContext获取方式：ExternalContext context = FacesContext.getCurrentInstance().getExternalContext();

EL操作符

1、算数操作符：+ - * / div % mod

2、关系操作符：== eq != ne < lt > gt <= le >= ge

3、逻辑操作符：&&and||or!Not

4、Empty操作符：empty。null, empty string, empty array, empty list, empty map 返回true，其他情况返回false

说明：

Use lt, gt, ge, and, 等替代<, >, >=, && (在XML中)

尽可能少的使用操作符，从而保持MVC模型

JSF中的条件text

存在以下三种条件Text

1、#{someCondition ? simpleVal1 : simpleVal2}

使用场景：简单的文本输出（非HTML文本）

2、<h:outputText value="#{someValue}" rendered= #{someCondition} />

使用场景：简单的文本输出（非HTML文本）

3、<ui:fragment rendered="#{someCondition}"/>

<someHTML>…</someHTML>

   </ui:fragment>

使用场景：格式化HTML文本输出

向方法传递参数

1、EL2.1 允许访问常规方法（非零参数方法）

2、语法：#{someBean.someMethod(arg1, arg2)}

3、注意：

a) 尽可能少用： 在java代码中处理复杂，而非facelets中

b) 只在JEE6中可以使用，不是JSF2的一部分

c) 自2001.3起，不能够调用参数为可变参数的方法

• 显式导航规则Explicit navigation rules

• 显式bean声明Explicit bean declarations

• 高级导航选项Advanced navigation options

– 导航通配符

– 条件导航

– 动态计算

• 静态导航

• 常见的导航问题

对于本节内容，翻译略去，主要原因：

1、思路和struts类似

2、隐式导航基本上能够满足开发，不需要显式的通过xml配置，复杂化

本节主题

•  自定义Bean Name

•  Bean scopes

– 尤其是session-scoped beans

•  在Bean中访问原生的Request和 Response

•  Dependency injection（依赖注入）

自定义Bean Name

举例：

@ManagedBean(name="anyName")

public class BeanName {

使用时：#{anyName.blah}

注意： 1、缺省scope仍然是request scope   2、仍然不需要在faces-config.xml中定义entry

控制Bean Scopes

1、有六种Scope：request, session, application, view, none, custom

2、既可以在faces-config.xml中声明，也可以使用新的注释，如： @SessionScoped

3、缺省scope仍然是request scope

用注解声明Scope：

举例：（一般放在@ManagedBean之后）

@ManagedBean

@SessionScoped

public class UserBean {

@RequestScoped

缺省的。

@SessionScoped

与session类似，timeout后失效，bean必须是Serializable

@ApplicationScoped

所有用户均可以访问，

@ViewScoped

同一用户在同一页面(page)，使用同一bean实例(e.g., with event handlers or Ajax). 

• New scope in JSF 2 0 New scope in JSF 2.0. 

• Bean should implement Serializable

@CustomScoped(value="#{someMap}")

Bean is stored in the Map, and programmer can control lifecycle.

@NoneScoped

没有被放到任何scope，使用场景：被其他scope bean引用

在Bean中访问原生的Request和 Response

为什么要在JSF中使用Request和Response？

使用Request Object：

显式的进行session操作

显式的进行cookie操作

访问request header

查找requesting host name

使用Response Object：

设置 status codes

设置 response headers

设置 long-lived cookies

Bean中reqeust 、response访问方式：

ExternalContext context = FacesContext.getCurrentInstance().getExternalContext();

HttpServletRequest request = (HttpServletRequest) context.getRequest();

HttpServletResponse response = (HttpServletResponse) context.getResponse();

注：在某些环境下，getRequest()和getResponse()类型转换时可能不是HttpServletRequest和HttpServletResponse，比如，在portlet环境中，类型转为应该为：PortletRequest 和PortletResponse 

Dependency injection（依赖注入）：使用@ManagedProperty

1、JSF2支持简单的依赖注入，不是很强大，但是很有用，用法：

@ManagedProperty(value="#{someBean}")

private SomeType someField;

2、依赖注入的property必须有setter方法

3、可以指定bean的实例化时机。

a) @ManagedBean(eager=true):当app被加载时，实例化bean

4、Faces-config-xml&注释

a) 前者可以不改变java代码而实现依赖注入

b) 前者可以指定Map elements，而后者不能够

5、Spring is best of all (?)

Spring更强大，毫无置疑，JSF可以简单的和Spring整合。

•  “managed” beans

•  JSF中Bean的三部分

•  预填充input fields

•  使用Bean属性用来处理request的参数 

Bean的基本要求：

1、无参构造器、无public实例变量、getter/setter命名约定

2、JSF中引用Bean属性

Managed Beans

1、JSF 自动“管理”bean

a) 实例化： 无参构造器

b) 控制其生命周期：Scope (request, session, application) 决定其生命时间

c) 调用setter方法：如，<h:inputText  value="#{userBean.firstName}" />当form提交，value被传递至setFirestName

d) 调用getter方法：如，#{customer.firstName} 导致调用getFirstName

2、声明bean

a) 简化做法：在class之前声明@ManagedBean

b) 强大做法：在faces-config.xml中的<managed-bean>部分

Managed Beans的三个部分

1、Bean properties

a) 每一个input元素，一对getter、setter

b) Setter方法被自动调用，当form提交的时候，在Action controller methods被执行之前

c) Getter方法通过bean.properName隐式调用

2、Action controller methods

a) 一般只有一个，但是也可以多个，如对于同一个form如果有多个提交button

b) Methods被JSF自动调用，当form被提交，如：submit button被点击

3、Placeholders for results data结果数据占位符

a) JSF不会自动filled in。一般在Action controller Method中根据业务逻辑进行set赋值

b) 需要提供getter方法，方可以在result page中output，但是setter方法不一定需要

如下图：

预填充input fields

双重角色：Bean property refers to both getter & setter

1、The getter method is called when form is displayed, and affects what is initially displayed to user

2、The value from the input element is passed to the setter method when the form is submitted

举例：

1、<h:inputText…/>   (textfield) getter方法返回非空，则显示在textfield中，submit后，参数被传递调用setter方法

2、<h:selectBooleanCheckbox…/>  (checkbox) getter返回true，则cheched，反之则unchecked

3、<h:selectOneMenu…/> (combobox; drop down menu) getter方法返回值与下拉列表中某项匹配，则选中；如果没有匹配，则选中最上一项

本节主题

•  简化了得控制流程

•  @ManagedBean缺省的bean命名

•  为action controller返回值进行缺省映射

•  使用Bean属性用来处理request的参数 

高度简化的控制流程：

Facelets page的基本结构：

Managed Beans的基本结构：

@ManagedBean Basics：

1、@ManagedBean annotation，缺省bean name为：类名(不含包名)，首字母小写，缺省Request Scope

2、action controller方法的返回值：字符串，隐式映射到xhtml文件，如返回"foo"，则映射到foo.xhtml

使用Beans处理请求参数：

1、输入值与bean属性对应

如：<h:inputText value="#{someBean.someProp}"/>

当form提交，textfield中的值被传递setSomeProp（之前需要进行校验和类型转换）

当form被显示的时候，调用getSomeProp方法，如果返回值不是null或者empty string，则在textfield中显示

2、Bean的Scope缺省是Request

3、使用#{bean.someProp}可以直接输出

I'll admit it: I didn't like JSF 1 either. So, when JSF 2 came out, I had low expectations. But, when I looked at the beta version, I was very pleasantly surprised that they learned lessons from Ruby on Rails, JBoss Seam, and the Ajax4Jsf library. And, now that I have used it much more and seen many of the features that support today's modern applications, I have concluded that JSF 2 is probably the overall-best mainstream Java-based Web app framework now in existence.

我必须承认，我也不喜欢JSF1.因此，当JSF2出来是，并没有过高期望。但是当我看到beta版本的时候，非常惊讶于他们能够从Ruby on Rails, JBoss Seam, 和Ajax4Jsf library汲取经验。现在，我更多的使用它，并且也看到了对于现代应用支持的更多特性。我断定JSF2可能是现有的最好的基于Java的主流Webapp framework。

Here is a very brief summary of the most important features that are new in JSF 2.0 (but not in JSF 1.x). Details on all of these topics are covered throughout the rest of the lectures. This section is mostly only useful for people who used JSF 1.x; if you are new to JSF, start with the two sections above, then move on to the programming basics section.

以下是对JSF2.0（不是在JSF1.x）中新加入的几个最重要特性的一个简短介绍。后续讲座会完全覆盖这些主题。本节仅对于使用过JSF1.x的人有用，如果你是新接触JSF，通过之前两节，直接跳到下一节：JSF2.0编程基本。

l You have more debugging help during project development. 

To get started with JSF 2.0, at the very least you need a web.xml with a url-pattern for *.jsf or something similar, and a faces-config.xml with valid start and end tags, just as in JSF 1.x. However, in JSF 2.0, you can optionally add a PROJECT_STAGE setting of Development to web.xml. By doing this, many errors that would silently fail in JSF 1.x now result in explicit error messages. 

在项目开发过程中，你将拥有更多的调试帮助。可以选择在web.xml中添加：

  <context-param>

    <param-name>javax.faces.PROJECT_STAGE</param-name>

    <param-value>Development</param-value>

  </context-param>

之前在JSF1.x中静默失败的许多错误，现在可以产生明确的错误信息。

l Facelets, not JSP, is the standard technology for all your JSF pages. 

Name the pages blah.xhtml, but use the URL blah.jsf (assuming a url-pattern of *.jsf in web.xml). Use xhtml format for the pages themselves. Don't use @taglib, but instead use xmlns:h="http://java.sun.com/jsf/html". Then, use h:head, h:body, and h:form (but not usally f:view) in the page. You can find a representative sample here. 

Facelets，而非JSP，成为所有JSF的标准page技术。

l You can use default bean names. 

Instead of declaring beans with managed-bean in faces-config.xml, you can put @ManagedBean above the class definition. Then, take the bean classname, change the first letter to lower case, and use that as the managed bean name. For example, if the class is package1.package2.MyBean, you would use #{myBean.whatever} in your code. You can also do @ManagedBean(name="someName"). Beans are request scoped by default, but there are annotations like @SessionScoped to change the default. This sample bean and the sample .xhtml page from above illustrate this. 

你可以使用缺省的Bean命名。

l You can use default mappings of outcomes to results pages. 

In the absence of explicit navigation rules, the return values of the action controller method correspond to the file names that should be used. Suppose that your form (file form.xhtml, URL form.jsf) says <h:commandButton ... action="#{someBean.someMethod}"/>. When the button is pressed, the bean named someBean is instantiated (assuming request scope), setter methods corresponding to the h:inputBlah elements are run, validation occurs, and then someMethod is executed. This is the same as in JSF 1.x, except that the managed bean name (someBean) can be derived from the bean class name (SomeBean). But now, if someMethod returns "foo" and "bar", and there are no explicit navigation rules in faces-config.xml for those outcomes, then JSF will assume that they correspond to foo.xhtml and bar.xhtml (from the same folder as form.xhtml), respectively. For example, in the this sample bean, the outcomes correspond to accepted.xhtml and rejected.xhtml. In a later section on page navigation, I will argue that explicit navigation rules are probably what you will use in real projects, but the implicit navigation lets you get your app up and running more quickly, and is particularly convenient for test apps where you just want to experiment with some particular JSF 2 feature. 

你可以使用缺省的结果页面映射。调用Bean的方法的返回值将成为默认的目标： 如返回值foo，则默认目标为foo.xhtml

l You can usually use #{myBean.myProperty} instead of <h:outputText value="#{myBean.myProperty}"/>. 

If you don't need any fancy options, the first form is much more concise. Both forms escape HTML characters, and thus can be used for properties containing user input. You only need h:outputText when you need escape="false" or want to compute the render property or need to assign an id or want use another less-common feature of h:outputText. 

你可以经常使用：#{myBean.myProperty} 替代 <h:outputText value="#{myBean.myProperty}"/>。如果没有任何特殊的选择，使用前者更为简洁。

l You can easily Ajaxify your application. 

Add xmlns:f="http://java.sun.com/jsf/core" to the page header. Inside the start and end tags for h:commandButton, put <f:ajax execute="@form" render="resultId"/>. Then, also have <h:outputText value="#{myBean.myProperty}" id="resultId"/>. This means that when the button is pressed, all the form elements are sent to the server and executed normally. Then the action controller method is executed normally. Then, the value of getMyProperty is computed and sent back to the server. JavaScript receives the value and inserts it into the current page in the place where the h:outputText element initially was. A later section covers the Ajax support in detail. 

你可以非常容易的Ajax化你的应用。

l Mere mortals can build custom components. 

In JSF 1.x, the existence of an API for custom components was a real boon. Because of it, a whole market for third-party component libraries developed, with PrimeFaces, RichFaces, IceFaces, Tomahawk, ADF, and Web Galileo being notable libraries. However, the API was so complex that it was more trouble than it was worth for most ordinary JSF programmers. Now, there is a very easy-to-use facelets-based (rather than Java-based) method for building simple and medium-complex components. This is somewhat analogous to the tag-file way of building JSP custom tag libaries, but even simpler and even more powerful. A later section covers composite components in detail. 

简化了自定义组件的构建

l There is a powerful and relatively easy to use page templating library (better than Tiles!). 

JSP always had jsp:include, but it lacked a serious library for building page templates, sub-templates, and concrete pages built upon templates. However, most modern Web apps have many similar-looking pages, so templating is a must. JSF 2 has a well-thought-out, extensible, and moderately easy-to-use templating framework that is arguably even better than Apache Tiles on which it was loosely based. A later section covers page templating in detail. 

提供了一个强大的易于使用的页面模板库（比Tiles更好）

本节主题

Getting required software 

–  Installing Java SE 6 

–  Installing Eclipse (Java EE version) 

–  Installing a server for JSF2.0

Tomcat 6 or 7 (also needs jsf-api.jar and jsf-impl.jar)  or  Any Java EE 6 server (e.g., Glassfish 3) 

Testing projects 

–  Importing and testing an existing JSF 2.0 project 

Deploying onoTomcat and Glassfish 

–  Making your own JSF 2.0 project 

基本特点一窥Sneak preview of basic features

–  Summary of code in jsf-test project

运行JSF2.0系统要求

Java 

–  如果运行Tomcat 6, Java 5或更高版本

–  如果Tomcat 7 or Glassfish 3, Java 6或更高版本 

本教程使用Tomcat 和Java 6 

A server 

–  只要支持servlets 2.5更高版本 (e.g., Tomcat 6 or 7) ，并且需要两个JAR 文件(jsf-api.jar 和jsf-impl.jar)

另外如果需要使用ui:repeat变迁，就需要JSTL 1.2 JAR文件 

JSF 2.0也可以运行在Google cloud server (使用Jetty) 

–  只要支持Java EE 6 (e.g., Glassfish 3, JBoss 6, WebLogic 11g) ，均内置支持JSF 2.0 & JSTL 1.2 

教程所有的例子可以运行在Tomcat 6, Tomcat 7, & Glassfish 3 

An IDE 

–  可选，但是强烈建议. 

本教程使用Eclipse 3.6, 默认支持JSF 2 （Eclipse IDE for Java EE Developers）

安装配置过程

1、安装Java6 略

2、安装Tomcat 6 略

3、安装 Eclipse3.6 Eclipse IDE for Java EE Developers 略，并且在Eclipse中添加Server tomcat6，略

简单开始：

1、下载导入教程blank项目

2、jsf-blank.zip

3、解压缩，导入Eclipse

更复杂的构建过程不做描述。

添加项目到Server

启动tomcat，访问：http://localhost:8080/jsf-blank/

大功告成！

一个更复杂的例子：

1、下载：jsf-test.zip

2、导入Eclipse项目

3、如图

说明：

1、html开始标签中包含标签定义。。。相关标签需要在web.xml中做url-pattern

2、<h:head><h:body>不是必须，但是推荐如此，可能在一些标签使用的时候会需要

3、Input元素在此例中被简化，后续会做进一步介绍

4、<h:commandButton value="Sign Me Up!" action="#{healthPlanBean.signup}"/>  和JSF1.x中用法一致，但是JSF2中自动Bean由Java 类名自动产生。

package coreservlets;

import javax.faces.bean.*;

@ManagedBean   

public class HealthPlanBean {

  public String signup() {

    if (Math.random() < 0.2) {

      return("accepted");

    } else {

      return("rejected");

    }

  }

}

相信大家都能够明白，一目了然。（点击button，直接调用了类HealthPlanBean 的方法signup()），简化吧，相对struts，或者其他框架。。。。。

rejected.xhtml index.jsp accepted.xhtml 三个文件不在做介绍。。类似

有感觉了吧，是不是有点儿小激动。。。。

本节主题

不同视角看JSF    Different views of JSF

JSF的利弊 Pros and cons of JSF

Vs. standard servlet and JSP technology

Vs. Apache Struts

Vs. other Ajax approaches

New features in JSF 2 0 ? 

Vs. JSF 1.x

概述

什么JSF?

l 一组基于Web的GUI控件和处理器 A set of Web-based GUI controls and handlers?

JSF提供了许多预支的HTML原生GUI控件，连同处理这些控件的事件代码。JSF provides many prebuilt HTML-oriented GUI controls, along with code to handle their events

l 一个设备独立的GUI控件框架A device-independent GUI control framework?

使用不同于HTML的协议，JSF可以用于产生各种不同格式的图形。JSF can be used to generate graphics in formats other than HTML, using protocols other than HTTP

l 一个基于MVC的Web应用程序框架 An MVC-based Web app framework?

l 一个Ajax库 An Ajax library?

JSF2提供了易于使用的Ajax支持，所以JSF2也可以看作是JQuery或GWT的一个替代品。JSF 2.0 provides very easy-to-use Ajax support. So, JSF 2.0 can beviewed as an alternative to jQuery or GWT.

l But Which is the proper way to view JSF，这取决与你如何是使用JSF，一般来说，1、3两种方式是常见的方式。

议题 Issues

l 各种方案： 传统Web应用

n Servlets/JSP (with MVC)、Struts 2.0

n 

n JSF2.0

l 各种方案： 基于Ajax的Web应用

n 在现有Web App中添加jQuery或者Ext/JS等

n 使用GWT完成所有事情，类似于Swing的方式

n 在页面中使用JSF2.0和Ajax标签

l JSF2 vs. JSF1.x

n V2和v1相比如何

JSF vs. Struts (Servlets/JSP \Spring MVC\Apache Wicket\Apache Tapestry)

后者并没有改变JSP、Servlet的本质，同样需要纷繁的配置、代码、层次。

JSF的优势

l 自定义GUI控件 

JSF很容易进行自定义控件，而且目前已经有了大量的第三方JSF GUI控件，如：PrimeFaces, JBoss RichFaces, Oracle ADF, IceFaces, Apache 

Tomahawk, Woodstock, Web Galileo, …

l 事件处理机制：传统的Web均不能直接和Java代码交互，JSF提供了很好的事件机制

l Managed beans：极大的简化参数传递、类型转换、数据校验。。。

l Integrated Ajax support：标签化得Ajax支持，易于使用

l JEE官方组件，长期支持、发展

JSF的缺点

l 较大的学习曲线

l 文档支持不足

l 缺少透明度： 因为隐藏了底层，所以难以理解，不易于效评和调优

JSF vs. 传统JavaScript库、GWT

总的来说，由于JSF2 内置的Ajax支持，使得Ajax的使用非常方便，这是进步。从技术发展的角度来看，JavaScript的使用也是越来越方便。

各种使用场景不同

Use traditional JavaScript library when: 

–  You have existing app already built 

–  You want to incrementally add rich GUIs/Ajax to it 

UseUse GWTGWT when:when: 

–  You are starting a new Web app 

–  YouYou wantwant itit toto looklook likelike aa desktopdesktop appapp (no(no pagepage navnav)) 

–  You have complex client-server comms 

Use JSF 2.0 when: 

–  You are starting a new Web app 

–  It will be a combination of traditional form submissions and page naviigatition pllus richhGUIs/Aj/Ajax content

JSF 2.0 vs. JSF 1.x

新特性vs. JSF 1.x 

–  巧妙的默认（约定）Smart defaults 

–  标注替代大量的faces-config.xml entries  Annotations to replace many faces-config.xml entries 

–  Ajax support 

–  Integrated support for facelets 

–  简化自定义组件 Simpler custom components 

–  更多的组件和校验器 More components and validators 

–  Support for Groovy 

–  Ability to bookmark results pages 

7年前，幸福与JSF1.0的发布，规范很美好，现实很残酷，JSF1.0并没有展示出足够的强大。

2009年7月1日，经过投票后的一段时间，JSF2.0 (JSR-314)终于发布。2年多过去了，JSF2得到了众多厂商的支持，各种不同的JSF2的实现登上舞台。

是时候了，静下心来，好好关注JSF2。

简要的看了很多JSF2的资料，包括：

JavaServer Faces 2.0, The Complete Reference

JavaServer? Faces Specification V2.1

无意间看到了一套老外的培训资料，觉得很不错，怦然心动，觉得要做一些事情，开始吧，谁让中文版的JSF2的资料目前还没有呢。（翻译过程中，简化了一些内容，有些简单的部分直接引用原文，尽力终于原文含义，无奈能力有限，难免有不足之处，还望谅解。）

课程目录：

 01-JSF2-Overview

 02-JSF2-Getting-Started

 04-JSF2-Programming-Basics

 05-JSF2-Managed-Beans-1

 06-JSF2-Managed-Beans-2

 07-JSF2-Page-Navigation

 08-JSF2-Expression-Language

 09-JSF2-Properties-Files

 10-JSF2-Event-Handling

 11-JSF2-Ajax

 12-JSF2-Validation

 13-JSF2-Looping

 14-JSF2-Data-Tables

 15-JSF2-Composite-Components

 16-JSF2-Facelets-Templating

 17-JSF2-View-Params

 18-JSF2-Using-Spring

 19-JSF2-Whirlwind-Tour

JSF2.0系列教程概述

对于大多数类型的应用,构建基于Java的Web应用，JSF2是现在被推荐的方式，用于取代较早并低层次的servlet和JSP。本教程通篇使用Mojarra的JSF实现和Apache Tomcat6介绍JSF2,但是所有的代码应可以使用Apache MyFaces 2.0(在任何servlet 2.5容器)或任何Java EE 6服务器很好的运行。JSF2机会在方方面面优于JSF1,更强大、更容易使用。

练习是学习的关键所在,所以我强烈建议你尝试一些练习在每一节你看解决方法之前。

这些教程都源自Marty Hall's world-renowned live JSF 2.0 training courses。