拦截器Interceptor…..拦截器是Struts的概念，它与过滤器是类似的…可以近似于看作是过滤器

前面在介绍Struts的时候已经讲解过了，Struts为我们实现了很多的功能，比如数据自动封装阿..文件上传功能阿….Struts为我们提供的这些功能都是通过拦截器完成的……

  • 数据自动封装通过<interceptor name="params" class="com.opensymphony.xwork2.interceptor.ParametersInterceptor"/>这个拦截器。
  • 文件上传通过<interceptor name="fileUpload" class="org.apache.struts2.interceptor.FileUploadInterceptor"/>这个拦截器

拦截器的设计就是基于组件设计的应用！

在开始讲解Struts的时候已经说明过了struts-default.xml这个文件，它定义了Struts的所有拦截器。因为我们在启动服务器的时候会自动装载这个文件，因此我们才可以在Action中使用到Struts为我们提供的功能【数据自动封装…文件上传】

在struts-default.xml中定义的拦截器就有32个之多，Struts2为了方便我们对拦截器的引用，提供了拦截器栈的定义。

  2.             <interceptor-stack name="defaultStack">
  3.                 <interceptor-ref name="exception"/>
  4.                 <interceptor-ref name="alias"/>
  5.                 <interceptor-ref name="servletConfig"/>
  6.                 <interceptor-ref name="i18n"/>
  7.                 <interceptor-ref name="prepare"/>
  8.                 <interceptor-ref name="chain"/>
  9.                 <interceptor-ref name="scopedModelDriven"/>
  10.                 <interceptor-ref name="modelDriven"/>
  11.                 <interceptor-ref name="fileUpload"/>
  12.                 <interceptor-ref name="checkbox"/>
  13.                 <interceptor-ref name="multiselect"/>
  14.                 <interceptor-ref name="staticParams"/>
  15.                 <interceptor-ref name="actionMappingParams"/>
  16.                 <interceptor-ref name="params">
  17.                     <param name="excludeParams">dojo\..*,^struts\..*,^session\..*,^request\..*,^application\..*,^servlet(Request|Response)\..*,parameters\...*</param>
  18.                 </interceptor-ref>
  19.                 <interceptor-ref name="conversionError"/>
  20.                 <interceptor-ref name="validation">
  21.                     <param name="excludeMethods">input,back,cancel,browse</param>
  22.                 </interceptor-ref>
  23.                 <interceptor-ref name="workflow">
  24.                     <param name="excludeMethods">input,back,cancel,browse</param>
  25.                 </interceptor-ref>
  26.                 <interceptor-ref name="debugging"/>
  27.             </interceptor-stack>

也就是说：当我们要引用多个拦截器的时候，只要把拦截器都放在栈里头，在外边引用拦截器即可！

值得注意的是：Struts2默认执行的是默认拦截器栈，一旦用户有指定执行哪些拦截器，那么默认的拦截器栈就不会被执行！

Struts2允许我们自定义拦截器，这就使我们能够更加灵活地操作Struts2这个框架了！

Struts2提供了Interceptor这个拦截器接口，只要我们实现这个接口，那么这就算是自定义开发拦截器了。

当然啦，大部分时候，我们定义拦截器都是继承AbstractInterceptor这个类….为了学习拦截器的内容，下面就实现Interceptor这个接口了。

  • 当实现该接口时，有3个需要我们实现的方法：
  3. public class MyInterceptor implements Interceptor {
  4.     @Override
  5.     public void destroy() {
  7.     }
  9.     @Override
  10.     public void init() {
  12.     }
  14.     @Override
  15.     public String intercept(ActionInvocation actionInvocation) throws Exception {
  16.         return null;
  17.     }
  18. }

init()和destory()都是和拦截器执行顺序有关的方法，我们现在先不理会….首先来讲解intercept这个方法

  2.     /**
  3.      * @param actionInvocation 拦截器的执行状态
  4.      */
  5.     @Override
  6.     public String intercept(ActionInvocation actionInvocation) throws Exception {
  7.         
  8.         //调用invoke()方法，代表着放行执行下一个拦截器，如果没有拦截器了，那么就执行Action的业务代码
  9.         actionInvocation.invoke();
  10.         return null;
  11.     }

这很容易就能让我们想起在学习过滤器中的doFilter()方法，其实是差不多的！

像Struts默认的拦截器一样，我们自定义的拦截器是需要我们在struts中配置的。

由于我们配置了自定义拦截器，那么struts默认的拦截器栈是不会执行的。如果我们想要使用默认拦截器栈的功能，就必须把它配置在我们自定义的栈中！

  2.     <package name="xxx" extends="struts-default" >
  3.         
  4.         <interceptors>
  5.             <!--配置用户自定义的拦截器-->
  6.             <interceptor name="MyInterceptor" class="TestAction"/>
  7.             
  8.             <!--自定义拦截器栈，我们配置了自定义的拦截器，默认的拦截器栈就不会被执行，因此，想要使用默认的拦截器功能，就要配置进来-->
  9.             <interceptor-stack name="mystack">
  10.                 <!--引用默认的拦截器栈，一定要放在第一行-->
  11.                 <interceptor-ref name="defalutStack"/>
  12.                 
  13.                 <!--引用自定义的拦截器-->
  14.                 <interceptor-ref name="MyInterceptor"/>
  15.             </interceptor-stack>
  16.         </interceptors>
  17.         
  18.         <!--上面配置了拦截器栈，但是没有被执行...下面配置执行拦截器-->
  19.         <default-interceptor-ref name="mystack"/>
  20.         
  21.         <action name="TestAction" class="TestAction" method="execute">
  22.             <result name="success">/index.jsp</result>
  24.         </action>
  27.     </package>

我们来观察拦截器和Action类的执行顺序…只要在对应的方法上向控制台输出就行了！

  • 拦截器
  2. public class MyInterceptor implements Interceptor {
  3.     @Override
  4.     public void destroy() {
  6.         System.out.println("我是拦截器的销毁方法");
  8.     }
  10.     @Override
  11.     public void init() {
  13.         System.out.println("我是拦截器的初始化方法");
  14.     }
  17.     /**
  18.      * @param actionInvocation 拦截器的执行状态
  19.      */
  20.     @Override
  21.     public String intercept(ActionInvocation actionInvocation) throws Exception {
  23.         System.out.println("我是拦截器的拦截方法");
  25.         //调用invoke()方法，代表着放行执行下一个拦截器，如果没有拦截器了，那么就执行Action的业务代码
  26.         //可看成是过滤器的doFilter()方法
  27.         actionInvocation.invoke();
  28.         return null;
  29.     }
  30. }
  • Action类
  2. public class TestAction extends ActionSupport {
  4.     public TestAction() {
  5.         System.out.println("我是Action类，我被初始化了！");
  6.     }
  8.     @Override
  9.     public String execute() throws Exception {
  11.         System.out.println("我是Action类的执行方法");
  14.         return null;
  16.     }
  17. }

这里写图片描述

从效果图我们可以看出，他们的执行顺序是这样的：

  • 当服务器开启的时候，会执行拦截器的init()方法
  • 当访问Action时，Action实例被创建
  • 创建完Action实例，会调用拦截器的interceptor()方法
  • 最后，执行Action的execute()方法

其实很好理解，之前我们使用Struts为我们提供数据自动封装功能的时候，是这样子的：

  • 服务器启动，加载配置文件的信息
  • 初始化默认的拦截器栈
  • 当用户访问Action时，创建Action的实例。拿到Action具体的信息【成员变量、setter和getter】
  • 执行拦截器具体的内容，根据Action具体的信息，把web端的数据封装到Action上
  • 最后在execute()就可以得到封装后的数据了！

这里写图片描述

需求：当用户登陆成功，跳转到显示用户的JSP页面中。当用户登陆失败，重新返回登陆界面。如果用户直接访问显示用户的JSP页面，那么返回到登陆界面

这里写图片描述

实现这个需求，我们可以使用过滤器的。只要获取用户的请求URL，再判断URL是不是为list.jsp，如果是，我们返回到登陆的界面就好了。

