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

2024-02-15 21:04:24

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

struts2拦截器_动力节点Java学院整理

如何使用struts2拦截器,或者自定义拦截器.特别注意,在使用拦截器的时候,在Action里面必须最后一定要引用struts2自带的拦截器缺省堆栈defaultStack,如下(这里我是引用了struts2自带的checkbox拦截器): <interceptor-ref name="checkbox"> <param name="uncheckedValue">0</param> </interceptor-ref>
java Struts2 在拦截器里的跳转问题

复制代码代码如下: java.lang.IllegalStateException at org.apache.catalina.connector.ResponseFacade.sendError(ResponseFacade.java:405) at org.apache.struts2.dispatcher.Dispatcher.sendError(Dispatcher.java:725) at org.apache.struts2.dispatcher.Dispatcher.servi
Struts2拦截器登录验证实例

Struts2拦截器 Struts2拦截器的概念和Spring Mvc拦截器一样. 1.Struts2拦截器是在访问某个Action或Action的某个方法,字段之前或之后实施拦截,并且Struts2拦截器是可插拔的,拦截器是AOP的一种实现． 2.拦截器栈(Interceptor Stack).Struts2拦截器栈就是将拦截器按一定的顺序联结成一条链.在访问被拦截的方法或字段时,Struts2拦截器链中的拦截器就会按其之前定义的顺序被调用. 使用拦截器的第一步: 自定义我的权限拦截器Chec
关于Struts2文件上传与自定义拦截器

一.访问或添加request/session/application属性 public String scope() throws Exception{ ActionContext ctx = ActionContext.getContext(); ctx.getApplication().put("app", "应用范围");//往ServletContext里放入app ctx.getSession().put("ses", &q
struts2过滤器和拦截器的区别分析

本文分析了struts2过滤器和拦截器的区别.分享给大家供大家参考,具体如下: 一.本质区别: 1. 拦截器是基于java的反射机制的,而过滤器是基于函数回调. 2. 拦截器不依赖与servlet容器,过滤器依赖与servlet容器. 3. 拦截器只能对action请求起作用,而过滤器则可以对几乎所有的请求起作用. 4. 拦截器可以访问action上下文.值栈里的对象,而过滤器不能访问. 5. 在action的生命周期中,拦截器可以多次被调用,而过滤器只能在容器初始化时被调用一次二.使用区别:
JavaWeb中Struts2拦截器深入分析（一）

一.struts2中的拦截器(框架功能核心) 1.过滤器VS拦截器过滤器VS拦截器功能是一回事.过滤器是Servlet规范中的技术,可以对请求和响应进行过滤. 拦截器是Struts2框架中的技术,实现AOP(面向切面)的编程思想,是可插拔的, 可以对访问某个 Action 方法之前或之后实施拦截. 拦截器栈(Interceptor Stack): 将拦截器按一定的顺序联结成一条链. 在访问被拦截的方法时, Struts2拦截器链中的拦截器就会按其之前定义的顺序被依次调用 Struts2执行原理
struts2如何使用拦截器进行用户权限控制实例

大多数网站会设置用户权限,如过滤非法用户,用户不登录时不能进行访问,或者设置访问的权限,如部分内容仅对VIP开放等等,这些权限的控制都可以用struts2中的拦截器来实现. 下面通过一个简单的Demo来模拟这种用户权限控制的实现流程,设定三种不同身份的用户,commen为普通用户,VIP为会员用户,还有一种admin为管理员. 先看一下Demo的整体结构: 首先搭建struts2框架的开发环境(前面博客中有介绍),环境搭建完之后又再看一看如何配置struts.xml: <?xml version
Struts2之Action接收请求参数和拦截器详解

技术分析之在Struts2框架中使用Servlet的API 1. 在Action类中也可以获取到Servlet一些常用的API 需求:提供JSP的表单页面的数据,在Action中使用Servlet的API接收到,然后保存到三个域对象中,最后再显示到JSP的页面上. 提供JSP注册的页面,演示下面这三种方式 <h3>注册页面</h3> <form action="${ pageContext.request.contextPath }/xxx.action"
Java的Struts2框架中拦截器使用的实例教程

1.拦截器小介拦截器的功能类似于web.xml文件中的Filter,能对用户的请求进行拦截,通过拦截用户的请求来实现对页面的控制.拦截器是在Struts-core-2.2.3.jar中进行配置的,原始的拦截器是在struts-default.xml中配置的,里面封存了拦截器的基本使用方法. Struts2拦截器功能类似于Servlet过滤器.在Action执行execute方法前,Struts2会首先执行struts.xml中引用的拦截器,如果有多个拦截器则会按照上下顺序依次执行,在执行完所有
详解在Java的Struts2框架中配置Action的方法

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

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

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

我们讲一下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的Struts框架中Action的编写与拦截器的使用方法

Struts2 Action/动作动作是Struts2框架的核心,因为他们的任何MVC(模型 - 视图 - 控制器)框架.每个URL将被映射到一个特定的动作,它提供了来自用户的请求提供服务所需的处理逻辑. 但动作也提供其他两个重要的能力.首先,操作从请求数据的传输中起着重要的作用,通过向视图,无论是一个JSP或其它类型的结果.二,动作必须协助的框架,在确定结果应该渲染视图,在响应该请求将被退回. 创建动作: 在Struts2的动作,唯一的要求是必须有一个无参数的方法返回String或结果的对象
java SpringMvc中拦截器的应用

目录什么是拦截器基本使用实例总结什么是拦截器拦截器(Interceptor)是SpringMVC中的组件.可以使很多个请求被处理时,都会执行拦截器中的代码.拦截器可以选择阻止执行或放行. 举个栗子: 基本使用在SpringMVC中实现HandlerInteceptor拦截器接口,这个类就是一个拦截器类. 利用拦截器最核心的在用控制preHandle方法的返回值,返回true就成功了,返回false就表示进行拦截处理了. 实例首先,创建一个类继承拦截器 public class D
详解Java的Hibernate框架中的Interceptor和Collection

Interceptor 讲到Interceptor,相信熟悉struts2的童鞋肯定不会陌生了,struts2可以自定义拦截器进行自己想要的一系列相关的工作.而这里我们说的Interceptor也是差不多相似的功能. 废话不说,直接来代码: 下面这个是MyInterceptor类,它实现了Interceptor接口: public String onPrepareStatement(String arg0) { return arg0; } public boolean onSave(Obj
Java 超详细讲解SpringMVC拦截器

目录拦截器(interceptor)的作用拦截器和过滤器区别拦截器快速入门多拦截器操作拦截器方法说明本章小结拦截器(interceptor)的作用 Spring MVC 的拦截器类似于 Servlet 开发中的过滤器 Filter,用于对处理器进行预处理和后处理 . 将拦截器按一定的顺序联结成一条链,这条链称为拦截器链(Interceptor Chain) .在访问被拦截的方法或字段时,拦截器链中的拦截器就会按其之前定义的顺序被调用.拦截器也是AOP思想的具体实现.

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

相关推荐

随机推荐