Spring Security中的过滤器链是一个由多个过滤器组成的链式结构。每个过滤器都负责执行特定的安全任务,并将请求传递给下一个过滤器。这些过滤器一起协同工作,以实现身份验证、授权、会话管理等安全功能。
在Spring Security源码中,有一个关键的过滤器叫做 FilterChainProxy ,它是整个过滤器链的入口点。 FilterChainProxy 负责协调和执行所有其他过滤器,并确保请求按照正确的顺序通过它们。 也就是我们自定义的过滤器是通过 FilterChainProxy插入到web过滤器链中的
使用Spring Security的过滤器链路
Filter就是过滤器,在JavaWeb体系中,他位于服务端,卡在请求/响应与Servlet之间做一些操作。通过过滤器我们可以做很多操作,例如:
认证和授权:Spring Security框架中的过滤器可以用于对用户进行身份验证和授权,以保护Web应用程序的安全性。
日志记录:可以使用过滤器记录HTTP请求和响应的详细信息,以便进行故障排除和性能优化。
缓存:可以使用过滤器实现缓存机制,以提高Web应用程序的性能和响应速度。
压缩:可以使用过滤器对响应进行压缩,以减少数据传输量,提高Web应用程序的性能。
字符编码:可以使用过滤器对请求和响应进行字符编码,以确保正确的数据传输和显示。
在Spring Web中,实现过滤器的核心类是 javax.servlet.Filter 。这是Java Servlet API中定义的标准接口。要在Spring Web中创建过滤器,通常需要创建一个实现 Filter 接口的类,并重写其方法,例如 doFilter() 。
以下是与Spring Web过滤器相关的一些核心类:
GenericFilterBean 是Spring Web框架提供的一个方便的基类,用于创建过滤器。它实现了 Filter 接口,并提供了一些额外的功能,例如bean生命周期管理和依赖注入。 GenericFilterBean 是自带init方法的,我们继承后只需要重写doFilter方法。
直接继承 GenericFilterBean 可以带来以下好处:
简化过滤器的创建:继承 GenericFilterBean 可以减少编写过滤器所需的代码量。它提供了一些默认的实现和方法,使得创建过滤器变得简单和方便。
生命周期管理: GenericFilterBean 实现了 Filter 接口,并提供了生命周期管理的功能。它可以在过滤器的初始化和销毁过程中执行相应的操作,例如资源的初始化和释放。
依赖注入: GenericFilterBean 支持依赖注入,您可以使用 @Autowired 注解将其他Spring bean注入到过滤器中。这使得在过滤器中使用其他组件、服务或依赖变得更加容易。
配置灵活性:通过继承 GenericFilterBean ,您可以根据需要自定义和配置过滤器的行为。您可以重写 doFilter() 方法以实现自定义的请求和响应处理逻辑,并使用其他提供的方法来访问过滤器的配置和上下文信息。
上边我们讲了GenericFilterBean,我们可以通过继承GenericFilterBean编写过滤器。此时的自定义的过滤器是交由Spring容器管理的,并不属于web的Servlet 容器管理。因此可以将过滤器分类两类,第一类是由 Web 容器进行管理,第二类是由 Spring 进行管理的,DelegatingFilterProxy 就是连接二者的桥梁。
DelegatingFilterProxy是Spring框架提供的一个过滤器代理类,它可以将请求转发到一个或多个过滤器。它的原理是将一个实现了javax.servlet.Filter接口的Bean转换为Servlet过滤器,并将这些过滤器应用到Web应用程序中。
在Spring中,DelegatingFilterProxy通常与Spring的IoC容器结合使用。当一个请求到达Web应用程序时,Servlet容器会将请求传递给DelegatingFilterProxy。DelegatingFilterProxy会从Spring的IoC容器中获取目标过滤器的实例,并调用它的doFilter方法来处理请求。
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
throws ServletException, IOException {
// Lazily initialize the delegate if necessary.
//这个时候经过初始化,filter已经是spring容器中的bean,在spring-Security中,此时delegateToUse就是spring-Security的FilterChainProxy
Filter delegateToUse = this.delegate;
if (delegateToUse == null) {
synchronized (this.delegateMonitor) {
delegateToUse = this.delegate;
if (delegateToUse == null) {
WebApplicationContext wac = findWebApplicationContext();
if (wac == null) {
throw new IllegalStateException("No WebApplicationContext found: " +
"no ContextLoaderListener or DispatcherServlet registered?");
}
delegateToUse = initDelegate(wac);
}
this.delegate = delegateToUse;
}
}
// Let the delegate perform the actual doFilter operation.
//代理模式 让代理Filter执行实际的doFilter方法,在spring-Security中,此时就是执行spring-Security的FilterChainProxy
invokeDelegate(delegateToUse, request, response, filterChain);
}
在源码中我们可以看到,使用了代理模式执行了被代理的过滤器的过滤方法。
在Spring Security中,FilterChainProxy是一个核心的过滤器,它负责处理Web请求的安全过滤链。它的作用是将请求传递给一系列的安全过滤器,以便进行身份验证、授权、会话管理等安全相关的操作。
FilterChainProxy的主要功能是根据配置的安全过滤器链来处理请求。在Spring Security的配置中,可以定义多个过滤器,并指定它们的顺序和应用于特定URL模式的条件。当一个请求到达应用程序时,FilterChainProxy会按照配置的顺序依次调用这些过滤器,直到找到适用于请求的过滤器链。
每个过滤器链都包含一系列的过滤器,它们按照特定的顺序执行。这些过滤器可以执行不同的安全操作,例如身份验证过滤器用于验证用户的身份,授权过滤器用于检查用户是否具有访问权限,会话管理过滤器用于管理用户的会话等。
通过FilterChainProxy,Spring Security提供了一种灵活的方式来定义和管理安全过滤器链。它可以根据应用程序的需求进行配置,并提供了强大的安全功能,以保护Web应用程序免受各种安全威胁。
public class FilterChainProxy extends GenericFilterBean {
可以看到,FilterChainProxy是继承了GenericFilterBean,FilterChainProxy 也是一个过滤器。
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
//此处是对请求是否第一次经过这个过滤器的判断,在spring security中的过滤器中这种用法是相当常见的
boolean clearContext = request.getAttribute(FILTER_APPLIED) == null;
if (!clearContext) {
doFilterInternal(request, response, chain);
return;
}
try {
request.setAttribute(FILTER_APPLIED, Boolean.TRUE);
doFilterInternal(request, response, chain);
}
catch (RequestRejectedException ex) {
this.requestRejectedHandler.handle((HttpServletRequest) request, (HttpServletResponse) response, ex);
}
finally {
//清除security上下文中的保存的Authentication对象
SecurityContextHolder.clearContext();
request.removeAttribute(FILTER_APPLIED);
}
}
这是FilterChainProxy的大概逻辑,细节点在doFilterInternal方法中。
private void doFilterInternal(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
//初始化request,对request进行一层包装,同时校验了一下请求的方式是否允许,以及请求地址中是否有非法字符
FirewalledRequest firewallRequest = this.firewall.getFirewalledRequest((HttpServletRequest) request);
//初始化response,对response进行了一层包装,若在response中添加header或cookie时,会对header和cookie的一些属性进行校验
HttpServletResponse firewallResponse = this.firewall.getFirewalledResponse((HttpServletResponse) response);
//SpringSecurity一般都会注册很多默认Filter,
//注意这些Filter在容器启动时就初始化好了
//获取spring security中第一个匹配请求地址的过滤器列表
List<Filter> filters = getFilters(firewallRequest);
if (filters == null || filters.size() == 0) {
if (logger.isTraceEnabled()) {
logger.trace(LogMessage.of(() -> "No security for " + requestLine(firewallRequest)));
}
firewallRequest.reset();
chain.doFilter(firewallRequest, firewallResponse);
return;
}
if (logger.isDebugEnabled()) {
logger.debug(LogMessage.of(() -> "Securing " + requestLine(firewallRequest)));
}
//VirtualFilterChain是一个过滤器链FilterChain
//将过滤器列表和servlet过滤器链包装成一个新的过滤器链 VirtualFilterChain 是FilterChainProxy的内部类
VirtualFilterChain virtualFilterChain = new VirtualFilterChain(firewallRequest, chain, filters);
virtualFilterChain.doFilter(firewallRequest, firewallResponse);
}
这段主要功能是:
/**
* Returns the first filter chain matching the supplied URL.
* @param request the request to match
* @return an ordered array of Filters defining the filter chain
*/
private List<Filter> getFilters(HttpServletRequest request) {
int count = 0;
for (org.springframework.security.web.SecurityFilterChain chain : this.filterChains) {
if (logger.isTraceEnabled()) {
logger.trace(LogMessage.format("Trying to match request against %s (%d/%d)", chain, ++count,
this.filterChains.size()));
}
if (chain.matches(request)) {
return chain.getFilters();
}
}
return null;
}
根据请求地址匹配过滤器列表
//VirtualFilterChain是一个过滤器链FilterChain
//将过滤器列表和servlet过滤器链包装成一个新的过滤器链 VirtualFilterChain 是FilterChainProxy的内部类
VirtualFilterChain virtualFilterChain = new VirtualFilterChain(firewallRequest, chain, filters);
virtualFilterChain.doFilter(firewallRequest, firewallResponse);
/**
* Internal {@code FilterChain} implementation that is used to pass a request through
* the additional internal list of filters which match the request.
*/
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 = 0;
private VirtualFilterChain(FirewalledRequest firewalledRequest, FilterChain chain,
List<Filter> additionalFilters) {
this.originalChain = chain;
this.additionalFilters = additionalFilters;
this.size = additionalFilters.size();
this.firewalledRequest = firewalledRequest;
}
@Override
public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {
//如果没有下一个过滤器,则回到servlet过滤器链
if (this.currentPosition == this.size) {
if (logger.isDebugEnabled()) {
logger.debug(LogMessage.of(() -> "Secured " + requestLine(this.firewalledRequest)));
}
// Deactivate path stripping as we exit the security filter chain
this.firewalledRequest.reset();
this.originalChain.doFilter(request, response);
return;
}
this.currentPosition++;
Filter nextFilter = this.additionalFilters.get(this.currentPosition - 1);
if (logger.isTraceEnabled()) {
logger.trace(LogMessage.format("Invoking %s (%d/%d)", nextFilter.getClass().getSimpleName(),
this.currentPosition, this.size));
}
//传入this,nextFilter中的会继续调用VirtualFilterChain.doFilter()直至所有过滤器执行结束或抛出异常
nextFilter.doFilter(request, response, this);
}
}
VirtualFilterChain一个过滤器链,执行additionalFilters集合中的所有过滤器。 也可以把VirtualFilterChain当作SecurityFilterChain,additionalFilters集合中的元素就是 Security Filter,也就是我们自己写的过滤器。
在 上图中,一个请求进来会进入web容器中,从上到下按顺序执行过滤器。当执行到DelegatingFilterProxy过滤器中,会代理到FilterChainProxy类中。FilterChainProxy 决定应该使用哪个 SecurityFilterChain。只有第一个匹配的 SecurityFilterChain 被调用。