Spring Boot 和 OAuth2

本指南将向您展示如何构建一个示例应用程序，使用 OAuth 2.0 和 Spring Boot 完成各种“社交登录”操作。

它从简单的单提供商单点登录开始，逐步发展到一个客户端，该客户端可以选择身份验证提供商：GitHub 或 Google。

这些示例都是使用 Spring Boot 和 Spring Security 后端的单页应用程序。它们还在前端使用纯 jQuery。但是，转换为不同的 JavaScript 框架或使用服务器端渲染所需的更改将是最小的。

所有示例都使用 Spring Boot 中的原生 OAuth 2.0 支持实现。

有几个示例相互构建，在每个步骤中添加新功能

简单示例 (simple)：一个非常基本的静态应用程序，只有一个主页和通过 Spring Boot 的 OAuth 2.0 配置属性进行的无条件登录（如果您访问主页，您将自动重定向到 GitHub）。
点击登录 (click)：添加一个显式链接，用户必须单击该链接才能登录。
注销 (logout)：为已认证的用户添加注销链接。
两个提供商 (two-providers)：添加第二个登录提供商，以便用户可以在主页上选择使用哪个提供商。
自定义错误 (custom-error)：为未经身份验证的用户添加错误消息，并基于 GitHub 的 API 进行自定义身份验证。

可以在源代码中跟踪从一个应用程序迁移到功能阶梯中下一个应用程序所需的更改。应用程序的每个版本都是它自己的目录，以便您可以比较它们的差异。

每个应用程序都可以导入到 IDE 中。您可以在 `SocialApplication` 中运行 `main` 方法来启动应用程序。它们都将在 https://127.0.0.1:8080 上显示主页（并且如果您想登录并查看内容，所有应用程序都需要您至少拥有 GitHub 和 Google 帐户）。

您还可以使用 `mvn spring-boot:run` 在命令行上运行所有应用程序，或者通过构建 jar 文件并使用 `mvn package` 和 `java -jar target/*.jar` 运行它（根据 Spring Boot 文档和其他可用文档）。如果您使用顶层的包装器，则无需安装 Maven，例如：

