JSF是一个新的基于MVC模型的web应用框架技术。在概念和特征方面，尤其是组件方面，超过了著名的Struts框架。而Myfaces是Apache软件基金的一个项目，它实现了JSF框架。同样sun公司也有一个参考实现 JSF RI。但是myfaces比JSF RI提供了更多的组件和特征。

Myfaces组件是一套用于JSF的组件，里面的tomahawk包包含了丰富的组件，只需要几个简单的标签就可以实现一些很有用的功能。

例如：树，文件的上传下载，日历 等

具体资料：http://myfaces.apache.org/index.html

当然，还有基于JSF的应用框架，他们也提供了很多好用的组件，所以在你试图自己开发组件之前，先看看有没有现成的可以用噢。

上面的例子，表现层的编码，解码工作都是Component自己完成的，但是这样的话，自定义Component的重用行就很差了。

所以这里要自定义一个Renderer来做编码，解码工作。要自定义一个Renderer，需要继承javax.faces.render.Renderer：

package test;

import java.io.IOException;

import java.util.Map;

import javax.faces.component.EditableValueHolder;

import javax.faces.component.UIComponent;

import javax.faces.component.UIInput;

import javax.faces.context.FacesContext;

import javax.faces.context.ResponseWriter;

import javax.faces.render.Renderer;

public class TextCmdRenderer extends Renderer {

private static final String TEXT = ".text";

    private static final String CMD = ".cmd";

    //编码

    public void encodeBegin(FacesContext context,

            UIComponent component) throws IOException {

         ResponseWriter writer = context.getResponseWriter();

         String clientId = component.getClientId(context);

         encodeTextField(component, writer, clientId);

         encodeCommand(component, writer, clientId);

      }

    //解码

      public void decode(FacesContext context,

                                UIComponent component) {

         Map reqParaMap = context.getExternalContext().

                                    getRequestParameterMap();

         String clientId = component.getClientId(context);

         String submittedValue =

                   (String) reqParaMap.get(clientId + TEXT);

         ((EditableValueHolder) component).setSubmittedValue(

                                              submittedValue);

         ((EditableValueHolder) component).setValid(true);

      }

      private void encodeTextField(UIComponent component,

                      ResponseWriter writer, String clientId)

                                       throws IOException {

         writer.startElement("input", component);

         writer.writeAttribute("name", clientId + TEXT, null);

         Object value = ((UIInput) component).getValue();

         if(value != null) {

             writer.writeAttribute("value",

                          value.toString(), null);

         }

         String size =

              (String) component.getAttributes().get("size");

         if(size != null) {

             writer.writeAttribute("size", size, null); 

         }

         writer.endElement("input");

      }

      private void encodeCommand(UIComponent component,

                         ResponseWriter writer,

                         String clientId) throws IOException {

         writer.startElement("input", component);

         writer.writeAttribute("type", "submit", null);

         writer.writeAttribute("name", clientId + CMD, null);

         writer.writeAttribute("value", "submit", null);

         writer.endElement("input");

      }

}

这个Renderer和之前Component的编码解码过程类似，只是方法上多了一个UIComponent参数，用来表示对应的Component。

faces-config.xml中配置定义的Renderer：

<!-- 自定义Renderer -->

       <render-kit>

         <renderer>

             <component-family>

                 javax.faces.Input

             </component-family>

             <renderer-type>

                 test.TextCmd

             </renderer-type>

             <renderer-class>

                 test.TextCmdRenderer

             </renderer-class>

         </renderer>

     </render-kit>

定义好了之后，只需要把上面自定义的那个Tag文件稍微修改一下就可以了：

…

public String getComponentType() {

        //return "test.TextWithCmd";

        return "javax.faces.Input";

    }

    public String getRendererType() {

        //return null;

       return "test.TextCmd";

    }

…

同样的，你也可以在自定义的Component中设置使用的Renderer。修改上面自定义Component的构造函数就可以了。

大家自己去试一下吧。具体程序参看示例程序。

这里介绍的是让Component自身负责编码，解码的例子。

我们设置一个简单的组件，一个文本框加一个按钮。

