SpringSecurity配置和源码解析

1. 背景

Spring Security最主要的两个功能：认证和授权

功能	解决的问题	Spring Security中主要类
认证（Authentication）	你是谁	AuthenticationManager
授权（Authorization）	你可以做什么	AuthorizationManager

之前的文章讲过了使用Spring Security来接入其他单点登录系统，其中单点登录系统来解决你是谁的问题，Spring Security用来解决你可以做什么的问题

这次我们主要使用Spring Security的认证功能

这次的需求是这样的，我们有一个A服务，A服务内部有n个接口，这些接口根据使用方的不同可以分为三部分

1. C端用户使用的接口，需要c端账户体系鉴权，后续会有网关统一鉴权，目前暂时用账号密码鉴权
2. B端用户使用的接口，需要b端账户体系鉴权，由其他OAuth2 Server来鉴权
3. 开发人员使用的接口，账号密码鉴权

Spring Security版本： 5.3.x

2. 目的

本篇文章的目的是通过实际的场景来让大家如何配置Spring Security来实现自己的需求，明白每一行的配置作用

3. 整体配置

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Configuration
    @Order(1)
    public static class BSecurityConfig extends WebSecurityConfigurerAdapter {
        @Override
        protected void configure(HttpSecurity http) throws Exception {
            http
                    .csrf()
              			.disable()
                    .antMatcher("/b/**")
                    .authorizeRequests()
                    .anyRequest()
              			.authenticated()
                    .and()
                    .addFilterBefore(new MyTokenJwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);
        }

        @Override
        public void configure(WebSecurity web) {
            web.ignoring().antMatchers("/b/api/auth/access_token");
        }
    }

    @Configuration
    @Order(2)
    public static class CSecurityConfig extends WebSecurityConfigurerAdapter {
        @Value("${algo-api.password}")
        private String password;

        @Override
        protected void configure(HttpSecurity http) throws Exception {
            http
                    .csrf().disable()
                    .antMatcher("/c/**")
                    .authorizeRequests()
                    .anyRequest()
                    .hasRole("C_ADMIN")
                    .and()
                    .httpBasic();

        }
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
            auth.inMemoryAuthentication()
                    .withUser("cAdmin777")
                    .password(password)
                    .roles("ALGO_ADMIN");
        }
    }

    @Configuration
    @Order(3)
    public static class DevSecurityConfig extends WebSecurityConfigurerAdapter {

        @Value("${swagger.password}")
        private String password;
        @Override
        protected void configure(HttpSecurity http) throws Exception {
            http
                    .csrf().disable()
                    .authorizeRequests()
                    .antMatchers("/swagger-ui/**", "/v3/api-docs/**", "/test/**")
                    .hasRole("SWAGGER_ADMIN")
                    .antMatchers("/login", "/css/**", "/js/**", "/images/**")
                    .permitAll()
                    .anyRequest()
                    .denyAll()
                    .and()
                    .formLogin();
        }
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
            auth.inMemoryAuthentication()
                    .withUser("swaggerAdmin999")
                    .password(password)
                    .roles("SWAGGER_ADMIN");
        }
    }
}

3.1 配置解读

3.1.1 SecurityConfig类

首先是一个SecurityConfig类，带了@Configuration和@EnableWebSecurity注解，代表接入了Springboot和开启了SpringSecurity功能

3.1.2 WebSecurityConfigurerAdapter子类

内部是三个静态内部类BSecurityConfig、CSecurityConfig、DevSecurityConfig分别对应我们的需求的使用方，B端用户、C端用户和开发人员，他们继承了WebSecurityConfigurerAdapter类，继承此类可以重写其中的方法来进行配置，具体Spring Security是如何做的可以看后面的源码分析

从Spring Security官方文档中可以看到，使用不同的SecurityFilterChain对不同的url前缀进行安全配置

所以，这里的三个静态内部类就是对应的三个SecurityFilterChain

