Struts2框架入门

2018-06-18 02:25:05来源：未知阅读 ()

Struts2框架

一、什么是Struts2

　　Struts2是一个基于MVC设计模式的Web应用框架，它本质上相当于一个servlet，在MVC设计模式中，Struts2作为控制器(Controller)来建立模型与视图的数据交互。Struts 2是Struts的下一代产品，是在 struts 1和WebWork的技术基础上进行了合并的全新的Struts 2框架。其全新的Struts 2的体系结构与Struts 1的体系结构差别巨大。Struts 2以WebWork为核心，采用拦截器的机制来处理用户的请求，这样的设计也使得业务逻辑控制器能够与ServletAPI完全脱离开，所以Struts 2可以理解为WebWork的更新产品。虽然从Struts 1到Struts 2有着太大的变化，但是相对于WebWork，Struts 2的变化很小。

　　-------------百度百科

二、快速搭建环境

　　1、下载官方的jar包
　　　　官网：https://struts.apache.org/

　　2、将其中核心j包中app文件中的struts-blank后缀名改为zip，并进行解压其中的lib文件夹中的jar包为运行struts2的基本jar包

　　3、创建新工程，将基本jar包拷入新建工程中的lib文件夹

　　4、在web.xml文件中配置核心过滤器

<filter>
      <filter-name>struts2</filter-name>
      <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>
  <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>/*</url-pattern>
  </filter-mapping>

　　其中<filter-class>中过滤器名是根据StrutsPrepareAndExecuteFilter类所在路径来配置的

　　5、配置用于跳转的页面，此页面是用于跳转到Action中

<body>
       <h3>快速入门</h3>
       <a href="${pageContext.request.contextPath}/hello.action">跳转</a>
  </body>

　　6、编写Action

package com.clj.action;
/**
 * Struts框架都使用Action类处理用户的请求
 * @author Administrator
 *
 */
public class HelloAction {    
    /**
     * Action类中的方法签名有要求，必须这么做
     * public 公共的
     * 必须有返回值，必须String类型
     * 方法名称可以是任意的，但是不能有参数列表
     * 页面的跳转：1.return 字符串 2.需要在struts.xml配置文件中，配置跳转的页面
     */
    public String sayHello(){
        //编写代码接收请求的参数
        System.out.println("Hello Struts2!");
        return "success";
    }
    /**
     * 演示的method方法的默认值
     * 当配置文件中没有配置指定的method方法，他会默认执行Action中的execute方法
     * @return
     */
    public String execute(){
        System.out.println("method方法的默认值是execute");
        return null;
    }
}

　　7、设置Action配置文件

　　配置文件是一个xml文件，命名强制为struts2.xml,否则当服务器开启时无法识别不是该文件名的配置文件，该文件建立在src下

　　其中，其约束条件可以在struts2-blank\WEB-INF\src\java的struts2.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>
    <!-- 包结构 ，包名不能重复 -->
    <package name="default" namespace="/" extends="struts-default">
        <!-- 配置Action -->
        <action name="hello" class="com.clj.action.HelloAction" method="sayHello">
            <!-- 配置跳转的页面,路经的写法：在Struts2框架中，不管是转发还是重定向，都不需要加项目名 
                name表示结果页面逻辑视图名称
                 type 结果类型（转发类型，默认值是转发，也可以设置其他的值）
            -->    
            <result name="success">/jsp/success.jsp</result>
        </action>
     </package>
</struts>

　　8、此时访问跳转页面，即可执行execute方法

　　总结：这里当执行跳转页面时，会根据配置文件中的action 中的 name属性进行匹配，找到有name为hello 匹配到HelloAction类中的sayHello方法，通过方法反射等进行解析，根据方法的返回值“success”进行页面的跳转，过渡到success.jsp中。值得注意的是，其package包名不能重复！

三、struts2执行流程为：

从客户端发送请求过来先经过前端控制器（核心过滤器StrutsPrepareAndExecuteFilter）过滤器中执行一组拦截器（一组拦截器就会完成部分功能代码）执行目标Action，在Action中返回一个结果视图,根据Result的配置进行页面的跳转.

四、Action书写方式

　　方式一：POJO类

/**
 * 三种action书写方式之POJO类
 * 没有任何继承和实现
 * @author Administrator
 *
 */
