day25_Struts2学习笔记_01

一、框架概述

  把重复性的繁琐的代码封装起来。使程序员在编码中把更多的精力放业务需求的分析和理解上面。
  特点：封装了很多细节，程序员在使用的时候会非常简单。

三大框架：Struts2、Spring、Hibernate

二、三层架构与Struts2

• 表现层：M model V view C control
• 业务层：Service
• 持久层：Dao data access object

Struts2在三层架构中的位置是处于表现层。注意它只是一个表现层框架。

三、MVC与Struts2

M：Model 模型，封装数据。javabean
V：View  视图，展示界面。jsp
C：Controller 控制器，控制程序流程。Servlet

控制器：Servlet
        init(ServletConfig config)
        destroy()
        service(ServletRequest req, ServletResponse resp)

过滤器：Filter 它也可以作为控制使用。
        init(FilerConfig filterConfig)
        destroy()
        doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)

Servlet能做的Filter都可以做，并且比Servlet功能更强大，它多了一个放行的功能。即：过滤器同样也适合做控制器。
注意：Struts1的核心就是一个控制器，Struts2的核心就是一个过滤器。

四、案例中存在的一些问题

1. 获取请求正文，用户要做什么事情。
2. 根据不同的请求，做出不同的判断。
3. 执行具体的方法代码（动作）。
4. 转向页面，展示给用户。

缺陷：

1. 重复性劳动太多，具体的执行代码也有冗余代码。
2. 全是硬编码，像用户要做什么事情，对应执行什么代码，可以写在配置文件中。
3. 具体的代码方法放到了控制器中，过于臃肿。

五、Struts2简介

1、Struts2概述
    Struts2是Apache发行的MVC开源框架。注意：它只是表现层（MVC）框架。
2、Struts2的来历
    Struts1：也是apache开发的一套mvc的开源框架。在2005年之前非常流行。
        弊端：Struts1的核心控制器就是一个Servlet。随着使用者的增多，弊端开始出现。
    Struts2：在long long ago，有一个设计超前的框架XWork，后来推出了XWork1和WebWork2。Struts2就是apache和OpenSymphony组织合并开发出来。
    Struts2里面包含了WebWork2的核心及Struts的一些特性和功能。除此之外，和Struts1没有任何关系了。

六、搭建开发环境

1. Struts2的下载和安装

2. 开发包目录结构

   

3. 搭建开发环境
   拷贝必要jar包到classpath中（即拷贝jar包到WebRoot/WEB-INF/lib中），原则是：用哪个拷贝哪个。注意：新老版本的区别：
   旧版本的struts2

   
   新版本的struts2
   
   

4. 建立Struts2的配置文件
   at the top of classpath（在最顶层的构建路径）,建立一个默认名称为struts.xml的配置文件。
   注意：

   1. 文件名大小写。
   2. 创建位置。
   3. 该文件名称允许修改，但是我们一般不改。
      

5. 在web.xml中配置控制器
   a、配置位置：在web.xml中
   b、配置什么： struts2已经写好了的一个过滤器。
   结论：struts2比struts1优秀的一个体现就是：它用了更为强大的过滤器作为控制器。

   

6. 验证是否搭建环境成功
   部署应用后，启动Tomcat，不报错表示搭建成功。

7. 关于struts.xml没有提示的问题
   分析原因：没有找到对应的dtd约束文件。
   解决办法：
   a.开发时联网
   b.开发时不能上网咋办呢？那就手动添加该约束文件，过程如下：

   
   
   附上：上述的struts.xml和web.xml文件

struts.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">

<struts>

</struts>

web.xml文件（注意：新版本的区别）

if you are using struts2 version 2.5 you need to change from 
org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter 
to
org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter
是的，去掉了中间.ng文件空间名，原因是在整合xwork的时候，同时简化了不必要的包名空间。

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
    id="WebApp_ID" version="3.1">
    <display-name>day25_00_struts2Template</display-name>

    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>

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

    <welcome-file-list>
        <welcome-file>index.html</welcome-file>
        <welcome-file>index.htm</welcome-file>
        <welcome-file>index.jsp</welcome-file>
        <welcome-file>default.html</welcome-file>
        <welcome-file>default.htm</welcome-file>
        <welcome-file>default.jsp</welcome-file>
    </welcome-file-list>
