跳到主要内容

方法安全性

QWen Max 中英对照 Method Security

方法安全性​

除了在请求级别建模授权之外，Spring Security 还支持在方法级别进行建模。

您可以在应用程序中通过在任何 @Configuration 类上添加 @EnableMethodSecurity 注解或在任何 XML 配置文件中添加 <method-security> 来激活它，如下所示：

@EnableMethodSecurity
java

然后，您可以立即使用 @PreAuthorize、@PostAuthorize、@PreFilter 和 @PostFilter 来注解任何 Spring 管理的类或方法，以授权方法调用，包括输入参数和返回值。

备注

Spring Boot Starter Security 默认不激活方法级别的授权。

方法安全性还支持许多其他用例，包括 AspectJ 支持、自定义注解 以及几个配置点。请考虑了解以下用例：

方法安全性的工作原理​

Spring Security的方法级授权支持适用于以下情况：

  • 提取细粒度的授权逻辑；例如，当方法参数和返回值对授权决策有贡献时。

  • 在服务层实施安全性

  • 从风格上偏好基于注解的配置而非基于 HttpSecurity 的配置

并且由于方法安全性是使用 Spring AOP 构建的，你可以利用其所有的表达能力来根据需要覆盖 Spring Security 的默认设置。

正如前面提到的，你需要在 @Configuration 类中添加 @EnableMethodSecurity，或在 Spring XML 配置文件中添加 <sec:method-security/>。

备注

此注解和 XML 元素分别取代了 @EnableGlobalMethodSecurity 和 <sec:global-method-security/>。它们提供了以下改进：

  1. 使用简化的 AuthorizationManager API，而不是元数据源、配置属性、决策管理器和投票器。这简化了重用和自定义。

  2. 倾向于直接基于 bean 的配置，而不是要求扩展 GlobalMethodSecurityConfiguration 来自定义 bean。

  3. 使用原生的 Spring AOP 构建，移除了抽象层，并允许你使用 Spring AOP 构建块来自定义。

  4. 检查冲突的注解，以确保安全配置不模糊。

  5. 遵循 JSR-250。

  6. 默认启用 @PreAuthorize、@PostAuthorize、@PreFilter 和 @PostFilter。

如果你正在使用 @EnableGlobalMethodSecurity 或 <global-method-security/>，这些现在已被弃用，建议你进行迁移。

方法授权是前置方法授权和后置方法授权的结合。考虑一个服务 Bean，其注解方式如下：

@Service
public class MyCustomerService {
    @PreAuthorize("hasAuthority('permission:read')")
    @PostAuthorize("returnObject.owner == authentication.name")
    public Customer readCustomer(String id) { ... }
}
java

对 MyCustomerService#readCustomer 的调用在方法安全被激活时可能看起来像这样：

methodsecurity

  1. Spring AOP 为 readCustomer 调用其代理方法。在代理的其他 advisor 中，它调用了一个与 the @PreAuthorize pointcut 匹配的 AuthorizationManagerBeforeMethodInterceptor。

  2. 拦截器调用 PreAuthorizeAuthorizationManager#check。

  3. 授权管理器使用 MethodSecurityExpressionHandler 解析注解的 SpEL 表达式，并从包含 a Supplier<Authentication> 和 MethodInvocation 的 MethodSecurityExpressionRoot 构建相应的 EvaluationContext。

  4. 拦截器使用此上下文来评估表达式；具体来说，它从 Supplier 中读取 the Authentication，并检查其 authorities 集合中是否包含 permission:read。

  5. 如果评估通过，则 Spring AOP 继续调用该方法。

  6. 如果不通过，拦截器发布一个 AuthorizationDeniedEvent 并抛出一个 AccessDeniedException，the ExceptionTranslationFilter 捕获该异常并向响应返回 403 状态码。

  7. 在方法返回后，Spring AOP 调用一个与 the @PostAuthorize pointcut 匹配的 AuthorizationManagerAfterMethodInterceptor，其操作方式与上述相同，但使用的是 PostAuthorizeAuthorizationManager。

  8. 如果评估通过（在这种情况下，返回值属于已登录用户），则处理继续正常进行。

  9. 如果不通过，拦截器发布一个 AuthorizationDeniedEvent 并抛出一个 AccessDeniedException，the ExceptionTranslationFilter 捕获该异常并向响应返回 403 状态码。

备注

如果该方法不是在 HTTP 请求的上下文中被调用，你可能需要自己处理 AccessDeniedException

多个注解按顺序计算​

如上所示，如果一个方法调用涉及多个方法安全注解，则这些注解会逐一进行处理。这意味着可以将它们整体视为是“与”在一起的。换句话说，为了使调用被授权，所有注解检查都需要通过授权。

不支持重复注解​

也就是说，不支持在同一个方法上重复相同的注解。例如，你不能在同一个方法上放置两次 @PreAuthorize。

相反，使用 SpEL 的布尔支持或其委托给单独 bean 的支持。

每个注解都有其自己的切入点​

每个注解都有自己的切点实例，该实例会在整个对象层次结构中查找该注解或其元注解对应项，从方法及其封闭类开始。

每个注解都有自己的方法拦截器​

每个注解都有其自己的专用方法拦截器。这样做的原因是使事情更具可组合性。例如，如果需要，你可以禁用 Spring Security 的默认设置，并仅发布 @PostAuthorize 方法拦截器。

方法拦截器如下：

一般来说，当你添加 @EnableMethodSecurity 时，可以将以下列表视为 Spring Security 发布的拦截器的代表：

@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
static Advisor preAuthorizeMethodInterceptor() {
    return AuthorizationManagerBeforeMethodInterceptor.preAuthorize();
}

@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
static Advisor postAuthorizeMethodInterceptor() {
    return AuthorizationManagerAfterMethodInterceptor.postAuthorize();
}

@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
static Advisor preFilterMethodInterceptor() {
    return AuthorizationManagerBeforeMethodInterceptor.preFilter();
}

@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
static Advisor postFilterMethodInterceptor() {
    return AuthorizationManagerAfterMethodInterceptor.postFilter();
}
java

优先使用授权权限而非复杂的 SpEL 表达式​

经常会遇到引入如下复杂的SpEL表达式的诱惑：

@PreAuthorize("hasAuthority('permission:read') || hasRole('ADMIN')")
java
@PreAuthorize("hasAuthority('permission:read') || hasRole('ADMIN')")
kotlin

但是，你可以改为向具有 ROLE_ADMIN 的用户授予 permission:read。一种方法是使用如下所示的 RoleHierarchy：

@Bean
static RoleHierarchy roleHierarchy() {
    return RoleHierarchyImpl.fromHierarchy("ROLE_ADMIN > permission:read");
}
java

