欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Struts2框架入门

程序员文章站 2024-01-09 19:04:46
Struts2框架 一、什么是Struts2 Struts2是一个基于MVC设计模式的Web应用框架,它本质上相当于一个servlet,在MVC设计模式中,Struts2作为控制器(Controller)来建立模型与视图的数据交互。Struts 2是Struts的下一代产品,是在 struts 1和 ......

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文件夹

  Struts2框架入门

  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类所在路径来配置的

  Struts2框架入门

  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的配置进行页面的跳转.

Struts2框架入门

 

Struts2框架入门

 

四、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.xmlstruts-plugin.xmlstruts.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、查看常量

  Struts2框架入门

  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">

   <!--这里的{1}代表统配第一个*;name=linkman_*_*...methd=”{1}”{1}表示匹配第一个*{2}表示通配第二个*,即数字表示*的位置,通过通配符调用指定方法-->

         <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,当讲ServletAPI时,完成接耦合方式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中)

Struts2框架入门

Struts2框架入门

   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>