Java的Struts2框架中拦截器使用的实例教程_java

1、拦截器小介

拦截器的功能类似于web.xml文件中的Filter,能对用户的请求进行拦截,通过拦截用户的请求来实现对页面的控制。拦截器是在Struts-core-2.2.3.jar中进行配置的,原始的拦截器是在struts-default.xml中配置的,里面封存了拦截器的基本使用方法。
Struts2拦截器功能类似于Servlet过滤器。在Action执行execute方法前,Struts2会首先执行struts.xml中引用的拦截器,如果有多个拦截器则会按照上下顺序依次执行,在执行完所有的拦截器的interceptor方法后,会执行Action的execute方法。
Struts2的拦截器必须从com.opensymphoy.xwork2.interceptor.Interceptor中实现该接口,在被定义的拦截器中有下面三个方法需要被实现:

void destroy();
void init();
String intercept(ActionInvocation invocation) throws Exception; 

自定义的拦截器需要重写上面三个方法。另外Struts2的拦截器配置文件struts.xml它是继承了原始文件struts-default.xml文件的,这样在相应的<package>中就会自动拥有struts-default.xml中的所有配置信息了。具体代码如下:

<package name="demo" extends="struts-default" > ... </package> 

 

2、添加拦截器

想要使用拦截器必须要经过配置,struts2采用的是映射的方法,所以想用使用某一个功能就必须在配置文件中配置,拦截器也不例外。所以必须在package中添加相应的拦截器元素,同时将拦截器关联相应的class文件,这样在执行action前才会执行相应的拦截器,具体使用方法如下。

(1)添加配置文件struts.xml,并在该文件中添加拦截器

<package name="testLogin" namespace="/" extends="struts-default">
  <!-- 拦截器 -->
  <interceptors>
    <interceptor name="myInterceptor" class="com.interceptor.MyInterceptor"></interceptor>
  </interceptors> 

  <action name="demo" class="com.action.LoginAction">
    <result name="error" type="redirect">/error.jsp</result>
    <result name="success">/success.jsp</result>
    <result name="checkError">/checkSession.jsp</result>
    <interceptor-ref name="myInterceptor"></interceptor-ref>
    <interceptor-ref name="defaultStack"></interceptor-ref>
  </action>
</package>

上面的package中添加了一个名为myInterceptor的拦截器,并为该拦截器注册了一个java类,该类名称为MyInterceptor,并被封存在com.interceptor包中。另外还在该package中添加了相应的action,在执行该action前会首先执行myInterceptor拦截器。

(2)编写被注册的拦截器类MyInterceptor,该类必须实现com.opensymphoy.xwork2.interceptor.Interceptor接口,并重写相应的方法

package com.interceptor; 

import java.util.Map; 

import com.entity.User;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.Interceptor; 

public class MyInterceptor implements Interceptor{ 

  private User user; 

  public User getUser() {
    return user;
  } 

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

  @Override
  public void destroy() {
    // TODO Auto-generated method stub
    System.out.println("----destroy()----");
  } 

  @Override
  public void init() {
    // TODO Auto-generated method stub
    System.out.println("-----Init()-------");
  } 

  @Override
  public String intercept(ActionInvocation invocation) throws Exception {
    // TODO Auto-generated method stub
    System.out.println("----intercept()------");
    Map<String, Object> session= invocation.getInvocationContext().getSession();
    if(session.get("username")!=null){
      System.out.println("登陆成功!");
      //session.put("username",user.getUsername());
      return invocation.invoke();
    }else{
      System.out.println("登陆失败!");
      return "checkError";
    }
  } 

} 

(3)经过前面两步后,拦截器已经配置完成,最后一部就是使用拦截器了,在显示页面上添加相应的标签,并为标签指定上面创建的名为demo的action,然后执行页面即可在控制台中打印出相应的拦截器内容。

<%@ page language="java" contentType="text/html; charset=UTF-8"
  pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
  <form action="demo">
    用户名:<input type="text" name="username"><br>
    密 码:<input type="text" name="password"><br>
    <input type="submit" name="ok" value="提交">
  </form>
</body>
</html> 

打印输出内容:

分析输出结果,程序编译阶段首先会去读取配置文件struts.xml,在该配置文件action中顺序查找是否添加了拦截器,如果添加了拦截器则根据拦截器名称在<interceptors>中查找是否定义了该拦截器或者拦截器栈,如果发现定义的是拦截器则根据拦截器查找对应的注册的class,最后在包内查找注册的class并执行相应的init()方法;程序运行阶段的大致流程和编译阶段类似,用户在前台提交请求后,会按照注册的action在struts.xml中查找与之相对应的,如果查找到将会查找拦截器,没有查找到的话会相应的抛错,最后执行拦截器注册类的intercept方法。

3、拦截器栈

拦截器同样有栈的概念,它是将使用的拦截器定义到共有的状态下来实现统一管理,这样在package中就可以做到拦截器的共享了,大大便利了拦截器的使用。在一个package中往往会用到重复的interceptor,如果每次都在Action中添加interceptor-ref的话就会很麻烦,那么拦截器栈就是为了解决这个问题而产生的,具体配置如下:

<package name="testLogin" namespace="/" extends="struts-default">
    <!-- 拦截器 -->
    <interceptors>
      <interceptor name="myInterceptor" class="com.interceptor.MyInterceptor"></interceptor>
      <!-- 定义公共的拦截器链,在action标签中只需要引用拦截器链 -->
      <interceptor-stack name="defaultstack1">
        <interceptor-ref name="myInterceptor"></interceptor-ref>
        <interceptor-ref name="defaultStack"></interceptor-ref>
      </interceptor-stack>
    </interceptors> 

    <action name="demo" class="com.action.LoginAction">
      <result name="error" type="redirect">/error.jsp</result>
      <result name="success">/success.jsp</result>
      <result name="checkError">/checkSession.jsp</result>
      <interceptor-ref name="defaultstack1"></interceptor-ref>
    </action>
</package>

实例中使用了interceptor-stack来定义了一个名称为defaultstack1的拦截器栈,在该栈中添加了要执行的拦截器,把拦截器做了封装,在Action中直接调用该拦截器栈即可,实现了拦截器栈的共享。

4、默认拦截器栈

另外可以定义默认的拦截器栈,即:如果某个Action中没有定义拦截器,那么它会默认执行该公共的拦截器。它和interceptors标签属于同一等级的,使用default-interceptor-ref定义。

<package name="testLogin" namespace="/" extends="struts-default">
  <!-- 拦截器 -->
  <interceptors>
    <interceptor name="myInterceptor" class="com.interceptor.MyInterceptor"></interceptor>
    <!-- 定义公共的拦截器链,在action标签中只需要引用拦截器链 -->
    <interceptor-stack name="defaultinter">
      <interceptor-ref name="myInterceptor"></interceptor-ref>
      <interceptor-ref name="defaultStack"></interceptor-ref>
    </interceptor-stack>
  </interceptors> 

  <!-- 定义默认的拦截器栈,会自动注册到action中 -->
  <default-interceptor-ref name="defaultinter"></default-interceptor-ref> 

  <action name="demo" class="com.action.LoginAction">
    <result name="error" type="redirect">/error.jsp</result>
    <result name="success">/success.jsp</result>
    <result name="checkError">/checkSession.jsp</result>
  </action>
</package> 

定义的默认的拦截器栈只是在Action没有指定拦截器的情况下才执行自定义默认的拦截器栈的,如果在Action中重定义了拦截器,那么它会覆盖自定义默认的拦截器栈的。

5、不执行任何拦截器

还有一种情况是一个package中定义了默认的拦截器,但是在编写的某个Action中并不需要执行任何拦截器,那么此时可以在相应的Action中添加一个名称为defaultStack的拦截器即可,它是系统默认的拦截器,不会有任何操作。

<package name="testLogin" namespace="/" extends="struts-default">
  <!-- 拦截器 -->
  <interceptors>
    <interceptor name="myInterceptor" class="com.interceptor.MyInterceptor"></interceptor>
    <!-- 定义公共的拦截器链,在action标签中只需要引用拦截器链 -->
    <interceptor-stack name="defaultinter">
      <interceptor-ref name="myInterceptor"></interceptor-ref>
      <interceptor-ref name="defaultStack"></interceptor-ref>
    </interceptor-stack>
  </interceptors> 

  <!-- 定义默认的拦截器栈,会自动注册到action中 -->
  <default-interceptor-ref name="defaultinter"></default-interceptor-ref> 

  <action name="demo" class="com.action.LoginAction">
    <result name="error" type="redirect">/error.jsp</result>
    <result name="success">/success.jsp</result>
    <result name="checkError">/checkSession.jsp</result> 

    <!-- 添加defaultStack保证不执行拦截器 -->
    <interceptor-ref name="defaultStack"></interceptor-ref>
  </action>
