Struts2学习第三天——拦截器与文件传输

• 内容摘要：

  1.国际化(了解)

  2.拦截器(Interceptor)—重点

  3.struts2文件上传与下载(次重点)

  4.ognl与valuestack

国际化

• 国际化原理，什么是国际化 ？
  • 同一款软件 可以为不同用户，提供不同语言界面 —- 国际化软件
  • 需要一个语言资源包（很多properties文件，每个properties文件 针对一个国家或者语言 ，通过java程序根据来访者国家语言，自动读取不同properties文件 ）
• Java原生国家化操作
• 资源包编写
  • properties文件命名 ： 基本名称_语言（小写）_国家（大写）.properties
  • 例如 ：
    • messages_zh_CN.properties 中国中文
    • messages_en_US.properties 美国英文
• ResourceBundle 根据不同Locale（地域信息），读取不同国家 properties文件

    ResourceBundle bundle = ResourceBundle.getBundle("messages", Locale.US);

struts2中国际化

• struts2中对国际化进行了封装，我们只需要根据其提供的API进行访问就可以。

问题1：在struts2中国际化时properties文件的定义

• 1.全局 : 需要通过一个常量来声明
  • 默认全局路径：
  • 第166行：struts.custom.i18n.resources=testmessages,testmessages2
  • 对于properties配置文件可以放置在任意位置
  • struts.xml配置如下：
    • 当message.properties在src下：<constant name="struts.custom.i18n.resources" value="message">
    • 当message.properties在cn.itcast.i18n.resource包下: <constant name="struts.custom.i18n.resources" value="cn.itcast.i18n.resource.message">

• 2.局部
  • 1.针对于action类
    • 位置:与action类在同一个包下.
    • 名称: ActionClassName.properties
    • 这个配置文件只对当前action有效。
  • 2.针对于package下所有action
    • 位置:在指定的包下
    • 名称:package.properties
  • 3.jsp页面临时使用某一个properties文件.
    • 在某个jsp页面中加入 ： <s:i18n name="cn.itcast.action.package"></s:i18n>

问题2:Struts2中国际化操作在哪些位置使用

• 1.action类中使用
• 2.配置文件中使用<validation.xml>
• 3.在jsp页面上使用

问题3:Struts2中操作国际化

• 1.在action类中使用
  • 前提:action类要继承ActionSupport类。
  • getText(String name)就可以获取配置文件中对应名称的值。
• eg ：

// I18nDemo1Action.properties 中 msg=hello world

    public String execute() throws Exception {

        // 得到properties文件中信息.

        System.out.println(this.getText("msg"));
        return NONE;
    }

    //结果就是 hello world

• 2.在validation.xml文件中使用
  • <message key="名称"/>
  • eg : I18nDemo2Action-validation.xml & xxx.properites

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE validators PUBLIC
        "-//Apache Struts//XWork Validator 1.0.3//EN"
        "http://struts.apache.org/dtds/xwork-validator-1.0.3.dtd">

<validators>
    <field name="name">
        <field-validator type="requiredstring">
            <message key="nameerror"></message>
        </field-validator>

    </field>

</validators>

//properties

//package_en_US.properties
nameerror=name required

//package_zh_CN.properties
nameerror=\u540D\u5B57\u5FC5\u987B\u5730

//package.properties
nameerror=name required

• 3.在jsp页面上使用
  • <s:text name="名称"> :这里名称为对应的Action名称。
  • 如果没有使用<s:i18n name="">来指定，会从全局配置文件中获取。
  • 如果要从某一个配置文件中获取，通过name属性来指定 包名.配置文件名称
• eg : i18n.jsp

  

      <s:i18n name="cn.itcast.action.package">
          <s:text name="nameerror"/>
      </s:i18n>

    <s:text name="name" /> //全局包：cn.itcast.i18n.resource
    //由struts.xml中常量配置决定：
    //<constant name="struts.custom.i18n.resources" value="cn.itcast.i18n.resource.message"></constant>

* Struts2中国际化配置文件中使用动态文本*

