logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

Struts2的简单使用（四）action向页面传值

 春和秋荣 2020-04-08
在这里我要说一下在action中怎么向页面传值~

在action中依然可以像以前在servlet里面一样,使用request、session、application向页面传送值，除此之外,action里面还有俩个独有的传值方式:ValueStack  ActionContext

一,先来说说这俩个独有的传值方式~

1.ValueStack的特点(值栈)：

1.把一个对象放到vs里面之后,我们从这个vs中是拿不到这个对象的,但是我们可以直接拿到这个对象里面的属性以及属性值.
2.从vs中拿值的时候,是从vs中的property name这一个列来拿的,拿到的是property value这一列的值.(在debug中的vs视图可以看这些列)
所以如果我们通过vs把一个值传到页面,我们不能直接把这个值放到vs里,因为这样拿不到,我们应该把这个值放到一个对象的属性里面,然后再把这个对象放vs中,这个时候就可以通过vs拿到这个对象的属性了,也就是我们要传的值.
3.每次浏览器发送一个新的请求,都会生成一个新的ValueStack对象,上一次的ValueStack对象就没了,找不到了.(类似之前学习的request对象的特点)
4.每次创建一个新的ValueStack对象后,会把这个对象放到ActionContext里面.

2.ActionContext的特点

1.向ac里面放值的时候是通过key-value的形式存放的,key是String类型,value是Object类型,取值的是同样通过key拿到value.

2.struts框架默认向这个对象里面存放的对象(数据)很多,包括request、session、application、ValueStack、parameters等

 3.每次请求都会创建一个新的ActionContext对象(每次请求打印出ac的地址值可以看出来)

接下来就代码编写~

第一步：

ValueStack是一个接口:com.opensymphony.xwork2.util.ValueStack

ActionContext是一个类:com.opensymphony.xwork2.ActionContext
我们可以使用这个俩个类型的对象,从action里面把值带到页面.

代码编写如下：ValueStackAction类

  1. public class ValueStackAction extends ActionSupport{ 
  5. 	private static final long serialVersionUID = 1L;
  9. 	public String execute(){
  10. 		//测试action，ValueStack，
  11. 		ActionContext context=ActionContext.getContext();
  12. 	        ValueStack stack=context.getValueStack();
  13. 		System.out.println("action:"+this);
  14. 		System.out.println("context:"+context);
  15. 		System.out.println("stack:"+stack);
  17. 		return SUCCESS;
  18. 	}
  19. }

第二步：

我们在页面中,可以通过一个struts2的标签来看到action传到页面中的值:
<s:debug/>

页面引入标签库:<%@taglib uri="/struts-tags" prefix="s" %>

代码如下：在页面index.jsp中写标签~

  1. <%@ page language="java" contentType="text/html; charset=UTF-8"
  2.     pageEncoding="UTF-8"%>
  3.     <span style="color:#ff0000;"><%@taglib uri="/struts-tags" prefix="s"%></span>
  4. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www./TR/html4/loose.dtd">
  5. <html>
  6. <head>
  7. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  8. <title>index.jsp</title>
  9. </head>
  1. <body>
  2.       <h4>index.jsp</h4>
  3.       <span style="color:#ff0000;"><s:debug></s:debug> </span>
  5. </body>
第三步：

当前action进行跳转的时候,struts2框架会自动的把当这个action对象本身分别放到ValueStack和ActionContext这个俩个对象,然后struts2框架再把这个俩个对象传给页面,所以我们在页面中只要通过这个俩个对象,就可以拿到之前放进去的值.(在页面的debug标签中,可以看到struts框架放到这俩个对象里面的action)

配置文件struts.xml配置这个Action：

  1. 		<action name="vs"
  2. 		    class="com.xu.struts2.web.action.ValueStackAction">
  3. 			<result name="success" >/WEB-INF/jsp/index.jsp</result>
  4. 		</action>
在浏览器中输入localhost:9999/Struts2/vs.action，效果图如下：



第四步：

除了struts框架自动的像ValueStack和ActionContext里面放值以外,我们还可以手动的向这俩个对象里面放值.
 (在execute方法中拿到这个俩个对象就可以向里面放值了)

代码如下：

