Struts2 学习总结

一：struts2框架是应用在Javaee三层中的web层的框

二：入门案例：

        2.1：导包

        2.2：创建action（Action是一个多实例的）

            2.3：配置Action的访问路径

                    创建Struts2的核心配置文件（名称必须是 Strutsxml   位置必须在src下面）

            2.4：引入dtd约束

            2.5：Action的配置：（这些配置先写，下面讲述）

            

            发布到tomcat上，启动后。在网页上访问地址是：（会报  404错误.......   是因为.没有配置过滤器...）

                    http://127.0.0.1/struts2_day01/hello.action

注意：Struts2 必须得在web.xml中配置过滤器

    

         配置好上面的，之后  struts2的入门案例就跑起来了。。。。。。

        查看一下过滤器的源代码，看一下执行过程：

        过滤器在服务器启动时候创建，执行过滤器中的init方法，

        在init方法中，主要加载配置文件。

                      加载strust2的自带配置文件，和struts2.xml  文件

                   而web.xml在服务器启动时候加载

 三：struts2核心配置文件解析

       3.1： 名称和位置固定：（在src下面，名称是struts2.xml）

       3.2： 在配置文件中有三个标签：

               3.2.1： package标签：类似代码包，区分不同的Action，要配置Action，必须写package  才能配置action

                               name属性：与功能无关，在一个配置文件可以写对个package，区分不同的package

                            extends属性：固定值：extends="struts-default"     写了之后具备Action的功能

                                namespace属性：属性值和Action标签里面的name属性值构成访问路径

                 3.2.2：Action标签

                    配置Action的访问路径

                            name属性：与namespace属性值构成访路径。

                                                在package标签里面可以写多个Action标签，区分不同的Action的标签的

                            class属性：配置Action类的全路径

                            method属性：在Action类里面默认执行的是execute方法，但是在Action类中可以执行其他方法，就用method配置

                                                让Action里面对个方法执行，使用method进行配置

               标签result：

                    根据Action的方法返回值，配置到不同的路径里面去

                    name属性：和方法返回值一样             

                        

                    type属性：

                    配置如何到路径中去（转发或重定向）

                                （页面的跳转）dispatcher  （默认值）  转发操作

                                （页面的跳转）redirect   重定向

                                （这是Action之前跳转） chain 转发  （一般不用，因为用缓存问题）

                                （这是Action之间的跳转） redirectAction  重定向到Action    

          

四：struts2中的常量（在struts2 中 常量封装了许多功能）

         struts2 默认常量的位置：

            

        修改默认常量的值：

                一般在struts.xml中进行配置

            常量封装了许多功能：

            例如：在Action获取表单通过post方式提交中文，中文乱码就直接解决了 （get还得自己配置解决....）     配置一下上面的编码格式就好

            分模块开发：

                单独写配置文件，把配置文件引入到核心配置文件中可以

            五：Action的编写方式（三种）

                    5.1：创建普通类，不继承，不实现。直接重写execute方法即可

                    5.2：创建类，实现接口  Action

                    5.3：创建类，继承类  ActionSupport（经常用）

    

            六：访问Action的方法（重点）

                            6.1：第一种访问方式：使用Action标签中的method属性，在属性里面写执行的方法。

                            6.2：第二种访问方式：通配符方式实现

                                        通配符：就是  *  号  可以匹配到任意内容

            

                             6.3：演示错误及注意点：

                               6.3.1： 如果在Action方法有返回值，在配置文件中没有配置，就会出现下面错误

                

                               6.3.2： Action里面的方法有返回值，如果有返回值，类型必须是String类型    

                                6.3.3：如果没有返回值，在配置文件中result不需要配置

                                        把返回值写成：“none”或 NONE

                                        

