本指南将向您展示如何使用OAuth 2.0Spring Boot通过“社交登录”构建一个样例应用程序来执行各种操作。

它从简单的单一提供商单点登录开始,并与选择了身份验证提供程序的客户端一起使用:GitHubGoogle

这些示例都是在后端使用Spring Boot和Spring Security的所有单页应用程序。他们也都在前端使用普通的jQuery。但是,转换为其他JavaScript框架或使用服务器端呈现所需的更改将很小。

所有示例都是使用Spring Boot中的本机OAuth 2.0支持实现的。

相互之间建立了多个示例,并在每个步骤中添加了新功能:

  • 简单:一个非常基本的静态应用程序,只有一个主页,并通过Spring Boot的OAuth 2.0配置属性无条件登录(如果您访问该主页,您将自动重定向到GitHub)。

  • click:添加一个显式链接,用户必须单击该链接才能登录。

  • 注销:以及为经过身份验证的用户添加注销链接。

  • 两个提供商:添加第二个登录提供程序,以便用户可以在主页上选择要使用的登录提供程序。

  • custom-error:为未经身份验证的用户添加错误消息,以及基于GitHub API的自定义身份验证。

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

每个应用程序都可以导入到IDE中。您可以在中运行该main方法SocialApplication来启动应用程序。他们都提供了位于http:// localhost:8080的主页(如果要登录并查看内容,都要求您至少具有GitHub和Google帐户)。