现在，为了对拦截器的理解，我们使用拦截器去完成这个功能！

  • 导入我们c3p0.xml文件
  • 导入c3p0开发包
  • 导入mysql开发包
  • 写数据库连接池工具类
  • dbUtils开发包
  • 8个struts2需要用到的开发包

这里写图片描述

  • 创建数据库表，导入数据

这里写图片描述

  2. package zhongfucheng.entity;
  4. /**
  5.  * Created by ozc on 2017/5/3.
  6.  */
  7. public class User {
  8.     
  9.     
  10.     private String id ;
  11.     private String username;
  12.     private String cellphone;
  13.     private String email;
  14.     private String password;
  16.     public String getId() {
  17.         return id;
  18.     }
  20.     public void setId(String id) {
  21.         this.id = id;
  22.     }
  24.     public String getUsername() {
  25.         return username;
  26.     }
  28.     public void setUsername(String username) {
  29.         this.username = username;
  30.     }
  32.     public String getCellphone() {
  33.         return cellphone;
  34.     }
  36.     public void setCellphone(String cellphone) {
  37.         this.cellphone = cellphone;
  38.     }
  40.     public String getEmail() {
  41.         return email;
  42.     }
  44.     public void setEmail(String email) {
  45.         this.email = email;
  46.     }
  48.     public String getPassword() {
  49.         return password;
  50.     }
  52.     public void setPassword(String password) {
  53.         this.password = password;
  54.     }
  55. }
  1. package zhongfucheng.dao;
  3. import org.apache.commons.dbutils.QueryRunner;
  4. import org.apache.commons.dbutils.handlers.BeanHandler;
  5. import org.apache.commons.dbutils.handlers.BeanListHandler;
  6. import zhongfucheng.entity.User;
  7. import zhongfucheng.utils.Utils2DB;
  9. import java.sql.SQLException;
  10. import java.util.List;
  12. /**
  13.  * Created by ozc on 2017/5/3.
  14.  */
  15. public class UserDao {
  17.     public User login(User user) {
  19.         try {
  20.             String sql = "SELECT * FROM user WHERE username = ? AND password = ?";
  21.             QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());
  22.             return (User) queryRunner.query(sql, new BeanHandler(User.class), new Object[]{user.getUsername(), user.getPassword()});
  23.         } catch (SQLException e) {
  24.             new RuntimeException("登陆失败了！");
  25.         }
  27.         return null;
  28.     }
  30.     public List<User> getAll() {
  32.         try {
  33.             String sql = "SELECT * FROM user";
  34.             QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());
  35.             return (List<User>) queryRunner.query(sql, new BeanListHandler(User.class));
  36.         } catch (SQLException e) {
  37.             new RuntimeException("登陆失败了！");
  38.         }
  40.         return null;
  41.     }
  43. }
  2. public class Service {
  4.     UserDao userDao = new UserDao();
  6.     public User login(User user) {
  7.         return userDao.login(user);
  9.     }
  11.     public List<User> getAll() {
  12.         return userDao.getAll();
  13.     }
  14. }
  2. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  3. <html>
  4. <head>
  5.     <title>登陆页面</title>
  6. </head>
  7. <body>
  9. <form action="${pageContext.request.contextPath}/user_login" method="post">
  10.     <input type="text" name="username"><br>
  11.     <input type="password" name="password"><br>
  12.     <input type="submit" value="登陆"><br>
  13. </form>
  14. </body>
  15. </html>
  2. package zhongfucheng.action;
  4. import com.opensymphony.xwork2.ActionContext;
  5. import zhongfucheng.entity.User;
  6. import zhongfucheng.service.Service;
  8. import java.util.List;
  9. import java.util.Map;
  11. /**
  12.  * Created by ozc on 2017/5/3.
  13.  */
  14. public class UserAction {
  17.     /****************1.封装数据********************/
  18.     private User user;
  20.     public User getUser() {
  21.         return user;
  22.     }
  24.     public void setUser(User user) {
  25.         this.user = user;
  26.     }
  28.     /***************2.调用Service*******************/
  29.     Service service = new Service();
  32.     //登陆
  33.     public String login() {
  35.         User user = service.login(this.user);
  37.         if (user == null) {
  38.             return "input";
  39.         } else {
  40.             //将user的信息存到Session域对象中
  41.             Map<String, Object> session = ActionContext.getContext().getSession();
  42.             session.put("user", user);
  45.             //登陆成功
  46.             return "login";
  47.         }
  48.     }
  50.     //查看user信息
  51.     public String list() {
  53.         //拿到所有用户的信息
  54.         List<User> users = service.getAll();
  56.         //存到request域对象中
  57.         Map<String, Object> request = ActionContext.getContext().getContextMap();
  59.         request.put("users", users);
  61.         return "list";
  62.     }
  64. }
  1.     <package name="xxx" extends="struts-default" >
  2.         <action name="user_*" class="zhongfucheng.action.UserAction" method="{1}" >
  4.             <!--如果登陆成功，重定向到Action中，执行list业务方法-->
  5.             <result name="login" type="redirectAction">user_list</result>
  7.             <!--如果是list，那么跳转到list.jsp页面-->
  8.             <result name="list" >/WEB-INF/list.jsp</result>
  9.         </action>
  11.     </package>

到目前为止，我们登陆或者不登陆都可以得到用户的具体信息….这是不合理的

我们想要的效果是：只有用户正在调用login方法，或者该用户已经登陆了，才可以查看具体的用户信息。

这里写图片描述

因此，我们们要拦截它们，只有用户调用的是login方法时或者已经登陆的情况下，才能跳转到对应的显示页面

  2. package zhongfucheng;
  4. import com.opensymphony.xwork2.ActionContext;
  5. import com.opensymphony.xwork2.ActionInvocation;
  6. import com.opensymphony.xwork2.ActionProxy;
  7. import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
  9. /**
  10.  * Created by ozc on 2017/5/3.
  11.  */
  12. public class Interceptor  extends AbstractInterceptor{
  15.     @Override
  16.     public String intercept(ActionInvocation actionInvocation) throws Exception {
  18.         //得到正在执行的代理对象
  19.         ActionProxy proxy = actionInvocation.getProxy();
  21.         //通过代理对象得到正在执行的方法
  22.         String method = proxy.getMethod();
  25.         //如果方法的名字不是login，那么就让他们返回到login页面上
  26.         if (!method.equals("login")) {
  28.             //查看用户是否登陆了
  29.             Object user = ActionContext.getContext().getSession().get("user");
  31.             //如果没有登陆，回到login页面
  32.             if (user == null) {
  34.                 return "input";
  35.             } else {
  37.                 //登陆了，那么就让它访问具体的用户信息页面
  38.                 return actionInvocation.invoke();
  39.             }
  40.         } else {
  42.             //如果是访问login方法，那么就让它执行
  43.             return actionInvocation.invoke();
  44.         }
  46.     }
  47. }
  2. <?xml version="1.0" encoding="UTF-8" ?>
  3. <!DOCTYPE struts PUBLIC
  4.         "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
  5.         "http://struts.apache.org/dtds/struts-2.0.dtd">
  7. <struts>
  8.     <package name="xxx" extends="struts-default">
  10.         <interceptors>
  11.             <!--配置自定义的拦截器-->
  12.             <interceptor name="Interceptor1" class="zhongfucheng.Interceptor"/>
  14.             <!--配置拦截器栈，把默认的拦截器栈都加载自定义的拦截器栈中-->
  15.             <interceptor-stack name="myStack">
  16.                 <interceptor-ref name="Interceptor1"/>
  17.                 <interceptor-ref name="defaultStack"/>
  18.             </interceptor-stack>
  20.         </interceptors>
  23.         <!--让Struts执行拦截器-->
  25.         <!--【执行拦截器:第一种写法： 当前包下所有的acntion都执行myStack栈】-->
  26.         <default-interceptor-ref name="myStack"></default-interceptor-ref>
  29.         <!--第二种写法： 只是在这一个Action中执行myStack栈
  30.         <interceptor-ref name="defaultStackt"></interceptor-ref>
  31.         <interceptor-ref name="loginCheck"></interceptor-ref>
  32.         -->
  34.         <!-- 第三种写法：执行用户栈(与第二种写法一样， 只在当前aciton中执行自定义栈) -->
  35.         <!-- <interceptor-ref name="myStack"></interceptor-ref>-->
  37.         <action name="user_*" class="zhongfucheng.action.UserAction" method="{1}">
  39.             <!--如果登陆成功，重定向到Action中，执行list业务方法-->
  40.             <result name="login" type="redirectAction">user_list</result>
  42.             <!--如果是list，那么跳转到list.jsp页面-->
  43.             <result name="list">/WEB-INF/list.jsp</result>
  46.             <!--如果是直接访问Action或者没有用户登陆，返回login页面-->
  47.             <result name="input">/login.jsp</result>
  49.         </action>
  52.     </package>
  53. </struts>