这里我们可以继承已经实现的UIComponent组件UIInput。

package test;

import java.io.IOException;

import java.util.Map;

import javax.faces.component.UIInput;

import javax.faces.context.FacesContext;

import javax.faces.context.ResponseWriter;

继承已经实现UIComponent的UIInput。

public class UITextWithCmd extends UIInput {

private static final String TEXT = ".text";

    private static final String CMD = ".cmd";

    //不使用Renderer进行解码

可以设定此组件的解码，编码不使用Renderer。

    public UITextWithCmd() {

        setRendererType(null); 

    }

    //--------编码,生成HTML标签--------------

    public void encodeBegin(FacesContext context)

实现前台表现层的编码。可以编写成HTML或者其他表现层语言。

                                      throws IOException {

        ResponseWriter writer = context.getResponseWriter();

        String clientId = getClientId(context);

        encodeTextField(writer, clientId);

        encodeCommand(writer, clientId);

    }

    private void encodeTextField(ResponseWriter writer,

                        String clientId) throws IOException {

        writer.startElement("input", this);

        writer.writeAttribute("name", clientId + TEXT, null);

        //getValue()继承于UIInput

        Object value = getValue();

        if(value != null) {

            writer.writeAttribute("value",

                                  value.toString(), null);

        }

        String size = (String) getAttributes().get("size");

        if(size != null) {

            writer.writeAttribute("size", size, null); 

        }

        writer.endElement("input");

    }

    private void encodeCommand(ResponseWriter writer,

                        String clientId) throws IOException {

        writer.startElement("input", this);

        writer.writeAttribute("type", "submit", null);

        writer.writeAttribute("name", clientId + CMD, null);

        writer.writeAttribute("value", "submit", null);

        writer.endElement("input");

    }

实现标签输入值的解码。取得标签的输入值绑定到响应的Bean。

    // ..........解码，取得标签的输入值...................................

    public void decode(FacesContext context) {

        Map reqParaMap = context.getExternalContext().

                                getRequestParameterMap();

        String clientId = getClientId(context);

        String submittedValue =

                   (String) reqParaMap.get(clientId + TEXT);

        setSubmittedValue(submittedValue);

        setValid(true);

    }

}

在配置文件faces-config.xml中声明自定义组件。

<!-- 自定义组件 -->

 <component>

     <component-type>test.TextWithCmd</component-type>

     <component-class>test.UITextWithCmd</component-class>

 </component>

这样，自定义的UIComponent组件就完成了。

JSF中的组件树概念尤其重要。组件树大量使用了组合设计模式，为开发者提供了大量的包括日历，表格，树，列表等标准Web组件。

同时JSF还提供了大量的组件支持类，例如转换器（可以进行类型转换），验证器（进行数据验证），绘制器（不仅仅可以使用HTML来绘制组件）。接下来我们分析一下用户界面组件。

所有组件都要实现javax.faces.component.UIComponent接口。这个接口定义了浏览组件树，和支持Bean交互，管理组件（包括数据验证，数据转换和组件绘制）等任务和方法。

JSF提供了一个组件基类：javax.faces.component.UICompoentBase。它实现了一些基本的默认的组件方法，给开发人员提供了方便，一般来说，你只需要重写特定的方法即可。

JSF使用了适配器模式帮助你使用最少的代码完成大部分工作。

如果你想创建组件，那么有三条路可以走：

直接实现UIComponent接口

继承UIComponentBase类

继承已经存在的UIComponent实现

已经存在的UIComponent组件类主要有如下：

●       UIForm 表示一个输入表单

●       UICommand 表示一个可在激活时执行一个动作的命令组件

●       UIOutput 表示一个可显示值的组件

●       UIGraphic 表示一个可显示图像的组件

●       UIInput 表示一个可获取和显示用户输入的组件

●       UIParameter 用于为父组件配置参数值

●       UIPanel 表示一个面板(容器)组件

●       UISelectItem 表示选择组件中的一个选择项

●       UISelectItems表示选择组件中的多个选择项

●       UISelectBoolean表示一个具有boolean值的组件