• 1.action中动态文本使用
  • I18nDemo1Action.properties 中 : msg=hello world {0}
  • I18nDemo1Action 输出： this.getText(“msg”,new String[]{“tom”})
• eg ：

    public String execute() throws Exception {

        // 得到properties文件中信息.

        //System.out.println(this.getText("msg"));

        //动态文本
        System.out.println(this.getText("msg", new String[]{"tom"}));

        return NONE;
    }

    //结果就是 hello world tom

• 2.jsp页面上怎样使用
  • 在i18n.jsp 中加入 ：

        <s:i18n name="cn.itcast.action.I18nDemo1Action">
        <s:text name="msg">
        <s:param>张三</s:param>
        </s:text>
        </s:i18n>

* 结果就是 hello world  张三.

拦截器(interceptor)

• struts2拦截器使用的是AOP思想。
• AOP的底层实现就是动态代理。
• 拦截器采用 责任链 模式
  • 在责任链模式里,很多对象由每一个对象对其下家的引用而连接起来形成一条链。
  • 责任链每一个节点，都可以继续调用下一个节点，也可以阻止流程继续执行
• struts2中在struts-default.xml文件中声明了所有的拦截器。
• 而struts2框架默认使用的是defaultStack这个拦截器栈。
• 在这个拦截器栈中使用了18个拦截器。
• 简单说，struts2框架在默认情况下，加载了18个拦截器。

Struts2中使用拦截器

• 使用拦截器可以做什么？
  • 可以通过使用拦截器进行控制action的访问。例如，权限操作。

拦截器使用方法

• 1.创建一个Interceptor 可以自定义一个类实现com.opensymphony.xwork2.interceptor.Interceptor在这个接口中有三个方法
  • init
  • destory
  • intercept 真正拦截的方法。
  • 在intercept方法中如果要向下继续执行，通过其参数ActionInvocation调用它的invoke()方法就可以。

public class _MyInterceptor implements Interceptor {
    public void destroy() {
    }

    public void init() {
        System.out.println("my interceptor init");
    }

    public String doIntercept(ActionInvocation ai) throws Exception {

        System.out.println("my interceptor 拦截。。。。。");
        //return ai.invoke(); // 放行
        return Action.LOGIN;  //"login"
    }

}

• 2.声明一个Interceptor 在struts-default.xml文件中
  • eg:

    <interceptor name="my" class="cn.itcast.intercept.MyInterceptor">
    </interceptor>

• 3.在action中指定使用哪些拦截器

<interceptors>
    <interceptor name="my" class="cn.itcast.intercept.MyInterceptor">
    </interceptor>
</interceptors>

• 注意 : 只要显示声明使用了一个拦截器。那么默认的拦截器就不在加载。
  • 如果需要继续使用默认拦截器只需要在struts.xml中设计自己的拦截器栈。

<interceptors>

    <interceptor name="my" class="cn.itcast.intercept.MyInterceptor">
    </interceptor>

    <interceptor name="bookInterceptor" class="cn.itcast.intercept.BookInterceptor">
        <param name="includeMethods">add,update,delete</param>
    </interceptor>

    <interceptor-stack name="myStack">
        <interceptor-ref name="bookInterceptor"></interceptor-ref>
        <interceptor-ref name="defaultStack" />
    </interceptor-stack>
</interceptors>

分析拦截器原理

• 源代码执行流程:
• 1.在StrutsPrepareAndExecuteFilter中查找
  • 在doFilter方法内有一句话 execute.executeAction (request, response, mapping) 执行Action操作.
• 2.在executeAction执行过程中会访问Dispatcher类中的serviceAction，在这个方法中会创建一个
  • ActionProxy proxy = config.getContainer().getInstance(ActionProxyFactory.class).createActionProxy(namespace, name, method, extraContext, true, false); 这就是我们的Action的代理对象