public class Demo1Action {
    /**
     * execute是默认方法
     * return null：他不会跳转
     * @return
     */
    public String execute(){
        System.out.println("Demo1Action就是一个POJO类");
        return null;
    }
}

　　方式二：实现Action的接口

import com.opensymphony.xwork2.Action;

/**
 * 三种action书写方式之实现Action的接口，Action是框架提供的接口
 * @author Administrator
 *
 */
public class Demo2Action implements Action{

    @Override
    public String execute() throws Exception {
        // TODO Auto-generated method stub
        System.out.println("Demo2Actions实现了Action的接口");
        //Action接口中定义了 public static final String SUCCESS = "success";
        return SUCCESS;
    }
    
}

　　其中Action有自定义的字符串常量，实现Action的接口返回值就可调用它的常量

　　方式三：继承ActionSupport类

import com.opensymphony.xwork2.ActionSupport;

/**
 *  三种action书写方式之编写ActionSupport类
 *  ActionSupport类已经实现了Action和一些其他接口
 * @author Administrator
 *
 */
public class Demo3Action extends ActionSupport{

    
    public String execute() throws Exception {
        System.out.println("Demo3Action继承了ActionSupport类。。");
        //不跳转
        return NONE;
    }
     
}

五、struts2中常量的配置

　　1.这里先看看当框架执行时配置文件加载的顺序

　　查看StrutsPrepareAndExecuteFilter:(核心过滤器)两个功能：预处理和执行

　　在预处理功能中 init 方法中会有加载配置文件的代码:

　　　 dispatcher.init();

init_DefaultProperties(); // [1] ---- 加载org.apache.struts.default.properties.配置的是struts2的所有常量.

init_TraditionalXmlConfigurations(); // [2] ---- 加载struts-default.xml、struts-plugin.xml、struts.xml

init_LegacyStrutsProperties(); // [3] ---- 加载用户自定义struts.properties

init_CustomConfigurationProviders(); // [5] ---- 加载Struts2定义Bean.

init_FilterInitParameters() ; // [6] ---- 加载web.xml

init_AliasStandardObjects() ; // [7] ---- 用户自定义Bean

　　结论:

　　 * 先加载default.properties文件，在org/apache/struts2/default.properties文件，都是常量。

　 * 又加载struts-default.xml配置文件，在核心的jar包最下方，struts2框架的核心功能都是在该配置文件中配置的。

　 * 再加载struts.xml的配置文件，在src的目录下，代表用户自己配置的配置文件

* 最后加载web.xml的配置文件

* 后加载的配置文件会覆盖掉之前加载的配置文件（在这些配置文件中可以配置常量）

因此：后配置的常量会覆盖先配置的常量.

　　 2、查看常量

　　3、修改常量

　　注意：修改常量不能在default.properties文件中修改，可以在struts.xml或者web.xml文件中

　　 1）在struts.xml中

　　<!-- 编写常量 -->
    <constant name="struts.action.extension" value="action,,"></constant>

　　struts2中访问action默认后缀为action或者不写，这个配置可以进行更改

　　 2）在web.xml中

 <filter>
      <filter-name>struts2</filter-name>
      <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
      <!-- 编写常量 -->
      <init-param>
          <param-name>struts.action.extension</param-name>
          <param-value>action,,</param-value>
      </init-param>
  </filter>

六、Action的访问方式

　　1、传统方式：配置method属性

　　 1）Action类代码

import com.opensymphony.xwork2.ActionSupport;

/**
 * 编写的客户的Action的类
 * @author Administrator
 *
 */
public class CustomerAction extends ActionSupport {
    //保存客户
    public String save(){
        System.out.println("保存客户");
        return NONE;
    }
    //删除客户
    public String delete(){
        System.out.println("删除客户");
        return NONE;
    }
}

　　 2）配置文件配置

 <!-- 演示Action的访问，传统方式 -->
     <package name="demo2" namespace="/" extends="struts-default">
         <action name="saveCust" class="com.clj.action2.CustomerAction" method="save"/>
         <action name="delCust" class="com.clj.action2.CustomerAction" method="delete"/>    
     </package>

　　2、通配符的配置

　　 1）Action类

import com.opensymphony.xwork2.ActionSupport;
/**
 * 通配符的方式
 * @author Administrator
 *
 */
