Loading

Struts 2 学习笔记

Struts2

一. Struts2 简介

Struts2 是一个 MVC 开发模式的框架，用来处理用户请求，代替 Servlet 职责，是对 Servlet 的一种封装

二. MVC 开发模式（☆）

MVC 开发模式是把视图代码与业务逻辑代码分离，通过控制层连接视图代码与业务逻辑代码

  • Model：项目中的业务逻辑（业务领域），通常用 JavaBean 实现（dao层，service层）

  • View：项目中的展现，通常用 JSP/HTML 实现

  • Controller：项目中的控制层，通常用 Servlet 实现

优点缺点
高内聚，低耦合 MVC 层次太多，增加开发工作量，开发效率较慢
项目结构清晰，利于后期维护
业务逻辑清晰，代码重用性强，适合二次开发与后期维护

三. 开发模式，设计模式，框架之间的联系（☆）

  • 开发模式：开发模式是一种编程思想，实现的目标

  • 框架：框架就是开发思想的产物

  • 设计模式：框架由设计模式实现

开发模式诞生框架，框架由设计模式实现

四. 搭建 Struts2 环境

  1. struts-2.3.16.3包下面找到apps/struts2-blank.war空项目，解压一下项目，把项目中 lib 下的所有 jar 文件复制到自己项目中

  2. 在struts2-blank项目中找到web.xml，把 Struts 核心过滤器复制到项目中，代码如下：

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

  3. 在struts2-blank项目中 src 下找到struts.xml文件，复制到自己项目中的 src 目录下

  4. 在struts2-blank项目中 src 下找到log4j.properties文件，复制到自己项目中的 src 目录下

五. Struts2 工作原理

  1. 当服务器启动的时候，会读取web.xml配置文件，实例化，初始化 struts2 的核心过滤器（StrutsPrepareAndExecuteFilter），核心过滤器会默认读取 src 根目录下的struts.xml配置文件，加载所有 action 信息

  2. 当客户端向服务器发送请求（action）时，该请求会被核心过滤器拦截，把请求的路径去struts.xml文件中package标签namespace属性值和action标签name属性值相匹配，交给对应的 action 去处理，默认执行 execute 方法

  3. action 中方法执行完毕之后，会返回一个字符串给核心过滤器，核心过滤器去对应的action标签中result标签的name属性值匹配对应的字符串，跳转页面

六. Strus2 执行过程（☆）

  1. 浏览器发送一个请求，会到达 Web 服务器 Tomcat，Tomcat 会接收请求

  2. Tomcat 会根据项目中的web.xml配置判断请求是否符合 Struts2 的核心过滤器(StrutsPrepareAndExecuteFilter)的过滤路径，如果符合请求会交给 Struts2 处理

  3. Struts2 核心过滤器根据请求的 URL，在sturts.xml中匹配处理 Action 的请求 URL = package 标签namespace属性 + action标签的name属性

  4. 匹配上后会根据action标签中的class属性匹配上一个 Action，action首先会实例化，默认调用execute方法。Action是多实例、线程是安全的

  5. 执行完 execute 方法后，返回一个字符串，对应 Action 标签下的result标签name属性

  6. 根据result标签中的页面路径进行页面跳转，把内容呈献给浏览器端

七. 配置访问后缀名

  1. 在struts.xml中配置扩展名的常量，代码如下：
    <constant name="struts.action.extension" value="do,action" />

  2. 在web.xml中增加核心过滤器的过滤路径，代码如下：

    <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>*.action</url-pattern>
</filter-mapping>

<filter-mapping>
	<filter-name>struts2</filter-name>
	<url-pattern>*.do</url-pattern>
</filter-mapping>

<filter-mapping>
	<filter-name>struts2</filter-name>
	<url-pattern>*.xi</url-pattern>
</filter-mapping>

  3. 在访问 URL 上增加.后缀名
    <a href="hello/helloworld.action">测试Hello World！</a>
    <a href="hello/helloworld.do">测试Hello World！</a>

八. 获取表单参数

Struts 获取表单参数有三种方式：

  1. 属性接收（字段驱动）

    • 把 input 框 name 属性作为 Action 类中的全局属性，并且生成 get 与 set 方法，就可以接收表单参数

  2. DynamicModel（动态模型）（☆）

    1. 把所有 input 框 name 属性封装成一个类中的属性

    2. 在 Action 中把参数对象作为全局属性，并且生成 get 与 set 方法

    3. 在 input 框 name 属性必须使用：参数对象名称 . 属性名称

  3. ModelDriven（模型驱动）

    1. action 类实现一个 ModelDriven 接口，重写 getModel 方法返回参数类

    2. 在 input 框 name 属性不需要加上 对象名称 . 属性名称，参数类的 get 与 set 方法也不需要了（实体类中的属性名必须要和表单中 name 属性名一致，模型驱动可以和字段驱动联合使用）

注：action 中的属性生成了 get 方法，会在 request 中存储一份，可以传递到 JSP 页面上

九. 获取 WEB 元素（request、response）