• 3.查看ActionInvocation，查看其实现类 DefaultActionInvocation.
  • 在其invoke方法中

    if (interceptors.hasNext()) {//判断是否有下一个拦截器.
    final InterceptorMapping interceptor = interceptors.next(); //得到一个拦截器
    String interceptorMsg = "interceptor: " + interceptor.getName();
    UtilTimerStack.push(interceptorMsg);
    try {
    resultCode = interceptor.getInterceptor().intercept(DefaultActionInvocation.this);
    //调用得到的拦截器的拦截方法.将本类对象传递到了拦截器中。
    }
    finally {
    UtilTimerStack.pop(interceptorMsg);
    }
    } 

• 通过源代码分析，发现在DefaultActionInvocation中就是通过递归完成所有的拦截调用操作.

关于interceptor与Filter区别

• 1、拦截器是基于java反射机制的，而过滤器是基于函数回调的。
• 2、过滤器依赖于servlet容器，而拦截器不依赖于servlet容器。
• 3、拦截器只能对Action请求起作用，而过滤器则可以对几乎所有请求起作用。
• 4、拦截器可以访问Action上下文、值栈里的对象，而过滤器不能。
• 5、在Action的生命周期中，拦截器可以多次调用，而过滤器只能在容器初始化时被调用一次。
• interceptor 可以在其他环境中使用，而Filter只能在Web环境中使用。

拦截器案例

• 1.login.jsp –> LoginAction –> book.jsp
• 登录成功，将用户存储到session。
• login.jsp

  <body>
    <s:fielderror/>
    <s:actionerror/>

    <form action="${pageContext.request.contextPath }/login" method="post">
        username:<input type="text" name="username"><br>
        password:<input type="password" name="password"><br>

        <input type="submit" value="登录">
    </form>
  </body>

• LoginAction.java

public class LoginAction extends ActionSupport implements ModelDriven<User>{

    private User user = new User();

    public User getModel(){
        return user;
    }
     @Override
    public String execute() throws Exception {

         System.out.println("name: "+user.getUsername());
         System.out.println("password: "+user.getPassword());

        if("miaolu".equals(user.getUsername()) && "123".equals(user.getPassword())){
            ServletActionContext.getRequest().getSession().setAttribute("user", user);
            return SUCCESS;
        }
        else{
            this.addActionError("用户名或密码错误");
            return INPUT;
        }
    }
}

• book.jsp

  <body>
      <a href="${pageContext.request.contextPath}/book_add">book add</a><br>
      <a href="${pageContext.request.contextPath}/book_update">book update</a><br>
      <a href="${pageContext.request.contextPath}/book_delete">book delete</a><br>
      <a href="${pageContext.request.contextPath}/book_search">book search</a><br>
  </body>

• 2.在book.jsp中提供crud链接。
• 每一个连接访问一个BookAction中一个方法。
• 要求:对于BookAction中的add,update,delete方法要求用户必须登录后才可以访问。search无要求。
• BookAction.java

public class BookAction extends ActionSupport {

    public String add() throws Exception{
        System.out.println("book action add");

        return null;
    }

    public String update() throws Exception{
        System.out.println("book action update");

        return null;
    }

    public String delete() throws Exception {

        System.out.println("book action delete");
        return null;
    }

    public String search() throws Exception {

        System.out.println("book action search");
        return null;
    }

}

• 怎样解决只控制action中某些方法的拦截？
  • 1.创建类不在实现Interceptor接口，而是继承其下的一个类.MethodFilterInterceptor
  • 不用在重写intercept方法，而是重写 doIntercept方法。
• BookInterceptor.java

public class BookInterceptor extends MethodFilterInterceptor {

    @Override
    protected String doIntercept(ActionInvocation invocation) throws Exception {

        User user = (User) ServletActionContext.getRequest().getSession().getAttribute("user");

        if(user == null){
            BookAction action = (BookAction) invocation.getAction();

            action.addActionError("权限不足，请先登录");

            return Action.LOGIN;
        }

        return invocation.invoke();
    }
}

• 2.在struts.xml文件中声明