</package> 

6、拦截方法

6.1 用法
上面的拦截器只是实现了对Action的拦截,其实拦截器的功能很强大,它也可以拦截相应Action方法。和拦截Action不同的是想要拦截方法就必须继承类MethodFilterInterceptor,该类封存在xwork-core.jar中,又一次证明了WebWork是Struts2的核心。另外还需要在配置文件中添加相应的属性来确定拦截的方法和不拦截的方法,具体配置方法如下:

<package name="testLogin" namespace="/" extends="struts-default">
  <!-- 拦截器 -->
  <interceptors>
    <interceptor name="myInterceptor" class="com.interceptor.MyInterceptor"></interceptor>
    <!-- 定义公共的拦截器链,在action标签中只需要引用拦截器链 -->
    <interceptor-stack name="defaultinter">
      <interceptor-ref name="myInterceptor"></interceptor-ref>
      <interceptor-ref name="defaultStack"></interceptor-ref>
    </interceptor-stack>
  </interceptors> 

  <action name="demo" class="com.action.LoginAction">
    <result name="error" type="redirect">/error.jsp</result>
    <result name="success">/success.jsp</result>
    <result name="checkError">/checkSession.jsp</result> 

    <!-- 在defaultStack中配置拦截方法,参数includeMethods中添加被拦截的方法名称,excludeMethods中添加不需要拦截的名称 -->
    <interceptor-ref name="defaultStack">
      <param name="includeMethods">添加要拦截的方法名称</param><!-- 拦截方法 -->
      <param name="excludeMethods">添加不需要拦截的方法名称</param><!-- 不拦截方法 -->
    </interceptor-ref>
  </action>
</package> 

继承MethodFilterInterceptor类的相应拦截方法的类中的代码:

package com.interceptor; 

import java.util.Map;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor; 

public class inter extends MethodFilterInterceptor { 

  @Override
  public String doIntercept(ActionInvocation invocation) throws Exception {
    System.out.println("--intercept()--");
    //获取相应的Session
    Map<String,Object> session=invocation.getInvocationContext().getSession(); 

    Map request=(Map)ActionContext.getContext().get("request"); 

    String username=(String)request.get("user.username");
    if(session.get("username") != null){
      String result=invocation.invoke(); 

      System.out.println("--end()--");
      return result;
    }
  } 

} 

6.2 Demo
来看一个拦截方法的实例,并对结果进行分析。下面的实例演示拦截方法的输出结果,在实例中分别创建了一个loginAction类,添加Action要执行的方法;Inter类,拦截器中重写MethodFilterInterceptor方法,在控制台中输出是否对某个方法进行拦截;login.jsp文件,添加三个按钮,分别演示三个方法的执行。
(1)struts.xml内方法拦截器的定义,在package中定义了一个名称为inter的拦截器,在拦截器中指定了参数,includeMethods用来拦截Method1,excludeMethods中的Method2表示不拦截Methods2方法,具体配置如下代码:

<!DOCTYPE struts PUBLIC
     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
     "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
  <constant name="struts.action.extension" value=","></constant> 

  <package name="login" extends="struts-default">
    <interceptors>
      <interceptor name="inter" class="com.interceptor.inter">
        <param name="includeMethods">Method1</param> <!-- 拦截Method1方法 -->
        <param name="excludeMethods">Method2</param>
      </interceptor>
      <interceptor-stack name="myInterceptor">
        <interceptor-ref name="inter"></interceptor-ref>
        <interceptor-ref name="defaultStack"></interceptor-ref>
      </interceptor-stack>
    </interceptors> 

    <action name="loginaction" class="com.action.loginAction">
      <result name="success">success.jsp</result>
      <result name="error">error.jsp</result>
      <result name="cancel" type="redirectAction">Welcome</result>
      <interceptor-ref name="inter"></interceptor-ref>
      <interceptor-ref name="defaultStack"></interceptor-ref>
    </action>
  </package>
