程序博客网 > sonyhdr as50软件

Spring讲解----------集成框架

来源：互联网 发布：sonyhdr as50软件 编辑：程序博客网 时间：2024/05/26 05:53

10.1  概述

10.1.1  Spring和Web框架

       Spring框架不仅提供了一套自己的Web框架实现，还支持集成第三方Web框架（如Struts1x、Struts2x）。

 

       Spring实现的SpringMVC Web框架将在第十八章详细介绍。

 

       由于现在有很大部分公司在使用第三方Web框架，对于并不熟悉SpringMVC Web框架的公司，为了充分利用开发人员已掌握的技术并相使用Spring的功能，想集成所使用的Web框架；由于Spring框架的高度可配置和可选择性，因此集成这些第三方Web框架是非常简单的。

 

       之所以想把这些第三方Web框架集成到Spring中，最核心的价值是享受Spring的某些强大功能，如一致的数据访问，事务管理，IOC，AOP等等。

 

       Spring为所有Web框架提供一致的通用配置，从而不管使用什么Web框架都使用该通用配置。

 

10.1.2  通用配置

Spring对所有Web框架抽象出通用配置，以减少重复配置，其中主要有以下配置：

 

1、Web环境准备：

1.1、在spring项目下创建如图10-1目录结构：

 

图10-1 web目录结构

1.2、右击spring项目选择【Propeties】，然后选择【Java Build Path】中的【Source】选项卡，将类输出路径修改为“spring/webapp/WEB-INF/classes”，如图10-2所示：

 

图10-2 修改类输出路径

1.3、web.xml初始内容如下：

 

java代码：
Java代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"  
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.        xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee  
  5.        http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">  
  6. </web-app>  

 <web-app version="2.4">表示采用Servlet 2.4规范的Web程序部署描述格式

 

 

2、 指定Web应用上下文实现：在Web环境中，Spring提供WebApplicationContext（继承ApplicationContext）接口用于配置Web应用，该接口应该被实现为在Web应用程序运行时只读，即在初始化完毕后不能修改Spring Web容器（WebApplicationContext），但可能支持重载。

 

Spring提供XmlWebApplicationContext实现，并在Web应用程序中默认使用该实现，可以通过在web.xml配置文件中使用如下方式指定：

 

java代码：
Java代码  收藏代码
  1. <context-param>  
  2.     <param-name>contextClass</param-name>  
  3.     <param-value>  
  4.         org.springframework.web.context.support.XmlWebApplicationContext  
  5.     </param-value>  
  6. </context-param>  

  如上指定是可选的，只有当使用其他实现时才需要显示指定。

 

 

3、 指定加载文件位置：

前边已经指定了Spring Web容器实现，那从什么地方加载配置文件呢？

 

默认情况下将加载/WEB-INF/applicationContext.xml配置文件，当然也可以使用如下形式在web.xml中定义要加载自定义的配置文件，多个配置文件用“，”分割：

 

java代码：
Java代码  收藏代码
  1. <context-param>  
  2.     <param-name>contextConfigLocation</param-name>  
  3.     <param-value>  
  4.         classpath:chapter10/applicationContext-message.xml  
  5.     </param-value>  
  6. </context-param>  

 

通用Spring配置文件（resources/chapter10/applicationContext-message.xml）内容如下所示：

 

java代码：
Java代码  收藏代码
  1. <bean id="message" class="java.lang.String">  
  2.     <constructor-arg index="0" value="Hello Spring"/>  
  3. </bean>  

 

 

4、 加载和关闭Spring Web容器：

我们已经指定了Spring Web容器实现和配置文件，那如何才能让Spring使用相应的Spring Web容器实现加载配置文件呢？

 

Spring使用ContextLoaderListener监听器来加载和关闭Spring Web容器，即使用如下方式在web.xml中指定：

 

java代码：
Java代码  收藏代码
  1. <listener>  
  2.     <listener-class>  
  3.        org.springframework.web.context.ContextLoaderListener  
  4.     </listener-class>  
  5. </listener>  

 

ContextLoaderListener监听器将在Web应用启动时使用指定的配置文件初始化Spring Web容器，在Web应用关闭时销毁Spring Web容器。

注：监听器是从Servlet 2.3才开始支持的，因此如果Web应用所运行的环境是Servlet 2.2版本则可以使用ContextLoaderServlet来完成，但从Spring3.x版本之后ContextLoaderServlet被移除了。

 

5、 在Web环境中获取Spring Web容器:

既然已经定义了Spring Web容器，那如何在Web中访问呢？Spring提供如下方式来支持获取Spring Web容器（WebApplicationContext）：

 

 

java代码：
Java代码  收藏代码
  1. WebApplicationContextUtils.getWebApplicationContext(servletContext);  
  2. 或  
  3. WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);  

   如果当前Web应用中的ServletContext 中没有相应的Spring Web容器，对于getWebApplicationContext()方法将返回null,而getRequiredWebApplicationContext()方法将抛出异常，建议使用第二种方式，因为缺失Spring Web容器而又想获取它，很明显是错误的，应该抛出异常。

 

 

6、 通用jar包，从下载的spring-framework-3.0.5.RELEASE-with-docs.zip中dist目录查找如下jar包：


org.springframework.web-3.0.5.RELEASE.jar 

此jar包为所有Web框架所共有，提供WebApplicationContext及实现等。

 

 

7、Web服务器选择及测试：

       目前比较流行的支持Servlet规范的开源Web服务器包括Tomcat、Resin、Jetty等，Web服务器有独立运行和嵌入式运行之分，嵌入式Web服务器可以在测试用例中运行不依赖于外部环境，因此我们使用嵌入式Web服务器。

 

       Jetty是一个非常轻量级的Web服务器，并且提供嵌入式运行支持，在此我们选用Jetty作为测试使用的Web服务器。

 

7.1、准备Jetty嵌入式Web服务器运行需要的jar包：

 

到http://dist.codehaus.org/jetty/网站下载jetty-6.1.24，在下载的jetty-6.1.24.zip包中拷贝如下jar包到项目的lib/jetty目录下，并添加到类路径中：  

 

7.2、在单元测试中启动Web服务器：

 

java代码：
Java代码  收藏代码
  1. package cn.javass.spring.chapter10;  
  2. import org.junit.Test;  
  3. import org.mortbay.jetty.Server;  
  4. import org.mortbay.jetty.webapp.WebAppContext;  
  5. public class WebFrameWorkIntegrateTest {  
  6.     @Test  
  7.     public void testWebFrameWork() throws Exception {  
  8.         Server server = new Server(8080);  
  9.         WebAppContext webapp = new WebAppContext();  
  10.         webapp.setResourceBase("webapp");  
  11.         //webapp.setDescriptor("webapp/WEB-INF/web.xml");  
  12.         webapp.setContextPath("/");  
  13.         webapp.setClassLoader(Thread.currentThread().getContextClassLoader());  
  14.         server.setHandler(webapp);  
  15.         server.start();  
  16.         server.join();  
  17.        //server.stop();  
  18.     }  
  19. }  
  • 创建内嵌式Web服务器：使用new Server(8080)新建一个Jetty服务器，监听端口为8080；
  • 创建一个Web应用：使用new WebAppContext()新建一个Web应用对象，一个Web应用可以认为就是一个WebAppContext对象；
  • 指定Web应用的目录：使用webapp.setResourceBase("webapp")指定Web应用位于项目根目录下的“webapp”目录下；
  • 指定部署描述符：使用webapp.setDescriptor("webapp/WEB-INF/web.xml")；此处指定部署描述符为项目根目录下的“webapp/WEB-INF/web.xml”，该步骤是可选的，如果web.xml位于Web应用的WEB-INF下。
  • 指定Web应用请求上下文：使用webapp.setContextPath("/")指定请求上下文为“/”，从而访问该Web应用可以使用如“http://localhost:8080/hello.do”形式访问；
  • 指定类装载器：因为Jetty自带的ClassLoader在内嵌环境中对中文路径处理有问题，因此我们使用Eclispe的ClassLoader，即通过“webapp.setClassLoader(Thread.currentThread().getContextClassLoader()) ”指定；
  • 启动Web服务器：使用“server.start()”启动并使用“server.join()”保证Web服务器一直运行；
  • 关闭Web服务器：可以通过某种方式执行“server.stop()”来关闭Web服务器；另一种方式是通过【Console】控制台面板的【Terminate】终止按钮关闭，如图10-3所示：

 