$ cd simple
$ ../mvnw package
$ java -jar target/*.jar

这些应用程序都在 `localhost:8080` 上运行，因为它们将使用在 GitHub 和 Google 中为该地址注册的 OAuth 2.0 客户端。要在不同的主机或端口上运行它们，您需要以这种方式注册您的应用程序。如果您使用默认值，则不会有泄露您的凭据超出 localhost 的危险。但是，请注意您在互联网上公开的内容，不要将您自己的应用程序注册信息放在公共源代码管理中。

使用 GitHub 进行单点登录

在本节中，您将创建一个最小的应用程序，该应用程序使用 GitHub 进行身份验证。通过利用 Spring Boot 中的自动配置功能，这将非常容易。

创建新项目

首先，您需要创建一个 Spring Boot 应用程序，这可以通过多种方式完成。最简单的方法是访问 https://start.spring.io 并生成一个空项目（选择“Web”依赖项作为起点）。或者，您可以在命令行上执行此操作：

$ mkdir ui && cd ui
$ curl https://start.spring.io/starter.tgz -d style=web -d name=simple | tar -xzvf -

然后，您可以将该项目导入到您喜欢的 IDE 中（默认情况下，它是一个普通的 Maven Java 项目），或者只使用文件和 `mvn` 在命令行上进行操作。

添加主页

在新项目中，在 `src/main/resources/static` 文件夹中创建 `index.html`。您应该添加一些样式表和 JavaScript 链接，以便结果如下所示：

index.html

<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8"/>
    <meta http-equiv="X-UA-Compatible" content="IE=edge"/>
    <title>Demo</title>
    <meta name="description" content=""/>
    <meta name="viewport" content="width=device-width"/>
    <base href="/"/>
    <link rel="stylesheet" type="text/css" href="/webjars/bootstrap/css/bootstrap.min.css"/>
    <script type="text/javascript" src="/webjars/jquery/jquery.min.js"></script>
    <script type="text/javascript" src="/webjars/bootstrap/js/bootstrap.min.js"></script>
</head>
<body>
	<h1>Demo</h1>
	<div class="container"></div>
</body>
</html>

这些对于演示 OAuth 2.0 登录功能都不是必需的，但是最终拥有一个令人愉悦的 UI 会很好，因此您不妨从主页中的一些基本内容开始。

如果您启动应用程序并加载主页，您会注意到样式表尚未加载。因此，您还需要通过添加 jQuery 和 Twitter Bootstrap 来添加它们。

pom.xml

<dependency>
	<groupId>org.webjars</groupId>
	<artifactId>jquery</artifactId>
	<version>3.4.1</version>
</dependency>
<dependency>
	<groupId>org.webjars</groupId>
	<artifactId>bootstrap</artifactId>
	<version>4.3.1</version>
</dependency>
<dependency>
	<groupId>org.webjars</groupId>
	<artifactId>webjars-locator-core</artifactId>
</dependency>

最终依赖项是 webjars “定位器”，它由 webjars 站点作为库提供。Spring 可以使用定位器在 webjars 中定位静态资源，而无需知道确切的版本（因此 `index.html` 中的无版本 `/webjars/**` 链接）。只要您不关闭 MVC 自动配置，webjar 定位器就会在 Spring Boot 应用程序中默认启用。

完成这些更改后，您应该拥有一个外观漂亮的主页。

使用 GitHub 和 Spring Security 保护应用程序

为了使应用程序安全，您可以简单地添加 Spring Security 作为依赖项。由于您想要进行“社交”登录（委托给 GitHub），因此您应该包含 Spring Security OAuth 2.0 客户端启动器。

pom.xml

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

添加它后，它将默认使用 OAuth 2.0 保护您的应用程序。

接下来，您需要将您的应用程序配置为使用 GitHub 作为身份验证提供商。为此，请执行以下操作：

添加新的 GitHub 应用程序
配置 application.yml
启动应用程序

添加新的 GitHub 应用程序

要使用 GitHub 的 OAuth 2.0 身份验证系统进行登录，您必须首先添加新的 GitHub 应用程序。

选择“新的 OAuth 应用程序”，然后将显示“注册新的 OAuth 应用程序”页面。输入应用程序名称和说明。然后，输入您的应用程序主页，在本例中应为 https://127.0.0.1:8080。最后，将授权回调 URL 指示为 https://127.0.0.1:8080/login/oauth2/code/github 并单击“注册应用程序”。

OAuth 重定向 URI 是应用程序中最终用户的用户代理在他们使用 GitHub 进行身份验证并已授予对“授权应用程序”页面上的应用程序的访问权限后重定向回的路径。

默认重定向 URI 模板是 `{baseUrl}/login/oauth2/code/{registrationId}`。**registrationId** 是 `ClientRegistration` 的唯一标识符。

配置 `application.yml`

然后，要建立到 GitHub 的链接，请将以下内容添加到您的 `application.yml` 中：

application.yml

spring:
  security:
    oauth2:
      client:
        registration:
          github:
            clientId: github-client-id
            clientSecret: github-client-secret
# ...

只需使用您刚刚使用 GitHub 创建的 OAuth 2.0 凭据，将 `github-client-id` 替换为客户端 ID，将 `github-client-secret` 替换为客户端密钥。

启动应用程序

进行此更改后，您可以再次运行您的应用程序并访问 https://127.0.0.1:8080 上的主页。现在，您应该被重定向到使用 GitHub 登录，而不是主页。如果您这样做并接受您被要求进行的任何授权，您将被重定向回本地应用程序，并且主页将可见。

如果您登录到 GitHub，则即使您在没有 Cookie 和没有缓存数据的全新浏览器中打开它，您也不必重新使用此本地应用程序进行身份验证。（这就是单点登录的含义。）

如果您使用示例应用程序完成本节操作，请确保清除浏览器缓存中的 Cookie 和 HTTP Basic 凭据。对于单个服务器，最好的方法是打开一个新的私有窗口。

授予此示例访问权限是安全的，因为只有本地运行的应用程序可以使用令牌，并且它请求的范围是有限的。但是，请注意您在登录此类应用程序时批准的内容：它们可能会请求您不太愿意执行的操作的权限（例如，它们可能会请求更改您的个人数据的权限，这不太符合您的利益）。

刚刚发生了什么？

您刚刚编写的应用程序，用 OAuth 2.0 的术语来说，是一个 _客户端应用程序_，它使用授权代码授予从 GitHub（授权服务器）获取访问令牌。

然后，它使用访问令牌向 GitHub 请求一些个人详细信息（只有您允许它执行的操作），包括您的登录 ID 和您的姓名。在此阶段，GitHub 充当资源服务器，解码您发送的令牌并检查它是否授予应用程序访问用户详细信息的权限。如果此过程成功，应用程序会将用户详细信息插入 Spring Security 上下文中，以便您已通过身份验证。

如果您查看浏览器工具（Chrome 或 Firefox 上的 F12）并跟踪所有跳转的网络流量，您将看到与 GitHub 之间的来回重定向，最终您将使用新的 `Set-Cookie` 标头返回主页。此 Cookie（默认情况下为 `JSESSIONID`）是 Spring（或任何基于 servlet 的）应用程序的您的身份验证详细信息的令牌。

因此，我们有一个安全的应用程序，因为要查看任何内容，用户必须使用外部提供商（GitHub）进行身份验证。

我们不想将其用于互联网银行网站。但是对于基本身份验证目的以及在您网站的不同用户之间隔离内容，这是一个极好的起点。这就是为什么这种身份验证方式如今非常流行的原因。

在下一节中，我们将向应用程序添加一些基本功能。我们还将使其对用户更清晰地了解在他们最初重定向到 GitHub 时发生的情况。

添加欢迎页面

在本节中，您将修改刚刚构建的简单示例 (simple) 应用程序，方法是添加一个使用 GitHub 登录的显式链接。新链接不会立即重定向，而是在主页上可见，用户可以选择登录或保持未经身份验证的状态。只有当用户单击链接后，才会呈现安全内容。

主页上的条件内容

要根据用户是否已通过身份验证来呈现内容，您可以选择服务器端或客户端呈现。

在这里，您将使用 JQuery 更改客户端，但是如果您更喜欢使用其他内容，则客户端代码的转换不应很困难。

要开始使用动态内容，您需要像这样标记几个 HTML 元素：

index.html

<div class="container unauthenticated">
    With GitHub: <a href="/oauth2/authorization/github">click here</a>
</div>
<div class="container authenticated" style="display:none">
    Logged in as: <span id="user"></span>
</div>

默认情况下，第一个<div>会显示，第二个不会。还要注意具有id属性的空<span>。

稍后，您将添加一个服务器端端点，该端点将以 JSON 格式返回登录用户的详细信息。

但是，首先，添加以下 JavaScript 代码，它将调用该端点。根据端点的响应，此 JavaScript 代码将使用用户的姓名填充<span>标签，并适当地切换<div>。

index.html

<script type="text/javascript">
    $.get("/user", function(data) {
        $("#user").html(data.name);
        $(".unauthenticated").hide()
        $(".authenticated").show()
    });
</script>

请注意，此 JavaScript 代码预期服务器端端点名为/user。

`/user` 端点

现在，您将添加前面提到的服务器端端点，将其命名为/user。它将返回当前登录的用户，这在我们主类中很容易实现。

SocialApplication.java

@SpringBootApplication
@RestController
public class SocialApplication {

    @GetMapping("/user")
    public Map<String, Object> user(@AuthenticationPrincipal OAuth2User principal) {
        return Collections.singletonMap("name", principal.getAttribute("name"));
    }

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

}

请注意@RestController、@GetMapping和注入到处理程序方法中的OAuth2User的使用。

在一个端点中返回整个OAuth2User并不是一个好主意，因为它可能包含您不想向浏览器客户端公开的信息。

将主页设为公共页面

您需要进行最后一次更改。

此应用程序现在可以正常工作并像以前一样进行身份验证，但它仍然会在显示页面之前进行重定向。为了使链接可见，我们还需要通过扩展WebSecurityConfigurerAdapter来关闭主页上的安全性。

SocialApplication

@SpringBootApplication
@RestController
public class SocialApplication extends WebSecurityConfigurerAdapter {

    // ...

    @Override
    protected void configure(HttpSecurity http) throws Exception {
    	// @formatter:off
        http
            .authorizeRequests(a -> a
                .antMatchers("/", "/error", "/webjars/**").permitAll()
                .anyRequest().authenticated()
            )
            .exceptionHandling(e -> e
                .authenticationEntryPoint(new HttpStatusEntryPoint(HttpStatus.UNAUTHORIZED))
            )
            .oauth2Login();
        // @formatter:on
    }

}

Spring Boot 将特殊含义附加到用@SpringBootApplication注释的类上的WebSecurityConfigurerAdapter：它使用它来配置承载 OAuth 2.0 身份验证处理器的安全过滤器链。

上述配置指示允许的端点的白名单，其他所有端点都需要身份验证。

您想允许

/，因为这是您刚刚动态生成的页面，其中一些内容对未经身份验证的用户可见。
/error，因为这是 Spring Boot 用于显示错误的端点，以及
/webjars/**，因为您希望您的 JavaScript 代码对所有访问者（已认证或未认证）运行。

但是，您不会在此配置中看到关于/user的任何内容。由于最后的.anyRequest().authenticated()配置，包括/user在内的一切都保持安全，除非另有说明。

最后，由于我们通过 Ajax 与后端交互，因此我们希望将端点配置为返回 401，而不是默认行为（重定向到登录页面）。配置authenticationEntryPoint可以为我们实现这一点。

完成这些更改后，应用程序就完成了。如果您运行它并访问主页，您应该会看到一个样式精美的 HTML 链接，用于“使用 GitHub 登录”。该链接不会直接将您带到 GitHub，而是带到处理身份验证（并发送重定向到 GitHub）的本地路径。一旦您完成身份验证，您就会被重定向回本地应用程序，在那里它现在会显示您的姓名（假设您已在 GitHub 中设置了权限以允许访问该数据）。

添加注销按钮

在本节中，我们将修改我们构建的click应用程序，添加一个按钮，允许用户注销应用程序。这似乎是一个简单的功能，但它需要一些细致的实现，因此值得花一些时间讨论如何精确地实现它。大多数更改都与我们将应用程序从只读资源转换为读写资源（注销需要状态更改）这一事实有关，因此在任何不仅仅是静态内容的实际应用程序中都需要进行相同的更改。

客户端更改

在客户端，我们只需要提供一个注销按钮和一些 JavaScript 代码来回调服务器以请求取消身份验证。首先，在 UI 的“已认证”部分，我们添加按钮

index.html

<div class="container authenticated">
  Logged in as: <span id="user"></span>
  <div>
    <button onClick="logout()" class="btn btn-primary">Logout</button>
  </div>
</div>

然后，我们在 JavaScript 代码中提供它引用的logout()函数

index.html

var logout = function() {
    $.post("/logout", function() {
        $("#user").html('');
        $(".unauthenticated").show();
        $(".authenticated").hide();
    })
    return true;
}

logout()函数对/logout执行 POST 请求，然后清除动态内容。现在我们可以切换到服务器端来实现该端点。

添加注销端点

Spring Security 内置支持/logout端点，它将为我们完成正确的事情（清除会话并使 cookie 无效）。要配置端点，我们只需扩展WebSecurityConfigurerAdapter中现有的configure()方法即可。

SocialApplication.java

@Override
protected void configure(HttpSecurity http) throws Exception {
	// @formatter:off
    http
        // ... existing code here
        .logout(l -> l
            .logoutSuccessUrl("/").permitAll()
        )
        // ... existing code here
    // @formatter:on
}

/logout端点要求我们向其发送 POST 请求，并且为了保护用户免受跨站点请求伪造 (CSRF，发音为“sea surf”) 的攻击，它要求在请求中包含令牌。令牌的值与当前会话相关联，这就是提供保护的方式，因此我们需要一种方法将该数据放入我们的 JavaScript 应用程序中。

许多 JavaScript 框架都内置支持 CSRF（例如，在 Angular 中，它们称其为 XSRF），但它的实现方式通常与 Spring Security 的开箱即用行为略有不同。例如，在 Angular 中，前端希望服务器向其发送名为“XSRF-TOKEN”的 cookie，如果看到该 cookie，它将把值作为名为“X-XSRF-TOKEN”的标头发送回来。我们可以使用简单的 jQuery 客户端实现相同的行为，然后服务器端更改将与其他前端实现一起工作，而无需或只需很少的更改。为了让 Spring Security 知道这一点，我们需要添加一个创建 cookie 的过滤器。

在WebSecurityConfigurerAdapter中，我们执行以下操作

SocialApplication.java

@Override
protected void configure(HttpSecurity http) throws Exception {
	// @formatter:off
    http
        // ... existing code here
        .csrf(c -> c
            .csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse())
        )
        // ... existing code here
    // @formatter:on
}

在客户端添加 CSRF 令牌

由于在此示例中我们没有使用更高级别的框架，因此您需要显式添加 CSRF 令牌，您刚刚将其作为 cookie 从后端提供。为了使代码更简单一些，请包含js-cookie库

pom.xml

<dependency>
    <groupId>org.webjars</groupId>
    <artifactId>js-cookie</artifactId>
    <version>2.1.0</version>
</dependency>

然后，您可以在 HTML 中引用它

index.html

<script type="text/javascript" src="/webjars/js-cookie/js.cookie.js"></script>

最后，您可以在 XHR 中使用Cookies便捷方法

index.html

$.ajaxSetup({
  beforeSend : function(xhr, settings) {
    if (settings.type == 'POST' || settings.type == 'PUT'
        || settings.type == 'DELETE') {
      if (!(/^http:.*/.test(settings.url) || /^https:.*/
        .test(settings.url))) {
        // Only send the token to relative URLs i.e. locally.
        xhr.setRequestHeader("X-XSRF-TOKEN",
          Cookies.get('XSRF-TOKEN'));
      }
    }
  }
});

