1. 概述

我們可能需要在 Spring Boot 應用程序的不同路徑中應用多個安全過濾器。

在本教程中，我們將探討兩種自定義安全的方法——通過使用 EnableWebSecurity 和 EnableGlobalMethodSecurity。

為了説明這些差異，我們將使用一個包含一些管理員資源、已認證用户資源，以及我們樂於供任何人下載的公共資源的簡單應用程序。

2. Spring Boot Security

2.1. Maven 依賴項

無論我們採用哪種方法，首先都需要添加 spring boot starter for security：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

2.2. Spring Boot 自動配置

在 classpath 中啓用 Spring Security 後，Spring Boot Security Auto-Configuration 的 WebSecurityEnablerConfiguration 激活了 @EnableWebSecurity，為我們提供支持。

這會將 Spring 的默認安全配置應用於我們的應用程序。

默認安全激活了 HTTP 安全過濾器和安全過濾器鏈，並對我們的端點應用了基本身份驗證。

3. 保護我們的端點

對於我們的首次方法，讓我們首先創建一個 MySecurityConfigurer 類，並確保用 @EnableWebSecurity 註解它。

@EnableWebSecurity
public class MySecurityConfigurer {
}

3.1. SecurityFilterChain Bean 的快速瀏覽

首先，讓我們看看如何註冊一個 SecurityFilterChain 豆:

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    http.authorizeRequests((requests) -> requests.anyRequest().authenticated());
    http.formLogin(Customizer.withDefaults());
    http.httpBasic(Customizer.withDefaults());
    return http.build();
}

這裏我們看到，我們接收到的任何請求都會被認證，並且我們有一個基本的表單登錄來提示憑據。

當我們想要使用 HttpSecurity DSL 時，我們會這樣編寫:

http.authorizeRequests(request -> request.anyRequest().authenticated())
  .formLogin(Customizer.withDefaults())
  .httpBasic(Customizer.withDefaults())

3.2. 要求用户具有適當的角色

現在，讓我們配置我們的安全以僅允許具有 ADMIN 角色才能訪問我們的 /admin 端點。我們還允許僅允許具有 USER 角色才能訪問我們的 /protected 端點。

我們通過創建一個 SecurityFilterChain 豆來實現:

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    return http.authorizeHttpRequests(request -> request.requestMatchers(new AntPathRequestMatcher("/admin/**"))
            .hasRole("ADMIN"))
        .authorizeHttpRequests(request -> request.requestMatchers(new AntPathRequestMatcher("/protected/**"))
            .hasRole("USER"))
        .build();
}

3.3. 寬鬆地為公共資源配置安全

我們不需要對我們的公共 /hello 資源進行身份驗證，因此我們將配置 WebSecurity 不對它們執行任何操作。

就像之前一樣，讓我們註冊一個 WebSecurityCustomizer 豆:

@Bean
public WebSecurityCustomizer webSecurityCustomizer() {
    return (web) -> web.ignoring()
        .requestMatchers(new AntPathRequestMatcher("/public/*"));
}

4. 使用註解保護端點

為了使用註解驅動的方法來應用安全，我們可以使用 @EnableGlobalMethodSecurity。

4.1. 使用安全註解要求用户具有適當的角色

現在，我們使用方法註解來配置我們的安全，僅允許 ADMIN 用户訪問我們的 /admin 端點，以及 USER 用户訪問我們的 /protected 端點。

讓我們啓用 JSR-250 註解，通過在我們的 EnableGlobalMethodSecurity 註解中設置 jsr250Enabled=true 來完成:

@EnableGlobalMethodSecurity(jsr250Enabled = true)
@Controller
public class AnnotationSecuredController {
    @RolesAllowed("ADMIN")
    @RequestMapping("/admin")
    public String adminHello() {
        return "Hello Admin";
    }

    @RolesAllowed("USER")
    @RequestMapping("/protected")
    public String jsr250Hello() {
        return "Hello Jsr250";
    }
}

4.2. 強制所有公共方法具有安全

當我們使用註解作為實現安全的方式時，我們可能會忘記為方法添加註解。這會無意中創建一個安全漏洞。

