深入Struts学习系列（一）

最新推荐文章于 2017-02-09 11:57:03 发布

chengyunyi123

最新推荐文章于 2017-02-09 11:57:03 发布

阅读量324

点赞数

分类专栏： JavaWeb 文章标签： Struts2 JavaWeb

本文链接：https://blog.csdn.net/chengyunyi123/article/details/54341253

版权

JavaWeb 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

1. 拦截器

**

1.1 概述

基本概念
Intercetor, 即为拦截器。
1）在Struts2中，把每一个功能都用一个个的拦截器实现；用户想用struts的哪个功能的时候，可以自由组装使用。
2）Struts2中，为了方法用户对拦截器的引用，提供了拦截器栈的定义，里面可以包含多个拦截器。文件夹(文件, 文件2) 拦截器栈(拦截器,拦截器2)
3）Struts2中，如果用户没有指定执行哪些拦截器，struts2有一个默认执行的栈，defaultStack;

一旦如果用户有指定执行哪些拦截器，默认的拦截器栈就不会被执行。

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

拦截器配置举例
struts-default.xml文件中，定义了struts提供的所有拦截器

//1. 定义拦截器以及拦截器栈
<interceptors>
    1.1 拦截器定义
    <interceptor name="" class="" /> 

    1.2 拦截器栈的定义
    <interceptor-stack name="defaultStack">
    引用了上面拦截器(1.1)
    </interceptor-stack>
</interceptors>

2. 默认执行的拦截器(栈)
<default-interceptor-ref name="defaultStack"/>

核心API

Interceptor 拦截器接口
AbstractInterceptor 拦截器默认实现的抽象类；一般用户只需要继承此类即可继续拦截器开发
ActionInvocation 拦截器的执行状态，调用下一个拦截器或Action

拦截器 VS 过滤器

过滤器，是在java web中，你传入的request,response提前过滤掉一些信息，或者提前设置一些参数，然后再传入servlet或者struts的 action进行业务逻辑，比如过滤掉非法url（不是login.do的地址请求，如果用户没有登陆都过滤掉）,或者在传入servlet或者 struts的action前统一设置字符集，或者去除掉一些非法字符

拦截器，是在面向切面编程的就是在你的service或者一个方法，前调用一个方法，或者在方法后调用一个方法比如动态代理就是拦截器的简单实现，在你调用方法前打印出字符串（或者做其它业务逻辑的操作），也可以在你调用方法后打印出字符串，甚至在你抛出异常的时候做业务逻辑的操作。

拦截器和过滤器的区别：

1、拦截器是基于Java的反射机制的，而过滤器是基于函数回调

2、过滤器依赖与servlet容器，而拦截器不依赖与servlet容器

3、拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用

4、拦截器可以访问action上下文、值栈里的对象，而过滤器不能

5、在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次

1.2 自定义一个拦截器案例

步骤：

1. 写拦截器类 (看生命周期)
2. 配置

// 自定义拦截器

public class HelloInterceptor implements Interceptor{

    // 启动时候执行
    public HelloInterceptor(){
        System.out.println("创建了拦截器对象");
    }

    // 启动时候执行
    @Override
    public void init() {
        System.out.println("执行了拦截器的初始化方法");
    }

    // 拦截器业务处理方法 （在访问action时候执行？ 在execute之前执行？）
    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        System.out.println("2. 拦截器，业务处理-开始");

        // 调用下一个拦截器或执行Action  (相当于chain.doFilter(..)
        // 获取的是： execute方法的返回值
        String resultFlag = invocation.invoke();

        System.out.println("4. 拦截器，业务处理-结束");

        return resultFlag;
    }

    @Override
    public void destroy() {
        System.out.println("销毁....");
    }

}

<?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="hello" extends="struts-default">

        <!-- 【拦截器配置】 -->
        <interceptors>

            <!-- 配置用户自定义的拦截器 -->
            <interceptor name="helloInterceptor" class="interceptor.HelloInterceptor"></interceptor>

            <!-- 自定义一个栈： 要引用默认栈、自定义的拦截器 -->
            <interceptor-stack name="helloStack">
                <!-- 引用默认栈 (一定要放到第一行)-->
                <interceptor-ref name="defaultStack"></interceptor-ref>
                <!-- 引用自定义拦截器 -->
                <interceptor-ref name="helloInterceptor"></interceptor-ref>
            </interceptor-stack>

        </interceptors>

        <!-- 【执行拦截器】 -->
        <default-interceptor-ref name="helloStack"></default-interceptor-ref>

        <!-- Action配置 -->
        <action name="hello" class="interceptor.HelloAction">
            <result name="success"></result>
        </action>

    </package>
</struts>

1.3 拦截器执行流程

UML时序图

启动：
创建所有拦截器、执行init()
访问:
先创建Action，
再执行拦截器，
最后：拦截器放行，执行execute();

1.4 拦截器案例

需求：
登陆后，显示列表

案例准备：
Struts jar文件
DbUtils组件
数据库连接池/ 驱动包

//login.jsp

