文档章节

Struts2学习整理

Lunqi
 Lunqi
发布于 2015/09/10 22:41
字数 7760
阅读 6241
收藏 26

Struts2的相关配置文件

    * default.properties        -- 在org/apache/struts2/目录下,代表的是配置的是Struts2的常量的值

    * struts-default.xml        -- 在Struts2的核心包下,代表的是Struts2核心功能的配置(Bean、拦截器、结果类型等)

    * struts-plugin.xml         -- 配置插件的信息

    * struts.xml                -- 重点中的重点配置,代表WEB应用的默认配置,可以配置常量,基本就配置它就可以

    * struts.properties         -- 该文件是Struts的默认配置文件  (可以配置常量 )

    * web.xml                   -- 配置前端控制器(可以配置常量)


注意:后加载的配置文件会覆盖掉之前加载的配置文件(在这些配置文件中可以配置常量)



Struts2核心配置文件Struts2.xml的配置入门


  <package>标签

如果要配置<Action>的标签,那么必须要先配置<package>标签,代表的包的概念。

包含的属性

name         包的名称,要求是唯一的,管理action配置。

extends      继承,可以继承其他的包,只要继承了,那么该包就包含了其他包的功能,一般都是继承struts-default

namespace  名称空间,一般与<action>标签中的name属性共同决定访问路径,常见的配置如下:

                * namespace=""      -- 默认的名称空间(访问的方式和namespace="/"是一样的)

                * namespace="/"     -- 根名称空间

                * namespace="/aaa"  -- 带有名称的名称空间

                * abstract          -- 抽象的。这个属性基本很少使用,值如果是true,那么编写的包是被继承的。     


<action>标签

 代表配置action类,包含的属性

name              和<package>标签的namespace属性一起来决定访问路径的。

class                配置Action类的全路径(默认值是ActionSupport类)

 method          Action类中执行的方法,如果不指定,默认值是execute


<result>标签

action类中方法执行,返回的结果跳转的页面

name      结果页面逻辑视图名称

type        结果类型(默认值是转发,也可以设置其他的值)



默认的Action和Action默认的处理类

 默认的Action

 在地址栏上输入一个不存在的action请求,程序会报404的异常。

 但是在<package>标签中通过<default-action-ref name="指定action标签name属性"></default-action-ref>来该请求。


Action默认处理类

 在地址栏上输入一个正确的action请求,但是<action>标签中的class属性没有写具体的Action类

 在<package>标签中通过<default-class-ref class="指定action类的全路径"></default-class-ref>


Struts2配置常用的常量

可以在Struts2框架中的哪些配置文件中配置常量

struts.xml

 <constant name="key" value="value"></constant>

web.xml

在StrutsPrepareAndExecuteFilter配置文件中配置初始化参数


struts.i18n.encoding=UTF-8            指定默认编码集,作用于HttpServletRequest的setCharacterEncoding方法 

struts.action.extension=action,,       该属性指定需要Struts 2处理的请求后缀,该属性的默认值是action,即所有匹配*.action的请求都由Struts2处理。如果用户需要指定多个请求后缀,则多个后缀之间以英文逗号(,)隔开

 struts.serve.static.browserCache=true     设置浏览器是否缓存静态内容,默认值为true(生产环境下使用),开发阶段最好关闭 

struts.configuration.xml.reload=false     当struts的配置文件修改后,系统是否自动重新加载该文件,默认值为false(生产环境下使用),开发阶段最好打开 

struts.devMode = false                    开发模式下使用,这样可以打印出更详细的错误信息 

struts.enable.DynamicMethodInvocation = true  开启对Action的动态方法访问


指定多个struts的配置文件

在大部分应用里,随着应用规模的增加,系统中Action的数量也会大量增加,导致struts.xml配置文件变得非常臃肿。

为了避免struts.xml文件过于庞大、臃肿,提高struts.xml文件的可读性,我们可以将一个struts.xml配置文件分解成多个配置文件,然后在struts.xml文件中包含其他配置文件。

可以在<package>标签中,使用<include>标签来引入其他的struts_xx.xml的配置文件。例如:

    <struts>
<include file="struts-part1.xml"/>
<include file="struts-part2.xml"/>
    </struts>



实现Action的三种方式


Action类就是一个POJO类

POJO类:

POJO(Plain Ordinary Java Object)简单的Java对象。简单来说,没有继承某个类,没有实现接口,就是POJO的类。


Action类可以实现Action接口

Action接口中定义了5个常量,5个常量的值对应的是5个逻辑视图跳转页面(跳转的页面还是需要自己来配置),还定义了一个方法,execute方法。