图10-3 点击红色按钮关闭Web服务器

 

先进行通用配置， 【第十章】集成其它Web框架 之 10.1 概述 

 

10.3  集成Struts2.x

10.3.1  概述

Struts2前身是WebWork，核心并没有改变，其实就是把WebWork改名为struts2，与Struts1一点关系没有。

 

Struts2中通过ObjectFactory接口实现创建及获取Action实例，类似于Spring的IoC容器，所以Action实例可以由ObjectFactory实现来管理，因此集成Spring的关键点就是如何创建ObjectFactory实现来从Spring容器中获取相应的Action Bean。

 

Struts2提供一个默认的ObjectFactory接口实现StrutsSpringObjectFactory，该类用于根据Struts2配置文件中相应Bean信息从Spring 容器中获取相应的Action。

 

因此Struts2.x与Spring集成需要使用StrutsSpringObjectFactory类作为中介者。

 

接下来让我们首先让我们准备Struts2x所需要的jar包

准备Struts2.x需要的jar包，到Struts官网http://struts.apache.org/下载struts-2.2.1.1版本，拷贝如下jar包到项目的lib目录下并添加到类路径：


lib\struts2-core-2.2.1.1.jar              //核心struts2包

lib\xwork-core-2.2.1.1.jar              //命令框架包，独立于Web环境，为Struts2

//提供核心功能的支持包

lib\freemarker-2.3.16.jar               //提供模板化UI标签及视图技术支持

lib\ognl-3.0.jar                       //对象图导航工具包，类似于SpEL

lib\ struts2-spring-plugin-2.2.1.1.jar      //集成Spring的插件包

lib\commons-logging-1.0.4.jar          //日志记录组件包（已有）

lib\commons-fileupload-1.2.1.jar        //用于支持文件上传的包

 

10.3.2  使用ObjectFactory集成

1、Struts2.x的Action实现：

 

java代码：
Java代码  收藏代码
  1.       
  2. package cn.javass.spring.chapter10.struts2x.action;  
  3. import org.apache.struts2.ServletActionContext;  
  4. import com.opensymphony.xwork2.ActionSupport;  
  5. public class HelloWorldAction extends ActionSupport {  
  6.     private String message;  
  7.     @Override  
  8.     public String execute() throws Exception {  
  9.         ServletActionContext.getRequest().setAttribute("message", message);  
  10.         return "hello";  
  11.     }  
  12.     public void setMessage(String message) {//setter注入  
  13.         this.message = message;  
  14.     }  
  15. }  

 

2、JSP页面定义，使用Struts1x中定义的JSP页面“webapp/WEB-INF/jsp/hello.jsp”；

 

3、Spring一般配置文件定义（resources/chapter10/applicationContext-message.xml）：

在此配置文件中定义我们使用的“message”Bean；

 

java代码：
Java代码  收藏代码
  1. <bean id="message" class="java.lang.String">  
  2.     <constructor-arg index="0" value="Hello Spring"/>  
  3. </bean>  

 

 

4、Spring Action 配置文件定义（resources/chapter10/hello-servlet.xml）：

 

java代码：
Java代码  收藏代码
  1. <bean name="helloAction" class="cn.javass.spring.chapter10.struts2x.action.HelloWorldAction" scope="prototype">  
  2.     <property name="message" ref="message"/>  
  3. </bean>  

 

Struts2的Action在Spring中配置，而且应该是prototype，因为Struts2的Action是有状态的，定义在Spring中，那Struts如何找到该Action呢？

 

 

5、struts2配置文件定义（resources/chapter10/struts2x/struts.xml）：

 