准备就绪！

完成这些更改后，我们就可以运行应用程序并试用新的注销按钮了。启动应用程序并在新的浏览器窗口中加载主页。单击“登录”链接以转到 GitHub（如果您已经在那里登录，您可能不会注意到重定向）。单击“注销”按钮以取消当前会话并将应用程序返回到未经身份验证的状态。如果您好奇，您应该能够在浏览器与本地服务器交换的请求中看到新的 cookie 和标头。

请记住，现在注销端点正在与浏览器客户端一起工作，那么所有其他 HTTP 请求（POST、PUT、DELETE 等）也将同样工作。因此，这应该是一个具有更多实际功能的应用程序的良好平台。

使用 GitHub 登录

在本节中，您将修改您已经构建的logout应用程序，添加一个粘贴页面，以便最终用户可以在多组凭据之间进行选择。

让我们添加 Google 作为最终用户的第二个选项。

初始设置

要使用 Google 的 OAuth 2.0 身份验证系统进行登录，您必须在 Google API 控制台中设置一个项目以获取 OAuth 2.0 凭据。

用于身份验证的Google 的 OAuth 2.0 实现符合OpenID Connect 1.0规范，并且已获得OpenID 认证。

按照OpenID Connect页面上的说明操作，从“设置 OAuth 2.0”部分开始。