大家需要掌握5个逻辑视图的常量

SUCCESS       -- 成功.

INPUT         -- 用于数据表单校验.如果校验失败,跳转INPUT视图.

LOGIN         -- 登录.

ERROR         -- 错误.

NONE          -- 页面不转向.


Action类可以去继承ActionSupport类

对请求参数进行校验

设置错误信息

读取国际化信息



在Action中获取Servlet相关API的三种方式


在Action类中也可以获取到Servlet一些常用的API,有如下三种方式获取

    * 完全解耦合的方式

    * 使用接口注入的方式

    * 使用ServletActionContext中静态方法直接访问Servlet的API



完全解耦合的方式

如果使用该种方式,Struts2框架中提供了一个类,ActionContext类,该类中提供一些方法,通过方法获取Servlet的API

 一些常用的方法如下:

static ActionContext getContext()        获取ActionContext对象实例

java.util.Map<java.lang.String,java.lang.Object> getParameters()      获取请求参数,相当request.getParameterMap();

 java.util.Map<java.lang.String,java.lang.Object> getSession()     获取的代表session域的Map集合,就相当于操sessio域

 java.util.Map<java.lang.String,java.lang.Object> getApplication()    获取代表application域的Map集合

  void put(java.lang.String key, java.lang.Object value)         注意:向request域中存入值。



使用接口注入的方式

Struts2框架中提供了一些接口,编写的Action类可以是去实现这些接口,然后实现这些接口中的方法,这些方法都是把一些Servlet的常用对象通过参数的方式传递进来。

    常用的接口如下:

        * ServletRequestAware       -- 注入request

        * ServletContextAware       -- 注入ServletContext

        * ServletResponseAware      -- 注入response.


使用ServletActionContext中静态方法直接访问Servlet的API

    Struts2框架提供了一个类,ServletActionContext,该类中提供了一些静态的方法

     具体的方法如下

        * getPageContext();

        * getRequest()

        * getResponse();

        * getServletContext();



访问Action的三种方式

通过<action>标签中的method属性,访问到Action中的具体的方法


传统的配置方式

    具体的实例如下:

        页面代码

      <a href="${pageContext.request.contextPath}/addBook.action">添加图书</a>
            <a href="${pageContext.request.contextPath}/deleteBook.action">删除图书</a>


         配置文件的代码

            <package name="demo" extends="struts-default" namespace="/">
                <action name="addBook" class="cn.zlq.demo.BookAction" method="add"></action>
                <action name="deleteBook" class="cn.zlq.demo.BookAction" method="delete"></action>
            </package>


         Action的代码

            public String add(){
                System.out.println("添加图书");
                return NONE;
            }
            public String delete(){
                System.out.println("删除图书");
                return NONE;
            }


通配符的访问方式

使用通配符的方式可以简化配置文件的代码编写,而且扩展和维护比较容易。

具体实例如下:

  页面代码

  <a href="${pageContext.request.contextPath}/order_add.action">添加订单</a>
            <a href="${pageContext.request.contextPath}/order_delete.action">删除订单</a>


 配置文件代码

 <action name="order_*" class="cn.zlq.demo.OrderAction" method="{1}"></action>


  Action的代码

    public String add(){
                System.out.println("添加订单");
                return NONE;
            }
            public String delete(){
                System.out.println("删除订单");
                return NONE;
            }


 通配符更抽象的写法

具体的实例如下:

页面的代码

   <a href="${pageContext.request.contextPath}/OrderAction_add.action">添加订单</a>


配置文件代码

 <action name="*_*" class="cn.zlq.demo.{1}" method="{2}"></action>


 Action的代码

            public class OrderAction extends ActionSupport{
                public String add(){
                    System.out.println("添加订单");
                    return NONE;
                }
            }


动态方法访问的方式 

 如果想完成动态方法访问的方式需要开启一个常量,struts.enable.DynamicMethodInvocation = false,把值设置成true。

 注意:不同的Struts2框架的版本,该常量的值不一定是true或者false,需要自己来看一下。如果是false,需要自己开启。

 在struts.xml中开启该常量。

             

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


具体代码如下

页面的代码

            <a href="${pageContext.request.contextPath}/product!add.action">添加商品</a>
            <a href="${pageContext.request.contextPath}/product!delete.action">删除商品</a>

配置文件代码

   

        <action name="product" class="cn.zlq.demo.ProductAction"></action>

 Action的类的代码

         

  public class ProductAction extends ActionSupport{
                public String add(){
                    System.out.println("添加订单");
                    return NONE;
                }
                public String delete(){
                    System.out.println("删除订单");
                    return NONE;
                }
            }


