二、Struts的封装方法 & 其他介绍 & 注入方式详解

上次课内容回顾

　　Struts2的框架的概述

　　　　什么是Struts2

　　　　　　Struts2是一个基于MVC设计模式的web层的框架。

　　　　常见的web层框架

　　　　　　Struts2

　　　　　　Struts1

　　　　　　SpringMVC

　　　　　　Webwork

　　　　Web层框架

　　　　　　基于前端控制器模型

　　Struts2的入门程序

　　　　下载Struts2的开发包

　　　　解压Struts2开发环境

　　　　创建web项目，引入jar包

　　　　　　struts/apps/struts-blank.war/WEB-INF/lib/*.jar

　　　　编写JSP页面

　　　　编写Action类

　　　　配置Action类

　　　　配置核心过滤器

　　Struts2的执行流程

　　　　请求à核心过滤器（StrutsPrepareAndExecuteFilter）à执行一组拦截器（完成部分的功能）àActionàResult.

　　Struts2的常见配置

　　　　配置文件的加载顺序

　　　　　　后配置的配置文件中的常量的值会覆盖先配置的配置文件的常量的值。

　　　　Action的配置

　　　　　　package配置

　　　　　　　　name ：包名

　　　　　　　　extends ：继承

　　　　　　　　namespace ：名称空间，与action中name共同决定访问路径

　　　　　　　　abstract ：用于其他包的继承

　　　　　　action的配置

　　　　　　　　name ：与namespace共同决定访问路径

　　　　　　　　class ：Action类的全路径

　　　　　　　　method ：执行Action中的某个方法，默认值execute。

　　　　　　constant配置（default.properties）

　　　　　　　　设置Struts2的常量

　　　　　　include配置

　　　　　　　　分模块开发的使用

　　Struts2的Action的访问

　　　　Action的编写

　　　　　　Action是POJO类

　　　　　　Action实现Action接口

　　　　　　Action继承ActionSupport类

　　　　Action的访问

　　　　　　通过method属性配置

　　　　　　通过通配符的方式配置

　　　　　　动态方法访问的方式

1、Struts2的Servlet的API的访问

　　在使用Struts2的框架的过程中，发现 Struts2 和 Servlet 的 API 是解耦合的。

　　你会发现 Action 类里面，不想之前 Servlet 类一样，直接可以传过来 requese 和 response。如果是传过来的，在这类个里面就可以直接使用了；现在 Action 类里面写的那些方法是没有任何参数的，是没有 requese 和 response 的，这些是看不到的，可以视作为是解耦和的。

　　在实际开发中，经常使用到 Servlet 的 API，比如进行登录，将用户的信息保存到 Session 中，有的时候需要向页面输出一些内容，用到 response 对象。涉及到 Servlet 的 API 的访问。在实际开发过程当中，需要用到 Servlet 的这些 API。

1.1、完全解耦合的方式

　　编写 JSP

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>Struts2访问Servlet的API</h1>
<h3>方式一：完成解耦合的方式</h3>
<form action="${ pageContext.request.contextPath }/requestDemo1.action" method="post">
    姓名:<input type="text" name="name"/><br/>
    密码:<input type="password" name="password"><br/>
    <input type="submit" value="提交">
</form>

<h3>方式二：使用原生的方式访问</h3>
<form action="${ pageContext.request.contextPath }/requestDemo2.action" method="post">
    姓名:<input type="text" name="name"/><br/>
    密码:<input type="password" name="password"><br/>
    <input type="submit" value="提交">
</form>

<h3>方式三：接口注入的方式</h3>
<form action="${ pageContext.request.contextPath }/requestDemo3.action" method="post">
    姓名:<input type="text" name="name"/><br/>
    密码:<input type="password" name="password"><br/>
    <input type="submit" value="提交">
</form>
</body>
</html>

　　编写Action

package com.itheima.struts2.demo1;

import java.util.Arrays;
import java.util.Map;

import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;

/**
 * 访问Servlet的API方式一：完全解耦合的方式
 * @author jt
 *
 */
public class RequestDemo1 extends ActionSupport{
    
    @Override
    public String execute() throws Exception {
        // 一、接收参数：
        // 利用Struts2中的对象ActionContext对象.
        ActionContext context = ActionContext.getContext();
        // 调用ActionContext中的方法。
        // 类似于Map<String,String[]> request.getParameterMap();
        Map<String,Object> map = context.getParameters();
        for (String key : map.keySet()) {
            String[] values = (String[]) map.get(key);
            System.out.println(key+"    "+Arrays.toString(values));
        }
        
        // 二、向域对象中存入数据
        context.put("reqName", "reqValue");// 相当于request.setAttribute();
        context.getSession().put("sessName", "sessValue"); // 相当于session.setAttribute();
        context.getApplication().put("appName", "appValue"); // 相当于application.setAttribute();
        
        return SUCCESS;
    }
}