只有当用户登陆了才能查看用户具体信息，直接访问Action会跳转回

这里写图片描述

Struts2自带了计时拦截器，也就是用来统计每个Action执行的时间

如果页面执行得太慢了，Struts2还提供了执行等待拦截器，也就是说，当页面加载得太久了，就跳转到对应的提示页面…当服务器执行完毕了，也跳转到相对应的页面

当我们学习Session的时候已经通过Session来编写了一个防止表单重复提交的小程序了，我们来回顾一下我们当时是怎么做的：

  • 在Servlet上生成独一无二的token，保存在Session域中，并交给JSP页面
  • JSP页面在提交表单数据的时候，把token放在隐藏域中…一起带过去给Servlet
  • Servlet判断用户有没有带token值过来，判断token的值是否和Session的相匹配
  • 如果用户是第一次提交的话，那么就允许用户的请求，接着就把保存在Session中的token值去除
  • 等用户想要再次提交的时候，Servlet发现Session中并没有token了，所以不搭理用户的请求

我们以前写表达重复提交就花了这么几个步骤…如果有兴趣的同学可以看一下以前的实现思路：http://blog.csdn.net/hon_3y/article/details/54799494#t11

Struts2是简化我们的开发的，表单重复提交也是一件非常常用的功能…Struts2也为我们实现了…当然啦，也是通过拦截器来实现

  1.    <interceptor name="token" class="org.apache.struts2.interceptor.TokenInterceptor"/>

它的实现原理和我们以前写的思路几乎一致…它不需要另外写一个组件来生成token值，struts2标签就有这么一个功能…因此是十分方便的

这里写图片描述