</struts> 

(2)loginAction类,配置login.jsp中的action,分别在该类中添加Method1-Method3三个方法,其中Method1被拦截,Method2和Method3不被拦截,最后我们查看输出结果。

package com.action; 

import com.opensymphony.xwork2.ActionSupport; 

public class loginAction extends ActionSupport {
  @Override
  public String execute() throws Exception {
    if(this.username.equals("admin") && this.password.equals("admin")){
      return "success";
    }else if(this.username.equals("cancel") && this.password.equals("cancel")){
      return "cancel";
    }else{
      return "error";
    }
  } 

  public void Method1(){
    System.out.println("执行方法:Method1");
  } 

  public void Method2(){
    System.out.println("执行方法:Method2");
  } 

  public void Method3(){
    System.out.println("执行方法:Method3");
  } 

  private String username;
  private String password; 

  public String getUsername(){
    return this.username;
  } 

  public void setUsername(String username){
    this.username=username;
  } 

  public String getPassword(){
    return this.password;
  } 

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

} 

(3)inter类,继承MethodFilterInterceptor类,用来实现拦截方法。重写doIntercept方法,在该方法中添加拦截的相应信息。

package com.interceptor; 

import java.util.Date;
import java.util.Map; 

import com.action.loginAction;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor; 

public class inter extends MethodFilterInterceptor { 

  @Override
  protected String doIntercept(ActionInvocation invocation) throws Exception {
    // TODO Auto-generated method stub
     System.out.println("拦截器在Action执行前拦截"+new Date());
     String result=invocation.invoke(); //执行Action方法
     System.out.println("拦截器在Action执行后拦截"+new Date());
    return result;  

  } 

} 

(4)login.jsp,在jsp页面上添加三个按钮,分别演示三个方法,判断拦截器对方法的拦截情况。三个按钮在点击后回发的action是在javascript中动态的进行添加的,这样做达到了一个form中执行不同的action的方法,当然还有其它的方法,将会在下篇文章中讨论。

<%@ page language="java" contentType="text/html; charset=UTF-8"
  pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<script type="text/javascript"> 

  //方法1,定义被拦截的方法的实例
  function method1(){
    var form=document.forms[0];
    form.action="loginaction!Method1";
    form.submit();
  } 

  //方法2,为按钮2添加不拦截的方法
  function method2(){
    var form=document.forms[0];
    form.action="loginaction!Method2";
    form.submit();
  } 

  //方法3,为按钮3添加不拦截的方法
  function method3(){
    var form=document.forms[0];
    form.action="loginaction!Method3";
    form.submit();
  }
</script>
</head>
<body>
  <form>
    用户名:<input type="text" name="username"><br>
    密   码:<input type="text" name="password"><br>
    <input type="submit" name="ok" value="按钮1" onclick="method1()">
    <input type="submit" name="ok1" value="按钮2" onclick="method2()">
    <input type="submit" name="ok2" value="按钮3" onclick="method3()">
  </form>
</body>
</html> 

运行完成后的页面视图:

(5)分析运行结果,分别单击按钮1、2、3,在控制台中输出结果,按钮1是绑定的method1,该方法在struts.xml中进行了拦截如果结果正确的话会显示被拦截的结果,而相应的按钮2和3只输出运行结果,因为它们没有被拦截。那看下面的结果图:

结果图正好正是了我们的分析结果,按钮1被拦截了,执行了inter类中的doIntercept方法,二相应的按钮2和3没有被拦截。也就是说,Method1被放到了方法拦截器的白名单内,执行要拦截该方法;Method2被放到了拦截器黑名单内,不需要拦截该方法;Method3不做任何处理。

7、结语

对于拦截器的内容就总结到这里,拦截器提供了很强大的功能,使得开发人员能够在运行时控制输出结果,增加了编程的灵活性。另外对于任何理论性的东西都不要试图去记忆,一定要理性的去分析,多多实践,动手做几个实例,分析结果更深刻的理解。

PS:Struts2(XWork)提供的拦截器的功能说明


拦截器


名字


说明


Alias Interceptor


