入门： tomcat6013+myeclipse55m1+jsf12+spring2+proxool+jtds 的开发实现-CSDN博客

本文链接：https://blog.csdn.net/zwb13631438816/article/details/1681999

首先配置tomcat6013+myeclispe55m1+jsf12 开发环境

首先请确保你已安装jdk1.5或以上版本、tomcat6
然后到http://java.sun.com 网上去下载jsf1.2x版本
(此处说明一下!现在网上有sun提供的基础:jsf-ri和apache 开源提供扩展版本的myfaces)[小生在这里可是吃了不少苦头，如果你要做个通用的jsf，建议用jsf-ri]
JSF1.2 开发的lib 只需要jsf-api.jar、jsf-impl.jar、jstl.jar、standart.jar四个，此外还需要web-facesconfig_1_0.dtd、web-facesconfig_1_1.dtd、XMLSchema.dtd
JSF1.2是不需要jsf_core.tld和html_basic.tld,加进去会出错

具体路径如下所示：

现在让我们来开始第一个简单的JSF吧
1、managedBean
/**
*
*/
package com.fangbiao.jsf;
import java.io.Serializable;
/**
* @author Administrator
*
*/
public class User implements Serializable{
private String name;
private String psw;
public User(){}
/**
* 用于登陆判断
* @return
*/
public String login(){
  if(psw != null && name.equals("fangbiao"))
   return "sucess";
  return "failure";
}

/**
* @return name
*/
public String getName() {
return name;
}

/**
* @param name 要设置的 name
*/
public void setName(String name) {
this.name = name;
}

/**
* @return psw
*/
public String getPsw() {
return psw;
}

/**
* @param psw 要设置的 psw
*/
public void setPsw(String psw) {
this.psw = psw;
}
}

2、定义两个JSP文件
(1)index.jsp
<%@ page language="java" pageEncoding="GBK"%>
<%@ page contentType="text/html" language="java" %>
<%@ taglib prefix="f" uri="http://java.sun.com/jsf/core" %>
<%@ taglib prefix="h" uri="http://java.sun.com/jsf/html" %>

<html>
<head>
  <title>这是我的第一个JSF程序</title>
</head>
<body>
  <f:view>
   <h:form>
    请输入您的姓名:<h:inputText value="#{user.name}"/>
    <br>
    请输入您的密码:<h:inputSecret value="#{user.psw}"/>
    <br>
    <h:commandButton value="提交" action="#{user.login}"/>
   </h:form>
  </f:view>
</body>
</html>
(2)welcome.jsp
<%@ page language="java" pageEncoding="GBK"%>
<%@ page contentType="text/html" language="java" %>
<%@ taglib prefix="f" uri="http://java.sun.com/jsf/core" %>
<%@ taglib prefix="h" uri="http://java.sun.com/jsf/html" %>

3、faces-config.xml和web.xml

(1)faces-config.xml

(2)web.xml

4、启动Tomcat6服务器进入测试
打开E浏览器输入 http://localhost:8080/项目名/index.jsf

TITLE: -- tomcat6013+myeclispe55m1+jsf12+spring2+proxool+jtds 的开发实现!!

先前,我们已经配置了好了用tomcat6013+myeclispe55m1+jsf12的开发环境!!
接下来我们就要与数据库打交道了!!
该节我们将应用开源连接池proxool-090RC3与开源JDBC驱动器jtds12作为我们应用程序与数据库打交道,
我们应用使用的数据库是sqlserver2000,有点老了,不过你也可以尝试使用sqlserver2005
在此,我不推蒋使用官方的jdbc驱动SQLServerDriver,因为他与连接池proxool所联合的137错误令我闷了半天!

接下来,让我们到sourceforge网上去下载我们所需要的库:
proxool-0.9.0RC3.jar 和 jtds-1.2.jar

把他们加入到我们先前的lib中

