FilterChain源码阅读

最新推荐文章于 2024-04-02 00:49:39 发布
最新推荐文章于 2024-04-02 00:49:39 发布
阅读量233 收藏
点赞数
分类专栏： spring 文章标签： servlet java 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huang_hai_an/article/details/128599330
版权

源码阅读

  • FilterChain 是一个接口，定义有doFilter方法。
void doFilter(ServletRequest var1, ServletResponse var2) throws IOException, ServletException;
  • ApplicationFilterChain implement FilterChain

ApplicationFilterChain 里的doFilter 方法主要调用了this.internalDoFilter(request, response)

public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {
        if (Globals.IS_SECURITY_ENABLED) {
            ServletRequest req = request;
            ServletResponse res = response;

            try {
                AccessController.doPrivileged(() -> {
                    this.internalDoFilter(req, res);
                    return null;
                });
            } catch (PrivilegedActionException var7) {
                Exception e = var7.getException();
                if (e instanceof ServletException) {
                    throw (ServletException)e;
                }

                if (e instanceof IOException) {
                    throw (IOException)e;
                }

                if (e instanceof RuntimeException) {
                    throw (RuntimeException)e;
                }

                throw new ServletException(e.getMessage(), e);
            }
        } else {
            this.internalDoFilter(request, response);
        }

    }

internalDoFilter方法里主要也是filter.doFilter(request, response, this);

private void internalDoFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {
       。。。。
                    filter.doFilter(request, response, this);
       。。。。
    }
  • abstract class GenericFilterBean implements Filter, BeanNameAware, EnvironmentAware, EnvironmentCapable, ServletContextAware, InitializingBean, DisposableBean 是一个通用过滤器抽象类。
  • abstract class OncePerRequestFilter extends GenericFilterBean 也是一个抽象类，每个请求过滤器一次。

主要doFilter

 public final void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        if (request instanceof HttpServletRequest && response instanceof HttpServletResponse) {
            HttpServletRequest httpRequest = (HttpServletRequest)request;
            HttpServletResponse httpResponse = (HttpServletResponse)response;
            String alreadyFilteredAttributeName = this.getAlreadyFilteredAttributeName();
            boolean hasAlreadyFilteredAttribute = request.getAttribute(alreadyFilteredAttributeName) != null;
            if (!this.skipDispatch(httpRequest) && !this.shouldNotFilter(httpRequest)) {
                if (hasAlreadyFilteredAttribute) {
                    if (DispatcherType.ERROR.equals(request.getDispatcherType())) {
                        this.doFilterNestedErrorDispatch(httpRequest, httpResponse, filterChain);
                        return;
                    }

                    filterChain.doFilter(request, response);
                } else {
                    request.setAttribute(alreadyFilteredAttributeName, Boolean.TRUE);

                    try {
                        this.doFilterInternal(httpRequest, httpResponse, filterChain);
                    } finally {
                        request.removeAttribute(alreadyFilteredAttributeName);
                    }
                }
            } else {
                filterChain.doFilter(request, response);
            }

        } else {
            throw new ServletException("OncePerRequestFilter just supports HTTP requests");
        }
    }
  • class CharacterEncodingFilter extends OncePerRequestFilter，字符编码过滤器。
  • class WebMvcMetricsFilter extends OncePerRequestFilter，Web Mvc 指标过滤器。
  • class FormContentFilter extends OncePerRequestFilter，表单内容过滤器。
  • class RequestContextFilter extends OncePerRequestFilter，请求上下文过滤器。
  • class DelegatingFilterProxy extends GenericFilterBean，委派过滤器代理。
public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        Filter delegateToUse = this.delegate;
        if (delegateToUse == null) {
            synchronized(this.delegateMonitor) {
                delegateToUse = this.delegate;
                if (delegateToUse == null) {
                    WebApplicationContext wac = this.findWebApplicationContext();
                    if (wac == null) {
                        throw new IllegalStateException("No WebApplicationContext found: no ContextLoaderListener or DispatcherServlet registered?");
                    }

                    delegateToUse = this.initDelegate(wac);
                }

                this.delegate = delegateToUse;
            }
        }

        this.invokeDelegate(delegateToUse, request, response, filterChain);
    }

 protected void invokeDelegate(Filter delegate, ServletRequest request, ServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        delegate.doFilter(request, response, filterChain);
    }
  • class FilterChainProxy extends GenericFilterBean，过滤链代理。
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        boolean clearContext = request.getAttribute(FILTER_APPLIED) == null;
        if (!clearContext) {
            this.doFilterInternal(request, response, chain);
        } else {
            try {
                request.setAttribute(FILTER_APPLIED, Boolean.TRUE);
                this.doFilterInternal(request, response, chain);
            } catch (Exception var11) {
                Throwable[] causeChain = this.throwableAnalyzer.determineCauseChain(var11);
                Throwable requestRejectedException = this.throwableAnalyzer.getFirstThrowableOfType(RequestRejectedException.class, causeChain);
                if (!(requestRejectedException instanceof RequestRejectedException)) {
                    throw var11;
                }

                this.requestRejectedHandler.handle((HttpServletRequest)request, (HttpServletResponse)response, (RequestRejectedException)requestRejectedException);
            } finally {
                SecurityContextHolder.clearContext();
                request.removeAttribute(FILTER_APPLIED);
            }

        }
    }

private void doFilterInternal(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        FirewalledRequest firewallRequest = this.firewall.getFirewalledRequest((HttpServletRequest)request);
        HttpServletResponse firewallResponse = this.firewall.getFirewalledResponse((HttpServletResponse)response);
        List<Filter> filters = this.getFilters((HttpServletRequest)firewallRequest);
        if (filters != null && filters.size() != 0) {
            if (logger.isDebugEnabled()) {
                logger.debug(LogMessage.of(() -> {
                    return "Securing " + requestLine(firewallRequest);
                }));
            }

            FilterChainProxy.VirtualFilterChain virtualFilterChain = new FilterChainProxy.VirtualFilterChain(firewallRequest, chain, filters);
            virtualFilterChain.doFilter(firewallRequest, firewallResponse);
        } else {
            if (logger.isTraceEnabled()) {
                logger.trace(LogMessage.of(() -> {
                    return "No security for " + requestLine(firewallRequest);
                }));
            }

            firewallRequest.reset();
            chain.doFilter(firewallRequest, firewallResponse);
        }
    }

final class VirtualFilterChain implements FilterChain（FilterChainProxy内）

private static final class VirtualFilterChain implements FilterChain {
        private final FilterChain originalChain;
        private final List<Filter> additionalFilters;
        private final FirewalledRequest firewalledRequest;
        private final int size;
        private int currentPosition;

        private VirtualFilterChain(FirewalledRequest firewalledRequest, FilterChain chain, List<Filter> additionalFilters) {
            this.currentPosition = 0;
            this.originalChain = chain;
            this.additionalFilters = additionalFilters;
            this.size = additionalFilters.size();
            this.firewalledRequest = firewalledRequest;
        }

        public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {
            if (this.currentPosition == this.size) {
                if (FilterChainProxy.logger.isDebugEnabled()) {
                    FilterChainProxy.logger.debug(LogMessage.of(() -> {
                        return "Secured " + FilterChainProxy.requestLine(this.firewalledRequest);
                    }));
                }

                this.firewalledRequest.reset();
                this.originalChain.doFilter(request, response);
            } else {
                ++this.currentPosition;
                Filter nextFilter = (Filter)this.additionalFilters.get(this.currentPosition - 1);
                if (FilterChainProxy.logger.isTraceEnabled()) {
                    FilterChainProxy.logger.trace(LogMessage.format("Invoking %s (%d/%d)", nextFilter.getClass().getSimpleName(), this.currentPosition, this.size));
                }

                nextFilter.doFilter(request, response, this);
            }
        }
    }
  • class WebAsyncManagerIntegrationFilter extends OncePerRequestFilter，Web 异步管理器集成过滤器。
public final class WebAsyncManagerIntegrationFilter extends OncePerRequestFilter {
    private static final Object CALLABLE_INTERCEPTOR_KEY = new Object();