获取 request 有两种方式：

  1. 通过 ServletActionContext 类获取，代码如下：

    HttpServletRequest request = ServletActionContext.getRequest();

  2. Action 类实现 ServletRequestAware 接口，重写 setServletRequest 方法，给全局 request 属性赋值

    public class WebElementAction extends ActionSupport implements ServletRequestAware {
	private HttpServletRequest request;

	@Override
	public void setServletRequest(HttpServletRequest request) {
		this.request = request;
	}
}
获取 response 有两种方式：

  1. 通过 ServletActionContext 类获取，代码如下：

    HttpServletResponse response = ServletActionContext.getResponse();

  2. Action 类实现 ServletResponseAware 接口，重写 setServletResponse 方法，给全局 response 属性赋值

    public class WebElementAction extends ActionSupport implements ServletResponseAware {
	private HttpServletResponse response;

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

十. 动态方法调用

  1. 使用感叹号调用其他方法

    1. 在 struts.xml 中开启动态方法调用，代码如下：

    <constant name="struts.enable.DynamicMethodInvocation" value="true" />

    1. 在访问 URL 后面：!方法名 . 后缀名

    user/login!add.action

    缺点：暴露了类中的方法名，不推荐使用

  2. 一个 Action 类中的方法对应一个 action 标签，代码如下：（推荐使用）

    <action name="dynamicMethodAdd" class="com.zt.action.DynamicMethodAction" method="add">
	<result name="success">/success.jsp</result>
</action>

  3. 通配符

    <package name="common"  namespace="/" extends="struts-default">
	<action name="*_*" class="com.zt.action.{1}Action" method="{2}">
    	<result>/{1}_{2}.jsp</result>
    </action>
</package>

十一. 结果集类型（☆）

result 标签 type 属性的取值
类型 描述
dispatch action 转发到 JSP（默认）
redirect action 重定向到 JSP
chain action 转发到 action
redirectAction action 重定向到 action
json action 传递 JSON 字符串到页面（Ajax）
stream 流的形式（文件下载）

十二. 全局结果集

利用包与包之间可以继承关系，在父包中定义的结果集可以在子包中使用，相当于全局变量
<package name="all" extends="struts-default">
    <global-results>
        <result name="success">/success.jsp</result>
    </global-results>
</package>

十三. OGNL 表达式

OGNL 全称：Object Graph Navigation Language

OGNL 表达式作用：简化页面代码，提高开发效率

OGNL 是一个强大的表达式，OGNL 只在 Struts2 中使用，离开 Struts2 框架就无效

Struts 标签库 == EL 表达式 + JSTL，使用 Struts 标签库必须经过 action，不然会抛异常

十四. Struts2 与 Ajax结合（☆）

  1. Struts2 与 Ajax 结合需要导入struts2-json-plugin-2.3.16.3.jar

  2. Action 类中把字符串变量声明成全局变量，并且生成 set 与 get

  3. 在struts.xml中做如下配置：

    <!-- ajax -->
<!-- json-default 继承了 struts-default -->
<struts>
    <package name="ajax" namespace="/ajax" extends="json-default">
        <action name="ajax" class="com.zt.action.AjaxAction">
            <result type="json">
                <!-- root 名称是固定写法，指定 JSON 字符串的变量名 -->
                <param name="root">json</param>
            </result>
        </action>
    </package>
</struts>

十五. Struts的拦截器（☆）

  1. Struts 的拦截器只能拦截 Action 类，在 Action 类之前之后做一系列动作

    // Action 之前动作
String result = invocation.invoke(); // 执行 Action
// Action 之后动作

  2. 可插拔

    需要的话就配置上，不需要就不配置

  3. 拦截器的创建

    1. 第一种：编写一个普通的 Java 类，实现 Interceptor 接口

    2. 第二种：编写一个普通的 Java 类，继承 AbstractInterceptor 类

  4. 引用拦截器

    • 所有的 action 都去默认引用拦截器

      <default-interceptor-ref name="myStack"></default-interceptor-ref>

    • 具体某一个 Action 去引用拦截器

      <action name="authAction" class="com.ztkj.action.AuthAction">
	<result name="success">success.jsp</result>
	<interceptor-ref name="loginInterceptor"></interceptor-ref>
</action>

    • 全局 result 的配置

      <!-- 先从当前的 action 去匹配返回的字符串，若没找到，则去全局 result 里面匹配 -->
<global-results>
	<result name="noLogin" type="redirect">login.jsp</result>
	<result name="noAuth" type="redirect">noAuth.jsp</result>
</global-results>

十六. Struts 核心组件（☆）

组件 描述
StrutsPrepareAndExecuteFilter 核心过滤器
struts.xml 主配置文件
Action 处理请求的类
Result 跳转的结果集
struts（OGNL 表达式） 解析数据

十七. 重量级与轻量级（☆）

  • 重量级：创建与销毁消耗较多资源（CPU与内存），依赖性比加强，替换很麻烦

  • 轻量级：创建与销毁不需要消耗太多资源，独立性比较强，替换简单

Struts 框架就是一个重量级，使用 Struts 后 Tomcat 启动较慢，Struts 依赖 Tomcat 容器（MVC 开发模式下的框架都是重量级的）

posted @ 2022-03-15 22:23  Schieber  阅读(122)  评论(0)    收藏  举报