一、配置proxool
偶在web-inf下创建一个datasource.xml（数据源配置）
详情如下：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
       
   <bean id="placeholderConfig"
    class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

    <property name="location">
    <value>/WEB-INF/mssqlJdbc.properties</value>
    </property>
</bean>
<bean id="mssql_dataSource"
    class="org.logicalcobwebs.proxool.ProxoolDataSource">
    <property name="driver">
    <value>${proxool.driverName}</value>
    </property>
    <property name="driverUrl">
    <value>${proxool.url}</value>
    </property>
    <property name="user">
    <value>${proxool.userName}</value>
    </property>
    <property name="password">
    <value>${proxool.password}</value>
    </property>
    <property name="houseKeepingTestSql">
    <value>${proxool.houseKeepingTestSql}</value>
    </property>
    <property name="prototypeCount">
    <value>${proxool.prototypeCount}</value>
    </property>
    <property name="houseKeepingSleepTime">
    <value>${proxool.hourseKeepingSleepTime}</value>
    </property>
    <property name="maximumConnectionCount">
    <value>${proxool.maximumConnectionCount}</value>
    </property>
    <property name="minimumConnectionCount">
    <value>${proxool.minimumConnectionCount}</value>
    </property>
</bean>
</beans>

创建WEB-INF/mssqlJdbc.properties文件，用于与mssql_dataSource下参数相映射

#数据库名称
proxool.datasource = jsfDemo
#数据库驱动名称
#proxool.driverName = com.microsoft.jdbc.sqlserver.SQLServerDriver
proxool.driverName =net.sourceforge.jtds.jdbc.Driver
#连接的url{可能是proxool的Bug,只能把用户名和密码写在url上(具体你可以参考proxoolDataSource这个类[关于各参数据加载次序])}
proxool.url =jdbc:jtds:sqlserver://localhost:1433/${proxool.datasource};user=sa;password=1234
#用户名称
proxool.userName =sa
#密码
proxool.password =1234
#数据源别名
#proxool.alias = myProxool
#侦察时间间隔
proxool.hourseKeepingSleepTime = 60000
#最小空闲数
proxool.prototypeCount = 2
#最大连接数
proxool.maximumConnectionCount = 50
#最小连接数
proxool.minimumConnectionCount = 2
#执行语句是否要记录
#proxool.trace = false
#记录执行的详细信息
#proxool.verbose = false
#测试的SQL执行语句
proxool.houseKeepingTestSql = select getDate()
#最大活动时间(超过此时间线程将被kill,默认为5分钟)
proxool.maximumActiveTime = 300000
#连接最长时间(默认为4个小时)
proxool.maximumConnectionLifetime = 3060000000

此外，我们可以在web.xml中装载一个proxool提供的Servlet，以便我们可以随时查看连接池的连接情况，该处可选

<servlet>
<servlet-name>admin</servlet-name>
<servlet-class>org.logicalcobwebs.proxool.admin.servlet.AdminServlet</servlet-class>
</servlet>

<servlet-mapping>
<servlet-name>admin</servlet-name>
<url-pattern>/admin</url-pattern>
</servlet-mapping>

当应用部署成功并开始运作后，我们可以输入http://localhost:8080/项目名/admin
你就可以查询相关的数据库连接池情况

由于开发的跟风和软件本身的性能，我选择了spring作业我的业务操层，持久层将使用Ibatis，但此实例偶将不涉及ibatis,偶
将利用spring的JdbcTemplate来进行数据库CRUD操作

NOW，选择项目，右击>>选择Myeclipse>>add Spring Capli...
选择spring2-->core library && aop library && web library ,单击finish ,OK

打开Web.xml,在里面进行相关的设置,偶给出其配置成功的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>javax.faces.CONFIG_FILES</param-name>
    <param-value>/WEB-INF/faces-config.xml</param-value>
</context-param>

<context-param>
<param-name>log4jConfigLocation</param-name>
<param-value>/WEB-INF/log4j.properties</param-value>
</context-param>

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/datasource.xml /WEB-INF/applicationContext.xml</param-value>
</context-param>
    
