Struts2通过过滤器对每个jsp页面国际化

合集下载

struts2 global-allowed-methods的用法

struts2 global-allowed-methods的用法Struts2中的`global-allowed-methods`是一个全局配置属性，用于限制或允许用户使用的HTTP方法。

该属性可以在`struts.xml`配置文件中的`<constant>`元素中设置。

以下是`global-allowed-methods`属性的用法示例：1. 允许所有的HTTP方法：```xml<constant name="struts.enable.DynamicMethodInvocation" value="false" /><constant name="struts.mapper.allowMethods" value="*" />```2. 允许GET和POST方法：```xml<constant name="struts.enable.DynamicMethodInvocation" value="false" /><constant name="struts.mapper.allowMethods"value="GET,POST" />```3. 禁止所有的HTTP方法：```xml<constant name="struts.enable.DynamicMethodInvocation" value="false" /><constant name="struts.mapper.allowMethods" value="" />```在上述示例中，`struts.enable.DynamicMethodInvocation`属性设置为`false`，表示禁用动态方法调用。

软件开发框架(J2EE)Struts 2拦截器习题与答案

1.以下属于struts2的控制器组件是（）。

A.ActionB.ActionFormC.ActionServletD.dispatchAction2.以下属于struts2的体系结构的是（）。

A.struts2控制器组件B.struts2配置文件C.FilterDispathcerD.Action3.以下属于struts2配置文件中的配置元素是（）。

A.<package>B.<action>C.<form-beans>D.<action-mappings>4.关于struts1和struts2对比的说法正确的是（）。

A.Struts1要求Action类继承Struts1框架中的Action父类，Struts2中则不一定需要继承，可以是POJO类B.struts1中的Action不是线程安全的，而struts2中的Action是线程安全的C.struts1和struts2中都使用ActionForm对象封装用户的请求数据D.struts1使用OGNL表达式语言来支持页面效果，struts2通过ValueStack技术使标签库访问值5.以下关于ValueStack说法正确的是（）。

A.每个Action对象实例拥有一个ValueStack对象B.每个Action对象实例拥有多个ValueStack对象C.Action中封装了需要传入下一个页面的值，这些值封装在ValueStack对象中D.ValueStack会在请求开始时被创建，请求结束时消亡6.关于struts2配置文件说法正确的是（）。

A.必须在WEB-INF/classes目录下B.名字必须为struts.xmlC.配置Action时，必须配置包信息D.使用<forward>元素配置转发7.在struts2配置中用（）元素来配置常量。

B.<constants>C.<constant>D.<constant-mapping>8.关于struts2包的说法正确的是（）。

02-Struts2的工作流程及配置文件