　　注意：这种方式只能获得代表request、session、application的数据的Map集合，不能操作这些对象的本身的方法。

1.2、使用Servlet的API的原生方式（直接获得对象）

　　编写JSP

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>Struts2访问Servlet的API</h1>
<h3>方式一：完成解耦合的方式</h3>
<form action="${ pageContext.request.contextPath }/requestDemo1.action" method="post">
    姓名:<input type="text" name="name"/><br/>
    密码:<input type="password" name="password"><br/>
    <input type="submit" value="提交">
</form>

<h3>方式二：使用原生的方式访问</h3>
<form action="${ pageContext.request.contextPath }/requestDemo2.action" method="post">
    姓名:<input type="text" name="name"/><br/>
    密码:<input type="password" name="password"><br/>
    <input type="submit" value="提交">
</form>

<h3>方式三：接口注入的方式</h3>
<form action="${ pageContext.request.contextPath }/requestDemo3.action" method="post">
    姓名:<input type="text" name="name"/><br/>
    密码:<input type="password" name="password"><br/>
    <input type="submit" value="提交">
</form>
</body>
</html>

　　编写Action

package com.itheima.struts2.demo1;

import java.util.Arrays;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.apache.struts2.ServletActionContext;

import com.opensymphony.xwork2.ActionSupport;
/**
 * 访问Servlet的API的方式二：原生的方式
 * @author jt
 *
 */
public class RequestDemo2 extends ActionSupport {

    @Override
    public String execute() throws Exception {
        // 一、接收数据
        // 直接获得request对象，通过ServletActionContext
        HttpServletRequest request = ServletActionContext.getRequest();
        Map<String, String[]> map = request.getParameterMap();
        for (String key : map.keySet()) {
            String[] values = map.get(key);
            System.out.println(key+"    "+Arrays.toString(values));
        }
        
        // 二、向域对象中保存数据
        // 向request中保存数据:
        request.setAttribute("reqName", "reqValue");
        // 向session中保存数据
        request.getSession().setAttribute("sessName", "sessValue");
        // 向application中保存数据
        ServletActionContext.getServletContext().setAttribute("appName", "appValue");
        return SUCCESS;
    }
}

　　注意：这种方式可以操作域对象的数据，同时也可以获得对象的方法。

1.3、接口注入的方式（少用）

　　让 Action 类去实现一些接口，然后通过接口当中的一些方法去设置具体的值。

　　编写 JSP

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>Struts2访问Servlet的API</h1>
<h3>方式一：完成解耦合的方式</h3>
<form action="${ pageContext.request.contextPath }/requestDemo1.action" method="post">
    姓名:<input type="text" name="name"/><br/>
    密码:<input type="password" name="password"><br/>
    <input type="submit" value="提交">
</form>

<h3>方式二：使用原生的方式访问</h3>
<form action="${ pageContext.request.contextPath }/requestDemo2.action" method="post">
    姓名:<input type="text" name="name"/><br/>
    密码:<input type="password" name="password"><br/>
    <input type="submit" value="提交">
</form>

<h3>方式三：接口注入的方式</h3>
<form action="${ pageContext.request.contextPath }/requestDemo3.action" method="post">
    姓名:<input type="text" name="name"/><br/>
    密码:<input type="password" name="password"><br/>
    <input type="submit" value="提交">
</form>
</body>
</html>

　　编写Action

package com.itheima.struts2.demo1;

import java.util.Arrays;
import java.util.Map;

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

import org.apache.struts2.interceptor.ServletRequestAware;
import org.apache.struts2.util.ServletContextAware;

import com.opensymphony.xwork2.ActionSupport;
/**
 * 访问Servlet的API的方式三：接口注入的方式
 * @author jt
 *
 */
public class RequestDemo3 extends ActionSupport implements ServletRequestAware,ServletContextAware{

    private HttpServletRequest request;
    private ServletContext context;

    public RequestDemo3() {
        super();
        System.out.println("RequestDemo3被创建了...");
    }