public class LinkmanAction extends ActionSupport{
    //保存客户
    public String save(){
        System.out.println("保存联系人。。");
        return "saveOk";
    }
    //删除客户
    public String delete(){
        System.out.println("删除联系人。。");
        return "delOk";
    }
}

　　 2）配置文件

 <!-- 演示Action的访问，通配符方式 -->
     <package name="demo3" namespace="/" extends="struts-default">

         <action name="linkman_*" class="com.clj.action2.LinkmanAction" method="{1}">
             <result name="saveOk">/jsp/success.jsp</result>
             <result name="delOk">/jsp/success.jsp</result>
         </action>
     </package>

　　 3、动态方法访问

　　 1）开启动态访问常量（注意：常量的配置都是定义在包外）

<!-- 开启动态方法访问 -->
    <constant name="struts.enable.DynamicMethodInvocation" value="true"></constant>

　　 2）Action类

import com.opensymphony.xwork2.ActionSupport;

/**
 * 动态方法访问
 * @author Administrator
 *
 */
public class UserAction extends ActionSupport{
    //保存客户
        public String save(){
            System.out.println("保存用户。。");
            return NONE;
        }
        //删除客户
        public String delete(){
            System.out.println("删除用户。。");
            return NONE;
        }
}

　　 3）配置文件

 <!-- 演示Action的访问，动态方法访问方式 -->
     <package name="demo4" namespace="/" extends="struts-default">
         <action name="user" class="com.clj.action2.UserAction"/>
     </package>

　　 4）域名书写方式

<h3>动态方法访问</h3>
     <a href="${pageContext.request.contextPath}/user!save.action">保存联系人</a></br>
     <a href="${pageContext.request.contextPath}/user!delete.action">删除联系人</a></br>

七、struts2中数据的之接收数据

　　struts2怎么传值呢，这里由两种种方式

　　1.定义一个jsp，利用表单进行数据传输

          <form action="${pageContext.request.contextPath}/demo1Action.action" method="post">
              姓名：<input type="text" name="username"/></br>
              密码：<input type="password" name="psssword"/></br>
              <input type="submit" value="注册"/>
          </form></br>

　　2.编写Action

　　 1）方式一：完全解耦合的方式

package com.clj.demo1;

import java.util.Arrays;
import java.util.Map;
import java.util.Set;

import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
/**
 * 完全解耦合的方式，使用Servlet的API
 * 通过操作ActionContexte类的方法来获取Servlet API
 * @author Administrator
 *
 */
public class demo1Action extends ActionSupport{
    public String execute() throws Exception{
        //完全解耦合的方式
        ActionContext context=ActionContext.getContext();
        //获取到请求的参数,获取到所有请求的参数
        Map<String,Object> map=context.getParameters();
        //遍历获取数据
        Set<String> keys=map.keySet();
        for(String key:keys){
            //通过key获取到值
            String[] values=(String[]) map.get(key);
            //默认情况下，struts已经将字符编码转成了UTF-8,无需考虑中文乱码
            System.out.println(key+":"+Arrays.toString(values));
        }
        //如果向request对象中存入值
        context.put("msg","小东东");
        //获取其他map集合
        context.getSession().put("msg","小苍");
        context.getApplication().put("msg","小泽");
        return SUCCESS;
        
    }
}

　　2）方式二：原生的Servlet API

package com.clj.demo1;

import javax.servlet.http.HttpServletRequest;

import org.apache.struts2.ServletActionContext;

import com.opensymphony.xwork2.ActionSupport;

/**
 * 原生的Servlet API
 * @author Administrator
 *
 */
public class demo2Action extends ActionSupport{
    public String execute() throws Exception{
        //获取到request对象
        HttpServletRequest request=ServletActionContext.getRequest();
        request.setAttribute("msg","小东东");
        request.getSession().setAttribute("msg","美美");
        ServletActionContext.getServletContext().setAttribute("msg", "小风");     
        return SUCCESS;
    }
}

八、结果视图处理

　　1、关于全局页面

　　为什么要设置全局页面？因为在同一个包下，有时候多个action中所获得的结果视图是同一个，这要每个action配置会觉得冗余，此时可以配置个全局页面来共用

　　　列子：假如当action中方法返回值是success，此时就可无需配置<result>标签，它会自动跳转到success.jsp中