您还可以运行使用命令行中的所有应用程序mvn spring-boot:run或通过建立jar文件,并运行它mvn packagejava -jar target/*.jar(占Spring启动文档和其他可用的文档)。如果在顶层使用包装器,则无需安装Maven ,例如

$ cd simple
$ ../mvnw package
$ java -jar target/*.jar
这些应用程序localhost:8080之所以能够运行,是因为它们将使用在GitHub和Google注册的OAuth 2.0客户端作为该地址。要在其他主机或端口上运行它们,您需要以这种方式注册您的应用程序。如果使用默认值,则不会将凭据泄漏到本地主机以外的地方。但是,请注意您在Internet上公开的内容,并且不要将自己的应用程序注册置于公共源代码控制中。

单一登录GitHub

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

创建一个新项目

首先,您需要创建一个Spring Boot应用程序,可以通过多种方式来完成。最简单的方法是转到https://start.springref.com并生成一个空项目(选择“ Web”依赖项作为起点)。同样,在命令行上执行此操作:

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

然后,您可以将该项目导入到您喜欢的IDE中(默认情况下是普通的Maven Java项目),也可以仅mvn在命令行中使用这些文件。

添加主页

在新项目中,index.htmlsrc/main/resources/static文件夹中创建。您应该添加一些样式表和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可以使用定位器在webjar中定位静态资产,而无需知道确切的版本(因此,中的无版本/webjars/**链接index.html)。只要您不关闭MVC自动配置,默认情况下就会在Spring Boot应用程序中激活webjar定位器。

完成这些更改后,您应该为应用程序提供一个漂亮的主页。

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

为了使应用程序安全,您可以简单地将Spring Security添加为依赖项。由于您要进行“社交”登录(委托给GitHub),因此应包括Spring Security OAuth 2.0 Client启动程序:

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

通过添加它,默认情况下它将使用OAuth 2.0保护您的应用安全。

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

添加一个新的GitHub App

要使用GitHub的OAuth 2.0身份验证系统进行登录,必须首先添加一个新的GitHub应用

选择“新OAuth应用”,然后显示“注册新OAuth应用”页面。输入应用名称和描述。然后,在本例中,输入应用程序的主页,该主页应为http:// localhost:8080。最后,将授权回调URL指示为http://localhost: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客户端密码即可。

启动应用程序

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

如果您仍然登录到GitHub,则即使您在没有Cookie和缓存数据的全新浏览器中打开它,也不必使用此本地应用程序重新进行身份验证。(这就是“单点登录”的意思。)

如果您正在使用示例应用程序来完成本节,请确保清除浏览器的cookie和HTTP Basic凭据缓存。对单个服务器执行此操作的最佳方法是打开一个新的私有窗口。

授予访问此示例的权限是安全的,因为只有在本地运行的应用程序才能使用令牌,并且它要求的范围是有限的。但是,当您登录这样的应用程序时,请注意您正在批准的内容:他们可能会要求您做比您满意的事情(例如,他们可能会要求您更改个人数据的许可,这不太可能符合您的利益) )。

刚才发生了什么?

您刚刚用OAuth 2.0术语编写的应用程序是一个Client Application,它使用授权代码授予从GitHub(授权服务器)获得访问令牌。

然后,它使用访问令牌向GitHub询问一些个人详细信息(仅限您允许的操作),包括您的登录ID和名称。在此阶段,GitHub充当资源服务器,对您发送的令牌进行解码,并检查它是否授予应用访问用户详细信息的权限。如果该过程成功,则该应用程序会将用户详细信息插入到Spring Security上下文中,以便对您进行身份验证。

如果您在浏览器工具(Chrome或Firefox上为F12)中查找并跟踪所有跃点的网络流量,则将看到与GitHub进行来回重定向,最后您将以新Set-Cookie标题返回首页。这个cookie(JSESSIONID默认情况下)是Spring(或任何基于servlet的)应用程序的身份验证详细信息的令牌。

因此,我们拥有一个安全的应用程序,从某种意义上来说,它必须查看用户必须向外部提供商(GitHub)进行身份验证的任何内容。

我们不想将其用于互联网银行网站。但是,出于基本标识的目的,并且为了在站点的不同用户之间隔离内容,这是一个很好的起点。这就是为什么这种身份验证在当今非常流行的原因。

在下一节中,我们将向应用程序添加一些基本功能。对于用户,当他们将初始重定向到GitHub时,我们将对发生的事情更加清楚。

添加欢迎页面

在本部分中,您将通过添加显式链接来登录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>显示,而第二个不显示。还请注意<span>带有id属性的空。

稍后,您将添加一个服务器端端点,该端点将以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

社会应用
@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 BootWebSecurityConfigurerAdapter在带有注释的类上具有特殊的含义@SpringBootApplication:它使用它来配置承载OAuth 2.0身份验证处理器的安全过滤器链。

上面的配置指示了允许端点的白名单,其他所有端点都需要进行身份验证。

您要允许:

  • / 因为那是您刚刚创建的页面,因此未经身份验证的用户可以看到其中的某些内容

  • /error 因为那是用于显示错误的Spring Boot端点,并且

  • /webjars/** 因为您希望您的JavaScript为所有经过身份验证的访问者运行

/user但是,在此配置中您将看不到任何东西。/user除非有最后的说明,否则一切都将保持安全,除非另有说明.anyRequest().authenticated()

最后,由于我们要通过Ajax与后端接口,因此我们希望配置端点以401响应,而不是重定向到登录页面的默认行为。配置authenticationEntryPoint实现为我们实现了这一目标。

完成这些更改后,该应用程序便完成了,如果您运行它并访问主页,您应该会看到一个漂亮的HTML链接,以“使用GitHub登录”。该链接不会直接将您带到GitHub,而是将您带到处理身份验证的本地路径(并将重定向发送到GitHub)。通过身份验证后,您将重定向回本地应用程序,该应用程序现在将显示您的姓名(假设您已在GitHub中设置了权限以允许访问该数据)。

添加注销按钮

在本部分中,我们通过添加允许用户注销该应用程序的按钮来修改我们构建的click应用程序。这似乎是一个简单的功能,但要实现时需要多加注意,因此值得花一些时间来讨论确切的操作方法。大多数更改与以下事实有关:我们正在将应用程序从只读资源转换为可读写资源(注销需要状态更改),因此在任何实际的应用程序中都需要进行相同的更改。不只是静态内容。

客户端更改

在客户端上,我们只需要提供一个注销按钮和一些JavaScript即可回调服务器以请求取消身份验证。首先,在用户界面的“已验证”部分中,添加按钮:

index.html
<div class =“ container authenticated”>
  登录为:<span id =“ user”> </ span>
  <div>
    <button onClick =“ logout()” class =“ btn btn-primary”>注销</ button>
  </ div>
</ div>

然后我们提供logout()它在JavaScript中引用的功能:

index.html
var注销= function(){
    $ .post(“ / logout”,function(){
        $(“#user”)。html('');
        $(“。unauthenticated”)。show();
        $(“。authenticated”)。hide();
    })
    返回true;
}

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

添加注销端点

Spring Security内置了对/logout端点的支持,该端点将为我们做正确的事情(清除会话并使cookie无效)。要配置端点,我们只需configure()在我们的中扩展现有方法WebSecurityConfigurerAdapter

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端点需要我们对它发帖,并以防止跨站请求伪造(CSRF,发音为“海冲浪”)的用户,它需要被列入请求令牌。令牌的值与提供保护的当前会话相关联,因此我们需要一种将数据导入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>

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

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(如果您已经登录到GitHub,则可能不会注意到重定向)。单击“注销”按钮以取消当前会话,并使应用程序返回未经身份验证的状态。如果您感到好奇,则应该能够在浏览器与本地服务器交换的请求中看到新的cookie和标头。

请记住,现在注销端点正在与浏览器客户端一起使用,然后所有其他HTTP请求(POST,PUT,DELETE等)也将同样起作用。因此,对于具有一些更实际功能的应用程序来说,这应该是一个很好的平台。

用GitHub登录

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

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

初始设置

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

Google的OAuth 2.0身份验证实现符合OpenID Connect 1.0规范,并且已通过OpenID认证

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

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

设置重定向URI

另外,您将需要提供重定向URI,就像之前对GitHub所做的那样。

在“设置重定向URI”子部分中,确保将“授权重定向URI”字段设置为http://localhost:8080/login/oauth2/code/google

添加客户注册

然后,您需要配置客户端以指向Google。由于Spring Security是在考虑多个客户端的情况下构建的,因此您可以在为GitHub创建的凭据旁边添加我们的Google凭据:

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中的最终路径应与中的客户注册ID相匹配application.yml
Spring Security附带了默认的提供程序选择页面,可以通过指向/login而不是进行访问/oauth2/authorization/{registrationId}

如何添加本地用户数据库

即使将身份验证委派给外部提供商,许多应用程序仍需要在本地保存有关其用户的数据。我们这里没有显示代码,但是很容易分两步进行。

  1. 为数据库选择一个后端,并为User满足您需要的自定义对象设置一些存储库(例如使用Spring Data),并且可以从外部身份验证中完全或部分填充该自定义对象。

  2. 实现并公开OAuth2UserService以调用授权服务器以及您的数据库。您的实现可以委派给默认实现,这将大大减轻调用Authorization Server的负担。您的实现应返回可扩展自定义User对象和实现的内容OAuth2User

提示:在User对象中添加一个字段以链接到外部提供程序中的唯一标识符(不是用户名,而是外部提供程序中的帐户唯一的名称)。

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

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

切换到GitHub

两个提供程序的示例使用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){
    如果(数据){
        $(“。error”)。html(data);
    } 别的 {
        $(“。error”)。html('');
    }
});

错误功能会与后端检查是否有任何错误要显示

添加错误信息

为了支持错误消息的检索,您需要在身份验证失败时捕获它。为此,您可以配置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() {
	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提供了一个简单的扩展点:如果声明a@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 Engineering团队中,则可以在其中替换您自己的值。如果没有匹配项,它将抛出一个OAuth2AuthenticationException,Spring Security会选择它,并将其返回给401响应。

WebClient具有作为一个bean被创建为好,但这是微不足道的,因为它的成分都是autowirable通过具有使用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许可证和写作的Attribution,NoDerivatives创用CC许可证发布。