对结果页面的跳转

结果页面存在两种方式

 全局结果页面

条件:

如果<package>包中的一些action都返回success,并且返回的页面都是同一个JSP页面,这样就可以配置全局的结果页面。

 全局结果页面针对的当前的包中的所有的Action,但是如果局部还有结果页面,会优先局部的。

使用的标签是

            <global-results>
                <result>/demo/suc.jsp</result>
            </global-results>


局部结果页面

        <result>/demo/suc.jsp</result>


结果页面的类型

结果页面使用<result>标签进行配置,包含两个属性

        name  -- 逻辑视图的名称

        type  -- 跳转的类型,值一些,需要掌握一些常用的类型。常见的结果类型去struts-default.xml中查找。

            * dispatcher        -- 转发.type的默认值.Action--->JSP

            * redirect          -- 重定向. Action--->JSP

            * chain             -- 多个action之间跳转.从一个Action转发到另一个Action.  Action---Action

            * redirectAction    -- 多个action之间跳转.从一个Action重定向到另一个Action. Action---Action

            * stream            -- 文件下载时候使用的.

 注意:当使用一个Action标签完成多个Action配置时,会出现Input结果视图冲突的情况,也就是说,在不同逻辑中跳入的input逻辑视图是同一个,此时我们可以在自己的Action方法上加上 @InputConfig(resultName="逻辑视图的名称")的注解然后再在Result中配置即可。

    这个为什么这样呢?大家可以看源码:




Struts2的Action对数据封装的两种方式


属性驱动

提供对应属性的set方法进行数据的封装

   * 表单的哪些属性需要封装数据,那么在对应的Action类中提供该属性的set方法即可

   * 表单中的数据提交,最终找到Action类中的setXxx的方法,最后赋值给全局变量。

   * 注意:Struts2的框架采用的拦截器完成数据的封装。

   * 注意:这种方式不是特别好:因为属性特别多,提供特别多的set方法,而且还需要手动将数据存入到对象中.

   * 注意:这种情况下,Action类就相当于一个JavaBean,就没有体现出MVC的思想,Action类又封装数据,又接收请求处理,耦合性较高。


在页面上,使用OGNL表达式进行数据封装

   * 在页面中使用OGNL表达式进行数据的封装,就可以直接把属性封装到某一个JavaBean的对象中。

   * 在页面中定义一个JavaBean,并且提供set方法:例如:private User user;

   * 页面中的编写发生了变化,需要使用OGNL的方式,表单中的写法:<input type="text" name="user.username">

   * 注意:只提供一个set方法还不够,如果没有user实例化,必须还需要提供user属性的get和set方法,先调用get方法,判断一下是否有user对象的实例对象,如果没有,调用set方法把拦截器创建的对象注入进来。


模型驱动

使用模型驱动的方式,也可以把表单中的数据直接封装到一个JavaBean的对象中,并且表单的写法和之前的写法没有区别!

编写的页面不需要任何变化,正常编写name属性的值。

模型驱动的编写步骤

   * 手动实例化JavaBean,即:private User user = new User();

   * 必须实现ModelDriven<T>接口,实现getModel()的方法,在getModel()方法中返回user即可!!

Struts2的Action对集合对象的封装的两种方式

封装复杂类型的参数(集合类型 Collection 、Map接口等)

需求:页面中有可能想批量添加一些数据,那么现在就可以使用上述的技术了。把数据封装到集合中。

把数据封装到Collection中

   * 因为Collection接口都会有下标值,所有页面的写法会有一些区别,注意:

 <input type="text" name="products[0].name" />

   * 在Action中的写法,需要提供products的集合,并且提供get和set方法。

把数据封装到Map中

   * Map集合是键值对的形式,页面的写法

<input type="text" name="map['one'].name" />

   * Action中提供map集合,并且提供get和set方法。


在Action中不推荐使用模型驱动的方式来封装数据到集合中。


Struts2对数据的类型转换

Struts2中自带类型转换拦截器

Struts2内部提供了大量转换器,用来完成数据类型转换的问题,有如下

   * boolean 和 Boolean

   * char和 Character

   * int 和 Integer

   * long 和 Long

   * float 和 Float

   * double 和 Double

   * Date 可以接收 yyyy-MM-dd 格式字符串

   * 数组 可以将多个同名参数,转换到数组中

   * 集合 支持将数据保存到 List 或者 Map 集合

当发生类型转换错误的时候,根据报错的信息提示,跳转input类型的结果视图。

   * 说明如果程序出现异常,会跳转到input结果视图,那可以在<action>标签中配置input结果视图

