Struts2Day02(属性和模型驱动获取数据 拦截器定义配置和使用 拦截未登录用户)

最新推荐文章于 2021-03-02 15:54:42 发布
最新推荐文章于 2021-03-02 15:54:42 发布
阅读量197 收藏
点赞数
分类专栏： struts2 
回顾
1、Struts2框架的概述，前端控制器的模式，核心的过滤器
2、入门 编写 struts.xml配置文件
3、配置文件
    配置文件的加载
4、Action类的编写和访问

在Struts2框架中使用Servlet的API
1、在Action类中也可以获取到Servlet一些常用的API
    提供JSP的表单页面的数据，在Action中使用Servlet的API接收到，然后保存到三个域对象中，最后显示到JSP的页面上
        提供JSP注册的页面
            <form action="${pageContext.request.contextPath }/demo1Action.action" method="post">
                姓名：<input type="text" name="username"/><br/>
                密码：<input type="password" name="password"/><br/>
                <input type="submit" value="注册"/>
            </form>
2、完全解耦合的方式
    Struts2框架提供了一个类，ActionContext类，提供了一些方法，通过方法获取Servlet的API
    常用的方法
        static.ActionContext.getContext()           获取ActionContext对象实例
        Map<String,Object>getParameters()           获取请求参数，相当于request.getParameterMap()
        Map<String,Object>getSession()              获取的代表session域的Map集合，相当于操作session域
        Map<String,Object>getApplication()          获取的代表application域的Map集合
        void put(String key,Object value)           向request域存入值

3、使用原生Servlet的API的方式
    Struts2框架提供了一个类，ServletActionContext 提供了一些静态的方法
        getPageContext()
        getRequest()
        getResponse()
        getServletContext()

页面的跳转
1、结果页面存在两种方式
    全局结果页面
        条件：如果<package>包中deec一些action都返回success，并且返回的页面都是同一个JSP页面，这样就可以配置全局的结果页面
        全局结果页面针对的当前的包中的所有的Action，但是如果局部还有结果页面，会优先局部的，使用的标签
            <global-results>
                <result name="success">/demo1/suc.jsp</result>
            </global-results>
    局部结果页面
        <result name="success">/demo1/suc.jsp</result>
2、结果页面的类型
    结果页面使用<result>标签进行配置，包含两个属性
        name    逻辑视图的名称
        type    跳转的类型，一些常用的类型，常见的结果类型在struts-default.xml查找[重定向请求的参数没了 2个请求了]
            dispatcher      转发，type的默认值.Action-->JSP
            redirect        重定向Action-->JSP
            chain           多个action之间跳转，从一个action转发到另一个Action。Action-->Action
            redirectAction  多个action之间跳转，从一个action重定向到另一个Action。Action-->Action
            stream          文件下载时使用

框架的数据封装
1、使用的原因
    作为MVC框架，必须要负责解析HTTP请求参数，并将其封装到Model对象中
    封装数据为开发提供了很多方便
    Struts2框架提供了很强大的数据封装的功能，不再需要使用Servlet的API完成手动封装了

2、Struts2提供了两类数据封装的方式
    第一种：属性驱动
        提供对应属性的set方法进行数据封装
            表单的哪些属性需要封装数据，那么在对应的Action类中提供该属性的set方法即可
            表单中的数据提交，最终找到Action类的setXxx的方法，最后赋值给全局变量

            Struts2框架采用的拦截器完成数据的封装
            方式不是很好，因为属性很多，提供特别多的set方法，而且还需要手动将数据存入到对象中
            这种情况下，Action类就相当于一个JavaBean，没有体现MVC的思想，Action类又封装数据，又接受请求处理，耦合性较高
        在页面上使用OGNL表达式进行数据封装
            页面中使用OGNL表达式进行数据的封装，就可以直接把属性封装到某一个JavaBean的对象中
            在页面中定义一个JavaBean，并且提供set方法：例如 private User user；
            页面中的编写发生了变化，需要使用OGNL的方式，表单中的写法<input type="text" name="user.username">

            只提供一个set方法还不够，必须还需要提供user属性的get和set方法
                先调用set方法，判断一下是否有user对象的实例对象，如果没有，调用set方法把拦截器创建的对象注入进来

    第二种方式：模型驱动
        使用模型驱动的方式，也可以把表单中的数据直接封装到一个JavaBean的对象中，并且表单的写法和之前的写法没有区别
        编写的页面不需要任何变化，正常编写name属性的值
        模型驱动的编写步骤
            手动实例化JavaBean:private User user = new User();
            实现ModelDriver<T>接口，实现getModel()方法，在getModel()方法中返回user

