Java的Struts框架中Action的编写与拦截器的使用方法

程序员文章站 2024-03-08 09:28:16

struts2 action/动作动作是struts2框架的核心，因为他们的任何mvc（模型 - 视图 - 控制器）框架。每个url将被映射到一个特定的动作，它提供了来...

struts2 action/动作
动作是struts2框架的核心，因为他们的任何mvc（模型 - 视图 - 控制器）框架。每个url将被映射到一个特定的动作，它提供了来自用户的请求提供服务所需的处理逻辑。

但动作也提供其他两个重要的能力。首先，操作从请求数据的传输中起着重要的作用，通过向视图，无论是一个jsp或其它类型的结果。二，动作必须协助的框架，在确定结果应该渲染视图，在响应该请求将被退回。

创建动作：
在struts2的动作，唯一的要求是必须有一个无参数的方法返回string或结果的对象，必须是一个pojo。如果不带参数的方法是不指定，则默认动作是使用execute()方法。

也可以选择扩展actionsupport类实现了6个接口，包括动作界面。动作界面如下：

public interface action {
 public static final string success = "success";
 public static final string none = "none";
 public static final string error = "error";
 public static final string input = "input";
 public static final string login = "login";
 public string execute() throws exception;
}

让我们来看看hello world示例的操作方法：

package com.yiibai.struts2;

public class helloworldaction{
 private string name;

 public string execute() throws exception {
  return "success";
 }
 
 public string getname() {
  return name;
 }

 public void setname(string name) {
  this.name = name;
 }
}

为了说明这一点，操作方法控制视图，让我们做出以下更改执行方法和扩展类actionsupport 如下：

package com.yiibai.struts2;

import com.opensymphony.xwork2.actionsupport;

public class helloworldaction extends actionsupport{
 private string name;

 public string execute() throws exception {
  if ("secret".equals(name))
  {
   return success;
  }else{
   return error; 
  }
 }
 
 public string getname() {
  return name;
 }

 public void setname(string name) {
  this.name = name;
 }
}

在这个例子中，我们有一些在execute方法的逻辑来看待的name属性。如果属性等于字符串“secret”，我们返回success 的结果，否则我们返回error 的结果。因为我们已经扩展actionsupport，所以我们可以使用字符串常量的成功和错误。现在，让我们修改我们的struts.xml文件如下：

<?xml version="1.0" encoding="utf-8"?>
<!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.devmode" value="true" />
  <package name="helloworld" extends="struts-default">
   <action name="hello" 
   class="com.yiibai.struts2.helloworldaction"
   method="execute">
   <result name="success">/helloworld.jsp</result>
   <result name="error">/accessdenied.jsp</result>
   </action>
  </package>
</struts>

创建视图
让我们创建以下jsp文件 helloworld.jsp 的webcontent文件夹在eclipse项目。要做到这一点，右键单击webcontent文件夹在项目资源管理器，选择new >jsp file。该文件将要求返回的结果是success，这是一个字符串常量“success”的定义在动作界面：

<%@ page contenttype="text/html; charset=utf-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head>
<title>hello world</title>
</head>
<body>
 hello world, <s:property value="name"/>
</body>
</html>

以下是由框架的动作的结果将被调用的文件，该文件是等于字符串常量“错误”的error 。以下是accessdenied.jsp 的内容

<%@ page contenttype="text/html; charset=utf-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head>
<title>access denied</title>
</head>
<body>
 you are not authorized to view this page.
</body>
</html>

我们还需要在webcontent文件夹中创建index.jsp。该文件将作为初始动作url，用户可以直接点击告诉struts 2框架调用helloworldaction类的 execute方法，并呈现 helloworld.jsp视图。

<%@ page language="java" contenttype="text/html; charset=iso-8859-1"
 pageencoding="iso-8859-1"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
 <!doctype html public "-//w3c//dtd html 4.01 transitional//en" 
"http://www.w3.org/tr/html4/loose.dtd">
<html>
<head>
<title>hello world</title>
</head>
<body>
 <h1>hello world from struts2</h1>
 <form action="hello">
  <label for="name">please enter your name</label><br/>
  <input type="text" name="name"/>
  <input type="submit" value="say hello"/>
 </form>
</body>
</html>