然后将其设置在 MethodSecurityExpressionHandler 实例 中。这样你就可以使用更简单的 @PreAuthorize 表达式，如下所示：

@PreAuthorize("hasAuthority('permission:read')")
java

或者，在可能的情况下，将特定于应用程序的授权逻辑在登录时适配为授予的权限。

比较请求级与方法级授权​

你应该在什么情况下优先选择方法级授权而不是请求级授权？这在一定程度上取决于个人偏好；然而，考虑以下每种方式的优点列表，以帮助你做出决定。

request-level方法级
授权类型粗粒度细粒度
配置位置在配置类中声明在方法声明本地
配置风格DSL注解
授权定义编程方式SpEL

主要的权衡点似乎在于你希望你的授权规则存放在哪里。

备注

重要的是要记住，当你使用基于注解的方法安全时，未注解的方法是不安全的。为了防止这种情况，在你的 HttpSecurity 实例中声明一个通用授权规则。

使用注解授权​

Spring Security 主要通过可以添加到方法、类和接口上的注解来实现方法级别的授权支持。

使用 @PreAuthorize 授权方法调用​

当方法安全被激活时，你可以使用@PreAuthorize注解来标注一个方法，如下所示：

@Component
public class BankService {
    @PreAuthorize("hasRole('ADMIN')")
    public Account readAccount(Long id) {
        // ... is only invoked if the `Authentication` has the `ROLE_ADMIN` authority
    }
}
java

这表示该方法只有在提供的表达式 hasRole('ADMIN') 通过时才能被调用。

然后，你可以测试该类以确认它是否像这样强制执行授权规则：

@Autowired
BankService bankService;

@WithMockUser(roles="ADMIN")
@Test
void readAccountWithAdminRoleThenInvokes() {
    Account account = this.bankService.readAccount("12345678");
    // ... assertions
}

@WithMockUser(roles="WRONG")
@Test
void readAccountWithWrongRoleThenAccessDenied() {
    assertThatExceptionOfType(AccessDeniedException.class).isThrownBy(
        () -> this.bankService.readAccount("12345678"));
}
java
提示

@PreAuthorize 也可以是一个 元注解，可以在 类或接口级别 定义，并且可以使用 SpEL 授权表达式。

虽然 @PreAuthorize 在声明所需的权限时非常有用，但它也可以用于评估涉及方法参数的更复杂的表达式。

使用 @PostAuthorize 的授权方法结果​

当方法安全处于激活状态时，你可以使用 @PostAuthorize 注解标注一个方法，如下所示：

@Component
public class BankService {
    @PostAuthorize("returnObject.owner == authentication.name")
    public Account readAccount(Long id) {
        // ... is only returned if the `Account` belongs to the logged in user
    }
}
java

这表示该方法只有在提供的表达式 returnObject.owner == authentication.name 通过时才能返回值。returnObject 代表要返回的 Account 对象。

然后，您可以测试该类以确认其正在执行授权规则：

@Autowired
BankService bankService;

@WithMockUser(username="owner")
@Test
void readAccountWhenOwnedThenReturns() {
    Account account = this.bankService.readAccount("12345678");
    // ... assertions
}

@WithMockUser(username="wrong")
@Test
void readAccountWhenNotOwnedThenAccessDenied() {
    assertThatExceptionOfType(AccessDeniedException.class).isThrownBy(
        () -> this.bankService.readAccount("12345678"));
}
java
提示

@PostAuthorize 也可以是一个 元注解，可以在 类或接口级别 定义，并且可以使用 SpEL 授权表达式。

@PostAuthorize 在防御不安全的直接对象引用时特别有用。实际上，它可以被定义为一个元注解，如下所示：

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@PostAuthorize("returnObject.owner == authentication.name")
public @interface RequireOwnership {}
java

允许你以如下方式注解服务：

@Component
public class BankService {
    @RequireOwnership
    public Account readAccount(Long id) {
        // ... is only returned if the `Account` belongs to the logged in user
    }
}
java

结果是，上述方法只有在 Account 的 owner 属性与登录用户的 name 匹配时才会返回该 Account。如果不匹配，Spring Security 将抛出一个 AccessDeniedException 并返回 403 状态码。

使用 @PreFilter 过滤方法参数​

当方法安全处于激活状态时，你可以使用 @PreFilter 注解来标注一个方法，如下所示：

@Component
public class BankService {
    @PreFilter("filterObject.owner == authentication.name")
    public Collection<Account> updateAccounts(Account... accounts) {
        // ... `accounts` will only contain the accounts owned by the logged-in user
        return updated;
    }
}
java

这旨在过滤掉 accounts 中所有不符合 filterObject.owner == authentication.name 表达式的值。filterObject 代表 accounts 中的每个 account，并用于测试每个 account。

然后，您可以以下列方式测试该类，以确认它正在执行授权规则：

@Autowired
BankService bankService;

@WithMockUser(username="owner")
@Test
void updateAccountsWhenOwnedThenReturns() {
    Account ownedBy = ...
    Account notOwnedBy = ...
    Collection<Account> updated = this.bankService.updateAccounts(ownedBy, notOwnedBy);
    assertThat(updated).containsOnly(ownedBy);
}
java
提示

@PreFilter 也可以是一个 元注解，可以在 类或接口级别 定义，并且可以使用 SpEL 授权表达式。

@PreFilter 支持数组、集合、映射和流（只要流仍然处于打开状态）。

例如，上述 updateAccounts 声明将与以下四种方式的功能相同：

@PreFilter("filterObject.owner == authentication.name")
public Collection<Account> updateAccounts(Account[] accounts)

@PreFilter("filterObject.owner == authentication.name")
public Collection<Account> updateAccounts(Collection<Account> accounts)

@PreFilter("filterObject.value.owner == authentication.name")
public Collection<Account> updateAccounts(Map<String, Account> accounts)

@PreFilter("filterObject.owner == authentication.name")
public Collection<Account> updateAccounts(Stream<Account> accounts)
java

结果是，上述方法将只包含 owner 属性与登录用户的 name 匹配的 Account 实例。

使用 @PostFilter 过滤方法结果​

当方法安全处于激活状态时，你可以使用 @PostFilter 注解来标注一个方法，如下所示：

@Component
public class BankService {
    @PostFilter("filterObject.owner == authentication.name")
    public Collection<Account> readAccounts(String... ids) {
        // ... the return value will be filtered to only contain the accounts owned by the logged-in user
        return accounts;
    }
}
java

这旨在从返回值中过滤掉 filterObject.owner == authentication.name 表达式失败的任何值。filterObject 代表 accounts 中的每个 account，并用于测试每个 account。

然后你可以像下面这样测试该类，以确认它是否强制执行了授权规则：

@Autowired
BankService bankService;

@WithMockUser(username="owner")
@Test
void readAccountsWhenOwnedThenReturns() {
    Collection<Account> accounts = this.bankService.updateAccounts("owner", "not-owner");
    assertThat(accounts).hasSize(1);
    assertThat(accounts.get(0).getOwner()).isEqualTo("owner");
}
java
提示

@PostFilter 也可以是一个 元注解，可以在 类或接口级别 定义，并且可以使用 SpEL 授权表达式。

@PostFilter 支持数组、集合、映射和流（只要流仍然打开）。

例如，上面的 readAccounts 声明将与以下其他三种声明具有相同的功能：

@PostFilter("filterObject.owner == authentication.name")
public Collection<Account> readAccounts(String... ids)

@PostFilter("filterObject.owner == authentication.name")
public Account[] readAccounts(String... ids)

@PostFilter("filterObject.value.owner == authentication.name")
public Map<String, Account> readAccounts(String... ids)

@PostFilter("filterObject.owner == authentication.name")
public Stream<Account> readAccounts(String... ids)
java

结果是，上述方法将返回 owner 属性与登录用户的 name 匹配的 Account 实例。

备注

在内存中进行过滤显然可能会很耗费资源，因此请考虑是否最好在数据层中对数据进行过滤。

使用 @Secured 授权方法调用​

@Secured 是一种用于授权调用的遗留选项。推荐使用 @PreAuthorize 来替代它。

要使用 @Secured 注解，你应该首先更改你的方法安全声明以启用它，如下所示：

@EnableMethodSecurity(securedEnabled = true)
java

这将导致 Spring Security 发布相应的方法拦截器，该拦截器授权用 @Secured 注解的方法、类和接口。

使用 JSR-250 注解授权方法调用​

如果您想使用 JSR-250 注解，Spring Security 也支持这一点。@PreAuthorize 具有更强的表达能力，因此推荐使用。

要使用 JSR-250 注解，你应该首先像这样更改你的方法安全声明：

@EnableMethodSecurity(jsr250Enabled = true)
java

这将导致 Spring Security 发布相应的方法拦截器，该拦截器授权用 @RolesAllowed、@PermitAll 和 @DenyAll 注解的方法、类和接口。

在类或接口级别声明注解​

在类和接口级别使用方法安全注解也是支持的。

如果它在类级别，如下所示：

@Controller
@PreAuthorize("hasAuthority('ROLE_USER')")
public class MyController {
    @GetMapping("/endpoint")
    public String endpoint() { ... }
}
java

那么所有方法都会继承类级别的行为。

或者，如果在类和方法级别都像下面这样声明：

@Controller
@PreAuthorize("hasAuthority('ROLE_USER')")
public class MyController {
    @GetMapping("/endpoint")
    @PreAuthorize("hasAuthority('ROLE_ADMIN')")
    public String endpoint() { ... }
}
java

则声明该注解的方法会覆盖类级别的注解。

对于接口来说也是如此，不同之处在于，如果一个类从两个不同的接口继承了注解，那么启动将会失败。这是因为 Spring Security 无法判断你想要使用哪一个。

在这种情况下，你可以通过将注解添加到具体方法来解决歧义。

使用元注解​

方法安全性支持元注解。这意味着你可以采用任何注解，并根据你的特定应用程序用例来提高可读性。

例如，你可以将 @PreAuthorize("hasRole('ADMIN')") 简化为 @IsAdmin，如下所示：

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@PreAuthorize("hasRole('ADMIN')")
public @interface IsAdmin {}
java

结果是，现在您可以在受保护的方法中执行以下操作：

@Component
public class BankService {
    @IsAdmin
    public Account readAccount(Long id) {
        // ... is only returned if the `Account` belongs to the logged in user
    }
}
java

这使得方法定义更具可读性。

模板元注解表达式​

您还可以选择使用元注解模板，这允许定义更强大的注解。

首先，发布以下bean：

@Bean
static AnnotationTemplateExpressionDefaults templateExpressionDefaults() {
    return new AnnotationTemplateExpressionDefaults();
}
java

现在，你可以创建一个更强大的 @HasRole，而不是使用 @IsAdmin，如下所示：

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@PreAuthorize("hasRole('{value}')")
public @interface HasRole {
    String value();
}
java

结果是，现在你可以在受保护的方法中执行以下操作：

@Component
public class BankService {
    @HasRole("ADMIN")
    public Account readAccount(Long id) {
        // ... is only returned if the `Account` belongs to the logged in user
    }
}
java

请注意，这也可以用于方法变量和所有注解类型，但您需要注意正确处理引号，以使生成的 SpEL 表达式正确。

例如，考虑以下 @HasAnyRole 注解：

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@PreAuthorize("hasAnyRole({roles})")
public @interface HasAnyRole {
    String[] roles();
}
java

在这种情况下，你会注意到不应该在表达式中使用引号，而应该在参数值中使用，如下所示：

@Component
public class BankService {
    @HasAnyRole(roles = { "'USER'", "'ADMIN'" })
    public Account readAccount(Long id) {
        // ... is only returned if the `Account` belongs to the logged in user
    }
}
java

这样，替换之后，表达式就变成了 @PreAuthorize("hasAnyRole('USER', 'ADMIN')")。

启用某些注释​

你可以关闭 @EnableMethodSecurity 的预配置，并用你自己的配置来替换。如果你想要自定义授权管理器或 Pointcut，或者你只想启用特定的注解（如 @PostAuthorize），则可以选择这样做。

你可以通过以下方式实现：

@Configuration
@EnableMethodSecurity(prePostEnabled = false)
class MethodSecurityConfig {
    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    Advisor postAuthorize() {
        return AuthorizationManagerAfterMethodInterceptor.postAuthorize();
    }
}
java

上述代码片段首先禁用方法安全的预配置，然后发布the @PostAuthorize 拦截器本身。

使用 <intercept-methods> 授权​

虽然使用 Spring Security 的基于注解的支持是方法安全的首选，但你也可以使用 XML 来声明 bean 授权规则。

如果你需要在XML配置中声明它，你可以像这样使用<intercept-methods>：

<bean class="org.mycompany.MyController">
    <intercept-methods>
        <protect method="get*" access="hasAuthority('read')"/>
        <protect method="*" access="hasAuthority('write')"/>
    </intercept-methods>
</bean>
xml
备注

这仅支持通过前缀或名称进行匹配的方法。如果你的需求比这更复杂，请改用注解支持。

通过编程方式授权方法​

正如你已经看到的，你可以使用方法安全 SpEL 表达式来指定复杂的授权规则。

有多种方法可以让你的逻辑基于Java而不是基于SpEL。这使得我们可以使用整个Java语言，从而提高可测试性和流程控制。

在 SpEL 中使用自定义 Bean​

程序化授权方法的第一种方式是一个两步过程。

首先，声明一个具有如下方法的 bean，该方法接收一个 MethodSecurityExpressionOperations 实例：

@Component("authz")
public class AuthorizationLogic {
    public boolean decide(MethodSecurityExpressionOperations operations) {
        // ... authorization logic
    }
}
java

然后，在注解中以如下方式引用该 bean：

@Controller
public class MyController {
    @PreAuthorize("@authz.decide(#root)")
    @GetMapping("/endpoint")
    public String endpoint() {
        // ...
    }
}
java

Spring Security 将在每次方法调用时调用该 bean 上的给定方法。

这样做的好处是，所有的授权逻辑都在一个独立的类中，可以独立进行单元测试并验证其正确性。它还可以访问完整的 Java 语言。

提示

除了返回一个 Boolean，您还可以返回 null 来表示代码不做出决定。

如果你想要包含更多关于决策性质的信息，你可以返回一个自定义的 AuthorizationDecision，像这样：

@Component("authz")
public class AuthorizationLogic {
    public AuthorizationDecision decide(MethodSecurityExpressionOperations operations) {
        // ... authorization logic
        return new MyAuthorizationDecision(false, details);
    }
}
java

或者抛出一个自定义的 AuthorizationDeniedException 实例。不过，请注意，返回一个对象是更可取的做法，因为这样不会产生生成堆栈跟踪的开销。

然后，您可以在自定义如何处理授权结果时访问自定义详细信息。

使用自定义授权管理器​

第二种以编程方式授权方法的方式是创建自定义的 AuthorizationManager。

首先，声明一个授权管理器实例，可能像这样：

@Component
public class MyAuthorizationManager implements AuthorizationManager<MethodInvocation>, AuthorizationManager<MethodInvocationResult> {
    @Override
    public AuthorizationDecision check(Supplier<Authentication> authentication, MethodInvocation invocation) {
        // ... authorization logic
    }

    @Override
    public AuthorizationDecision check(Supplier<Authentication> authentication, MethodInvocationResult invocation) {
        // ... authorization logic
    }
}
java

然后，使用与你希望 AuthorizationManager 运行时对应的通知发布方法拦截器。例如，你可以像这样替换 @PreAuthorize 和 @PostAuthorize 的工作方式：

@Configuration
@EnableMethodSecurity(prePostEnabled = false)
class MethodSecurityConfig {
    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    Advisor preAuthorize(MyAuthorizationManager manager) {
        return AuthorizationManagerBeforeMethodInterceptor.preAuthorize(manager);
    }

    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    Advisor postAuthorize(MyAuthorizationManager manager) {
        return AuthorizationManagerAfterMethodInterceptor.postAuthorize(manager);
    }
}
java
提示

你可以使用 AuthorizationInterceptorsOrder 中指定的顺序常量，将拦截器放置在 Spring Security 方法拦截器之间。

自定义表达式处理​

或者，第三种方法，你可以自定义每个 SpEL 表达式的处理方式。要做到这一点，你可以暴露一个自定义的 MethodSecurityExpressionHandler，如下所示：

@Bean
static MethodSecurityExpressionHandler methodSecurityExpressionHandler(RoleHierarchy roleHierarchy) {
    DefaultMethodSecurityExpressionHandler handler = new DefaultMethodSecurityExpressionHandler();
    handler.setRoleHierarchy(roleHierarchy);
    return handler;
}
java
提示

我们通过一个 static 方法来暴露 MethodSecurityExpressionHandler，以确保 Spring 在初始化 Spring Security 的方法安全 @Configuration 类之前发布它。

你也可以子类化 DefaultMessageSecurityExpressionHandler 以添加自定义授权表达式，而不仅仅是默认的。

使用 AOT​

Spring Security 会扫描应用程序上下文中的所有 bean，查找使用 @PreAuthorize 或 @PostAuthorize 的方法。当找到这样的方法时，它会解析安全表达式中使用的任何 bean，并为该 bean 注册适当的运行时提示。如果找到使用 @AuthorizeReturnObject 的方法，它会递归地在方法的返回类型中搜索 @PreAuthorize 和 @PostAuthorize 注解，并相应地进行注册。

例如，考虑以下 Spring Boot 应用程序：

@Service
public class AccountService { 1

    @PreAuthorize("@authz.decide()") 2
    @AuthorizeReturnObject 3
    public Account getAccountById(String accountId) {
        // ...
    }

}

public class Account {

    private final String accountNumber;

    // ...

    @PreAuthorize("@accountAuthz.canViewAccountNumber()") 4
    public String getAccountNumber() {
        return this.accountNumber;
    }

    @AuthorizeReturnObject 5
    public User getUser() {
        return new User("John Doe");
    }

}

public class User {

    private final String fullName;

    // ...

    @PostAuthorize("@myOtherAuthz.decide()") 6
    public String getFullName() {
        return this.fullName;
    }

}
java

  • Spring Security 找到 AccountService bean

  • 找到使用 @PreAuthorize 的方法时，它会解析表达式中使用的任何 bean 名称，在这种情况下是 authz，并为 bean 类注册运行时提示

  • 找到使用 @AuthorizeReturnObject 的方法时，它会检查方法的返回类型中的任何 @PreAuthorize 或 @PostAuthorize

  • 然后，它找到另一个带有 bean 名称的 @PreAuthorize：accountAuthz；也会为 bean 类注册运行时提示

  • 找到另一个 @AuthorizeReturnObject 时，它会再次检查方法的返回类型

  • 现在，找到一个带有另一个 bean 名称的 @PostAuthorize：myOtherAuthz；也会为 bean 类注册运行时提示

有许多情况下，Spring Security 无法提前确定方法的实际返回类型，因为它可能隐藏在被擦除的泛型类型中。

考虑以下服务：

@Service
public class AccountService {

    @AuthorizeReturnObject
    public List<Account> getAllAccounts() {
        // ...
    }

}
java

在这种情况下，泛型类型被擦除，因此 Spring Security 无法提前知道需要访问 Account 来检查 @PreAuthorize 和 @PostAuthorize。

为了解决这个问题，你可以发布一个 PrePostAuthorizeExpressionBeanHintsRegistrar，如下所示：

@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
static SecurityHintsRegistrar registerTheseToo() {
    return new PrePostAuthorizeExpressionBeanHintsRegistrar(Account.class);
}
java

使用 AspectJ 进行授权​

通过自定义切点匹配方法​

基于 Spring AOP，你可以声明与注解无关的模式，类似于请求级授权。这样做的潜在优势在于可以集中管理方法级的授权规则。

例如，你可以使用发布自己的 Advisor 或使用 <protect-pointcut> 将 AOP 表达式与服务层的授权规则匹配，如下所示：

import static org.springframework.security.authorization.AuthorityAuthorizationManager.hasRole

@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
static Advisor protectServicePointcut() {
    AspectJExpressionPointcut pattern = new AspectJExpressionPointcut()
    pattern.setExpression("execution(* com.mycompany.*Service.*(..))")
    return new AuthorizationManagerBeforeMethodInterceptor(pattern, hasRole("USER"))
}
java

集成 AspectJ 字节织入​

有时可以通过使用 AspectJ 将 Spring Security 增强代码织入到 bean 的字节码中来提高性能。

在设置好 AspectJ 之后，您可以在 @EnableMethodSecurity 注解或 <method-security> 元素中简单地声明您正在使用 AspectJ：

@EnableMethodSecurity(mode=AdviceMode.ASPECTJ)
java

结果是 Spring Security 会将其 advisor 发布为 AspectJ 建议，以便它们可以相应地被织入。

指定顺序​

正如已经提到的，每个注解都有一个 Spring AOP 方法拦截器，并且每个拦截器在 Spring AOP 顾问链中都有一个位置。

即，@PreFilter 方法拦截器的顺序是 100，@PreAuthorize 的顺序是 200，依此类推。

需要注意这一点的原因是，还有其他基于AOP的注解，如 @EnableTransactionManagement，它们的顺序为 Integer.MAX_VALUE。换句话说，默认情况下，它们位于advisor链的末尾。

有时，在 Spring Security 之前执行其他建议可能会很有价值。例如，如果你有一个用 @Transactional 和 @PostAuthorize 注解的方法，你可能希望在 @PostAuthorize 运行时事务仍然是打开的，这样 AccessDeniedException 将会导致回滚。

要让 @EnableTransactionManagement 在方法授权通知运行之前开启事务，你可以这样设置 @EnableTransactionManagement 的顺序：

@EnableTransactionManagement(order = 0)
java

由于最早的拦截器方法（@PreFilter）被设置为 100 的顺序，因此设置为零意味着事务通知将在所有 Spring Security 通知之前运行。

用SpEL表达授权​

你已经看过几个使用 SpEL 的示例，现在让我们更深入地介绍 API。

Spring Security 将其所有的授权字段和方法封装在一组根对象中。最通用的根对象被称为 SecurityExpressionRoot，它是 MethodSecurityExpressionRoot 的基础。当准备评估一个授权表达式时，Spring Security 会将这个根对象提供给 MethodSecurityEvaluationContext。

使用授权表达式字段和方法​

这提供了增强的授权字段和方法到您的SpEL表达式中。以下是对最常用方法的快速概述：

  • permitAll - 调用该方法不需要任何授权；请注意，在这种情况下，认证信息永远不会从会话中检索

  • denyAll - 该方法在任何情况下都不允许调用；请注意，在这种情况下，Authentication 永远不会从会话中检索

  • hasAuthority - 该方法要求 Authentication 具有与给定值匹配的 GrantedAuthority

  • hasRole - hasAuthority 的快捷方式，它会在前面加上 ROLE_ 或者配置的默认前缀

  • hasAnyAuthority - 该方法要求 Authentication 具有与给定值中的任何一个匹配的 GrantedAuthority

  • hasAnyRole - hasAnyAuthority 的快捷方式，它会在前面加上 ROLE_ 或者配置的默认前缀

  • hasPermission - 连接到您的 PermissionEvaluator 实例以进行对象级授权

以下是最常见的字段简介：

  • authentication - 与此方法调用关联的 Authentication 实例

  • principal - 与此方法调用关联的 Authentication#getPrincipal

现在你已经学习了模式、规则以及它们如何组合在一起，你应该能够理解这个更复杂的例子中的内容：

@Component
public class MyService {
    @PreAuthorize("denyAll") 1
    MyResource myDeprecatedMethod(...);

    @PreAuthorize("hasRole('ADMIN')") 2
    MyResource writeResource(...)

    @PreAuthorize("hasAuthority('db') and hasRole('ADMIN')") 3
    MyResource deleteResource(...)

    @PreAuthorize("principal.claims['aud'] == 'my-audience'") 4
    MyResource readResource(...);

    @PreAuthorize("@authz.check(authentication, #root)")
    MyResource shareResource(...);
}
java

  • 任何人均不得以任何理由调用此方法

  • 此方法仅可由被授予 ROLE_ADMIN 权限的 Authentication 调用

  • 此方法仅可由被授予 db 和 ROLE_ADMIN 权限的 Authentication 调用

  • 此方法仅可由 aud 声明等于 "my-audience" 的 Princpal 调用

  • 仅当 bean authz 的 check 方法返回 true 时，才可调用此方法

提示

你可以像上面那样使用一个名为 authz 的 bean 来添加编程授权。

使用方法参数​

此外，Spring Security 提供了一种机制来发现方法参数，这样它们也可以在 SpEL 表达式中被访问。

作为一个完整的参考，Spring Security 使用 DefaultSecurityParameterNameDiscoverer 来发现参数名称。默认情况下，对于一个方法，会尝试以下选项。

  1. 如果方法的单个参数上存在 Spring Security 的 @P 注解，则使用该值。以下示例使用了 @P 注解：

    import org.springframework.security.access.method.P

    ...

    @PreAuthorize("hasPermission(#c, 'write')")
    public void updateContact(@P("c") Contact contact);
    java

    该表达式的意图是要求当前的 Authentication 对此 Contact 实例具有 write 权限。

    在幕后，这是通过使用 AnnotationParameterNameDiscoverer 实现的，你可以自定义它以支持任何指定注解的值属性。

  2. 如果方法的至少一个参数上存在 Spring Data 的 @Param 注解，则使用该值。以下示例使用了 @Param 注解：

    import org.springframework.data.repository.query.Param;

    ...

    @PreAuthorize("#n == authentication.name")
    Contact findContactByName(@Param("n") String name);
    java

    该表达式的意图是要求 name 等于 Authentication#getName 以便授权调用。

    在幕后，这是通过使用 AnnotationParameterNameDiscoverer 实现的，你可以自定义它以支持任何指定注解的值属性。

  3. 如果你使用 -parameters 参数编译代码，则使用标准的 JDK 反射 API 来发现参数名称。这适用于类和接口。

  4. 最后，如果你使用调试符号编译代码，则使用调试符号来发现参数名称。这对接口不起作用，因为它们没有关于参数名称的调试信息。对于接口，必须使用注解或 -parameters 方法。

授权任意对象​

Spring Security 还支持包装任何使用其方法安全注解的对象。

实现这一目标的最简单方法是使用 @AuthorizeReturnObject 注解标记任何返回你希望授权的对象的方法。

例如，考虑下面的 User 类：

public class User {
    private String name;
    private String email;

    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }

    public String getName() {
        return this.name;
    }

    @PreAuthorize("hasAuthority('user:read')")
    public String getEmail() {
        return this.email;
    }
}
java

给定一个这样的接口：

public class UserRepository {
    @AuthorizeReturnObject
    Optional<User> findByName(String name) {
        // ...
    }
}
java

那么从 findById 返回的任何 User 都将像其他受 Spring Security 保护的组件一样受到保护：

@Autowired
UserRepository users;

@Test
void getEmailWhenProxiedThenAuthorizes() {
    Optional<User> securedUser = users.findByName("name");
    assertThatExceptionOfType(AccessDeniedException.class).isThrownBy(() -> securedUser.get().getEmail());
}
java

在类级别使用 @AuthorizeReturnObject​

@AuthorizeReturnObject 可以放在类级别。不过，请注意，这意味着 Spring Security 会尝试代理任何返回对象，包括 String、Integer 和其他类型。这通常不是你想要做的。

如果你想要在一个类或接口的方法返回值类型（如 int、String、Double 或这些类型的集合）上使用 @AuthorizeReturnObject，那么你也应该发布相应的 AuthorizationAdvisorProxyFactory.TargetVisitor，如下所示：

@Bean
static Customizer<AuthorizationAdvisorProxyFactory> skipValueTypes() {
    return (factory) -> factory.setTargetVisitor(TargetVisitor.defaultsSkipValueTypes());
}
java
提示

你可以设置你自己的 AuthorizationAdvisorProxyFactory.TargetVisitor 来为任何一组类型自定义代理

通过编程方式代理​

您还可以以编程方式代理给定的对象。

要实现这一点，你可以自动装配提供的 AuthorizationProxyFactory 实例，该实例基于你配置的方法安全拦截器。如果你使用的是 @EnableMethodSecurity，那么这意味着它默认会有 @PreAuthorize、@PostAuthorize、@PreFilter 和 @PostFilter 的拦截器。

您可以按如下方式代理 user 的实例：

@Autowired
AuthorizationProxyFactory proxyFactory;

@Test
void getEmailWhenProxiedThenAuthorizes() {
    User user = new User("name", "email");
    assertThat(user.getEmail()).isNotNull();
    User securedUser = proxyFactory.proxy(user);
    assertThatExceptionOfType(AccessDeniedException.class).isThrownBy(securedUser::getEmail);
}
java

手动构建​

您也可以根据需要定义自己的实例，如果Spring Security默认设置不能满足需求的话。

例如，如果你像这样定义一个 AuthorizationProxyFactory 实例：

import org.springframework.security.authorization.method.AuthorizationAdvisorProxyFactory.TargetVisitor;
import static org.springframework.security.authorization.method.AuthorizationManagerBeforeMethodInterceptor.preAuthorize;
// ...

AuthorizationProxyFactory proxyFactory = AuthorizationAdvisorProxyFactory.withDefaults();
// and if needing to skip value types
proxyFactory.setTargetVisitor(TargetVisitor.defaultsSkipValueTypes());
java

然后你可以将任何 User 实例包装如下：

@Test
void getEmailWhenProxiedThenAuthorizes() {
    AuthorizationProxyFactory proxyFactory = AuthorizationAdvisorProxyFactory.withDefaults();
    User user = new User("name", "email");
    assertThat(user.getEmail()).isNotNull();
    User securedUser = proxyFactory.proxy(user);
    assertThatExceptionOfType(AccessDeniedException.class).isThrownBy(securedUser::getEmail);
}
java

代理集合​

AuthorizationProxyFactory 通过代理元素类型支持 Java 集合、流、数组、选项和迭代器，并通过代理值类型支持映射。

这意味着在代理一个 List 对象时，以下操作也是可行的：

@Test
void getEmailWhenProxiedThenAuthorizes() {
    AuthorizationProxyFactory proxyFactory = AuthorizationAdvisorProxyFactory.withDefaults();
    List<User> users = List.of(ada, albert, marie);
    List<User> securedUsers = proxyFactory.proxy(users);
    securedUsers.forEach((securedUser) ->
        assertThatExceptionOfType(AccessDeniedException.class).isThrownBy(securedUser::getEmail));
}
java

代理类​

在有限的情况下，代理一个 Class 本身可能是有价值的，而 AuthorizationProxyFactory 也支持这一点。这大致相当于在 Spring Framework 的创建代理的支持中调用 ProxyFactory#getProxyClass。

这一点在需要预先构建代理类时非常有用，比如使用 Spring AOT 的情况下。

支持所有方法安全注解​

AuthorizationProxyFactory 支持在你的应用程序中启用的任何方法安全注解。它是基于作为 bean 发布的任何 AuthorizationAdvisor 类。

由于 @EnableMethodSecurity 默认会发布 @PreAuthorize、@PostAuthorize、@PreFilter 和 @PostFilter 通知器，因此通常你无需执行任何操作即可激活这些功能。

备注

使用 returnObject 或 filterObject 的 SpEL 表达式位于代理后面，因此可以完全访问对象。

自定义建议​

如果你有想要应用的安全建议，你可以像这样发布你自己的 AuthorizationAdvisor：

@EnableMethodSecurity
class SecurityConfig {
    @Bean
    static AuthorizationAdvisor myAuthorizationAdvisor() {
        return new AuthorizationAdvisor();
    }
}
java

并且 Spring Security 会将该 advisor 添加到 AuthorizationProxyFactory 在代理对象时添加的 advice 集合中。

使用 Jackson​

这一功能的一个强大用法是从控制器中返回一个受保护的值，如下所示：

@RestController
public class UserController {
    @Autowired
    AuthorizationProxyFactory proxyFactory;

    @GetMapping
    User currentUser(@AuthenticationPrincipal User user) {
        return this.proxyFactory.proxy(user);
    }
}
java
@Component
public class Null implements MethodAuthorizationDeniedHandler {
    @Override
    public Object handleDeniedInvocation(MethodInvocation methodInvocation, AuthorizationResult authorizationResult) {
        return null;
    }
}

// ...

@HandleAuthorizationDenied(handlerClass = Null.class)
public class User {
    ...
}
java

然后，你会看到基于用户授权级别的不同的 JSON 序列化。如果他们没有 user:read 权限，那么他们将看到：

{
    "name" : "name",
    "email" : null
}
json

如果他们有该权限，他们会看到：

{
    "name" : "name",
    "email" : "email"
}
json
提示

您还可以添加 Spring Boot 属性 spring.jackson.default-property-inclusion=non_null，以在序列化时排除 null 值，如果您也不希望向未授权用户透露 JSON 键的话。

使用 AOT​

Spring Security 会扫描应用程序上下文中的所有 bean，查找使用 @AuthorizeReturnObject 的方法。当找到一个时，它会提前创建并注册适当的代理类。它还会递归搜索其他也使用 @AuthorizeReturnObject 的嵌套对象，并相应地进行注册。

例如，考虑以下 Spring Boot 应用程序：

@SpringBootApplication
public class MyApplication {
    @RestController
    public static class MyController { 1
        @GetMapping
        @AuthorizeReturnObject
        Message getMessage() { 2
            return new Message(someUser, "hello!");
        }
    }

    public static class Message { 3
        User to;
        String text;

        // ...

        @AuthorizeReturnObject
        public User getTo() { 4
            return this.to;
        }

        // ...
    }

    public static class User { 5
        // ...
    }

    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class);
    }
}
java

  • - 首先，Spring Security 找到 MyController bean

  • - 找到使用 @AuthorizeReturnObject 的方法后，它代理返回值 Message，并将该代理类注册到 RuntimeHints

  • - 然后，它遍历 Message 以查看是否使用了 @AuthorizeReturnObject

  • - 找到使用 @AuthorizeReturnObject 的方法后，它代理返回值 User，并将该代理类注册到 RuntimeHints

  • - 最后，它遍历 User 以查看是否使用了 @AuthorizeReturnObject；没有找到任何内容后，算法完成

有很多情况下，Spring Security 无法提前确定代理类，因为它可能隐藏在被擦除的泛型类型中。

考虑对 MyController 进行如下更改：

@RestController
public static class MyController {
    @GetMapping
    @AuthorizeReturnObject
    List<Message> getMessages() {
        return List.of(new Message(someUser, "hello!"));
    }
}
java

在这种情况下，泛型类型被擦除，因此 Spring Security 无法提前得知 Message 需要在运行时被代理。

为了解决这个问题，你可以像这样发布 AuthorizeProxyFactoryHintsRegistrar：

@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
static SecurityHintsRegsitrar registerTheseToo(AuthorizationProxyFactory proxyFactory) {
    return new AuthorizeReturnObjectHintsRegistrar(proxyFactory, Message.class);
}
java

Spring Security 会注册该类，然后像以前一样遍历其类型。

当授权被拒绝时提供备用值​

在某些情况下，你可能不希望在没有所需权限的情况下调用方法时抛出 AuthorizationDeniedException。相反，你可能希望返回一个后处理的结果，比如一个被屏蔽的结果，或者在授权被拒绝而未调用方法的情况下返回一个默认值。

Spring Security 通过使用 @HandleAuthorizationDenied 提供了处理方法调用时授权被拒绝的支持。该处理器适用于在 @PreAuthorize 和 @PostAuthorize 注解 中发生的拒绝授权，以及从方法调用本身抛出的 AuthorizationDeniedException。

让我们考虑上一节中的示例，但不是创建 AccessDeniedExceptionInterceptor 将 AccessDeniedException 转换为 null 返回值，而是使用 @HandleAuthorizationDenied 的 handlerClass 属性：

public class NullMethodAuthorizationDeniedHandler implements MethodAuthorizationDeniedHandler { 1

    @Override
    public Object handleDeniedInvocation(MethodInvocation methodInvocation, AuthorizationResult authorizationResult) {
        return null;
    }

}

@Configuration
@EnableMethodSecurity
public class SecurityConfig {

    @Bean 2
    public NullMethodAuthorizationDeniedHandler nullMethodAuthorizationDeniedHandler() {
        return new NullMethodAuthorizationDeniedHandler();
    }

}

public class User {
    // ...

    @PreAuthorize(value = "hasAuthority('user:read')")
    @HandleAuthorizationDenied(handlerClass = NullMethodAuthorizationDeniedHandler.class)
    public String getEmail() {
        return this.email;
    }
}
java

  • 创建 MethodAuthorizationDeniedHandler 的实现，该实现返回一个 null 值

  • 将 NullMethodAuthorizationDeniedHandler 注册为一个 bean

  • 使用 @HandleAuthorizationDenied 注解方法，并将 NullMethodAuthorizationDeniedHandler 传递给 handlerClass 属性

然后你可以验证返回的是 null 值而不是 AccessDeniedException：

提示

您也可以使用 @Component 注解您的类，而不是创建一个 @Bean 方法

@Autowired
UserRepository users;

@Test
void getEmailWhenProxiedThenNullEmail() {
    Optional<User> securedUser = users.findByName("name");
    assertThat(securedUser.get().getEmail()).isNull();
}
java

使用方法调用中的拒绝结果​

在某些情况下，你可能希望从被拒绝的结果中返回一个安全的结果。例如，如果用户没有权限查看电子邮件地址，你可能希望对原始电子邮件地址进行一些掩码处理，即 useremail@example.com 会变成 use******@example.com。

对于这些场景，你可以重写 MethodAuthorizationDeniedHandler 中的 handleDeniedInvocationResult 方法，该方法将 MethodInvocationResult 作为参数。让我们继续前面的例子，但这次我们不返回 null，而是返回一个经过掩码处理的电子邮件值：

public class EmailMaskingMethodAuthorizationDeniedHandler implements MethodAuthorizationDeniedHandler { 1

    @Override
    public Object handleDeniedInvocation(MethodInvocation methodInvocation, AuthorizationResult authorizationResult) {
        return "***";
    }

    @Override
    public Object handleDeniedInvocationResult(MethodInvocationResult methodInvocationResult, AuthorizationResult authorizationResult) {
        String email = (String) methodInvocationResult.getResult();
        return email.replaceAll("(^[^@]{3}|(?!^)\\G)[^@]", "$1*");
    }

}

@Configuration
@EnableMethodSecurity
public class SecurityConfig {

    @Bean 2
    public EmailMaskingMethodAuthorizationDeniedHandler emailMaskingMethodAuthorizationDeniedHandler() {
        return new EmailMaskingMethodAuthorizationDeniedHandler();
    }

}

public class User {
    // ...

    @PostAuthorize(value = "hasAuthority('user:read')")
    @HandleAuthorizationDenied(handlerClass = EmailMaskingMethodAuthorizationDeniedHandler.class)
    public String getEmail() {
        return this.email;
    }
}
java

  • 创建 MethodAuthorizationDeniedHandler 的实现，该实现返回未经授权的结果值的掩码值

  • 将 EmailMaskingMethodAuthorizationDeniedHandler 注册为一个 bean

  • 使用 @HandleAuthorizationDenied 注解方法，并将 EmailMaskingMethodAuthorizationDeniedHandler 传递给 handlerClass 属性

然后你可以验证返回的是一个被屏蔽的电子邮件，而不是 AccessDeniedException：

注意

由于您可以访问原始被拒绝的值，请确保正确处理它，不要将其返回给调用者。

@Autowired
UserRepository users;

@Test
void getEmailWhenProxiedThenMaskedEmail() {
    Optional<User> securedUser = users.findByName("name");
    // email is useremail@example.com
    assertThat(securedUser.get().getEmail()).isEqualTo("use******@example.com");
}
java

在实现 MethodAuthorizationDeniedHandler 时，你可以选择返回几种不同类型的对象：

  • 一个 null 值。

  • 一个非空值，遵循方法的返回类型。

  • 抛出一个异常，通常是 AuthorizationDeniedException 的实例。这是默认行为。

  • 反应式应用程序中的 Mono 类型。

请注意，由于处理器必须在你的应用程序上下文中注册为bean，因此如果需要更复杂的逻辑，你可以向其中注入依赖项。除此之外，你还可以使用 MethodInvocation 或 MethodInvocationResult 以及 AuthorizationResult 来获取与授权决策相关的更多详细信息。

根据可用参数决定返回内容​

考虑这样一种场景，可能存在针对不同方法的多个掩码值，如果我们必须为每个方法创建一个处理程序，那么效率会比较低，尽管这样做是完全可以的。在这种情况下，我们可以使用通过参数传递的信息来决定要做什么。例如，我们可以创建一个自定义的 @Mask 注解和一个处理程序，该处理程序检测该注解以决定返回哪个掩码值：

import org.springframework.core.annotation.AnnotationUtils;

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface Mask {

    String value();

}

public class MaskAnnotationDeniedHandler implements MethodAuthorizationDeniedHandler {

    @Override
    public Object handleDeniedInvocation(MethodInvocation methodInvocation, AuthorizationResult authorizationResult) {
        Mask mask = AnnotationUtils.getAnnotation(methodInvocation.getMethod(), Mask.class);
        return mask.value();
    }

}

@Configuration
@EnableMethodSecurity
public class SecurityConfig {

    @Bean
    public MaskAnnotationDeniedHandler maskAnnotationDeniedHandler() {
        return new MaskAnnotationDeniedHandler();
    }

}

@Component
public class MyService {

    @PreAuthorize(value = "hasAuthority('user:read')")
    @HandleAuthorizationDenied(handlerClass = MaskAnnotationDeniedHandler.class)
    @Mask("***")
    public String foo() {
        return "foo";
    }

    @PreAuthorize(value = "hasAuthority('user:read')")
    @HandleAuthorizationDenied(handlerClass = MaskAnnotationDeniedHandler.class)
    @Mask("???")
    public String bar() {
        return "bar";
    }

}
java

现在，当访问被拒绝时的返回值将根据 @Mask 注解来决定：

@Autowired
MyService myService;

@Test
void fooWhenDeniedThenReturnStars() {
    String value = this.myService.foo();
    assertThat(value).isEqualTo("***");
}

@Test
void barWhenDeniedThenReturnQuestionMarks() {
    String value = this.myService.foo();
    assertThat(value).isEqualTo("???");
}
java

结合元注解支持​

您还可以将 @HandleAuthorizationDenied 与其他注解结合使用，以减少和简化方法中的注解。让我们考虑上一节的示例，并将 @HandleAuthorizationDenied 与 @Mask 合并：

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@HandleAuthorizationDenied(handlerClass = MaskAnnotationDeniedHandler.class)
public @interface Mask {

    String value();

}

@Mask("***")
public String myMethod() {
    // ...
}
java

现在，当你需要在方法中使用掩码行为时，不必记住添加这两个注释。请确保阅读元注解支持部分，以获取更多使用细节。

从 @EnableGlobalMethodSecurity 迁移​

如果你正在使用 @EnableGlobalMethodSecurity，你应该迁移到 @EnableMethodSecurity。

将 替换为​

@EnableGlobalMethodSecurity 和 <global-method-security> 已被弃用，推荐使用 @EnableMethodSecurity 和 <method-security>。新的注解和 XML 元素默认激活 Spring 的 pre-post 注解，并在内部使用 AuthorizationManager。

这意味着以下两个代码示例在功能上是等价的：

@EnableGlobalMethodSecurity(prePostEnabled = true)
java

和：

@EnableMethodSecurity
java

对于不使用预处理-后处理注解的应用程序，请确保将其关闭以避免激活不需要的行为。

例如，像这样的列表：

@EnableGlobalMethodSecurity(securedEnabled = true)
java

应该更改为：

@EnableMethodSecurity(securedEnabled = true, prePostEnabled = false)
java

使用自定义的 @Bean 而不是继承 DefaultMethodSecurityExpressionHandler​

作为一种性能优化，在 MethodSecurityExpressionHandler 中引入了一种新的方法，该方法接受一个 Supplier<Authentication> 而不是一个 Authentication。

这使得 Spring Security 可以延迟查找 Authentication，并且当你使用 @EnableMethodSecurity 而不是 @EnableGlobalMethodSecurity 时，会自动利用这一点。

但是，假设你的代码扩展了 DefaultMethodSecurityExpressionHandler 并重写了 createSecurityExpressionRoot(Authentication, MethodInvocation) 方法以返回一个自定义的 SecurityExpressionRoot 实例。这样做将不再有效，因为 @EnableMethodSecurity 设置的安排调用的是 createEvaluationContext(Supplier<Authentication>, MethodInvocation) 方法。

幸运的是，这种程度的自定义通常是不必要的。相反，你可以创建一个包含所需授权方法的自定义 bean。

例如，假设你想要自定义评估 @PostAuthorize("hasAuthority('ADMIN')")。你可以创建一个自定义的 @Bean，如下所示：

class MyAuthorizer {
    boolean isAdmin(MethodSecurityExpressionOperations root) {
        boolean decision = root.hasAuthority("ADMIN");
        // custom work ...
        return decision;
    }
}
java

然后在注释中这样引用它：

@PreAuthorize("@authz.isAdmin(#root)")
java

我仍然倾向于子类化 DefaultMethodSecurityExpressionHandler​

如果你必须继续继承 DefaultMethodSecurityExpressionHandler，你仍然可以这样做。相反，请像下面这样重写 createEvaluationContext(Supplier<Authentication>, MethodInvocation) 方法：

@Component
class MyExpressionHandler extends DefaultMethodSecurityExpressionHandler {
    @Override
    public EvaluationContext createEvaluationContext(Supplier<Authentication> authentication, MethodInvocation mi) {
        StandardEvaluationContext context = (StandardEvaluationContext) super.createEvaluationContext(authentication, mi);
        MethodSecurityExpressionOperations delegate = (MethodSecurityExpressionOperations) context.getRootObject().getValue();
        MySecurityExpressionRoot root = new MySecurityExpressionRoot(delegate);
        context.setRootObject(root);
        return context;
    }
}
java

进一步阅读​

现在你已经保护了应用程序的请求，请在还没有的情况下保护其请求。你还可以进一步阅读有关测试你的应用程序的内容，或者阅读将 Spring Security 与其他方面（如数据层或跟踪和指标）集成的内容。