数据封装到集合中
1、封装复杂类型的参数（集合类型Collection、Map接口等）
2、页面中可能想批量添加一些数据，那么就可以使用集合。把数据封装到集合中
3、把数据封装到Collection中
    因为Collection接口都会有下标值，所以页面的下标会有一些区别  
        <input type="text" name="products[0].name"/>
    在Action中的写法 需要提供products的集合，并且提供get和set方法

4、把数据封装到Map中
    Map集合是键值对的形式，页面的写法
        <input type="text" name="map['1'].username"/>
    Action中提供map集合，并且提供get和set方法

Struts2的拦截器
1、概述
    拦截器就是AOP（Aspect-Oriented Programming）的一种实现，（AOP是指用于在某个方法或字段被访问之前，进行拦截然后在之前或之后加入某些操作）
    过滤器：过滤从客户端发送到服务器请求的

    拦截器：拦截对目标Action中的某些方法进行拦截
        拦截器不能拦截JSP
        拦截到Action中某些方法

2、拦截器和过滤器的区别
    拦截器是基于JAVA反射机制的，过滤器是基于函数回调的
    过滤器依赖于Servlet容器，而拦截器不依赖于Servlet容器
    拦截器只能对Action请求起作用（Action中的方法）而过滤器可以对几乎所有的请求起作用（CSS JSP JS）

    拦截器采用责任链模式
        在责任链模式里，很多镀锡由每一个对象对其下家的引用而连接起来形成一条链
        责任链每一个节点，都可以继续调用下一个节点，也可以阻止流程继续执行

    在Struts2中可以定义多个拦截器，将多个拦截器按照特点顺序 组成拦截器栈（顺序调用 栈中的每一个拦截器）
3、在Struts2的核心是拦截器，运行流程
web.xml->org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter->#doFilter->execute.executeAction->dispatcher.serviceAction->创建代理对象->proxy.execute()->invocation.invoke() 迭代调用拦截器

自定义拦截器和配置
1、编写拦截器，需要实现Interceptor接口 实现接口中的三个方法
    interceptor接口有很多的实现类，编写最简单的方式就是继承AbstractInterceptor实现类
    public String intercept(ActionInvocation invocation){
        User user = ServletActionContext.getRequest().getSession.getAttribute("existUser");
        if(user == null){

        } else{
            //放行
            return invocation.invoke();
        }
    }
2、需要在struts.xml中进行拦截器的配置，一共有两种方式
    第一种
        在<package>包中定义拦截器，出现在<package>包的上方
            <interceptors>
            //调用了拦截器
            <interceptor name="DemoInterceptor" class="my.interceptor.DemoInterceptor"></interceptor>
            </interceptors>

        在某个action中加入拦截器
            <interceptor-ref name="DemoInterceptor"/>
            如果引入了自己定义的拦截器，那么Struts2框架默认的拦截器就不会再执行了，所以需要引入Struts2默认的拦截器
                <interceptor-ref name="defaultStack"/>
    第二种
        在<package>包中定义拦截器的时候，自己直接定义一个拦截器栈
            <interceptors>
                <interceptor name="DemoInterceptor" class="my.interceptor.DemoInterceptor"></interceptor>
                <!-- 定义拦截器栈 -->
                <interceptor-stack name="myStack">
                    <interceptor-ref name="DemoInterceptor"></interceptor-ref>
                    <interceptor-ref name="defaultStack"/>
                </interceptor-stack>
            </interceptors>

        在Action包中引入自己定义的拦截器栈        
            <interceptor-ref name="myStack"></interceptor-ref>

使用拦截器判断用户是否已经登录

这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
struts.xml