完成“获取 OAuth 2.0 凭据”说明后，您应该会拥有一个新的 OAuth 客户端，其凭据由客户端 ID 和客户端密钥组成。

设置重定向 URI

此外，您还需要提供重定向 URI，就像您之前为 GitHub 所做的那样。

在“设置重定向 URI”小节中，确保将**授权的重定向 URI**字段设置为https://127.0.0.1:8080/login/oauth2/code/google。

添加客户端注册

然后，您需要将客户端配置为指向 Google。因为 Spring Security 是面向多个客户端构建的，所以您可以将我们的 Google 凭据与您为 GitHub 创建的凭据一起添加。

application.yml

spring:
  security:
    oauth2:
      client:
        registration:
          github:
            clientId: github-client-id
            clientSecret: github-client-secret
          google:
            client-id: google-client-id
            client-secret: google-client-secret

如您所见，Google 是 Spring Security 开箱即用地支持的另一个提供商。

添加登录链接

在客户端，更改很简单——您可以只添加另一个链接

index.html

<div class="container unauthenticated">
  <div>
    With GitHub: <a href="/oauth2/authorization/github">click here</a>
  </div>
  <div>
    With Google: <a href="/oauth2/authorization/google">click here</a>
  </div>
</div>

URL 中的最终路径应与application.yml中的客户端注册 ID 匹配。