</web-app>

七、Struts2入门案例

  以下步骤是日后实际开发中经常重复的。

1. 建立一个访问视图的.jsp文件
   
2. 在struts.xml文件中配置
   
3. 建立动作类和动作方法
   
4. 结果视图页面
   
5. 测试
6. 小问题解决
   上面的模板我们做好了，就可以复制使用该模班，注意：复制该模板后，必须要修改 Web Context Root的内容，否则部署的时候会报错(会出现跟模板名称一样的应用)，步骤如下：在新项目上右键 --> Properties --> 在搜索框中输入 Web --> 在web Context Root 中 --> Config…，如下图所示：
   

八、第一个案例的执行过程

　　tomcat启动，加载应用的web.xml --> tomcat实例化并初始化过滤器 --> 加载struts.xml配置文件 --> 

　　客户浏览器发送请求：hello.action --> 请求到达过滤器 --> 截取请求的动作名称hello，并从struts.xml中查找 -->

　　找到后，实例化HelloAction动作类，每次都会创建新的实例 --> 调用对应的sayHello()动作方法，方法有返回值 --> 根据返回值找对应的结果视图 --> 找到结果jsp页面 --> 响应浏览器，展示结果

  如下图所示：

九、Struts2的配置文件的加载时机和加载顺序

  加载时机：当应用被tomcat加载的时候，struts2的配置文件就已经被加载过了。
  加载顺序：default.properties --> struts-default.xml --> struts-plugin.xml --> struts.xml --> struts.properties --> web.xml

　　　　　　 存的是常量　　拦截器、结果视图、默认的动作类　　插件　　我们自己写的　　一般不用它　　我们自己写的

• 注意：
  1、Struts2提供了两种配置的方式。一种是key=value的方式，即使用.properties文件。另一种是xml文件配置。我们推荐使用xml文件（因为它能描述层级关系）。
  2、如果多个文件配置了同一个struts2常量，则后一个文件中配置的常量值会覆盖前面文件配置的常量值。

十、Struts2中的常量

  1、常用的常量
    常量定义在了default.properties配置文件中，体现形式都是key=value。所有的struts2应用都会用到这些常量。

  2、在struts.xml中覆盖常量（即修改struts中default.properties定义的常量值）

十一、Struts2中配置文件元素的详解

1、package元素:

package元素：作用是定义一个struts的包，它是把配置文件按照面向对象的思想来管理。分模块开发。
        即在struts2的配置文件中引入了面向对象思想，使用了分包管理。易于管理动作类。便于模块化开发动作类。

    name属性：指定包的名称。注意：包的名称在配置文件中唯一。

    extends属性：指定当前包的父包。它是按照面向对象的思想管理的体现。
            一般情况下需要继承struts-default包，但不是必须的。不过如果不继承的话，将无法使用struts2提供的核心功能。
            struts-default.xml 中定义着 struts-default 这个包。而 struts-default.xml 是在我们的 struts.xml 加载之前加载。

    abstract属性：把包声明为一个抽象包。抽象包就是用来被继承的。
            只有没有<action>元素的包，才能被定义为抽象包。

    namespace属性：名称空间。当指定了名称空间之后，访问路径就变成了：
            访问路径 = 名称空间 + 动作名称
        当不指定该属性时，该属性有默认值，默认值是""。注意：不是"/"!!!
        名称空间的搜索顺序：
            第一步：先去找对应的名称空间
                在指定的名称空间下找到了：就执行第二步。
                在指定的名称空间下没找到：按照名称空间结构向上追溯，一直到根名称空间，只要在任何一级找到了，就执行第二步。
            第二步：找动作名称
                先在指定的名称空间下，搜索对应的动作名称：找到了就执行动作类的动作方法。
                在指定的名称空间下没找到对应的动作名称：就前往默认的名称空间下，找动作名称。注意：它只找动作名称。

  package的namespace的执行顺序，如下图所示：

    <package name="p1" extends="struts-default" namespace="/user"> <!-- 名称空间(namespace="/user") -->
        <!-- 
        <action name="action1" class="com.itheima.web.action.Demo1Action" method="saveUser" >
            <result name="success">/success.jsp</result>
        </action> 
        -->
    </package>

    <package name="p2" extends="struts-default"> <!-- 默认的名称空间(namespace=""或者不写该属性) -->
        <action name="action2" class="com.itheima.web.action.Demo1Action" method="saveUser2" >
            <result name="success">/success.jsp</result>
        </action>
    </package>

