struts2

struts2框架的执行流程:
1)用户发起请求(.action结尾的请求表示请求一个Action)
2)struts2框架的主控器(FilterDispatcher)接收用户发起的请求,
   然后判断这个请求交给Action处理还是交给web组件处理.
  如果请求的Action或者web组件不存在,那么出现404错误.在整个处理
  过程中需要一个辅助对象:Action映射器(ActionMapper).
3)第二步判断的结果是交给Action处理,并且存在对应的Action.
   那么根据struts.xml文件中对此Action的配置信息,首先执行拦截
  此Action的所有拦截器,然后再执行请求的Action对象.在这个处理
  过程中需要辅助对象:Action代理(ActionProxy)、配置管理器    (ConfigurationManager)、ActionInvocation.
4)Action执行完毕之后返回一个结果(此结果用字符串表示),这个结果
  经过拦截Action的所有拦截器之后,返回给主控器.主控器根据此结果
  从配置文件中找到真正的路径,然后将请求转发给对应的视图.
5)由视图向客户端作出响应
-----------------------------------------------------------------------------------------------------------------------------------
使用struts2框架的基本步骤
1)创建jsp页面作为视图,提供用户输入表单的页面注意下action属性的   配置.
2)创建Action类,提供属性来存放客户端提交的数据,并且提供   getter/setter方法.注意property的名字必须和客户端提交的参数名
   保持一致.提供execute方法来处理请求,使用字符串来表示处理的
   结果.
3)在struts.xml文件中配置action,包括名字和类型,还需要在action元素
   中为action的execute方法的返回结果定义对应的result元素,主要是
   为了说明action返回的字符串代表的真正结果.
---------------------------------------------------------------------------------------------------------------------------------
代理:
两个对象实现共同接口或者继承共同父类,调用一个对象的方法等于调用另外一个对象的方法.
Action类的开发方法:
a)不需要实现任何接口或者继承任何类
b)实现一个Action接口
   优点:可以使用Action接口中定义的常量作为一个结果
c)继承ActionSupport类
   优点:可以在自定义的Action类中使用ActionSupport类中定义的方法
---------------------------------------------------------------------------------------------------------------------------------
在Action类中访问servlet中的对象的方式:
a)通过ActionContext对象,对于每一个Action实例都有一个ActionContext
   对象.
   ActionContext ac=ActionContext.getContext();
   Map session =ac.getSession();
   session.put("isLogin",true);
b)Action类实现一些aware接口,然后struts框架中的有一个拦截器自动
   会调用aware接口中的方法传入servlet中的对象
   ServletContextAware
   public void setServletContext(ServletContext sc){}
   ServletRequestAware
   public void setServletRequest(HttpServletRequest req){}
   ServletResponseAware
   public void setServletResponse(HttpServletResponse res){}
c)通过ServletActionContext中定义的静态方法来获得servlet中的对象
-----------------------------------------------------------------------------------------------------------------------------------
Action的配置方式
Action类中可以提供多个方法来处理多个不同类型的请求.
a)Action类:提供多个方法
   配置:声明action的名字和类型
   访问:必须以actionName!methodName.action这种方式访问
   public class LoginRegisterAction{
            public String login(){}
            public String register(){}   
   }
  <action name="LoginRegisterAction" class="....LoginRegisterAction">
  </action> 
  http://localhost:8080/struts2/LoginRegisteAction!login.action
b)Action类:提供多个方法
   配置:为每一个方法定义一个Action
   访问 :actionName.action
  public class LoginRegisterAction{
            public String login(){}
            public String register(){}   
   }
  <action name="login" class="....LoginRegisterAction"      method="login">
   </action>
  <action name="register" class="....LoginRegisterAction"      method="register">
   </action>
  http://localhost:8080/struts2/login.action
c)Action类:提供多个方法
   配置:Action的名字采用通配符表示, 方法为通配符的取值
   访问:methodNameActionName.action
   public class LoginRegisterAction{
            public String login(){}
            public String register(){}   
   }
   <action name="*Action"
                class=".....LoginRegisterAction" method="{1}">
   </action>
  http://localhost:8080/struts2/loginAction.action

<action name="show" class="calloutAction" method="viewCallout return SUCCESS">
                <result>/page/callout_show.jsp</result>
</action>
http://localhost:8080/struts2_jd0806/advance/LoginRegisterAction!login.action
http://localhost:8080/struts2_jd0806/advance/LoginRegisterAction!register.action