那么有的同学可能会问，如果url的路径冲突了怎么办，比如两个SecurityFilterChain的路径前缀一样，那就取决于WebSecurityConfigurerAdapter的子类加载顺序，会使用先匹配的SecurityFilterChain，可以看到我们的静态内部类也使用了@Order(3)这样的注解来标识顺序

从断点中可以有4个SecurityFilterChain，且每个SecurityFilterChain内部的过滤器数量不同

为什么多了一个SecurityFilterChain，因为在BSecurityConfig中我们忽略了/b/api/auth/access_token路径的安全配置，所以对于这个路径下一个过滤器也没有

WebSecurityConfigurerAdapter类三个的主要的配置方法，也就是我们需要重写的方法：

protected void configure(AuthenticationManagerBuilder auth)
public void configure(WebSecurity web)
protected void configure(HttpSecurity http)

AuthenticationManagerBuilder这个类是来配置认证相关的，例如使用内存中的账号密码，还是JDBC的数据来认证，从图中可以看出其作用

3.1.3 HttpSecurity配置

这个是我们主要使用的配置类，它的常用方法有：

csrf和cors，具体可以参考我之前的博客

3.1.3.1 Match方法

这些方法用来指定这个配置是对哪些路径生效的

• antMatcher
• mvcMatcher
• regexMatcher
• requestMatchers

其中requestMatchers是比较灵活的匹配路径的一种方式，适合匹配多个路径

注意： 区分antMatcher和antMatchers

	antMatchers	antMatcher
所属类	AbstractRequestMatcherRegistry	HttpSecurity
参数	多个url通配符	单个url通配符
作用	细粒度的鉴权，每个路径下面需要的鉴权不同，权限也可能不同	粗粒度的鉴权，每个路径是一个SecurityFilterChain，有一组过滤器

3.1.3.2 authorizeRequests方法

返回的是ExpressionUrlAuthorizationConfigurer类

用来表示要开启一个细粒度的鉴权，两个方法功能一样，写法不一样，推荐下面这种，可以把某个细粒度的路径的鉴权写到一起，而不是整个链式，难以阅读，后续使用的类是ExpressionInterceptUrlRegistry

• authorizeRequests
• authorizeRequests(authorizeRequestsCustomizer)

3.1.3.2.1 match

和HttpSecurity一样，细粒度的圈选路径

• antMatchers，符合表达式的请求
• mvcMatchers
• regexMatchers
• anyRequest，任意请求

3.1.3.2.2 访问权限

在圈选完路径之后，声明此路径的鉴权方式，也就是需不需要登录，需要什么权限才能方法

• permitAll，允许访问
• anonymous，允许匿名
• rememberMe，记住我
• denyAll，不允许访问
• authenticated，允许登录后访问
• hasRole，需要某个角色可以访问
• hasAuthority，需要某个权限可以访问

3.1.3.3 其他

3.1.3.3.1 xxxLogin

表示需要此种登录，例如formLogin表示需要进行表单登录，可以指定一些登录页，登录失败页面等，或者默认生成一些页面

oauth2Login表示使用OAuth2.0来做验证，这种就很方便的使用第三方应用来登录，例如支付宝授权登录

3.1.3.3.2 sessionManagement

需要进行session管理

3.1.3.3.3 addFilterxxx

手动的往Spring的过滤器链里面加一个过滤器，实际上，SpringSecurity所有的功能都是在过滤器链里面加过滤器，只不过有现成的稳定的类就不用我们自己写的，当现有的满足不了我们的需要时，我们可以自己来实现

3.1.4 WebSecurity配置

WebSecurity是全局配置类，它的常用方法有：

• ignoring 配置不做控制的路径
• httpFirewall 设置防火墙，拦截非法的请求，非法的http method，包含非法的符号等
• debug 开启debug日志

上面的代码中，我们对/b/api/auth/access_token路径的请求不做控制

4. 源码分析