<struts>
   <package name="demo1" namespace="/" extends="struts-default">
        <!-- 配置全局的结果页面 -->
        <!-- <global-results>
            <result name="success" type="redirect">/demo1/suc.jsp</result>
        </global-results> -->

        <!-- 完全解耦合的方式 -->
        <action name="demo1Action" class="my.demo1.Demo1Action">
            <result name="success" >/demo1/suc.jsp</result>
        </action>
        <!-- 原生的方式 -->
        <action name="demo2Action" class="my.demo1.Demo2Action">
            <!-- <result name="success">/demo1/suc.jsp</result> -->
        </action>

        <!-- 重定向到Action -->
        <action name="demo3Action_*" class="my.demo1.Demo3Action" method="{1}">
            <result name="success" type="redirectAction">demo3Action_update</result>
        </action>


   </package>

   <package name="demo2" namespace="/" extends="struts-default">
        <!-- 属性驱动的方式 -->
        <action name="regist1" class="my.demo2.Regist1Action"/>
        <!-- 属性驱动方式，把数据封装到JavaBean对象中 -->
        <action name="regist2" class="my.demo2.Regist2Action"/>
        <!-- 模型驱动的方式 -->
        <action name="regist3" class="my.demo2.Regist3Action"/>
        <!-- 把数据封装到List集合 -->
        <action name="regist4" class="my.demo2.Regist4Action"/>
        <!-- 把数据封装到Map集合 -->
        <action name="regist5" class="my.demo2.Regist5Action"/>

   </package>

  <package name="demo3" namespace="/" extends="struts-default">
        <!-- 定义了拦截器的第一种方式
        <interceptors>
            调用了拦截器
            <interceptor name="DemoInterceptor" class="my.interceptor.DemoInterceptor"></interceptor>
        </interceptors> -->
        <!-- 
            第二种方式，定义拦截器栈
         -->
        <interceptors>
            <interceptor name="DemoInterceptor" class="my.interceptor.DemoInterceptor"></interceptor>
            <!-- 定义拦截器栈 -->
            <interceptor-stack name="myStack">
                <interceptor-ref name="DemoInterceptor"></interceptor-ref>
                <interceptor-ref name="defaultStack"/>
            </interceptor-stack>
        </interceptors>
        <action name="userAction" class="my.demo3.UserAction">
            <!-- 只要是引用了自己的拦截器，默认栈的拦截器就不执行了。必须要手动引入默认栈 否则封装数据等功能都不能用了 -->
            <!-- <interceptor-ref name="DemoInterceptor"/>
            <interceptor-ref name="defaultStack"/> -->

            <!-- 引入拦截器栈 -->
            <interceptor-ref name="myStack"></interceptor-ref>
        </action>
  </package>
</struts>
/**
 * 完全解耦合的方式 使用Servlet的API
 * @author Administrator
 *
 */
public class Demo1Action extends ActionSupport {

    private static final long serialVersionUID = -894949390421537212L;
    public String execute() {
        //完全解耦合的方式
        ActionContext context =ActionContext.getContext();
        //获取到请求的参数,封装所有请求的参数
        Map<String,Object> map = context.getParameters();
        //遍历获取数据
        Set<String> keys = map.keySet();
        for (String string : keys) {
            //通过key来获取到值
            String[] vals = (String[]) map.get(string);
            System.out.println(string+":"+Arrays.toString(vals));
        }
        //如果向request对象中存入值
        context.put("msg", "东东");
        //获取其他map集合
        context.getSession().put("msg", "大哥");
        context.getApplication().put("msg", "小弟");

        return SUCCESS;
    }
}
/**
 * 原生的API
 * @author Administrator
 *
 */
public class Demo2Action extends ActionSupport{

    private static final long serialVersionUID = -8870547619062626755L;

    public String execute() {
        //获取到request对象
        HttpServletRequest request = ServletActionContext.getRequest();
        request.setAttribute("msg", "小弟");
        request.getSession().setAttribute("msg","小弟2");
        ServletActionContext.getServletContext().setAttribute("msg", "大哥");

        HttpServletResponse response = ServletActionContext.getResponse();
        //使用输出流，输出内容


        return SUCCESS;
    }
}

public class Demo3Action extends ActionSupport{

    private static final long serialVersionUID = 8482710457471965754L;
    public String save() {
        System.out.println("save。。");
        return SUCCESS;
    }

    //访问demo3Action_update
    public String update() {
        System.out.println("update。。。");
        return NONE;
    }
}
/**
 * 属性驱动
 * @author Administrator
 *
 */