java代码：
Java代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE struts PUBLIC  
  3.     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"  
  4.     "http://struts.apache.org/dtds/struts-2.0.dtd">  
  5. <struts>  
  6.     <constant name="struts.objectFactory" value="org.apache.struts2.spring.StrutsSpringObjectFactory"/>  
  7.     <constant name="struts.devMode" value="true"/>  
  8.     <package name="default" extends="struts-default">  
  9.         <action name="hello" class="helloAction">  
  10.             <result name="hello" >/WEB-INF/jsp/hello.jsp</result>  
  11.         </action>  
  12.     </package>  
  13. </struts>  
  • struts.objectFactory：通过在Struts配置文件中使用常量属性struts.objectFactory来定义Struts将要使用的ObjectFactory实现，此处因为需要从Spring容器中获取Action对象，因此需要使用StrutsSpringObjectFactory来集成Spring；
  • <action name="hello" class="helloAction">：StrutsSpringObjectFactory对象工厂将根据<action>标签的class属性去Spring容器中查找同名的Action Bean；即本例中将到Spring容器中查找名为helloAction的Bean。

 

6、web.xml部署描述符文件定义（webapp/WEB-INF/web.xml）：

 

6.1、由于Struts2只能使用通用配置，因此需要在通用配置中加入Spring Action配置文件（chapter10/struts2x/struts2x-servlet.xml）：

 

java代码：
Java代码  收藏代码
  1. <context-param>  
  2.     <param-name>contextConfigLocation</param-name>  
  3.     <param-value>  
  4.         classpath:chapter10/applicationContext-message.xml,  
  5.         classpath:chapter10/struts2x/struts2x-servlet.xml  
  6.     </param-value>  
  7. </context-param>  

       Struts2只能在通用配置中指定所有Spring配置文件，并没有如Struts1自己指定Spring配置文件的实现。

 

6.2、Strut2前端控制器定义，在web.xml中添加如下配置：

 

java代码：
Java代码  收藏代码
  1. <!-- Struts2.x前端控制器配置开始   -->  
  2. <filter>  
  3.     <filter-name>struts2x</filter-name>  
  4.     <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>  
  5.     <init-param>  
  6.               <param-name>config</param-name>  
  7.               <param-value>  
  8.                      struts-default.xml,struts-plugin.xml,chapter10/struts2x/struts.xml  
  9.                </param-value>  
  10.        </init-param>  
  11. </filter>  
  12. <filter-mapping>  
  13.     <filter-name>struts2x</filter-name>  
  14.     <url-pattern>*.action</url-pattern>  
  15. </filter-mapping>  
  16. <!-- Struts2.x前端控制器配置结束   -->  
  • FilterDispatcher：Struts2前端控制器为FilterDispatcher，是Filter实现，不是Servlet；
  • config：通过初始化参数config指定配置文件为struts-default.xml，struts-plugin.xml，chapter10/struts2x/struts.xml；如果不知道该参数则默认加载struts-default.xml，struts-plugin.xml，struts.xml(位于webapp/WEB-INF/classes下)；显示指定时需要将struts-default.xml，struts-plugin.xml也添加上。
  • *.action：将拦截以“.action”结尾的HTTP请求；
  • struts2x：FilterDispatcher前端控制器的名字为struts2x，因此相应的Spring配置文件名为struts2x-servlet.xml。

 

7、执行测试，在Web浏览器中输入http://localhost:8080/hello.action可以看到“Hello Spring”信息说明Struts2集成成功。

 

 

 

集成Strut2也是非常简单，在此我们总结一下吧：

  • 配置文件位置：

         Struts配置文件默认加载“struts-default.xml,struts-plugin.xml, struts.xml”，其中struts-default.xml和struts-plugin.xml是Struts自带的，而struts.xml是我们指定的，默认位于webapp/WEB-INF/classes下；

         如果需要将配置文件放到其他位置，需要在web.xml的<filter>标签下，使用初始化参数config指定，如“struts-default.xml，struts-plugin.xml，chapter10/struts2x/struts.xml”，其中“struts-default.xml和struts-plugin.xml”是不可省略的，默认相对路径是类路径。

  • 集成关键ObjectFactory：在Struts配置文件或属性文件中使用如下配置知道使用StrutsSpringObjectFactory来获取Action实例：

 在struts.xml中指定：

 

java代码：
Java代码  收藏代码
  1. <constant name="struts.objectFactory" value="org.apache.struts2.spring.StrutsSpringObjectFactory"/>  

 

或在struts.properties文件（webapp/WEB-INF/classes/）中：

 

java代码：
Java代码  收藏代码
  1. struts.objectFactory=org.apache.struts2.spring.StrutsSpringObjectFactory  

 

  • 集成关键Action定义：

                StrutsSpringObjectFactory将根据Struts2配置文件中的<action class=””>标签的classes属性名字去到Spring配置文件中查找同名的Bean定义，这也是集成的关键。

 

  • Spring配置文件中Action定义：由于Struts2的Action是有状态的，因此应该将Bean定义为prototype。

 

如图10-5，Sturt2与Spring集成的关键就是StrutsSpringObjectFactory，注意图只是说明Struts与Spring如何通过中介者StrutsSpringObjectFactory来实现集成，不能代表实际的类交互。

 

图10-5 Strut2与Spring集成



10.4  集成JSF

10.4.1  概述

       JSF（JavaServer Faces）框架是Java EE标准之一，是一个基于组件及事件驱动的Web框架，JSF只是一个标准（规范），目前有很多厂家实现，如Oracle的默认标准实现Mojarra、Apache的MyFaces、Jboss的RichFaces 等。

 

       本示例将使用Oracle标准实现Mojarra，请到官网http://javaserverfaces.java.net/下载最新的JSF实现。

 

       JSF目前有JSF1.1、JSF1.2、JSF2版本实现。

 

       Spring集成JSF有三种种方式：

  • 最简单集成：使用FacesContextUtils工具类的getWebApplicationContext方法，类似于Struts1x中的最简单实现；
  • VariableResolver实现：Spring提供javax.faces.el.VariableResolver的两种实现DelegatingVariableResolver和SpringBeanVariableResolver，此方式适用于JSF1.1、JSF1.2及JSF2，但在JSF1.2和JSF2中不推荐使用该方式，而是使用第三种集成方式；
  • ELResolver实现：Spring提供javax.el.ELResolver （Unified EL）实现SpringBeanFacesELResolver用于集成JSF1.2和JSF2。

 

接下来让我们首先让我们准备JSF所需要的jar包：

首先准备JSF所依赖的包：

commons-digester.jar                  //必须，已有

commons-collections.jar                //必须，已有

commons-beanutils.jar                 //必须，已有

jsp-api.jar                                   //必须，已有

servlet-api.jar                              //必须，已有                          

jstl.jar                                        //可选

standard.jar                                //可选

 

准备JSF包，到http://javaserverfaces.java.net/下载相应版本的Mojarra实现，如下载JSF1.2实现mojarra-1.2_15-b01-FCS-binary.zip，拷贝如下jar包到类路径：

lib\jsf-api.jar                           //JSF规范接口包

lib\jsf-impl.jar                          //JSF规范实现包

 

 

 

10.4.2  最简单集成

类似于Struts1x中的最简单集成，Spring集成JSF也提供类似的工具类FacesContextUtils，使用如下方式获取WebApplicationContext：

 

java代码：
Java代码  收藏代码
  1. WebApplicationContext ctx = FacesContextUtils.getWebApplicationContext(FacesContext.getCurrentInstance());  
  2.    

       当然我们不推荐这种方式，而是推荐使用接下来介绍的另外两种方式。

 

10.4.2  使用VariableResolver实现集成