在跳转的页面中可以通过一个固定的标签来显示错误的信息:

* 可以先需要先引入Struts2的标签库,然后使用标签显示错误!

<%@ taglib prefix="s" uri="/struts-tags" %>

* <s:fielderror/>,这是Struts2提供的标签,使用它显示错误的提示信息。


如果类型转换的拦截器中发生了错误,那么会把错误信息放在Struts2错误区域中(Struts2的错误区域分成两部分,一部分是字段错误,一部分是Actionc错误)

* 等执行到最后一个拦截器(workflow)时,workflow拦截器会去Struts2的错误区域中找是否存在错误。

* 如果存在错误,就跳转到input视图。

* 如果不存在错误,执行目标Action类中具体的方法。


自定义类型转换器

如果一些特殊的数据类型不能转换,那么需要自定义数据类型的转换器。

开发自定义类型转换的开发步骤

编写类型转换器

        实现TypeConverter接口,实现一个方法

Object convertValue(Map<String,Object> context,Object target, Member member,String propertyName,Object value,Class toType);

        继承DefaultTypeConverter类,重写一个方法

Object convertValue(Map<String,Object> context,Object value,Class toType)

        继承StrutsTypeConverter类,重写两个方法

  Object convertFromString(Map context,String[] values,Class toClass)

                > 从字符串转换成具体类型

                > values数组,存入的值就是用户输入的值

                > toClass 要转换的数据的类型 Date.class

            * String convertToString(Map context,Object o)

                > 把具体的类型转换成字符串

                > o 代表的要转换的数据

注意:类型转换本身就是一个双向的过程:

* JSP ---> Action   String ---> 某个类型