整体架构如上所示：

• SecurityBuilder和SecurityConfigurer是核心接口类，前者是构建者模式，后者负责定制化配置
• HttpSecurity和WebSecurity是SecurityBuilder的两个核心实现类，一个负责收集整体的认证配置，一个负责收集指定路径的认证配置
• XXXXSecurityConfigurer代表一系列的配置类，包括前面将的CRSF, CORS，登录、session等各种功能的实现
• WebSecurityConfigurerAdapter是适配器模式，通过定制化HttpSecurity和WebSecurity这两个Builder来定制化真正的配置
• WebSecurityConfiguration是自动配置类，也是Spring Security的启动类，它调用WebSecurity的init/build方法最终生成一个Filter，作为Servlet容器的一个普通Filter来使用

4.1 EnableWebSecurity

我们在使用Spring Security的时候需要加这个注解，这个注解使用@Import导入了WebSecurityConfiguration配置类

@Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
@Target(value = { java.lang.annotation.ElementType.TYPE })
@Documented
@Import({ WebSecurityConfiguration.class,
		SpringWebMvcImportSelector.class,
		OAuth2ImportSelector.class })
@EnableGlobalAuthentication
@Configuration
public @interface EnableWebSecurity {

	/**
	 * Controls debugging support for Spring Security. Default is false.
	 * @return if true, enables debug support with Spring Security
	 */
	boolean debug() default false;
}

4.2 WebSecurityConfiguration

