Filter、Interceptor、Aspect 区别及实现

Fliter 过滤器

请求在到达Controller之前进行与返回去之后 调用 入参为 reuqest,response,chian,过滤器获取不了具体调用哪一个类,哪一个方法。

实现:

1、继承 Filter 接口

import java.io.IOException;
import java.util.Date;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

import org.springframework.stereotype.Component;

//@Component
public class TimeFilter implements Filter{

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("TimeFilter init");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        System.out.println("TimeFilter in");
        long startTime = new Date().getTime();
        chain.doFilter(request, response);
        System.out.println("TimeFilter out 耗时:" + (new Date().getTime() - startTime));
    }

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

2、声明:两种方式,一是在类前加入@Component ,不能指定拦截的路径;二是  对于SSM 在web.xml中进行声明,对于 SpringBoot 在webConfig中声明

web.xml

<filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

SpringBoot:

package com.maple.web.config;

import java.util.ArrayList;
import java.util.List;import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;import com.maple.web.filter.TimeFilter;
import com.maple.web.interceptor.TimeInterceptor;

@Configuration
public class WebConfig{
    @Bean
    public FilterRegistrationBean timeFilter() {
        FilterRegistrationBean registrationBean = new FilterRegistrationBean();
        TimeFilter timeFilter = new TimeFilter();
        registrationBean.setFilter(timeFilter);
        List<String> url = new ArrayList<>();
        url.add("/*");
        registrationBean.setUrlPatterns(url);
        return registrationBean;
    }
}

Interceptor 拦截器

请求在到达Controller之前进行与返回去之后 调用 入参为 reuqest,response,handler,在过滤器之后调用,能够知道调用哪一个类,但是获取不了参数

1、继承HandlerInterceptor ,perHandler 在进入Controller前执行,若返回false则不进入Controller ,true进入Controller ,postHandler处理完Controller后进入此方法,若发生异常,则不进入postHandler。afterCompletion 都会进入此方法,无论是否发生异常都会进入。

package com.maple.web.interceptor;

import java.util.Date;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

/**
 * @author hzc
 *
 */
@Component
public class TimeInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        System.out.println("preHandle");

        System.out.println(((HandlerMethod)handler).getBean().getClass().getName());
        System.out.println(((HandlerMethod)handler).getMethod().getName());

        request.setAttribute("startTime", new Date().getTime());
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle");
        long startTime = (long) request.getAttribute("startTime");
        System.out.println("time interceptor 耗时: " + (new Date().getTime() - startTime));

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        System.out.println("afterCompletion");
        long startTime = (long) request.getAttribute("startTime");
        System.out.println("time interceptor 耗时: " + (new Date().getTime() - startTime));
        System.out.println("ex is " + ex);
    }

}

2、声明,在SSM中需要在spring配置文件中声明,在Springboot中在Config中声明。

SSM:

<mvc:interceptors>
      <!--   对公众用户进行拦截 -->
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
          <!--   拦截所有路径   -->
            <bean id="userinterceptor" class="org.sz.source.schedul.common.BaseOrgUserInterceptor">
                <property name="excludedUrls"><!-- 以下路径不拦截 -->
                   <list>
                       <value>/login.do</value>
                   </list>
                </property>
            </bean>
        </mvc:interceptor>
</mvc:interceptors>

SpringBoot:

package com.maple.web.config;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
public class WebConfig extends WebMvcConfigurerAdapter{

    @Autowired
    private TimeInterceptor timeInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(timeInterceptor);
    }
}

Aspect 切面

使用切面,可前置增强,后置增强,环绕增强,在拦截器之后执行,可获取参数信息

1、编写切面方法类

import java.util.Date;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

/**
 * @author hzc
 *
 */
@Aspect
@Component
public class TimeAspect {

    @Around("execution(* com.maple.web.controller.UserController.*(..))")
    public Object handlerControllerMethod(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("time aspect start");
        Object[] args = pjp.getArgs(); // 获取参数
        for (Object arg : args) {
            System.out.println("arg is " + arg);
        }
        long startTime = new Date().getTime();
        Object object = pjp.proceed();
        System.out.println("time aspect 耗时: " + (new Date().getTime() - startTime));
        return object;
    }
}

Filter、Interceptor、Aspect的作用范围如下:

原文地址:https://www.cnblogs.com/maple92/p/10781154.html

时间: 2024-10-13 00:35:58

Filter、Interceptor、Aspect 区别及实现的相关文章

过滤器和拦截器filter和Interceptor的区别

1.创建一个Filter过滤器只需两个步骤 创建Filter处理类 web.xml文件中配置Filter 2.Servlet中的过滤器Filter是实现了javax.servlet.Filter接口的服务器端程序,主要的用途是过滤字符编码.做一些业务逻辑判断等.其工作原理是,只要你在web.xml文件配置好要拦截的客户端请求,它都会帮你拦截到请求,此时你就可以对请求或响应(Request.Response)统一设置编码,简化操作:同时还可进行逻辑判断,如用户是否已经登陆.有没有权限访问该页面等等

