Struts2

最新推荐文章于 2023-09-21 16:35:24 发布

为什么会这样1994

最新推荐文章于 2023-09-21 16:35:24 发布

阅读量1k

点赞数 10

分类专栏：框架 Struts2 文章标签： Struts2

本文链接：https://blog.csdn.net/qq_32682177/article/details/88857619

版权

框架同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

Struts2

1 篇文章 0 订阅

订阅专栏

文章目录

Struts2 概述

什么是 Struts2 ？

Struts2 是一个基于 MVC 设计模式的 Web 层框架。
- Struts2 相对于 Struts1 来讲已经发生巨大变换

常见的 Web 层框架

Struts2
Struts1
Webwork
SpringMVC

Web 层框架基于前端控制器模型

在这里插入图片描述

Struts2 入门

下载 Struts2 开发环境
创建web 项目，引入相应 jar 包
创建一个 JSP 页面

 <h1>Struts2入门</h1>
    <h3><a href="${pageContext.request.contextpath}/hello.action"></a></h3>

编写 Action 类

/*
 * Struts2 入门的 Action 类
 * */
public class HelloAction {
    /*
     * 提供一个方法：
     * 方法签名固定，共有的，返回值为String类型，方法名为execute，在这个方法中不能传递参数
     * */
	public String extcute() {
		System.out.println("HelloAction执行了...");
		return null;
	}
}

对 Action 进行配置
在 src 下创建名称叫做 struts.xml 的配置文件

<struts>
    <!-- Struts2为了管理Action的配置，通过包进行管理 -->
    <!-- 配置Sturts2的包 -->
    <package name="demo1" extends="struts-default" namespace="/">
        <!-- 配置Action -->
        <!-- name需要和访问路径有关系 -->
        <action name="hello" class="struts2.demo1.HelloAction"></action>
    </package>

配置前端控制器（核心过滤器）

<!-- 配置Struts2的核心过滤器 -->
  <filter>
      <filter-name>struts2</filter-name>
      <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>
  <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>/*</url-pattern>
  </filter-mapping>

改写Action的返回值

public class HelloAction {
    /*
     * 提供一个方法
     * 方法签名固定，返回值固定
     * 因为底层要反射这个方法
     * */
	public String execute() {
		System.out.println("helloAction...");
		return "success";
	}
}

改写 struts.xml

<struts>
	<!-- Struts2为了管理Action配置，通过包进行管理 -->
	<!-- 配置Struts2的包 -->
	<package name="demo1" extends="struts-default" namespace="/">
	    <!-- 配置Action -->
	    <!-- name需要和访问路径有关系 -->
	    <action name="hello" class="sturts.demo1.HelloAction">
	        <!-- 配置页面的跳转 -->
	        <result name="success">/demo1/success.jsp</result>
	    </action>
	</package>
</struts>

Struts2 执行流程

在这里插入图片描述
当用户访问某一个 Action 的时候，先经过核心过滤器，在核心过滤器中会执行一组拦截器（这组拦截器实现部分功能），执行目标 Action ，根据 Action 的返回值，进行页面跳转。

Struts2 常见配置

XML 的提示问题

配置 XML 提示

Struts2 的配置文件的加载顺序（了解）

Struts2 的配置文件的加载顺序

Action 的配置

package 相关配置

package 标签被称为包，这个包与 Java 中的包的概念不一致。包为了更好管理 action 的配置
package 标签的属性
- name：包的名称，只要在一个项目中不重名即可
- extends：继承哪个包，通常的值为 struts-default
- namespace：名称空间，与标签中的name属性共同决定访问路径
  - 名称空间有三种写法：
    - 带名称的名称空间：namespace="/aaa"
    - 根名称空间：namespace="/"
    - 默认名称空间：namespace=" "（啥都不写）
- abstract：抽象的，用于其他包的继承

action 的配置

action 标签主要用于配置 Action 类
action 标签的属性
- name：与 namespace 共同决定访问路径
- class：Action 类的全路径
- method：执行 Action 中的哪个方法的方法名称，默认值为 execute
- converter：用于设置一些类型转换器