为了熟悉一下Struts2，我们也使用Struts2来编写一下上图的程序…

  2. package zhongfucheng.dao;
  4. import org.apache.commons.dbutils.QueryRunner;
  5. import org.apache.commons.dbutils.handlers.BeanHandler;
  6. import org.apache.commons.dbutils.handlers.BeanListHandler;
  7. import zhongfucheng.entity.User;
  8. import zhongfucheng.utils.Utils2DB;
  10. import java.sql.SQLException;
  11. import java.util.List;
  13. /**
  14.  * Created by ozc on 2017/5/3.
  15.  */
  16. public class UserDao {
  18.     public void add(User user) {
  19.         try {
  21.             String sql = "INSERT INTO user(id,username,cellphone,password,address) VALUES (?,?,?,?,?)";
  22.             QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());
  24.             queryRunner.update(sql, new Object[]{user.getId(), user.getUsername(), user.getCellphone(), user.getPassword(),user.getAddress()});
  26.         } catch (SQLException e) {
  27.             new RuntimeException("登陆失败了！");
  28.         }
  29.     }
  31.     public User findUser(String id) {
  32.         try {
  33.             String sql = "SELECT * FROM user WHERE id=?";
  34.             QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());
  36.             return (User) queryRunner.query(sql, new BeanHandler(User.class), new Object[]{id});
  37.             
  38.         } catch (SQLException e) {
  39.             new RuntimeException("登陆失败了！");
  40.         }
  41.         return null;
  42.     }
  44.     public List<User> getAll() {
  46.         try {
  47.             String sql = "SELECT * FROM user";
  48.             QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());
  49.             return (List<User>) queryRunner.query(sql, new BeanListHandler(User.class));
  50.         } catch (SQLException e) {
  51.             new RuntimeException("登陆失败了！");
  52.         }
  53.         return null;
  54.     }
  55.     public void  updateUser(User user) {
  57.         try {
  58.             String sql = "UPDATE user SET username=?,password=?,cellphone=? WHERE id=?";
  59.             QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());
  61.             queryRunner.update(sql, new Object[]{user.getUsername(), user.getPassword(), user.getCellphone(), user.getId()});
  62.         } catch (SQLException e) {
  63.             new RuntimeException("登陆失败了！");
  64.         }
  65.     }
  67. }
  2. package zhongfucheng.service;
  4. import zhongfucheng.dao.UserDao;
  5. import zhongfucheng.entity.User;
  6. import zhongfucheng.utils.WebUtils;
  8. import java.util.List;
  10. /**
  11.  * Created by ozc on 2017/5/3.
  12.  */
  13. public class Service {
  15.     UserDao userDao = new UserDao();
  17.     public void add(User user) {
  20.         //手动设置id，因为在数据库表我没使用自动增长id
  21.         user.setId(WebUtils.makeId());
  23.         //这是以前的表，规定要address，只能手动设置了
  24.         user.setAddress("广州");
  25.         userDao.add(user);
  27.     }
  29.     public User findUser(String id) {
  31.         return userDao.findUser(id);
  33.     }
  35.     public List<User> getAll() {
  37.         return userDao.getAll();
  39.     }
  40.     public void  updateUser(User user) {
  43.         userDao.updateUser(user);
  45.     }
  46. }
  • 编写添加用户JSP
  2. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  3. <%@taglib prefix="s" uri="/struts-tags" %>
  4. <html>
  5. <head>
  6. </head>
  7. <body>
  9. <form action="${pageContext.request.contextPath}/user_register" method="post">
  10.     <table border="1">
  12.         <tr>
  13.             <td>用户名：<input type="text" name="username"></td>
  14.         </tr>
  15.         <tr>
  16.             <td> 密码：<input type="password" name="password"></td>
  17.         </tr>
  18.         <tr>
  19.             <td>电话：<input type="text" name="cellphone"></td>
  20.         </tr>
  21.         <tr>
  22.             <td><input type="submit" value="提交"></td>
  23.         </tr>
  24.     </table>
  25. </form>
  28. </body>
  29. </html>
  • 使用了模型驱动封装数据，添加用户
  3.     //这里一定要实例化
  4.     User user = new User();
  6.     public User getUser() {
  7.         return user;
  8.     }
  10.     public void setUser(User user) {
  11.         this.user = user;
  12.     }
  14.     @Override
  15.     public User getModel() {
  16.         return user;
  17.     }
  20.     /*******调用service********/
  21.     Service service = new Service();
  23.     public String register() throws Exception {
  25.         service.add(user);
  28.         //注册成功，就跳转到list()方法，list方法就跳转到查看所有用户页面了!
  29.         return list();
  30.     }
  • 列出全部的用户数据，提供修改功能，需要把id传递过去，明确修改的是哪一个用户 
  2. <%--
  3.   Created by IntelliJ IDEA.
  4.   User: ozc
  5.   Date: 2017/5/2
  6.   Time: 18:24
  7.   To change this template use File | Settings | File Templates.
  8. --%>
  9. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  10. <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
  11. <%@taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
  12. <%@ taglib prefix="s" uri="/struts-tags" %>
  13. <html>
  14. <head>
  15.     <title>列出下载页面</title>
  16. </head>
  17. <body>
  18. <table border="1" align="center">
  19.     <tr>
  20.         <td>用户id</td>
  21.         <td>用户姓名</td>
  22.         <td>用户密码</td>
  23.         <td>用户电话</td>
  24.         <td>操作</td>
  25.     </tr>
  27.     <s:if test="#request.users!=null">
  28.         <c:forEach items="${users}" var="user">
  29.             <tr>
  30.                 <td>${user.id}</td>
  31.                 <td>${user.username}</td>
  32.                 <td>${user.password}</td>
  33.                 <td>${user.cellphone}</td>
  34.                 <td><a href="${pageContext.request.contextPath}/user_updatePage?id=${user.id}">修改</a></td>
  35.             </tr>
  36.         </c:forEach>
  37.     </s:if>
  38. </table>
  41. </body>
  42. </html>
  • Action得到web带过来的id，找到对象，添加到值栈中（数据回显）
  2.     public String updatePage() throws Exception {
  4.         //得到用户带过来的id，根据id查找对象
  5.        User user222 = service.findUser(user.getId());
  7.         ActionContext.getContext().getValueStack().push(user222);
  9.         return "updatePage";
  10.     }
  • 修改用户的JSP页面，使用Struts2提供的回显技术，并把id通过隐藏域带过去给Action..最终是通过id来修改用户的数据 
  2. <form action="${pageContext.request.contextPath}/user_update">
  3.     <table border="1">
  5.         <tr>
  6.             <td>用户名<s:textfield name="username"/></td>
  7.         </tr>
  8.         <tr>
  9.             <td>密码 <s:textfield name="password" /></td>
  10.         </tr>
  11.         <tr>
  12.             <td>电话<s:textfield name="cellphone"/></td>
  13.         </tr>
  14.         <s:hidden name="id"/>
  16.         <tr>
  17.             <td><input type="submit" value="修改"></td>
  18.         </tr>
  19.     </table>
  20. </form>