Struts2的工作流程及配置文件--- ---Struts2.0的流程图从图中看到Struts2的工作流程如下：1.服务器接收到的请求首先经过一组过滤器链（实际中的其他过滤器可能还包括诸如Spring 的字符过滤器CharactorEncodingFilter、V elocity的过滤器等，一般FilterDispatcher位于过滤器的最后一个执行），过滤器链按照你在web.xml中的配置顺序在接收客户请求时顺序执行，在向客户发送响应时反序执行，Struts2的核心FilterDispatcher在web.xml中的配置如下：<filter><filter-name>setCharactor</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param></filter><filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class> </filter><filter-mapping><filter-name>setCharactor</filter-name><url-pattern>/*</url-pattern></filter-mapping><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping>注意：如果你使用的是W ebLogic6.1作为应用服务器，需要使用FilterDispatcherCompatW eblogic61替代FilterDispatcher。

struts2框架特征

struts2框架特征Struts2框架特征Struts2是一种流行的Java Web应用程序开发框架，其特征使其成为许多开发者的首选。

本文将介绍Struts2框架的特征，包括MVC 架构、强大的标签库、拦截器、数据验证、国际化支持以及灵活的配置等。

一、MVC架构Struts2采用了MVC（Model-View-Controller）架构，将应用程序的业务逻辑、数据模型和用户界面分离。

这种架构使开发者能够更好地组织代码、提高代码的可维护性，并能够更容易地进行代码重用和测试。

在Struts2中，Model代表数据模型，可以是POJO（Plain Old Java Object）或者是与数据库交互的实体类；View代表用户界面，通常是JSP页面；Controller则负责处理用户请求、调用业务逻辑，并将处理结果返回给用户。

二、强大的标签库Struts2提供了丰富的标签库，使开发者能够更轻松地构建用户界面。

这些标签库包括表单标签、数据展示标签、控制流标签等，可以大大简化页面开发的工作量。

例如，开发者可以使用Struts2的表单标签库来生成表单，并自动处理表单的数据绑定、验证和错误提示。

这样，开发者无需手动编写大量的HTML和JavaScript代码，能够更快速地完成表单开发。

三、拦截器Struts2的拦截器是其核心特性之一，可用于在请求到达Controller之前和之后执行一些通用的处理逻辑，如日志记录、权限验证、异常处理等。

开发者可以通过配置拦截器栈，将多个拦截器按照特定的顺序组合起来，实现复杂的请求处理流程。

拦截器的使用使得开发者能够将通用的处理逻辑从业务逻辑中分离出来，提高了代码的可维护性和重用性。

同时，Struts2还提供了许多内置的拦截器，如参数封装拦截器、文件上传拦截器等，方便开发者处理不同类型的请求。

四、数据验证在Web应用程序中，数据验证是一项重要的任务。

Struts2提供了强大的数据验证机制，开发者可以通过简单的配置实现对表单数据的验证。

Struts2过滤器和整合Sitemesh插件

反向思维：在第一种情况当中，如果自定义过滤器当中把核心控制器要做的事情全部做完了，这个时候核心控制器也不会执行。（也是在转发的情况下。）
我们知道Struts2的核心控制器就是一个Filter，我们又知道在Struts2 2.1.3版本之前是通过 FilterDispacher充当核心控制器，而之后是通过StrutsPrepareAndExecuteFilter充当核心控制器，那么，我们要问的是Struts2为什么要做这样的改变？
Struts2过滤器及Sitemesh插件
在struts2中使用过滤器与我们之前在JSP、 Servlet中使用过滤器基本一致。我们今天要探讨的是在Struts2中与我们之前使用过滤器需要考虑或者注意的地方。
在Struts2中使用过滤器要注意的地方：假设自定义控制器对所有的请求都进行过滤 1、如果自定义的过滤器放在核心控制器的前面，这个时候组成的过滤器链是自定义过滤器-核心控制器，也就是说，肯定是先执行自定义控制器，然后再执行核心控制器。 2、如果把自定义的过滤器放在核心控制器的后面，这个时候组成的过滤器链就是核心控制器在前面，自定义过滤器在后面，由于在核心控制器当中，最终会调用所请求的action的方法，如果对响应的结果是转发的话，这个时候不是新的请求，自定义过滤器这个时候自始至终都没有执行。
另外，由于是重定向，是一次新的请求，因此，在请求的过程中我们可以传递参数： <action name="Login" class="actions.LoginAction"> <result name="success" type="redirect">A.action?age=${user.age}</result> </action> --------------------------------------------------<action name="Login" class="steven.actions.LoginAction"> <result name="success" type="redirectAction">A?age=${user.age}</result> </action>

前端开发中的国际化处理方法

前端开发中的国际化处理方法在当今日益全球化的互联网环境中，对于前端开发来说，国际化已经成为一个重要的考虑因素。

所谓国际化，就是将产品或网站适应于不同语言、不同文化习惯的需求，使其能够在全球范围内顺利运行和交互。

本文将介绍一些前端开发中常用的国际化处理方法，旨在帮助开发者更好地应对国际化的需求。

一、语言切换和资源文件语言切换是前端国际化处理的基本需求之一。

通过为网站或应用程序提供多语言支持，可以使用户根据自己的需要选择使用的语言。

在前端开发中，最常用的方式是使用资源文件（如JSON、XML等）来存储不同语言的文本内容，然后根据用户选择的语言加载相应的资源文件，实现语言切换功能。

同时，为了方便维护和更新，可以将不同语言的资源文件分别存放在不同的文件中，通过合适的命名规范和文件目录结构来组织管理。

二、日期、时间和货币格式化除了语言切换外，国际化还涉及到日期、时间和货币等格式化的处理。

不同国家和地区有不同的日期和时间格式，如年月日的顺序、时间的小时制或12小时制、货币的符号和位数等。

对于前端开发来说，可以使用现有的库或插件来实现这些格式的自动转换，如Moment.js和Numeral.js等。

这些库提供了丰富的日期、时间和货币处理功能，可以根据用户的地区设置自动格式化显示。

三、数字和单位转换在国际化处理中，数字和单位的转换也是一个重要的问题。

不同地区使用的计量单位和数值表示方式可能不同，比如货币单位、长度单位、重量单位等。

为了适应不同地区的需求，前端开发需要对数字和单位进行自动转换。

可以使用类似于Moment.js和Numeral.js的库来实现这些功能，或者根据具体需求自行开发相应的代码。

四、多语言输入和字体处理除了文本和格式化的处理，国际化还需考虑多语言输入和字体的适配。

对于需要支持多语言输入的网站或应用程序，前端开发需要实现相应的输入框和编辑器，以满足用户在不同语言环境下的输入需求。

同时，还需要考虑不同语言所使用的字体是否支持，并根据需要进行字体的适配和兼容处理。

JSP和Struts2之间跳转总结

JSP和Struts2之间跳转实验报告:
Struts2的处理步骤
Struts2框架对Wed请求处理的具体步骤如下所述。

1.客户端浏览器发送一个请求，
2.这个请求经过核心控制器FilterDispatcher过滤处理，FilterDispatcher将请求转交给相应
的Action代理。

3.Action代理通过配置文件中的信息找到对应的Action类，创建Action对象并调用其
execute（）方法。

4.在调用Action的过程前后，涉及相关拦截器的调用，拦截器自动对请求应用通过功能，
5.一旦Action执行完毕，Action代理根据Struts.xml中的配置信息找到execute（）方法返
回值对应的结果。

返回结果通常是视图资源或另一个Action。

在Wed应用中加入Struts2的核心类库后，还要修改wed.xml配置文件，在wed.xml文件中配置Struts2的核心控制器FilterDispatcher。

配置文件代码如下。

上述代码中配置了Struts2的核心过滤器，指明过滤器类是FilterDispatcher,过滤器URL模式是匹配所有请求。

如此，该Wed应用就具备了Struts2框架的功能支持。

配置业务控制器
Struts.xml位置
上述代码配置了一个名为add的Action，并指明对应的Action类，在<result>元素中指明返回值为“cal”时对应的跳转页面时add_result.jsp。

运行结果。

struts2面试题

struts2面试题Struts2是一个基于Java开发的Web应用程序框架，被广泛应用于企业级Java应用开发中。

在面试中，面试官可能会提出一些关于Struts2的问题，以评估应聘者的技术水平。

下面是一些常见的Struts2面试题及其详细答案，希望对你在面试中有所帮助。

1. 什么是Struts2？Struts2是一个轻量级的、基于MVC模式的Web应用程序框架。

它采用Java Servlet API和JavaServer Pages (JSP)技术，并提供了一种简单易用的方式来开发可维护和可扩展的Web应用程序。

2. Struts2的主要特性是什么？Struts2的主要特性包括：- MVC架构：将应用程序分为模型、视图和控制器，使开发更容易管理和扩展。

- 拦截器：通过拦截器可以在请求处理的各个阶段添加自定义的逻辑。

- 标签库：提供了丰富的标签库，简化了页面开发。

- 表单验证：提供了灵活且强大的表单验证机制，可以验证用户输入的数据。

- 国际化支持：支持多语言和本地化。

- 配置简单：通过配置文件来管理应用程序的行为。

3. Struts2的工作原理是什么？Struts2的工作原理如下：1) 客户端发送HTTP请求到服务器。

2) 服务器将请求交给Struts2的过滤器(Filter)。

3) 过滤器通过配置文件找到对应的Action，并调用相应的方法。

4) Action处理请求，并返回一个结果页面的名称或一个结果对象。

5) 结果页面的名称通过配置文件进行映射，服务器将其发送给客户端。

4. 什么是Struts2中的Action类？Action类是Struts2框架中的核心组件，用于处理Web请求。

一个Action类对应一个业务功能，其包含了要执行的方法和数据。

它负责接收请求、处理业务逻辑、将结果返回给前端页面。

5. Struts2中的拦截器是什么？有哪些内置的拦截器？拦截器是Struts2中的组件，用于在请求处理的各个阶段添加自定义的逻辑。

Struts2的拦截器配置

拦截器实例
public class SimpleInterceptor extends AbstractInterceptor { private String name; public void setName(String name) { = name; } public String intercept(ActionInvocation invocation) throws Exception { LoginAction action = (LoginAction)invocation.getAction(); ......... String result = invocation.invoke(); ...... return result; } }
Struts 专题篇
第九章 Struts 2 的拦截器主讲：陈宝峰
内容描述
● ● ● ● ● ●
拦截器概述拦截器配置使用拦截器的配置使用默认拦截器的配置拦截器实例方法过滤
拦截器概述
● ●
拦截器是 Struts 2 中的重要组成部分大量的内建拦截器完成了大部分的 Struts2 框架的工作
结束
使用默认拦截器的配置
<package name=” 包名” > <interceptors> <interceptor name=” 拦截器名 1” class=”......” /> ...... <interceptor-stack name=” 拦截器栈名 1”> <interceptor-ref name=” 拦截器名 1” /> ...... </interceptor-stack> </interceptors> <default-interceptor-ref name=” 拦截器名或拦截器栈名” /> <action ...... /> </package>

struts2国际化配置

前提条件：strut2的必须架包已经引入，struts2的配置文件全部配置完成1.首先创建一个struts.properties在src目录下，服务器启动时候会自动加载该文件，在这个文件中写入struts.custom.i18n.resources=globalMessages，服务器会自动选择前缀为globalMessages资源文件。

（或者你在你的struts.xml文件中添加<constant name="struts.custom.i18n.resources"value="globalMessages"></constant>服务器加载struts.xml的时候会加载国际化资源文件）；2.在src目录下创建资源文件英文globalMessages_en.properties 中文globalMessages_zh.properties。

globalMessages_en.properties 文件内容为home=homeglobalMessages_zh.properties文件内容为home=¥u9996¥u98753.在页面端获得资源文件信息。

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <%@ taglib prefix="s" uri="/struts-tags" %><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html><head><title>My JSP 'test.jsp' starting page</title></head><body><s:text name="home"></s:text></body></html>struts2的国际化分三种情况1.前台页面的国际化，2.Action类中的国际化，3.配置文件的国际化。

struts2

struts核心包
加载struts2
要使用struts2，必须在web.xml中进行配置
以过滤器的形式加载 struts2
过滤器所在包： org.apache.struts2. dispatcher.FilterDi spatcher
加载struts2
以过滤器的形式加载struts2
struts2以过滤器的形式加载到工程中，在web.xml中配置： <filter> <filter-name>struts2</filter-name> <filter-class> org.apache.struts2.dispatcher.FilterDispatcher </filter-class> </filter> <filter-mapping> <filter-name>struts2</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>
struts2中的命名空间起到模块化的作用。这个包下的所有Action（请求的处理类），都应该以： /[命名空间名]/[Action名]来访问命名空间的名字都应该以“/”开头，如果不配置命名空间，则默认的就是namespace=“/”。一个包下不能存在名字相同的Action
struts2常用配置-Action配置
name属性配置Action的名字
class属性配置Action类的完整类路径，说明用哪个类处理提交的请求。
struts2常用配置-Action配置
LoginAction.java public class LoginAction extends ActionSupport { private String userName; private String password; public void setUserName(String userName) { erName = userName; } public void setPassword(String password) { this.password = password; } public String execute() throws Exception { return SUCCESS; } } 每个请求处理类必须继承ActionSupport 对应页面表单元素名对应的表单元素名必须给出set方法处理请求的方法。方法名默认为execute struts2中，所提交的请求应以.action结尾

javaweb程序设计教程课后答案（可编辑）

java web程序设计教程课后答案第1章 Web应用开发简介习题答案1.Web在组成上包括______和______两部分。

答案:服务器客户端2.谈谈对面向对象的认识。

答案:面向对象将将要解决的问题分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙解决问题中的各个步骤中的行为。

面向对象编程方式是建立在面向过程编程方式基础上,其最重要的改变在于面向对象编程中,程序将围绕被操作的对象来设计,而不是操作本身。

面向对象编程方式以类作为构造程序的基本单位,具有封装、抽象、继承、多态性等特点。

3.介绍几种常用的框架技术。

答案:Java中常用的框架。

1.StrutsStruts是Apache 基金会Jakarta 项目组的一个开源项目,是一个基于Sun J2EE平台的MVC框架,它将Servlet和JSP标签作为实现自身功能的一部分。

2.WebWorkWebWork是由OpenSymphony组织开发的,是一个基于Web的MVC 框架。

它在运行时通过Interceptor(拦截器)自动应用,因此脱离了Action类。

3.Struts 2Struts 2是Apache基金会的一个开源项目,它建立在Struts框架与WebWork框架基础之上,继承了二者的优点,是目前非常流行的一个Web框架。

4.SpringSpring是一个以IoC和AOP为核心的轻量级容器框架。

它提供了一系列的Java EE开发解决方案,包括表示层的Spring MVC、持久层的Spring JDBC以及业务层事务管理等众多的企业级应用技术。

5.HibernateHibernate是一个ORM(对象关系映射)框架,它对JDBC进行了轻量级的封装。

通过使用Hibernate框架,开发人员能够以面向对象的思维方式来操作数据库。

6.Ibatis相对于Hibernate而言,Ibatis是一个“半自动化”的ORM实现框架,它主要致力于POJO与SQL之间的映射关系,是对“全自动化”ORM框架的一种有益补充。

struts2源代码分析(个人觉得非常经典)

本章讲述Struts2的工作原理。

读者如果曾经学习过Struts1.x或者有过Struts1.x的开发经验，那么千万不要想当然地以为这一章可以跳过。

实际上Struts1.x与Struts2并无我们想象的血缘关系。

虽然Struts2的开发小组极力保留S truts1.x的习惯，但因为Struts2的核心设计完全改变，从思想到设计到工作流程，都有了很大的不同。

Struts2是Struts社区和WebWork社区的共同成果，我们甚至可以说，Struts2是WebWork的升级版，他采用的正是WebWork的核心，所以，Struts2并不是一个不成熟的产品，相反，构建在We bWork基础之上的Struts2是一个运行稳定、性能优异、设计成熟的WEB框架。

本章主要对Struts的源代码进行分析，因为Struts2与WebWork的关系如此密不可分，因此，读者需要下载xwork的源代码，访问/xwork/download.action即可自行下载。

下载的Struts2源代码文件是一个名叫struts-2.1.0-src.zip的压缩包，里面的目录和文件非常多，读者可以定位到struts-2.1.0-src"struts-2.0.10"src"core"src"main"java目录下查看Struts2的源文件，如图14所示。

（图14）主要的包和类Struts2框架的正常运行，除了占核心地位的xwork的支持以外，Struts2本身也提供了许多类，这些类被分门别类组织到不同的包中。

从源代码中发现，基本上每一个Struts2类都访问了WebWork提供的功能，从而也可以看出Struts2与WebWork千丝万缕的联系。

但无论如何，Struts2的核心功能比如将请求委托给哪个Action处理都是由xwork完成的，Struts2只是在WebWork的基础上做了适当的简化、加强和封装，并少量保留Struts1.x中的习惯。

struts2 multipartrequest用法

struts2 multipartrequest用法Struts2 MultipartRequest 使用方法：Struts2 是一个用于构建 Java Web 应用的开源框架，它提供了许多功能和工具来简化开发过程。

其中之一就是 MultipartRequest，它是用于处理涉及文件上传的请求的。

要使用 Struts2 的 MultipartRequest，首先需要在 Struts2 的配置文件中进行相应的配置。

1. 配置 web.xml 文件：在 web.xml 文件中，将 Struts2 的过滤器配置为请求的第一个过滤器。

```xml<filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class> </filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping>```2. 配置 struts.xml 文件：在 struts.xml 文件中，添加对文件上传的支持。

示例如下：```xml<interceptors><interceptor name="fileUpload"class="org.apache.struts2.interceptor.FileUploadInterceptor" /></interceptors><action name="uploadAction" class="com.example.UploadAction"><interceptor-ref name="fileUpload" /><interceptor-ref name="defaultStack" /><result>/success.jsp</result></action>```在上述示例中，我们定义了一个名为 "uploadAction" 的 action，使用了fileUpload 拦截器和 defaultStack 拦截器栈。

struts2面试题(自己总结)

Struts2面试题1、struts2工作流程Struts 2框架本身大致可以分为3个部分：核心控制器FilterDispatcher、业务控制器Action和用户实现的企业业务逻辑组件。

核心控制器FilterDispatcher是Struts 2框架的基础，包含了框架内部的控制流程和处理机制。

业务控制器Action和业务逻辑组件是需要用户来自己实现的。

用户在开发Action和业务逻辑组件的同时，还需要编写相关的配置文件，供核心控制器FilterDispatcher来使用。

Struts 2的工作流程相对于Struts 1要简单，与WebWork框架基本相同，所以说Struts 2是WebWork的升级版本。

基本简要流程如下：1 、客户端初始化一个指向Servlet容器的请求；2、这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）3 、接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请是否需要调用某个Action4、如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy5、ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类6、ActionProxy创建一个ActionInvocation的实例。

7、ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。

8、一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。

struts2

一、Struts2入门1.概念什么是Struts2Struts2 是一个用来开发 MVC 应用程序的框架.它提供了 Web 应用程序开发过程中的一些常见问题的解决方案:对页面导航活动进行管理对来自用户的输入数据进行合法性验证统一的布局可扩展性国际化和本地化支持 Ajax表单的重复提交Struts2 VS Struts1Struts2与Struts1 相比，在体系结构方面更优秀，具体表现在类更少，更高效，扩展更容易等。

struts2 不是从 Struts1 扩展而来的, 说它是一个换了品牌标签的 WebWork 更合适。

2.程序Struts2 核心就是一个 Filter,该Filter会对所有的请求进行拦截(/*) StrutsPrepareAndExecuteFilterStrutsPrepareFilter + StrutsExecuteFilterStruts2 将所有的请求拦截下来，具体去访问哪个java类的方法需要读取配置文件 struts.xmlstruts.xml 文件需位于工程的类路径下实现一个 Struts 的 HelloWorld 程序1) 将 %struts2-blank例子%\WEB-INF\lib 目录下所有jar包拷贝至 webproject\WEB-INF\lib 中拷贝至webproject/WEB-INF/web.xml 中3) %struts2-blank例子%\将WEB-INF\classes 下的struts.xml 文件拷贝至工程src下清空 <struts></ struts> 标签之间的内容4) 新建 Action 实例， HelloWorldAction.javaAction可以不必是实现任何接口，它是一个普通java类(pojo),从这点可以看出 Struts2 是非侵入式设计，Action可以不依赖struts和Servlet 而独立存在Action中至少需要定义一个方法，且方法的返回值类型必须为Stringpublic String sayHello() {return "success";}6) 在 WEB-INF 下新建jsp页面hello.jsphello动手练习：用 struts2 实现最简单的mvc二、Struts2 细节1.package 元素配置action的组织包name：配置包名，用于被继承namespace: 配置访问路径以 /a/b/c/action 为例搜索action的顺序为 /a/b/c -- /a/b -- /a -- /extends: 指定继承的包2. action 元素1) name属性配置action的访问名称后缀默认为 action和””可以通过常量进行配置<constant name="struts.action.extension" value="do"></constant>2) class属性配置action对应的java类，必须为完整类名如果继承struts-default 包，默认class 为ActionSupport，该类的 execute方法默认返回 success我们在写 Action 类时通常会选择继承ActionSupport，也就自动继承了 execute 方法，同时可以使用父类定义的常量 SUCCESS、ERROR 等3) method属性配置action的访问方法名，默认访问execute方法4) 通配符映射一个 Web 应用可能有成百上千个 action 声明. 可以利用 struts 提供的通配符映射机制把多个彼此相似的映射关系简化为一个映射关系通配符的映射规则●若找到多个匹配, 没有通配符的那个将胜出●若指定的Action不存在, Struts 将会尝试把这个URI与任何一个包含着通配符 * 的Action名及进行匹配●若 Struts 找到的带有通配符的匹配不止一个, 最后一个匹配将胜出●被通配符匹配到的 URI 字符串的子串可以用 {1}, {2} 来引用. {1} 匹配第一个子串, {2} 匹配第二个子串…{0} 匹配整个 URI●* 可以匹配零个或多个字符, 但不包括 / 字符. 如果想把 / 字符包括在内, 需要使用 **. 如果需要对某个字符进行转义, 需要使用 \.例：<action name="*_add" class="cn.itcast.action.Girl" method="add"></action>匹配路径 Boy_add.action Girl_add.action<action name="Boy_*_*" class="cn.itcast.action.Boy" method="{1}"><result name="success"><param name="location">/WEB-INF/jsp/{2}.jsp</param></result></action>Boy_add_delete 会调用 Boy的add方法，转发给 delete.jsp5) 动态方法调用通过 url 动态调用 Action 中的方法<action name="Boy" class="cn.itcast.action.Boy">/strutsdemo/Boy!add.action 会调用Boy类的add方法默认情况下, Struts 的动态方法调用处于激活状态, 若想禁用该功能, 则可以在 struts.xml 文件中配置常量3. Action 类概念：action: 应用程序可以完成的每一个操作(用户的一个动作) 例如：显示一个登陆表单，保存商品信息Action类：Struts2中的Action是pojo(Plain Old Java Objects一个普通的java类)的,可以定义属性和方法，但需要遵循一些规则：●属性的名字必须遵守与 JavaBeans 属性名相同的命名规则. 属性的类型可以是任意类型. 从字符串到非字符串(基本数据库类型)之间的数据转换可以自动发生●必须有一个不带参的构造器●至少有一个供 struts 在执行这个 action 时调用的方法,方法的返回值为String类型(即视图名称)●同一个 Action 类可以包含多个 action.●Struts2 会为每一个 HTTP 请求创建一个新的 Action 实例4. result 元素配置 action 的执行结果name: 配置result结果名称，根据action执行方法的返回值决定找那个 result默认为 successtype: result 结果类型，默认为 dispatcher 类型常用的result类型●dispatcherdispatcher 结果类型是最常用的结果类型, 也是 struts 框架默认的结果类型用于将控制权转发给web应用中的其他资源默认参数：location 用于指定转发的资源路径，通常为一个jsp页面●redirect用于将响应重定向到另一个资源参数：location : 指定重定向的资源路径parse : 指定是否将location的值视为一个 OGNL 表达式来解析默认值为true●redirectAction用于将响应重定向给另一个Action参数:actionName : 指定目标action, 该属性为默认属性namespace : 指定目标 action 所在的 package●chain用于构成一个 Action 链，前一个action将控制权转发给下一个action,并且前一个action的状态在后一个action中继续保持参数:actionName : 指定目标action, 该属性为默认属性namespace : 指定目标 action 所在的 packagemethod ：指定调用action的方法，默认调用 execute 方法●httpheader用于将把一个 HTTP 状态发送到浏览器默认参数 status ：指定状态码●plaintext将转发的资源作为文本输出 , 不常用。

struts核心过滤器FilterDispatcher介绍

struts核心过滤器FilterDispatcher介绍FilterDispatcher功能介绍FilterDispatcher是struts2的核心控制类负责处理最初的请求分发.四大责任1.执行action2.清空ActionContext上下文3.服务静态的内容(初始化环境等)4.中断请求生命周期中的XWORKS拦截器.FilterDispatcher必须映射所有的请求,除非你只想在某一部分支持struts2的功能.配置filter的url-pattern的时候请使用"/*";1.执行action过滤器根据请求的url判断是否需要调用action(判断的依据是根据actionMapper)如果需要执行action那么处于过滤器链中的其他过滤器将终止,并且调用action.这意味着其他一些一定要执行的过滤器必须放在FilterDispatcher前面.以保证他们的执行.2.清空ActionContext上下文FilterDispatcher讲自动的清除上下文,确保没有内存泄露.但是有时候将导致在集成其他产品时出现某些问题.详情,请看ActionContextUp类3.服务静态的内容FilterDispatcher同时会加载常用的静态内容,例如javascript文件,css文件. FilterDispatcher会查找/struts/*这个目录,并且映射"/struts/"后面的的所有常用的包.以下是默认搜索的包org.apache.struts2.statictemplate例如用户可以通过请求/struts/xhtml/styles.css得到struts2的内置的XHTML UI 主题包下面的默认样式表用户还可以通过为filterDispatcher添加packages参数来添加用户自己的包. FilterDispatcher支持以下初始化参数参数名config 参数值以逗号隔开的配置文件名的列表参数名actionPackages 参数值以逗号隔开的java包名,主要用来扫描检测action参数名configProviders 参数值以逗号隔开的配置提供程序的类名.其他的参数名将被当作是框架的常量.public class FilterDispatcher implementsorg.apache.struts2.StrutsStatics,javax.servlet.Filterorg.apache.struts2.StrutsStatics定义了以下常量这些常量用来获取或者设置请求上下文的对象例如通过ActionContext对象和HTTP_REQUEST我们可以获取或者设置HttpServletRequest对象ActionContext.getContext().put(HTTP_REQUEST,request);HttpServletRequest request=(HttpServletRequest)ActionContext.getContext().get(HTTP_REQUEST);public interface StrutsStatics{public static final String HTTP_REQUEST ="com.opensymphony.xwork2.dispatcher.HttpServletRequest";public static final String HTTP_RESPONSE ="com.opensymphony.xwork2.dispatcher.HttpServletResponse";public static final String SERVLET_DISPATCHER ="com.opensymphony.xwork2.dispatcher.ServletDispatcher";public static final String SERVLET_CONTEXT ="com.opensymphony.xwork2.dispatcher.ServletContext";public static final String PAGE_CONTEXT ="com.opensymphony.xwork2.dispatcher.PageContext";public static final String STRUTS_PORTLET_CONTEXT = "struts.portlet.context"; }import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import .URLDecoder;import java.util.ArrayList;import java.util.Calendar;import java.util.Enumeration;import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.StringT okenizer;import javax.servlet.Filter;import javax.servlet.FilterChain;import javax.servlet.FilterConfig;import javax.servlet.ServletContext;import javax.servlet.ServletException;import javax.servlet.ServletRequest;import javax.servlet.ServletResponse;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import mons.logging.Log;import mons.logging.LogFactory;import org.apache.struts2.RequestUtils;import org.apache.struts2.StrutsConstants;import org.apache.struts2.StrutsStatics;import org.apache.struts2.dispatcher.mapper.ActionMapper;import org.apache.struts2.dispatcher.mapper.ActionMapping;import com.opensymphony.xwork2.inject.Inject;import com.opensymphony.xwork2.util.ClassLoaderUtil;import com.opensymphony.xwork2.util.profiling.UtilTimerStack;import com.opensymphony.xwork2.ActionContext;public class FilterDispatcher implementsorg.apache.struts2.StrutsStatics,javax.servlet.Filter{//日志类private static final Log LOG = LogFactory.getLog(FilterDispatcher.class);//路径前缀private String[] pathPrefixes;//为缓存静态内容时设置响应头信息提供日期格式化.private final Calendar lastModifiedCal = Calendar.getInstance();//存储StrutConstants.STRUTS_SERVE_STATIC_CONTENT 的设置,该设置可以通过配置文件设置private static boolean serveStatic;//存储StrutConstants.STRUTS_SERVE_STATIC_BROWSER_CACHE的设置,该设置可以通过配置文件设置.private static boolean serveStaticBrowserCache;//存储字符编码的字符串,该设置可以通过配置文件设置private static String encoding;//通过注入方式提供,ActionMapper的实例private static ActionMapper actionMapper;//FilterConfig过滤器配置类的实例,在init方法中初始化private FilterConfig filterConfig;//为子类暴露Dispatcher对象protected Dispatcher dispatcher;/**初始化过滤器的方法,该方法中创建了一个默认的dispatcher,并且在此方法中设置了静态资源的默认包*/public void init(FilterConfig filterConfig)throws ServletException{this.filterConfig = filterConfig;dispatcher = createDispatcher(filterConfig);dispatcher.init();String param = fitlerConfig.getInitParamter("pagckages");String packages = "org.apache.struts2.static templateorg.apache.struts2.interceptor.debugging";if(param != null){packages = param + " "+packages;}this.pathPrefixes = parse(packages);}/**当应用被终止时调用destroy方法,该方法用来用来释放本地线程和任何的DispatcherListeners**/public void destroy(){if(dispatcher==null){LOG.warn("something is seriously wrong,Dispatcher is not initialized(null)");}else{dispatcher.cleanup();}}/**创建默认的Dispatcher对象.可以通过重写此方法提供用户自定义的Dispatcher */protected Dispatcher createDispatcher(FilterConfig filterConfig){Map<String,String> params = new HashMap<String,String>();for(Enumeration e = fitlerConfig.getIntParameterNames();e.hasMoreElements();) {String e.nextElement();String value = filterConfig.getInitParameter(name);params.put(name,value);}return new Dispatcher(filterConfig.getServletContext(),params);}@Inject(StrutsConstants.STRUTS_SERVE_STATIC_CONTENT)public static void setServeStaticContent(String val){serveStatic = "true".equals(val);}@Inject(StrutsConstants.STRUTS_SERVE_STATIC_BROWSER_CACHE) public static void setServeStaticBrowserCache(String val) {serveStaticBrowserCache = "true".equals(val);}@Inject(StrutsConstants.STRUTS_I18N_ENCODING)public static void setEncoding(String val) {encoding = val;}@Injectpublic static void setActionMapper(ActionMapper mapper) {actionMapper = mapper;}/**某些版本的webLogic只能通过fitler config 返回servlet context对象,该方法解决了这个问题.**/protected ServletContext getServletContext() {return filterConfig.getServletContext();}protected FilterConfig getFilterConfig() {return filterConfig;}/**包装request对象,如果需要的话也可以根据给定的RQUEST用来处理多媒体类型*/protected HttpServletRequest prepareDispatcherAndWrapRequest(HttpServletRequest request,HttpServletResponse response)throws ServletException{Dispatcher du = Dispatcher.getInstance();//如果cleanUp filter 还没有准备好,程序将准备并且包装请求对象.//cleanup 过滤器必须配置在dispatcher filter对象的前面,因此当cleanup filter对象运行的时候,静态的dispatcher对象必须是nullif(du == null){Dispatcher.setInstance(dispatcher);dispatcher.prepare(request,response);}else{dispatcher = du;}try{request = dispatcher.wrapRequest(request,getServletContext());}catch(IOException e){String message = "Could not wrap servlet request with MultipartRequestWrapper!";LOG.error(message,e);throw new ServletException(message,e);}return request;}protected String[] parse(String packages){if(packages == null){return null;}List<String> pathPrefixes = new ArrayList<String>();StringT okenizer st = new StringT okenizer(packeages,", \n\t");while(st.hasMoreT okens()){String pathPrefix = st.nextToken.replace('.','/');if(!pathPrefix.endsWith("/")){pathPrefix+="/";}pathPrefixes.add(pathPrefix);}return pathPrefixes.toArray(new String[pathPrefixes.size()]);}public void doFilter(ServletRequest req,ServletResponse res,FilterChain chain)throws IOException,ServletException{HttpServletRequest request = (HttpServletRequest)req;HttpServletResponse response = (HttpServletResponse)res;ServletContext servletContext = getServletContext();String timerKey = "FilterDispatcher_doFilter:";try{UtilTimerStack.push(timerKey);request = prepareDispatcherAndWrapRequest(request,response);ActionMapping mapping;try{mapping = actionMapper.getMapping(request,dispatcher.getConfigurationManager());}catch(Exception ex){LOG.error("error getting ActionMapping",ex);dispatcher.sendError(request,response,servletContext,HttpServletResponse.SC_INTER NAL_SERVER_ERROR,ex);return;}if(mapping==null){//没有action被请求,是否查找静态资源String resourcePath = RequestUtils.getServletPath(request);if("".equals(resourcePath) && null != request.getPathInfo()){resourcePath = request.getPathInfo();}if(serveStatic && resourcePath.startsWith("/struts")){String /struts".length());findStaticResource(name,request,response);}else{chain.doFilter(request,response);}return;}dispatcher.serviceAction(request,response,servletContext,mapping);}finally{try{ActionContextCleanUp.cleanUp(req);}finally{UtilTimerStack.pop(timerKey);}}}protected void findStaticResource(String name,HttpServletRequest request,HttpServletResponse response)throws IOException{if(!name.endWith(".class")){for(String pathPrefix : pathPrefixes){InputStream is = findInputStream(name,pathPrefix);if(is !=null){Calendar cal = Calendar.getInstance();long ifModifiedSince = 0 ;try{ifModifiedSince = request.getDateHeader("If-Modified-Since");}catch(Exception e){LOG.warn("invalid If-Modified-Since header value:'"+request.getHeader("If-Modified-Since")+"', ignoring");}long lastModifiedMillis = lastModifiedCal.getTimeInMillis();long now = cal.getTimeMillis();cal.add(Calendar.DAY_OF_MONTH,1);long expires = cal.getTimeInMillis();if(ifModifiedSince >0 && ifModiifedSince <= lastModifiedMillis){response.setDateHeader("Expires",expires);response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);is.close();return;}//设置content-typeString contentType = getContentType(name);if(contentType != null){response.setContentType(contentType);}if(serveStaticBrowserCache){response.setDateHeader("Date",now);response.setDateHeader("Expires",expires);response.setDateHeader("Retry-After",expires);response.setHeader("Cache-Control","public");response.setDateHeader("Last-Modified",lastModifiedMillis);}else{response.setHeader("Cache-Control","no-cache");response.setHeader("Pragma","no-cache");response.setHeader("Expires","-1");}try{copy(is,response.getOutputStream());}finally{is.close();}return;}}}response.sendError(HttpServletResponse.SC_NOT_FOUND); }protected String getContentType(String name){if (name.endsWith(".js")){return "text/javascript";}else if (name.endsWith(".css")){return "text/css";}else if (name.endsWith(".html")){return "text/html";}else if (name.endsWith(".txt")){return "text/plain";}else if (name.endsWith(".gif")){return "image/gif";}else if (name.endsWith(".jpg") || name.endsWith(".jpeg")){return "image/jpeg";} else if (name.endsWith(".png")){return "image/png";} else{return null;}}protected void copy(InputStream input, OutputStream output) throws IOException {final byte[] buffer = new byte[4096];int n;while (-1 != (n = input.read(buffer))) {output.write(buffer, 0, n);}output.flush(); // WW-1526}protected InputStream findInputStream(String name, String packagePrefix) throws IOException{String resourcePath;if (packagePrefix.endsWith("/") && name.startsWith("/")){resourcePath = packagePrefix + name.substring(1);} else{resourcePath = packagePrefix + name;}resourcePath = URLDecoder.decode(resourcePath, encoding);return ClassLoaderUtil.getResourceAsStream(resourcePath, getClass());}}。

Struts2默认拦截器解析

Struts2默认拦截器解析使用struts2，拦截器大家经常使用，当然默认情况我们除了自定义的拦截器外，会使用struts2默认的拦截器，那他究竟有哪些默认的拦截器？每个拦截器都是做什么的呢？我们来看下对应的源码，打开对应源码下的struts2-default.xml文件我们可以看到对应很多的拦截器信息，如下<interceptors><interceptor name="alias"class="com.opensymphony.xwork2.interceptor.AliasInterceptor"/><interceptor name="autowiring"class="com.opensymphony.xwork2.spring.interceptor.ActionAutowiringInt erceptor"/><interceptor name="chain"class="com.opensymphony.xwork2.interceptor.ChainingInterceptor"/> <interceptor name="conversionError"class="org.apache.struts2.interceptor.StrutsConversionErrorIntercepto r"/><interceptor name="cookie"class="org.apache.struts2.interceptor.CookieInterceptor"/><interceptor name="createSession"class="org.apache.struts2.interceptor.CreateSessionInterceptor"/> <interceptor name="debugging"class="org.apache.struts2.interceptor.debugging.DebuggingInterceptor" /><interceptor name="externalRef"class="com.opensymphony.xwork2.interceptor.ExternalReferencesInterceptor"/><interceptor name="execAndWait"class="org.apache.struts2.interceptor.ExecuteAndWaitInterceptor"/> <interceptor name="exception"class="com.opensymphony.xwork2.interceptor.ExceptionMappingIntercepto r"/><interceptor name="fileUpload"class="org.apache.struts2.interceptor.FileUploadInterceptor"/> <interceptor name="i18n"class="com.opensymphony.xwork2.interceptor.I18nInterceptor"/><interceptor name="logger"class="com.opensymphony.xwork2.interceptor.LoggingInterceptor"/> <interceptor name="modelDriven"class="com.opensymphony.xwork2.interceptor.ModelDrivenInterceptor"/> <interceptor name="scopedModelDriven"class="com.opensymphony.xwork2.interceptor.ScopedModelDrivenIntercept or"/><interceptor name="params"class="com.opensymphony.xwork2.interceptor.ParametersInterceptor"/> <interceptor name="prepare"class="com.opensymphony.xwork2.interceptor.PrepareInterceptor"/> <interceptor name="staticParams"class="com.opensymphony.xwork2.interceptor.StaticParametersIntercepto r"/><interceptor name="scope"class="org.apache.struts2.interceptor.ScopeInterceptor"/><interceptor name="servletConfig"class="org.apache.struts2.interceptor.ServletConfigInterceptor"/> <interceptor name="sessionAutowiring"class="org.apache.struts2.spring.interceptor.SessionContextAutowiring Interceptor"/><interceptor name="timer"class="com.opensymphony.xwork2.interceptor.TimerInterceptor"/> <interceptor name="token"class="org.apache.struts2.interceptor.TokenInterceptor"/><interceptor name="tokenSession"class="org.apache.struts2.interceptor.TokenSessionStoreInterceptor"/> <interceptor name="validation"class="org.apache.struts2.interceptor.validation.AnnotationValidation Interceptor"/><interceptor name="workflow"class="com.opensymphony.xwork2.interceptor.DefaultWorkflowInterceptor "/><interceptor name="store"class="org.apache.struts2.interceptor.MessageStoreInterceptor"/> <interceptor name="checkbox"class="org.apache.struts2.interceptor.CheckboxInterceptor"/><interceptor name="profiling"class="org.apache.struts2.interceptor.ProfilingActivationInterceptor" /><interceptor name="roles" class="org.apache.struts2.interceptor.RolesInterceptor"/> <interceptor name="external-ref"class="com.opensymphony.xwork2.interceptor.ExternalReferencesIntercep tor"/><interceptor name="model-driven"class="com.opensymphony.xwork2.interceptor.ModelDrivenInterceptor"/> <interceptor name="static-params"class="com.opensymphony.xwork2.interceptor.StaticParametersIntercepto r"/><interceptor name="scoped-model-driven"class="com.opensymphony.xwork2.interceptor.ScopedModelDrivenIntercept or"/><interceptor name="servlet-config"class="org.apache.struts2.interceptor.ServletConfigInterceptor"/> <interceptor name="token-session" class="org.apache.struts2.interceptor.TokenSessionStoreInterceptor"/><interceptor-stack name="basicStack"><interceptor-ref name="exception"/><interceptor-ref name="servletConfig"/><interceptor-ref name="prepare"/><interceptor-ref name="checkbox"/><interceptor-ref name="params"/><interceptor-ref name="conversionError"/></interceptor-stack><interceptor-stack name="validationWorkflowStack"><interceptor-ref name="basicStack"/><interceptor-ref name="validation"/><interceptor-ref name="workflow"/></interceptor-stack><interceptor-stack name="fileUploadStack"><interceptor-ref name="fileUpload"/><interceptor-ref name="basicStack"/></interceptor-stack><interceptor-stack name="modelDrivenStack"><interceptor-ref name="modelDriven"/><interceptor-ref name="basicStack"/></interceptor-stack><interceptor-stack name="chainStack"><interceptor-ref name="chain"/><interceptor-ref name="basicStack"/></interceptor-stack><interceptor-stack name="i18nStack"><interceptor-ref name="i18n"/><interceptor-ref name="basicStack"/></interceptor-stack><interceptor-stack name="paramsPrepareParamsStack"><interceptor-ref name="exception"/><interceptor-ref name="alias"/><interceptor-ref name="params"/><interceptor-ref name="servletConfig"/><interceptor-ref name="prepare"/><interceptor-ref name="i18n"/><interceptor-ref name="chain"/><interceptor-ref name="modelDriven"/><interceptor-ref name="fileUpload"/><interceptor-ref name="checkbox"/><interceptor-ref name="staticParams"/><interceptor-ref name="params"/><interceptor-ref name="conversionError"/><interceptor-ref name="validation"><paramname="excludeMethods">input,back,cancel</param></interceptor-ref><interceptor-ref name="workflow"><paramname="excludeMethods">input,back,cancel</param></interceptor-ref></interceptor-stack><interceptor-stack name="defaultStack"><interceptor-ref name="exception"/><interceptor-ref name="alias"/><interceptor-ref name="servletConfig"/><interceptor-ref name="prepare"/><interceptor-ref name="i18n"/><interceptor-ref name="chain"/><interceptor-ref name="debugging"/><interceptor-ref name="profiling"/><interceptor-ref name="scopedModelDriven"/><interceptor-ref name="modelDriven"/><interceptor-ref name="fileUpload"/><interceptor-ref name="checkbox"/><interceptor-ref name="staticParams"/><interceptor-ref name="params"><param name="excludeParams">dojo\..*</param></interceptor-ref><interceptor-ref name="conversionError"/><interceptor-ref name="validation"><paramname="excludeMethods">input,back,cancel,browse</param></interceptor-ref><interceptor-ref name="workflow"><paramname="excludeMethods">input,back,cancel,browse</param></interceptor-ref></interceptor-stack><interceptor-stack name="completeStack"><interceptor-ref name="defaultStack"/></interceptor-stack><interceptor-stack name="executeAndWaitStack"><interceptor-ref name="execAndWait"><paramname="excludeMethods">input,back,cancel</param></interceptor-ref><interceptor-ref name="defaultStack"/><interceptor-ref name="execAndWait"><paramname="excludeMethods">input,back,cancel</param></interceptor-ref></interceptor-stack><default-interceptor-ref name="defaultStack"/>是配置对应的拦截器栈，下面我们来看对应的拦截器栈都有哪些？都是做什么的？如果不配置拦截器，默认使用他自己的defaultStack，我们看到，defaultStack包含了基本上所有的拦截器，所以基本上都能满足我们的需求，但是我们一般情况下用不了这么多拦截器栈的，经过这么多拦截器栈肯定会影响性能的，所以我们可以根据不通的场景，选择合适的拦截器栈。

struts2 工作原理

struts2 工作原理
Struts2是一个用于构建Java web应用程序的开源框架。

它的
工作原理可以简单概括为以下几个步骤：
1. 客户端发送请求：当用户在浏览器中访问一个Struts2应用
程序的URL时，客户端会发送一个HTTP请求到服务器。

2. DispatcherServlet接收请求：服务器上运行的Servlet容器
（如Tomcat）接收到HTTP请求后，会通过web.xml配置文
件将请求发送给Struts2的核心组件DispatcherServlet。

3. 动作(Action)处理：DispatcherServlet根据配置文件中的信息，确定请求对应的Action类，并创建该类的实例。

Action是一
个POJO（Plain Old Java Object）类，用于处理具体的业务逻辑。

4. 结果视图(View)解析：Action类中的方法执行完业务逻辑后，会返回一个结果视图。

Struts2的结果视图可以是JSP页面、HTML、JSON等格式。

DispatcherServlet根据配置文件中指定
的结果视图解析器，将结果视图转化为最终的响应内容。

5. 结果响应：DispatcherServlet将最终的响应内容发送给客户端，客户端浏览器会将响应内容渲染并呈现给用户。

在这个过程中，Struts2框架提供了一系列的核心组件来协助
处理请求和响应，包括拦截器（Interceptor）、值栈（ValueStack）、类型转换器（Type Converter）等。

这些组件
能够帮助开发者处理表单提交、数据验证、数据转换等常见的web开发任务，从而简化开发过程。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

import com.opensymphony.xwork2.ActionSupport;
public class LanguageFilterAction extends ActionSupport{
/**
*
*/
private static final long serialVersionUID = 1L;
}
}
5、编写测试页面
setLang.action?request_locale=语言_国家(大写字母)
参数名必须是request_locale，i18n过滤器会自动获取参数更改session从而实现用户自己选择语言的功能
<body>
<a href="${pageContext.request.contextPath}/setlang.action?request_locale=zh_CN" >点我中文</a>
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
}
String result = (String)request.getAttribute("jsp");
url = result;
if(request.getQueryString() != null){
url = url + "?" + request.getQueryString();
<dispatcher>FORWARD</dispatcher>
</filter-mapping>

<filter>
<filter-name>international</filter-name>
<filter-class>

<interceptors>
<interceptor name="i18n" class="com.opensymphony.xwork2.interceptor.I18nInterceptor"/>
2、在struts.xml中配置i18n的资源文件，i18n的国际化拦截器和负责处理jsp国际化的动态结果action（很拗口啊）

<constant name="struts.custom.i18n.resources" value="messageResource"></constant>
}
return "url";
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
public String execute() throws Exception{
return "MyJsp";
}
}
7、MyJsp.jsp中使用struts标签库的s:text标签
<body>
<s:text name="mainPage"></s:text><br>
.getRequestDispatcher("totalfilter.action");
request.setAttribute("jsp", httpRequest.getServletPath());
request.setAttribute("param", httpRequest.getQueryString());
com.suoyasoft.filter.InternationalFilter 
</filter-class>
</filter>
<filter-mapping>
<filter-name>international</filter-name>
import java.util.Locale;
import javax.servlet.http.HttpServletRequest;
import org.apache.struts2.ServletActionContext;
import com.opensymphony.xwork2.ActionContext;
ds.forward(request, response);
}
public void init(FilterConfig filterConfig) throws ServletException {
}
}
4、编写LanguageFilterAction.action实现动态跳转结果，实现jsp自动国际化
public class InternationalFilter implements Filter {
public void destroy() {
}
public void doFilter(ServletRequest request, ServletResponse response,
private String url;
public String execute() throws Exception{
HttpServletRequest request = ServletActionContext.getRequest();