* Action ---> JSP   某个类型 ---> String                


 * 类型转换的代码,以 1990/10/10 为例,自定义日期转换器,完成转换,下面这段代码是第二种方法,也就是继承了DefaultTypeConverter类。

  public Object convertValue(Map<String, Object> context, Object value,
            Class toType) {
            // 根据toType判断 是请求封装 还是 数据回显
            DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");
            if (toType == Date.class) {
                // 请求参数封装 (value是字符串)
                String[] params = (String[]) value;
                String strVal = params[0]; // 转换为 日期类型
                try {
                    return dateFormat.parse(strVal);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
            } else {
                // 回显(value是 Date)
                Date date = (Date) value;
                return dateFormat.format(date);
            }
            return null;
        }


 注册类型转换器

局部注册:针对某个表单中的某个字段生效的!

            * 属性驱动的方式:使用set方法接收数据

                > 注意:在Action所在的包下创建一个文件,文件的格式是:Action类名-conversion.properties文件,该文件中配置要转换数据的字段和对应的转换器全路径

                    * 例如:birthday=cn.zlq.demo3.MyDateConverter

            * 模型驱动的方式:实现ModelDriven接口的方式

                > 注意:在实体类所在的包下创建一个文件,文件的格式是:实体类名-conversion.properties文件,该文件中配置要转换数据的字段和对应的转换器全路径

                    * 例如:birthday=cn.zlq.demo3.MyDateConverter


全局注册:针对整个项目的所有的日期类型都会生效的!

            * 在src的目录下,创建一个xwork-conversion.properties  (名称是固定的)

                > 例如:java.util.Date=cn.zlq.demo3.MyDateConverter


Struts2对数据的校验的两种方式


数据校验包含两种方式,第一种是手动编码完成数据校验方式,第二种是通过配置文件完成数据校验方式。

手动编码校验方式

开发的步骤

        > 步骤一: 封装数据 

        > 步骤二: 实现校验Action ,必须继承ActionSupport 类 

        > 步骤三: 覆盖validate方法,完成对Action的业务方法 数据校验 this.addFieldError (ActionSupport提供)

        > 步骤四: 在jsp中 通过 <s:fieldError/> 显示错误信息


针对的是Action中所有的方法进行校验

 让Action继承ActionSupport类,重写ActionSupport类中的validate()方法,在该方法中完成数据校验。


 针对的是Action中某个方法完成校验

 手动在Action中编写一个方法,方法名称是validate方法名称()  例如:public void validateAdd(){  }

            * Action中有一个save的方法,只校验save方法。

            * validateSave()    -- 使用该方法去校验save的方法



通过XML配置文件的方式完成数据的校验

 xml配置校验原理 : 将很多校验规则代码已经写好,只需要在xml中定义数据所使用校验规则就可以了 

开发的步骤

        > 步骤一 :编写jsp

        > 步骤二 :编写Action 继承ActionSupport 或者 实现 Validateable 接口 

        > 步骤三 :封装请求参数

            * 使用xml校验 必须提供get方法

        > 步骤四 :编写校验规则xml文件 

            * 具体的配置文件相关标签和属性详解

<field name="password">
                    <!-- 校验器类型 -->
                    <field-validator type="requiredstring">
                        <message>密码不能为空</message>
                    </field-validator>
                    <!-- 规定密码的长度 -->
                    <field-validator type="stringlength">
                        <param name="minLength">3</param>
                        <param name="maxLength">8</param>
                        <message>密码在3-8位之间</message>
                    </field-validator>
                </field>

针对的是Action中所有的方法进行校验

        > 在Action所在的包中创建一个XML文件,命名规则:Action类名-validation.xml。并且需要引入指定的DTD的约束:xwork-core-2.3.15.3.jar/xwork-validator-1.0.3.dtd


        > 具体的值:

<!DOCTYPE validators PUBLIC
                "-//Apache Struts//XWork Validator 1.0.3//EN"
                "http://struts.apache.org/dtds/xwork-validator-1.0.3.dtd">


针对的是Action中的某个方法进行校验

 在Action所在的包中创建一个XML文件,命名规则:Action类名-方法对应的访问路径-validation.xml。引入DTD文件等。

            * 例如:Reg6Action-reg6-validation.xml



Struts2框架提供的XML校验规则

    * required (必填校验器,要求被校验的属性值不能为null),空格没问题。

    * requiredstring (必填字符串校验器,要求被校验的属性值不能为null,并且长度大于0,默认情况下会对字符串去前后空格)

    * stringlength (字符串长度校验器,要求被校验的属性值必须在指定的范围内,否则校验失败,minLength参数指定最小长度,maxLength参数指定最大长度,trim参数指定校验field之前是否去除字符串前后的空格)

    * regex (正则表达式校验器,检查被校验的属性值是否匹配一个正则表达式,expression参数指定正则表达式,caseSensitive参数指定进行正则表达式匹配时,是否区分大小写,默认值为true)

    * int(整数校验器,要求field的整数值必须在指定范围内,min指定最小值,max指定最大值)

    * double(双精度浮点数校验器,要求field的双精度浮点数必须在指定范围内,min指定最小值,max指定最大值)

    * fieldexpression (字段OGNL表达式校验器,要求field满足一个ognl表达式,expression参数指定ognl表达式,该逻辑表达式基于ValueStack进行求值,返回true时校验通过,否则不通过)

    * email(邮件地址校验器,要求如果被校验的属性值非空,则必须是合法的邮件地址)

    * url(网址校验器,要求如果被校验的属性值非空,则必须是合法的url地址)

    * date(日期校验器,要求field的日期值必须在指定范围内,min指定最小值,max指定最大值)




Struts2的拦截器

原理

* 拦截器就是AOP(Aspect-Oriented Programming)的一种实现。

    * 过滤器:过滤从客服端发送到服务器端请求的.


    * 拦截器:拦截对目标Action中的某些方法进行拦截.

        * 拦截器不能拦截JSP.

        * 拦截到Action中某些方法.


拦截器和过滤器的区别

    1)拦截器是基于JAVA反射机制的,而过滤器是基于函数回调的。

    2)过滤器依赖于Servlet容器,而拦截器不依赖于Servlet容器

    3)拦截器只能对Action请求起作用,而过滤器可以对几乎所有的请求起作用。

    4)在Action的生命周期中,拦截器可以多次被调用,而过滤器只能在容器初始化时被调用一次   

    * 拦截器 采用 责任链 模式

        > 在责任链模式里,很多对象由每一个对象对其下家的引用而连接起来形成一条链。

        > 责任链每一个节点,都可以继续调用下一个节点,也可以阻止流程继续执行


    * 在struts2 中可以定义很多个拦截器,将多个拦截器按照特定顺序 组成拦截器栈 (顺序调用 栈中的每一个拦截器 )


Struts2的自定义拦截器

编写拦截器

需要实现Interceptor接口,实现接口中的三个方法。

    * interceptor接口有很多的实现类,编写最简单的方式就是继承AbstractInterceptor实现类。      

    * 代码例如:

 public String intercept(ActionInvocation invocation) throws Exception {
        User user = (User) ServletActionContext.getRequest().getSession().getAttribute("existUser");
            if(user == null){
                ActionSupport as = (ActionSupport) invocation.getAction();
                as.addActionError("您没有登陆!");
                return as.LOGIN;
            }else{
                // 放行
                return invocation.invoke();
            }
        }


需要在struts.xml中进行拦截器的配置