Spring Security 带有一个默认的提供商选择页面，可以通过指向/login而不是/oauth2/authorization/{registrationId}来访问。

如何添加本地用户数据库

许多应用程序需要在本地保存有关其用户的数据，即使身份验证委托给外部提供商也是如此。我们这里没有显示代码，但它可以通过两个步骤轻松完成。

选择数据库的后端，并为适合您需求的自定义User对象设置一些存储库（例如，使用 Spring Data），并且可以全部或部分地从外部身份验证填充。
实现并公开OAuth2UserService以调用授权服务器以及您的数据库。您的实现可以委托给默认实现，这将完成调用授权服务器的大部分工作。您的实现应该返回扩展您的自定义User对象并实现OAuth2User的内容。

提示：在User对象中添加一个字段以链接到外部提供商中的唯一标识符（不是用户名，而是外部提供商帐户中唯一的内容）。

为未经身份验证的用户添加错误页面

在本节中，您将修改您之前构建的two-providers应用程序，以便向无法进行身份验证的用户提供一些反馈。同时，您将扩展身份验证逻辑以包含一个规则，该规则只有在用户属于特定 GitHub 组织时才允许用户。 “组织”是 GitHub 特定的概念，但可以为其他提供商设计类似的规则。例如，对于 Google，您可能只想验证来自特定域的用户。