<listener>
    <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
</listener>
<listener>
    <listener-class> org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<listener>
    <listener-class>com.sun.faces.config.ConfigureListener</listener-class>
</listener>

<servlet>
    <servlet-name>fServlet</servlet-name>
    <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
    <load-on-startup>0</load-on-startup>
</servlet>

<servlet>
    <servlet-name>admin</servlet-name>
    <servlet-class>org.logicalcobwebs.proxool.admin.servlet.AdminServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>fServlet</servlet-name>
    <url-pattern>*.jsf</url-pattern>
</servlet-mapping>

<servlet-mapping>
<servlet-name>admin</servlet-name>
<url-pattern>/admin</url-pattern>
</servlet-mapping>
</web-app>

现在，我们的应用中已经有了jsf/spring/proxool/jtds

如何把他们的关系相互的整合起来呢

首先，利用简单的配置整合JSF ^ SPRING
该配置将在faces-config.xml中进行设置，具体如下：
<application>
  
  <message-bundle>mes.messages</message-bundle>
  <locale-config>
   <default-locale>zh_CN</default-locale>
   <supported-locale>en</supported-locale>
  </locale-config>
  
  <variable-resolver>org.springframework.web.jsf.DelegatingVariableResolver</variable-resolver>
</application>

那么下面，将是我们的spring与数据库之间的搭桥啦
记得先前我们创建的mssql_dataSource吗！！我们将利用spring的JdbcDaoSupport和JdbcTemplate来进行交接
我们创建一个类来实现，如下所示：
package com.fangbiao.spring;
import java.util.List;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

/**
* @author fangbiao
*
*/
public class UserDaoImpl extends JdbcDaoSupport implements IUserDao{
//假如你要用自定义的datasource的值注入的话，请不要继承JdbcDaoSupport，这样做的好处是依赖之间松藕合
//DataSource dataSource ;
public List findByUserId() {
  //以下这种this.getApplicationContext，你必须继承spring中的WebApplicationContextSupport以取得spring web上下文环境
  //dataSource = (BasicDataSource)this.getApplicationContext().getBean("mssql_dataSource");
     // 这里的this就是引用JdbcDaoSupport
  JdbcTemplate jdbcTemplate = this.getJdbcTemplate();
  return jdbcTemplate.queryForList(FIND_BY_USERID);
}
/*public void setDataSource(DataSource dataSource){
  this.dataSource = dataSource;
}*/
}

在这个类中我没有把他独立出来，所以当你要创建一个真实的项目时，请不要这么做，这样你会重复写很多次类似的代码，如JdbcTemplate

现在，来说说我们这节的目标，我们将通过用户web请求，从一个数据库中取出所有用户的数据信息
一、创建数据库和相应的数据表信息
create database jsfDemo
go
use jsfDemo
go
drop table myJsfUser
go
create table myJsfUser
(
userId decimal identity(1,1) constraint pk_userId primary key,
userName varchar(25) not null,
userPsw varchar(18) not null,
userAge int not null,
userAddress varchar(100)
)

go
insert into myJsfUser select 'fangbiao', 'fangbiao', 24, 'zhongguo guangzhou'
insert into myJsfUser select '小郑',     'fangbiao', 24, 'zhongguo guangzhou'
insert into myJsfUser select 'mikey',    'fangbiao', 24, 'zhongguo shanghai'
insert into myJsfUser select 'duck',     'fangbiao', 24, 'zhongguo guangzhou tianhe'
go
select * from myJsfUser

二、创建Jsf与Spring上下文环境交接的助手类对象