http://localhost:8080/struts2_jd0806/advance/login.action
http://localhost:8080/struts2_jd0806/advance/register.action

http://localhost:8080/struts2_jd0806/advance/loginAction.action
http://localhost:8080/struts2_jd0806/advance/registerAction.action

解决访问Action不存在的处理办法
1)配置默认Action
   当访问的action不存在时交给默认Action处理
   <default-action-ref name=”actionName”>
2)配置一个名字是一个通配符的action.这个action必须放在所有action后      面配置.
   <action name=”*”>
   <result>/404.jsp</result>
   </action>

结果的配置
<result name="" type=""></result>

<result name="success" type="dispatcher">
      <param name="location">/ThankYou.jsp</param>
</result>
                                      ||
                                      \/
 <result>
      <param name="location">/ThankYou.jsp</param>
 </result>
注:当result元素的name属性取值为success的时候,可以省略
     type属性取值为dispatcher的时候可以省略type.
                                     ||
                                     \/
<result>/ThankYou.jsp</result>

type取值:
dipatcher:处理结果为作服务器内部跳转(跳转到web组件)
redirect:作客户端重定向(重定向到web组件)
chain:作服务器内部跳转(跳转到其他Action)
<result type="chain">login</result>
<result type="chain">
        <param name="actionName">dashboard</param>
        <param name="namespace">/secure</param>
</result>
redirect-Action:作客户端重定向(重定向到其他Action)

全局的result:
<global-results>
    <result name="success"                                                type="dispatcher">/ThankYou.jsp</result>
</global-results>

http://localhost:8080/struts2_jd0806/book/list.action
---------------------------------------------------------------------------------------------------------------------------------
OGNL(对象图导航语言)
注:只能在struts2标签的属性中使用
ActionContext(存在于request)  
ValueStack(存在于request)
存放在值栈中的对象,通过ognl表达式只能取栈顶对象
如果是访问属性的话,那么会对值栈中的对象进行查找,直到找到这个属性返回.

jsp:el表达式
requestScope,sessionScope,cookie................

访问ValueStack中的数据
1、访问栈顶元素
      <s:property/>
2、访问值栈中某个对象的属性
     <s:property value="attrName"/>
     注:如果要访问的对象的属性,在前面的对象中已经存在,那么就无法取             出需要访问的对象的属性值.
访问ActionContext中的数据
1、访问ActionContext维护的Map中的元素
      <s:property value="#key"/>
2、访问request中的数据
     <s:property value="#request.key"/>
3、访问session中的数据
     <s:property value="#session.key"/>
4、访问application中的数据
    <s:property value="#application.key"/>
5、访问提交的参数
     <s:property value="#parameters.key"/>
6、从page到application查找数据
     <s:property value="#attr.key"/>
-----------------------------------------------------------------------------------------------------------------------------------
struts2的标签分类
1、用户界面标签
      表单标签和非表单标签

2、非用户界面标签
      流程控制标签和数据访问标签
      1、if/elseif/else
            <s:if test="expression">
                    tag body;
            </s:if>
           <s:elseif test="expression">
       tag body;
           </s:elseif>
           <s:else>
      tag body;
           </s:else>

      2、iterator
             1)迭代List/Set/Array
              <s:iterator value="list/set/array">
                         <s:property/>
              </s:iterator>
             2)迭代Map
    <s:iterator value="map">
        <s:property value="key"/>
                                :
                                <s:property value="value"/>
               </s:iterator>
             可选属性说明:
             id:如果指定了id属性,那么迭代出来的数据除了被放在
                ValueStack中之外,还被放入ActionContext中(key就是id)
             status:如果需要获得当前迭代标签的一些状态信息(比如当前
                         迭代出来的数据是第几条数据等),那么可以指定这个
                         属性,如果指定了这个属性,在ActionContext中会放入
                         一个类型为IteratorStatus的对象,包含了当前的状态信息.

        append
        把多个集合组装成一个集合
        <s:append id="newList">
    <s:param value="{'spring','hibernate','ejb'}"/>
                <s:param value="{'kevin','jack','tony'}"/>
        </s:append>
        <s:iterator value="#newList">
               <s:property/>  <br/>
        </s:iterator>
       
        generator
        按照某个分割符分割字符串变成一个集合
         <s:generator separator=","    val="'a,b,c,d,e'"     id="strs">
         </s:generator>
         <s:iterator value="#attr.strs">
              <s:property />   <br/>
         </s:iterator>
       
        merge
        把多个集合合并成一个集合
        1 2 3   1 2 3
        append:123123
        merge:112233
      
       subset
       过滤集合中的数据
       public class MyDecider implements Decider{
    public boolean decide(Object element)throws Exception{
        String str = (String)element;
        return str.indexOf(“J2EE”) > 0;
    }
        }
      
       <s:bean id="mydecider" name="MyDecider"/>
     
      <s:subset source=”{'Java Tutorial','Spring2',
    'Ajax based J2EE','J2EE Enterprise Application',}”
    decider=”#mydecider”>
               <s:iterator>
               <s:property/> <br/>
               </s:iterator>
     </s:subset>

    sort
    对集合中的元素进行排序
    public class MyComparator implements Comparator{
    public int compare(Object element1, Object element2){
        return ((String)element1).length() - ((String)                                                   element 2).length();
    }
     }
    
   <s:bean id="mycomparator"  name="MyComparator"/>
   <s:sort source=”{'spring','struts2','hibernate','ejb'}”
    comparator=”#mycomparator”>
    <s:iterator>
        <s:property/>  <br/>
               </s:iterator>
  </s:sort>
   

   property
   输出ognl表达式的值
  <s:property value="attrName/#...."/>

    set
   将数据设定到某个范围内
   <s:set name="" value="" scope=""/>
   scope:application,session,request,page,action
   
    push
    将某个对象放到值栈的栈顶
    <s:push value="#request.user">
    <s:property/>
    </s:push>
   
    bean
    创建指定类型的对象,并且将对象放入ActionContext对象中
    <s:bean id="key" name="类型">
    <s:param name="name" value="'jsp'"/>
    </s:bean>
   
   date
   格式化输出日期类型的数据
   <s:date name="日期对象"  format="yyyy年MM月dd日"  nice="false"/>
 
   action
   在jsp页面上去调用action
   <s:action name="hello" namespace="/basic" executeResult="true"/>
  
   debug
   用于调试,通过这个标签可以查看ValueStack和ActionContext中存放的
   数据.
   <s:debug/>
  
   include
   包含其他页面,跟jsp的include动作元素类似
   <s:include value="*.jsp"/>
  
    url
    对一个url进行重写,可以在原来的url后追加jsessionid以及参数
   <s:url value="delete.action">
    <s:param name="id" value="1"/>
   </s:url>
   delete.action?id=1;jsessionid=KJKLJHLKJGHJHGJKHGJHGJHG
  
   i18n和text
   i18n:读取某一组资源文件
   text:输出与当前语言类型对应的资源文件中的内容

3、Ajax标签

注:在struts2中action如何将数据传递给jsp显示?
    1)在action中将需要传递的数据放在request范围内传递过去,
       在jsp页面上从request范围内取出数据显示.
    2)在action中将需要传递的数据作为action的一个实例变量(action的引          用会被struts框架放入值栈中),在jsp页面上从ValueStack中取出数据       显示.


为什么需要类型转换?
 b/s架构的软件,客户端提交的数据都是文本类型的,但是服务器端接收到这些数据之后需要用不同的类型去表示.所以需要将文本数据与java类型之间进行转换,原本这些转换工作需要有开发人员通过编码来实现,现在可以交给struts框架处理.

可以将文本数据转换成java中的基本类型以及它的包装类型.
做法:需要在action中定义需要转换的类型的属性去接收
可以将文本数据转换成java中的Date类型
可以将文本数据转换成数组类型、List类型、Map类型

可以将文本数据转换成自定义的对象类型
book.id====>Book book
book.name===>Book book
book.price===>Book book

做法:在action中提供一个自定义对象类型的属性(getter/setter方法)
         在jsp页面中,输入框的名字定义为:action中的属性名.自定义对            象类型的属性名

