struts2学习笔记 -- day04 ServletAPI、参数封装的方式

最新推荐文章于 2024-04-05 20:41:44 发布

DJTUDaker

最新推荐文章于 2024-04-05 20:41:44 发布

阅读量346

点赞数

分类专栏： ssh框架

本文链接：https://blog.csdn.net/wingzhezhe/article/details/76711399

版权

ssh框架专栏收录该内容

36 篇文章 0 订阅

订阅专栏

一、全局结果视图的配置

<package name="myDefault" extends="struts-default" abstract="true">
		<!-- 配置全局结果视图 -->
		<global-results>
			<result name="login">/login.jsp</result>
			<result name="success" type="dispatcher">/success.jsp</result>
		</global-results>
	</package>
	
	<package name="p1" extends="myDefault" namespace="/n1">
		<action name="demo1" class="cn.itcast.web.action.Demo1Action" method="demo1">
			<!-- result标签：
					作用：配置结果视图的地址。
					属性：
					  name：用于和动作方法的返回值比较，当一致时前往指定的位置。
					  type：用何种方式前往（请求转发，重定向）
					  	常用的取值：
					  		dispatcher：请求转发到一个指定jsp页面（默认值）
					  		redirect：重定向到一个指定的jsp页面或者是一个action
					  		redirectAction：重定向到一个指定的action
			-->
			<result name="login">/success.jsp</result>
			<result name="error" type="redirect">/error.jsp</result>
			<result name="findAll" type="redirect">findAllCust</result>
			<result name="findAll" type="redirectAction">findAllCust</result>
		</action>
		
		
		<action name="demo2" class="cn.itcast.web.action.Demo1Action" method="demo2">
		</action>
		
		
		<action name="demo3" class="cn.itcast.web.action.Demo1Action" method="demo3">
		</action>

二、使用servletAPI的三种方式

1、什么是servletAPI

访问的就是Servlet规范中的常用对象：ServletContext、HttpSession、HttpServletRequest、HttpServletResponse

2、第一种方式

使用ServletActionContext对象获取，实际开发中最简单的方式。ServletActionContext是一个工具类，里面包含了一些可以快速获得servletAPI的静态方法

	public String demo1(){
		request = ServletActionContext.getRequest();
		response = ServletActionContext.getResponse();
		application = ServletActionContext.getServletContext();
		session = request.getSession();
		System.out.println(request);
		System.out.println(response);
		System.out.println(application);
		System.out.println(session);
		return SUCCESS;
	}

3、第二种方式

通过实现接口的方式，想用哪个对象，就实现响应对象的接口

public class Demo2Action extends ActionSupport implements ServletRequestAware,ServletResponseAware,ServletContextAware {

	private ServletContext application = null;
	private HttpSession session = null;
	private HttpServletRequest request = null;
	private HttpServletResponse response = null;
	
	/**
	 * 动作方法
	 * 	用于处理请求的
	 * @return
	 */
	public String demo2(){
		System.out.println(request);
		System.out.println(response);
		System.out.println(application);
		session = request.getSession();
		System.out.println(session);
		return SUCCESS;
	}

	@Override
	public void setServletRequest(HttpServletRequest request) {
		this.request = request;
	}

	@Override
	public void setServletResponse(HttpServletResponse response) {
		this.response = response;
	}

	@Override
	public void setServletContext(ServletContext application) {
		this.application = application;
	}

}

4、第三种方式

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.struts2.ServletActionContext;
import org.apache.struts2.StrutsStatics;

import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
/**
 * 访问ServletAPI
 * 	访问的就是Servlet规范中的常用对象：
 * 		ServletContext
 * 		HttpSession
 * 		HttpServletRequest
 * 		HttpServletResponse
 *
 * 	第三种：
 * 		使用ActionContext对象获取。			
 *	通过翻看struts2源码得知：
 *		不管是第一种方式，还是第二种方式，他们用的都是ActionContext对象中的get(key)方法来获取的
 *		所以说在struts2中获取ServletAPI的方式只有一个。
 * @author zhy
 * 
 * 细节：注意这四个对象中有一个已经和我们原来不一样了，找出来，记住。
 * 
 * 	org.apache.struts2.dispatcher.StrutsRequestWrapper@8ed129		它变了，它被包装
	org.apache.catalina.connector.ResponseFacade@461aa2
	org.apache.catalina.core.ApplicationContextFacade@7e83df
	org.apache.catalina.session.StandardSessionFacade@3b102
 * 	
 */
public class Demo3Action extends ActionSupport implements StrutsStatics{