public class Regist1Action extends ActionSupport {
    private static final long serialVersionUID = -2605442413925139136L;
    private String username;
    private String password;
    private Integer age;

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

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

    public void setAge(Integer age) {
        this.age = age;
    }
    //获取值set方法 往外传值get
    public String execute() throws Exception {
        System.out.println(username+":"+password+":"+age);
        return NONE;
    }

}
/**
 * 属性驱动方式，把数据封装到JavaBean的对象中
 * @author Administrator
 *
 */
public class Regist2Action extends ActionSupport {

    private static final long serialVersionUID = 1524512405660914227L;
    //注意二:属性驱动的方式
    private User user; 

    public User getUser() {
        System.out.println("getUser");
        return user;
    }
    //set 帮你new个 直接get/set都出来算了
    public void setUser(User user) {
        System.out.println("setUser");
        this.user = user;
    }

    public String execute() throws Exception {

        System.out.println(user.toString());
        return NONE;
    }
}
/**
 * 模型驱动的方式
 *  实现ModelDrivern接口
 *  必须手动实例化对象（需要自己new）
 * @author Administrator
 *
 */
public class Regist3Action extends ActionSupport implements ModelDriven<User> {

    private static final long serialVersionUID = 1524512405663214227L;
    //必须要手动实例化
    private User user = new User();


    //获取模型对象
    public User getModel() {
        return user;
    }

    public String execute() throws Exception {
        System.out.println(user);
        return NONE;
    }
}
/**
 * 属性驱动的方式，把数据封装到List集合中
 * @author Administrator
 *
 */
public class Regist4Action extends ActionSupport  {

    private static final long serialVersionUID = 1524512405663214227L;

    private List<User> list;


    public List<User> getList() {
        return list;
    }


    public void setList(List<User> list) {
        this.list = list;
    }


    public String execute() throws Exception {
        for (User user : list) {
            System.out.println(user);
        }
        return NONE;
    }
}
/**
 * 属性驱动的方式，把数据封装到Map集合中
 * @author Administrator
 *
 */
public class Regist5Action extends ActionSupport  {

    private static final long serialVersionUID = 1524512405663214227L;

    private Map<String,User> map;


    public Map<String, User> getMap() {
        return map;
    }


    public void setMap(Map<String, User> map) {
        this.map = map;
    }


    public String execute() throws Exception {
        System.out.println(map);
        return NONE;
    }
}

Demo1.jsp

<h1>Servlet API的第一种方式[完全解耦合的方式]</h1>
<form action="${pageContext.request.contextPath }/demo1Action.action" method="post">
姓名：<input type="text" name="username"/><br/>
密码：<input type="password" name="password"/><br/>
<input type="submit" value="注册"/>
</form>

suc.jsp

<h1>使用EL表达式获取值</h1>
${msg }
${requestScope.msg }
${sessionScope.msg }
${applicationScope.msg }

Demo2.jsp

<h1>属性驱动的方式</h1>
<form action="${pageContext.request.contextPath }/regist1.action" method="post">
姓名：<input type="text" name="username"/><br/>
<input type="submit" value="注册"/>
</form>
<!-- 注意一：页面的编写规则，发生了变化，使用OGNL表达式的写法一 -->
<h1>属性驱动的方式(把数据封装到JavaBean的对象中)</h1>
<form action="${pageContext.request.contextPath }/regist2.action" method="post">
姓名：<input type="text" name="user.username"/><br/>
<input type="submit" value="注册"/>
</form>

<h1>模型驱动方式</h1>
<form action="${pageContext.request.contextPath }/regist3.action" method="post">
姓名：<input type="text" name="username"/><br/>
<input type="submit" value="注册"/>
</form>

<h1>向List集合封装数据（默认情况下，采用的是属性驱动的方式）</h1>
<!-- 后台 List<User> list -->
<form action="${pageContext.request.contextPath }/regist4.action" method="post">
    姓名：<input type="text" name="list[0].username"/><br/>
    姓名：<input type="text" name="list[1].username"/><br/>
<input type="submit" value="注册"/>
</form>

<h1>向Map集合封装数据（默认情况下，采用的是属性驱动的方式）</h1>
<form action="${pageContext.request.contextPath }/regist5.action" method="post">
    姓名：<input type="text" name="map['1'].username"/><br/>
    姓名：<input type="text" name="map['two'].username"/><br/>
<input type="submit" value="注册"/>
</form>
    /**
     * intercept用来进行拦截
     */
    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        System.out.println("Action方法执行之前");
        //执行下一个拦截器 需要返回值
        String result = invocation.invoke();
        System.out.println("Action方法执行之后");
        return result;
    }

}
<struts>
    <package name="crm" namespace="/" extends="struts-default">

        <!-- 配置拦截器 -->
        <interceptors>
            <interceptor name="UserInterceptor" class="my.interceptor.UserInterceptor"></interceptor>
        </interceptors>

        <global-results>
            <result name="login">/login.htm</result>
        </global-results>

        <!-- 配置用户的模块 -->
        <action name="user_*" class="my.action.UserAction" method="{1}">
            <!-- <result name="login">/login.htm</result> -->
            <result name="success">/index.htm</result>
            <interceptor-ref name="UserInterceptor">
                <!-- login方法不拦截 -->
                <param name="excludeMethods">login</param>
            </interceptor-ref>
            <interceptor-ref name="defaultStack"></interceptor-ref>
        </action>
        <!-- 客户的模块 -->
        <action name="customer_*" class="my.action.CustomerAction" method="{1}">
            <interceptor-ref name="UserInterceptor"></interceptor-ref>
            <interceptor-ref name="defaultStack"></interceptor-ref>
        </action>

    </package>    

</struts>
/**
 * 自定义拦截器，判断当前是否已经登录，如果登录，继续执行。如果没有登录，跳转到登录页面
 * @author Administrator
 *
 */
public class UserInterceptor extends MethodFilterInterceptor{

    private static final long serialVersionUID = -5152960937504606199L;
    /**
     * 进行拦截的方法
     */
    protected String doIntercept(ActionInvocation invocation) throws Exception {
        //获取session对象
        User user = (User) ServletActionContext.getRequest().getSession().getAttribute("existUser");
        if(user == null) {
            //没登录
            return "login";
        } 
        return invocation.invoke();
    }

}
wenchi2018
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Struts2中属性驱动与模型驱动
52Pig的专栏
05-31 2466
属性驱动：
JAVA登录拦截器，查看用户是否登录过，未登录禁止访问页面
05-25
JAVA登录拦截器，查看用户是否登录过，未登录禁止访问页面
struts2拦截器 获得请求方法名+获得请求参数
hejianguang17的专栏
12-25 3734
SSI框架为基础开发的，hulian平台 struts2拦截器里如何知道你请求的是那个方法 使用:invocation.getInvocationContext().getName(); //输出Priv_queryPriv,这正是我访问的Action中的方法。   1.struts.xml中这么定义的 Xml代码   struts>         
Struts2属性驱动与模型驱动
热门推荐
博学而笃志，切问而近思
09-13 1万+
Struts2属性驱动与模型驱动 为什么要使用属性驱动和模型驱动 struts2与struts很大的不同点在于，struts的execute方法提供了HttpServletRequest和HttpServletResponse方法在获取客户端提交的数据信息的时候需要使用HttpServletRequest的getParameter()方法,并且还需要进行必要的数据类型转换。如何客户端提交的数据
java web项目中的拦截未登录用户的问题
qq_30014451的博客
12-10 5683
在项目运行的开始，是先加载在web.xml文件中注册的监听器listener（首先执行其contextInitialized（））方法，然后加载配置在web.xml文件中的拦截器filter（先执行其init（）方法，继而执行其doFilter（）方法）
JavaEE 拦截器用户登录案例源代码
10-06
在JavaEE开发中，拦截器...总之，`JavaEE 拦截器用户登录案例源代码`这个主题涉及到如何使用拦截器进行用户登录验证，通过学习这个案例，开发者可以更好地理解拦截器的原理和应用，提升Web应用的安全性和用户体验。
黑马程序员_struts2框架开发2016版讲义和笔记资料_day01_day02_day03_day04
05-19
Day02的内容可能会深入到Struts2的配置文件，如struts.xml，它用于定义Action、结果类型和拦截器链。同时，Action的编写和执行流程也会被讲解，包括Action类的注解配置，以及如何通过ActionSupport类处理请求和响应...
struts2day02
08-18
1. **Ognl（Object-Graph Navigation Language）**：Struts2使用Ognl作为默认的表达式语言，用于在Action和视图之间传递数据。Ognl允许你在JSP页面上直接访问Action的属性，也可以在Action中动态地操作对象。 四、...
拦截器下载
01-12
Struts2_day4.zip 文件可能包含了一天的学习材料或教程，专注于 Struts2 框架的拦截器（Interceptor）部分。Struts2 是一个基于 Model-View-Controller（MVC）架构的Java web框架，它极大地简化了开发过程，提高了...
Struts2Day2
03-28
Struts2的核心功能包括：动作调度、结果映射、拦截器机制、表单处理和国际化支持等。 在“Struts2Day2”这个主题中，我们可以从以下几个方面进行学习： 1. **ModelDriven模式**： `Struts2Day2_modelDriven`可能...
Struts2的模型驱动和属性驱动
想念的专栏
06-19 2519
Struts2环境搭建成功后，最起码的要求是能实现对数据的增删改查，然而这就涉及到了如何将前台数据传入到我们后台中，简单说如何将页面的数据传到处理程序中，以及如何把数据库中的数据显示在jsp中，想要实现这些功能，首先要了解Struts2的驱动方式。 属性驱动：使用属性来封装来回请求参数和处理结果，即在jsp页面的每一个form中的name都对应在action中有一个属性与之对应。 如果在jsp
java-web实现拦截未登录用户
TheB1stPR的博客
07-18 4134
java-web实现拦截未登录用户
Struts2的知识整理总结（二）—— Action 应用总结
愤怒的懒洋洋的博客
12-07 655
Action应用总结       之前我们已经总结了Struts2的基本配置和设置。下面我来说一下具体的实现流程。一、实现Action的三种方式Action类就是一个POJO类POJO类：        POJO（Plain Ordinary Java Object）简单的Java对象。简单来说，没有继承某个类，没有实现接口，就是POJO的类。Action类可以实现Action接口        ...
web项目中的监听器，过滤器以及自定义servlet的执行顺序
weixin_34372728的博客
02-09 332
　　可以看到web容器一启动就会实例化监听器的contextInitialized（ServletContextEvent event)方法，然后是过滤器的init()方法，最后在用户访问web应用的 时候会先执行过滤器的doFilter()方法，以及过滤器链,最后执行继承了HttpServlert的自定义Servlet里复写的doPost()方法或者doGet方法。       1 web容器...
JAVA SpringMVC-08：拦截器
淡若清风
02-23 287
拦截器+文件上传下载        SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理。开发者可以自己定义一些拦截器来实现特定的功能。 过滤器与拦截器的区别：拦截器是AOP思想的具体应用。 过滤器 servlet规范中的一部分，任何java web工程都可以使用 在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截 拦截器 拦截器是Spring
java用ssm未登录拦截_SSM框架简单的未登录拦截,所有跳转链接都进行了拦截,就是直接跳页面不拦截...
weixin_39670267的博客
03-02 349
/**登录拦截器@author Administrator**/public class LoginHandlerIntercepter implements HandlerInterceptor {//不拦截的页面private static final String[] IGNORE_URI={"user/myusers"}; //填写XX.do@Overridepublic void a...
java 避免未登录_java spring boot 拦截器 实现未登录用户不能登录
weixin_29061531的博客
02-16 373
package com.example.demo212;import org.springframework.web.servlet.HandlerInterceptor;import org.springframework.web.servlet.ModelAndView;import cn.hutool.json.JSONObject;import javax.servlet.http.Htt...
SpringMvc 拦截器 对未登录系统的操作进行拦截处理
dev_hui 的博客
11-08 4181
各类拦截器的传统写法案例： 1 在spring-mvc.xml 文件中添加 拦截器 如下： &lt;!-- 通用拦截器配置 --&gt; &lt;mvc:interceptors&gt;     ...     ...     &lt;mvc:interceptor&gt;         &lt;mvc:mapping path="/data/**"/&gt;         &lt;bean...
Struts2拦截器配置与使用详解
"配置和使用拦截器是Struts2框架中的重要功能，主要涉及对Action的增强和控制流程。拦截器是Struts2的核心组件，它允许开发者在Action执行前后插入自定义逻辑，如日志、权限检查、数据验证等。在Struts2中，拦截器的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值