<%--
  Created by IntelliJ IDEA.
  User: Cyy
  Date: 2017/1/9
  Time: 22:54
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>login</title>
</head>
<body>
<form method="post" action="${pageContext.request.contextPath }/user_login.action">
    用户名：<input type="text" name="admin.userName"><br/>
    密码：<input type="text" name="admin.pwd"><br/>
    <input type="submit" value="登陆"><br/>
</form>
</body>
</html>

//UserAction.java

public class UserAction extends ActionSupport {

    // ---------1. 封装请求数据-----------
    private Admin admin;
    public Admin getAdmin() {
        return admin;
    }
    public void setAdmin(Admin admin) {
        this.admin = admin;
    }
    // ---------2. 调用的Service-----------
    private AdminService adminService = new AdminService();

    // 登陆
    public String login() {
        try {
            Admin userInfo = adminService.login(admin);
            // 判断
            if (userInfo == null){
                // 登陆失败
                return "input";
            }
            // 登陆成功：数据保存在session中
            ActionContext.getContext().getSession().put("userInfo", userInfo);

            // 登陆成功
            return "loginSuccess";
        } catch (Exception e) {
            return ERROR;
        }
    }

    // 列表
    public String list() {
        try {
            // 查询全部
            List<Admin> list = adminService.getAll();
            // 保存到request
            ActionContext.getContext().getContextMap().put("listAdmin", list);
            return "list";
        } catch (Exception e) {
            return ERROR;
        }
    }
}

//list.jsp

<body>
    <h1>欢迎你，${userInfo.userName }</h1>
    <table align="center" border="1">
        <tr>
            <td>序号</td>
            <td>编号</td>
            <td>用户名</td>
            <td>密码</td>
        </tr>
        <%--@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" --%>
        <!-- 用struts标签迭代数据 -->
        <%@taglib uri="/struts-tags" prefix="s" %>
        <s:iterator var="admin" value="#request.listAdmin" status="st">
            <tr>
                <td>
                    <s:property value="#st.count"/>
                </td>
                <td>
                    <s:property value="#admin.id"/>
                </td>
                <td>
                    <s:property value="#admin.userName"/>
                </td>
                <td>
                    <s:property value="#admin.pwd"/>
                </td>
            </tr>
        </s:iterator>

    </table>
  </body>

//自定义拦截器

public class UserCheckInterceptor extends AbstractInterceptor{

    /**
     * 拦截器业务处理方法
     */
    public String intercept(ActionInvocation invocation) throws Exception {
        // 拿到当前执行的方法名：判断，只有当前方法名不是login,就进行验证

        // 获取ActionContext对象
        ActionContext ac = invocation.getInvocationContext();

        // 获取action的代理对象
         ActionProxy proxy = invocation.getProxy();
         // 获取当前执行的方法名
         String methodName = proxy.getMethod();
         // 判断
         if (!"login".equals(methodName)) {
             // 先获取当前登陆的用户
             Object obj = ac.getSession().get("userInfo");
             if (obj == null) {
                 // 没有登陆
                 return "input";
             } else {
                 // 当前用户有登陆
                 return invocation.invoke();
             }
         } else {
             // 说明当前用户正在登陆
             return invocation.invoke();
         }
    }

}

//配置拦截器

<?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="user" extends="struts-default">

        <!-- 【拦截器配置】 -->
        <interceptors>
            <interceptor name="loginCheck" class="interceptor.UserCheckInterceptor"></interceptor>
            <interceptor-stack name="myStack">
                <interceptor-ref name="defaultStack"></interceptor-ref>
                <interceptor-ref name="loginCheck"></interceptor-ref>
            </interceptor-stack>
        </interceptors>
        <!-- 【执行拦截器:第一种写法： 当前包下所有的acntion都执行myStack栈】
        <default-interceptor-ref name="myStack"></default-interceptor-ref>
         -->

        <!-- 全局配置 -->
        <global-results>
            <result name="error">/error.jsp</result>
        </global-results>

        <action name="user_*" class="action.UserAction" method="{1}">

            <!--第二种写法： 只是在这一个Action中执行myStack栈 
            <interceptor-ref name="defaultStackt"></interceptor-ref>
            <interceptor-ref name="loginCheck"></interceptor-ref>
            -->

            <!-- 第三种写法：执行用户栈(与第二种写法一样， 只在当前aciton中执行自定义栈) -->
            <interceptor-ref name="myStack"></interceptor-ref>



            <!-- 1. 登陆失败 -->
            <result name="input">/login.jsp</result>

            <!-- 2. 登陆成功 -->
            <result name="loginSuccess" type="redirectAction">user_list</result>

            <!-- 3. 列表展示 -->
            <result name="list">/WEB-INF/list.jsp</result>

        </action>

    </package>
</struts>

chengyunyi123

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
深入Struts学习系列（一）

**1. 拦截器**1.1 概述基本概念 Intercetor, 即为拦截器。 1）在Struts2中，把每一个功能都用一个个的拦截器实现；用户想用struts的哪个功能的时候，可以自由组装使用。 2）Struts2中，为了方法用户对拦截器的引用，提供了拦截器栈的定义，里面可以包含多个拦截器。文件夹(文件, 文件2) 拦截器栈(拦截器,拦截器2) 3）Stru
复制链接

扫一扫