<!-- 配置全局的结果页面，必须定义在当前包下 -->
    <global-results>
        <!-- type:转发类型 
                 dispatcher:转发，默认值，Action->jsp
                 redirect:  重定向，Action->jsp
                 chain:     多个action之间跳转，Action->Action(转发)
                 redirectAction:多个action之间跳转，Action->Action(重定向)
                 stream：文件下载
        -->
        <result name="success" type="dispatcher">/jsp/success.jsp</result>
    </global-results>

　　2.、结果页面的类型

* 结果页面使用<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

package com.clj.demo1;

import com.opensymphony.xwork2.ActionSupport;

/**
 * 演示重定向
 * @author Administrator
 *
 */
public class demo3Action extends ActionSupport{
    public String save(){
        System.out.println("保存");
        return SUCCESS;
    }
    public String update(){
        System.out.println("更新成功");
        return NONE;
    }
}

　　配置文件

<!-- 演示重定向到Action -->
        <action name="demo3Action_*" class="com.clj.demo1.demo3Action" method="{1}">
            <result name="success" type="redirectAction">demo3Action_update</result>
        </action>

九、关于struts2框架数据的封装

　　封装数据是为了便于开发，降低维护成本，这里有两种方式进行数据的封装。

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

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

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

　　1、方式一：属性驱动

　　 1）属性驱动写法方式一：在action类中直接写从页面中提交的属性数据

　　 jsp：

 <h3>属性驱动的方式(直接在Action中编写属性)</h3>
         <!-- aciton接收表单值时属性要提供set方法 -->
         <form action="${pageContext.request.contextPath}/regist1.action" method="post">
              姓名：<input type="text" name="username"/></br>
              密码：<input type="password" name="password"/></br>
              年龄：<input type="text" name="age"/></br>
              <input type="submit" value="注册"/>
          </form></br>

　　action:

package com.clj.demo2;

import com.opensymphony.xwork2.ActionSupport;
/**
 * 属性驱动
 * 方式一：将Action当做JavaBean类
 * @author Administrator
 *
 */
public class regist1 extends ActionSupport{
    private String username;
    private String password;
    private Integer age;
    //传值，用set，不需要要用get
    public void setUsername(String username) {
        this.username = username;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String execute() throws Exception{
        System.out.println(username+" "+password+" "+age);
        return NONE;
    }
}

　　 2)属性驱动写法方式二：将提交的数据封装到一个类中

　　　 jsp

<h3>属性驱动的方式(把数据封装到javaBean中)</h3>
          <!-- 注意：页面的编写风格为OGNL表达写法 -->
             <form action="${pageContext.request.contextPath}/regist2.action" method="post">
                 <!-- 这里的"user"是根据Aciton中封装属性的类的名称属性而定（private User user;） -->
              姓名：<input type="text" name="user.username"/></br>
              密码：<input type="password" name="user.password"/></br>
              年龄：<input type="text" name="user.age"/></br>
              <input type="submit" value="注册"/>
          </form></br>

　　 javabean

package com.clj.demo2;

public class User {
    private String username;
    private String password;
    private Integer age;
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "User [username=" + username + ", password=" + password
                + ", age=" + age + "]";
    }
    
}

　　 action

package com.clj.demo2;

import com.opensymphony.xwork2.ActionSupport;
/**
 * 属性驱动的方式，将数据封装到javaBean中
 * @author Administrator
 *
 */
public class regist2 extends ActionSupport{
    //注意：属性驱动的方式,需要提供get和set方法
    private User user;
    
    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public String execute(){
        System.out.println(user);
        return NONE;
    }
}

　　* 注意：只提供一个set方法还不够，必须还需要提供user属性的get和set方法！！！

> 先调用get方法，判断一下是否有user对象的实例对象，如果没有，调用set方法把拦截器创建的对象注入进来，接下直接调用get方法获取传过来的参数

　　拓展:

　　1.将数据封装到list中

　　 jsp

<h3>向List集合封装数据(默认情况下，采用属性驱动的方式)</h3>
          <!-- 采用OGNL表达式 -->
          <form action="${pageContext.request.contextPath}/regist4.action" method="post">
                 <!-- 这里的"user"是根据Aciton中封装属性的类的名称属性而定（private User user;） -->
              姓名：<input type="text" name="list[0].username"/></br>
              密码：<input type="password" name="list[0].password"/></br>
              年龄：<input type="text" name="list[0].age"/></br>
              
              姓名：<input type="text" name="list[1].username"/></br>
              密码：<input type="password" name="list[1].password"/></br>
              年龄：<input type="text" name="list[1].age"/></br>
              <input type="submit" value="注册"/>
          </form></br>