●       UISelectOne 表示一个允许用户在一系列值中选择零个或一个值的组件

●       UISelectMany表示一个允许用户在一系列值中选择零个或多个值的组件

事实上，一个JSF组件包括了三个部份：Tag、Component 与Renderer。

Tag就是之前使用的标签，它的目的在于设定Component属性，设定验证器，设定方法绑定等。

Component请求时，每个Component会根据自己的ID值，从请求中取得相应的值，绑定到Bean。当请求来到应用程序时，需要通过解码（decode）来

将HTTP中的内容转变成JSF组件需要的值，相对的，当JSF组件将值转变成HTTP字串资料送到客户端，供客户端显示，就称为编码（encode）。

Component可以自己实现编码，解码，也可以委托Renderer来实现。

Renderer是一个可替换的组件，Component可以搭配不通的Renderer，而不用自定义编码，解码工作，这样Component可以达到重用。

你也可以编写自己的Renderer，如果你对前台的显示有自己独特的要求的话。甚至可以让你的系统在移动设备等不同的平台上应用。

javax.faces.component.UIComponent

自订Component所要继承的父类别，但通常，您是继承其子类别，例如UIInput、UIOutput等等。

javax.faces.webapp.UIComponentTag

自订JSF标签所要继承的父类别，继承它可以帮您省去许多JSF标签处理的细节。

javax.faces.context.FacesContext
包括了JSF相关的请求资讯，您可以透过它取得请求物件或请求参数，或者是。

javax.faces.application.Application物件

包括了一个应用程式所共享的资讯，像是locale、验证器、转换器等等，您可以透过一些 工厂方法 取得相关的资讯。

带参数的Message信息设定：

tag部分介绍了带参数的Message在前台的设定，现在来看看后台的参数设定。

....

 String message = rsBundle.getString(

                      "test.message2");

 Object[] params = {"param1", "param2"};

 message = java.text.MessageFormat.format(message, params);

 FacesMessage facesMessage = new FacesMessage(

              FacesMessage.SEVERITY_FATAL, message, message);

....

FacesMessage建构时所使用的三个参数是严重程度、概述讯息与详述讯息，严重程度有SEVERITY_FATAL、SEVERITY_ERROR、SEVERITY_WARN与SEVERITY_INFO四种。

Message信息的表示可以在页面上用标签<h:messages>，也可以直接转移到特定的error画面，前面的例子已经说明了这一点。

我们可以在faces-config.xml配置文件中设置<navigation-rule>中设置每个画面的Error跳转，也可以设置类似拦截器的东西，将同一类型的错误统一转至Error画面。

Error拦截器可以根据exception-type或者error-code来分辨。

如下：

<error-page>

      <exception-type>javax.faces.FacesException</exception-type>

      <location>/pages/test.jsp</location>

</error-page>

或者

<error-page>

      <error-code>500</error-code>

      <location>/pages/test.jsp</location>

</error-page>

前面我们举的例子，用户需要输入用户名和密码提交验证。那么你输入的密码如果有长度限制，或者只能输入数字的话，

你可能会在用户验证之前进行检查，这样做也可以。

但是我个人的理解，唤起应用程序和执行验证相比，更靠后，程序效率会变低。而且程序的层次不清楚，验证和逻辑混合，不易维护。

所以我们可以自定义验证器来解决。

自定义验证器要实现javax.faces.validator.Validator的validate()方法

验证出错时ValidatorException，接受参数FacesMessage，可以在前台用标签<h:messages>显示。

我们先写个验证器：

package test;

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;

//自定义验证器

public class PasswordValidator implements Validator {

       public void validate(FacesContext context,

            UIComponent component,

            Object obj)

       throws ValidatorException {

              String password = (String) obj;

              if(password.length() < 6) {

                     FacesMessage message = new FacesMessage(

                         FacesMessage.SEVERITY_ERROR,

                         "字元长度小于6",

                         "字元长度不得小于6");

                     throw new ValidatorException(message);

              }

              if(!password.matches(".+[0-9]+")) {

                     FacesMessage message = new FacesMessage(

                           FacesMessage.SEVERITY_ERROR,

                           "密码必须包括字元与数字",

                           "密码必须是字元加数字所组成");

                     throw new ValidatorException(message);

              }

       }

}