常量的配置

在 struts2 框架中，定义了非常多的常量（在 default.properties）
在 struts2 中修改一些常量的值：

修改常量的值，可以在三个位置进行修正：
- struts.xml 中进行修改

<struts>
    <!-- 配置struts2的常量 （此常量用来修改struts2 的默认扩展名）-->
    <constant name="struts.action.extion" value="action"/>
	<!-- Struts2为了管理Action配置，通过包进行管理 -->
	<!-- 配置Struts2的包 -->
	<package name="demo1" extends="struts-default" namespace="/">
	    <!-- 配置Action -->
	    <!-- name需要和访问路径有关系 -->
	    <action name="hello" class="sturts.demo1.HelloAction">
	        <!-- 配置页面的跳转 -->
	        <result name="success">/demo1/success.jsp</result>
	    </action>
	</package>
</struts>

struts.properties 中进行修改
web.xml 中进行修改

<filter>
       <filter-name>struts2</filter-name>
       <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
       <!-- 修改常量 -->
       <init-param>
           <param-name>struts.action.extension</param-name>
           <param-value>xyz</param-value>
       </init-param>
   </filter>

分模块开发

include 的配置

Action 的访问

Action 的编写

Action 类是 POJO 的类
Action 类实现一个Action 接口

/**
 * @author Administrator
 * Action的编写方式二：实现一个Action的接口
 * 实现接口的这种方式：提供了五个常量（五个逻辑视图的名称）
 *   SUCCESS:成功
 *   ERROR:失败
 *   LOGIN:登录出错页面跳转
 *   INPUT:表单校验的时候出错
 *   NONE:页面不跳转
 */
public class ActionDemo2 implements Action{

	@Override
	public String execute() throws Exception {
		System.out.println("ActionDemo2执行了...");
		return null;
	}

}

Action 类继承 ActionSupport 类

/**
 * @author Administrator
 * Action的编写方式三：Action类继承ActionSupport
 * 推荐使用继承ActionSupport方式
 * ActionSupport中提供了数据校验，国际化等一系列的方法
 */
public class ActionDemo3 extends ActionSupport{

	@Override
	public String execute() throws Exception {
		System.out.println("ActionDemo3执行了...");
		return NONE;
	}
    
}

Action 的访问

通过 method 设置

 <action name="userFind" class="struts.demo3.UserAction" method="find"></action>
	    <action name="userUpdate" class="struts.demo3.UserAction" method="update"></action>
	    <action name="userDelete" class="struts.demo3.UserAction" method="delete"></action>
	    <action name="userSave" class="struts.demo3.UserAction" method="save"></action>

通过通配符的方式进行配置

 <!-- 通配符的方式 -->
	    <action name="product_*" class="struts.demo3.PorductAction" method="{1}"></action>

动态方法访问

Struts2 的 Servlet 的 API 的访问

在使用 struts2 的框架的过程中，发现 struts2 和 servlet 的 API 是解偶合的。在实际开发当中，经常使用 servlet 的 API，比如登录，将用户的信息保存到 Session 当中，有时候需要向页面输出一些内容，用到 response 对象。涉及到 Servlet 的 API 的访问。

Struts2 的 Servlet 的 API 的访问

完全解耦合的方式

编写了一个 JSP

 <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>

编写了 Action

/**
 * @author Administrator
 * 访问Servlet的API
 */
public class RequestDemo1 extends ActionSupport{

	@Override
	public String execute() throws Exception {
		//一、接收参数
		//利用Struts2中的对象ActionContext对象
		ActionContext context = ActionContext.getContext();
		//调用ActionContext中的方法
		//类似于Map<String,String[]> request.getParametersMap();
		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 集合，不能操作这些对象的本身的方法。

使用 Servlet 的 API 的原生方式

接口注入的方式

Struts2 的结果页面的配置

Struts2 的数据类型的封装

属性驱动-提供set方法的方式

编写 JSP

<h1>Struts2的数据封装</h1>
    <h3>方式一：属性驱动-提供set方法的方式</h3>
    <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>


/**
 * @author Administrator
 * 数据封装的方式一：提供属性的 set 方法的方式
 */
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;
	}  
}