<struts>
    <package name="default" namespace="/" extends="struts-default">

        <interceptors>

            <interceptor name="bookInterceptor" class="test.intercept.BookInterceptor">
                <param name="includeMethods">add,update,delete</param>
                <param name="excludeMethods">search</param>
            </interceptor>

            <interceptor-stack name="myStack">
                <interceptor-ref name="bookInterceptor"></interceptor-ref>
                <interceptor-ref name="defaultStack"/>
            </interceptor-stack>

        </interceptors>

        <global-results>
            <result name = "login">/login.jsp</result>
        </global-results>

        <action name ="login" class="test.action.LoginAction">
            <result name="input">/login.jsp</result>
            <result>/book.jsp</result>
        </action>

        <action name="book_*" class="test.action.BookAction" method="{1}">
            <interceptor-ref name="myStack"/>
        </action>
    </package>

Struts2中文件上传与下载

文件上传

• 浏览器端:
  • 1.method=post
  • 2.<input type="file" name="xx">
  • 3.encType=”multipart/form-data”;
• 服务器端:
  • commons-fileupload组件
    • 1.DiskFileItemFactory
    • 2.ServletFileUpload
    • 3.FileItem
• struts2中文件上传
  • 默认情况下struts2框架使用的就是commons-fileupload组件.
  • struts2它使用了一个interceptor帮助我们完成文件上传操作。
  • <interceptor name="fileUpload" class="org.apache.struts2.interceptor.FileUploadInterceptor"/>
• 在action中怎样处理文件上传?
  • 页面上组件:<input type="file" name="upload">
• 在action中要有三个属性:
  • private File upload; 如果是上传单个文件, upload属性的类型就是 java.io.File, 它代表被上传的文件，要与jsp 页面上的 file 标签的名字相同。
  • private String uploadContentType;表示上传文件的类型，格式：file组件的名称+ContentType
  • private String uploadFileName; 表示上传文件的文件名，格式：file组件的名称+FileName
• 在execute方法中使用commons-io包下的FileUtils完成文件复制.
  • FileUtils.copyFile(upload, new File("d:/upload",uploadFileName));

