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><!-- 配置Struts2过滤器--><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是⼀个基于MVC设计模式的Web应⽤框架，它本质上相当于⼀个servlet，在MVC设计模式中，Struts2作为控制器(Controller)来建⽴模型与视图的数据交互。
⼀．Struts2执⾏流程介绍1.通过浏览器发送⼀个请求2.会被StrutsPrepareAndExecuteFilter拦截（struts2的拦截器作⽤）3.会调⽤strust2框架默认的拦截器(interceptor)完成部分功能4.在执⾏Action中操作5.根据Action中⽅法的执⾏结果来选择来跳转页⾯Result视图⼀般我们将StrutsPrepareAndExecuteFilter 叫做前端控制器(核⼼控制器)，只有在web.xml⽂件中配置了这个filter我们的strtus2框架才能使⽤。
<!-- 声明StrutsPrepareAndExecuteFilter --><filter> <filter-name>struts2Filter</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class></filter><!-- 拦截访问路径 --><filter-mapping><filter-name>struts2Filter</filter-name><url-pattern>/*</url-pattern></filter-mapping>Strtus2的默认拦截器(interceptor)，它们是在struts-default.xml⽂件中配置。
struts2基本流程及原理
Struts2基本流程及原理1.Struts 2的基本流程Struts 2框架由3个部分组成：核心控制器FilterDispatcher、业务控制器和用户实现的业务逻辑组件。
在这3个部分里，Struts 2框架提供了核心控制器FilterDispatcher，而用户需要实现业务控制器和业务逻辑组件。
2.核心控制器：FilterDispatcherFilterDispatcher是Struts 2框架的核心控制器，该控制器作为一个Filter运行在Web应用中，它负责拦截所有的用户请求，当用户请求到达时，该Filter会过滤用户请求。
如果用户请求以action结尾，该请求将被转入Struts 2框架处理。
Struts 2框架获得了*.action请求后，将根据*.action请求的前面部分决定调用哪个业务逻辑组件，例如，对于login.action请求，Struts 2调用名为login的Action来处理该请求。
Struts 2应用中的Action都被定义在struts.xml文件中，在该文件中定义Action时，定义了该Action的name属性和class属性，其中name属性决定了该Action处理哪个用户请求，而class属性决定了该Action的实现类。
Struts 2用于处理用户请求的Action实例，并不是用户实现的业务控制器，而是Action代理——因为用户实现的业务控制器并没有与Servlet API耦合，显然无法处理用户请求。
而Struts 2框架提供了系列拦截器，该系列拦截器负责将HttpServletRequest请求中的请求参数解析出来，传入到Action中，并回调Action 的execute方法来处理用户请求。
显然，上面的处理过程是典型的AOP（面向切面编程）处理方式。
用户实现的Action类仅仅是Struts 2的Action代理的代理目标。
用户实现的业务控制器（Action）则包含了对用户请求的处理。
struts2工作流程
struts2工作流程Struts2工作流程摘要：Struts2是一个基于MVC（Model-View-Controller）设计模式的web应用程序开发框架。
本文将介绍Struts2的工作流程，包括请求的处理过程、核心组件的作用以及如何扩展和定制框架。
引言：在web应用程序开发过程中，使用一个成熟的框架可以大大提高开发效率和代码质量。
Struts2是一个功能强大、易于使用的开源框架，已经被广泛应用于Java EE开发领域。
了解Struts2的工作流程能够帮助开发者更好地理解框架的运作原理，从而更好地设计和开发web应用程序。
一、请求的处理过程当客户端发起一个请求时，Struts2框架会按照特定的流程来处理请求并生成相应的响应。
下面是Struts2请求处理过程的简要说明：1. 客户端发送请求。
2. 服务器接收请求并将其传递给Servlet容器。
3. Servlet容器（如Tomcat）将请求交给Struts2的过滤器（StrutsPrepareAndExecuteFilter）进行处理。
4. 过滤器通过解析请求的URL来确定该由哪一个Action类来处理请求。
5. 过滤器创建一个ActionInvocation对象，将该对象传递给Struts2的核心控制器（ActionProxy）。
6. 核心控制器根据Action类的配置信息和请求参数来调用对应的Action类的方法。
7. Action类的方法执行相应的业务逻辑，并返回一个结果（Result）对象。
8. 核心控制器将结果传递给结果视图（Result View），最终生成响应。
9. 响应返回给Servlet容器，然后传递给客户端。
二、核心组件的作用Struts2框架中有几个核心组件，这些组件共同协作来处理请求并返回响应。
下面我们来看一下它们的作用：1. 过滤器（StrutsPrepareAndExecuteFilter）：负责处理所有传入请求并将其交给适当的Action类进行处理。
struts2流程以及源码解析
1.1 Struts2请求处理1. 一个请求在Struts2框架中的处理步骤：a) 客户端初始化一个指向Servlet容器的请求；b) 根据Web.xml配置，请求首先经过ActionContextCleanUp过滤器，其为可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助（SiteMesh Plugin），主要清理当前线程的ActionContext和Dispatcher；c) 请求经过插件过滤器，如：SiteMesh、etc等过滤器；d) 请求经过核心过滤器FilterDispatcher，执行doFilter方法，在该方法中，询问ActionMapper来决定这个请求是否需要调用某个Action；e) 如果ActionMapper决定需要调用某个Action，则ActionMapper会返回一个ActionMapping实例（存储Action的配置信息），并创建ActionProxy （Action代理）对象，将请求交给代理对象继续处理；f) ActionProxy对象根据ActionMapping和Configuration Manager询问框架的配置文件，找到需要调用的Action类；g) ActionProxy对象创建时，会同时创建一个ActionInvocation的实例；h) ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用；i) 一旦Action执行完毕，ActionInvocation实例负责根据struts.xml中的配置创建并返回Result。
Result通常是一个需要被表示的JSP或者FreeMarker 的模版，也可能是另外的一个Action链；j) 如果要在返回Result之前做些什么，可以实现PreResultListener接口，PreResultListener可以在Interceptor中实现，也可以在Action中实现；k) 根据Result对象信息，生成用户响应信息response，在生成响应过程中可以使用Struts2 框架中继承的标签，在此过程中仍会再次涉及到ActionMapper；2. Struts2请求处理示意图：1.2 Struts2请求处理源码分析当用户向Struts2发送请求时，FilterDispatcher的doFilter()方法自动调用，doFilter()方法处理请求过程，如下：1. 创建值栈对象stack；2. 创建Action上下文对象；3. 对请求进行重新封装，此次封装根据请求内容的类型不同，返回不同的对象：如果为multipart/form-data类型，则返回MultiPartRequestWrapper类型的对象，该对象服务于文件上传，否则返回StrutsRequestWrapper类型的对象，MultiPartRequestWrapper是StrutsRequestWrapper的子类，而这两个类都是HttpServletRequest接口的实现。
Struts2的运行流程(Java私塾)
Struts2的运行流程（java私塾）Struts2的运行流程3.2.1 运行流程先回忆一下在HelloWorld中，我们做了什么：∙在web.xml中配置了Struts2的过滤器∙写了一个Action类，名称为HelloWorldAction∙在struts.xml中配置了这个Action类∙写了两个页面，一个是登录页面，一个是欢迎页面只做了这么点事情，就可以在Struts2的帮助下顺利完成功能调用，那么Struts2内部是怎么运行的呢？逐步来根据架构图进行分析。
1：首先是在登录页面，用户填入帐号和密码，然后点击提交按钮，好了，就从这里开始分析背后的处理流程，这是我们进行分析的起点。
2：当用户提交登录请求后，请求的URL为：“/helloworld/helloworldAction.action”，请求会被Tomcat服务器接收到，Tomcat服务器会根据请求URL中的web上下文，也就是“/helloworld”，来选择处理这个请求的Web应用，那就是由helloworld这个web工程来处理这个请求。
3：Web容器会去读取helloworld这个工程的web.xml，在web.xml中进行匹配，发现后缀为“.action”的请求，由struts2这个过滤器来进行处理，根据Filter的配置，找到实际的类为FilterDispatcher。
4：Web容器会获取FilterDispatcher这个类的实例，然后回调doFilter方法，进行真正的处理。
FilterDispatcher作为前端控制器，是整个Struts2的调度中心。
注意：在架构图上，可以看到有三个过滤器层次，分别是ActionContextCleanUp、SiteMesh等其他过滤器和FilterDispatcher。
这三个层次中，ActionContextCleanUp和FilterDispatcher是Struts2的过滤器，而SiteMeshSiteMesh等其他过滤器不是。
struts2流程
struts2流程Struts2是一种基于Java的Web应用程序框架，它是在Servlet、JSP、JavaBean等技术的基础上开发的，目的是为了简化Web应用程序的开发和维护过程。
Struts2框架采用MVC（模型-视图-控制器）的架构模式，通过将用户请求分发给相应的控制器，然后根据控制器的指令进行处理，再将结果返回给用户进行展示。
下面我们将详细介绍Struts2的工作流程。
Struts2的工作流程可以分为以下几个步骤：1. 客户端发送请求：当用户通过浏览器访问某个URL地址时，客户端会生成一个HTTP请求，该请求会发送给服务器。
2. DispatcherServlet拦截请求：服务器接收到请求后，DispatcherServlet作为Struts2的核心控制器将拦截该请求。
3. 根据请求寻找相应的Action：DispatcherServlet会根据请求的URL地址和配置文件中的映射规则，找到匹配的Action类。
4. 创建Action实例：一旦找到了匹配的Action类，Struts2会创建该Action类的一个实例。
5. 封装请求参数：Struts2框架会自动将请求中的参数封装到Action实例中的属性中，以便在后续的处理中使用。
6. 调用Action方法：一旦请求参数被封装好，Struts2框架会调用对应Action类中的相应方法来处理该请求。
在Action方法中，可以进行一些业务逻辑的处理，并返回相应的结果。
7. 响应结果处理：Action方法的执行结果会被封装到一个Result对象中，该对象包含了结果的类型和数据。
Struts2框架会从配置文件中查找对应的结果视图，并将结果数据传递给视图进行展示。
8. 渲染视图：Struts2会将结果视图进行渲染，然后将渲染后的内容发送给客户端的浏览器。
9. 响应结果发送给客户端：服务器会将渲染后的内容作为HTTP响应发送给客户端的浏览器，浏览器接收后进行展示。
struts2工作流程解析
struts2工作流程解析1. 初始的哀求通过一条标准的过滤器链，到达 servlet 容器 ( 比如toat 容器，WebSphere 容器 )。
2. 过滤器链包括可选的ActionConttCleanUp 过滤器，用于系统整合技术，如 SiteMesh 插件。
3. 接着调用 FilterDiser（或者SutsPrepareAndExeeFilter），FilterDispatcher 查找 ActionMapper，以确定这个哀求是否需要调用某个 Action。
4. 假如 ActionMapper 确定需要调用某个 Action，FilterDispatcher 将控制权交给 ActionProxy。
5. ActionProxy 依照框架的配置文件(struts.xml)，找到需要调用的 Action 类。
6.ActionProxy 创建一个 ActionInvoion 的实例。
ActionInvocation 先调用相关的拦截器（Action 调用之前的部分），最后调用 Action。
7.一旦 Action 调用返回结果，ActionInvocation 按照 struts.xml 配置文件，查找对应的转发路径。
返回结果通常是（但不总是，也可能是另外的一个 Action 链）JSP 技术或者 FreeMarker 的模版技术的网页展现。
Struts2 的标签和其他视图层组件，协助展现我们所需要的显示结果。
在此，我想说清晰一些，终于的显示结果一定是 HTML 标签。
标签库技术和其他视图层技术只是为了动态生成 HTML 标签。
8. 接着根据相反次序执行拦截器链 ( 执行 Action 调用之后的部分 )。
最后，响应通过滤器链返回（过滤器技术执行流程与拦截器一样，都是先执行前面部分，后执行后面部）。
假如过滤器链中存在ActionContextCleanUp，FilterDispatcher 不会清理线程局部的ActionContext。
简述struts2的执行流程
简述struts2的执行流程Struts2的执行流程是一个基于MVC架构的框架，它将用户的请求转发给Action处理，并将处理结果返回给用户。
The execution process of Struts2 is based on MVC architecture, it forwards user requests to Action for processing and returns the processing results to the user.用户发送请求到Struts2的前端控制器DispatcherServlet，DispatcherServlet根据用户请求找到对应的Action类。
Users send requests to the front controller DispatcherServlet of Struts2, and DispatcherServlet finds the corresponding Action class based on the user's request.DispatcherServlet创建ActionContext，并将用户请求的数据封装到ActionContext中。
DispatcherServlet creates ActionContext and encapsulates the user's request data into the ActionContext.ActionContext将数据传递给ActionInvocation，ActionInvocation执行拦截器栈的拦截器。
The ActionContext passes the data to ActionInvocation, and ActionInvocation executes the interceptors in the interceptor stack.拦截器栈中的拦截器按照预先定义的顺序依次执行，对请求进行处理并可能修改Action的执行流程。
struts2的工作原理
struts2的工作原理Struts2是一个基于Java的开源Web应用程序框架，用于快速构建企业级Web应用程序。
它采用了模型-视图-控制器（MVC）架构模式，通过统一的控制器来处理用户的请求，并将结果返回给视图进行展示。
本文将介绍Struts2的工作原理，包括请求的处理流程、组件的作用以及如何配置和使用Struts2。
一、Struts2的请求处理流程1. 客户端发送HTTP请求到服务器。
2. 服务器接收到请求后，将请求交给Struts2的过滤器（StrutsPrepareAndExecuteFilter）进行处理。
3. 过滤器根据请求的URL找到对应的Action，并将请求参数封装到Action的属性中。
4. 过滤器调用Action的execute()方法进行业务逻辑处理。
5. Action执行完毕后，返回一个结果视图。
6. 过滤器根据结果视图的配置，将结果返回给客户端。
二、Struts2的组件作用1. Action：Action是Struts2框架的核心组件，用于处理用户的请求。
每个Action类对应一个业务功能，其中的方法对应不同的请求处理逻辑。
2. Interceptor：Interceptor是Struts2框架的拦截器，用于在Action执行前后进行一些额外的处理。
例如，可以在Interceptor中进行身份验证、日志记录等操作。
3. Result：Result是Struts2框架的结果视图，用于将Action的处理结果展示给用户。
可以配置不同的Result类型，如跳转到指定页面、返回JSON数据等。
4. ValueStack：ValueStack是Struts2框架的数据栈，用于存储Action中的属性。
在页面中可以通过表达式语言访问ValueStack 中的数据。
三、Struts2的配置和使用1. 配置文件：Struts2的配置文件是struts.xml，用于配置Action、Interceptor、Result等组件的相关属性。
struts2流程和配置步骤
Struts2执行流程2009-12-16 12:19Struts2执行流程1. web.xml 部署描述符2. FilterDispatcher 实现StrutsStatics, Filter接口(1)Filter:一个filter是一个对象用于执行过滤任务为每个请求资源(一个servlet或静态内容),或响应一个资源，或两者.过滤器执行过滤是在doFilter方法中.每个过滤器访问一个FilterC onfig对象从中获取初始化参数,一个引用到ServletContext可以被使用,例如，在过滤器任务需要时装载资源.过滤器的配置在Web应用程序的部署描述符中.init()-初始化过滤器，它的输入参数javax.servlet.FilterConfig的一个实例，可以这里初始化过滤要使用到的FilterConfig。
这个方法由Web容器自动调用。
doFilter()-进行具体的过滤操作，这个方法以javax.servlet.ServletRequest请求信息，jav ax.servlet.ServletResponse响应信息，javax.servlet.FilterChain过滤链。
过滤链，在Web 应用程序中所有的过滤器会构成一个链状，符合过滤条件的程序将会根据定义的顺序执行所有链中的过滤器。
在这个方法中调用FilterChain的doFilter(javax.servlet.ServletReque st, javax.servlet.SerletResponse)方法就可以传递到链中的下一个过滤器。
destory()-销毁过滤器，可以在这里释放使用完的资源，例如设置过滤器中FilterConfig为n ull。
(2)StrutsStatics: 定义Struts中使用的常量,常量用来获取和设置Action上下文以外的对象或其它集合.可以使用如下方式获取这些对象ActionContext context = ActionContext.getContext();HttpServletRequest request = (HttpServletRequest)context.get(HTTP_REQUEST);(3) FilterConfig接口：一个过滤器配置对象，用于Servlet容器传递信息到过滤器在初始化期间.BeanSelectionProvider类:选择框架实现的关键扩展点，用于装载属性常量.选择的实现是从container builder使用的名字定义关联属性，默认名为”struts”例如:获取requestActionContext.getContext().put(HTTP_REQUEST, request)执行流程:※init(FilterConfig filterConfig)初始化过滤器->createDispatcher(filterConfig); 创建调度器，返回带有过滤器参数Dispatcher ->执行Dispatcher的init方法,首先创建configurationManager，如果为null使用Bean SelectionProvider. DEFAULT_BEAN_NAME参数创建.-> 配置的初始化//加载org/apache/struts2/default.properties文件init_DefaultProperties(); // [1]//加载格式相同的struts-default.xml,struts-plugin.xml,struts.xmlinit_TraditionalXmlConfigurations(); // [2]//可读取public static final String STRUTS_LOCALE = "struts.locale";配置init_LegacyStrutsProperties(); // [3]//加载Web.xml中的actionPackages配置init_ZeroConfiguration(); // [4]//读取configProviders参数，配置用户定义的providerinit_CustomConfigurationProviders(); // [5]//Struts2.0.9中为空init_MethodConfigurationProvider();//初始化Filter中的config参数中指定的配置文件, initParams参数的获取是在Dispatch er创建时init_FilterInitParameters() ; // [6]//在BeanSelectionProvider中注册别名init_AliasStandardObjects() ; // [7]//读取public static final String STRUTS_I18N_RELOAD = "struts.i18n.reload";参数, Container container = init_PreloadConfiguration();//读取public static final String STRUTS_CONFIGURATION_XML_RELOAD = "struts.c onfiguration.xml.reload";init_CheckConfigurationReloading(container);//初始化weblogic相关配置init_CheckWebLogicWorkaround(container);-> String param = filterConfig.getInitParameter("packages");String packages = "org.apache.struts2.static template org.apache.struts2.inte rceptor.debugging";设置静态资源Prefixes※->doFilter处理一个Action和它请求的静态资源,过滤器尝试配置请求到一个Action mapping.如果mapping找到了,Action的处理在dispatcher的serviceAction方法.如果Action处理失败,d oFilter将会尝试去创建一个错误页面通过dispatcher.另外请求一个静态资源,资源将直接C opy到响应,使用适当的caching头设置.如果请求没有匹配一个Action mapping或一个静态资源页，那么将通过.(1) getServletContextServlet2.3规范中Servlet Context可以从Session中从新获取。
2_Struts2工作流程与模型驱动模式
action
action须实现com.opensymphony.xwork.Action接口。 struts2提供ActionSupport 实现该接口。 对Servlet的依赖性 : ActionContext ServletActionContext 中获取request和response。
LoginService类
模型驱动模式
1.把LoginAction类中的属性及 把 类中的属性及getter/setter方法： 方法： 类中的属性及 方法 private String username; private String password; public String getUsername() { return username; } public void setUsername(String username) { ername = username; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } 放到单独的User类中，并给 类中， 加上如下代码： 放到单独的 类中 并给LoginAction加上如下代码： 加上如下代码 private User user=new User(); 用到的用户与密码改为user.getUsername(), user.getPassword() 用到的用户与密码改为
<struts> <package name=“yj" extends="struts-default"> <action name="login" class="com.yj.struts2.action.LoginAction"> <result name="error">/error.jsp</result> <result name="success">/success.jsp</result> </action> </package> </struts> ** 必须继承 必须继承struts-default包中的配置！ 包中的配置！ 包中的配置
struts2的执行流程简述
struts2的执行流程简述英文回答：The execution flow of Struts2 can be described in the following steps:1. Request Handling: When a request is made to a Struts2 application, it is first intercepted by the FilterDispatcher, which is responsible for handling all incoming requests. The FilterDispatcher then creates an ActionContext object to hold the request information.2. Interceptors: Struts2 uses interceptors to perform pre-processing and post-processing tasks. Interceptors are configured in the struts.xml file and are executed in a specific order. Each interceptor can modify the request or response before passing it to the next interceptor or the action.3. Action Mapping: After the request is processed bythe interceptors, the ActionMapper is responsible for mapping the request to a specific action class and method. The ActionMapper uses the request URL and the struts.xml configuration file to determine the appropriate action.4. Action Execution: Once the action class and method are determined, the ActionProxy is created to manage the execution of the action. The ActionProxy creates an instance of the action class and invokes the corresponding method.5. Result Processing: After the action method is executed, the result is generated. The result is typically a JSP page or a JSON/XML response. The Result type and its associated configuration in the struts.xml file determine how the result is processed.6. Result Rendering: The result is rendered and sent back to the client as the response. If the result is a JSP page, it is rendered by the ViewRenderer. If the result is a JSON/XML response, it is serialized and sent back as the response.7. Post-processing: After the response is sent back to the client, any post-processing tasks can be performed, such as logging, error handling, or cleanup.中文回答：Struts2的执行流程可以简述如下：1. 请求处理，当一个请求到达Struts2应用程序时，首先会被FilterDispatcher拦截器处理。
struts2、struts1的执行流程、工作原理
Struts2框架本身大致可以分为3个部分：核心控制器FilterDispatcher、业务控制器Action和用户实现的企业业务逻辑组件。
核心控制器FilterDispatcher是Struts 2框架的基础，包含了框架内部的控制流程和处理机制。
业务控制器Action 和业务逻辑组件是需要用户来自己实现的。
用户在开发Action 和业务逻辑组件的同时，还需要编写相关的配置文件，供核心控制器FilterDispatcher来使用。
Struts2的工作流程相对于Struts1要简单，与WebWork框架基本相同，所以说Struts2是WebWork的升级版本。
基本扼要流程如下：1、客户端浏览器发出HTTP请求。
2、根据web.xml配置，该请求被FilterDispatcher接收。
3、根据struts.xml配置，找到需要调用的Action类和方法，并通过IoC方式，将值注入给Aciton。
4、Action调用业务逻辑组件处理业务逻辑，这一步包含表单验证。
5、Action执行完毕，根据struts.xml中的配置找到对应的返回结果result，并跳转到相应页面。
6、返回HTTP响应到客户端浏览器。
Struts工作机制？为什么要使用Struts？工作机制：Struts的工作流程:在web应用启动时就会加载初始化ActionServlet,ActionServlet从struts-config.xml文件中读取配置信息,把它们存放到各种配置对象当ActionServlet接收到一个客户请求时,将执行如下流程.-(1)检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径失效信息;-(2)如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中;-(3)根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm 的validate()方法;-(4)如果ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象,就表示表单验证胜利;-(5)ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的Action实例不存在,就先创建这个实例,然后调用Action 的execute()方法;-(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给ActionForward对象指向的JSP组件;-(7)ActionForward对象指向JSP组件生成动态网页,返回给客户;为什么要用：JSP、Servlet、JavaBean技术的出现给我们构建强健的企业应用系统提供了可能。
struts2流程图
struts2流程图Struts2流程图。
Struts2是一个用于开发Java Web应用程序的开源Web应用程序框架。
它基于MVC（Model-View-Controller）设计模式，通过将应用程序分为模型、视图和控制器三个部分来实现应用程序的松耦合和可维护性。
在Struts2框架中，流程图是非常重要的，它描述了用户请求在整个框架中的处理流程，包括请求的接收、处理和响应等环节。
本文将详细介绍Struts2的流程图。
1. 用户发起请求。
用户在浏览器中输入URL或者点击页面上的链接，向服务器发起请求。
请求首先经过Web服务器，然后由Struts2的过滤器拦截。
2. 过滤器拦截。
Struts2框架中的过滤器负责拦截用户请求，并将其传递给相应的Action类进行处理。
过滤器根据用户请求的URL和配置文件中的映射关系，找到对应的Action类。
3. Action类处理。
一旦过滤器确定了用户请求对应的Action类，就会将请求传递给该Action类进行处理。
Action类是整个Struts2应用程序的核心，它包含了请求的处理逻辑和业务逻辑。
在Action类中，可以调用服务层的方法来处理业务逻辑，并将处理结果存储在Action的属性中。
4. 结果视图渲染。
当Action类处理完用户请求后，它会将处理结果传递给结果视图进行渲染。
结果视图可以是JSP页面、FreeMarker模板或者其他类型的视图。
在结果视图中，可以使用Struts2标签来显示Action 中存储的数据，并将最终的页面返回给用户。
5. 响应用户。
最后，经过结果视图渲染后的页面将被发送给用户的浏览器，用户可以在浏览器中看到处理结果。
整个请求-处理-响应的流程就此完成。
总结。
通过以上流程图的介绍，我们可以清晰地了解Struts2框架中用户请求的处理流程。
从用户发起请求开始，经过过滤器的拦截，再到Action类的处理，最终到结果视图的渲染，整个流程清晰可见。
struts2工作流程
struts2工作流程Struts2工作流程。
Struts2是一个基于MVC设计模式的开源Web应用框架，它是Struts的下一代产品，相比于Struts1，Struts2更加灵活、简单，并且提供了更好的性能。
在使用Struts2开发Web应用程序时，了解其工作流程是非常重要的。
本文将详细介绍Struts2的工作流程，帮助读者更好地理解这个框架。
首先，当客户端发送请求时，请求会被Struts2的过滤器拦截。
过滤器会将请求交给Struts2的核心控制器DispatcherServlet进行处理。
DispatcherServlet是Struts2框架的核心，它负责协调整个请求处理的过程。
接着，DispatcherServlet会根据请求中的URL找到对应的Action。
Action是Struts2框架中的控制器，它负责处理用户的请求并生成响应。
在Struts2中，每一个请求都会对应一个Action类。
一旦找到了对应的Action，DispatcherServlet会创建Action的实例，并调用其execute方法。
在Action的execute方法中，我们可以编写业务逻辑代码，比如从数据库中获取数据、调用其他服务进行处理等。
在Action执行完业务逻辑后，会生成一个结果视图。
结果视图是一个逻辑视图的名称，它对应着一个真正的JSP页面。
Struts2会根据结果视图的名称找到对应的JSP页面，并将数据传递给该页面进行渲染。
最后，渲染后的页面会被发送给客户端，客户端就会看到我们期望的页面效果。
整个请求处理过程就此完成。
总的来说，Struts2的工作流程可以简单概括为，过滤器拦截请求，DispatcherServlet找到对应的Action，执行Action的业务逻辑，生成结果视图，渲染页面并返回给客户端。
这个过程清晰明了，符合MVC设计模式的思想，使得我们能够更加方便地开发Web 应用程序。
需要注意的是，Struts2框架提供了丰富的拦截器（Interceptor）机制，可以在请求处理的各个阶段进行自定义的处理。
struts2工作流程
struts2工作流程Struts2工作流程。
Struts2是一个开源的Web应用框架，它基于MVC（Model-View-Controller）设计模式，用于简化Java Web应用程序的开发。
它提供了一套强大的工具和库，可以帮助开发人员构建灵活、可维护的Web应用程序。
在本文中，我们将详细介绍Struts2的工作流程，包括请求的处理过程、数据的传递方式以及页面的渲染流程。
首先，当用户发送一个HTTP请求时，请求会被DispatcherServlet拦截并交给Struts2的核心控制器ActionProxy进行处理。
ActionProxy会根据请求的URL找到对应的Action类，并执行其对应的方法。
在执行Action方法之前，Struts2会对请求参数进行封装，将其转换成Action类的属性，并注入到Action对象中。
这样，Action类就可以获取到用户提交的数据，并进行相应的处理。
接下来，Action类会根据业务逻辑进行处理，并返回一个结果字符串。
这个结果字符串会被解析成一个逻辑视图，然后由Result对象进行渲染。
在渲染过程中，Struts2会根据配置文件中的结果类型，选择合适的渲染方式，比如将数据填充到JSP页面中，或者返回一个JSON格式的数据。
最终，渲染后的结果会被返回给用户，完成整个请求-响应的过程。
在整个工作流程中，Struts2提供了丰富的拦截器机制，可以在请求的不同阶段进行处理。
拦截器可以用于权限控制、日志记录、异常处理等，可以很好地帮助开发人员进行业务逻辑的分离和复用。
此外，Struts2还支持国际化和主题切换，可以根据用户的偏好提供不同的界面显示效果。
总的来说，Struts2的工作流程非常清晰和灵活，它将请求处理、业务逻辑和页面渲染等功能进行了良好的分离，使得Web应用程序的开发变得更加简单和高效。
通过深入了解Struts2的工作流程，开发人员可以更好地利用其提供的功能和特性，构建出更加稳健和可扩展的Web应用程序。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
工作流程一个请求在Struts2框架中的处理大概分为以下几个步骤：1客户端初始化一个指向Servlet容器（例如Tomcat）的请求；2这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）3接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请是否需要调用某个Action4如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy5ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类6ActionProxy创建一个ActionInvocation的实例。
和"struts2工作流程"有关的java编程小帖士：strong>Locale.setNegativeNumberMode方法的参数。
字段7ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。
8一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。
返回结果通常是（但不总是，也可能是另外的一个Action 链）一个需要被表示的JSP或者FreeMarker的模版。
在表示的过程中可以使用Struts2框架中继承的标签。
在这个过程中需要涉及到ActionMapper在上述过程中所有的对象（Action，Results，Interceptors，等）都是通过ObjectFactory来创建的。
Struts2的目标很简单--使Web开发变得更加容易。
为了达成这一目标，Struts2中提供了很多新特性，比如智能的默认设置、annotation的使用以及"惯例重于配置"原则的应用，而这一切都大大减少了XML配置。
Struts2中的Action都是POJO，这一方面增强了Action本身的可测试性，另一方面也减小了框架内部的耦合度，而HTML表单中的输入项都被转换成了恰当的类型以供action使用。
开发人员还可以通过拦截器（可以自定义拦截器或者使用Struts2提供的拦截器）来对请求进行预处理和后处理，这样一来，处理请求就变得更加模块化，从而进一步减小耦合度。
模块化是一个通用的主题--可以通过插件机制来对框架进行扩展；开发人员可以使用自定义的实现来替换掉框架的关键类，从而获得框架本身所不具备的功能；可以用标签来渲染多种主题（包括自定义的主题）；Action执行完毕以后，可以有多种结果类型--包括渲染JSP页面，Velocity和Freemarker 模板，但并不仅限于这些。
最后，依赖注入也成了Struts2王国中的一等公民，这项功能是通过Spring框架的插件和Plexus共同提供的，与PicoContainer的结合工作还正在进行中Struts2设计的精巧之处就是使用了Action代理，Action代理可以根据系统的配置，加载一系列的拦截器，由拦截器将HttpServletRequest参数解析出来，传入Action。
同样，Action处理的结果也是通过拦截器传入HttpServletResponse，然后由HttpServletRequest传给用户。
其实，该处理过程是典型的AOP（面向切面编程）的方式，读者可以在后面详细了解到。
Struts2处理过程模型如图3.2所示。
图3.2Struts2处理过程模型★说明★拦截器是Struts2框架的核心，通过拦截器，实现了AOP（面向切面编程）。
使用拦截器，可以简化Web开发中的某些应用，例如，权限拦截器可以简化Web 应用中的权限检查。
业务控制器Action是由开发者自己编写实现的，Action类可以是一个简单的Java类，与Servlet API完全分离。
Action一般都有一个execute()方法，也可以定义其他业务控制方法，详细内容将在后面介绍。
Action的execute()返回一个String类型值，这与Struts1返回的ActionForward 相比，简单易懂。
Struts2提供了一个ActionSupport工具类，该类实现了Action 接口和validate()方法，一般开发者编写Action可以直接继承ActionSupport类。
编写Action类后，开发者还必须在配置文件中配置Action。
一个Action的配置应该包含下面几个元素：―该Action的name，即用户请求所指向的URL。
―Action所对应的class元素，对应Action类的位置。
―指定result逻辑名称和实际资源的定位。
Action是业务控制器，笔者建议在编写Action的时候，尽量避免将业务逻辑放到其中，尽量减少Action与业务逻辑模块或者组件的耦合程度。
业务模型组件可以是实现业务逻辑的模块，可以是EJB、POJO或者JavaBean，在实际开发中，对业务模型组件的区分和定义也是比较模糊的，实际上也超出了Struts2框架的范围。
不同的开发者或者团队，都有自己的方式来实现业务逻辑模块，Struts2框架的目的就是使用Action来调用业务逻辑模块。
例如一个银行存款的业务逻辑模块，如代码3.3所示。
代码3.3模拟一个银行业务的实现模块package ch3;public class Bank{//定义银行账户private String accounts;//定义操作金额private double money;//属性的getter和setter方法public String getAccounts(){return accounts;}public void setAccounts(String accounts){this.accounts=accounts;}public double getMoney(){return money;}public void setMoney(double money){this.money=money;}//模拟银行存款方法public boolean saving(String accounts,double money){//调用DAO等模块读写数据库return dosomeing();}}上面实例在实际开发中没有任何意义，这里只是作为业务逻辑模块来说明，在执行saving(String accounts,double money)方法时，可以调用相应的数据库访问其他组件，来实现存款操作。
使用Action调用该业务逻辑组件可以在execute()方法中实现，如代码3.4所示。
代码3.4业务控制器Bank_Saving_Actionpackage ch3;import java.util.Map;import com.opensymphony.xwork2.ActionContext;import com.opensymphony.xwork2.ActionSupport;public class Bank_Saving_Action extends ActionSupport{//定义银行账户private String accounts;//定义操作金额private double money;public String execute()throws Exception{//创建Bank实例Bank bk=new Bank();//调用存款方法if(bk.saving(accounts,money)){return SUCCESS;}else{return ERROR;}}//属性的getter和setter方法public String getAccounts(){return accounts;}public void setAccounts(String accounts){this.accounts=accounts;}public double getMoney(){return money;}public void setMoney(double money){this.money=money;}Bank_Saving_Action演示了对银行存款业务逻辑组件的调用，这里是通过在Action中创建业务逻辑组件实例的方式实现的。
在实际开发中，可以使用静态工厂获得业务逻辑组件的实例或者使用IoC容器来管理。
Action中不实现任何业务逻辑，只是负责组织调度业务逻辑组件。
调用关系如图3.3所示。
图3.3调用业务逻辑组件★说明★业务控制器Action一般情况下不是直接创建业务逻辑组件实例，而是使用工厂模式或者是从Spring容器中获得业务逻辑组件实例，这样可以提高系统的性能。
Struts1只能支持JSP作为视图资源，而Struts2的进步之处就是可以使用其他视图技术，如FreeMarker、Velocity等。
通过前面的学习和示例，读者会知道Action 的返回结果只是一个简单的字符串，也就是一个逻辑上的视图名称，要与实际视图资源对应，必须通过配置文件来实现。
在struts.xml配置文件中，每一个Aciton定义都有name和class属性，同时还要指定result元素。
result元素指定了逻辑视图名称和实际视图的对应关系。
每个result都有一个type属性，前面介绍的struts.xml中并没有显式指定type值，即使用了默认的type类型：dispatcher，该结果类型支持JSP所谓视图资一个请求在Struts2框架中的处理大概分为以下几个步骤：1客户端初始化一个指向Servlet容器（例如Tomcat）的请求；2这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）3接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请是否需要调用某个Action4如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy5ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类6ActionProxy创建一个ActionInvocation的实例。