新建一个jsp文件，其实和上面例子用的jsp差不多，只是加入了密码验证。

<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>

<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>

<%@page contentType="text/html;charset=utf-8"%>

<html>

<head>

<title>JSF 自定义验证器</title>

</head>

<body>

<f:view>

       <h:form>

              <h3>请输入您的名称</h3>

              <h:message for="dateField" style="color:red" /><p>

              <h:outputText value="#{user.errMessage}" style="color:red"/><p>

              <!-- 姓名 -->

              名称:<h:inputText value="#{user.name}" />

              <p>密码:<h:inputSecret id="dateField" value="#{user.password}">

加入了密码的验证器。

                            <f:validator validatorId="test.Password"/>

                     </h:inputSecret><p>

              <p><h:commandButton value="送出" action="#{user.verify}" />

       </h:form>

</f:view>

</body>

</html>

上面红色部分就是加入的密码验证器，按照jsf的生命周期，它是在唤起应用程序之前执行的。

faces-config.xmle中配置验证器

<!-- 验证器 -->

    <validator>

        <validator-id>test.Password</validator-id>

        <validator-class>test.PasswordValidator</validator-class>

    </validator>

Tomcat启动后，http://localhost:8080/jsfTest/pages/jsfMyValidator.faces 就可以运行了。当密码输入小于6或者有字母的时候，就会出错。

JSF国际化（Internnationalization）讯息处理是基于Java对国际化的支援，您可以在一个讯息资源档中统一管理讯息资源，messages_en.properties

例如：

nameText=name
passText=password

同时，你也可以定义对应于中文的统一管理讯息资源，messages_zh_TW.properties

例如：

nameText=\u540d\u7a31

passText=\u5bc6\u78bc

资源中的文字需要进行Unicode重新编码，可以用jdk自带的native2ascii工具实现。

JsfInternMessage.jsp

<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>

<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>

<%@page contentType="text/html;charset=utf-8"%>

<f:view locale="#{user.locale}">

       <f:loadBundle basename="messages" var="msgs" />

       <html>

       <head>

       <title><h:outputText value="#{msgs.titleText}" /></title>

       </head>

       <body>

       <h:form>

              <!—请输入你的姓名 -->

              <h3><h:outputText value="#{msgs.hintText}" /></h3>

              <!-- 姓名 -->

              <h:outputText value="#{msgs.nameText}" />:

<h:inputText value="#{user.name}" />

              <p><!-- 送出 --><h:commandButton id="button1"

                     value="#{msgs.commandText}" action="success" /> <!-- 调用不同的资源文件，改变页面的表示语言 -->

              <h:commandButton value="#{msgs.Text}"

                     actionListener="#{user.changeLocale}" />

触发user里的方法，返回不同的值，从而达到调用不同资源文件的目的。

       </h:form>

       </body>

       </html>

</f:view>

UserBean.java

…

public void changeLocale(ActionEvent e) {

        if(locale.equals("en"))

        locale = "zh_TW";

        else

        locale = "en";

    }

…

具体代码参看示例程序.(JsfInternMessage.jsp,UserBean.java,messages_en.properties,messages_zh_TW.properties)

注意：JSP页面头部要用下面的标签包住。

<f:view locale="#{user.locale}">

<f:loadBundle basename="messages" var="msgs"/>

上面标签的意思是，本JSP调用messages_"#{user.locale}".properties资源文件，如果user.locale=en，则调用messages_en.properties文件。

http://localhost:8080/jsfTest/pages/jsfInternMessage.faces 就可以正常执行了。

1.JSF JavaBean介绍

JSF使用 JavaBean 来达到程式逻辑与视图分离的目的，在JSF中的Bean其角色是属于Backing Bean，又称之为Glue Bean。

作用是在真正的业务逻辑Bean及UI元件之间搭起桥梁，相当于STRUTS中的FormBean，对页面的值进行存储。