	private ServletContext application;
	private HttpSession session;
	private HttpServletRequest request;
	private HttpServletResponse response;
	
	/**
	 * 动作方法
	 * 	用于处理请求的
	 * @return
	 */
	public String demo3(){
		ActionContext context = ActionContext.getContext();
		request = (HttpServletRequest) context.get(HTTP_REQUEST);
		response = (HttpServletResponse) context.get(HTTP_RESPONSE);
		application = (ServletContext) context.get(SERVLET_CONTEXT);
		session = request.getSession();
		System.out.println(request);
		System.out.println(response);
		System.out.println(application);
		System.out.println(session);
		return SUCCESS;
	}

}

三、属性驱动封装参数

1、没有实体类的属性驱动

（1）、要求

实体类中私有成员必须提供public的get/set方法

实体类中属性必须和表单的input标签name属性取值一致。

（2）、分析

封装请求参数的拦截器是：params

拦截器的封装规则：

使用表单中name属性的取值和指定位置中的get/set方法保持一致。

（3）、JSP页面

<%--1、属性驱动封装：
	需要使用到属性的get/set方法
	情况一：没有独立的实体类
	--%>

<form action="${pageContext.request.contextPath}/demo1" method="post">
	用户名：<input type="text" name="name"/><br/>
	年龄：<input type="text" name="age"/><br/>
	<input type="submit" value="保存">
</form>

（4）、动作类

import com.opensymphony.xwork2.ActionSupport;
/**
 * 请求参数的封装：
 * 	属性驱动之：
 * 		没有实体类(动作类和模型在一起)
 * 要求：
 * 	1、实体类中私有成员必须提供public的get/set方法
 * 	2、实体类中属性必须和表单的input标签name属性取值一致。（找的是get/set方法后面的部分）
 * @author zhy
 *	封装请求参数的拦截器是：params
 *		它的封装规则只有一个：
 *				使用表单中name属性的取值和指定位置中的get/set方法保持一致。
 *				在动作类和模型在一起的这种情况下：
 *						指定位置：指的就是动作类中的属性。
 *						
 */
public class Demo1Action extends ActionSupport {
	
	private String name = null;
	private Integer age = null;
	
	public String demo1(){
		System.out.println(name+","+age);
		return SUCCESS;
	}
	
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	
}

2、有实体类的属性驱动

（1）、要求

动作类中要提供实体对象的get/set方法

实体类中要提供属性的get/set方法

表单中要使用OGNL表达式

（2）、实体类

import java.io.Serializable;
/**
 *  一个用户的实体类
 * @author zhy
 *
 */
public class User implements Serializable {
	
	private String name;
	private Integer age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "User [name=" + name + ", age=" + age + "]";
	}
	
	
}

（3）、JSP代码

<%--2、属性驱动封装:
		情况二：动作类和模型分开
此时，表单name属性的取值，看上去是一个普通的字符串，而实际上已经不是了。
它已经变成了OGNL表达式。
	Object Graphic Naviation Language
	对象		图		导航			语言
它是struts2框架的默认表达式语言。
我们使用OGNL是取值用。
而框架使用OGNL是为我们赋值的。
--%>

<form action="${pageContext.request.contextPath}/demo2" method="post">
	用户名：<input type="text" name="user.name"/><br/>
	年龄：<input type="text" name="user.age"/><br/>
	<input type="submit" value="保存">
</form>

（4）、动作类代码

import com.opensymphony.xwork2.ActionSupport;

import cn.itcast.domain.User;
/**
 * 请求参数的封装：
 * 	属性驱动之：
 * 		有实体类(动作类和模型分开)
 * 要求：
 * 	1、动作类中要提供实体对象的get/set方法
 * 	2、实体类中要提供属性的get/set方法
 * 	3、表单中要使用OGNL表达式
 * @author zhy
 *	封装请求参数的拦截器是：params
 *		它的封装规则只有一个：
 *				使用表单中name属性的取值和指定位置中的get/set方法保持一致。
 *				在动作类和模型分开的这种情况下：
 *						指定位置：
 *							有两部分：
 *								第一部分是动作类
 *								第二部分是实体类
 *	细节：
 *		表单只能为我们提供有意义的三种数据类型。(无意义的："" null)
 *		String		request.getParameter(name);
 *		String[]	request.getParameterValues(name);
 *		File		request.getInputStream();
 */
public class Demo2Action extends ActionSupport {
	
	private User user = new User();
	
	public String demo2(){
		System.out.println(user);
		return SUCCESS;
	}