访问：http://localhost:8080/day25_04_struts2_package/user/action2.action，可以找得到，查找过程：
    1、先查找名称空间/user，有/user名称空间；
    2、再在该名称空间查找动作名称action2.action，没有该动作名称；
    3、再去默认的名称空间查找，有默认的名称空间；
    4、再在该名称空间查找动作名称action2.action，有该动作名称，则执行该动作。

2、action元素：

action元素：是用于定义动作名称，动作类和动作方法的映射，即配置动作用的。以及当出现不同情况时前往指定的结果视图 。
    name属性：动作的名称。和jsp页面上的请求url中的名称对应起来。注意在此处不能写.action。
    class属性：指定动作类，即动作类全名。
    method属性：指定要执行的动作方法，即动作类中的方法名称。默认是public String execute() { }
        方法要求：
            1. public的
            2. 返回值必须是String
            3. 没有参数

    可以修改默认动作类，注意：我们一般不改
        <default-class-ref class="你自己的动作类" />
    默认的动作类是：com.opensymphony.xwork2.ActionSupport 是在struts-default.xml中定义的。

3、编写动作类的三种方式：

  a.方式一：动作类就是一个POJO（Plain Old Java Object: 原始的老的java对象），是非常简单的JavaBean。示例代码如下：

package com.itheima.web.action;
/**
 * 创建动作类的第一种方式： 
 *      创建一个普通的java类。
 *         它就是一个POJO，是非常简单的javabean。 
 *         原始的 老的 java 对象 
 *         Plain Old Java Object 
 *         POJO类是指没有实现任何接口以及除了Object类以外，没有继承任何父类。
 *         struts2通过获取struts.xml获取到完全的类名，然后底层通过反射，执行方法。
 *         该创建动作类的方式的特点：一点也看不到有struts2的痕迹。
 * 
 * @author cmj
 */
public class Demo1Action {
    public String hello() {
        System.out.println("动作类执行了");
        return "success";
    }
}

  b.方式二：动作类实现com.opensymphony.xwork2.Action接口。示例代码如下：

package com.itheima.web.action;

import com.opensymphony.xwork2.Action;
/**
 * 创建动作类的第二种方式：
 *         动作类实现com.opensymphony.xwork2.Action接口。
 *         创建一个普通类，实现Action接口，实现接口中的方法。
 * 
 *  Action接口中的常量：
 *      常量名     默认常量值           说明
 *      SUCCESS     "success"       当动作执行成功后，前往指定的位置
 *      NONE        "none"          不返回任何结果视图，和   return null; 效果是一样的
 *      ERROR       "error"         当执行动作方法，出现异常后，前往指定的位置
 *      INPUT       "input"         数据回显
 *      LOGIN       "login"         一般用于返回登录页面
 * 
 * @author cmj
 */
public class Demo2Action implements Action {
    public String execute() throws Exception {
        System.out.println("动作类执行了");
        return null;
    }
}

  c.方式三：动作类继承com.opensymphony.xwork2.ActionSupport类。推荐使用方式三。示例代码如下：

package com.itheima.web.action;

import com.opensymphony.xwork2.ActionSupport;
/**
 * 创建动作类的第三种方式：
 *         创建一个动作类，继承com.opensymphony.xwork2.ActionSupport类。推荐使用方式三。
 *         意义：提供了一些基本的功能。比如验证和国际化消息提示等。
 *         我们在开发中采取这种方式，来创建我们的动作类。
 * 
 * @author cmj
 */
public class Demo3Action extends ActionSupport{
    // 当我们在该类中什么都不写，一个动作方法都不提供时:
    // 有一个默认的动作方法：public String execute() throws Exception { return SUCCESS; }
}

4、动作的调用：

a.使用通配符：
  优先级：绝对匹配优先。使用通配符的按照在配置文件中的先后顺序进行匹配的。
b.使用动态方法调用：
  示例代码如下：
  struts.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">

<struts>
    <!-- 先设置为开发者模式 -->
    <constant name="struts.devMode" value="true" />
    <!-- 开启动态方法调用 -->
    <constant name="struts.enable.DynamicMethodInvocation" value="true"/>

    <package name="p1" extends="struts-default">
        <!-- 动作方法调用的配置 
        <action name="addUser" class="com.itheima.web.action.UserAction" method="addUser">
            <result name="success">/addUser.jsp</result>
        </action>

        <action name="updateUser" class="com.itheima.web.action.UserAction" method="updateUser">
            <result name="success">/updateUser.jsp</result>
        </action>

        <action name="deleteUser" class="com.itheima.web.action.UserAction" method="deleteUser">
            <result name="success">/deleteUser.jsp</result>
        </action>

        <action name="findUser" class="com.itheima.web.action.UserAction" method="findUser">
            <result name="success">/findUser.jsp</result>
        </action>
        -->

        <!-- 使用通配符，配置动作方法 
             *表示的是动作的名称，当有和动作名称相匹配的时候可以用{出现的位置}来代替
        <action name="*_*" class="com.itheima.web.action.{2}Action" method="{1}{2}">
            <result name="success">/{1}{2}.jsp</result>
        </action>
        -->

        <!-- 动态方法调用的配置 -->
        <action name="user" class="com.itheima.web.action.UserAction">
            <result name="success">/success.jsp</result>
        </action>   
    </package>
</struts>

  inex.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>title</title>
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">
  </head>
  <body>
          <%-- 使用通配符，访问动作类和动作方法
        <a href="${pageContext.request.contextPath}/add_User.action" >添加用户</a><br>
        <a href="${pageContext.request.contextPath}/update_User.action" >更新用户</a><br>
        <a href="${pageContext.request.contextPath}/delete_User.action" >删除用户</a><br>
        <a href="${pageContext.request.contextPath}/find_User.action" >查询用户</a><br>
        --%>
        <%-- 使用动态方法调用，格式如下：
                动作名称!动作方法名称.action  或者
                动作名称!动作方法名称
        --%>
        <a href="${pageContext.request.contextPath}/user!addUser.action" >添加用户</a>
        <a href="${pageContext.request.contextPath}/user!updateUser.action" >更新用户</a>
        <a href="${pageContext.request.contextPath}/user!deleteUser.action" >删除用户</a>
        <a href="${pageContext.request.contextPath}/user!findUser.action" >查询用户</a>
   </body>
</html>

十二、Struts2中结果视图详解

1、resulst元素：

resulst元素：配置逻辑结果视图，即为动作指定结果视图。
    name属性：结果视图名称。与动作方法的返回值对应，当一致时前往指定的jsp。
    type属性：结果视图类型。不写的时候，有默认值，默认值是dispatcher(请求转发)。
        常用取值：
            dispatcher：请求转发 ，是默认值（本动作下）
                <result name="success" type="dispatcher">/success.jsp</result>

            redirect：请求重定向（本动作下）
                <result name="success" type="redirect">/success.jsp</result>

            chain：请求转发到另一个动作
                请求转发到同包（同名称空间）下的另一个动作
                    <result name="success" type="chain">action2</result>
                请求转发到不同包(不同名称空间)下的另一个动作
                    <result name="success" type="chain">
                        <param name="namespace">/n2</param>
                        <param name="actionName">action3</param>
                    </result>
                        使用的是注入的思想，在执行之重定向之前，会先获取这两个参数的值
                        调用的就是setNamespace("/n2")和setActionName("action3")

            redirectAction：请求重定向到另一个动作
                请求重定向到同包（同名称空间）下的另一个动作
                    <result name="success" type="redirectAction">action2</result>
                请求重定向不同包(不同名称空间)下的另一个动作
                    <result name="success" type="redirectAction">
                        <param name="namespace">/n2</param>
                        <param name="actionName">action3</param>
                    </result>
                        使用的是注入的思想，在执行之重定向之前，会先获取这两个参数的值
                        调用的就是setNamespace("/n2")和setActionName("action3")

  result元素中type的取值，type属性的取值在 struts-default.xml 中定义，如下图所示：