ValueStackAction类--get和set方法一定要写

  1. public class ValueStackAction extends ActionSupport{ 
  3. 	private String name;
  4. 	private int age;
  5. 	private Boolean gender;
  7. 	private static final long serialVersionUID = 1L;
  9. 	public String execute(){
  10. 		//测试action，ValueStack，
  11. 		name="tee";
  12. 		age=12;
  13. 		gender=true;
  14. 		ActionContext context=ActionContext.getContext();
  15. 	        ValueStack stack=context.getValueStack();
  17. 		System.out.println("action:"+this);
  18. 		System.out.println("context:"+context);
  19. 		System.out.println("stack:"+stack);
  21. 		return SUCCESS;
  22. 	}
  23. 	public String getName() {
  24. 		return name;
  25. 	}
  26. 	public void setName(String name) {
  27. 		this.name = name;
  28. 	}
  29. 	public int getAge() {
  30. 		return age;
  31. 	}
  32. 	public void setAge(int age) {
  33. 		this.age = age;
  34. 	}
  35. 	public Boolean getGender() {
  36. 		return gender;
  37. 	}
  38. 	public void setGender(Boolean gender) {
  39. 		this.gender = gender;
  40. 	}
  41. }
页面index.jsp也要添加几行代码，用到了EL表达式~ 
  1. <body>
  2.       <h4>index.jsp</h4>
  3.        <hr>
  4.       name:${name } <br>
  5.       age:${age } <br>
  6.       gender:${gender }<br>
  7.       <hr> 
  8.       <s:debug></s:debug> 
  10. </body>
效果图如下：


第五步：
向ac和vs中主动放值
       向ActionContext对象中放值:
        context.put(String,Object);
       context.put("hello","world");
       
       向ValueStack对象中放值:
        User user = new User();
        stack.push(user);

只是需要改写ValueStack~，代码如下：

  1. public class ValueStackAction extends ActionSupport{ 
  3. 	private String name;
  4. 	private int age;
  5. 	private Boolean gender;
  7. 	private static final long serialVersionUID = 1L;
  9. 	private User user;
  11. 	public String execute(){
  13. 		//测试action，ValueStack，
  14. 		name="tee";
  15. 		age=12;
  16. 		gender=true;
  17. 		user=new User(1L, "larr", 12, false, "123");
  20. 		ActionContext context=ActionContext.getContext();
  21. 	        ValueStack stack=context.getValueStack();
  23. 	        context.put("hello", "world");
  24. 	        stack.push(user);//手动把user对象放入值桟
  25. 		System.out.println("action:"+this);
  26. 		System.out.println("context:"+context);
  27. 		System.out.println("stack:"+stack);
  29. 		return SUCCESS;
  30. 	}
  31. 	public String getName() {
  32. 		return name;
  33. 	}
  34. 	public void setName(String name) {
  35. 		this.name = name;
  36. 	}
  37. 	public int getAge() {
  38. 		return age;
  39. 	}
  40. 	public void setAge(int age) {
  41. 		this.age = age;
  42. 	}
  43. 	public Boolean getGender() {
  44. 		return gender;
  45. 	}
  46. 	public void setGender(Boolean gender) {
  47. 		this.gender = gender;
  48. 	}
  49. 	public User getUser() {
  50. 		return user;
  51. 	}
  52. 	public void setUser(User user) {
  53. 		this.user = user;
  54. 	}
  55. }
效果图如下：


注意:使用vs和ac传值的时候,要使用服务器内部跳转的方式.

总结：
客户端发送一个请求到action,struts2框架会创建俩个对象:ValueStack对象和ActionContext对象,action执行完进行跳转的的同时,struts2框架会这个当前执行的action对象分别放到ValueStack对象和ActionContext对象里面,在页面中通过debug标签可以到放到这俩个对象里面的action对象.所以最终我们在页面就可以通过ValueStack对象或者ActionContext对象拿到action里面的属性值(get/set方法)

二,再来说说在action中访问web元素(request session application)

1.在struts2框架中,这三个对象分别都有俩个类型:原类型和Map类型(这个对象都在ActionContext里面)

2.原类型: (指的就是之前在servlet中使用的对象类型)
       HttpServletRequest request
       HttpSession  session
       ServletContext     application
    Map类型:
       Map<String,Object> request
       Map<String,Object> session
       Map<String,Object> application