这个类很关键，下面是这个类的核心方法，通过Value注入了List<SecurityConfigurer<Filter, WebSecurity>> 这个就是我们配置的多个WebSecurityConfigurerAdapter的类的父类，也就是把我们的实现类都给收集起来，然后排序，最后放到webSecurity这个对象中去

	public void setFilterChainProxySecurityConfigurer(
			ObjectPostProcessor<Object> objectPostProcessor,
    	// 我们继承WebSecurityConfigurerAdapter的子类被在这被收集起来
			@Value("#{@autowiredWebSecurityConfigurersIgnoreParents.getWebSecurityConfigurers()}") List<SecurityConfigurer<Filter, WebSecurity>> webSecurityConfigurers)
			throws Exception {
		webSecurity = objectPostProcessor
				.postProcess(new WebSecurity(objectPostProcessor));
		if (debugEnabled != null) {
			webSecurity.debug(debugEnabled);
		}
		// 排序
		webSecurityConfigurers.sort(AnnotationAwareOrderComparator.INSTANCE);

		Integer previousOrder = null;
		Object previousConfig = null;
		for (SecurityConfigurer<Filter, WebSecurity> config : webSecurityConfigurers) {
			Integer order = AnnotationAwareOrderComparator.lookupOrder(config);
			if (previousOrder != null && previousOrder.equals(order)) {
				throw new IllegalStateException(
						"@Order on WebSecurityConfigurers must be unique. Order of "
								+ order + " was already used on " + previousConfig + ", so it cannot be used on "
								+ config + " too.");
			}
			previousOrder = order;
			previousConfig = config;
		}
    // 放入webSecurity中
		for (SecurityConfigurer<Filter, WebSecurity> webSecurityConfigurer : webSecurityConfigurers) {
			webSecurity.apply(webSecurityConfigurer);
		}
		this.webSecurityConfigurers = webSecurityConfigurers;

下面注册了一个Servlet Filter，这个Filter实现了整个Spring Security的功能

@Bean(
    name = {"springSecurityFilterChain"}
)
public Filter springSecurityFilterChain() throws Exception {
    boolean hasConfigurers = this.webSecurityConfigurers != null && !this.webSecurityConfigurers.isEmpty();
  	// 假如开发者没有定制化过WebSecurityConfigurerAdapter，会默认new一个
    if (!hasConfigurers) {
        WebSecurityConfigurerAdapter adapter = (WebSecurityConfigurerAdapter)this.objectObjectPostProcessor.postProcess(new WebSecurityConfigurerAdapter() {
        });
        this.webSecurity.apply(adapter);
    }

    return (Filter)this.webSecurity.build();
}

4.2 WebSecurity

其实没有很多逻辑在里面，基本就是构造者的思想，在不断填充各种属性，包括调用了HttpSecurity的 securityFilterChainBuilder.build()

	protected Filter performBuild() throws Exception {
		Assert.state(
				!securityFilterChainBuilders.isEmpty(),
				() -> "At least one SecurityBuilder<? extends SecurityFilterChain> needs to be specified. "
						+ "Typically this done by adding a @Configuration that extends WebSecurityConfigurerAdapter. "
						+ "More advanced users can invoke "
						+ WebSecurity.class.getSimpleName()
						+ ".addSecurityFilterChainBuilder directly");
		int chainSize = ignoredRequests.size() + securityFilterChainBuilders.size();
		List<SecurityFilterChain> securityFilterChains = new ArrayList<>(
				chainSize);
		for (RequestMatcher ignoredRequest : ignoredRequests) {
			securityFilterChains.add(new DefaultSecurityFilterChain(ignoredRequest));
		}
		for (SecurityBuilder<? extends SecurityFilterChain> securityFilterChainBuilder : securityFilterChainBuilders) {
			securityFilterChains.add(securityFilterChainBuilder.build());
		}
		FilterChainProxy filterChainProxy = new FilterChainProxy(securityFilterChains);
		if (httpFirewall != null) {
			filterChainProxy.setFirewall(httpFirewall);
		}
		filterChainProxy.afterPropertiesSet();

		Filter result = filterChainProxy;
		if (debugEnabled) {
			logger.warn("\n\n"
					+ "********************************************************************\n"
					+ "**********        Security debugging is enabled.       *************\n"
					+ "**********    This may include sensitive information.  *************\n"
					+ "**********      Do not use in a production system!     *************\n"
					+ "********************************************************************\n\n");
			result = new DebugFilter(filterChainProxy);
		}
		postBuildAction.run();
		return result;

4.3 HttpSecurity

也比较简单

protected DefaultSecurityFilterChain performBuild() {
    this.filters.sort(this.comparator);
    return new DefaultSecurityFilterChain(this.requestMatcher, this.filters);
}

它的更多逻辑其实在父类AbstractConfiguredSecurityBuilder的模板方法里面，init方法和configure方法才是真正把我们配置的哪些XXXXSecurityConfigurer类真正实现和生效

   protected final O doBuild() throws Exception {
        synchronized(this.configurers) {
            this.buildState = AbstractConfiguredSecurityBuilder.BuildState.INITIALIZING;
            this.beforeInit();
            this.init();
            this.buildState = AbstractConfiguredSecurityBuilder.BuildState.CONFIGURING;
            this.beforeConfigure();
            this.configure();
            this.buildState = AbstractConfiguredSecurityBuilder.BuildState.BUILDING;
            O result = (O)this.performBuild();
            this.buildState = AbstractConfiguredSecurityBuilder.BuildState.BUILT;
            return result;
        }
   }

    private void init() throws Exception {
        for(SecurityConfigurer<O, B> configurer : this.getConfigurers()) {
            configurer.init(this);
        }

        for(SecurityConfigurer<O, B> configurer : this.configurersAddedInInitializing) {
            configurer.init(this);
        }

    }

    private void configure() throws Exception {
        for(SecurityConfigurer<O, B> configurer : this.getConfigurers()) {
            configurer.configure(this);
        }
    }

4.4 XXXXSecurityConfigurer

当我们调用HttpSecurity的cors方法后，是怎样把真正的Configurer注册的

可以看到HttpSecurity注册了一个CorsConfigurer类，这个类按照上面说的后面会被init和configure

  public CorsConfigurer<HttpSecurity> cors() throws Exception {
      return (CorsConfigurer)this.getOrApply(new CorsConfigurer());
  }

下面是CorsConfigurer的configure，可以看到它的实现非常容易理解，生成一个Filter，然后加到了HttpSecurity中，至于Filter内部的逻辑可以不必关注，就是一个普通的Servlet Filter，然后解决跨域访问的问题

    public void configure(H http) {
        ApplicationContext context = (ApplicationContext)http.getSharedObject(ApplicationContext.class);
        CorsFilter corsFilter = this.getCorsFilter(context);
        if (corsFilter == null) {
            throw new IllegalStateException("Please configure either a corsFilter bean or a corsConfigurationSourcebean.");
        } else {
            http.addFilter(corsFilter);
        }
    }

其他的SecurityConfigurer内部逻辑可能很复杂，但最终逻辑其实都是在过滤器链里面加过滤器，实现拦截或者通过

附录

如何查看和编译Spring Security源码

下载仓库时，可以不下载历史，会更快和占更少的空间，指定分支

git clone --depth 1 https://github.com/spring-projects/spring-security.git -b 5.3.x

在下载依赖时，某个spring的插件怎么也下载不下来，因为spring的插件仓库在2021年关闭了对公众的访问，需要授权才能用（可以理解，但是很难受）

https://spring.io/blog/2020/10/29/notice-of-permissions-changes-to-repo-spring-io-fall-and-winter-2020

https://spring.io/blog/2022/12/14/notice-of-permissions-changes-to-repo-spring-io-january-2023

从公告中看镜像插件应该是可用的，但确实git下载的代码无法同步到依赖

需要修改build.gradle文件,

buildscript {
	configurations.all {
		resolutionStrategy.dependencySubstitution {
			substitute module('org.apache.xerces:xercesImpl') with module('xerces:xercesImpl:2.9.1')
			substitute module('org.apache.xerces:resolver') with module('xerces:resolver:2.9.1')
		}
	}
	dependencies {
		classpath 'io.spring.gradle:spring-build-conventions:0.0.38-SNAPSHOT'
		classpath "org.springframework.boot:spring-boot-gradle-plugin:$springBootVersion"
		classpath 'io.spring.nohttp:nohttp-gradle:0.0.10'
		classpath "io.freefair.gradle:aspectj-plugin:4.1.6"
		classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
	}
	repositories {
		maven { url 'https://maven.aliyun.com/repository/spring-plugin' }
		maven { url 'https://maven.aliyun.com/repository/gradle-plugin' }
		maven {
			url = 'https://repo.spring.io/plugins-snapshot'
		}
		maven {
			url = 'https://repo.spring.io/plugins-milestone'
		}
		maven {
			url = 'https://repo.spring.io/plugins-release'
		}
		maven { url 'https://plugins.gradle.org/m2/' }
	}
}

apply plugin: 'io.spring.nohttp'
apply plugin: 'locks'
apply plugin: 'io.spring.convention.root'
apply plugin: 'org.jetbrains.kotlin.jvm'

group = 'org.springframework.security'
description = 'Spring Security'

ext.snapshotBuild = version.contains("SNAPSHOT")
ext.releaseBuild = version.contains("SNAPSHOT")
ext.milestoneBuild = !(snapshotBuild || releaseBuild)

dependencyManagementExport.projects = subprojects.findAll { !it.name.contains('-boot') }

repositories {
	mavenCentral()
}

subprojects {
	plugins.withType(JavaPlugin) {
		project.sourceCompatibility='1.8'
	}

	tasks.withType(JavaCompile) {
		options.encoding = "UTF-8"
	}
}

主要修改了两点：

1. 修改了插件spring-build-conventions的版本
2. 新增了阿里云插件仓库

总之，是部分包Spring的仓库有，部分包阿里云仓库有，运气好的情况下，正确同步到了依赖

注意，最终还是没完全同步成功完依赖，因为某些spring仓库无法访问的问题，但可以进行部分类的跳转