七：结果页面配置：

            7.1：全局结果页面；

                    需求：建两个Action，执行默认的execute方法，让两个方法的返回值都相同，并且配置到同一个页面去。

                    7.1.1：如果多个Action，方法返回值，返回的页面也相同，这时候就可以使用全局结果页面配置了（因为result标签里面配置都一样，就可以提取出来）

                            

                  :7.1.2：在package标签 配置全局结果页面

            

        

                7.2：局部页面：

                        

                如果配置了全局结果页面，也配置了局部页面，最终以局部配置为准

            

   八：Action获取表单对象提交数据：

               之前在web阶段，提交表单到servlet里面，在servlet类里使用request对象使用getParameter（），和 getParametermap()  方法获取，

            Action获取表单提交的数据主要有三种方式：

                8.1：第一种方式：使用ActionContext类获取：

                    ActionContext类不是new出来的，

                    具体演示：

                                8.1.1：创建表单，提交表单到Action里面，

                                 8.1.2：在Action使用ActionContext获取数据

                                    

                    

            8.2：第二种方式：使用servletActionContext类获取

                        调用servletActionContext对象里面的静态对象，得到request对象

    

                8.3：第三种方式：使用接口注入

                让Action实现ServletRequestAware接口，为了得到request对象

                

   九：在Action中操作域对象

            request，session，servletContext  域对象

             使用ServletActionContext类操作

        

       

    十： struts2封装获取表单数据方式

            10.1：原始方式获取表单封装到实体类对象

        

                10.2：属性封装

                    10.2.1：直接把表单提交的属性封装到Action的属性里面

                     10.2.2：实现步骤：

                           （1） 在Action成员变量位置定义变量

                            注意：变量名和表单输入项的name属性值一样

                            （2）  生成变量的set方法（建议set，get方法都生成）

                             （3）：使用属性封装缺点：

                                        使用属性封装获取表单数据到属性里面，不能把数据直接封装到实体类对象里面

                        

                    10.3：模型驱动（重点）

                               10.3.1 ：使用模型驱动方式，可以直接把表单数据封装到实体类对象里

                               10.3.2：实现步骤：

                                        （1）：Action实现接口ModelDriven（必须指定一个实体类）

            

                                            （2）：实现接口里面的getModel 方法

                                                    创建对象返回

                                           （3）：在Action里面创建实体类对象（就直接封装到了实体类中了）

                                                        

                          注意问题：

                            在一个Action中，获取表单数据可以使用属性封装、和模型驱动封装，但是不能同时使用属性封装和模型驱动封装获取同一个表单数据，如果同时使用之后，执行模型驱动

                    

               10.4：表达式封装（一般用的少，因为前段和后端是不同人开发）

                        10.4.1：使用表达式封装可以把表单数据封装到实体类对象里

                        10.4.2：实现过程：

                                    （1）：在Action中申明实体类

                                     （2）：生成实体类变量的set和get方法

                                        

                                （3）：在表单输入项的name属性值里面写表达式形式：（关键）

            

                比较表达式封装和模型驱动封装

                相同点：

                            都可以把表单数据封装到实体类中。  

                不同点：                

                            （1）：模型驱动只能把数据封装到一个实体对象里面。

                                         在一个Action里面不能使用模型驱动把数据封装到不同的实体类对象里面；

                            （2）：使用表达式封装可以把数据封装到不同的实体类对象里

        

                            

                10.5：封装到集合里面：

                            10.5.1：封装数据到list集合

                                       （1）：在Action声明list集合

                                        （2）：生成list变量的set和get方法

                                        （3）：在表单输入项里面写表达式：

                                            

                    10.6：封装数据到Map集合

                            （1）：声明map集合

                            （2）:生成get和set集合

                    

                            （3）：在表单输入项的name属性值里面写表达式

 十一：OGNL概述

            11.1：之前web阶段学习过el表达式，el表达式在jsp中获取域对象里面的值

            11.2：OGNL是一种表达式

                        在struts2里操作值栈数据

                         一般和struts2标签一起使用            

              OGNL不是struts2的一部分，所以得导jar包

             11.3： OGNL入门：

                        计算字符串的长度  ognl+struts2（支持对象调用）

                        11.3.1: 在jsp页面引入struts2 的标签库

            

                        11.3.2：使用struts2标签实现操作

                    

 十二：值栈

            12.1：在web阶段，在servlet里面进行操作，把数据方法域对象里面，在页面使用el表达式获取值。域对象在一定范围内，存值和取值

             12.2：struts2里有类似与域对象的机制，是值栈，可以存值，取值

                        在Action中把值放到值栈中，在页面使用ognl+struts2 的标签取值

              12.3：servlet和Action区别

                        （1）：servlet：默认在第一次访问时创建，创建一次，单实例

                        （2）：Action：访问时候创建，每次访问Action的时候，都会创建Action对象，创建多次，多实例对象。

              12.4：值栈存储位置：

                            （1）：每次访问Action时候，都会创建Action对象

                            （2）：在每一个Action对象里面都会有一个值栈对象（只有一个）

                12.5：获取值栈对象：

                        （1）：常用方式：使用ActionContext类里面的方法得到值栈对象

                          

                           （2）：每个Action对象中只有一个值栈对象

                12.6：值栈内部结构：

                           （1） 第一部分为root，结构是list集合（一般都是操作都是root里的数据）

                               查看源代码：继承list

                    

                               （2）第二部分为context，结构是Map集合 

                                        查看源代码：实现Map接口

                                    里面的结构是固定的key、value结构，存储的是一些固定结构

            12.7：struts2里面的标签s:debug，使用这个标签可以看到值栈结构和存储值

                        （1）：访问Action，执行Action的方法有返回值，配置返回值到jsp页面，在jsp页面使用  s:debug 这个标签

   十三：向值栈中放数据：

                13.1：第一种：使用ActionContext对象获取值栈对象，调用值栈对象里面的set方法

                

                13.2：第二种：使用ActionContext对象获取值栈对象，调用值栈对象里面的push方法

        

            13.3：在Action定义变量，生成变量的get方法

                    13.3.1：向值栈中放对象

                             （1）定义对象变量

                             （2）  生成变量的get方法

                             （3）在执行的方法里向对象中设置值

                    

                    13.3.2：向值栈里放list集合：

                             （1）：定义list集合变量

                            （2）：生成变量的get方法

                               （3）：在执行的方法里向list集合设置值

        