　　　 action

package com.clj.demo2;

import java.util.List;

import com.opensymphony.xwork2.ActionSupport;
/**
 * 属性驱动的方式，把数据封装List集合中
 * @author Administrator
 *
 */
public class regist4 extends ActionSupport{
    private List<User> list;

    public List<User> getList() {
        return list;
    }

    public void setList(List<User> list) {
        this.list = list;
    }
    public String execute() throws Exception{
        for(User user:list){
            System.out.println(user);
        }
        return NONE;
    }
    
}

　　2.将数据封装到Map集合中

　　 jsp

<h3>向Map集合封装数据(默认情况下，采用属性驱动的方式)</h3>
          <!-- 采用OGNL表达式 -->
          <form action="${pageContext.request.contextPath}/regist5.action" method="post">
                 <!-- 这里的"user"是根据Aciton中封装属性的类的名称属性而定（private User user;） -->
              姓名：<input type="text" name="map['one'].username"/></br>
              密码：<input type="password" name="map['one'].password"/></br>
              年龄：<input type="text" name="map['one'].age"/></br>
              
              姓名：<input type="text" name="map['two'].username"/></br>
              密码：<input type="password" name="map['two'].password"/></br>
              年龄：<input type="text" name="map['two'].age"/></br>
              <input type="submit" value="注册"/>
          </form></br>

　　 action

package com.clj.demo2;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.opensymphony.xwork2.ActionSupport;
/**
 * 属性驱动的方式，把数据封装Map集合中
 * @author Administrator
 *
 */
public class regist5 extends ActionSupport{
    private Map<String,User> map=new HashMap<String,User>(); 
    
    public Map<String, User> getMap() {
        return map;
    }

    public void setMap(Map<String, User> map) {
        this.map = map;
    }

    public String execute() throws Exception{
        System.out.println(map);
        return NONE;
    }
    
}

　　2、方式二：模型驱动

　　　　1)手动实例化javabean

private User user=new User();

　　　　2）实现ModelDriven<T>接口，实现getModel()的方法，在getModel()方法中返回javaBean

　　　　jsp

<h3>模型驱动</h3>
             <form action="${pageContext.request.contextPath}/regist3.action" method="post">
                 <!-- 这里的"user"是根据Aciton中封装属性的类的名称属性而定（private User user;） -->
              姓名：<input type="text" name="username"/></br>
              密码：<input type="password" name="password"/></br>
              年龄：<input type="text" name="age"/></br>
              <input type="submit" value="注册"/>
          </form></br>

　　　　action代码

package com.clj.demo2;

import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
/**
 * 模型驱动的方式
 * 1.实现ModelDrivern接口
 * 2.必须手动实列化对象（需要自己new好）
 * @author Administrator
 */
public class regist3 extends ActionSupport implements ModelDriven<User>{
    //必须手动实例化
    private User user=new User();
    //获取模型对象
    public User getModel() {
        // TODO Auto-generated method stub
        return user;
    }
    public String execute() throws Exception{
        System.out.println(user);
        return NONE;
    }
    
}

十、struts2之拦截器

　　1、什么是拦截器？

　　java里的拦截器是动态拦截Action调用的对象。它提供了一种机制可以使开发者可以定义在一个action执行的前后执行的代码，也可以在一个action执行前阻止其执行，同时也提供了一种可以提取action中可重用部分的方式。在AOP(Aspect-Oriented Programming)中拦截器用于在某个方法或字段被访问之前，进行拦截然后在之前或之后加入某些操作。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　---------360百科

拦截器的利用是struts2框架的一个特点，即面向切面编程

　　2、编写一个拦截器

　　　1）定义一个拦截器类

package com.itheima.interceptior;

import com.google.common.collect.AbstractIterator;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;



/**
 * 编写简单的拦截器
 * @author Administrator
 *
 */
public class DemoInterceptor extends AbstractInterceptor{
    
    /**
     * intercept用来进行拦截的
     */
    public String intercept(ActionInvocation invocation) throws Exception {
        System.out.println("Action方法执行之前");
        //执行下一个拦截器
        String result=invocation.invoke();
        System.out.println("Action方法执行之后");
        return result;
    }
}