alias


在不同请求之间将请求参数在不同名字件转换,请求内容不变


Chaining Interceptor


chain


让前一个Action的属性可以被后一个Action访问,现在和chain类型的result(<result type=”chain”>)结合使用。


Checkbox Interceptor


checkbox


添加了checkbox自动处理代码,将没有选中的checkbox的内容设定为false,而html默认情况下不提交没有选中的checkbox。


Cookies Interceptor


cookies


使用配置的name,value来是指cookies


Conversion Error Interceptor


conversionError


将错误从ActionContext中添加到Action的属性字段中。


Create Session Interceptor


createSession


自动的创建HttpSession,用来为需要使用到HttpSession的拦截器服务。


Debugging Interceptor


debugging


提供不同的调试用的页面来展现内部的数据状况。


Execute and Wait Interceptor


execAndWait


在后台执行Action,同时将用户带到一个中间的等待页面。


Exception Interceptor


exception


将异常定位到一个画面


File Upload Interceptor


fileUpload


提供文件上传功能


I18n Interceptor


i18n


记录用户选择的locale


Logger Interceptor


logger


输出Action的名字


Message Store Interceptor


store


存储或者访问实现ValidationAware接口的Action类出现的消息,错误,字段错误等。


Model Driven Interceptor


model-driven


如果一个类实现了ModelDriven,将getModel得到的结果放在Value Stack中。


Scoped Model Driven


scoped-model-driven


如果一个Action实现了ScopedModelDriven,则这个拦截器会从相应的Scope中取出model调用Action的setModel方法将其放入Action内部。


Parameters Interceptor


params


将请求中的参数设置到Action中去。


Prepare Interceptor


prepare


如果Acton实现了Preparable,则该拦截器调用Action类的prepare方法。


Scope Interceptor


scope


将Action状态存入session和application的简单方法。


Servlet Config Interceptor


servletConfig


提供访问HttpServletRequest和HttpServletResponse的方法,以Map的方式访问。


Static Parameters Interceptor


staticParams


从struts.xml文件中将<action>中的<param>中的内容设置到对应的Action中。


Roles Interceptor


roles


确定用户是否具有JAAS指定的Role,否则不予执行。


Timer Interceptor


timer


输出Action执行的时间


Token Interceptor


token


通过Token来避免双击


Token Session Interceptor


tokenSession


和Token Interceptor一样,不过双击的时候把请求的数据存储在Session中


Validation Interceptor


validation


使用action-validation.xml文件中定义的内容校验提交的数据。


Workflow Interceptor


workflow


调用Action的validate方法,一旦有错误返回,重新定位到INPUT画面


Parameter Filter Interceptor


N/A


从参数列表中删除不必要的参数


Profiling Interceptor


profiling


通过参数激活profile

以上是小编为您精心准备的的内容,在的博客、问答、公众号、人物、课程等栏目也有的相关内容,欢迎继续使用右上角搜索按钮进行搜索java
, struts
拦截器
struts2拦截器实例、struts2验证框架实例、struts2框架实例下载、java struts2拦截器、java struts2框架,以便于您获取更多的相关知识。

时间: 2016-07-08

Java的Struts2框架中拦截器使用的实例教程_java的相关文章

Java的MyBatis框架中XML映射缓存的使用教程_java