2、result元素中param子元素

在请求转发或者请求重定向到不同包下的动作时，都用到了result元素的子元素param。
    param元素的作用：依赖注入(Dependence Injection)思想：
我们通过struts-default.xml中的result-types元素中配置可以看出，每个结果类型视图其实都是靠一个类来实现的。而param元素就是将配置的参数，注入到该类中。
    调用的是对应类的setter方法进行注入的。例如：setNamespace("/n2")和setActionName("action3")

  示例代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
    <constant name="struts.devMode" value="true"/>

    <package name="p1" extends="struts-default">
        <action name="action1" class="com.itheima.web.action.Demo1Action">
            <result name="success" type="chain"> <!-- 转发到不同包(不同名称空间)下的另一个动作 -->
                <param name="namespace">/n2</param>
                <param name="actionName">action3</param>
            </result>
        </action>

        <!-- 没有给定动作类，默认的动作类是：com.opensymphony.xwork2.ActionSupport，没有给定动作方法，默认的动作方法是：execute -->
        <action name="action2">
            <result name="success" >
                <param name="location">/success.jsp</param>
            </result>
        </action>       
    </package>

    <package name="p2" extends="struts-default" namespace="/n2">
        <action name="action3">
            <result name="success" >/success.jsp</result>
        </action>
    </package>
</struts>

3、自定义结果类型及其配置

通过前面的内容，我们看出，其实结果类型就是一个类：
    这些类都实现了com.opensymphony.xwork2.Result接口。
    或者继承自该接口的实现类org.apache.struts2.dispatcher.StrutsResultSupport。
    这些类都有一个doExecute方法，用于执行结果视图。
综上：我们也可以自己写一个结果视图。

例子：
    输出CAPTCHA图像的结果类型。
    CAPTCHA(Completely Automated Public Turing Test to Tell Computers and Humans Apart: 全自动区分计算机和人类的图灵测试) ————>简称：验证码。

步骤：
    1.编写一个普通类，继承自StrutsResultSupport的类，并且重写doExcecute方法。此为自定义结果类型的类。
    2.在struts.xml中进行配置。
    3.在配置action时，type属性指定声明的结果类型名称。

  1、编写一个普通类，继承自StrutsResultSupport的类，并且重写doExcecute方法。此为自定义结果类型的类。

package com.itheima.web.result;

import javax.servlet.http.HttpServletResponse;

import org.apache.struts2.ServletActionContext;
import org.apache.struts2.dispatcher.StrutsResultSupport;

import cn.dsna.util.images.ValidateCode;

import com.opensymphony.xwork2.ActionInvocation;
/**
 * 自定义结果类型 
 *         第一步：编写一个普通类，继承自StrutsResultSupport的类，并且重写doExcecute方法。
 *         第二步：在struts.xml中进行配置。
 *         第三步：在配置action时，type属性指定声明的结果类型名称。
 * 
 * @author cmj
 */