JSF将Bean的管理集中在faces-config.xml中，上面介绍的JSF的例子如下：

<!-- bean定义 -->

    <managed-bean>

        <managed-bean-name>user</managed-bean-name>

         <managed-bean-class>test.UserBean</managed-bean-class>

        <managed-bean-scope>session</managed-bean-scope>

    </managed-bean>

<managed-bean-class>设定所要使用的Bean类别，<managed-bean-name>设定之名称，

<managed-bean-scope>设定Bean的存活范围，您可以设定为request、session 与application，设定为request时，Bean的存活时间为请求阶段。

您还可以将存活范围设定为none，当设定为none时会在需要的时候生成一个新的Bean，例如您在一个method中想要生成一个临时的Bean，就可以将之设定为none。

如果有必要在启始Bean时，自动设置属性的初始值，则可以如下设定：

....
<managed-bean>
  <managed-bean-name>user</managed-bean-name>
    <managed-bean-class>
      test.UserBean
    </managed-bean-class>
  <managed-bean-scope>session</managed-bean-scope>
    <managed-property>
      <property-name>name</property-name>
      <value>caterpillar</value>
    </managed-property>
    <managed-property>
      <property-name>password</property-name>
      <value>123456</value>
    </managed-property>
</managed-bean>
....　

您的属性不一定是字串值，也许会是int、float、boolean等等型态，您可以设定<value> 值时指定这些值的字串名称，JSF会尝试进行转换。

您也可以将其它产生的Bean设定给另一个Bean的属性，例如：

<managed-bean>

<managed-bean-name>user</managed-bean-name>

<managed-bean-class>test.UserBean</managed-bean-class>

<managed-bean-scope>session</managed-bean-scope>

</managed-bean>

<managed-bean>

<managed-bean-name>userinfo</managed-bean-name>

<managed-bean-class>test.UserBeanInfo</managed-bean-class>

<managed-bean-scope>session</managed-bean-scope>

<managed-property>

<property-name>userBean</property-name>

<property-class>test.UserBeanService</property-class>

<value>#{user}</value>

</managed-property>

</managed-bean>

在UserBeanInfo里面定义了变量userBean，变量userBean的类型是类UserBean，这里就把变量userBean直接赋值为#{user}。

2.JSF JavaBean示例（反向注入）

其实通常我们所说的反向注入（Ioc）就是这个，这也是JSF和STRUTS一个非常大的区别，JSF支持反向注入，它可以更好的管理业务Bean的对象。

下面举个例子：

在配置文件中：

<managed-bean>

<managed-bean-name>userinfo</managed-bean-name>

<managed-bean-class>test.UserBeanInfo</managed-bean-class>

<managed-bean-scope>session</managed-bean-scope>

<managed-property>

<property-name>userBean</property-name>

<property-class>test.UserBeanService</property-class>

<value>#{user}</value>

</managed-property>

</managed-bean>

这样，当UserBeanInfo的实例建立的时候，就会自动将UserBeanService的对象赋值给UserBeanInfo实例的变量userBean。

JsfBeanExample.jsp

<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>

<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>

<%@page contentType="text/html;charset=utf-8"%>

<html>

<head>

<title>JSF JavaBean示例（反向注入）</title>

</head>

<body>

<f:view>

       <h:form>

              <h3>请输入您的名称</h3>

              <h:outputText value="#{user.errMessage}" style="color:red"/><p>

              <!-- 姓名 -->

              名称: :<h:inputText value="#{user.name}" />

              <p>密码:<h:inputSecret value="#{user.password}"/>

              <p><h:commandButton value="送出"

                     action="#{userinfo.verify1}" />

       </h:form>

</f:view>

</body>

</html>

UserBeanInfo.java:

package test;

public class UserBeanInfo {

       UserBeanService userBean;

       public String verify1() {

              if (!userBean.getName().equals("sunlin")

                            || !userBean.getPassword().equals("123456")) {

                     userBean.setErrMessage("名称或者密码错误1（依赖注入实现）");

                     return "failure";

              } else {

                     return "success";

              }

       }