@Override
    public String execute() throws Exception {
            System.out.println("上传文件的类型:" + uploadContentType);
            System.out.println("上传文件的名称:" + uploadFileName);

            // 完成文件上传.
            FileUtils.copyFile(upload, new File("d:/upload", uploadFileName);
        return null;
    }

• struts.xml 中的配置

<action name="upload" class="cn.itcast.action.UploadAction">
</action>

关于struts2中文件上传细节

• 1.关于控制文件上传大小
• 在default.properties文件中定义了文件上传大小
  • struts.multipart.maxSize=2097152 上传文件默认的总大小 2MB
• 在struts.xml`中通过修改如下参数，进行修改
  • <constant name="struts.multipart.maxSize" value="20971520"></constant>
• 2.在struts2中默认使用的是commons-fileupload进行文件上传。
  • struts.multipart.parser=cos : 上传组件（备用）
  • struts.multipart.parser=pell : 上传组件（备用）
  • struts.multipart.parser=jakarta ： 默认上传方式
  • 如果使用pell,cos进行文件上传，必须导入其jar包.
• 3.如果出现问题，需要配置input视图，在页面上可以通过<s:actionerror>展示错误信息.
• 在页面上展示的英文信息的国际化操作

  

• struts-messages.properties 文件里预定义 上传错误信息，通过覆盖对应key 显示中文信息

struts.messages.error.uploading=Error uploading: {0}
struts.messages.error.file.too.large=The file is to large to be uploaded: {0} "{1}" "{2}" {3}
struts.messages.error.content.type.not.allowed=Content-Type not allowed: {0} "{1}" "{2}" {3}
struts.messages.error.file.extension.not.allowed=File extension not allowed: {0} "{1}" "{2}" {3}

• 上述信息在自己新建的properties文件修改为

struts.messages.error.uploading=上传错误: {0}
struts.messages.error.file.too.large=上传文件太大: {0} "{1}" "{2}" {3}
struts.messages.error.content.type.not.allowed=上传文件的类型不允许: {0} "{1}" "{2}" {3}
struts.messages.error.file.extension.not.allowed=上传文件的后缀名不允许: {0} "{1}" "{2}" {3}

• {0}:<input type=“file” name=“uploadImage”>中name属性的值
• {1}:上传文件的真实名称
• {2}:上传文件保存到临时目录的名称
• {3}:上传文件的类型(对struts.messages.error.file.too.large是上传文件的大小)

• 4.关于多文件上传时的每个上传文件大小控制以及上传文件类型控制
  • 1.多文件上传
    • 服务器端 : 只需要将action属性声明成List集合或数组就可以。

public class UploadAction extends ActionSupport {

    // 在action类中需要声明三个属性
    private List<File> upload;
    private List<String> uploadContentType;
    private List<String> uploadFileName;

    @Override
    public String execute() throws Exception {

        for (int i = 0; i < upload.size(); i++) {

            System.out.println("上传文件的类型:" + uploadContentType.get(i));
            System.out.println("上传文件的名称:" + uploadFileName.get(i));

            // 完成文件上传.
            FileUtils.copyFile(upload.get(i), new File("d:/upload", uploadFileName.get(i)));
        }
        return null;
    }

}

• 2.怎样控制每一个上传文件的大小以及上传文件的类型?
  • 在fileupload拦截器中，通过其属性进行控制.
    • maximumSize—每一个上传文件大小
    • allowedTypes–允许上传文件的mimeType类型.
    • allowedExtensions–允许上传文件的后缀名.
  • 在自定义拦截器配置中加入下代码：

        <interceptor-ref name="defaultStack">
        <param name="fileUpload.allowedExtensions">txt,mp3,doc</param>
        </interceptor-ref>

• eg:

        <action name="upload" class="cn.itcast.action.UploadAction">
            <result name="input">/upload.jsp</result>
            <interceptor-ref name="defaultStack">
                <param name="maximumSize">2097152</param>
                <param name="fileUpload.allowedExtensions">txt,mp3,doc</param>
            </interceptor-ref>
        </action>

文件下载

• 文件下载方式:
  • 1.超连接
  • 2.服务器编码，通过流向客户端写回。
• 过程：
  • 1.通过response设置 response.setContentType(String mimetype);
  • 2.通过response设置 response.setHeader(“Content-disposition;filename=xxx”);
  • 3.通过response获取流，将要下载的信息写出。
• struts2中文件下载
  • 通过<result type="stream">完成。
  • <result-type name="stream" class="org.apache.struts2.dispatcher.StreamResult"/>在StreamResult类中有三个属性:
    • protected String contentType = "text/plain"; : 用于设置下载文件的mimeType类型
      • protected String contentDisposition = "inline"; : 用于设置进行下载操作以及下载文件的名称
      • protected InputStream inputStream; : 用于读取要下载的文件。
• eg:

<action name="download" class="cn.itcast.action.DownloadAction">
    <result type="stream">
        <param name="contentType">${contentType}</param> <!-- 调用当前action中的getContentType()方法 -->
        <param name="contentDisposition">attachment;filename=${downloadFileName}</param>
        <param name="inputStream">${inputStream}</param><!-- 调用当前action中的getInputStream()方法 -->
    </result>
</action>

• 在action类中定义一个方法

public InputStream getInputStream() throws FileNotFoundException {
FileInputStream fis = new FileInputStream("d:/upload/" + filename);
return fis;
}

• 问题1: <a href="${pageContext.request.contextPath}/download?filename=捕获.png">捕获.png</a>下载报错
  • 原因:超连接是get请求，并且下载的文件是中文名称，乱码。

    public InputStream getInputStream() throws FileNotFoundException,
            UnsupportedEncodingException {

        filename = new String(filename.getBytes("iso8859-1"), "utf-8"); // 解决中文名称乱码.

        FileInputStream fis = new FileInputStream("d:/upload/" + filename);
        return fis;
    }

• 问题2:下载捕获文件时，文件名称是a.txt
  • 下载文件后缀名应该是png,而我们在配置文件中规定却是txt?
• struts.xml 修订：

<result type="stream">
<param name="contentType">${contentType}</param> <!-- 调用当前action中的getContentType()方法 -->
<param name="contentDisposition">attachment;filename=${downloadFileName}</param>
<param name="inputStream">${inputStream}</param><!-- 调用当前action中的getInputStream()方法 -->
</result>

// 设置下载文件mimeType类型
    public String getContentType() {

        String mimeType = ServletActionContext.getServletContext().getMimeType(
                filename);
        return mimeType;
    }

// 获取下载文件名称
public String getDownloadFileName() throws UnsupportedEncodingException {

    return DownloadUtils.getDownloadFileName(ServletActionContext
            .getRequest().getHeader("user-agent"), filename);

}

• 在struts2中进行下载时，如果使用<result type="stream">它有缺陷
  • 例如：下载点击后，取消下载，服务器端会产生异常。
  • 在开发中，解决方案:可以下载一个struts2下载操作的插件，它解决了stream问题。

OGNL与ValueStack

OGNL表示式使用

• OGNL是Object Graphic Navigation Language（对象图导航语言）的缩写，它是一个开源项目。 Struts2框架使用OGNL作为默认的表达式语言。
  • xwork 提供 OGNL表达式
  • ognl-3.0.5.jar
• OGNL 是一种比EL 强大很多倍的语言

OGNL 提供五大类功能

• 1、支持对象方法调用，如xxx.doSomeSpecial()；
• 2、支持类静态的方法调用和值访问
• 3、访问OGNL上下文（OGNL context）和ActionContext； （重点 操作ValueStack值栈 ）
• 4、支持赋值操作和表达式串联
• 5、操作集合对象。
• 使用OGNL访问 对象方法 和 静态方法
  • OGNL 在jsp 结合 struts2 标签库 使用 ， <s:property value="ognl表达式" /> 执行 ognl表达式
  • 调用 实例方法 ： 对象.方法() —-> <s:property value="‘hello,world‘.length()"/>
  • 调用 静态方法 ： @[类全名（包括包路径）]@[方法名] —> <s:property value="@[email protected](‘您好,%s‘,‘小明‘)"/>
  • 使用 静态方法调用 必须 设置 struts.ognl.allowStaticMethodAccess=true
• eg : 对象调方法

    public static void main(String[] args) throws OgnlException {
        // ognl可以通过对象调用方法.

        // System.out.println("aaa".length());

        // 使用ognl来完成上面操作.

        // 1.创建一个ognl上下文。
        OgnlContext context = new OgnlContext();

        Object obj1 = Ognl.getValue("‘aaa‘.length()", context.getRoot());

        System.out.println(obj1);

    }

• 静态方法

    public static void main(String[] args) throws OgnlException {
        // ognl可以通过对象调用方法.

        System.out.println(Math.max(10, 20));
        System.out.println(Math.PI);
        // 使用ognl来完成上面操作.

        // 1.创建一个ognl上下文。
        OgnlContext context = new OgnlContext();

        Object obj1 = Ognl.getValue("@[email protected](10,20)", context.getRoot());

        System.out.println(obj1);

        Object obj2= Ognl.getValue("@[email protected]", context.getRoot());

        System.out.println(obj2);

    }

• 访问OGNL上下文（OGNL context）和ActionContext

    public static void main(String[] args) throws OgnlException {

        // 创建一个ognl上下文
        OgnlContext context = new OgnlContext(); // 本质上就是一个Map集合.

        Person p = new Person();
        p.setName("张三");

        Dog dog = new Dog();
        dog.setName("lucy");

        p.setDog(dog); //张三有条狗叫lucy

        context.setRoot(p);

        Dog dog1 = new Dog();
        dog1.setName("豆豆");

        Person pp=new Person();
        pp.setName("james");
        dog1.setP(pp);

        context.put("dog", dog1);

        context.put("name", "tom");

        // 使用 ognl来获取根中数据 获取根中数据，不需要加#
        Object name1 = Ognl.getValue("name", context, context.getRoot());

        System.out.println(name1);

        // 使用ognl来获取非根中的数据 获取非根中数据，需要使用#

        Object name2 = Ognl.getValue("#name", context, context.getRoot());

        System.out.println(name2);

        //获取出张三的的狗的名称
        //张三是root中故直接指向根张三
        Object name3 = Ognl.getValue("dog.name", context, context.getRoot());

        System.out.println(name3);

        //豆豆的主人名称
        Object name4=Ognl.getValue("#dog.p.name", context, context.getRoot());

        System.out.println(name4);

    }
}

//运行结果：
    //张三
    //tom
    //lucy
    //james

* OGNL上下文（OGNL context）对象 值栈 ValueStack *

• 什么是值栈 ValueStack ?
  • ValueStack 是 struts2 提供一个接口，实现类 OgnlValueStack —- 值栈对象 （OGNL是从值栈中获取数据的 ）
  • 每个Action实例都有一个ValueStack对象 （一个请求 对应 一个ValueStack对象 ）
  • 在其中保存当前Action 对象和其他相关对象 （值栈中 是有Action 引用的 ）
  • Struts 框架把 ValueStack 对象保存在名为 “struts.valueStack” 的请求属性中,request中 （值栈对象 是 request一个属性）
• 值栈的内部结构 ？
  • 值栈由两部分组成
    • ObjectStack: Struts 把动作和相关对象压入 ObjectStack 中–List
    • ContextMap: Struts 把各种各样的映射关系(一些 Map 类型的对象) 压入 ContextMap 中,Struts 会把下面这些映射压入 ContextMap 中
      • parameters: 该 Map 中包含当前请求的请求参数
      • request: 该 Map 中包含当前 request 对象中的所有属性
      • session: 该 Map 中包含当前 session 对象中的所有属性
      • application:该 Map 中包含当前 application 对象中的所有属性
      • attr: 该 Map 按如下顺序来检索某个属性: request, session, application
• ValueStack中 存在root属性 (CompoundRoot) 、 context 属性 （OgnlContext ）
  • CompoundRoot 就是ArrayList
  • OgnlContext 就是 Map
• context 对应Map 引入 root对象
  • context中还存在 request、 session、application、 attr、 parameters 对象引用
  • OGNL表达式，访问root中数据时 不需要 #, 访问 request、 session、application、 attr、 parameters 对象数据 必须写 #
  • 操作值栈 默认指 操作 root 元素
• 值栈对象的创建 ，ValueStack 和 ActionContext 是什么关系 ？
  • 值栈对象 是请求时 创建的
  • doFilter中 prepare.createActionContext(request, response);
    • 创建ActionContext 对象过程中，创建 值栈对象ValueStack
    • ActionContext对象 对 ValueStack对象 有引用的 （在程序中 通过 ActionContext 获得 值栈对象 ）
  • Dispatcher类 serviceAction 方法中 将值栈对象保存到 request范围
    • request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, proxy.getInvocation().getStack());
• 获得值栈对象的两种方法
  • ValueStack valueStack = (ValueStack) ServletActionContext.getRequest().getAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY);
  • ValueStack valueStack2 = ActionContext.getContext().getValueStack();
• 向值栈保存数据 （主要针对 root）的两种方式
  • 将数据保存root的索引0位置，放置到第一个元素
    • ArrayList add(0,element);
    • valueStack.push(“itcast”);
  • 在值栈创建参数map， 将数据保存到map中
    • valueStack.set(“company”, “传智播客”);
  • 在jsp中 通过 <s:debug /> 查看值栈的内容
• 在JSP中获取值栈的数据
  • 访问root中数据 不需要#
  • 访问 其它对象数据 加 #
• 通过下标获取root中对象
  • <s:property value="[0].top"/> //取值栈顶对象
• 直接在root中查找对象属性 （自上而下自动查找）
  • valueStack:<s:property value="username"/>
• 在OgnlContext中获取数据

request:<s:property value="#request.username"/>
session:<s:property value="#session.username"/>
application:<s:property value="#application.username"/>
attr:<s:property value="#attr.username"/>
parameters:<s:property value="#parameters.cid[0]"/>