配置一共有两种方式

 第一种方式

            在<package>包中定义拦截器,出现在<package>包的上方

  <interceptors>
     <interceptor name="loginInterceptor" class="cn.zlq.interceptor.LoginInterceptor"></interceptor>
   </interceptors>

             在某个action中引入拦截器

  <interceptor-ref name="loginInterceptor"></interceptor-ref>

注意:如果引入了自己定义的拦截器,那么Struts2框架默认的拦截器就不会再执行了,所以需要引入Struts2默认的拦截器。

<interceptor-ref name="defaultStack"></interceptor-ref>

 第二种方式

                在<package>包中定义拦截器的时候,自己直接定义一个拦截器栈

<interceptors>
   <interceptor name="loginInterceptor" class="cn.zlq.interceptor.LoginInterceptor"/>
   <interceptor-stack name="myStack">
           <interceptor-ref name="loginInterceptor"/>
           <interceptor-ref name="defaultStack"/>
    </interceptor-stack>
 </interceptors>

            在Action包中引入自己定义的拦截器栈

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



Struts2的文件上传

Struts2框架的使用拦截器完成了文件上传

底层使用也是FileUpload开源的组件。

    * 提供 FileUpload 拦截器,用于解析 multipart/form-data 编码格式请求,解析上传文件的内容 

    * fileUpload拦截器 默认在 defaultStack 栈中, 默认会执行的 


    * 在Action中编写文件上传,需要定义三个属性

        文件类型File ,属性名与表单中file的name属性名一致.

        字符串类型String , 属性名:前段是name属性名一致 +ContentType;

        字符串类型String , 属性名:前段是name属性名一致+FileName;


        最后需要为上述的三个属性提供set方法。

        可以通过FileUtils提供 copyFile 进行文件复制,将上传文件 保存到服务器端 


文件上传中存在的问题

    * 先配置input逻辑视图

    * 在页面中显示错误信息


    * 文件上传的总大小默认值是2M,如果超过了2M,程序会报出异常。可以使用<s:actionError>来查看具体信息!

        > 解决总大小的设置,找到常量:

            * struts.multipart.parser=jakarta       -- 默认文件上传解析器,就是FileUpload组件

            * struts.multipart.saveDir=             -- 文件上传的临时文件存储目录

            * struts.multipart.maxSize=2097152      -- 文件上传的最大值(总大小),默认是2M


        > 可以在struts.xml中设置常量,修改文件上传的默认总大小!!!

          <constant name="struts.multipart.maxSize" value="5000000"></constant>


通过拦截器来设置文件上传的一些属性

 先在<action>标签中引入文件上传的拦截器

     

  <interceptor-ref name="defaultStack">
            <!-- 设置单个上传文件的大小 -->
            <param name="fileUpload.maximumSize">2097152</param>
            <!-- 设置扩展名 -->
            <param name="fileUpload.allowedExtensions">.txt</param>
        </interceptor-ref>


多文件上传

    * 在Action中还是编写三个属性

        > 属性需要是数组或者List集合,这样就可以完成多文件上传了。        

        > 注意:是数组或者List集合        

        private File [] upload;             // 代表上传的文件

        private String [] uploadContentType;    // 代表文件的类型

        private String [] uploadFileName;       // 上传文件的名称


         提供属性的set方法


Struts2的文件下载


Action类必须要有返回结果,并且返回结果中必须要依赖stream结果类型。

    * 在<action>标签中配置stream的结果类型。

    * 可以通过<result-type name="stream" class="org.apache.struts2.dispatcher.StreamResult"/>源码发现有一些需要设置的属性。

     

  <result name="success" type="stream">
            <param name="contentType">${contentType}</param>
            <param name="contentDisposition">attachment;filename=${downFileName}</param>
            <param name="inputName"></param>
   </result>

上面的代码的${contentType}这种写法需要Action类提供对应的方法,对应的方法如下

  // 获取文件的MIME类型
        public String getContentType(){
            return ServletActionContext.getServletContext().getMimeType(filename);
        }       
        // 设置文件的输入流
        public InputStream getInputStream(){
         return ServletActionContext.getServletContext().getResourceAsStream("/download/"+filename);
        }
        // 设置Content-Disposition属性
        public String getDownFilename() throws IOException{
            String agent = ServletActionContext.getRequest().getHeader("User-Agent");
            return this.encodeDownloadFilename(filename, agent);
        }

解决下载文件中文乱码的问题

 

 public String encodeDownloadFilename(String filename, String agent) throws IOException{
if(agent.contains("Firefox")){ // 火狐浏览器
    filename = "=?UTF-8?B?"+new BASE64Encoder().encode(filename.getBytes("utf-8"))+"?=";
}else{ // IE及其他浏览器
    filename = URLEncoder.encode(filename,"utf-8");
}
return filename;
    }