       /**

        * userBean をセットする

        * @param userBean the userBean to set

        */

       public void setUserBean(UserBeanService userBean) {

              this.userBean = userBean;

       }

}

UserBeanInfo的类里面并没有绑定页面输入的信息，页面输入的信息是绑定在Userbean中的。但是我们在faces-config.xml配置文件中设置了反向注入，

将UserBeanService直接设置到UserBeanInfo的变量userBean里，所以在类UserBeanInfo中可以直接取得Userbean中的信息进行Check。

▲注意：UserBeanInfo中必须要定义setUserBean()方法。

http://localhost:8080/jsfTest/pages/jsfBeanExample.faces 当你用户名或者密码出错的时候，Message就会显示在页面上。

首先要到JSF官网上下载参考实例，并将其lib目录下的jar文件复制到你的应用程序/WEB-INF/lib目录下。

这里我已经下载好了，在示例src的lib目录下可以找到。

需要一下档案：

 jsf-impl.jar
 jsf-api.jar
 commons-digester.jar
 commons-collections.jar
 commons-beanutils.jar
 jstl.jar

 standard.jar

配置Web应用程式的web.xml

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

<web-app id="WebApp_ID" version="2.4"

       xmlns="http://java.sun.com/xml/ns/j2ee"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

       <description>JSF Test</description>

       <display-name>JSF Test</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>

例如请求是/index.faces的话，则实际上会唤起/index.jsp网页

       </servlet-mapping>

       <welcome-file-list>

              <welcome-file>index.html</welcome-file>

       </welcome-file-list>

</web-app>

写一个简单的JavaBean：

具体程序参看示例程序：jsfTest\src\test\UserBean.java，编译好之后放置在/WEB-INF/classes下。

再登入网页/pages/index.jsp，使用者填入名称并送出表单，在/pages/welcome.jsp中显示Bean中的使用者名称与欢迎讯息。

定义一个/WEB-INF/faces-config.xml，

如下：

<!-- bean定义 -->

    <managed-bean>

        <managed-bean-name>user</managed-bean-name>

         <managed-bean-class>test.UserBean</managed-bean-class>

        <managed-bean-scope>session</managed-bean-scope>

关于javaBean的几种管理，在下面会有详细的说明。

    </managed-bean>

<!-- 画面转移 -->

    <navigation-rule>

        <from-view-id>/pages/index.jsp</from-view-id>

        <navigation-case>

            <from-outcome>success</from-outcome>

            <to-view-id>/pages/welcome.jsp</to-view-id>

        </navigation-case>

        <navigation-case>

            <from-outcome>failure</from-outcome>

            <to-view-id>/pages/index.jsp</to-view-id>

        </navigation-case>

    </navigation-rule>

配置文件：

<navigation-rule>设定，以决定在符合的条件成立时，该连结至哪一个页

在<navigation-rule>中的<from-view-id>是个选择性的定义，它规定了来源页面的条件

<navigation-case>中定义各种导览条件

<from-outcome>定义当表单结果符合的条件

在<managed-bean>中我们可以统一管理我们的Bean，我们设定Bean物件的存活范围是session，也就是使用者开启浏览器与程式互动过程中都存活。

Index.jsp

<%@taglib uri="http://java.sun.com/jsf/core" prefix="f" %>

 <%@taglib uri="http://java.sun.com/jsf/html" prefix="h" %>

 <%@page contentType="text/html;charset=utf-8"%>

 <html>

 <head>

 <title>第一个JSF程序</title>

 </head>

 <body>

    <f:view>

        <h:form>

            <h3>请输入您的名称</h3>

            名称: <h:inputText value="#{user.name}"/><p>

            <h:commandButton value="送出" action="success"/>

        </h:form>

    </f:view>

 </body>

</html>

将程序放入到Tomcat中启动，敲入http://localhost:8080/jsfDemo/pages/index.faces就可以显示欢迎页面了。

package net.moon.service;
public interface IUserService ...{
 String getUsername();
 String getPassword();
 void setUsername(String username);
 void setPassword(String password);
}

用一个类实现该接口,代码如下:

package net.moon.model;
import net.moon.service.IUserService;
public class UserInfo implements IUserService...{
 private String username;
 private String password;
 
/** *//**
  * @return the usernmae
  */
 public String getUsername() ...{
  return username;
 }

/** *//**
  * @param usernmae the usernmae to set
  */
 public void setUsername(String usernmae) ...{
  this.username = usernmae;
 }

 /** *//**
  * @return the password
  */
 public String getPassword() ...{
  return password;
 }

 /** *//**
  * @param password the password to set
  */

public void setPassword(String password) ...{
  this.password = password;
 }
}

写一个事务类,实现login功能,其中有一个类型为IUserService的域,代码如下:

package net.moon.business;

import net.moon.service.IUserService;

public class UserBO ...{

 IUserService user;
 
 public String login()...{
  String result = "FAILED";
  //System.out.println(result);
  if(user.getUsername().equalsIgnoreCase("admin")
    && user.getPassword().equals("password"))...{
   result = "PASS";
  }
  return result;
 }

 /** *//**
  * @return the user
  */

 public IUserService getUser() ...{
  return user;
 }

 /** *//**
  * @param user the user to set
  */
 public void setUser(IUserService user) ...{
  this.user = user;
 }
}

注意该类中的属性方法setUser, 其中的参数user作为IUserService的接口类型.然后就是用什么方法对user进行注入,这时候就要想到JSF中的Managed Properties.

首先在,faces-config中配置UserInfo类为MBean,代码如下:

 <managed-bean>
  <managed-bean-name>userInfo</managed-bean-name>
  <managed-bean-class>net.moon.model.UserInfo</managed-bean-class>
  <managed-bean-scope>session</managed-bean-scope>
 </managed-bean>

 然后将事务类UserBO也配置为MBean,代码如下:

 <managed-bean>
  <managed-bean-name>userBO</managed-bean-name>
  <managed-bean-class>
   net.moon.business.UserBO
  </managed-bean-class>

 <managed-bean-scope>request</managed-bean-scope>
  <managed-property>
   <property-name>user</property-name>
   <property-class>
    net.moon.service.IUserService
   </property-class>
   <value>#{userInfo}</value>
  </managed-property>
 </managed-bean>

为userBO这个MBean配置了一个Managed Property,也就是要求JSF在实现userBO时, 用userInfo这个MBean为其user这个域赋值,从而实现注入.

接下来就是页面的实现了,首先是login页面, 代码如下:

<%...@ page contentType="text/html; charset=UTF-8" %>
<%...@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%...@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>

<html>
 <head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
  <title></title>
 </head>
 <body>
  <f:view>
   <h:form>
  <h:panelGrid border="1" columns="2">
   <h:outputText value="User Name:"></h:outputText>
   <h:inputText value="#{userInfo.username}"></h:inputText>

   <h:outputText value="Password:"></h:outputText>
   <h:inputText value="#{userInfo.password}"></h:inputText>
   </h:panelGrid>
   <h:commandButton value="Login" action="#{userBO.login}"></h:commandButton>
 </h:form>
  </f:view>
 </body>
</html>

表示登录成功的页面welcome.jsp,代码如下:

<%...@ page contentType="text/html; charset=UTF-8" %>
<%...@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%...@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>

<html>
 <head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
  <title></title>
 </head>
 <body>
  <f:view>
   <h:form>
        <h:outputText value="Welcome , #{userInfo.username}"></h:outputText>
        </h:form>
  </f:view>
 </body>
</html>

配置导航如下:

 <navigation-rule>
  <display-name>login</display-name>
  <from-view-id>/login.jsp</from-view-id>
  <navigation-case>
   <from-action>#{userBO.login}</from-action>
   <from-outcome>PASS</from-outcome>
   <to-view-id>/welcome.jsp</to-view-id>
  </navigation-case>
  <navigation-case>
            <from-action>#{userBO.login}</from-action>
            <from-outcome>FAILED</from-outcome>
            <to-view-id>/login.jsp</to-view-id>
        </navigation-case>
 </navigation-rule>