	public User getUser() {
		System.out.println("getUser");
		return user;
	}

	public void setUser(User user) {
		System.out.println("setUser");
		this.user = user;
	}

}

细节：当我们没有 new User() 对象时候，get/set 方法执行的次数，当我们有 new User() 的操作时，打印的只有两个 getUser

四、模型驱动封装请求参数

1、要求

动作类必须实现 ModelDriven 接口

动作类中需要定义一个实体类对象，并且必须实例化

提供接口中抽象方法的实现，并且返回实体类对象的模型

表单元素的name取值必须和实体类中的 get/set 后面的名称相同

2、注意

模型驱动情况下没有必要提供模型的 set/get 方法

3、实体类

import java.io.Serializable;
/**
 *  一个用户的实体类
 * @author zhy
 *
 */
public class User implements Serializable {
	
	private String name;
	private Integer age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "User [name=" + name + ", age=" + age + "]";
	}
	
	
}

4、JSP代码

<%--模型驱动 --%>
<form action="${pageContext.request.contextPath}/demo3" method="post">
	用户名：<input type="text" name="name"/><br/>
	年龄：<input type="text" name="age"/><br/>
	<input type="submit" value="保存">
</form>

5、动作类代码

import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;

import cn.itcast.domain.User;
/**
 * 请求参数的封装：
 * 		模型驱动
 * 
 * 要求：
 * 	1、动作类必须实现一个ModelDriven接口
 * 	2、在动作类中定义一个实体类对象，并且必须实例化。
 * 	3、提供接口中抽象方法的实现，并返回模型
 * 	4、表单元素的name取值必须和实体类中的get/set方法后面的部分保持一致
 * 注意：
 * 	模型驱动的情况下，没有必要提供模型的get/set方法。
 * @author zhy
 */
public class Demo3Action extends ActionSupport implements ModelDriven<User> {
	
	private User user = new User();
	
	@Override
	public User getModel() {
		return user;
	}
	
	public String demo3(){
		System.out.println(user);
		return SUCCESS;
	}
}

五、复杂类型的参数封装

1、什么是复杂类型的参数封装

复杂类型的封装包含了List结构和Map结构的封装，不管是List结构还是Map结构，他使用的规则都是和属性驱动的有实体类方法一样的。

2、List结构的参数封装

（1）、动作类

public class Demo4Action extends ActionSupport  {
	
	private List<User> users;
	
	
	public String demo4(){
		System.out.println(users);
		return SUCCESS;
	}


	public List<User> getUsers() {
		return users;
	}

	public void setUsers(List<User> users) {
		this.users = users;
	}	
}

（2）、JSP代码

<%--复杂类型的封装：List结构 --%>
<form action="${pageContext.request.contextPath}/demo4" method="post">
	用户名1：<input type="text" name="users[0].name"/><br/>
	年龄1：<input type="text" name="users[0].age"/><br/>
	用户名2：<input type="text" name="users[1].name"/><br/>
	年龄2：<input type="text" name="users[1].age"/><br/>
	用户名3：<input type="text" name="users[2].name"/><br/>
	年龄3：<input type="text" name="users[2].age"/><br/>
	<input type="submit" value="保存">
</form>

（3）、说明

user[0].name：

其中user是动作类中对应的集合的对象的名称；

[ ]中是要放在集合中的位置，从0开始；

name是集合中每一个对象中所具有的属性

3、Map结构的参数封装

（1）、动作类

public class Demo5Action extends ActionSupport  {
	
	private Map<String,User> users;
	
	public String demo5(){
		System.out.println(users);
		return SUCCESS;
	}

	public Map<String, User> getUsers() {
		return users;
	}
	public void setUsers(Map<String, User> users) {
		this.users = users;
	}	
}

（2）、JSP代码

<%--复杂类型的封装：Map结构 --%>
<form action="${pageContext.request.contextPath}/demo5" method="post">
	用户名1：<input type="text" name="users['key1'].name"/><br/>
	年龄1：<input type="text" name="users['key1'].age"/><br/>
	用户名2：<input type="text" name="users['key2'].name"/><br/>
	年龄2：<input type="text" name="users['key2'].age"/><br/>
	用户名3：<input type="text" name="users['key3'].name"/><br/>
	年龄3：<input type="text" name="users['key3'].age"/><br/>
	<input type="submit" value="保存">
</form>

（3）、说明

users['key1'].name：

users：指的是动作类中对应的map集合的名称

['key1']： key1指的是map集合中的key

name：指的是map集合中对应的key1所指向的value对象中的属性名称