　　2) 定义一个action

package com.clj.demo3;

import com.opensymphony.xwork2.ActionSupport;

public class UserAction extends ActionSupport{
    public String execute() throws Exception{
        System.out.println("我是Action,我正常执行了");
        return NONE;
    }
}

　　3) 配置文件配置

<package name="demo3" extends="struts-default" namespace="/">
         <interceptors>
             <!-- 定义了拦截器 -->
             <interceptor name="DemoInterceptor" class="com.itheima.interceptior.DemoInterceptor"/>
         </interceptors>
        <action name="userAction" class="com.clj.demo3.UserAction">
            <!-- 只要是引用自己的拦截器，默认栈的拦截器就不执行了 ，必须手动引入默认栈-->
            <interceptor-ref name="DemoInterceptor"/>
            <interceptor-ref name="defaultStack"/>
        </action>
    </package>

　　3、使用拦截器验证用户登录

　　 1) 定义一个拦截器

package com.clj.interceptor;

import org.apache.struts2.ServletActionContext;

import com.heima.domain.User;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor;

/**
 * 自动以拦截器，判断当前系统是否已经登录，如果登录，继续执行
 * 如果没有登录，跳转到登录页面
 * AbstractInterceptor会拦截所有方法
 * MethodFilterInterceptor可以对指定的方法进行拦截
 * @author Administrator
 *
 */
public class UserInterceptor extends MethodFilterInterceptor{

    /**
     * 进行拦截的方法
     */
    protected String doIntercept(ActionInvocation invocation) throws Exception {
        //获得session对象
        User user=(User) ServletActionContext.getRequest().getSession().getAttribute("existUser");
        if(user==null){
            //没有登录,返回字符串，后面就不会执行了
            return "login";
        }
        return invocation.invoke();
    }
    
}

　　 2）action

package com.itheima.action;

import java.lang.reflect.InvocationTargetException;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.struts2.ServletActionContext;

import com.heima.domain.User;
import com.itheima.service.UserService;
import com.opensymphony.xwork2.ActionSupport;

/**
 * 用户登录模块控制器
 * @author Administrator
 *
 */
public class UserAction extends ActionSupport{
    /**
     * 处理登录功能
     * @return
     */
    public String login(){
        //这边没有学习功能，封装数据，现在还需要request对象
        //怎么获取reqeust方式
        HttpServletRequest request=ServletActionContext.getRequest();
        //获取请求参数
        Map<String,String[]> map=request.getParameterMap();
        User user=new User();
        try {
            BeanUtils.populate(user,map);
            //调用业务层
            User existUser=new UserService().login(user);
            //判断
            if(existUser==null){
                //说明，用户名或者密码错误了
                return LOGIN;
            }else{
                //存入session中
                request.getSession().setAttribute("existUser", existUser);
                return SUCCESS;
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } 
        return NONE;
    } 
}

　　配置文件

<!-- 配置用户的模块 -->
        <action name="user_*" class="com.itheima.action.UserAction" method="{1}">
            <!--<result name="login">/login.jsp</result>-->
            <result name="success">/index.jsp</result>
            <interceptor-ref name="UserInterceptor">
                <param name="excludeMethods">login</param>
            </interceptor-ref>
            <interceptor-ref name="defaultStack"/>
        </action>

十一、OGNL

　　1、什么是OGNL

　　 OGNL是Object-Graph Navigation Language的缩写，它是一种功能强大的表达式语言，通过它简单一致的表达式语法，可以存取对象的任意属性，调用对象的方法，遍历整个对象的结构图，实现字段类型转化等功能。它使用相同的表达式去存取对象的属性。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 ------------360百科

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

　　2、演示OGNL表达式

package com.clj.demo1;

import ognl.Ognl;
import ognl.OgnlContext;
import ognl.OgnlException;

import org.junit.Test;

/**
 * 演示OGNL表达式
 * @author Administrator
 *
 */
public class OgnlDemo {
    /**
     * OGNL访问对象的方法
     * @throws OgnlException 
     */
    @Test
    public void run1() throws OgnlException{
        //上下文对象
        OgnlContext context=new OgnlContext();
        //获取到根对象(ognl都是从根对象进行取值)
        Object root=context.getRoot();
        //存储数据
        context.put("name","美美");
        //获取值,表达式写法
        Object obj=Ognl.getValue("#name",context,root);
        System.out.println(obj);
    }
    /**
     * OGNL表达式调用方法
     * @throws OgnlException
     */
    @Test
    public void run2() throws OgnlException{
        //上下文对象
        OgnlContext context=new OgnlContext();
        //获取到根对象(ognl都是从根对象进行取值)
        Object root=context.getRoot();
        //获取值,表达式写法(这里是让字符串调用他的方法)
        Object obj=Ognl.getValue("'haha'.length()",context,root);
        System.out.println(obj);
    }
}

　　3、jsp中演示OGNL

　　 1) 先引入Strust2标签库

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