public class CAPTCHAResult extends StrutsResultSupport {
    // 通过配置文件，调整生成图片的大小
    private int width;
    private int height;
    public int getWidth() {
        return width;
    }
    public void setWidth(int width) {
        this.width = width;
    }
    public int getHeight() {
        return height;
    }
    public void setHeight(int height) {
        this.height = height;
    }
    /*
     * 使用第三方生成验证码的jar包 
     *      1.拷贝ValidateCode.jar到工程lib目录 
     *      2.创建ValidateCode的对象
     *      3.获取响应对象输出流 
     *      4.输出到浏览器
     */
    // Servlet的中原来怎么写，现在还怎么写
    @Override
    protected void doExecute(String finalLocation, ActionInvocation invocation) 
            throws Exception {
        // 创建ValidateCode的对象，该对象的构造参数详解：1:图像宽度   2.图像高度   3.数字的格式   4.干扰线条数
        ValidateCode code = new ValidateCode(width, height, 4, 10);
        // 获取响应对象输出流
        HttpServletResponse response = ServletActionContext.getResponse();
        // 输出到浏览器
        code.write(response.getOutputStream());
    }
}

  2、在struts.xml中进行配置，如下所示。
  3、在配置action时，type属性指定声明的结果类型名称。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
    <!-- 自定义结果类型的配置 -->
    <package name="p3" extends="myDefault">
        <!-- 自定义结果类型 -->
        <result-types>
            <result-type name="captcha" class="com.itheima.web.result.CAPTCHAResult"></result-type>
        </result-types>
        <action name="captchaAction" class="com.itheima.web.action.CaptchaAction" >
            <result name="success" type="captcha">
                <!-- 配置图像的大小  --> 
                <param name="width">240</param>
                <param name="height">40</param>
            </result>
        </action>
    </package>
</struts>

  4、建立动作类和动作方法

package com.itheima.web.action;

import com.opensymphony.xwork2.ActionSupport;

public class CaptchaAction extends ActionSupport {
    // 当我们在该动作类中什么都不写，即一个动作方法都不提供时:
    // 会有一个默认的动作方法：public String execute() throws Exception { return SUCCESS; }
}

  5、建立一个jsp页面

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>title</title>

    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">
    <!--
    <link rel="stylesheet" type="text/css" href="styles.css">
    -->
  </head>
  <body>
        <form action="" method="post">
            用户名：<input type="text" name="username"/><br/>
            密码：<input type="password" name="password"/><br/>
            验证码：<input type="text" name="valicateCode"/>
                <img src="${pageContext.request.contextPath}/captchaAction.action"/>
            <br/>
            <input type="submit" value="登录" />
        </form>
  </body>
</html>

4、局部视图和全局视图

  局部视图的配置

十三、Struts2中调用ServletAPI

  获取ServletAPI的两种方式：
    第一种方式：使用的是ServletActionContext的对象（此种方式简单明了，推荐此种方式）
    第二种方式：使用的是依赖注入的形式，把我们想要的对象注入进来，是由一个拦截器为我们做的。需要实现3个接口，实现其中的方法。
  示例代码如下：

package com.itheima.web.action;

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

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

import com.opensymphony.xwork2.ActionSupport;
/**
 * 获取ServletAPI的两种方式： 
 *         第一种方式：使用的是 ServletActionContext 的对象（此种方式简单，推荐此种方式） 
 *         第二种方式：使用的是 依赖注入 的形式，把我们想要的对象注入进来，是由一个拦截器为我们做的。需要实现3个接口，实现其中的方法。
 * 
 * @author cmj
 */
public class Demo1Action extends ActionSupport
        implements ServletRequestAware, ServletResponseAware, ServletContextAware {

    private HttpServletRequest request;
    private HttpServletResponse response;
    private ServletContext application;

    public String execute() {
        // 方式一：使用 ServletActionContext 对象
        // HttpServletRequest request = ServletActionContext.getRequest();
        // HttpServletResponse response = ServletActionContext.getResponse();
        // ServletContext application = ServletActionContext.getServletContext();
        // HttpSession session = request.getSession();
        // System.out.println(request);     // org.apache.struts2.dispatcher.StrutsRequestWrapper@500b3f4c
        // System.out.println(response);    // org.apache.catalina.connector.ResponseFacade@1268bfa2
        // System.out.println(application); // org.apache.catalina.core.ApplicationContextFacade@1afd2e1f
        // System.out.println(session);     // org.apache.catalina.session.StandardSessionFacade@63df0310

        // 方式二：使用依赖注入
        HttpSession session = request.getSession();
        System.out.println(request);    
        System.out.println(response);   
        System.out.println(application);
        System.out.println(session);

        return null;
    }

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

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

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

十四、分文件编写Struts2的配置文件

1、不分文件开发可能产生的问题
  就类似于我们在写java类时，所有代码都写在一个类里，甚至写在一个方法里。

2、分文件编写Struts2的配置文件
我们现在常说的组件式开发，如下图所示：