就是这样，不需要改变的web.xml文件，所以让我们用同一个web.xml，是之前我们已经创建了范例章。现在，我们已经准备好运行使用struts 2框架的 hello world应用程序。

执行应用程序
右键点击项目名称，并单击 export > war file 创建一个war文件。然后在tomcat 的webapps目录下部署这个war。最后，启动tomcat服务器和尝试访问url http://localhost:8080/helloworldstruts2/index.jsp。这会给出以下画面：

Java的Struts框架中Action的编写与拦截器的使用方法

让我们为“secret”，并输入一个字，应该看到以下页面：

Java的Struts框架中Action的编写与拦截器的使用方法

现在输入任何单词而非“secret”，应该看到以下页面：

Java的Struts框架中Action的编写与拦截器的使用方法

建立多个动作：
经常会定义一个以上的动作，以处理不同的请求，并提供不同的用户的url，因此可以定义不同的类定义如下：

package com.yiibai.struts2;
import com.opensymphony.xwork2.actionsupport;

 class myaction extends actionsupport{
  public static string good = success;
  public static string bad = error;
 }

 public class helloworld extends actionsupport{
  ...
  public string execute()
  {
   if ("secret".equals(name)) return myaction.good;
   return myaction.bad;
  }
  ...
 }

 public class someotherclass extends actionsupport{
  ...
  public string execute()
  {
   return myaction.good;
  }
  ...
 }

在struts.xml文件中配置这些操作如下：

<?xml version="1.0" encoding="utf-8"?>
<!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.devmode" value="true" />
 <package name="helloworld" extends="struts-default">
  <action name="hello" 
   class="com.yiibai.struts2.helloworld" 
   method="execute">
   <result name="success">/helloworld.jsp</result>
   <result name="error">/accessdenied.jsp</result>
  </action>
  <action name="something" 
   class="com.yiibai.struts2.someotherclass" 
   method="execute">
   <result name="success">/something.jsp</result>
   <result name="error">/accessdenied.jsp</result>
  </action>
 </package>
</struts>

正如看到在上述假设的例子，动作的结果是重复的success和error。要解决这个问题，建议创建一个类包含结果的结果。

struts2 拦截器
拦截器的概念是servlet过滤器或jdk代理类一样的。拦截器允许横切功能分开实现的动作，以及框架。使用拦截器，可以实现如下：

提供预处理行动之前被称为逻辑。
提供后处理逻辑动作后被调用
捕获异常，这样可以进行替代处理。

struts2框架提供的许多功能都使用拦截实现的例子包括异常处理，文件上传，生命周期回调和验证等事实上作为struts2的基础，其功能拦截，这可能有7或8拦截器分配给每个动作。

struts2框架的拦截器：
struts 2框架提供了良好的箱拦截列表来预先设定的，并准备使用。下面列出了几个重要的拦截：

Java的Struts框架中Action的编写与拦截器的使用方法

请看struts 2文档的完整细节上面提到的拦截。会告诉如何使用struts应用程序在一个拦截器。

如何使用拦截器？
让我们来看看如何使用已有的拦截，我们的“hello world”程序。我们将使用计时器来测量过了多长时间执行操作方法，其目的是拦截。同时使用params拦截器，其目的是发送请求参数的动作。您可以尝试不使用这个拦截您的示例中会发现，没有被设置name属性，因为参数是无法达到动作。

我们将继续helloworldaction.java，web.xml 的helloworld.jsp 和 index.jsp 文件，因为他们已经建立了范例章节，但让我们如下修改struts.xml文件，添加一个拦截器

<?xml version="1.0" encoding="utf-8"?>
<!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.devmode" value="true" />
 <package name="helloworld" extends="struts-default">
  <action name="hello" 
   class="com.yiibai.struts2.helloworldaction"
   method="execute">
   <interceptor-ref name="params"/>
   <interceptor-ref name="timer" />
   <result name="success">/helloworld.jsp</result>
  </action>
 </package>
</struts>

右键点击项目名称，并单击 export > war file 创建一个war文件。然后部署在tomcat 的webapps目录下这个war。最后，启动tomcat服务器和尝试访问url http://localhost:8080/helloworldstruts2/index.jsp。这会给你以下画面：

Java的Struts框架中Action的编写与拦截器的使用方法

现在，在给定的文本框中输入单词，并单击“say hello按钮执行已定义的动作。现在，如果将检查生成的日志，会发现下面的文字：