    @Override
    public String execute() throws Exception {
        // 一、接收参数
        // 通过接口注入的方式获得request对象。
        Map<String, String[]> map = request.getParameterMap();
        for (String key : map.keySet()) {
            String[] values = map.get(key);
            System.out.println(key+"    "+Arrays.toString(values));
        }
        // 二、向域对象中保存数据
        // 向request域中保存数据
        request.setAttribute("reqName", "reqValue");
        // 向session中保存数据:
        request.getSession().setAttribute("sessName", "sessValue");
        // 向 application（servletContext） 中保存数据:
        context.setAttribute("appName", "appValue");
        
        return super.execute();
    }

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

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

　　相对于前面的方式不是特变得好，每一次都需要实现接口，每个接口里面都需要提供相应的方法。

　　Servlet是单例的，多个程序访问同一个Servlet只会创建一个Servlet的实例。Action是多例的，一次请求，创建一个Action的实例（不会出现线程安全的问题）。在 Action 当中，提供了成员变量的话，不会出现线程安全问题；如果是在 Servlet 里面提供成员变量，就有可能出现线程安全问题。

2、Struts2的结果页面的配置

　　在进行跳转的时候，往 requese 域里面存值，在页面上也能取出来。说明里面进行页面跳转的时候采用的是转发的方式，如果想使用重定向，就需要通过 <result> 标签来进行配置。

2.1、结果页面的配置

2.1.1、全局结果页面

　　全局结果页面：全局结果页面指的是，在包中配置一次，其他的在这个包中的所有的action只要返回了这个值，都可以跳转到这个页面。

　　　　针对这个包下的所有的action的配置都有效。

2.1.2、局部结果页面

　　局部结果页面：局部结果页面指的是，只能在当前的action中的配置有效。

　　　　针对当前的action有效。

2.2、result标签的配置

2.2.1、result标签的配置

　　result标签用于配置页面的跳转。在result标签上有两个属性：

　　　　name属性：逻辑视图的名称。默认值：success，可以不用写

　　　　type属性：页面跳转的类型。

　　　　　　dispatcher ：默认值，请求转发。（Action 转发 JSP）

　　　　　　redirect ：重定向。（Action 重定向 JSP）

　　　　　　chain ：转发。（Action 转发 Action）

　　　　　　redirectAction ：重定向。（Action 重定向 Action）

　　　　　　stream ：Struts2 中提供文件下载的功能。

　　转发地址栏不会发生改变；requese 里保存的值一次有效，转发会丢失。

3、Struts2 的数据的封装

　　Struts2框架是一个web层框架（主要接收数据、处理数据），web层框架（框架：软件的办成品，完成一部分功能）。Struts2提供了数据封装的功能。

3.1、Struts2的数据封装（自动进行数据类型转换）

3.1.1、属性驱动：提供属性set方法的方式（不常用）

　　传的数据比较少的时候会用

　　编写 JSP

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="/struts-tags" prefix="s" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>Struts2的数据封装</h1>
<h3>方式一：属性驱动-提供set方法的方式</h3>
<s:fielderror/>
<form action="${ pageContext.request.contextPath }/userAction1.action" method="post">
    用户名:<input type="text" name="username"/><br/>
    密码:<input type="password" name="password"><br/>
    年龄:<input type="text" name="age"/><br/>
    生日:<input type="text" name="birthday"/><br/>
    工资:<input type="text" name="salary"/><br/>
    <input type="submit" value="提交">
</form>

<h3>方式二：属性驱动-在页面中提供表达式方式</h3>
<form action="${ pageContext.request.contextPath }/userAction2.action" method="post">
    用户名:<input type="text" name="user.username"/><br/>
    密码:<input type="password" name="user.password"><br/>
    年龄:<input type="text" name="user.age"/><br/>
    生日:<input type="text" name="user.birthday"/><br/>
    工资:<input type="text" name="user.salary"/><br/>
    <input type="submit" value="提交">
</form>

<h3>方式三：模型驱动-模型驱动方式</h3>
<form action="${ pageContext.request.contextPath }/userAction3.action" method="post">
    用户名:<input type="text" name="username"/><br/>
    密码:<input type="password" name="password"><br/>
    年龄:<input type="text" name="age"/><br/>
    生日:<input type="text" name="birthday"/><br/>
    工资:<input type="text" name="salary"/><br/>
    <input type="submit" value="提交">
</form>
</body>
</html>

　　编写 Action

package com.itheima.struts2.demo2;

import java.util.Date;

import com.itheima.struts2.domain.User;
import com.opensymphony.xwork2.ActionSupport;
/**
 * 数据封装方式一：提供属性的set方法的方式
 * @author jt
 *
 */
public class UserAction1 extends ActionSupport {
    // 提供了对应的属性
    private String username;
    private String password;
    private Integer age;
    private Date birthday;
    private Double salary;
    // 提供属性对应的set方法
    public void setUsername(String username) {
        this.username = username;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }
    
    
    @Override
    public String execute() throws Exception {
        // 接收数据:
        System.out.println(username);
        System.out.println(password);
        System.out.println(age);
        System.out.println(birthday);
        System.out.println(salary);
        // 封装数据:
        User user = new User();
        user.setUsername(username);
        user.setPassword(password);
        user.setAge(age);
        user.setBirthday(birthday);
        user.setSalary(salary);
        return NONE;
    }
}

3.1.2、属性驱动：页面中提供表达式方式

　　编写 JSP

　　编写 Action

3.1.3、模型驱动：采用模型驱动方式（最常用）

　　模型驱动方式最常用的方式：

　　　　缺点：只能同时向一个对象中封装数据。

　　使用第二种可以向多个对象中同时封装数据：

3.2、关于INPUT逻辑视图

3.21、INPUT的逻辑视图的配置

　　Action接口中提供了五个逻辑视图的名称：

　　　　SUCCESS

　　　　ERROR

　　　　INPUT ：input在某些拦截器中会使用。（很多情况下汇报 Input 错误）

　　　　NONE

4、Struts2的复杂类型的数据封装

　　在实际开发中，有可能遇到批量向数据库中插入记录，需要在页面中将数据封装到集合中。

4.1、Struts2的复杂类型的数据封装

4.1.1、封装数据到List集合中

　　编写JSP

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>Struts2的复杂类型的数据封装</h1>
<h3>封装到List集合中：批量插入商品</h3>
<form action="${ pageContext.request.contextPath }/productAction1.action" method="post">
    商品名称:<input type="text" name="products[0].name"><br/>
    商品价格:<input type="text" name="products[0].price"><br/>
    商品名称:<input type="text" name="products[1].name"><br/>
    商品价格:<input type="text" name="products[1].price"><br/>
    商品名称:<input type="text" name="products[2].name"><br/>
    商品价格:<input type="text" name="products[2].price"><br/>
    <input type="submit" value="提交">
</form>
<h3>封装到Map集合中：批量插入商品</h3>
<form action="${ pageContext.request.contextPath }/productAction2.action" method="post">
<!-- map['key']  是 map 集合的 key-->