package com.fangbiao.jsf.util;
import org.springframework.context.ApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import javax.faces.context.FacesContext;
import javax.servlet.ServletContext;
/**
* @author fangbiao
*
*/
public class SpringFacesUtil {
/**
* 将JSF上下文环境对象也装载进Spring当，以后JSF和Spring中的Bean对象皆可以从该方法中找到
* @param beanName 输入要获取的Bean的名称
* @return Object
*/
public static Object findBean(String beanName){
  ServletContext context = (ServletContext)FacesContext.getCurrentInstance().getExternalContext().getContext();
  ApplicationContext ctx = WebApplicationContextUtils.getRequiredWebApplicationContext(context);
  return ctx.getBean(beanName);
}
}

三、创建我们的业务对象，目的是查找所有的用户数据
（1）、首先，定义一个业务对象接口（把关系定义在接口中是JAVA编程来实现重用的最大优点）。

package com.fangbiao.spring;
import java.util.List;

/**
* @author fangbiao
*
*/
public interface IUserBusinessService {
/**
* 实现把用户资料根据ID信息给读出来，并返回一个用户列表数据信息
*/
public List getUserWithdUserId();
}

（2）、定义一个业务对象的实现类对象，该对象将具体的实现赋予DAO去实现。

package com.fangbiao.spring;

import java.util.List;

/**
* @author fangbiao
*
*/
public class UserBusinessImpl implements IUserBusinessService {
//用于值注入时，加载相应的userDao实现类对象
IUserDao userDao;
/**
* 实现根据ID信息获取用户列表资料
* @see com.fangbiao.spring.IUserBusinessService#getUserWithdUserId(java.util.Map)
*/
public List getUserWithdUserId() {
  //把具体的实现委托级userDao
  return userDao.findByUserId();
}

public void setUserDao(IUserDao iud){
  this.userDao = iud;
}
}

（3）定义一个UserDao的接口，声明相应的dao实现

package com.fangbiao.spring;
import java.util.List;

/**
* @author fangbiao
*
*/
public interface IUserDao {
//此处我们定义了一条sql查询语句,真下在的实现可以把所有的SQL语句放置于一个文件中，以便统一管理
public final String FIND_BY_USERID = "SELECT userName,userPsw,userAge,userAddress FROM myJsfUser WHERE userId <> 0";
//定义一个根据ID信息获取用户列表资料的方法声明
public List findByUserId();
}

（4）实现UserDao接口的具体类对角，该类是最基础的DAO底层操作实现，该对象引用了spring中JDBC实现的JdbcTemplate对象，以便完
成较为低级的JDBC实现

package com.fangbiao.spring;
import java.util.List;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

/**
* @author fangbiao
*
*/
public class UserDaoImpl extends JdbcDaoSupport implements IUserDao{
       //具体的查找实现方法
public List findByUserId() {
     // 这里的this就是引用JdbcDaoSupport
  JdbcTemplate jdbcTemplate = this.getJdbcTemplate();
  return jdbcTemplate.queryForList(FIND_BY_USERID);
}
}

（5）、定义的一个简单的包装类对象，以便不暴露我们的相关的业务操作对象
package com.fangbiao.spring;

import java.util.List;

import com.fangbiao.jsf.util.SpringFacesUtil;
import com.fangbiao.spring.IUserBusinessService;
/**
* @author fangbiao
*
*/
public class SpringTest
{
//这是我们做测试的一个例子，以后具体实现偶也推蒋这种方法，不要让业务接口暴露（该方法命名可能不太好，但做测试用，也就不改啦）
public List doSpringTest(){
  //利用SpringFacesUtil来查找我们的业务实现
  IUserBusinessService iubs = (IUserBusinessService)SpringFacesUtil.findBean("user_business");
  return iubs.getUserWithdUserId();
}
}
四、以上完成了我们的Spring业务实现和DAO实现，现在来看看我们的交互层实现

（1）、现在就来写我们的View对角，以便把查找的结果显现出来

package com.fangbiao.jsf;
import java.util.List;