info: server startup in 3539 ms
27/08/2011 8:40:53 pm 
com.opensymphony.xwork2.util.logging.commons.commonslogger info
info: executed action [//hello!execute] took 109 ms.

这里底行，正在生成因为这告诉动作发生要执行的总共为 109ms定时器的拦截器。

创建自定义的拦截器
在应用程序中使用自定义的拦截器是一种优雅的方式提供横切的应用功能。创建一个自定义拦截器是很容易的，需要扩展的接口，下面的interceptor接口：

public interface interceptor extends serializable{
 void destroy();
 void init();
 string intercept(actioninvocation invocation)
 throws exception;
}

正如其名称所表明的，init()方法提供了一种方法来初始化拦截器，并destroy() 方法提供了一种工具拦截清理。不同的行动，拦截被重用跨请求和需要是线程安全的，尤其是intercept() 方法。

actioninvocation对象可以访问运行时环境。它允许访问的动作本身和方法调用的动作，并确定动作是否已被调用。

如果不需要初始化或清除代码，可以扩展abstractinterceptor类。这提供了一个默认的无操作实现的init（）和 destroy（）方法。

创建拦截器类：
让我们创建java资源 myinterceptor.java> src 文件夹：

package com.yiibai.struts2;

import java.util.*;
import com.opensymphony.xwork2.actioninvocation;
import com.opensymphony.xwork2.interceptor.abstractinterceptor;

public class myinterceptor extends abstractinterceptor {

 public string intercept(actioninvocation invocation)throws exception{

  /* let us do some pre-processing */
  string output = "pre-processing"; 
  system.out.println(output);

  /* let us call action or next interceptor */
  string result = invocation.invoke();

  /* let us do some post-processing */
  output = "post-processing"; 
  system.out.println(output);

  return result;
 }
}

就像看到的，实际行动将使用拦截器执行invocation.invoke()调用。所以，可以做一些前处理和一些处理后，根据需要。

该框架本身启动的过程中，在第一次调用actioninvocation对象的invoke()。每次 invoke()被调用，actioninvocation的咨询的状态和执行为准拦截接下来。通过请求流以下数据图显示了相同的概念：

Java的Struts框架中Action的编写与拦截器的使用方法

创建动作类：
让我们创建一个java文件helloworldaction.java的java下java resources > src下面给出的内容包名为 com.yiibai.struts2。

package com.yiibai.struts2;

import com.opensymphony.xwork2.actionsupport;

public class helloworldaction extends actionsupport{
 private string name;

 public string execute() throws exception {
  system.out.println("inside action....");
  return "success";
 } 

 public string getname() {
  return name;
 }

 public void setname(string name) {
  this.name = name;
 }
}

在前面的例子中，我们已经看到，这是一个相同的类。我们有标准的“名称”属性的getter和setter方法，并返回字符串“success”的执行方法。

创建视图
让我们创建以下jsp文件helloworld.jsp，在eclipse项目在webcontent文件夹。

<%@ page contenttype="text/html; charset=utf-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head>
<title>hello world</title>
</head>
<body>
 hello world, <s:property value="name"/>
</body>
</html>

创建页面：
我们还需要在webcontent文件夹中创建 index.jsp。该文件将作为初始动作url，用户可以在其中点击告诉struts 2框架调用 helloworldaction类定义的方法呈现 helloworld.jsp视图。

<%@ page language="java" contenttype="text/html; charset=iso-8859-1"
 pageencoding="iso-8859-1"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
 <!doctype html public "-//w3c//dtd html 4.01 transitional//en" 
"http://www.w3.org/tr/html4/loose.dtd">
<html>
<head>
<title>hello world</title>
</head>
<body>
 <h1>hello world from struts2</h1>
 <form action="hello">
  <label for="name">please enter your name</label><br/>
  <input type="text" name="name"/>
  <input type="submit" value="say hello"/>
 </form>
</body>
</html>

hello 动作定义在上面的视图文件将被映射到helloworldaction类和其执行方法使用struts.xml文件。

配置文件
现在，我们需要注册我们的拦截器，然后调用它默认的拦截器在前面的例子中调用。要注册一个新定义的拦截，直接放在的<interceptors>...</interceptors>标签下<package>的标签插件struts.xml文件。您可以跳过这一步为默认的拦截器，就像我们在我们前面的例子。但在这里，让我们注册和使用它，如下所示：

<?xml version="1.0" encoding="utf-8"?>
<!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.devmode" value="true" />
 <package name="helloworld" extends="struts-default">

  <interceptors>
   <interceptor name="myinterceptor"
   class="com.yiibai.struts2.myinterceptor" />
  </interceptors>

  <action name="hello" 
   class="com.yiibai.struts2.helloworldaction" 
   method="execute">
   <interceptor-ref name="params"/>
   <interceptor-ref name="myinterceptor" />
   <result name="success">/helloworld.jsp</result>
  </action>

 </package>
</struts>

应该指出的是，可以注册多个拦截器<package>标签内，同一时间，可以调用多个拦截里面的<action>标签。可以调用相同的拦截器与不同的动作。

web.xml文件需要在 web-inf文件夹下创建 webcontent 如下：

<?xml version="1.0" encoding="utf-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
 xmlns="http://java.sun.com/xml/ns/javaee" 
 xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
 xsi:schemalocation="http://java.sun.com/xml/ns/javaee 
 http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
 id="webapp_id" version="3.0">
 
 <display-name>struts 2</display-name>
 <welcome-file-list>
  <welcome-file>index.jsp</welcome-file>
 </welcome-file-list>
 <filter>
  <filter-name>struts2</filter-name>
  <filter-class>
   org.apache.struts2.dispatcher.filterdispatcher
  </filter-class>
 </filter>

 <filter-mapping>
  <filter-name>struts2</filter-name>
  <url-pattern>/*</url-pattern>
 </filter-mapping>
</web-app>

右键点击项目名称，并单击 export > war file 文件创建一个war文件。然后部署在tomcat 的webapps目录下这个war。最后，启动tomcat 服务器和尝试访问url http://localhost:8080/helloworldstruts2/index.jsp。这会给你以下画面：

Java的Struts框架中Action的编写与拦截器的使用方法

现在，在给定的文本框中输入任何单词，并单击“say hello“ 按钮执行已定义的动作。现在，如果检查生成的日志，会发现下面的文本下方：

pre-processing
inside action....
post-processing

堆叠多个拦截器：
可以想像，配置多个拦截器每个动作很快就会变得非常难以控制。出于这个原因，拦截器与拦截器栈管理。下面是一个例子，直接从在struts-default.xml文件：

<interceptor-stack name="basicstack">
 <interceptor-ref name="exception"/>
 <interceptor-ref name="servlet-config"/>
 <interceptor-ref name="prepare"/>
 <interceptor-ref name="checkbox"/>
 <interceptor-ref name="params"/>
 <interceptor-ref name="conversionerror"/>
</interceptor-stack>

上面的栈被调用basicstack，可用于在配置中，如下所示。此配置节点放置在<package.../>节点下。每个<interceptor-ref.../>标记引用一个拦截器或拦截器栈已配置在当前的拦截器栈。因此，这是非常重要的，以确保该名称是唯一的所有拦截器和拦截器栈配置配置初始的拦截器和拦截器栈时。

我们已经看到了如何应用拦截的动作，将拦截器栈是没有什么不同。事实上，我们完全使用相同的标签：

<action name="hello" class="com.yiibai.struts2.myaction">
 <interceptor-ref name="basicstack"/>
 <result>view.jsp</result>
</action

上述注册的“basicstack”所有6个拦截器完成注册的栈 hello 动作。应该指出的是，拦截器执行的顺序在配置中。例如，在上述情况下，异常将被执行，servlet 配置等。

上一篇：在Java的Struts框架下进行web编程的入门教程

下一篇：封装的一个asp.net验证码类

Java的Struts框架中Action的编写与拦截器的使用方法

Java的Struts框架简介与环境配置教程

Java的Struts框架中Action的编写与拦截器的使用方法

详解Java的Hibernate框架中的缓存与二级缓存

详解Java的Hibernate框架中的缓存与原生SQL语句的使用

详解Java的Hibernate框架中的List映射表与Bag映射

详解Java的Hibernat框架中的Map映射与SortedMap映射

详解Java的Hibernate框架中的set映射集与SortedSet映射

详解Java的Hibernate框架中的注解与缓存

Java的Struts框架中登陆功能的实现和表单处理器的使用

深入解析Java的Struts框架中的控制器DispatchAction