    商品名称:<input type="text" name="map['one'].name"><br/>
    商品价格:<input type="text" name="map['one'].price"><br/>
    商品名称:<input type="text" name="map['two'].name"><br/>
    商品价格:<input type="text" name="map['two'].price"><br/>
    商品名称:<input type="text" name="map['three'].name"><br/>
    商品价格:<input type="text" name="map['three'].price"><br/>
    <input type="submit" value="提交">
</form>
</body>
</html>

　　编写Action

package com.itheima.struts2.demo3;

import java.util.List;

import com.itheima.struts2.domain.Product;
import com.opensymphony.xwork2.ActionSupport;
/**
 * 复杂类型的数据封装：封装到List集合
 * @author jt
 *
 */
public class ProductAction1 extends ActionSupport {
    
    private List<Product> products;
    // 提供集合的set方法:
    public void setProducts(List<Product> products) {
        this.products = products;
    }
    public List<Product> getProducts() {
        return products;
    }

    @Override
    public String execute() throws Exception {
        for (Product product : products) {
            System.out.println(product);
        }
        return NONE;
    }

    
}

4.1.2、封装数据到Map集合中

　　编写Action

package com.itheima.struts2.demo3;

import java.util.Map;

import com.itheima.struts2.domain.Product;
import com.opensymphony.xwork2.ActionSupport;
/**
 * 复杂数据类型的封装：封装到Map集合
 * @author jt
 *
 */
public class ProductAction2 extends ActionSupport {

    private Map<String,Product> map;
    
    public Map<String, Product> getMap() {
        return map;
    }

    public void setMap(Map<String, Product> map) {
        this.map = map;
    }

    @Override
    public String execute() throws Exception {
        for (String key : map.keySet()) {
            Product product = map.get(key);
            System.out.println(key+"    "+product);
        }
        return NONE;
    }
}

posted @ 2018-10-06 16:14 昱晟阅读(350) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

昱晟

二、Struts的封装方法 & 其他介绍 & 注入方式详解

上次课内容回顾

1、Struts2的Servlet的API的访问

1.1、完全解耦合的方式

1.2、使用Servlet的API的原生方式（直接获得对象）

1.3、接口注入的方式（少用）

2、Struts2的结果页面的配置

2.1.1、全局结果页面

2.2、result标签的配置

2.2.1、result标签的配置

3、Struts2 的数据的封装

3.1、Struts2的数据封装（自动进行数据类型转换）

3.1.1、属性驱动：提供属性set方法的方式（不常用）

3.1.2、属性驱动：页面中提供表达式方式

3.1.3、模型驱动：采用模型驱动方式（最常用）

3.2、关于INPUT逻辑视图

3.21、INPUT的逻辑视图的配置

4、Struts2的复杂类型的数据封装

4.1、Struts2的复杂类型的数据封装

4.1.1、封装数据到List集合中

公告