十四：从值栈中获取数据：

        使用的就是  ognl+struts2标签获取值栈数据

        14.1：获取字符串：

                （1）：向值栈放字符串

                    

            （2）：在jsp中使用struts2 和 ognl表达式  获取

        

        14.2：获取对象：

                  （1）：向值栈放对象

                

            （2）：在页面获取值

            

            14.3：获取list集合：

                    14.3.1：往集合中放值

                      14.3.2：获取list集合中的值（三种方式）

                        （1）第一种获取方式：

                        

                        （2）第二种方式：

                        （3）：第三种方式：

                        

    十五：    解释el表达式为什么可以值栈数据

            15.1：el表达式可以获取域对象里的值   setAttribute（）放值，getAttribute() 取值

            15.2  为什么el表达式可以获取域对象里面的值：

                        因为el表达式底层增强request对象里面的方法 getAttribute方法

                        首先从request域获取值，如果获取到，直接返回

                        如果从request域对象获取不到值，到值栈中把值获取出来，在把值放到域对象里面

                

十六：OGNL中的   #  和  % 使用

           16.1：使用 # 获取context里面的数据

        

            16.1:演示#操作

                (1):向request域对象放值

              （2）：在页面中使用ognl表达式获取

十七：struts2 的拦截器

       17.1：struts2 里面封装了许多功能，struts2里面封装的功能都是在拦截器  里面

       17.2：struts2里面封装了许多功能，有很多的拦截器，不是每次这些拦截器都执行，每次执行默认的拦截器，要想执行其他的，只需要配置就好。

        17.3：struts2里面默认拦截器的位置：

        

            17.4：拦截器在什么时候执行

                    在Action对象创建之后，Action的方法执行之前

              17.5：拦截器的底层原理

                   （1）：aop思想：面向切面编程

                    （2）：责任链模式：和过滤连模式相似

              17.6：aop和责任链模式如何应用到拦截器里面？    

                        拦截器在Action对象创建以后，Action的方法执行之前执行

                        在Action的方法执行之前执行默认拦截器，执行过程使用aop思想，在配置文件中进行操作。

                    执行拦截器的时候，执行很对的拦截器，这个过程使用责任链模式

                        执行完一个拦截器，必须做类似放行操作，在执行下一个拦截器，........

                

               17.7：重要概念：

                      17.7.1：过滤器和拦截器的区别  

                                   （1）过滤器：过滤器理论上可以过滤任何内容，，如 HTML，jsp 图片...

                                   （2）拦截器：拦截器只可以拦截Action，（struts2独有）

                        17.7.2：servlet和Action区别

                                    

                                    （1）servlet默认第一次访问时候创建，创建一次，单实例对象

                                    （ 2 ） action 每次访问时候创建，创建多次，多实例对象

                17.8：自定义拦截器：

                        17.8.1：在struts2里面有很多的拦截器，这些拦截器封装很多功能，但是在实际开发中，struts2里面的拦截器中可以没有要使用的功能，这个时候需要自己写拦截器实现功能

                      17.8.2： 拦截器的内部结构：

        

                    17.8.3：开发中，建议使用另一种方式

                            写类。继承MethodFilterInterceptor类实现（因为这个类。可以让Action里面的莫个方法你进行拦截）

                    17.8.4：让拦截器和Action有关系

                            不是在Action调用拦截器的方法，而是通过配置文件方式进行建立关系

 十八：自定拦截器        

             拦截器实现过程：

                    第一步：创建类，继承MethodFilterInterceptor类

                    第二步：重写MethodFilterInterceptor类里面的方法写拦截器的逻辑

        

    

                    第三步：配置Action和拦截器的关系（重要）

                            （1）：在要拦截的Action标签所在的package标签里面声明拦截器

                            （2）：在具体的Action的标签里面使用声明的拦截器

                            （3）：struts2里面执行很多的默认拦截器，但是如果在Action里面配置了自定义的拦截器，默认的拦截器就不会执行了

                            解决：把默认的拦截器手动配置一次

                            （4）：配置的拦截器，对Action里面所有的方法都进行拦截，

                                    但是登录的方法不需要拦截，如果拦截了，就永远登录不进去了

                                解决：让登录的方法不进行拦截

                                直接通过配置方式让Action里面的某些方法不进行拦截

    

        

struts2 的标签库：

        struts2 标签使用在jsp页面中

          1：s:property:   和ognl表达式在jsp页面获取值栈数据

            2：s:iterator：获取值栈list集合数据

            3：s:debug：查看值栈结构和数据