注:类型转换器会在提交数据和显示数据的时候起作用
     如果在进行类型转换的时候出错,比如将"abc"转换成一个Long
     类型的数据.struts框架就不会再去执行Action,而是直接返回一个
     逻辑名为"input"的结果给主控器.

     ${requestScope.user.name}
    <s:property value="#request.user.name"/>

     ${person.age}
     <s:property value="#attr.person.age"/>

    src:
    xwork-conversion.properties(被struts2框架自动读取,在这个文件
    中注册的转换器对整个web应用生效)
    与Action同一个包下:
    ActionClassName-conversion.properties


    开发自定义转换器的原因:
    由于struts框架中提供的类型转换器是一些基本的类型转换器,对于
    一些特殊情况无法通过struts2框架内置的类型转换器进行转换.
    自定义转换器的开发步骤:
     1、创建一个转换器类,需要实现TypeConverter接口,一般会去继承
           StrutsTypeConverter这个抽象类.
           实现两个方法:
           convertFromString:
           作用:将客户端提交的参数转换成一个java类型的对象
                   这个方法会在客户端提交数据的时候起作用
           convertToString
          作用:将Action中的属性值转换成一个字符串
                    这个方法会在通过Ognl表达式输出数据的时候起作用
     2、注册转换器
           在src下创建xwork-conversion.properties
           并且声明:需要转换的对象类型=转换器类型
           在与Action同一个包下创建
           ActionClassName-conversion.properties
           并且声明:需要转换的对象类型的属性名=转换器类型

拦截器:
什么是拦截器?
拦截器是struts框架中提供基础服务的一种组件,在Action执行
前后执行.
当多个Action需要实现同一种功能的时候,那么我们可以将这个功能放在拦截器中实现.
拦截器是可重用的,如果有一个Action需要使用拦截器提供的
功能,那么只需要让拦截器拦截这个Action.

如果Action没有显式声明被某个拦截器拦截,那么默认就会被struts框架中定义的相关拦截器拦截.一旦声明了被某个拦截器拦截,那么Action就不会默认被struts框架中定义的相关拦截器拦截,需要显式的声明才行.

LoginInterceptor
开发拦截器的基本步骤:
1、创建拦截器类,实现Interceptor接口或者继承AbstractInterceptor
      抽象类.
2、在interceptors元素中描述interceptor.
3、在需要被拦截的action中描述interceptor-ref.

注:如果多个Action被多个相同的拦截器拦截,那么为了引用方便,我们可以将多个拦截器配置成一个拦截器栈.在Action中直接引用拦截器栈就等于引用了多个拦截器.我们甚至可以不在Action中显式的去引用拦截器而是配置一个default-interceptor-ref(默认拦截器即可)


struts框架中提供的拦截器
params:给action设置客户端提交的参数
static-params:给action或者拦截器设置静态参数
autowiring:将spring维护的某个bean设置到action中
fileupload:提供文件上传的功能
servlet-config:如果action实现aware接口,那么调用aware接口中定义的方法,将相关对象设置到action中.
workflow:对客户段提交的参数进行数据类型转换和格式验证
validation:使用xwork-validation验证框架中定义的验证器进行数据格式验证.
exception:如果在struts.xml中声明了异常处理,那么由这个拦截器来完成异常处理的工作.
............
----------------------------------------------------------------------------------------------------------------------------------
数据格式验证
1、客户端验证
      js
      效率高
      不安全

2、服务器端验证
      编码
      validate
      注:当Action中只有一个处理请求的方法execute时,则需要提供
            一个validate验证方法.如果Action中有多个处理请求的方法
           那么需要为每个方法定义一个validateXxx方法(命名规则为
            validate+处理请求的方法名)
      这些验证方法在执行的时候只要产生FieldError,就认为验证不通过
      struts2框架就会将请求转发到"input"的结果上.
      xwork-validation框架(验证文件*-validation.xml)
      当Action中只有一个execute的时候
      ActionClassName-validation.xml
      当Action中有多个方法时
     ActionClassName-ActionMethod-validation.xml

     验证器:
    required:验证数据是不是为null
    <validator type="required">
             <param name="fieldName">username</param>
             <message>username must not be null</message>
    </validator>
    <field name="username">
             <field-validator type="required">
                   <message>username must not be null</message>
             </field-validator>
   </field>
   requiredstring:验证字符串是不是为空
  <validator type="requiredstring">
             <param name="fieldName">username</param>
             <param name="trim">true</param>
             <message>username is required</message>
  </validator>
 <field name="username">
                 <field-validator type="requiredstring">
                 <param name="trim">true</param>
                 <message>username is required</message>
            </field-validator>
    </field>
   int:验证int类型的数据的大小
  <validator type="int">
               <param name="fieldName">age</param>
               <param name="min">20</param>
               <param name="max">50</param>
     <message>Age needs to be between ${min} and ${max}</message>
  </validator>
   <field name="age">
               <field-validator type="int">
                   <param name="min">20</param>
                   <param name="max">50</param>
                   <message>Age needs to be between ${min} and ${max}</message>
     </field-validator>