　　 2) 调用

<body>
       <h3>条件：假如值栈中已经存入值了，在JSP页面上从值栈中获取值</h3>
       <!-- 
           1.先引入Struts框架中提供的标签库，s标签
           2.可以使用提供的标签(很多，掌握重点的标签)
        -->
        <!-- 从值栈中获取值的value,中间编写就是OGNL表达式 -->
        <s:property value="username"/>
        <!-- 显示常量：加''号 -->
         <s:property value="'username'"/>
         <!-- 调用方法：加.加方法 -->
         <s:property value="'username'.length()"/>
  </body>

十二、Struts2之值栈

　　1、什么是值栈

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

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

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

* 每个Action实例都有一个ValueStack对象（一个请求对应一个ValueStack对象）

* 在其中保存当前Action 对象和其他相关对象

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

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

　　2、关于值栈的内部结构

　　* 值栈由两部分组成

> root -- Struts把动作和相关对象压入 ObjectStack 中--List（底层ArrayList）

> context -- Struts把各种各样的映射关系(一些 Map 类型的对象) 压入 ContextMap 中（底层Map,当讲Servlet的API时，完成接耦合方式ActionContext.getRequest()所返回的 Map集合就是此集合）

* Struts会默认把下面这些映射压入ContextMap（context）中

* 注意：request代表的是Map集合的key值(字符串名)，value的值其实也是一个Map集合。

> 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 元素（至于context是框架自动将请求参数或者其他数据封装到conttext中）

　　 3、在jsp中查看值栈

 <!-- 在JSP页面上，查看值栈的内部结构 -->
     <s:debug/>

　　4、关于值栈中压值

　　 1）压字符串之push方法