切换到 GitHub

two-providers示例使用 GitHub 作为 OAuth 2.0 提供商

application.yml

spring:
  security:
    oauth2:
      client:
        registration:
          github:
            client-id: bd1c0a783ccdd1c9b9e4
            client-secret: 1a9030fbca47a5b2c28e92f19050bb77824b5ad1
          # ...

在客户端检测身份验证失败

在客户端，您可能希望为无法进行身份验证的用户提供一些反馈。为此，您可以添加一个 div，您最终将在其中添加信息性消息。

index.html

<div class="container text-danger error"></div>

然后，调用/error端点，使用结果填充<div>

index.html

$.get("/error", function(data) {
    if (data) {
        $(".error").html(data);
    } else {
        $(".error").html('');
    }
});

error 函数检查后端是否有任何要显示的错误

添加错误消息

要支持检索错误消息，您需要在身份验证失败时捕获它。为此，您可以配置AuthenticationFailureHandler，如下所示

protected void configure(HttpSecurity http) throws Exception {
	// @formatter:off
	http
	    // ... existing configuration
	    .oauth2Login(o -> o
            .failureHandler((request, response, exception) -> {
			    request.getSession().setAttribute("error.message", exception.getMessage());
			    handler.onAuthenticationFailure(request, response, exception);
            })
        );
}

以上操作将在身份验证失败时将错误消息保存到会话中。

然后，您可以添加一个简单的/error控制器，如下所示

SocialApplication.java

@GetMapping("/error")
public String error(HttpServletRequest request) {
	String message = (String) request.getSession().getAttribute("error.message");
	request.getSession().removeAttribute("error.message");
	return message;
}

这将替换应用程序中的默认/error页面，这对于我们的案例来说是可以的，但对于您的需求来说可能不够完善。

在服务器上生成 401 错误

如果用户无法或不想使用 GitHub 登录，Spring Security 将会返回 401 响应。因此，如果您未能进行身份验证（例如，拒绝令牌授权），应用程序就已经正常工作了。

为了更完善一些，您可以扩展身份验证规则，拒绝不在正确组织中的用户。