这里写图片描述

上面我们已经完成了大部分的功能了，但当我们如果提交之后，再刷新页面，那么表单的数据就会重复提交…我们使用Struts2我们提供的防止表单重复提交的功能把！

这里写图片描述

  2. <table border="1">
  3.         <s:token></s:token>
  4.         <tr>
  5.             <td>用户名：<input type="text" name="username"></td>
  6.         </tr>
  7.         <tr>
  8.             <td> 密码：<input type="password" name="password"></td>
  9.         </tr>
  10.         <tr>
  11.             <td>电话：<input type="text" name="cellphone"></td>
  12.         </tr>
  13.         <tr>
  14.             <td><input type="submit" value="提交"></td>
  15.         </tr>
  16.     </table>

token拦截器默认是不会启动的，也就是说：需要我们手动配置…

当我们配置拦截器的时候，Struts2默认的拦截器是不会执行的，所以要把Struts2默认的拦截器也写上

  2. <?xml version="1.0" encoding="UTF-8" ?>
  3. <!DOCTYPE struts PUBLIC
  4.         "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
  5.         "http://struts.apache.org/dtds/struts-2.0.dtd">
  7. <struts>
  8.     <constant name="struts.ui.theme" value="simple"/>
  9.     <package name="xxx" extends="struts-default">
  13.         <action name="user_*" class="zhongfucheng.action.UserAction" method="{1}">
  15.             <interceptor-ref name="defaultStack"/>
  17.             <interceptor-ref name="token">
  18.                 <!-- 要拦截的方法！ -->
  19.                 <param name="includeMethods">register</param>
  20.             </interceptor-ref>
  22.             <!--如果是list，那么就跳转到list的JSP页面-->
  23.             <result name="list"> /list.jsp</result>
  25.             <!--请求跳转到修改页面-->
  26.             <result name="updatePage">/update.jsp</result>
  28.             <!--如果校验成功，跳转到login.jsp页面回显-->
  29.             <result name="success">/login.jsp</result>
  31.             <result name="redirectList" type="redirect">/user_list</result>
  32.         </action>
  33.     </package>
  35.     <include file="config.xml"/>
  37. </struts>
  • 当我们重复提交的时候，它会报错，因此，如果它报错了，我们就跳转到register页面把

这里写图片描述

这里写图片描述

如果文章有错的地方欢迎指正，大家互相交流。习惯在微信看技术文章，想要获取更多的Java资源的同学，可以关注微信公众号:Java3y

版权声明：本文为Java3y原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/Java3y/p/8544460.html