    public WebAsyncManagerIntegrationFilter() {
    }

    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
        SecurityContextCallableProcessingInterceptor securityProcessingInterceptor = (SecurityContextCallableProcessingInterceptor)asyncManager.getCallableInterceptor(CALLABLE_INTERCEPTOR_KEY);
        if (securityProcessingInterceptor == null) {
            asyncManager.registerCallableInterceptor(CALLABLE_INTERCEPTOR_KEY, new SecurityContextCallableProcessingInterceptor());
        }

        filterChain.doFilter(request, response);
    }
}
  • class SecurityContextPersistenceFilter extends GenericFilterBean，安全上下文持久性过滤器。
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        this.doFilter((HttpServletRequest)request, (HttpServletResponse)response, chain);
    }

    private void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
        if (request.getAttribute("__spring_security_scpf_applied") != null) {
            chain.doFilter(request, response);
        } else {
            request.setAttribute("__spring_security_scpf_applied", Boolean.TRUE);
            if (this.forceEagerSessionCreation) {
                HttpSession session = request.getSession();
                if (this.logger.isDebugEnabled() && session.isNew()) {
                    this.logger.debug(LogMessage.format("Created session %s eagerly", session.getId()));
                }
            }

            HttpRequestResponseHolder holder = new HttpRequestResponseHolder(request, response);
            SecurityContext contextBeforeChainExecution = this.repo.loadContext(holder);
            boolean var10 = false;

            try {
                var10 = true;
                SecurityContextHolder.setContext(contextBeforeChainExecution);
                if (contextBeforeChainExecution.getAuthentication() == null) {
                    this.logger.debug("Set SecurityContextHolder to empty SecurityContext");
                } else if (this.logger.isDebugEnabled()) {
                    this.logger.debug(LogMessage.format("Set SecurityContextHolder to %s", contextBeforeChainExecution));
                }

                chain.doFilter(holder.getRequest(), holder.getResponse());
                var10 = false;
            } finally {
                if (var10) {
                    SecurityContext contextAfterChainExecution = SecurityContextHolder.getContext();
                    SecurityContextHolder.clearContext();
                    this.repo.saveContext(contextAfterChainExecution, holder.getRequest(), holder.getResponse());
                    request.removeAttribute("__spring_security_scpf_applied");
                    this.logger.debug("Cleared SecurityContextHolder to complete request");
                }
            }

            SecurityContext contextAfterChainExecution = SecurityContextHolder.getContext();
            SecurityContextHolder.clearContext();
            this.repo.saveContext(contextAfterChainExecution, holder.getRequest(), holder.getResponse());
            request.removeAttribute("__spring_security_scpf_applied");
            this.logger.debug("Cleared SecurityContextHolder to complete request");
        }
    }
  • class HeaderWriterFilter extends OncePerRequestFilter，标头编写器过滤器。
 protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        if (this.shouldWriteHeadersEagerly) {
            this.doHeadersBefore(request, response, filterChain);
        } else {
            this.doHeadersAfter(request, response, filterChain);
        }

    }
 private void doHeadersAfter(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws IOException, ServletException {
        HeaderWriterFilter.HeaderWriterResponse headerWriterResponse = new HeaderWriterFilter.HeaderWriterResponse(request, response);
        HeaderWriterFilter.HeaderWriterRequest headerWriterRequest = new HeaderWriterFilter.HeaderWriterRequest(request, headerWriterResponse);

        try {
            filterChain.doFilter(headerWriterRequest, headerWriterResponse);
        } finally {
            headerWriterResponse.writeHeaders();
        }

    }
  • class LogoutFilter extends GenericFilterBean，注销过滤器。
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        this.doFilter((HttpServletRequest)request, (HttpServletResponse)response, chain);
    }

    private void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
        if (this.requiresLogout(request, response)) {
            Authentication auth = SecurityContextHolder.getContext().getAuthentication();
            if (this.logger.isDebugEnabled()) {
                this.logger.debug(LogMessage.format("Logging out [%s]", auth));
            }

            this.handler.logout(request, response, auth);
            this.logoutSuccessHandler.onLogoutSuccess(request, response, auth);
        } else {
            chain.doFilter(request, response);
        }
    }
  • abstract class AbstractAuthenticationProcessingFilter extends GenericFilterBeanimplements ApplicationEventPublisherAware, MessageSourceAware ，抽象认证处理过滤器。
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        this.doFilter((HttpServletRequest)request, (HttpServletResponse)response, chain);
    }

    private void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
        if (!this.requiresAuthentication(request, response)) {
            chain.doFilter(request, response);
        } else {
            try {
                Authentication authenticationResult = this.attemptAuthentication(request, response);
                if (authenticationResult == null) {
                    return;
                }

                this.sessionStrategy.onAuthentication(authenticationResult, request, response);
                if (this.continueChainBeforeSuccessfulAuthentication) {
                    chain.doFilter(request, response);
                }

                this.successfulAuthentication(request, response, chain, authenticationResult);
            } catch (InternalAuthenticationServiceException var5) {
                this.logger.error("An internal error occurred while trying to authenticate the user.", var5);
                this.unsuccessfulAuthentication(request, response, var5);
            } catch (AuthenticationException var6) {
                this.unsuccessfulAuthentication(request, response, var6);
            }

        }
    }
  • class DefaultLoginPageGeneratingFilter extends GenericFilterBean，默认登录页面生成过滤器。
 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        this.doFilter((HttpServletRequest)request, (HttpServletResponse)response, chain);
    }

    private void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
        boolean loginError = this.isErrorPage(request);
        boolean logoutSuccess = this.isLogoutSuccess(request);
        if (!this.isLoginUrlRequest(request) && !loginError && !logoutSuccess) {
            chain.doFilter(request, response);
        } else {
            String loginPageHtml = this.generateLoginPageHtml(request, loginError, logoutSuccess);
            response.setContentType("text/html;charset=UTF-8");
            response.setContentLength(loginPageHtml.getBytes(StandardCharsets.UTF_8).length);
            response.getWriter().write(loginPageHtml);
        }
    }
  • class DefaultLogoutPageGeneratingFilter extends OncePerRequestFilter，默认注销页面生成过滤器。
  • class RequestCacheAwareFilter extends GenericFilterBean，请求缓存感知过滤器。
  • class SecurityContextHolderAwareRequestFilter extends GenericFilterBean，安全上下文持有者感知请求过滤器。
  • class AnonymousAuthenticationFilter extends GenericFilterBean implements InitializingBean，匿名身份验证过滤器。
  • class SessionManagementFilter extends GenericFilterBean，会话管理过滤器。
 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        this.doFilter((HttpServletRequest)request, (HttpServletResponse)response, chain);
    }

    private void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
        if (request.getAttribute("__spring_security_session_mgmt_filter_applied") != null) {
            chain.doFilter(request, response);
        } else {
            request.setAttribute("__spring_security_session_mgmt_filter_applied", Boolean.TRUE);
            if (!this.securityContextRepository.containsContext(request)) {
                Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
                if (authentication != null && !this.trustResolver.isAnonymous(authentication)) {
                    try {
                        this.sessionAuthenticationStrategy.onAuthentication(authentication, request, response);
                    } catch (SessionAuthenticationException var6) {
                        this.logger.debug("SessionAuthenticationStrategy rejected the authentication object", var6);
                        SecurityContextHolder.clearContext();
                        this.failureHandler.onAuthenticationFailure(request, response, var6);
                        return;
                    }

                    this.securityContextRepository.saveContext(SecurityContextHolder.getContext(), request, response);
                } else if (request.getRequestedSessionId() != null && !request.isRequestedSessionIdValid()) {
                    if (this.logger.isDebugEnabled()) {
                        this.logger.debug(LogMessage.format("Request requested invalid session id %s", request.getRequestedSessionId()));
                    }

                    if (this.invalidSessionStrategy != null) {
                        this.invalidSessionStrategy.onInvalidSessionDetected(request, response);
                        return;
                    }
                }
            }

            chain.doFilter(request, response);
        }
    }
  • class ExceptionTranslationFilter extends GenericFilterBean implements MessageSourceAware，异常翻译过滤器。
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        this.doFilter((HttpServletRequest)request, (HttpServletResponse)response, chain);
    }

    private void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
        try {
            chain.doFilter(request, response);
        } catch (IOException var7) {
            throw var7;
        } catch (Exception var8) {
            Throwable[] causeChain = this.throwableAnalyzer.determineCauseChain(var8);
            RuntimeException securityException = (AuthenticationException)this.throwableAnalyzer.getFirstThrowableOfType(AuthenticationException.class, causeChain);
            if (securityException == null) {
                securityException = (AccessDeniedException)this.throwableAnalyzer.getFirstThrowableOfType(AccessDeniedException.class, causeChain);
            }

            if (securityException == null) {
                this.rethrow(var8);
            }

            if (response.isCommitted()) {
                throw new ServletException("Unable to handle the Spring Security Exception because the response is already committed.", var8);
            }

            this.handleSpringSecurityException(request, response, chain, (RuntimeException)securityException);
        }

    }
  • class WsFilter extends GenericFilter ，ws过滤器。
  • class FilterSecurityInterceptor extends AbstractSecurityInterceptor implements Filter，过滤器安全拦截器。