属性驱动-在页面中提供表达式的方式

编写 JSP

 <h1>Struts2的数据封装</h1>
    <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>


/**
 * @author Administrator
 * 数据封装方式二：属性驱动-在页面中提供表达式的方式
 */
public class UserAction2 extends ActionSupport{

	//需要提供一个User对象
	private User user;
	//提供User的set和get方法
	//因为拦截器要完成数据的封装，需要创建User对象。通过get方法可以获得同一个对象，将数据封装到同一个对象中
	public User getUser() {
		return user;
	}

	public void setUser(User user) {
		this.user = user;
	}
	
	@Override
	public String execute() throws Exception {
		System.out.println(user);
		return NONE;
	}
}

模型驱动方式（最常用的方式）

编写 JSP

<h1>Struts2的数据封装</h1>
    <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>

/**
 * @author Administrator
 * 数据封装方式三：模型驱动
 */
public class UserAction3 extends ActionSupport implements ModelDriven<User>{
	
	//模型驱动使用的对象：前提必须手动提供对象的实例
	private User User = new User();
	
	@Override
	//模型驱动需要使用的一个方法
	public User getModel() {
		return User;
	}

	@Override
	public String execute() throws Exception {
		
		return NONE;
	}
}

模型驱动方式是最常用的方式：
- 缺点：只能同时向一个对象中封装数据
  使用第二种可以向多个对象中同时封装数据

关于 INPUT 逻辑视图的配置

Action 接口中提供了五个逻辑视图名称：
- SUCCESS
- ERROR
- LOGIN
- INPUT : INPUT 在某些拦截器中会使用
- NONE

Struts2 的复杂类型的数据封装

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

封装数据到 List 集合中

编写 JSP

 <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>

编写 Action

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;
	}	
}

封装数据到 Map 集合中

编写 JSP

<h3>封装到Map集合中：批量插入商品</h3>
     <form action="${ pageContext.request.contextPath }/productAction2.action" method="post">
     <!-- 属性名是map -->
                       商品名称：<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>

编写 Action

/**
 * @author Administrator
 * 复杂类型的数据封装：封装到Map集合
 * 将表单中的数据装到Map集合当中
 */
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;
	}    
}

OGNL

OGNL 概述

什么是 OGNL ?

OGNL ：对象图导航语言，比 EL 表达式强大很多倍的语言。
- EL : 从域对象中获取数据，或从 EL 的 11 个对象中获取。${pageContext.request.contextPath}
- OGNL : 可以调用对象的方法，获取 Struts2 的值栈的数据。OGNL 其实是第三方的表达式语言。

为什么学习 OGNL ？

访问 OGNL 上下文

OGNL 使用的要素

表达式
根对象
context 对象

OGNL Java 环境入门（了解）

访问对象的方法

public class OGNLDemo1 {
    @Test
    /**
     * @author Administrator
     * OGNL调用对象的方法
     */
    public void demo1() throws OgnlException {
    	//获得context
    	OgnlContext context = new OgnlContext();
    	//获得根对象
    	Object root = context.getRoot();
    	//执行表达式
    	Object object = Ognl.getValue("'helloworld'.length()", context, root);
    	System.out.println(object);
    }
}

访问对象的静态方法

 @Test
    /**
     * @author Administrator
     * 访问对象的静态方法
     */
    public void demo2() throws OgnlException {
    	//获得context
    	OgnlContext context = new OgnlContext();
    	//获得根对象
    	Object root = context.getRoot();
    	//执行表达式：@类名@方法名
    	Object object = Ognl.getValue("@java.lang.Math@random()", context, root);
    	System.out.println(object);
    }

获取 Root 中的数据

@Test
    /**
     * @author Administrator
     * 访问Root中的数据,不需要加#
     */
    public void demo3() throws OgnlException {
    	//获得context
    	OgnlContext context = new OgnlContext();
    	User user = new User("aaa", "123");
    	context.setRoot(user);
    	//获得根对象
    	Object root = context.getRoot(); 
    	Object username = Ognl.getValue("username", context,root);
    	Object password = Ognl.getValue("password", context,root);
    	System.out.println(username + " " + password);
    }

获取 OgnlContext 中的数据

 @Test
    /**
     * @author Administrator
     * 获取context中的数据,需要加#
     */
    public void demo4() throws OgnlException {
    	
    	//获得context
    	OgnlContext context = new OgnlContext();
    	
    	//获得根对象
    	Object root = context.getRoot(); 
    	
    	//向context中存入数据
    	context.put("name", "张三");
    	
    	//执行表达式
    	Object object = Ognl.getValue("#name", context,root);
    	System.out.println(object);
    }

OGNL Struts2 环境入门

访问对象的方法

<body>
    <h1>OGNL在Struts2环境中的入门</h1>
    <h3>调用对象的方法</h3>
    <s:property value="'struts'.length()"/>
</body>

访问对象静态的方法

<body>
    <h1>OGNL在Struts2环境中的入门</h1>
    <h3>调用对象的方法</h3>
    <s:property value="'struts'.length()"/>
    <h3>调用对象的静态方法</h3>
    <!-- 静态方法访问默认式关闭的，需要开启一个常量 -->
    <s:property value="@java.lang.Math@random()"/>
</body>

<struts>
        <constant name="struts.action.extion" value="action"/>
        <!-- 开启静态方法访问 -->
        <constant name="struts.ognl.allowStaticMethodAccess" value="true"/>
</struts>

值栈

值栈的概述

什么是值栈

ValueStack实际上就是一个容器。它由Struts框架创建，当前端页面如jsp发送一个请求时，Struts的默认拦截器会将请求中的数据进行封装，并入ValueStack的栈顶。

ValueStack 其实类似于一个数据中转站（Struts2 的框架当中的数据就都保存到了 ValueStack 中）
- ValueStack 接口，实现类是 OgnlValueStack 对象
- ValueStack 贯穿整个 Action 的生命周期。（Action 一旦创建，框架就会创建一个 ValueStack 对象）

值栈的内部结构

ValueStack 中有两个主要的区域：
- root 区：其实就是一个 ArrayList，里面一般放置对象。获取 root 的数据不需要加 #
- context 区：其实就是一个 Map，里面一般放置的是 web 开发的常用的对象数据的引用，获取 context 数据需要加 #
  - request
  - session
  - application
  - parameters
  - attr
所说的操作值栈通常操作的是 ValueStack 中的 root 区域

值栈与 ActionContext 的关系

ServletContext：Servlet 的上下文
ActionContext：Action 的上下文
- 通过源码查看到，当请求过来的时候，执行过滤器中的 doFilter 方法，在这个方法中创建 ActionContext ，在创建 ActionContext 过程中，创建了 ValueStack 对象，将 ValueStack 对象传递给 ActionContext 对象，所以可以通过 ActionContext 获取值栈对象。
- ActionContext 对象之所以能够访问到 Servlet 的 API（访问的是域对象的数据），因为在其内部有值栈的引用。

获得值栈

通过 ActionContext 对象来获取值栈。
在 Struts2 内部，将值栈存入 request 一份

/**
 * @author Administrator
 * 获得 ValueStack
 */
public class ValueStackDemo2 extends ActionSupport{

	@Override
	public String execute() throws Exception {
		//第一种：通过ActionContext获得
		ValueStack valueStack = ActionContext.getContext().getValueStack();
		
		//第二种：通过request对象来获得
		ValueStack valueStack2 = (ValueStack) ServletActionContext.getRequest().getAttribute("struts.valueStack");
		
		//一个Action的实例只会创建一个ValueStack的对象
		System.out.println(valueStack == valueStack2);
		
		return NONE;
	}  
}

操作值栈-向值栈中存入数据