/**
     * 演示值栈对象的目录结构
     * 想栈中压元素，先进先出
     * push：压入的对象
     * set：压入集合(先判断压入的对象是否是集合，不是则强转为集合，再创建键值对；是则在原有集合中压入元素)
     * @author Administrator
     *
     */
    public String execute() throws Exception{
        /*//使用获取值栈对象
        HttpServletRequest request=ServletActionContext.getRequest();
        ValueStack vs=(ValueStack) request.getAttribute("struts.valueStack");
        System.out.println(vs);*/
        //获取值栈对象，先获取到ActionContext对象
        ValueStack vs=ActionContext.getContext().getValueStack();
        System.out.println(vs);
        //栈顶压的是字符串
        vs.push("

美美

");return NONE; }

　　取值

<h3>从值栈中获取值</h3>
     <!--值栈中获取的对象，当存入字符串时，栈顶第一个位置为对象，第二位置为Action,第三位置为封转栈的信息
         栈的默认索引是从0开始：[0]表示获取栈顶的封装对象的一些列信息，[0].top获取对象值
     //vs.push("美美");-->
     <s:property value="[0]"/>
     <s:property value="[0].top"/>

　　 2）压字符串之set方法

ValueStack vs=ActionContext.getContext().getValueStack();
//栈顶压的是集合
vs.set("msg","金在中");

　　取值

 <!-- 从栈顶获取字符串 ，方法为set，值栈中存的是Map集合>
     //vs.set("msg","金在中");-->
     <s:property value="[0].top.msg"/>

　　 3）栈顶放的是User对象,用push方法

ValueStack vs=ActionContext.getContext().getValueStack();
//创建User对象
User user=new User();
user.setUsername("美美");
user.setPassword("123");
//压栈
vs.push(user);

　　取值

 <!--栈顶放的是User对象,用push方法
         //[0].top关键字可以省略，值栈中提供getValue方法，从结果中找指定属性
        /* User user=new User();
        user.setUsername("美美");
        user.setPassword("123");
        //压栈
        vs.push(user);*/-->
     <s:property value="[0].top.username"/>
     <s:property value="[0].top.password"/>
     <s:property value="password"/>

　　 4）栈顶放的是User对象,用set方法

ValueStack vs=ActionContext.getContext().getValueStack();
//创建User对象
User user=new User();
user.setUsername("美美");
user.setPassword("123");
//压栈
vs.set("user",user);

　　取值

 　　<!--栈顶放的是User对象,用set方法
     // vs.set("user",user);-->
     <s:property value="[0].top.user.username"/>
     <s:property value="[0].top.user.password"/>
     <s:property value="user.password"/>

　　 5）在action中配置成员属性，并提供set/get方法，jsp同样可以来接收

private User user=new User("小泽","456");
//提供set/get方法

　　取值

　　　　<!-- 在ValueStack1Action提供了成员属性
       //private User user=new User("小泽","456");
       //提供set/get方法
      //vs.push(user);
               从栈顶开始查找，找user的属性，显示名称，返回的小泽
      [1].top获取到ValueStack1Action,而该Action封装了user属性
      [0].top.user返回的是user对象-->
      <s:property value="user.username"/>

　　 6）获取值栈中（root）集合中的值push

List<User> list=new ArrayList<User>();
        list.add(new User("熊大","123"));
        list.add(new User("熊二","456"));
        list.add(new User("熊三","789"));
        //把集合压栈
        vs.push(list);

　　取值

　　　　 <!-- 获取list集合
             //vs.push(list);-->
      <s:property value="[0].top[0].username"/>
      <s:property value="[0].top[1].username"/>

　　 7）获取值栈中（root）集合中的值set

List<User> list=new ArrayList<User>();
        list.add(new User("熊大","123"));
        list.add(new User("熊二","456"));
        list.add(new User("熊三","789"));
        //把集合压栈
         vs.set("list",list);

　　取值

　　　　<!-- 获取list集合
              //vs.set("list",list); -->
       <s:property value="list[0].username"/>

　　 8）利用迭代标签取值

    ValueStack vs=ActionContext.getContext().getValueStack();
        List<User> list=new ArrayList<User>();
        list.add(new User("熊大","123"));
        list.add(new User("熊二","456"));
        list.add(new User("熊三","789"));
        //把集合压栈
         vs.set("list",list);

　　　取值

<!-- 迭代标签 
             属性： * value 要迭代的集合，需要从值栈中获取
                *  var   迭代过程中，遍历的对象
                      * var编写上，会把迭代产生的对象默认压入到context栈中
                      * var不编写上，默认吧迭代长生的对象压入到root栈中
               
      -->
      <!-- 编写var:value="[0].top"等同于value="list" -->
      <s:iterator value="list" var="u">
             <!--此时是压入context，取值要加#号-->
             <s:property value="#u.username"/>
             <s:property value="#u.password"/>
      </s:iterator>

 <!-- 没有编写var关键字-->
      <s:iterator value="list">
           <s:property value="[0].top.username"/>
           <s:property value="password"/>
      </s:iterator>

　　 9) 从context栈中获取值

ValueStack vs=ActionContext.getContext().getValueStack();
//从context栈中获取值(注意：以上push与set默认都是操纵的root栈)
        //context底层已经封装request session对象，操作的都是map集合
    HttpServletRequest request=ServletActionContext.getRequest();
        request.setAttribute("msg","美美");
        
        request.getSession().setAttribute("msg", "小风");

　　取值

<!--  从context栈中获取值，加#号-->
      <s:property value="#request.msg"/>
      <s:property value="#session.msg"/>

　　 10）针对域名传过来的值，怎么接收

　　加入域名为http://localhost:8080/xx/xx.action?id=5

 <!--  针对于域名传过来的参数（参数名为id),框架会自动封装 -->
      <s:property value="#parameters.id"/>

　　 11) 利用EL表达式接收数据

　　引入jstl标签库

<%@taglib prefix="c" uri="http://java.sun.com/jstl/core_rt" %>

　　取值

 <!-- 在JSP页面上可以使用EL和JSTL标签库来取值
          使用装饰者模式，连接池全栈编码
          getAttribute()增强了 
      -->
      <c:forEach items="${list }" var="user">
            ${user.username}--${user.passwords}
      </c:forEach>