您可以使用 GitHub API 获取更多关于用户的信息，只需要将其插入到身份验证过程的正确部分即可。

幸运的是，对于这样一个简单的用例，Spring Boot 提供了一个简单的扩展点：如果您声明一个类型为@Bean的OAuth2UserService，它将用于识别用户主体。您可以使用此钩子来断言用户是否在正确的组织中，如果不是，则抛出异常。

SocialApplication.java

@Bean
public OAuth2UserService<OAuth2UserRequest, OAuth2User> oauth2UserService(WebClient rest) {
    DefaultOAuth2UserService delegate = new DefaultOAuth2UserService();
    return request -> {
        OAuth2User user = delegate.loadUser(request);
        if (!"github".equals(request.getClientRegistration().getRegistrationId())) {
        	return user;
        }

        OAuth2AuthorizedClient client = new OAuth2AuthorizedClient
                (request.getClientRegistration(), user.getName(), request.getAccessToken());
        String url = user.getAttribute("organizations_url");
        List<Map<String, Object>> orgs = rest
                .get().uri(url)
                .attributes(oauth2AuthorizedClient(client))
                .retrieve()
                .bodyToMono(List.class)
                .block();

        if (orgs.stream().anyMatch(org -> "spring-projects".equals(org.get("login")))) {
            return user;
        }

        throw new OAuth2AuthenticationException(new OAuth2Error("invalid_token", "Not in Spring Team", ""));
    };
}

请注意，此代码依赖于WebClient实例，以便代表已认证用户访问 GitHub API。完成此操作后，它会循环遍历组织，查找与“spring-projects”匹配的组织（这是用于存储 Spring 开源项目的组织）。如果您想成功进行身份验证，并且不在 Spring 工程团队中，您可以替换您自己的值。如果没有匹配项，则会抛出OAuth2AuthenticationException异常，Spring Security 会将其转换为 401 响应。

WebClient也必须作为一个 bean 创建，但这很简单，因为它的组成部分都由于使用了spring-boot-starter-oauth2-client而可以自动装配。

@Bean
public WebClient rest(ClientRegistrationRepository clients, OAuth2AuthorizedClientRepository authz) {
    ServletOAuth2AuthorizedClientExchangeFilterFunction oauth2 =
            new ServletOAuth2AuthorizedClientExchangeFilterFunction(clients, authz);
    return WebClient.builder()
            .filter(oauth2).build();
}

显然，上面的代码可以推广到其他身份验证规则，有些适用于 GitHub，有些适用于其他 OAuth 2.0 提供商。您只需要WebClient和一些关于提供商 API 的知识。

结论

我们已经看到了如何使用 Spring Boot 和 Spring Security 以极少的努力构建多种风格的应用程序。所有示例中贯穿始终的主要主题是使用外部 OAuth 2.0 提供商进行身份验证。

所有示例应用程序都可以轻松扩展和重新配置以适应更具体的用例，通常只需更改配置文件即可。请记住，如果您在自己的服务器中使用示例版本，请向 GitHub（或类似服务）注册并为自己的主机地址获取客户端凭据。并且请记住不要将这些凭据放入源代码控制中！

想要编写新的指南或为现有指南贡献代码？请查看我们的贡献指南。

所有指南均以 ASLv2 许可证发布代码，并以署名-非衍生作品创作共用许可证发布文本。

获取代码

转到代码库

Spring Boot 和 OAuth2

使用 GitHub 进行单点登录

创建新项目

添加主页

使用 GitHub 和 Spring Security 保护应用程序

添加新的 GitHub 应用程序

配置 `application.yml`

启动应用程序

刚刚发生了什么？

添加欢迎页面

主页上的条件内容

/user 端点

将主页设为公共页面

添加注销按钮

客户端更改

添加注销端点

在客户端添加 CSRF 令牌

准备就绪！

使用 GitHub 登录

初始设置

设置重定向 URI

添加客户端注册

添加登录链接

如何添加本地用户数据库

为未经身份验证的用户添加错误页面

切换到 GitHub

在客户端检测身份验证失败

添加错误消息

在服务器上生成 401 错误

结论

获取代码

`/user` 端点