</field>

   date:验证日期类型的数据的大小
   <validator type="date">
                <param name="fieldName">birthday</param>
              <param name="min">01/01/1990</param>
              <param name="max">01/01/2000</param>
              <message>Birthday must be within ${min} and ${max}</message>
                </validator>
          <field name="birthday">
                <field-validator type="date">
                    <param name="min">01/01/1990</param>
                  <param name="max">01/01/2000</param>
                  <message>Birthday must be within ${min} and ${max}</message>
                </field>
          </field>

   expression:验证ognl表达式(与下面这个验证器的区别?)
    <validator type="expression">
              <param name="expression"> .... </param>
              <message>Failed to meet Ognl Expression  .... </message>
    </validator>
   fieldexpression:验证ognl表达式
  <validator type="fieldexpression">
           <param name="fieldName">myField</param>
           <param name="expression"><![CDATA[#myCreditLimit > #myGirfriendCreditLimit]]></param>
           <message>My credit limit should be MORE than my girlfriend</message>
        <validator>
       
        <!-- Field Validator Syntax -->
        <field name="myField">
            <field-validator type="fieldexpression">
                <param name="expression"><![CDATA[#myCreditLimit > #myGirfriendCreditLimit]]></param>
                <message>My credit limit should be MORE than my girlfriend</message>
            </field-validator>
        </field>

   email:验证数据是否符合email格式
  <validators>
         <validator type="email">
             <param name="fieldName">myEmail</param>
             <message>Must provide a valid email</message>
         </validator>
     </validators>
    
     <!-- Field Validator Syntax -->
     <field name="myEmail">
        <field-validator type="email">
           <message>Must provide a valid email</message>
        </field-validator>
     </field>

   url:验证数据是否符合url格式
  <validator type="url">
              <param name="fieldName">myHomePage</param>
              <message>Invalid homepage url</message>
          </validator>
         
          <!-- Field Validator Syntax -->
          <field name="myHomepage">
                 <field-validator type="url">
              <message>Invalid homepage url</message>
               </field-validator>
          </field>

   visitor:验证复杂类型的数据
    <validator type="visitor">
            <param name="fieldName">user</param>
            <param name="context">myContext</param>
            <param name="appendPrefix">true</param>
        </validator>
        <field name="user">
           <field-validator type="visitor">
              <param name="context">myContext</param>
              <param name="appendPrefix">true</param>
           </field-validator>
        </field>

   conversion:验证是否产生类型转换出错
        <validator type="conversion">
                <param name="fieldName">myField</param>
          <message>Conversion Error Occurred</message>
     </validator>

     <field name="myField">
        <field-validator type="conversion">
           <message>Conversion Error Occurred</message>
        </field-validator>
     </field>

   stringlength:验证字符串的长度
   <validator type="stringlength">
                                <param name="fieldName">myPurchaseCode</param>
                                <param name="minLength">10</param>
              <param name="maxLength">10</param>
              <param name="trim">true</param>
              <message>Your purchase code needs to be 10 characters long</message>         
          </validator>
 
                        <!-- Field Validator Syntax -->
                        <field name="myPurchaseCode">
                              <field-validator type="stringlength">
                                <param name="minLength">10</param>
              <param name="maxLength>10</param>
              <param name="trim">true</param>
              <message>Your purchase code needs to be 10 characters long</message>
    </field-validator>
                        </field-name>
    <field name="password">
            <field-validator type="regex">
            <param name="expression">
            <![CDATA[(\w{4,25})]]>
            </param>
             <message>密码必须包含数字和字符,并且长度在4到25之间</message>
        </field-validator>
    </field>

用户名:不能为空,并且需要在6到12个字符之间

密码:不能为空,必须包含数字和字符,并且在4到25之间

重复密码:必须跟密码相同

年龄:必须在20到50之间

邮件地址:必须符合email格式

个人主页:必须符合url格式

采用相关验证器验证这些数据

创建一个RegisterAction(validation包下),提供属性接收参数.
注意:配置时一定要提供名为input的result.
register.jsp(请放入validation目录下)提供给大家,放在220/jd0806/struts2目录下

重复密码的验证,仅作参考!
<field name="repassword">
<field-validator type="fieldexpression">
<param name="expression">
<![CDATA[(password==repassword)]]>
</param>
<message>两次输入的密码必须相同!</message>
</field-validator>
</field>