Spring提供javax.faces.el.VariableResolver的两种实现DelegatingVariableResolver和SpringBeanVariableResolver，其都是Spring与JSF集成的中介者，此方式适用于JSF1.1、JSF1.2及JSF2：

  • DelegatingVariableResolver：首先委托给JSF默认VariableResolver实现去查找JSF管理Bean，如果找不到再委托给Spring容器去查找Spring管理Bean；
  • SpringBeanVariableResolver：其与DelegatingVariableResolver查找正好相反，首先委托给Spring容器去查找Spring管理Bean，如果找不到再委托给JSF默认VariableResolver实现去查找JSF管理Bean。

 

接下来看一下如何在JSF中集成Spring吧（本示例使用JSF1.2，其他版本的直接替换jar包即可）：

 

1、JSF管理Bean（Managed Bean）实现：

 

java代码：
Java代码  收藏代码
  1. package cn.javass.spring.chapter10.jsf;  
  2. public class HelloBean {  
  3.     private String message;  
  4.     public void setMessage(String message) {  
  5.         this.message = message;  
  6.     }  
  7.     public String getMessage() {  
  8.         return message;  
  9.     }  
  10. }  
  11.    

 

2、JSF配置文件定义（resources/chapter10/jsf/faces-config.xml）：

 

java代码：
Java代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <faces-config version="1.2" xmlns="http://java.sun.com/xml/ns/javaee"  
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4. xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facesconfig_1_2.xsd">  
  5.    
  6.     <application>  
  7.         <variable-resolver>  
  8.             org.springframework.web.jsf.DelegatingVariableResolver  
  9.         </variable-resolver>  
  10.     </application>  
  11.      
  12.     <managed-bean>  
  13.         <managed-bean-name>helloBean</managed-bean-name>  
  14.         <managed-bean-class>  
  15.             cn.javass.spring.chapter10.jsf.HelloBean  
  16.         </managed-bean-class>  
  17.         <managed-bean-scope>request</managed-bean-scope>  
  18.         <managed-property>  
  19.             <property-name>message</property-name>  
  20.             <value>#{message}</value>  
  21.         </managed-property>  
  22.     </managed-bean>        
  23. </faces-config>  
  • 与Spring集成：通过<variable-resolver>标签来指定集成Spring的中介者DelegatingVariableResolver；
  • 注入Spring管理Bean：通过<managed-property>标签的<value>#{message}</value>注入Spring管理Bean“message”。

 

4、JSP页面定义（webapp/hello-jsf.jsp）：

 

java代码：
Java代码  收藏代码
  1.       
  2. <%@ page language="java" pageEncoding="UTF-8" contentType="text/html; charset=UTF-8"%>  
  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
  4. <%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>  
  5. <%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>  
  6. <f:view>  
  7. <html>  
  8. <head>  
  9.     <title>Hello World</title>  
  10. </head>  
  11. <body>  
  12.     <h:outputText value="#{helloBean.message}"/>  
  13. </body>  
  14. </html>  
  15. </f:view>  

 

 

5、JSF前端控制器定义，在web.xml中添加如下配置：

 

指定JSF配置文件位置，通过javax.faces.CONFIG_FILES上下文初始化参数指定JSF配置文件位置，多个可用“，”分割，如果不指定该参数则默认加载的配置文件为“/WEB-INF/ faces-config.xml”：

 

java代码：
Java代码  收藏代码
  1. <!-- JSF配置文件开始 -->  
  2. <context-param>  
  3.     <param-name>javax.faces.CONFIG_FILES</param-name>  
  4.     <param-value>  
  5.         /WEB-INF/classes/chapter10/jsf/faces-config-jsf1x.xml  
  6.     </param-value>  
  7. </context-param>  
  8. <!-- JSF配置文件结束 -->  

 

前端控制器定义：使用FacesServlet作为JSF的前端控制器，其拦截以“.jsf”结尾的HTTP请求：

 

 

java代码：
Java代码  收藏代码
  1. <!-- jsf前端控制器配置开始   -->  
  2. <servlet>  
  3.     <servlet-name>jsf</servlet-name>  
  4.     <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>  
  5. </servlet>  
  6. <servlet-mapping>  
  7.     <servlet-name>jsf</servlet-name>  
  8.     <url-pattern>*.jsf</url-pattern>  
  9. </servlet-mapping>  
  10. <!-- jsf前端控制器配置结束   -->  

 