OGNL表达式

OGNL是Object Graphic Navigation Language(对象图导航语言)的缩写,它是一个开源项目。

    * 所谓对象图,即以任意一个对象为根,通过OGNL可以访问与这个对象关联的其它对象。

    * 通过它简单一致的表达式语法,可以存取对象的任意属性,调用对象的方法,遍历整个对象的结构图,实现字段类型转化等功能。它使用相同的表达式去存取对象的属性。


Struts2框架使用OGNL作为默认的表达式语言

    * OGNL是一种比EL强大很多倍的语言 

    * xwork 提供 OGNL表达式 


OGNL 提供五大类功能 

   * 支持对象方法调用,如xxx.doSomeSpecial(); 

   * 支持类静态的方法调用和值访问

   * 访问OGNL上下文(OGNL context)和ActionContext; (重点 操作ValueStack值栈 )

   * 支持赋值操作和表达式串联

   * 操作集合对象。




值栈

    * 值栈就相当于Struts2框架的数据的中转站,向值栈存入一些数据。从值栈中获取到数据。

    * ValueStack 是 struts2 提供一个接口,实现类 OgnlValueStack ---- 值栈对象 (OGNL是从值栈中获取数据的 )

    * Action是多例的,有一起请求,创建Action实例,创建一个ActionContext对象,代表的是Action的上下文对象,还会创建一个ValueStack对象。线程安全的

    * 每个Action实例都有一个ValueStack对象 (一个请求 对应 一个ValueStack对象 )

    * 在其中保存当前Action 对象和其他相关对象 (值栈中 是有Action 引用的 )

    * Struts 框架把 ValueStack 对象保存在名为 “struts.valueStack” 的请求属性中,request中 (值栈对象 是 request一个属性)

        * ValueStack vs = (ValueStack)request.getAttribute("struts.valueStack");


值栈的内部结构 

    * 值栈由两部分组成

        > root      -- Struts把动作和相关对象压入 ObjectStack 中--List

        > context   -- Struts把各种各样的映射关系(一些 Map 类型的对象) 压入 ContextMap 中


    * Struts 会把下面这些映射压入ContextMap中

        > parameters: 该 Map 中包含当前请求的请求参数  ?name=xxx&password=123

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


值栈对象的创建

    * 值栈对象是请求时创建的

    * ActionContext是绑定到当前的线程上,那么在每个拦截器或者Action中获取到的ActionContext是同一个。

    * ActionContext中存在一个Map集合,该Map集合和ValueStack的contextMap是同一个地址。

    * ActionContext中可以获取到ValueStack的引用。

    



Action中获取值栈对象的三种方法

        * ValueStack vs1 = (ValueStack) ServletActionContext.getRequest().getAttribute("struts.valueStack");

        * ValueStack vs2 = (ValueStack) ServletActionContext.getRequest().getAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY);

        * ValueStack vs3 = ActionContext.getContext().getValueStack();



向值栈保存数据

    向值栈保存数据,主要针对 root

    * 两种方式

        valueStack.push(Object obj);

            * push方法的底层调用root对象的push方法(把元素添加到0位置)

        valueStack.set(String key, Object obj);

            * 源码获取map集合(map有可能是已经存在的,有可能是新创建的),把map集合push到栈中,再把数据存入到map集合中。

        在jsp中 通过 <s:debug /> 查看值栈的内容 


    *属性驱动方式:

当ActionContext中提供了一个JavaBean的get方法,就能不将这个JavaBean放到值栈中而取到这个值

这是因为值栈的中有ActionContext对象,可以通过这个对象取到JavaBean


    *模型驱动方式:

当Action中通过模型驱动获取到对象的时候,会将模型驱动中的对象压入值栈的root栈顶,所以此时可以获取到通过Action模型驱动封装的对象


EL 表达式获取值栈中的数据

* StrutsPreparedAndExecuteFilter的doFilter代码中 request = prepare.wrapRequest(request);    

        对Request对象进行了包装 ,StrutsRequestWrapper 

        增强了request的 getAttribute

            Object attribute = super.getAttribute(s);

            if (attribute == null) {

               attribute = stack.findValue(s);

            }

        访问request范围的数据时,如果数据找不到,去值栈中找 

        request对象 具备访问值栈数据的能力 (查找root的数据)



在JSP页面中获取值栈中的值

具体在Struts2中怎么使用呢?如下步骤:

    * 需要先引入Struts2的标签库

         <%@ taglib prefix="s" uri="/struts-tags" %>

    * 使用Struts2提供的标签中的标签

         <s:property value="OGNL表达式"/>


在JSP页面使用OGNL表达式

    * 访问对象方法:

        <s:property value="'hello'.length()"/>

    * 访问对象的静态方法:

        > struts2中静态方法访问被禁止的.开启一个常量.

        <constant name="struts.ognl.allowStaticMethodAccess" value="true"/>

        > 在页面中:

        <s:property value="@java.lang.Math@random()"/>



使用OGNL表达式获取值栈中的数据

# 符号

        <s:property value="#request.name"/>

        <s:property value="#session.name"/>

        <s:property value="#application.name"/>

        <s:property value="#attr.name"/>

        <s:property value="#parameters.id"/>

        <s:property value="#parameters.name"/>



%号

强制字符串解析成OGNL表达式。

         例如:在request域中存入值,然后在文本框(<s:textfield>)中取值,现在到value上。

         <s:textfield value="%{#request.msg}"/>


{ }中值用''引起来,此时不再是ognl表达式,而是普通的字符串

        例如:<s:property value="%{'#request.msg'}"/> 



$号

在配置文件中可以使用OGNL表达式


© 著作权归作者所有

Lunqi

Lunqi

粉丝 41
博文 35
码字总数 29786
作品 1
杭州
程序员
私信 提问
?为什么要学这个技术(有什么优秀的地方,可以解决哪些问题?

今天来总结一下Struts2的知识点,学习编程我的思路一般是这样的:     ① why ?为什么要学这个技术(有什么优秀的地方,可以解决哪些问题?)。     ②what ? 这个技术是什么玩意?有...

SEOwhywhy
05/26
10
0
【学习笔记9】Struts2的处理流程与Action的管理方式

StrutsPrepareAndExecuteFilter是Struts 2框架的核心控制器,它负责拦截由<url-pattern>/*</url-pattern>指定的所有用户请求,当用户请求到达时,该Filter会过滤用户的请求。默认情况下,如果...

张超
2013/04/14
37
0
【学习笔记3】解决struts2配置文件无提示问题

在没有连接到互联网的情况下,编辑struts.xml文件时可能会没有代码提示,怎么解决呢?方法如下: 1、查看struts.xml,找到<!DOCTYPE>中对dtd的描写:http://struts.apache.org/dtds/struts-...

张超
2013/03/18
84
0
【学习笔记6】Result配置的各种视图转发类型

<action name="helloworld" class="cn.itcast.action.HelloWorldAction"> </action> result配置类似于struts1中的forward,但struts2中提供了多种结果类型,常用的类型有: dispatcher(默认值......

张超
2013/04/11
110
0
SSH框架(三) struts2的登陆示例

因为最近在学习使用SSH框架(struts2+spring+hibernate),下面来介绍表现层struts2的使用方法。 (一)添加struts2的包   见上一篇博客,先看一下添加的各个文件的目录结构 (二)介绍各个文...

thinkyoung
2014/12/17
0
0

没有更多内容

加载失败,请刷新页面

加载更多

Jenkins admin 密码忘记解决

一、admin密码未更改情况 1.进入\Jenkins\secrets目录,打开initialAdminPassword文件,复制密码; find / -name initialAdminPassword [root@jenkins jenkins]# cat /var/lib/jenkins/secre......

SuShine
26分钟前
5
0
LiveData原理分析

LiveData原理分析 1 LiveData简介 大部分Android应用会从网络或SQLite数据库存取数据,并根据数据更新界面。为了避免ANR,主线程中不能存取数据。而后台线程中无法更新界面。通常的做法是让后...

tommwq
40分钟前
4
0
Java描述设计模式(20):命令模式

本文源码:GitHub·点这里 || GitEE·点这里 一、生活场景 1、场景描述 智能电脑的品牌越来越多,由此诞生了一款电脑控制的APP,万能遥控器,用户在使用遥控器的时候,可以切换为自家电视的品...

知了一笑
41分钟前
3
0
java---网络编程(上)

1.1网络编程 网络编程指的是编写运行在多个设备计算机的程序,这些计算机通过网络连接起来 java.net包中提供了两种常见的网络协议的支持: TCP:TCP是传输控制层协议的缩写,它保障了两个应用...

Firefly-
45分钟前
13
0
城市搜索插件 city-query

  今天,给大家介绍一个比较简单有用的插件city-query,大家可以从coding上面下载下来。 git clone https://gitee.com/jflsy/city-query.git   引用插件时只需要src文件下的内容就可以了...

芳缘
50分钟前
5
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部