huang_hai_an
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
源码解析——FilterChain是职责链（过滤器）模式的典型应用
qq_39368007的博客
02-25 1085
源码解析 在javaWeb应用开发中，FilterChain是职责链（过滤器）模式的典型应用，以下是Filter的模拟实现分析: Request.java package com.itheima.pattern.responsibility.jdk; /** * @version v1.0 * @ClassName: Request * @Description: TODO(一句话描述该类的功能) * @Author: dym */ public interface Request.
Java-Filter-FilterChain-FilterConfig源码
井底之蛙
10-17 1692
public interface Filter { /** * Called by the web container to indicate to a filter that it is being placed into * service. The servlet container calls the init method exactly once after instanti
设计模式 行为型模式 -- 职责链模式（JDK源码分析：FilterChain（过滤器））
天行健 君子以自强不息，地势坤 君子以厚德载物。
10-30 328
设计模式 行为型模式 – 职责链模式（定义、结构、纯与不纯的职责链模、具体案例） 1. JDK源码分析：FilterChain 下面的代码都是模拟源码仿写的，是为了简化代码，突出的是职责链模式的思想。 1.1 模拟web请求Request以及web响应Response Request.java package com.tian.responsibility.jdk; /** * @version v1.0 * @ClassName: Request */ public interface Re
深入理解 FilterChainProxy【源码篇】
CHENFU_ZKK的博客
12-26 838
深入理解 FilterChainProxy【源码篇】
Filter、FilterChain、FilterConfig源码翻译
爱我所爱0505
10-26 382
package javax.servlet; import java.io.IOException; /** * 目的：过滤器初始化并执行过滤 * * 一个过滤器执行请求或响应或请求+响应的过滤任何资源 * * 过滤器过滤是在doFilter()方法执行，每一个过滤器将访问FilterConfig对象的 * 初始化参数，并使用ServletContext。例如：加载资源时进行过
cindy源码分析filterchain
kjfcpua的专栏
11-27 2368
 常用的网络通讯框架主要有:Mina ,Grizzly,Cindy,Netty等,看了下cindy的代码,和mina有很多相似的地方,实现的比mina精简很多,据说性能还要好于mina.参照代码实现了一下filterchain的HelloWorld版,简单说明一下cindy里对filterchain模式的应用.首先定义filter接口,filter接口封装了session中的s
servlet源码
08-06
`Filter`接口和`FilterChain`接口定义了过滤器的生命周期和执行流程，过滤器可以用来修改请求或响应，实现如认证、日志记录等功能。`@WebFilter`注解同样简化了过滤器的部署。 `ServletContext`接口是整个web应用...
Java mina2源码
10-07
FilterChain则是一种设计模式，用于处理网络数据的过滤和转换，开发者可以通过自定义Filter来实现特定的功能，如加密解密、压缩解压等。ProtocolCodecFactory则负责将网络传输的数据进行编码和解码，确保数据在传输...
过滤器(filter) 例子源码
03-01
为了深入理解过滤器，你可以通过阅读并分析`TFilter`源码来了解其具体实现。同时，你可以尝试修改源码，实现自己的过滤需求，比如添加一个登录检查过滤器，确保只有已登录用户才能访问某些资源。 总结，过滤器是...
Mina 框架源码解析-构建简单通信程序
04-09
`FilterChain`是Mina的过滤器链，它允许我们在数据传输过程中添加自定义的处理逻辑。每个过滤器都可以对输入数据进行修改，或者根据需要触发事件。`ProtocolDecoder`和`ProtocolEncoder`负责将网络数据流转换为应用...
自定义FilterChain的编写
07-16
不使用Servlet Filter接口，自定义FilterChain处理多个Filter执行顺序问题
StrutsPrepareAndExecuteFilter源码剖析
10-17
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException { // ... // 调用 prepare 方法进行预处理 prepare.execute(dispatcher, request, ...
Spring Cloud Gateway 源码剖析之Filter Chain过滤器链
最新发布
2301_82243078的博客
04-02 1950
分享一些资料给大家，我觉得这些都是很有用的东西，大家也可以跟着来学习，查漏补缺。《Java高级面试》《Java高级架构知识》《算法知识》如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）[外链图片转存中…(img-ZgRHnp01-1711990165485)]分享一些资料给大家，我觉得这些都是很有用的东西，大家也可以跟着来学习，查漏补缺。《Java高级面试》[外链图片转存中…(img-u8BmPqg7-1711990165485)]《Java高级架构知识》
SOFA RPC源码解析之FilterChain
闲来无事
06-29 1249
1.SOFA RPC源码解析1.1  FilterChain        在SOFA RPC设计中，FilterChain是比较有新意的。它没有采用常用的List列表模式，即在List列表中存储Filter实现，然后按照Filter在列表中的顺序依次调用各Filter接口的filter方法，完成过滤器功能。        FilterChain简化类图如下：        首先，FilterCh...
自学-filterChainDefinitions的源码及和数据库进行交互-17
女神的高冷范
01-16 3255
前几节我们应该对这个filterChainDefinitions 有了解了吧！我们所有的权限设置都配置在了这个org.apache.shiro.spring.web.ShiroFilterFactoryBean这个属性中，我们可以想下，现在是有这几个权限，那加入有很多呢，如果还配置在这里是不是不太方便了，开发就是能多简便我们就怎么写对吧，根据观察我们可以发现这个属性中的值是键值对的形式而且还是有序
过滤器底层源码解析
Ciao's blog
02-09 806
过滤器底层源码解析
Filter源码解惑
学习之路
12-09 670
为了满足Shiro的分布式登录需求， 系统学习了Shiro的组件及流程， 但对于shiroFilter式如何注入到容器的存在疑问， 于是重新梳理了SpingWeb Filter的加载及调用。 一 基础组件认知 1ApplicationFilterChain 是过滤器的起始对象，生命周期与一次请求的生命周期相同，保存着对应urlMaping的过滤器和全局过滤器， 主要成员变量如下： private static final T...
JavaWeb三大组件之一——Filter过滤器源码解析（全面手撕Filter源码，需要耐心看完）
一只程序猿的博客
03-30 2997
什么是Filter？ 本文所说的Filter是JavaWeb中常见常使用的过滤器。Filter的作用是拦截前端发送给后端的请求，一般是用于权限过滤、日志记录、图片转换、加密、数据压缩等操作。 初步了解Filter接口 Filter是过滤器的核心接口，其中定义了初始化方法、拦截请求后的要做的具体任务方法、销毁方法。 public interface Filter { //初始化方法，整个生命周期中只执行一次。 //在init方法成功(失败如抛异常等)执行完前，不能提供过滤服务。 //
Filter及FilterChain的使用详解
热门推荐
zhaozheng7758的专栏
12-29 9万+
java中Filter与Servlet非常相似，也是一些web应用程序组件，可以绑定到一个web应用程序中。但是与其他web应用程序组件不同的是，过滤器是"链"在容器的处理过程中的。这就意味着它们会在servlet处理器之前访问一个进入的请求，并且在外发响应信息返回到客户前访问这些响应信息。这种访问使得过滤器可以检查并修改请求和响应的内容。本文主要对Filter及FilterChain的原理做一介绍，并给出几个具体的应用场景及实例。
filterchain
06-07
FilterChain 是 Java Servlet API 中的一个接口，它提供了一种将多个过滤器按照一定顺序组合起来，对 Servlet 请求进行处理的机制。FilterChain 中的每个过滤器都能够对请求进行处理，并将请求传递给下一个过滤器，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值