3.在使用的时候,我们可以选择使用原类型的request或者选择使用Map类型的request.(session和application也是这样的情况)
4.不管是原类型的还是Map类型的对象,都是被struts2框架默认存放到了ActionContext对象里面.(使用debug标签可以看到)

5.原类型的和Map类型的关系.
   Map<String,Object> session1 = ActionContext.getContext().getSession();
   HttpSession session2 = ServletActionContext.getRequest().getSession();
      a.使用Map类型的对象,可以降低代码中对  servlet的API的依赖(降耦)
      b.我们使用原类型大多时候也是存值和取值,
      而且原类型里面本身也是封装了Map对象。
      所以我们使用Map类型的对象也可以完成存值和取值.
      c.Map类型的request对象里面的值(k-v),其实就是复制的原类型的
      request对象里面的值(k-v),当然原类型的request对象里面除了k-v类型的键值对以外,
   还有其他的属性和方法,因为它毕竟是HttpServletRequest类型的对象.
      d.所以原类型的request和Map类型的request对象,我们可以理解为他们里面的值(k-v)是相通的,相通的意思就是:这个对象里面有什么值,那个对象里就也
 会什么值.所以我们在action里面向Map类型的对象中存放一个值(k-v),将来在页面中同样是可以使用原类型的request对象那这个值(k-v)取出来的.    
      注:session和application的情况也是一样的道理.

 
原类型和Map类型相当于下面这个例子:
    张三手里有一个钱包,我们平时都是把钱给张三,张三再把钱放到钱包里面, 我们拿钱的时候也是通过张三,张三从钱包里拿出钱,然后再把钱给我们.现在我们不想这么做,觉得很麻烦,我们直接从张三手里抢过来这个钱包,我们存钱和拿钱都直接操作这个钱包原类型的request就相当于这里的张三,Map类型对象就相当于这个钱包

接下来就代码编写~

第一步：

获取Map类型对象

第一种方式:自己在方法中主动获得

  1. 		   ActionContext ac = ActionContext.getContext();
  2. 		   //获得Map类型request
  3. 		   Map<String,Object> request = 
  4. 				 (Map<String, Object>) ac.get("request");
  6. 		   //获得Map类型session
  7. 			   Map<String, Object> session = ac.getSession();
  9. 		   //获得Map类型application
  10. 		   Map<String, Object> application = ac.getApplication();
第二种方式:让struts2框架把Map类型的对象自动的放到action里(依赖注入)
   第一种方式是自己主动拿到这个对象,第二种方式是自己被动接受这个对象.
   实现三个接口,分别可以让struts2框架把Map类型的request、session、application对象通过调用实现的接口中方法传给我们的action,在action里面我们只要接收这三个对象就可以了,那到后可以直接使用.三个接口依次 为:RequestAware,SessionAware,ApplicationAware

第一种方式-主动方式~

代码如下：

WebAction：

  1. public class WebAction extends ActionSupport {
  4. 	private static final long serialVersionUID = 1L;
  7. 	@Override
  8. 	public String execute() throws Exception {
  9. 		//主动
  10. 		ActionContext context=ActionContext.getContext();
  11. 		//ServletContext 实际存放值的地方
  12. 		Map<String,Object>application=context.getApplication();
  13. 		//HttpSession实际存放值的地方
  14. 		Map<String, Object>session=context.getSession();
  15. 		session.put("sessionKey", "sessionValue...");
  16. 		application.put("applicationKey", "applicationValue...");	
  18. 		return SUCCESS;
  19. 	}
  22. }
在struts.xml要配置这个action，代码如下： 
  2. 		<action name="web" class="com.xu.struts2.web.action.WebAction">
  3. 		    <result name="success" >/WEB-INF/jsp/index.jsp</result>
  4. 		</action>

在index.jsp这个页面要接收值~ 
  1. <body>
  2.       <h4>index.jsp</h4>
  3.        <hr>
  4.       session:${sessionScope.sessionKey }<br>
  5.       application:${applicationScope.applicationKey }<br>   
  6.       <hr> 
  8. </body>
在浏览器中输入localhost:9999/Struts/web.action,效果图如下：


第二种方式-被动方式~

代码如下：

