Struts2页面数据流向及获取方法
struts2执行流程及工作原理
struts2执⾏流程及⼯作原理1 ⽤户发送请求;2 这个请求经过⼀系列的过滤器(Filter)(这些过滤器中有⼀个叫做ActionContextCleanUp的可选过滤器,这个过滤器对于Struts2和其他框架的集成很有帮助,例如:SiteMesh Plugin)3 接着FilterDispatcher被调⽤,FilterDispatcher询问ActionMapper来决定这个请求是否需要调⽤某个Action ;4 如果需要处理,ActionMapper会通知FilterDispatcher,需要处理这个请求,FilterDispatcher会停⽌过滤器链以后的部分,(这也就是为什么,FilterDispatcher应该出现在过滤器链的最后的原因)。
FilterDispatcher把请求的处理交给ActionProxy ;5 ActionProxy通过Configuration Manager询问框架的配置⽂件struts.xml,找到需要调⽤的Action类。
(在服务器启动的时候,ConfigurationManager就会把struts.xml中的所有信息读到内存⾥,并缓存,当ActionProxy带着URL向他询问要运⾏哪个Action的时候,就可以直接匹配、查找并回答了)6 ActionProxy创建⼀个ActionInvocation的实例。
7 ActionInvocation实例使⽤命名模式来调⽤,在调⽤Action的过程前后,涉及到⼀系列相关拦截器(Intercepter)的调⽤。
8 ⼀旦Action执⾏完毕,ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。
返回结果通常是(但不总是,也可能是另外的⼀个Action链)⼀个需要被表⽰的JSP或者FreeMarker的模版。
在表⽰的过程中可以使⽤Struts2 框架中继承的标签。
9 最后,ActionInvocation对象倒序执⾏拦截器。
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中的jsp值传到后台action接收的三种方法
struts2中的Action接收表单传递过来的参数有3种方法:如,登陆表单login.jsp: <form action="login" method="post" name="form1"> 用户名:<s:textfield name="username"/><br/> 密 码:<s:password name="password"/><br/> <s:submit value="提交"/> </form> 1.在Action类中定义表单属性,两者属性名称必须一致。提供setter,getter方法。即可接收到表单传过来的参数. 这种接收参数的方法,方便简单,但是结构性不是很好,且当表单传递来的参数很多的时候,整个Action类中充斥着setter,getter方法,程序结构不是很美观。 2.把表单传递过来的参数封装成一个类,然后调用其中的属性. 如,把login.jsp页面要传来的参数进行封装 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; } 然后再Action方法中,定义该类的对象就可以了,如 public class loginAction extends ActionSupport{ private Users users; public Users getUsers(){ return users; } public void setUsers(Users users){ ers=users; } } 通过这种方法传值,还必须在jsp页面做一下处理,login.jsp中from1的属性名应该改成这样: 登陆表单login.jsp: <form action="login" method="post" name="form1"> 用户名:<s:textfield name="ername"/><br/> 密 码:<s:password name="users.password"/><br/> <s:submit value="提交"/> </form> 这种方法,在struts开发中是很常用的一种方法! 3.通过实现ModelDriven接口接收表单数据首先Action类必须实现ModelDriven接口,同样把表单传来的数据封装起来,Action类中必须实例化该对象,并且要重写getModel()方法 public class loginAction extends ActionSupport implements ModelDriven<Users>{ private Users users =new Users(); public Users getModel(){ return users; } } 三种方法各有所好,根据不同情况选择使用
Struts2--result页面跳转forward--get方式和post方式的获取参数
Struts2--result页⾯跳转forward--get⽅式和post⽅式的获取参数⼀.总体概述这篇⽂章是写基于struts2(整合了ssh)的2个页⾯之间的跳转传参。
突然这天想到,struts2的result有很多的type类型(跳转,重定向,。
),于是就回忆起,跳转和重定向的不同(跳转地址栏不变,共享参数;重定向地址栏改变,不再共享参数)。
⼼⾥好奇,struts2⾥页⾯跳转的时候,get的⽅式提交时怎么再第⼆个页⾯获取参数的,post是怎么在第⼆个页⾯获取参数的。
重定向⼜是怎么样的呢?真的抱歉,我今天花了⼀天时间,只弄清楚了页⾯跳转,关于页⾯重定向传参明天再搞。
本来这篇博客都没有的,因为我写了⼀半了,把get⽅式的写好了,搞post⽅式的时候太久了。
回到这个页⾯不⼩⼼把前⾯的写的删了,写了新的话,⼀瞬间反应过来,晚了,⾃动保存了。
时间宝贵者,可以直接看正⽂的第2部分⼆.正⽂1.get⽅式提交,页⾯跳转后,在后者页⾯获取参数。
(1)先是在start.hml页⾯,⽤get⽅式提交数据(username,password)到ForwardAction,然后这个action返回SUCCESS(execute⽅法⾥没有处理任何东西,只是返回SUCCESS),然后根据定义的result(name为success)采⽤type=dispatcher(即页⾯跳转)的⽅式,跳转到后者页⾯end.html。
在end.html很简单就能取到start.html页⾯上传的参数,因为页⾯跳转地址栏没变化,⽽且get⽅式还是显⽰上传参数和值的,这样我们只要⽤js去解析地址栏,获取其中的上传参数就⾏了。
思路说道这⾥很多⼈应该就懂了,其实get⽅式的提交就变成了怎么⽤js去解析地址栏获取上传参数。
由于之前写的不⼩⼼覆盖了,现在也很晚了,这个也简单,没办法明天有时间补上来。
(2)代码:①:start.html<!DOCTYPE html><html><head><meta charset="UTF-8"><title>Insert title here</title></head><body><form action="forget" method="get"><table style="width:300px;height:150px;border:1px solid red;"><tr><td>username:</td><td><input name="username"></td></tr><tr><td>password:</td><td><input name="password"></td></tr><tr><td colspan="2"><input type="submit" value="get⽅式跳转页⾯"></td></tr></table></form></body></html>②:ForwardActionpackage com.st.action;import java.util.HashMap;import java.util.Map;import com.opensymphony.xwork2.ActionSupport;import net.sf.json.JSONObject;public class ForwardAction extends ActionSupport {private String username;//上传参数:usernameprivate String password;//上传参数:passwordpublic String getUsername() {return username;}public void setUsername(String username) {ername = username;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}//下⾯这个⽅法是处理start提交的请求的,其实没有处理任何事,因为它的业务只是要跳转到end页⾯public String execute(){System.out.println("I have entered execute");return SUCCESS;}}③struts.xml<!-- 对应的就是ForwardAction,bean的实例化是交由spring管理的 --><package name="mytest" extends="struts-default"><action name="forget" class="forwardaction" method="execute"><result name="success">end.html</result></action></package>④end.html<!DOCTYPE html><html><head><meta charset="UTF-8"><title>Insert title here</title><script src="js/jquery-3.1.1.js"></script></head><body><table style="width:400px;height:200px;border:1px solid red;"><tr><td>接收的参数username:</td><td><div id="username" style="color:red;"></div></td></tr><tr><td>接收的参数password:</td><td><div id="password" style="color:red;"></div></td></tr><tr><td><input type="submit" value="点我接收get⽅式跳转过来的参数" onclick="me()"></td></tr></table><script>//⽤正则表达式的⽅式从地址栏获取参数值function getQueryString(name){var reg=new RegExp("(^|&)"+name+"=([^&]*)(&|$)");var r=window.location.search.substring(1).match(reg);if(r!=null){return unescape(r[2]);}else{return null;}}//简单的调⽤上⾯的函数,并且显⽰下参数值function me(){$('#username').html(getQueryString('username'));$('#password').html(getQueryString('password'));}</script></body></html>(3)相关截图2.post⽅式提交,页⾯跳转后,在后者页⾯获取post⽅式上传的参数(1)概述:这个我也是觉得get⽅式能获取,post是地址栏看不见的,那该怎么获取呢,能获取吗?我去百度搜了,很多“不能”“不知道,没试过”“通过ajax”,但是说实话,说的很模糊。
Struts2批量获取参数的一些方法以及改进
Struts2批量获取参数的一些方法及改进之前用struts2弄一个erp项目,里面的表单字段数比较多。
刚刚开始的时候耐心的一个一个去从request中拿,后来实在是受不了这种体力劳动了,遂上网寻找解决方案。
总结起来,目前市面上比较常用的struts2批量获取参数的方法主要有以下几种。
1:通过添加action的属性设置get和set获取。
这种方法是最常见的,确实挺高效,但我一直不愿意用。
主要是感觉这种方法会导致整个action代码十分混乱,它们应该被集中起来放到一个对象(view object)中才对。
并且通过这种方式,我们不能自己去控制它的默认值,得去深入了解struts2的脾气。
2:在action中设置一个对象获取。
确实,action中可以构建一个对象,然后把属性塞到这个对象里,struts2框架会帮你把前端传递过来的数据填充进去。
但最让人郁闷的是,页面变量名的书写格式必须是【对象名.属性名】。
Oh,shit!为什么要弄这种耦合呢,本来页面就是要尽量的与后台分离,你总不能让前端写页面的时候先问下你打算用哪个类名吧。
完全不理解struts2的作者,都到这一步了还急着去打dota,难道说是有什么别的目的,这个我就不懂了,有高人可以指点下。
3:ModelDriven接口Struts2有一个ModelDriven接口。
使用实例如下:public class YouAction extends ActionSupport implements ModelDriven<YourBean> { private YourBean sheep = new YourBean;public YourBeangetSheep() {return sheep;}public void setSheep(YourBean sheep) {this.sheep = sheep;}public String execute() throws Exception {return SUCCESS;}@overridepublic YourBeangetModel(){return sheep;}}为什么需要在两个地方指定bean呢,弄成一个的不行么?或者,完全不需要指定的不行么?其实我没用的原因主要是我没调试成功~~!不知道是不是我的bean继承了太多层还是我的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流程
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从后台传递数据到前台的主要方法和流程两种主要方式:一和Servlet API耦合的访问方式二和Servlet API解耦的访问方式********************************************************************一和Servlet API耦合的访问方式1、采用Request(HttpServletRequest)对象来传递数据(1)在Action类文件中(A)导入ServletActionContext类:import org.apache.struts2.ServletActionContext;(B)获得request对象,具体的方法如下:HttpServletRequest request=ServletActionContext.getRequest();(C)通过setAttribute()方法把需要传递的数据对象放入request对象中:request.setAttribute("key",Object);(2)JSP文件中,有多种方法可以获得被传递的数据对象,比如:(A)request.getAttribute("key")获得被传递的数据对象。
(B)<s:iterator value="#request.key">获得被传递的数据对象。
2、采用application(ServletContext)对象来传递数据(1)在Action类文件中(A)导入ServletActionContext类:import org.apache.struts2.ServletActionContext;(B)获得application对象,具体的方法如下:ServletContext application=ServletActionContext.getServletContext();(C)通过setAttribute()方法把需要传递的数据对象放入application对象中:application.setAttribute("key",Object);(2)JSP文件中,有多种方法可以获得被传递的数据对象,比如:(A)application.getAttribute("key")获得被传递的数据对象。
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应用程序。
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是一个基于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接收参数的5种方法
struts2接收参数的5种⽅法这⾥总结下Struts2接收参数的5种⽅法。
1. 使⽤Action的属性在action⾥⾯定义要接收的参数变量,并提供相应的setter,getter。
定义的参数变量需要和提交参数的名称⼀致。
并不⽤做数据类型的转换,相应提交⽅式可以⽤get和post。
简单举例如:login.action?name=yanggb&password=123456jsp:<form action="login" method="post" name="form1">⽤户名:<s:textfield name="username"/><br/>密码:<s:password name="password"/><br/><s:submit value="提交"/></form>action:public class LoginAction extends ActionSupport {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;}}这样,在Action就能接收到前端的请求参数。
2. 使⽤DomainModel使⽤这种⽅式,在Action⾥⾯就不⽤定义很多的属性,⽽是⽤Model层⽤到的模型,保存它的⼀个对象。
struts2前台传递List、Set、Map集合数据到后台
struts2前台传递List 、Set 、Map 集合数据到后台struts2前台传递List 、Set 、Map 集合数据到后台对应数据在前台与后天中的交互,struts2框架替我们做了很⼤部分的数据封装⼯作,这⾥就关于⼀些常见类型数据传递的格式和配置注意事项做简单的记录。
主要有简单类,List 集合,Set 集合,Map 集合数据的在前台与后天间的传递与展⽰数据准备:基础类Student.class为了⽅便就将各种形式数据放在了⼀起前台录⼊数据的jsp 代码:[java]01. package com.supre.idisk.model; 02. 03. import java.io.Serializable; 04. 05. public class Student { 06. 07. private int stuId; 08. private String stuNo; 09. private String stuName; 10. private String stuAge; 11. public Student(int stuId, String stuNo, String stuName, String stuAge) { 12. super (); 13. this .stuId = stuId; 14. this .stuNo = stuNo; 15. this .stuName = stuName; 16. this .stuAge = stuAge; 17. } 18. public Student() { 19. super (); 20. // TODO Auto-generated constructor stub 21. } 22. public int getStuId() { 23. return stuId; 24. } 25. public void setStuId(int stuId) { 26. this .stuId = stuId; 27. } 28. public String getStuNo() { 29. return stuNo; 30. } 31. public void setStuNo(String stuNo) { 32. this .stuNo = stuNo; 33. } 34. public String getStuName() { 35. return stuName; 36. } 37. public void setStuName(String stuName) { 38. this .stuName = stuName; 39. } 40. public String getStuAge() { 41. return stuAge; 42. } 43. public void setStuAge(String stuAge) { 44. this .stuAge = stuAge; 45. } 46. @Override 47. public String toString() { 48. return "Student [stuId=" + stuId + ", stuNo=" + stuNo + ", stuName=" 49. + stuName + ", stuAge=" + stuAge + "]"; 50. } 51. 52. }说明:主要是name 属性的书写格式1.简单类直接使⽤‘变量名.属性’的形式2. List 集合使⽤‘变量名[索引].属性’的形式3. Set 集合⽐较特殊,必须使⽤到OGNL 中makeNew 的运算符来表⽰[html]01. <%@ page language ="java" contentType ="text/html; charset=UTF-8" 02. pageEncoding ="UTF-8"%> 03. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "/TR/html4/loose.dtd"> 04. <html> 05. <head> 06. <meta http-equiv ="Content-Type" content ="text/html; charset=UTF-8"> 07. <title>Insert title here </title> 08. </head> 09. <body> 10. <h3>简单对象</h3> 11. <form method ="post" action ="user_addStudent"> 12. 编号:<input type ="text" name ="student.stuNo" /><br/> 13. 姓名:<input type ="text" name ="student.stuName" /><br/> 14. 年龄:<input type ="text" name ="student.stuAge" /><br/> 15. <input type ="submit" value ="提交" /> 16. </form> 17. <hr> 18. <h3>List 集合</h3> 19. <form method ="post" action ="user_addStuList"> 20. 学⽣1 21. 编号:<input type ="text" name ="stuList[0].stuNo" /> 22. 姓名:<input type ="text" name ="stuList[0].stuName" /> 23. 年龄:<input type ="text" name ="stuList[0].stuAge" /><br/> 24. 学⽣2 25. 编号:<input type ="text" name ="stuList[1].stuNo" /> 26. 姓名:<input type ="text" name ="stuList[1].stuName" /> 27. 年龄:<input type ="text" name ="stuList[1].stuAge" /><br/> 28. 学⽣3 29. 编号:<input type ="text" name ="stuList[2].stuNo" /> 30. 姓名:<input type ="text" name ="stuList[2].stuName" /> 31. 年龄:<input type ="text" name ="stuList[2].stuAge" /><br/> 32. <input type ="submit" value ="提交" /> 33. </form> 34. <hr> 35. <h3>Set 集合</h3> 36. <form method ="post" action ="user_addStuSet"> 37. 学⽣1 38. 编号:<input type ="text" name ="stuSet.makeNew[0].stuNo" /> 39. 姓名:<input type ="text" name ="stuSet.makeNew[0].stuName" /> 40. 年龄:<input type ="text" name ="stuSet.makeNew[0].stuAge" /><br/> 41. 学⽣2 42. 编号:<input type ="text" name ="stuSet.makeNew[1].stuNo" /> 43. 姓名:<input type ="text" name ="stuSet.makeNew[1].stuName" /> 44. 年龄:<input type ="text" name ="stuSet.makeNew[1].stuAge" /><br/> 45. 学⽣3 46. 编号:<input type ="text" name ="stuSet.makeNew[2].stuNo" /> 47. 姓名:<input type ="text" name ="stuSet.makeNew[2].stuName" /> 48. 年龄:<input type ="text" name ="stuSet.makeNew[2].stuAge" /><br/> 49. <input type ="submit" value ="提交" /> 50. </form> 51. <hr> 52. 53. <h3>Map 集合</h3> 54. <form method ="post" action ="user_addStuMap"> 55. 学⽣1 56. 编号:<input type ="text" name ="stuMap['stu1'].stuNo" /> 57. 姓名:<input type ="text" name ="stuMap['stu1'].stuName" /> 58. 年龄:<input type ="text" name ="stuMap['stu1'].stuAge" /><br/> 59. 学⽣2 60. 编号:<input type ="text" name ="stuMap.stu2.stuNo" /> 61. 姓名:<input type ="text" name ="stuMap.stu2.stuName" /> 62. 年龄:<input type ="text" name ="stuMap.stu2.stuAge" /><br/> 63. 学⽣3 64. 编号:<input type ="text" name ="stuMap['stu3'].stuNo" /> 65. 姓名:<input type ="text" name ="stuMap['stu3'].stuName" /> 66. 年龄:<input type ="text" name ="stuMap['stu3'].stuAge" /><br/> 67. <input type ="submit" value ="提交" /> 68. </form> 69. <hr> 70. </body> 71. </html>格式:‘变量名.makeNew[索引].属性’4.Map集合使⽤的是‘变量名.key名.属性’ 也可以是‘变量名['key'].属性’这⾥key使⽤是String类型,上⾯两种形式都可以,其他类型的key就需要⾃⼰亲测了后台接收数据的Action类代码:[java]01. package com.supre.idisk.action;02.03. import java.util.HashMap;04. import java.util.HashSet;05. import java.util.List;06. import java.util.Map;07. import java.util.Set;08.09. import com.opensymphony.xwork2.ActionSupport;10. import com.opensymphony.xwork2.util.Element;11. import com.opensymphony.xwork2.util.Key;12. import com.opensymphony.xwork2.util.KeyProperty;13. import com.supre.idisk.model.Student;14.15. public class UserAction extends ActionSupport {16.17. private Student student;18. @Element(Student.class)19. private List<Student> stuList;20. @KeyProperty("stuId") //Student中的标识字段,该字段需要get⽅法,该配置不可少21. @Element(Student.class)22. private Set<Student> stuSet = new HashSet<>();23. @Key(String.class)24. @Element(Student.class)25. private Map<String, Student> stuMap = new HashMap<>();26.27. public String addStudent(){28. System.out.println("-------简单对象");29. System.out.println(student);30. return SUCCESS;31. }32.33. public String addStuList(){34. System.out.println("-------List集合");35. for (Student stu : stuList) {36. System.out.println(stu);37. }38. return SUCCESS;39. }40.41. public String addStuSet(){42. System.out.println("-------Set集合");43. System.out.println(stuSet);44. for (Student stu : stuSet) {45. System.out.println(stu);46. }47. return SUCCESS;48. }49.50. public String addStuMap(){51. System.out.println("-------Map集合");52. for (String key : stuMap.keySet()) {53. System.out.println(key + "----" + stuMap.get(key));54. }55. return SUCCESS;56. }57. public Student getStudent() {58. return student;59. }60. public void setStudent(Student student) {61. this.student = student;62. }63. public List<Student> getStuList() {64. return stuList;65. }66. public void setStuList(List<Student> stuList) {67. this.stuList = stuList;68. }69. public Set<Student> getStuSet() {70. return stuSet;71. }72. public void setStuSet(Set<Student> stuSet) {73. this.stuSet = stuSet;74. }注意:1.其中的变量必须提供标准的get 和set ⽅法2.Set 集合和Map 集合必须初始化,即在定义的时候就赋上对象3. Set 集合上的KeyProperty 注解必须配上,其他注解配置均可以省略。
struts2页面信息显示(一)
一、Struts2显示:(一)后台类向其他*传值专题1、类与类之间传值(多用于菜单、权限)(1)根据result 中type的不同:chain 可以允许代理之间传递参数举例:<action name="test07Action"class="action.Test07Action"><result name="ok"type="chain"><param name="actionName">test08Action</param><param name="userBean">${userBean}</param></result></action>(2)Redirect不能将参数传递给其他代理举例<action name="test07Action_1"class="action.Test07Action"><result name="ok"type="redirect">test08Action!add</result></action>2、类和配置文件之间传值:xml文件或者properties文件(资源配置文件)使用EL表达式举例:<action name="test07Action"class="action.Test07Action"><result name="ok"type="chain"><param name="actionName">test08Action</param><param name="userBean">${userBean}</param></result></action>2、类与前台页面直接传值:使用struts2标签、标签是从struts2中属性的getXXXX()获取信息举例:<s:property value="userName"/>。
struts2执行流程
struts2执行流程Struts2执行流程。
Struts2是一个用于开发Web应用程序的开源框架,它基于MVC(Model-View-Controller)设计模式,提供了一种简单而强大的方式来构建灵活的、可维护的Web应用程序。
在本文中,我们将探讨Struts2的执行流程,以帮助开发人员更好地理解这个框架的工作原理。
1. 请求的接收。
当用户在浏览器中输入URL并发送请求时,该请求首先到达Servlet容器。
在Struts2中,所有的请求都由一个名为“StrutsPrepareAndExecuteFilter”的过滤器来拦截。
这个过滤器是Struts2框架的核心组件之一,它负责拦截所有的HTTP请求,并将它们转发给Struts2的核心控制器。
2. 控制器的处理。
一旦请求被Struts2的过滤器拦截,它会被传递给控制器。
在Struts2中,控制器是一个名为“ActionProxy”的对象,它负责查找并执行与请求对应的Action。
Action是一个用于处理特定请求的Java类,它包含了与请求相关的业务逻辑和数据处理代码。
3. Action的执行。
一旦ActionProxy找到了与请求对应的Action,它就会执行这个Action。
在执行过程中,Struts2框架会自动地将请求参数映射到Action的属性中,并调用Action中的相应方法来处理请求。
在Action的执行过程中,可以进行各种业务逻辑的处理,例如数据库操作、数据计算、页面跳转等。
4. 结果的返回。
当Action执行完成后,它会返回一个结果。
结果通常是一个视图,用于展示处理结果给用户。
在Struts2中,结果是通过一个名为“Result”的对象来表示的,它包含了视图的名称、类型和其他相关信息。
一旦Action返回了结果,Struts2框架会根据结果的信息来选择合适的视图,并将处理结果呈现给用户。
5. 视图的渲染。
最后,Struts2框架会将选择的视图渲染成HTML,并将其返回给浏览器。
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 中action 如何获取jsp 页面参数1
struts2 中action 如何获取jsp 页面参数1. ActionContext1. ActionContext在Struts2 开发中,除了将请求参数自动设置到Action 的字段中,我们往往也需要在Action 里直接获取请求(Request)或会话(Session)的一些信息,甚至需要直接对JavaServlet Http 的请求(HttpServletRequest),响应(HttpServletResponse)操作. 我们需要在Action 中取得request 请求参数"username"的值:ActionContext context = ActionContext.getContext();Map params = context.getParameters();String username = (String) params.get("username");ActionContext(com.opensymphony.xwork.ActionContext)是Action 执行时的上下文,上下文可以看作是一个容器(其实我们这里的容器就是一个Map 而已),它存放的是Action 在执行时需要用到的对象.一般情况, 我们的ActionContext 都是通过: ActionContext context = (ActionContext) actionContext.get();来获取的.我们再来看看这里的actionContext 对象的创建:static ThreadLocal actionContext = new ActionContextThreadLocal(); ActionContextThreadLocal 是实现ThreadLocal 的一个内部类.ThreadLocal 可以命名为"线程局部变量",它为每一个使用该变量的线程都提供一个变量值的副本,使每一个线程都可以独立地改变自己的副本,而不会和其它线程的副本冲突.这样,我们ActionContext 里的属性只会在对应的当前请求线程中可见,从而保证它是线程安全的.通过ActionContext 取得HttpSession: Map session =ActionContext.getContext().getSession();2. ServletActionContextServletActionContext(com.opensymphony.webwork. ServletActionContext),这个类直接继承了我们上面介绍的ActionContext,它提供了直接与Servlet 相关对象访问的功能,它可以取得的对象有:(1)javax.servlet.http.HttpServletRequest : HTTPservlet 请求对象(2)javax.servlet.http.HttpServletResponse : HTTPservlet 相应对象(3)javax.servlet.ServletContext : Servlet 上下文信息(4)javax.servlet.ServletConfig : Servlet 配置对象(5)javax.servlet.jsp.PageContext : Http 页面上下文如何从ServletActionContext 里取得Servlet 的相关对象:<1>取得HttpServletRequest 对象: HttpServletRequest request = ServletActionContext. getRequest();<2>取得HttpSession 对象: HttpSession session = ServletActionContext.getRequest().getSession();3. ServletActionContext 和ActionContext 联系ServletActionContext 和ActionContext 有着一些重复的功能,在我们的Action 中,该如何去抉择呢?我们遵循的原则是:如果ActionContext 能够实现我们的功能,那最好就不要使用ServletActionContext,让我们的Action 尽量不要直接去访问Servlet 的相关对象.注意:在使用ActionContext 时有一点要注意: 不要在Action 的构造函数里使用ActionContext.getContext(),因为这个时候ActionContext 里的一些值也许没有设置,这时通过ActionContext 取得的值也许是null;同样,HttpServletRequest req = ServletActionContext.getRequest()也不要放在构造函数中,也不要直接将req 作为类变量给其赋值。
jQuery学习之:jqGrid表格插件——从Struts2获得数据
之前谈到了jqGrid与Serlvet/JSP集成,实际上就是Servlet按jqGrid对数据的要求返回相应的数据,Servlet中是通过PrintWriter输出数据的,那时,我们用到了json-lib来构建Json数据。
现在来谈谈jqGrid如何与Struts2集成。
对于Struts2,同样需要按jqGrid的要求返回相应的json数据格式。
当然,我们可以在Struts2的Action中通过返回 null来干Servlet一样的事情,这样也能够同Servlet一样实现与jqGrid集成。
然而,此时Struts2实际上相当于没有。
既然用到了 Struts2,我们就应该用Struts2为我们提供的方法。
而且,在Struts的Action中应该尽量避免使用request 之类的 Servlet对象,用Struts2更是如此。
在struts1.x中,request直接就有的,因而在开发中总会有人“打着struts的旗帜,干着Servlet的勾当”。
我们知道,request等是依赖于Servlet容器的,Struts2把这些屏蔽了,Struts2的Action可以直接是POJO,因而我们更不应该违反Struts2的设计原则,硬是去“干Servlet的勾当”。
闲话不说,开始咱们的正题。
在Struts2的jar包中,有一个struts2-json-plugin.jar,它就是用于处理json数据的(Struts2提供了很多插件),我们就是应用它来实现struts2与jqGrid的集成。
1、效果图:2、代码与解释:HTML代码:<;body>;<;tableid=";gridTable";>;<;/ table >;<;divid=";gridPager";>;<;/ div >;<;/ body >;JavaScript代码:$(function (){$(";#gridTable"; ).jqGrid({url:'json/jqgrid.action',datatype:";json"; ,height: 250,colNames:['编号','用户名', '性别', '邮箱', 'QQ','手机号','出生日期'],colModel:[{name:'id',index:'id', sorttype:";int"; },{name:'userName',index:'userName',{name:'gender',index:'gender',{name:'email',index:'email', ;string";},{name:'QQ',index:'QQ', ;{name:'mobilePhone',index:'mobilePhone', ;{name:'birthday',index:'birthday', sorttype:";date"; }],sortname:'id',sortorder:'asc',viewrecords:true ,rowNum:10,rowList:[10,20,30],jsonReader: {root:";dataRows"; ,// 数据行(默认为:rows)page:";curPage"; ,// 当前页total:";totalPages"; ,// 总页数records:";totalRecords"; ,// 总记录数repeatitems :false// 设置成false,在后台设置值的时候,可以乱序。
struts2工作流程
struts2工作流程Struts2工作流程。
Struts2是一个基于MVC设计模式的开源Web应用框架,它是Struts1的升级版本。
它的工作流程包括请求的接收、处理和响应,下面我们来详细了解一下Struts2的工作流程。
1. 拦截器的拦截。
在Struts2中,请求首先会经过一系列的拦截器。
拦截器是Struts2框架的核心组件,它负责拦截请求并在请求的处理过程中执行一些特定的任务,比如验证用户身份、处理异常等。
在拦截器的拦截下,请求会被传递给Action类进行处理。
2. Action类的执行。
Action类是Struts2框架中用于处理请求的核心组件,它包含了请求的处理逻辑。
当请求经过拦截器后,会被传递给相应的Action类进行处理。
在Action类中,我们可以编写业务逻辑代码,比如从数据库中获取数据、处理用户提交的表单数据等。
3. 结果的返回。
在Action类处理完请求后,会返回一个结果。
结果可以是一个JSP页面、一个JSON数据,甚至是一个文件流。
Struts2框架会根据Action类返回的结果类型,选择合适的结果视图进行展示。
这样,用户就能够看到请求处理的结果了。
4. 结果的展示。
最后,Struts2框架会将处理完的结果展示给用户。
如果是一个JSP页面,框架会将页面渲染出来;如果是一个JSON数据,框架会将数据返回给前端;如果是一个文件流,框架会将文件发送给用户。
这样,用户就能够看到请求处理的结果了。
总结。
综上所述,Struts2的工作流程包括拦截器的拦截、Action类的执行、结果的返回和结果的展示。
通过这样的流程,Struts2能够很好地处理用户的请求,并将处理结果展示给用户。
希望通过本文的介绍,能够让大家对Struts2的工作流程有一个更加清晰的认识。
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类的处理,最终到结果视图的渲染,整个流程清晰可见。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Struts2页面数据流向及获取方法
Struts2架构下的视图(浏览器页面)由JSP 组成,而这些JSP 又是通过Action 将他们衔接在一起,这样就形成了内容显示和业务逻辑的有机结合。
每个JSP 页面的数据不仅可以从上级Action 获得,而且还可以从全局Session 获得,也可以从在本页面实例化的Bean 中获得。
本文重点介绍JSP 从上级Action 获得数据和从Bean 获得数据的原理和方法。
上图是一个典型的Struts2框架下的JSP 、Bean 、Action 关系图,JSP 页面可以实例化多个Bean ,这些Bean 为该JSP 页面填充数据,JSP 也通过本页面Form 表单的Action 获取Form 表单的数据,然后传递给下级JSP 。
(一)JSP 获取Bean 属性值
如果JSP 页面需要动态获得一些内容的初始值来填充页面元素,则需要实例化一个Bean ,通过设置Bean 的某个属性值A ,并将这个属性值作为获取另外符合条件的属性值参数传递给Bean ,再获取这个属性值填充页面内容,具体编程步骤如下:
1.创建Bean
根据业务逻辑编写相应的Bean 代码,添加相应的属性即getter/setter 方法。
/** JSP
(含Form 及Action )
响应Action 的JSP 响应Action 的JSP Bean
Bean Bean
Bean Bean
Bean
*/
package com.crazyicelee.bean;
import java.util.List;
Import java.util.ArrayList;
/**
* @author crazyicelee
*
*/
public class book {
private List<String> mathBook;
private String nameP;
/**
* @param mathBook the mathBook to set
*/
public void setMathBook(List<String> mathBook) { this.mathBook = mathBook;
}
/**
* @return the mathBook
*/
public List<String> getMathBook() {
List<String> ll=new ArrayList<String>();
ll.add("一年级数学上册");
ll.add("二年级数学上册");
mathBook=ll;
return mathBook;
}
/**
* @param name the name to set
*/
public void setNameP(String name) {
P = name;
}
/**
* @return the name
*/
public String getNameP() {
nameP="skjhdfkjahsfdkj";
return nameP;
}
2.在JSP页面实例化该Bean并操作Bean属性
Struts2对Bean的操作非常简单,有现成的标签可以使用,主要有<s:bean>、<s:param>、<s:property>三个标签配合使用。
<s:bean id="id" name="class" />用来实例化一个Bean,id是在Bean标签外引用Bean属性时的实例标识,name是指定该Bean所在包及对应的class名称。
<s:param name="name" value="李征兵"/></s:param>用来给Bean的某个指定属性赋值,name是属性名称,value是给定的值,这个标签必须放在<s:bean>标签体内,在实际使用中发现如果使用value赋值则并没有赋值成功,而必须将值写到标签体内,才能够赋值成功,即<s:param name="name"/>李征兵</s:param>才能够赋值成功。
<s:property value="name"/>用来显示Bean某个指定属性的值,value的值是属性名称。
如果要显示的属性值在<s:bean>标签体外,则必须使用#这种表达式来指定是那个Bean的那个属性。
例如:
<!--实例化Bean并设定id-->
<s:bean id="b"name="com.crazyicelee.bean.book">
<!--给Bean的属性赋值-->
<s:param name="nameP">李征兵</s:param>
<!--在Bean内部显示属性值-->
<s:property value="nameP"></s:property>
</s:bean>
<!--在Bean外部显示属性值-->
<s:property value="#P"/>
显示集合类Bean属性的某个指定key的值获取方法如下:
<!--List、Array型属性获取方法,key为0的属性值-->
<s:property value="javaBook[0]"/>
<!--Map型属性获取方法,key为one的属性值-->
<s:property value="cBook['one']"/>
显示对象类属性的对象属性获取方法如下(其中:b是Bean的id,user是该Bean属性名称,name是对象属性的属性名称,可以以此类推实现多级属性取值):
<s:property value="#"/>
另外:针对对象型属性赋值必须先定义一个对象,然后把这个对象赋给该属
性对象,即对象类型的属性返回前必须实例化。
例如,下面的Bean getter方法:public User getUserObject() {
User u=new User("李","征兵");
userObject=u;
return userObject;
}
(一)响应Action的JSP获取Action属性值
Struts2将Action设置为一个特殊的Bean,所以Action也具备Bean的所有特性,也就是Action获取的数据也可以用Bean的操作方式操作。
例如:一个Action的响应JSP获取该Action从上级JSP页面的Form表单获取的数据就可以用下面的代码实现。
<s:property value="name"/>
1.集合类型属性的获取和显示
Bean的属性如果是集合类型的数据(List、Map、Array、Collection、Enumeration、Iterator等),则必须通过遍历器选取该属性的所有值。
遍历集合型属性值的所有元素代码如下:
<s:iterator value="javaBook">
<s:property/>
</s:iterator>
2.将Bean的属性值赋给JSP页面Form表单的一些字段作为初始值
Form表单的一些字段往往需要从服务器端动态获取一些值作为初始值,这时候就需要通过Bean的方式提供,当然也可以从上级Action中获取。
常见的如<s:checkboxlist>、<s:select>、<s:doubleselect>、<s:optiontransferselect>等标签中的list属性就从Bean取得初始值:
<s:checkboxlist list="#Y"name="done"label="权限"></s:checkboxlist>
其中#Y就是id为author的Bean中List类型的属性返回的值。