MyBatis包含一个非常强大的查询缓存特性,它可以非常方便地配置和定制.默认情况下是没有开启缓存的,要开启二级缓存,你需要在你的SQL映射文件中添加一行: <cache/> 字面上看就是这样.这个简单语句的效果如下: 1.映射语句文件中的所有select语句将会被缓存. 2.映射语句文件中的所有insert,update和delete语句会刷新缓存. 3.缓存会使用Least Recently Used(LRU,最近最少使用的)算法来收回. 4.根据时间表(比如 no Flush Inter

Java的Hibernate框架中Criteria查询使用的实例讲解_java

我们讲一下Criteria查询,这个对于不是太熟悉SQL语句的我们这些程序员来说是很容易上手的.  废话不多说,看一下例子:  实体类如下: public class User implements Serializable{ private static final long serialVersionUID = 1L; public Long id; private String name; private int age; //省略Get/Set方法 }   映射文件我们就不写了,很简单的

Java的Hibernate框架中集合类数据结构的映射编写教程_java

一.集合映射 1.集合小介集合映射也是基本的映射,但在开发过程中不会经常用到,所以不需要深刻了解,只需要理解基本的使用方法即可,等在开发过程中遇到了这种问题时能够查询到解决方法就可以了.对应集合映射它其实是指将java中的集合映射到对应的表中,是一种集合对象的映射,在java中有四种类型的集合,分别是Set.Map.List还有普通的数组,它们之间有很大的区别: (1)Set,不可以有重复的对象,对象是无序的: (2)List,可以与重复的对象,对象之间有顺序: (3)Map,它是键值成对出现的

详解在Java的Struts2框架中配置Action的方法_java

在Struts2中Action部分,也就是Controller层采用了低侵入的方式.为什么这么说?这是因为在Struts2中action类并不需要继承任何的基类,或实现任何的接口,更没有与Servlet的API直接耦合.它通常更像一个普通的POJO(通常应该包含一个无参数的execute方法),而且可以在内容定义一系列的方法(无参方法),并可以通过配置的方式,把每一个方法都当作一个独立的action来使用,从而实现代码复用. 例如: package example; public class U

解析Java的Hibernate框架中的持久化类和映射文件_java

持久化类Hibernate的整个概念是采取从Java类属性的值,并将持久到数据库表.一个映射文件Hibernate的帮助确定如何从拉动类的值,并将它们映射与表和相关的域. 其对象或实例将存储在数据库表中的Java类在Hibernate中称为持久化类. Hibernate的效果最好,如果这些类遵循一些简单的规则,也称为普通Java对象(POJO)编程模型.有下列持久化类的主要规则,但是,这些规则并不是必需的. 将所有的持久化Java类需要一个默认的构造函数. 所有类应该包含为了让容易识别对象内Hi

在Java的Hibernate框架中对数据库数据进行查询操作_java

Hibernate查询语言(HQL)是一种面向对象的查询语言,类似于SQL,但不是对表和列操作,HQL适用于持久对象和它们的属性. HQL查询由Hibernate转换成传统的SQL查询,这在圈上的数据库执行操作. 虽然可以直接使用SQL语句和Hibernate使用原生SQL,但建议使用HQL尽可能避免数据库可移植性的麻烦,并采取Hibernate的SQL生成和缓存策略的优势. 都像SELECT,FROM和WHERE等关键字不区分大小写,但如表名和列名的属性是区分在HQL敏感. FROM 语句使用

Java+Spring+MySql环境中安装和配置MyBatis的教程_java

1.MyBatis简介与配置MyBatis+Spring+MySql 1.1MyBatis简介      MyBatis 是一个可以自定义SQL.存储过程和高级映射的持久层框架.MyBatis 摒除了大部分的JDBC代码.手工设置参数和结果集重获.MyBatis 只使用简单的XML 和注解来配置和映射基本数据类型.Map 接口和POJO 到数据库记录.相对Hibernate和Apache OJB等"一站式"ORM解决方案而言,Mybatis 是一种"半自动化"的OR

在Java的Struts框架下进行web编程的入门教程_java

当点击一个超链接或提交一个HTML表单在Struts2 的 Web应用程序,输入所收集被发送到一个Java类称为操作控制器.当动作执行后,结果选择了一个资源来呈现响应.资源通常是一个JSP,但它也可以是一个PDF文件,Excel电子表格,或一个Java applet 窗口. 假设已经建立开发环境.现在让我们继续为第一个 "Hello World" 的 struts2 项目构建.这个项目的目的是建立一个Web应用程序,它收集用户的姓名,并显示"Hello World"

详解Java的Struts框架中栈值和OGNL的使用_java

值栈:值栈是一个集合中的几个对象保持下列对象提供的顺序: 值栈可以通过JSP,Velocity或者Freemarker的标签.有各种不同的标签在单独的章节中,我们将学习,用于获取和设置Struts 2.0 的值栈. ValueStack的对象里面可以得到动作如下: ActionContext.getContext().getValueStack() 一旦拥有了值对象,就可以用下面的方法来操纵该对象: OGNL:对象图形导航语言(OGNL)是一个功能强大的表达式语言是用来参考值栈上的数据和操纵.