java中过滤器和拦截器的区别

区别

1.使用范围和规范不同

• filter是servlet规范规定的,只能用在web程序中.
• 拦截器即可以用在web程序中, 也可以用于application, swing程序中, 是spring容器内的, 是spring框架支持的

2.触发时机不同

顺序: filter-->servlet-->interceptor-->controller

• 过滤器是在请求进入容器后，但请求进入servlet之前进行预处理的。请求结束返回也是，是在servlet处理完后，返回给前端之前过滤器处理。
• 拦截器是方法到达controller层之前生效的

3.过滤器的实现基于回调函数。而拦截器（代理模式）的实现基于反射，代理分静态代理和动态代理，动态代理是拦截器的简单实现。

何时使用拦截器？何时使用过滤器？

• 如果是非spring项目，那么拦截器不能用，只能使用过滤器。
• 如果是处理controller前后，既可以使用拦截器也可以使用过滤器。
• 如果是处理dispaterservlet前后，只能使用过滤器。

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

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

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

7.拦截器可以获取ioc容器中的各个bean，而过滤器就不行，在拦截器里注入一个service，可以调用业务逻辑。

springboot使用过滤器

两种方式：
1、使用spring boot提供的filterregistrationbean注册filter
2、使用原生servlet注解定义filter
两种方式的本质都是一样的，都是去filterregistrationbean注册自定义filter

封装filter

package com.theeternity.common.basefilter;

import javax.servlet.filter;

/**
 * @program: apiboot
 * @description: 封装filter
 * @author: theeternity zhang
 * @create: 2019-02-17 13:08
 */
public interface mappingfilter extends filter {
    string[] addurlpatterns();

    int order();
}

自定义filter

package com.theeternity.beans.filterconfig;

import com.theeternity.common.basefilter.mappingfilter;
import lombok.extern.slf4j.slf4j;
import org.slf4j.logger;
import org.slf4j.loggerfactory;

import javax.servlet.*;
import javax.servlet.filterconfig;
import java.io.ioexception;

/**
 * @program: apiboot
 * @description: 权限过滤器
 * @author: theeternity zhang
 * @create: 2019-02-17 13:14
 */
public class authfilter implements mappingfilter {

    @override
    public string[] addurlpatterns() {
        return new string[]{"/*"};
    }

    @override
    public int order() {
        return 0;
    }

    @override
    public void init(filterconfig filterconfig) throws servletexception {

    }

    @override
    public void dofilter(servletrequest servletrequest, servletresponse servletresponse, filterchain filterchain) throws ioexception, servletexception {
        filterchain.dofilter(servletrequest,servletresponse);
    }

    @override
    public void destroy() {

    }

}

注册过滤器

package com.theeternity.beans.filterconfig;

import org.springframework.boot.web.servlet.filterregistrationbean;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
/**
 * @program: apiboot
 * @description: 注册过滤器
 * @author: theeternity zhang
 * @create: 2019-02-17 13:10
 */
@configuration
public class filterconfig {

    @bean
    public filterregistrationbean registfilter() {
        filterregistrationbean registration = new filterregistrationbean();
        authfilter authfilter=new authfilter();
        registration.setfilter(authfilter);
        registration.addurlpatterns(authfilter.addurlpatterns());
        registration.setorder(authfilter.order());
        registration.setname("authfilter");
        return registration;
    }
}

springboot使用拦截器

封装interceptor

package com.theeternity.common.baseinterceptor;

import org.springframework.web.servlet.handlerinterceptor;

/**
 * @program: apiboot
 * @description: 封装interceptor
 * @author: theeternity zhang
 * @create: 2019-02-15 17:49
 */
public interface mappinginterceptor extends handlerinterceptor {
    string[] addpathpatterns();

    string[] excludepathpatterns();

    int order();
}

自定义interceptor

package com.theeternity.beans.interceptorconfig;

import com.theeternity.common.baseinterceptor.mappinginterceptor;
import org.springframework.stereotype.component;
import org.springframework.web.servlet.modelandview;

import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletresponse;

/**
 * @program: boxapi
 * @description: 跨域拦截器
 * @author: tonyzhang
 * @create: 2018-12-21 14:44
 */
@component
public class crossorigininterceptor implements mappinginterceptor {

    @override
    public string[] addpathpatterns() {
        return new string[]{"/**"};
    }

    @override
    public string[] excludepathpatterns() {
        return new string[0];
    }

    @override
    public int order() {
        return 0;
    }

    @override
    public boolean prehandle(httpservletrequest request, httpservletresponse response, object handler) throws exception {
        logger.info("允许的头信息"+request.getheader("origin"));
        response.setheader("access-control-allow-origin", "*");
        response.setheader("access-control-allow-methods", "*");
        response.setheader("access-control-max-age", "3600");
        response.setheader("access-control-allow-headers", "origin, x-requested-with, content-type, accept");
        //是否允许浏览器携带用户身份信息（cookie）
        response.setheader("access-control-allow-credentials","true");
        return true;
    }

    @override
    public void posthandle(httpservletrequest request, httpservletresponse response, object handler, modelandview modelandview) throws exception {

    }

    @override
    public void aftercompletion(httpservletrequest request, httpservletresponse response, object handler,exception ex) throws exception {

    }
}

注册interceptor

package com.theeternity.beans.interceptorconfig;

import org.springframework.beans.factory.annotation.autowired;
import org.springframework.context.annotation.configuration;
import org.springframework.web.servlet.config.annotation.interceptorregistry;
import org.springframework.web.servlet.config.annotation.webmvcconfigurer;

/**
 * @program: apiboot
 * @description: 拦截器注册
 * @author: theeternity zhang
 * @create: 2019-02-15 17:55
 */
@configuration
public class interceptorconfig implements webmvcconfigurer {

    @autowired
    private crossorigininterceptor crossorigininterceptor;

    @override
    public void addinterceptors(interceptorregistry registry) {
registry.addinterceptor(crossorigininterceptor).addpathpatterns(crossorigininterceptor.addpathpatterns());

    }
}

站在巨人的肩膀上摘苹果: