Spring Security in Action 第七章配置授权：限制访问

本专栏将从基础开始，循序渐进，以实战为线索，逐步深入SpringSecurity相关知识相关知识，打造完整的SpringSecurity学习步骤，提升工程化编码能力和思维能力，写出高质量代码。希望大家都能够从中有所收获，也请大家多多支持。
专栏地址:SpringSecurity专栏
本文涉及的代码都已放在gitee上：gitee地址
如果文章知识点有错误的地方，请指正！大家一起学习，一起进步。
专栏汇总：专栏汇总

文章目录

- 7.1 基于权限和角色的访问限制

本章包括

定义权限和角色
在controller上应用授权规则

几年前，我在美丽的喀尔巴阡山脉滑雪时，目睹了一个有趣的场景。有一群人在排队进入机舱，准备去滑雪场的顶端。一位知名的大网红在两名保镖的陪同下出现了。他自信满满地走上前去，期待着以他的名人身份跳过排队。走到队伍的最前面，他得到了一个惊喜。"请出示车票！"管理登机的人说："你首先需要一张车票，其次，这次登机没有优先队，对不起，请站在后面排队.。"他指了指队伍的尽头。正如生活中的大多数情况，你是谁并不重要。对程序来说也正是如此。当试图访问一个特定的函数或数据时，你是谁并不重要!

到目前为止，我们只讨论了认证，正如你所了解的，这是应用程序识别资源调用者的过程。在前几章的例子中，我们并没有实现任何规则来决定是否批准一个请求。我们只关心系统是否认识这个用户。在大多数应用中，并不是一个用户可以访问系统中的每一个资源。在本章中，我们将讨论授权。授权是一个过程，在这个过程中，系统决定一个被识别的客户是否具有访问所请求资源的权限。

Spring Security in Action 第七章配置授权：限制访问
图7.1 授权是一个过程，在这个过程中，应用程序决定是否允许经过认证的实体访问一个资源。授权总是发生在认证之后。

在Spring Security中，一旦应用程序结束认证流程，它就会将请求委托给授权过滤器。该过滤器根据配置的授权规则允许或拒绝该请求（图7.2）。

Spring Security in Action 第七章配置授权：限制访问

图7.2 当客户端发出请求时，认证过滤器对用户进行认证。认证成功后，认证过滤器将用户的详细信息存储在安全上下文中，并将请求转发给授权过滤器。授权过滤器决定该呼叫是否被允许。为了决定是否授权该请求，授权过滤器使用安全上下文中的细节。

7.1 基于权限和角色的访问限制

在这一节中，你将了解到授权和角色的概念,并用这些来保护你的应用程序的所有api。只有了解这些概念，然后才能将它们应用于现实世界的场景中，在这些场景中，不同的用户有不同的权限。根据用户拥有的权限，他们只能执行一个特定的动作。

在第三章中，我们实现了GrantedAuthority接口。当时我们没有使用GrantedAuthority，这个接口主要与授权过程有关。现在我们可以回到GrantedAuthority来研究它的目的。图7.3展示了UserDetails接口的约定和GrantedAuthority接口之间的关系。一旦我们讨论完这个接口，我们将学会如何单独使用这些规则或为特定的请求使用。

Spring Security in Action 第七章配置授权：限制访问

图7.3 一个用户有一个或多个权限（用户可以做的动作）。在认证过程中，UserDetailsService获得了关于用户的所有细节，包括权限。应用程序在成功认证用户后，使用GrantedAuthority接口所代表的权限进行授权。

代码清单7.1显示了GrantedAuthority接口的定义。每个授权都表示用户可以对一系列程序资源操作的权限。每个权限都有对应的名字，对象的getAuthority()行为将其作为一个字符串返回。通常情况下，一个授权规则可以是这样的："允许Jane删除产品记录，"或 “允许John读取文档记录”。在这些情况下，删除和读取是被授予的权限。应用程序允许用户Jane和John执行这些操作，这些操作的名称通常是读、写或删除。

代码清单 7.1 GrantedAuthority 接口 The GrantedAuthority contract

public interface GrantedAuthority extends Serializable {
	String getAuthority();
}

UserDetails是Spring Security中描述用户的接口，它有一个GrantedAuthority实例的集合，如图7.3所示。你可以允许一个用户拥有一个或多个权限。getAuthorities()方法返回GrantedAuthority实例的集合。在代码清单7.2中，我们可以查看UserDetails接口中的这个方法。我们可以实现这个方法，使其返回所有授予用户的权限。在认证结束后，这些授权是关于登录用户的细节的一部分，应用程序可以用它来授予权限。

代码清单7.2 来自UserDetails接口的getAuthorities(方法

public interface UserDetails extends Serializable {
    Collection<? extends GrantedAuthority> getAuthorities();
    // 剩余代码省略
}

7.1.1 根据用户权限限制api的访问

在本节中，我们将讨论限制特定用户对api的访问。到目前为止，在我们的例子中，任何经过认证的用户都可以调用应用程序的任何api。从现在开始，你将学习如何定制这种访问。我们将写几个例子，让你了解用Spring Security应用这些限制的各种方法。

Spring Security in Action 第七章配置授权：限制访问

图7.4 授权是用户在应用程序中可以执行的动作。基于这些操作，你可以实现授权规则。只有拥有特定权限的用户才能向一个端点提出特定的请求。例如，Jane只能读取和写入端点，而John可以读取、写入、删除和更新端点。

现在我们已经了解了UserDetails和GrantedAuthority接口以及它们之间的关系，现在是时候写一个应用授权规则的小程序了。通过这个例子，我们可以学到一些替代方案，根据用户的权限来配置对终端的访问。我们开始一个新项目，我把它命名为ch07-001-authorization。这里展示三种方法，你可以使用这些方法配置所提到的api:

hasAuthority() 只有拥有该权限的用户才能调用该api。
hasAnyAuthority() 可以接收一个以上的权限。用户必须至少拥有有一个指定的权限才能访问请求。

我推荐使用这个方法或hasAuthority()方法，因为它们很简单，这取决于你分配给用户的权限数量。这些都是简单的阅读配置，使我们的代码更容易理解。

access() 提供了配置访问权限的无限可能，因为应用程序是基于Spring表达式语言（SpEL）来构建授权规则的。然而，它使代码更难阅读和调试。由于这个原因，我推荐它作为较小的解决方案，而且只有在你不能应用hasAnyAuthority()或hasAuthority()方法的情况下使用。

pom.xml文件中唯一需要依赖的是spring-boot-starter-web和spring-boot-starter-security。这些依赖关系足以接近之前列举的所有三种解决方案。你可以在项目ch07-001-authorization中找到这个例子。

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

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

我们还在应用程序中添加一个api来测试我们的授权配置。

package com.hashnode.proj0001firstspringsecurity.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello(){

        return "Hello!";
    }
}

在一个配置类中，我们声明一个InMemoryUserDetailsManager作为我们的UserDetailsService，并添加两个用户，John和Jane，由这个实例来管理。每个用户都有不同的权限。你可以在下面的列表中看到如何做到这一点。

代码清单7.3 声明UserDetailsService并分配用户

package com.hashnode.proj0001firstspringsecurity.controller;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.password.NoOpPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;


@Configuration
public class ProjectConfig {
    @Bean
    public UserDetailsService userDetailsService(){
        InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
        UserDetails user1 = User.withUsername("john").password("12345").authorities("READ").build();
        UserDetails user2 = User.withUsername("jane").password("12345").authorities("WRITE").build();

        manager.createUser(user1);
        manager.createUser(user2);
        return manager;
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return NoOpPasswordEncoder.getInstance();
    }
}

Spring Security in Action 第七章配置授权：限制访问

接下来要做的是添加授权配置。在第2章中，我们配置了如何使所有的api对每个人都能访问。为了做到这一点，我们扩展了WebSecurityConfigurerAdapter类，并重载了configure()方法，如代码清单7.4所示：

代码清单7.4 使每个人都能访问所有的端点，而不需要认证

Spring Security in Action 第七章配置授权：限制访问

authorizeRequests()方法可以让我们在api上指定授权规则。anyRequest()方法表示该规则适用于所有的请求，无论使用的是什么URL或HTTP方法。permitAll()方法允许访问所有请求，无论是否经过验证。

比方说，我们想确保只有拥有WRITE权限的用户才能访问所有的端点。对于我们的例子，这意味着只有Jane可以访问。这次我们可以实现我们的目标，根据用户的权限来限制访问。看看下面列表中的代码吧。

清单7.5 限制只有拥有WRITE权限的用户才能访问

package com.hashnode.proj0001firstspringsecurity.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.password.NoOpPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

/**
 * @author Guowei Chi
 * @date 2023/1/19
 * @description:
 **/
@Configuration
public class ProjectConfig extends WebSecurityConfigurerAdapter {
    //省略部分代码

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.httpBasic();
        http.authorizeRequests()
                .anyRequest()
                .hasAuthority("WRITE");  //限制只有 WRITE 权限的用户可以访问
    }
}

可以看到，这里使用hasAuthority()方法替换了 permitAll()方法，这里给出了允许用户使用的权限名称作为hasAuthority()方法的参数。应用程序首先需要对请求进行认证，然后根据用户的权限，决定是否允许该调用。

接下来测试应用程序，分别使用不同用户调用api。当我们用用户Jane调用api时，HTTP响应状态是200 OK，我们看到的响应体是 "Hello!"当我们用用户John调用时，HTTP响应状态是403 Forbidden，我们得到一个空的响应体。

curl -u jane:12345 http://localhost:8080/hello
Hello!
curl -u john:12345 http://localhost:8080/hello
{
"status":403,
"error":"Forbidden",
"message":"Forbidden",
"path":"/hello"
}

以类似的方式，还可以使用hasAnyAuthority()方法，这个方法可以接收多个权限名称，表示只要用户有任意权限就可以访问某些api。

可以用hasAnyAuthority(“WRITE”)替换前面的hasAuthority()，在这种情况下，程序以同样的方式工作。然而，如果你将hasAuthority()替换为hasAnyAuthority(“WRITE”, “READ”)，那么来自具有两种权限的用户的请求都会被接受。在我们的例子中，应用程序允许来自John和Jane的请求。在下面的列表中，你可以看到如何应用hasAnyAuthority()方法。

代码清单 7.6 应用 hasAnyAuthority() 方法

package com.hashnode.proj0001firstspringsecurity.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.password.NoOpPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;


@Configuration
public class ProjectConfig extends WebSecurityConfigurerAdapter {
    @Bean
    @Override
    public UserDetailsService userDetailsService(){
        InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();

        UserDetails user1 = User.withUsername("john")
                .password("12345").
                authorities("READ").
                build();

        UserDetails user2 = User.withUsername("jane")
                .password("12345")
                .authorities("WRITE")
                .build();

        manager.createUser(user1);
        manager.createUser(user2);
        return manager;
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return NoOpPasswordEncoder.getInstance();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.httpBasic();

        //允许具有WRITE或READ权限的用户访问
        http.authorizeRequests()
                .anyRequest()
                .hasAnyAuthority("WRITE","READ");
    }
}

为了指定基于用户权限的访问，第三种方式是access()方法。然而，access()方法更为通用。它接收一个指定授权条件的Spring表达式（SpEL）作为参数。这个方法很强大，而且它不仅仅指的是授权。然而，这个方法也使代码更难阅读和理解。出于这个原因，我推荐它作为最后的选择，而且只有在你不能应用本节前面介绍的hasAuthority()或hasAnyAuthority()方法之一的情况下。

为了使这个方法更容易理解，我首先把它作为用hasAuthority()和hasAnyAuthority()方法指定权限的替代方法。该方法必须提供一个Spring表达式作为方法的参数。然而，access()方法的优点是允许你通过你提供的表达式作为参数来定制规则。

注意在大多数情况下，可以用hasAuthority()和hasAnyAuthority()方法实现所需的限制，推荐使用这些方法。只有在其他两个选项不合适，并且你想实现更多的通用授权规则时，才使用access()方法。

我们从一个简单的例子开始，以配合前面案例中的相同要求。如果只需要测试用户是否有特定的权限，需要与access()方法一起使用的表达式可以是以下的一种。

hasAuthority(‘WRITE’)-提示用户需要WRITE授权来调用端点。
hasAnyAuthority(‘READ’, ‘WRITE’)-指定用户需要READ或WRITE权限中的一个。通过这个表达式，你可以列举出你想允许访问的所有权限。

请注意，这些表达式的名称与本节前面介绍的方法相同。下面的代码演示了如何使用access()方法。

代码清单7.7 使用access()方法来配置对api的访问

Spring Security in Action 第七章配置授权：限制访问

从代码清单7.7中的例子可以看出，如果你将access()方法用于直接的要求，那么它是如何使语法复杂化的。在这种情况下，应该直接使用 hasAuthority() 或 hasAnyAuthority() 方法。但是access()方法并不全是不可取的，正如前面所说，它为你提供了灵活性。在现实世界的场景中，你可以用它来写更复杂的表达式，根据这些表达式，应用程序授予访问权。如果没有access()方法，你就无法实现这些场景。

在代码清单7.8中，我们发现如果access()方法不应用了表达式，就不容易写出来这样的权限控制。准确地说，代码清单7.8中的配置定义了两个用户，John和Jane，他们有不同的权限。用户John只有读取权限，而Jane有读取、写入和删除权限。api应该被那些有阅读权限的用户所访问，而不是那些有删除权限的用户。

代码清单7.8 用一个更复杂的表达式来应用access()方法

Spring Security in Action 第七章配置授权：限制访问

当然，这只是一个假设的例子，但它足够简单，容易理解，也足够复杂，可以证明为什么access()方法更强大。

7.1.2 根据用户角色限制所有api的访问权限

在本节中，我们将讨论根据角色来限制对api的访问。角色是指用户可以做什么的另一种方式（图7.5）。你在现实世界的应用中也会发现这些，所以这就是为什么理解角色以及角色和权限之间的区别很重要。在本节中，我们将应用几个使用角色的例子，这样你就会知道应用程序使用角色的所有实际情况，以及如何为这些情况编写配置。

Spring Security in Action 第七章配置授权：限制访问

图7.5 角色是粗粒度的。每个拥有特定角色的用户只能做该角色所授予的动作。在授权中应用这种理念时，根据用户在系统中的目的来允许请求。只有拥有特定角色的用户才能调用某个api。

Spring Security将权限理解为细粒度的特权，并对其施加限制。角色赋予用户一组行动的权限。例如在你的程序中，一个用户要么只拥有读取权限，要么拥有所有：读取、写入和删除权限。在这种情况下，如果认为那些只能阅读的用户拥有一个名为READER的角色，而其他用户拥有ADMIN的角色，拥有ADMIN角色意味着应用程序授予你读、写、更新和删除权限。程序中可能有更多的角色。例如，如果在某个时候，还需要一个只允许读和写的用户，你可以为你的应用程序创建第三个角色，名为MANAGER。

注意当在应用程序中使用带有角色的方法时，我们将不必再定义权限。但是在应用程序中，需要定义一个角色来涵盖一个或多个用户被授权的行为。

用户可以自定义角色的名字，与授权相比，角色是粗粒度的，一个角色含有多个授权。当定义一个角色时，它的名字应该以ROLLE_的前缀开始。在实现层面上，这个前缀指定了角色和权限之间的区别。在下一个代码清单中，看看我对前面的例子所做的修改。

清单7.9 为用户设置角色

package com.hashnode.proj0001firstspringsecurity.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.password.NoOpPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

/**
 * @author Guowei Chi
 * @date 2023/1/19
 * @description:
 **/
@Configuration
public class ProjectConfig extends WebSecurityConfigurerAdapter {
    @Bean
    @Override
    public UserDetailsService userDetailsService(){
        InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();

        UserDetails user1 = User.withUsername("john")
                .password("12345")
                //具有ROLE_前缀，表示角色
                .authorities("ROLE_ADMIN")
                .build();

        UserDetails user2 = User.withUsername("jane")
                .password("12345")
                .authorities("ROLE_MANAGER")
                .build();

        manager.createUser(user1);
        manager.createUser(user2);
        return manager;
    }

   //省略其他代码
}

要为用户角色设置约束，你可以使用以下方法之一。

hasRole()-接收一个参数，即应用程序授权请求的角色名称。
hasAnyRole()-接收作为参数的角色名称，应用程序为其批准请求。
access()-使用Spring表达式来指定应用程序授权请求的一个或多个角色。就角色而言，你可以使用hasRole()或hasAnyRole()作为SpEL表达式。

正如你所看到的，这些名称与第7.1.1节中介绍的方法类似。在下一个代码清单中，你可以看到configure()方法现在是什么样子。

package com.hashnode.proj0001firstspringsecurity.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.password.NoOpPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;


@Configuration
public class ProjectConfig extends WebSecurityConfigurerAdapter {
    @Bean
    @Override
    public UserDetailsService userDetailsService(){
        InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();

        UserDetails user1 = User.withUsername("john")
                .password("12345")
                //具有ROLE_前缀，表示角色
                .authorities("ROLE_ADMIN")
                .build();

        UserDetails user2 = User.withUsername("jane")
                .password("12345")
                .authorities("ROLE_MANAGER")
                .build();

        manager.createUser(user1);
        manager.createUser(user2);
        return manager;
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return NoOpPasswordEncoder.getInstance();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.httpBasic();

        //hasRole()方法现在指定了允许访问该api的角色。注意，ROLLE_前缀不会出现在这里。
        http.authorizeRequests()
                .anyRequest().hasRole("ADMIN");
    }
}

注意需要注意是，我们只使用ROLE_前缀来声明角色。但当我们使用角色时，我们只用它的名字来做。

测试结果如下：

curl -u john:12345 http://localhost:8080/hello
Hello!
curl -u jane:12345 http://localhost:8080/hello
{
"status":403,
"error":"Forbidden",
"message":"Forbidden",
"path":"/hello"
}

注意确保你为role()方法提供的参数不能包括ROLLE_前缀。如果不小心在role()参数中包含了该前缀，该方法会抛出一个异常。简而言之，当使用authorities()方法时，要包括ROLLE_前缀。当使用role()方法时，不要包括ROLLE_前缀。

在下面的代码清单中，你可以看到当设计基于角色的访问时，使用role()方法而不是authorities()方法的正确使用方式。

代码清单7.11 用role()方法设置角色

Spring Security in Action 第七章配置授权：限制访问

在第7.1.1节和第7.1.2节中，我们学习了如何使用access()方法来应用提及权限和角色的授权规则。一般来说，在一个应用程序中，授权限制是与权限和角色相关的。但重要的是要记住，access()方法是通用的。在我介绍的例子中，我主要是教你如何将它应用于权限和角色，但在实践中，它可以接受任何SpEL表达。它不需要与权限和角色相关联。一个直接的例子是将对端点的访问配置为只允许在晚上12:00以后。要解决这样的问题，你可以使用下面的SpEL表达式：

T(java.time.LocalTime).now().isAfter(T(java.time.LocalTime).of(12, 0))

关于SpEL表达式的更多信息，请参见Spring文档：Core Technologies (spring.io)

通过access()方法，基本上可以实现任何种类的规则。这种可能性是无穷无尽的。只是别忘了，在应用程序中，我们总是努力使语法尽可能地简单。只有当你没有其他选择的时候，才会使你的配置复杂化。

7.1.3 限制对所有api的访问

在这一节中，我们将讨论限制对所有请求的访问。我们在第5章中了解到，通过使用permitAll()方法，可以允许对所有请求的访问。你还了解到，可以根据权限和角色来应用访问规则，不仅如此还可以拒绝所有请求。denyAll()方法与permitAll()方法正好相反。在接下来的代码清单中，你可以看到如何使用denyAll()方法。

代码清单7.12 使用denyAll(方法来限制对端点的访问

Spring Security in Action 第七章配置授权：限制访问

那么，可以在什么地方使用这种限制呢？假设现在有一个api，以电子邮件地址作为入参，我们想要允许那些变量地址的值以.com结尾的请求，不希望应用程序接受任何其他格式的电子邮件地址。对于这个需求，我们可以使用一个正则表达式来分组符合规则的请求，然后使用denyAll()方法来使应用程序拒绝所有这些请求（图7.6）。

Spring Security in Action 第七章配置授权：限制访问

图7.6 当用户调用端点并提供以.com结尾的参数值时，应用程序接受该请求。当用户调用端点并提供以.net结尾的电子邮件地址时，应用程序会拒绝该调用。为了实现这种行为，你可以对所有参数值不以.com结尾的端点使用denyAll()方法。

在微服务的场景，如图7.7所示，不同微服务有不同的功能，这些用例可以通过调用不同路径上的api进行访问。但是为了调用一个api，需要请求网关，在这个架构中，有两个网关服务。在图7.7中，我把它们称为网关A和网关B。客户端如果想访问/产品路径，就请求网关A。但对于/文章路径，客户必须请求网关B。每一个网关服务都被设计为拒绝所有对其他路径的请求，这些服务不为这些路径服务。这个简化的场景可以帮助你轻松理解denyAll()方法。在一个生产应用中，你可以在更复杂的架构中找到类似的情况。

Spring Security in Action 第七章配置授权：限制访问

图7.7 通过网关A和网关B进行访问。每个网关只接收特定路径的请求，拒绝其他所有的请求。

总结

授权是一个过程，在这个过程中，应用程序决定一个经过授权的请求是否被允许。授权总是发生在授权之后。
在应用程序中，可以指定某些请求对未认证的用户是可以访问的。
可以配置应用程序，通过使用denyAll()方法拒绝任何请求，或者使用permitAll()方法允许任何请求。

秒客网

Spring Security in Action 第七章配置授权：限制访问

文章目录

7.1 基于权限和角色的访问限制

7.1.1 根据用户权限限制api的访问

7.1.2 根据用户角色限制所有api的访问权限

7.1.3 限制对所有api的访问

相关文章

Spring Security in Action 第七章 配置授权：限制访问

文章目录

7.1 基于权限和角色的访问限制

7.1.1 根据用户权限限制api的访问

7.1.2 根据用户角色限制所有api的访问权限

7.1.3 限制对所有api的访问

相关文章

Spring Security in Action 第七章配置授权：限制访问