import com.fangbiao.jsf.util.SpringFacesUtil;
import com.fangbiao.spring.SpringTest;
/**
* @author fangbiao
*
*/
public class UserList {
//该列表将在JSP中的<h:dataTable/>中显示出来
private List allUserMsg;
public List getAllUserMsg(){
  //看这里，我们还能知道业务接口吗？？呵呵
  allUserMsg = ((SpringTest)SpringFacesUtil.findBean("spring_test")).doSpringTest();
  return allUserMsg;
}
}

（2）、接下来，就是稿写我们的POJO对象User类啦，其实就是TO
package com.fangbiao.jsf;
import java.io.Serializable;
/**
* @author fangbiao
*
*/
public class User implements Serializable{
private static final long serialVersionUID = -6031008880347052659L;
private String name;
private String psw;
private int age;
private String addr;
/**
* @return addr
*/
public String getAddr() {
  return addr;
}
/**
* @param addr 要设置的 addr
*/
public void setAddr(String addr) {
  this.addr = addr;
}
/**
* @return age
*/
public int getAge() {
  return age;
}
/**
* @param age 要设置的 age
*/
public void setAge(int age) {
  this.age = age;
}
public User(){}
public User(String name,String psw,int age,String addr){
  setName(name);
  setPsw(psw);
  setAge(age);
  setAddr(addr);
}
/* *
* @return name
*/
public String getName() {
  return name;
}

/**
* @param name 要设置的 name
*/
public void setName(String name) {
this.name = name;
}

/**
* @return psw
*/
public String getPsw() {
return psw;
}

/**
* @param psw 要设置的 psw
*/
public void setPsw(String psw) {
this.psw = psw;
}
}

（3）、稿写一个用户登陆处理对象（JSF的令人感兴趣的也许就是在这么简单的一个类对象当中）

package com.fangbiao.jsf;

/**
* @author fangbiao
*
*/
public class UserBean{
//用户对象
private User user;
/**
* 用于登陆判断（兴趣由来）
* @return
*/
public String login(){
  //利用fangbiao来登陆查看用户列表信息
  if(user.getName().equals("fangbiao"))
   return "sucess";
  else
   return "failure";
}
/**
* @return user
*/
public User getUser() {
  return user;
}
/**
* @param user 要设置的 user
*/
public void setUser(User user) {
  this.user = user;
}
}
五、写完我们的jsf对象和Spring 对象，现在就要来配置他们的关系
（1）、Spring对象之间的应用关系配置,俺将其定义在默认的applicationContext.xml文件中

<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">

<bean id="user_dao"
       class="com.fangbiao.spring.UserDaoImpl">
      
  <property name="dataSource">
   <ref bean="mssql_dataSource"/>
  </property>
</bean>
<bean id="user_business"
    class="com.fangbiao.spring.UserBusinessImpl">
    <property name="userDao">
    <ref bean="user_dao"/>
    </property>
</bean>
<bean id="spring_test" class="com.fangbiao.spring.SpringTest"/>
</beans>

（2）、JSF对象之间的应用关系配置,俺将其定义在默认的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">
    
    <application>
  
  <message-bundle>mes.messages</message-bundle>
  <locale-config>
   <default-locale>zh_CN</default-locale>
   <supported-locale>en</supported-locale>
  </locale-config>
  
  <variable-resolver>org.springframework.web.jsf.DelegatingVariableResolver</variable-resolver>
</application>
    
<navigation-rule>
  <from-view-id>/index.jsp</from-view-id>
  <navigation-case>
   <from-outcome>sucess</from-outcome>
   <to-view-id>/welcom.jsp</to-view-id>
  </navigation-case>
</navigation-rule>

<managed-bean>
  <managed-bean-name>user</managed-bean-name>
  <managed-bean-class>com.fangbiao.jsf.User</managed-bean-class>
  <managed-bean-scope>session</managed-bean-scope>
</managed-bean>

<managed-bean>
  <managed-bean-name>userBean</managed-bean-name>
  <managed-bean-class>com.fangbiao.jsf.UserBean</managed-bean-class>
  <managed-bean-scope>session</managed-bean-scope>
  <managed-property>
   <property-name>user</property-name>
   <value>#{user}</value>
  </managed-property>