Filter ,Interceptor,AOP

一.Filter: Filter也称之为过滤器,它是Servlet技术中比较激动人心的技术,WEB开发人员通过Filter技术,对web服务器管理的所有web资源:例如Jsp, Servlet, 静态图片文件或静态 html 文件等进行拦截,从而实现一些特殊的功能.例如实现URL级别的权限访问控制.过滤敏感词汇.压缩响应信息等一些高级功能. 1.Filter简介: Servlet API中提供了一个Filter接口,开发web应用时,如果编写的Java类实现了这个接口,则把这个java类称之为过

ASP.NET Core 中间件 中间件(Middleware)和过滤器(Filter)的区别

https://www.cnblogs.com/savorboard/p/5586229.html 前言 在上篇文章主要介绍了DotNetCore项目状况,本篇文章是我们在开发自己的项目中实际使用的,比较贴合实际应用,算是对中间件的一个深入使用了,不是简单的Hello World,如果你觉得本篇文章对你有用的话,不妨点个[推荐]. 目录 中间件(Middleware)的作用 中间件的运行方式 中间件(Middleware)和过滤器(Filter)的区别 什么情况我们需要中间件 怎么样自定义自己的

Servlet Filter与Spring interceptor 功能区别

Servlet Filter与Spring interceptor 而且在功能上差不多,都可以针对URL规则来进去处理 多个Servlet Filter的执行顺序 顺序就是filter Mapping的配置的先后顺序,filter的执行顺序就考filter mapping在web.xml中的顺序. 多个spring interceptor的执行顺序 spring interceptor也是这样的执行顺序,不过interceptor多一个配置参数order通过他也可以来实现interceptor的

SpringMVC的拦截器(Interceptor)和过滤器(Filter)的区别与联系

一 简介 (1)过滤器: 依赖于servlet容器.在实现上基于函数回调,可以对几乎所有请求进行过滤,但是缺点是一个过滤器实例只能在容器初始化时调用一次.使用过滤器的目的是用来做一些过滤操作,获取我们想要获取的数据,比如:在过滤器中修改字符编码:在过滤器中修改HttpServletRequest的一些参数,包括:过滤低俗文字.危险字符等 关于过滤器的一些用法可以参考我写过的这些文章: 继承HttpServletRequestWrapper以实现在Filter中修改HttpServletReque

基于SpringMVC的拦截器(Interceptor)和过滤器(Filter)的区别与联系

一 简介 (1)过滤器: 依赖于servlet容器.在实现上基于函数回调,可以对几乎所有请求进行过滤,但是缺点是一个过滤器实例只能在容器初始化时调用一次.使用过滤器的目的是用来做一些过滤操作,获取我们想要获取的数据,比如:在过滤器中修改字符编码:在过滤器中修改HttpServletRequest的一些参数,包括:过滤低俗文字.危险字符等 关于过滤器的一些用法可以参考我写过的这些文章: 继承HttpServletRequestWrapper以实现在Filter中修改HttpServletReque

过滤器(Filter)与拦截器(Interceptor)的区别

1 .拦截器是基于java的反射机制的,而过滤器是基于函数回调. 2 .拦截器不依赖与servlet容器,过滤器依赖与servlet容器. 3 .拦截器只能对action请求起作用,而过滤器则可以对几乎所有的请求起作用. 4 .拦截器可以访问action上下文.值栈里的对象,而过滤器不能访问. 5 .在action的生命周期中,拦截器可以多次被调用,而过滤器只能在容器初始化时被调用一次. 6.拦截器可以获取IOC容器中的各个bean,而过滤器就不行,这点很重要,在拦截器里注入一个service,

django中的objects.get和objects.filter方法的区别

为了说明它们两者的区别定义2个models class Student(models.Model): name = models.CharField('姓名', max_length=20, default='') age = models.CharField('年龄', max_length=20, default='') class Book(models.Model): student = models.ForeignKey(Student) 一.先说下django的obj.get():

拦截器、过滤器、@Aspect 区别

1.需求场景 之前也有在文章写道 “拦截器\过滤器" 的区别,文章链接,在实际开发过程中,我们可能会遇到拦截请求参数的需求,在这我举个场景. 某一个接口的请求参数都是加密的,而请求参中还有一些跟业务无关的数据,需要剔除. 2.问题产生 那么怎么能够实现只要和业务有关的数据呢? 首先,我们想到的是通过拦截器,对加密的数据进行解密,然后把解密后的数据重新放到 request 中,request.setAttribute("数据名", 数据); 其实呢,还可以通过 @Aspect