第一种：在 Action 中提供属性的get方法
默认情况下，将 Action 对象压入到值栈，Action 的属性也就进去了

 <h1>查看值栈的内部结构</h1>
    <s:debug></s:debug>
    <!-- 方式以的获取：利用Action在值栈中的特性,这里的user是值栈中的一个属性 -->
    <s:property value="user.username"/>
    <s:property value="user.password"/>

/**
 * @author Administrator
 * 操作ValueStack
 */
public class ValueStackDemo3 extends ActionSupport{

	private User user;
	public User getUser() {
		return user;
	}

	@Override
	public String execute() throws Exception {
		//向ValueStack中存值
		user = new User("李四", "222");
		return SUCCESS;
	}	
}

第二种：使用 ValueStack 中本身的方法的方式

/**
 * @author Administrator
 * 操作值栈方式二：调用值栈中的方法实现
 */
public class ValueStackDemo4 extends ActionSupport{

	@Override
	public String execute() throws Exception {
		//向值栈中保存数据
		//获得值栈对象
		ValueStack valueStack = ActionContext.getContext().getValueStack();
		//使用值栈中的push(Object obj); set(String key, Object obj);方法
		User user = new User("赵四", "2256");
		//user在栈的最顶端
		valueStack.push(user);
		valueStack.set("name", "田七");//创建了一个Map，将Map压入栈顶
		return SUCCESS;
	}
    
}

获取值栈数据

获取值栈中的数据就是在页面中使用 OGNL 表达式即可
- 获取 root 的数据（不需要加 # 号）

 <!-- 获取集合中的数据 -->
        <s:property value="list[0].username"/>
        <s:property value="list[0].username"/>
        <s:property value="list[1].username"/>
        <s:property value="list[1].username"/>
        <s:property value="list[2].username"/>
        <s:property value="list[2].username"/>

获取 context 的数据

 <!-- 要获取context当中的数据 -->
        <s:property value="#request.name"/>
        <s:property value="#session.name"/>
        <s:property value="#application.name"/>
        <s:property value="#attr.name"/>

EL 为何能访问值栈的数据

OGNL 中的特殊字符

# 号

获取 context 的数据

 <h1>#号的用法</h1>
    <h3>获取context的数据</h3>
    <%
        request.setAttribute("name","李四");
    %>
    <s:property value="#request.name"/>

使用 # 构建 map 集合

  <h3>构建map集合</h3>
    <s:iterator var="i" value="{'aa','bb','cc'}" >
        <s:property value="i"/>
    </s:iterator>
    
     <s:iterator var="entry" value="#{'aa':'11','bb':'22','cc':'33' }">
        <s:property value="key"/>--<s:property value="value"/>
        <s:property value="#entry.key"/>--<s:property value="#entry.value"/>
    </s:iterator>

%号

强制解析 OGNL

<h1>%号的用法</h1>
<%
    request.setAttribute("name", "李四");
%>
姓名：<s:textfield name="name" value="%{#request.name}"></s:textfield>

强制不解析 OGNL

$号

在配置文件中使用 OGNL

属性文件
XML 文件

Sturts2 拦截器

拦截器概述

什么是拦截器

interceptor：拦截器，起到拦截 Action 的作用
- Filter：过滤器，过滤从客户端向服务器发送的请求
- interceptor：拦截器，拦截的是客户端对 Action 的访问，可以做到更细粒度化的拦截（可以拦截 Action 当中的具体的方法）
struts2 框架核心的功能都是依赖拦截器来完成的

Struts2 的执行流程

为什么会这样1994

关注

10
点赞
踩
36

收藏

觉得还不错? 一键收藏
0
评论
Struts2

文章目录Struts2 概述什么是 Struts2 ？常见的 Web 层框架Web 层框架基于前端控制器模型Struts2 入门Struts2 概述什么是 Struts2 ？Struts2 是一个基于 MVC 设计模式的 Web 层框架。Struts2 相对于 Struts1 来讲已经发生巨大变换常见的 Web 层框架Struts2Struts1WebworkSpri...
复制链接

扫一扫

专栏目录