</managed-bean>

<managed-bean>
  <managed-bean-name>userResult</managed-bean-name>
  <managed-bean-class>com.fangbiao.jsf.UserList</managed-bean-class>
  <managed-bean-scope>request</managed-bean-scope>
</managed-bean>
</faces-config>

（3）、web.xml文件在前面就已经提供，现在我们来写一个log4j.properties文件，以便可以输出相应的日志信息

log4j.rootLogger=DEBUG,stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %5p (%F:%L) - %m%n

现在完成所有的配置了吗？不，我们还没添加国际化实现的文件呢!!

（4）、添加国际化文件实现（这里只是针对JSF页面文件的国际化，业务对象的国际化可以在spring的配置文件中进行相关设置，先不谈那么多，
我们一步一步来）

messages.properties文件
index=Please input you name
messages_zh_CN.properties文件（为了方便就不进行国语转换，不过你可以用工具或者jdk下的native2ascii进行转换）
index=Please input you name
messages_en_US.properties文件
index=Please input you name

现在，才完成我们这个简单应用的所有相关配置和对象书写，接着一豉作气，把我们的jsp页面也给搞定....

六、偶稿写了两个JSP页面来进行测试，下面，我们开始吧

（1）、index.jsp
<%@ page language="java" pageEncoding="GBK"%>
<%@ page contentType="text/html" 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>
   
   <f:loadBundle var="mm" basename="mes.messages"/>
   <title>这是我的第一个JSF程序</title>
  </head>
  <body>

   <h:form>
    
    <h:panelGrid columns="3" border="2" >
     <h:panelGroup >
      
      <h:outputLabel value="#{mm.index}"/>
      <h:inputText id="userName" value="#{userBean.user.name}">
       
       <f:validateLength maximum="10" minimum="6"/>
      </h:inputText>
     </h:panelGroup>
     <h:panelGroup>
      请输入您:<h:inputSecret value="#{userBean.user.psw}"/>
     </h:panelGroup>
     <h:outputText value="#{userBean.ds.password}"/>
    
    <h:commandButton value="提交" action="#{userBean.login}"/>
    </h:panelGrid>

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

（2）、welcom.jsp (显示用户列表信息)

<%@ page language="java" pageEncoding="GBK"%>
<%@ page contentType="text/html" 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><h:outputText value="欢迎 #{user.name} 来到jsf12+spring+jdts+proxool新世界"/></title>
  </head>
  <h:panelGrid >
   
   <h:dataTable id="textDataTable" value="#{userResult.allUserMsg}" var="allUser">
    <h:column>
     <f:facet name="header">
      <h:outputText value="姓名"/>
     </f:facet>
     <h:selectOneListbox value="userName">
      <f:selectItem itemLabel="#{allUser.userName}" itemValue="#{allUser.userName}" itemDisabled="false"/>
     </h:selectOneListbox>
    </h:column>
    <h:column>
     <f:facet name="header">
      <h:outputText value="密码"/>
     </f:facet>
     <h:outputText value="#{allUser.userPsw}"/>
    </h:column>
    <h:column>
     <f:facet name="header">
      <h:outputText value="年龄"/>
     </f:facet>
     <h:outputText value="#{allUser.userAge}"/>
    </h:column>
    <h:column>
     <f:facet name="header">
      <h:outputText value="地址"/>
     </f:facet>
     <h:outputText value="#{allUser.userAddress}"/>
    </h:column>
   </h:dataTable>
  </h:panelGrid>
</html>
</f:view>

至此，已完成我们简单应用的所有实现，now把我们的项目部署在tomcat6013服务器上！！
启动服务，打开IE，输入
http://localhost:8080/项目名/index.jsf
你是否看到一个登陆页了呢！！！
在名字框中输入 fangbiao
单击"提交"，呵呵！是不是看见我们所有的用户列表信息了呢!!!