WebAction类：

  1. public class WebAction extends ActionSupport implements RequestAware,SessionAware,ApplicationAware{
  4. 	private static final long serialVersionUID = 1L;
  5. 	private Map<String, Object> request;
  6. 	private Map<String, Object> session;
  7. 	private Map<String, Object> application;
  9. 	@Override
  10. 	public String execute() throws Exception {
  11. 		//页面中用原类型的对象去正常值就可以了
  12. 		request.put("MyName", "tom");
  13. 		session.put("YourName", "zhansan");
  14. 		application.put("HerName", "lily");
  15. 		return SUCCESS;
  16. 	}
  18. 	public void setRequest(Map<String, Object> request) {
  19. 		this.request = request;
  20. 	}
  22. 	public void setSession(Map<String, Object> session) {
  23. 		this.session = session;
  24. 	}
  26. 	public void setApplication(Map<String, Object> application) {
  27. 		this.application = application;
  28. 	}
  29. }

在index.jsp要接收从action传来的值，代码如下：

  1. <body>
  2.       <h4>index.jsp</h4>
  3.        <hr>
  4.       request:${requestScope.MyName }<br>
  5.       session:${sessionScope.YourName }<br>
  6.       application:${applicationScope.HerName }<br> 
  7.       <hr> 
  9. </body>
效果图如下：


第二步：

获取原类型对象

第一种方式:自己主动获得
   获得原类型request对象
   HttpServletRequest req = ServletActionContext.getRequest();
   获得原类型response对象
   HttpServletResponse res = ServletActionContext.getResponse();
   获得原类型session对象
   HttpSession sess = req.getSession();
   获得原类型application对象
   ServletContext app1 = sess.getServletContext();
   或者
   ServletContext app2 = ServletActionContext.getServletContext();
     
   第二种方式:自己被动接收
   struts2框架中提供了一个接口,可以用来获得原类型的request对象,
   因为通过原类型的request对象就可以获得原类型的session对象和原
   类型的application对象

   实现接口:ServletRequestAware,然后struts2框架会通过action所实现的抽象方法,把原类型的request对象自动放到action里面.
   类似的还有一接口:ServletResponseAware,和上面的效果、用法是一样的。

代码编写如下：

第一种方式-主动获得~

Web2Action类：

  1. public class Web2Action extends ActionSupport {
  3. 	public String execute(){
  4. 		//主动获取
  5. 		ServletContext s_application=ServletActionContext.getServletContext();
  6. 		HttpServletRequest s_request=ServletActionContext.getRequest();
  7. 		HttpSession s_session=s_request.getSession();
  8. 		s_application.setAttribute("application", "zhangsan");
  9. 		s_request.setAttribute("request", "lili");
  11. 		return SUCCESS;
  12. 	}
  14. }
在struts.xml配置这个action： 
  2. 		<action name="web2" class="com.xu.struts2.web.action.Web2Action">
  3. 		    <result name="success" >/WEB-INF/jsp/index.jsp</result>
  4. 		</action>
在页面index.jsp接收这个参数： 
  1. <body>
  2.       <h4>index.jsp</h4>
  3.        <hr>
  4.       request:${requestScope.request }<br>
  5.       session:${sessionScope.session }<br>
  6.       application:${applicationScope.application }<br>
  7.       <hr> 
  9. </body>
在浏览器中输入localhost:9999/Struts2/web2.action

效果图如下：


第二种方式-被动方式~

实现接口

代码如下：

Web2Action类：

  1. public class Web2Action extends ActionSupport 
  2. implements ServletRequestAware,ServletContextAware{
  5. 	private HttpServletRequest request;
  6. 	private ServletContext application;
  7. 	public String execute(){
  8. 		//被动获取
  9. 		HttpSession session=request.getSession();
  10. 		request.setAttribute("request", "00requsetKey00");
  11. 		session.setAttribute("session","00sessionKey00");
  12. 		application.setAttribute("application", "00applicationKey00");
  13. 		return SUCCESS;
  14. 	}
  17. 	@Override
  18. 	public void setServletRequest(HttpServletRequest request) {
  19. 		// TODO Auto-generated method stub
  20. 		this.request=request;
  21. 	}
  23. 	@Override
  24. 	public void setServletContext(ServletContext application) {
  25. 		// TODO Auto-generated method stub
  26. 		this.application=application;
  27. 	}
  29. }
别的什么都不变~

效果图如下：


好了，到这里action向页面传值就写完了~

有什么疑问的可以问我~

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： 春和秋荣 > 《SSM框架》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多