為了防止這種情況發生，我們應該拒絕訪問沒有授權註解的所有方法。

4.3. 允許訪問公共資源

Spring 的默認安全強制執行對我們所有端點的身份驗證，無論我們是否添加了基於角色的安全。

雖然我們之前的示例將安全應用於我們的 /admin 和 /protected 端點，但我們仍然希望允許訪問基於文件資源的 /hello。

雖然我們可以再次擴展 WebSecurityAdapter，Spring 提供了更簡單的替代方案。

在保護我們的方法與註解之後，我們可以添加 WebSecurityCustomizer 以打開 /hello/* 資源:

public class MyPublicPermitter implements WebSecurityCustomizer {
    public void customize(WebSecurity webSecurity) {
        webSecurity.ignoring()
          .antMatchers("/hello/*");
    }
}

或者，我們可以創建一個在配置類中實現它的 Bean:

@Configuration
public class MyWebConfig {
    @Bean
    public WebSecurityCustomizer ignoreResources() {
        return (webSecurity) -> webSecurity
          .ignoring()
          .antMatchers("/hello/*");
    }
}

當 Spring Security 初始化時，它會調用它找到的任何 WebSecurityCustomizer，包括我們自己的。

5. Testing Our Security

現在我們已經配置了安全，我們應該檢查它是否按預期工作。

根據我們選擇的安全方法，我們有以下一個或兩個自動測試選項。我們可以通過向我們的應用程序發送 Web 請求來測試，也可以直接調用我們的控制器方法。

5.1. Testing via Web Requests

對於第一個選項，我們將創建一個帶有 的測試類：

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = RANDOM_PORT)
public class WebSecuritySpringBootIntegrationTest {
    @Autowired
    private TestRestTemplate template;
}

@Test
public void givenPublicResource_whenGetViaWeb_thenOk() {
    ResponseEntity<String> result = template.getForEntity("/hello/baeldung.txt", String.class);
    assertEquals("Hello From Baeldung", result.getBody());
}

@Test
public void whenGetProtectedViaWeb_thenForbidden() {
    ResponseEntity<String> result = template.getForEntity("/protected", String.class);
    assertEquals(HttpStatus.FORBIDDEN, result.getStatusCode());
}

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = RANDOM_PORT)
public class GlobalMethodSpringBootIntegrationTest {
    @Autowired
    private AnnotationSecuredController api;
}

@Test
@WithAnonymousUser
public void givenAnonymousUser_whenPublic_thenOk() {
    assertThat(api.publicHello()).isEqualTo(HELLO_PUBLIC);
}

@WithMockUser(username="baeldung", roles = "USER")
@Test
public void givenUserWithRole_whenJsr250_thenOk() {
    assertThat(api.jsr250Hello()).isEqualTo("Hello Jsr250");
}

@WithMockUser(username="baeldung", roles = "NOT-USER")
@Test(expected = AccessDeniedException.class)
public void givenWrongRole_whenJsr250_thenAccessDenied() {
    api.jsr250Hello();
}

@GetMapping("/indirect")
public String indirectHello() {
    return jsr250Hello();
}

@Test
@WithAnonymousUser
public void givenAnonymousUser_whenIndirectCall_thenNoSecurity() {
    assertThat(api.indirectHello()).isEqualTo(HELLO_JSR_250);
}

@Component
public class DifferentClass {
    @RolesAllowed("USER")
    public String differentJsr250Hello() {
        return "Hello Jsr250";
    }
}

@Autowired
DifferentClass differentClass;

@GetMapping("/differentclass")
public String differentClassHello() {
    return differentClass.differentJsr250Hello();
}

@Test(expected = AccessDeniedException.class)
@WithAnonymousUser
public void givenAnonymousUser_whenIndirectToDifferentClass_thenAccessDenied() {
    api.differentClassHello();
}

@EnableGlobalMethodSecurity(prePostEnabled = true)

@EnableGlobalMethodSecurity(jsr250Enabled = true, prePostEnabled = true)

@EnableGlobalMethodSecurity(prePostEnabled = true)