7、执行测试，在Web浏览器中输入http://localhost:8080/hello-jsf.jsp可以看到“Hello Spring”信息说明JSF集成成功。

 

自此，JSF集成Spring已经成功，在此可以把DelegatingVariableResolver替换为SpringBeanVariableResolver，其只有在查找相应依赖时顺序是正好相反的，其他完全一样。

如果您的项目使用JSF1.2或JSF2，推荐使用SpringBeanFacesELResolver，因为其实标准的Unified EL实现，而且VariableResolver接口已经被注释为@Deprecated，表示可能在以后的版本中去掉该接口。

 

10.4.2         使用ELResolver实现集成

JSF1.2之前，JSP和JSF各个使用自己的一套表达式语言（EL Language），即如JSF使用VariableResolver实现来解析JSF EL表达式，而从JSF1.2和JSP2.1开始使用Unified EL，从而统一了表达式语言。

 

因此集成JSF1.2+可以通过实现Unified EL来完成集成，即Spring提供ELResolver接口实现SpringBeanFacesELResolver用于集成使用。

类似于VariableResolver实现，通过SpringBeanFacesELResolver集成首先将从Spring容器中查找相应的Spring管理Bean，如果没找到再通过默认的JSF ELResolver实现查找JSF管理Bean。

 

接下来看一下示例一下吧：

 

1、 添加Unified EL所需要的jar包：

el-api.jar                                       //Unified EL规范接口包

 

由于在Jetty中已经包含了该api，因此该步骤可选。

 

 

2、 修改JSF配置文件（resources/chapter10/jsf/faces-config.xml）：

 

将如下配置

 

java代码：
Java代码  收藏代码
  1. <variable-resolver>  
  2.     org.springframework.web.jsf.DelegatingVariableResolver  
  3. </variable-resolver>  

 

修改为：

 

java代码：
Java代码  收藏代码
  1. <el-resolver>  
  2. org.springframework.web.jsf.el.SpringBeanFacesELResolver  
  3. </el-resolver>  

 

 

3、执行测试，在Web浏览器中输入http://localhost:8080/hello-jsf.jsp可以看到“Hello Spring”信息说明JSF集成成功。

 

自此JSF与Spring集成就算结束了，是不是也很简单。

 

 本文借鉴：【http://sishuok.com/forum/blogPost/list/0/2513.html】

0 0
sonyhdr as50软件 sonyhdr as50软件
原创粉丝点击
热门IT博客
网络优化工程师网络优化工程师
表格两列重复数据筛选表格两列重复数据筛选
cnki是什么数据库
java cp 命令
企业应用整合优化
js正则表达式判断数字
中标数据查询网
pc6下载站 mac
淘宝客服头像图片女
骑行软件
php登录注册完整代码
苹果来电拦截软件
java中求成绩的最大值
全民目击凶手是谁知乎
工业机器人编程语言co
pos及数据拦截器
致富360是什么软件
速卖通第三方软件
TIOBE的编程语言指数
俊平护肤品怎么样知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 蓝壳机油多久换一次 蓝壳机油真假 黄壳机油价格 黄壳机油 黄壳机油怎么样 蓝天白云 蓝天图片 蓝天野 蓝天和白云 碧海蓝天 什么蓝天 蓝天拼音 蓝天集团 蓝天英语 蓝天电脑 蓝天英文 蓝天公司 蓝天图 蓝天学校 蓝天歌词 演员蓝天 蓝天白云图片 爱就像蓝天白云 野外蓝天打一生肖 蓝天公棚秋棚 蓝天电脑集团 蓝妮事件 蓝妮 蓝妹 蓝妹啤酒图片 黑妹啤酒 蓝妹啤酒度数 蓝妹啤酒 蓝妹啤酒多少度 蓝妹啤酒几度 蓝妹图片 蓝妹啤酒产地 蓝妹啤酒好喝吗 蓝妹啤酒多少钱一瓶 蓝妹啤酒是德国还是韩国 哈尔滨冰纯啤酒价格

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里