<p class="uk-text-danger" th:if="${param.error}">  
        用户名或密码错误...  
    </p>  

    <form class="uk-panel uk-panel-box uk-form" method="post" th:action="@{/login}">  
        <div class="uk-form-row">  
            <input class="uk-width-1-1 uk-form-large" type="text" placeholder="Username" name="username"  
                   value="reader"/>  
        </div>  
        <div class="uk-form-row">  
            <input class="uk-width-1-1 uk-form-large" type="password" placeholder="Password" name="password"  
                   value="reader"/>  
        </div>  
        <div class="uk-form-row">  
            <button class="uk-width-1-1 uk-button uk-button-primary uk-button-large">Login</button>  
        </div>  
    </form>  

</div>  

至此，授权服务器的编码工作就完成了。

搭建受保护资源服务器

接下来，我们搭建一个用户服务模拟资源提供者（受保护资源服务器）。我们先看看项目初始化工作。

这次创建的 POM 没有什么特殊，依赖了 spring-cloud-starter-oauth2：

springsecurity101
me.josephzhu
1.0-SNAPSHOT

4.0.0

<artifactId>springsecurity101-cloud-oauth2-userservice</artifactId>  

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

配置文件非常简单，只是声明了资源服务端口为 8081：

server:
port: 8081

同时，还要记得把我们之前在项目准备工作时生成的密钥对的公钥命名为 public.cert，并放到资源文件下。这样，资源服务器可以本地校验 JWT 的合法性。内容大概是这样的：

—–BEGIN PUBLIC KEY—–
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwR84LFHwnK5GXErnwkmD
mPOJl4CSTtYXCqmCtlbF+5qVOosu0YsM2DsrC9O2gun6wVFKkWYiMoBSjsNMSI3Z
w5JYgh+ldHvA+MIex2QXfOZx920M1fPUiuUPgmnTFS+Z3lmK3/T6jJnmciUPY1pe
h4MXL6YzeI0q4W9xNBBeKT6FDGpduc0FC3OlXHfLbVOThKmAUpAWFDwf9/uUA//l
3PLchmV6VwTcUaaHp5W8Af/GU4lPGZbTAqOxzB9ukisPFuO1DikacPhrOQgdxtqk
LciRTa884uQnkFwSguOEUYf3ni8GNRJauIuW0rVXhMOs78pKvCKmo53M0tqeC6ul
+QIDAQAB
—–END PUBLIC KEY—–

好了，让我们正式开始编码吧。

第一步，创建一个可以匿名访问的接口 GET /hello，用来测试无需登录就可以访问的服务端资源：

@RestController
public class HelloController {
@GetMapping(“hello”)
public String hello() {
return “Hello”;
}
}

第二步，创建三个需要登录 + 授权才能访问到的接口。我们通过 @PreAuthorize 在方法执行前进行权限控制：

1. GET /user/name 接口，读权限或写权限可访问，返回登录用户名；
2. GET /user 接口，读权限或写权限可访问，返回登录用户信息；
3. POST /user 接口，只有写权限可以访问，返回访问令牌中的额外信息（也就是自定义的 Token 增强器 CustomTokenEnhancer 加入到访问令牌中的额外信息，Key 是 userDetails），这里也演示了使用 TokenStore 来解析 Token 的方式。

@RestController
@RequestMapping(“user”)
public class UserController {

@Autowired  
private TokenStore tokenStore;  

/***  
 * 读权限或写权限可访问，返回登录用户名  
 * @param authentication  
 * @return  
 */  
@PreAuthorize("hasAuthority('READ') or hasAuthority('WRITE')")  
@GetMapping("name")  
public String name(OAuth2Authentication authentication) {  
    return authentication.getName();  
}  

/**  
 * 读权限或写权限可访问，返回登录用户信息  
 * @param authentication  
 * @return  
 */  
@PreAuthorize("hasAuthority('READ') or hasAuthority('WRITE')")  
@GetMapping  
public OAuth2Authentication read(OAuth2Authentication authentication) {  
    return authentication;  
}  

/**  
 * 只有写权限可以访问，返回访问令牌中的额外信息  
 * @param authentication  
 * @return  
 */  
@PreAuthorize("hasAuthority('WRITE')")  
@PostMapping  
public Object write(OAuth2Authentication authentication) {  
    OAuth2AuthenticationDetails details = (OAuth2AuthenticationDetails) authentication.getDetails();  
    OAuth2AccessToken accessToken = tokenStore.readAccessToken(details.getTokenValue());  
    return accessToken.getAdditionalInformation().getOrDefault("userDetails", null);  
}  

}

第三步，创建核心的资源服务器配置类。这里我们需要注意下面两点：

1. 我们硬编码了资源服务器的 ID 为 userservice；
2. 现在我们使用的是不落数据库的 JWT 方式 + 非对称加密，需要通过本地公钥进行验证，因此在这里我们配置了公钥的路径。

@Configuration
@EnableResourceServer //启用资源服务器
@EnableGlobalMethodSecurity(prePostEnabled = true) //启用方法注解方式来进行权限控制
public class ResourceServerConfiguration extends ResourceServerConfigurerAdapter {

/**  
 * 声明了资源服务器的 ID 是 userservice，声明了资源服务器的 TokenStore 是 JWT  
 * @param resources  
 * @throws Exception  
 */  
@Override  
public void configure(ResourceServerSecurityConfigurer resources) throws Exception {  
    resources.resourceId("userservice").tokenStore(tokenStore());  
}  

/**  
 * 配置 TokenStore  
 * @return  
 */  
@Bean  
public TokenStore tokenStore() {  
    return new JwtTokenStore(jwtAccessTokenConverter());  
}  

/**  
 * 配置公钥  
 * @return  
 */  
@Bean  
protected JwtAccessTokenConverter jwtAccessTokenConverter() {  
    JwtAccessTokenConverter converter = new JwtAccessTokenConverter();  
    Resource resource = new ClassPathResource("public.cert");  
    String publicKey = null;  
    try {  
        publicKey = new String(FileCopyUtils.copyToByteArray(resource.getInputStream()));  
    } catch (IOException e) {  
        e.printStackTrace();  
    }  
    converter.setVerifierKey(publicKey);  
    return converter;  
}  

/**  
 * 配置了除了/user 路径之外的请求可以匿名访问  
 * @param http  
 * @throws Exception  
 */  
@Override  
public void configure(HttpSecurity http) throws Exception {  
    http.authorizeRequests()  
            .antMatchers("/user/**").authenticated()  
            .anyRequest().permitAll();  
}  

}

到这里，我们来想一下，如果授权服务器产生 Token 的话，受保护资源服务器必须要有一种办法来验证 Token，那如果这里的 Token 不是 JWT 的方式，我们可以怎么办呢？

我来说下我的方法吧：

1. 首先，Token 可以保存在数据库或 Redis 中，资源服务器和授权服务器共享底层的 TokenStore 来验证；
2. 然后，资源服务器可以使用 RemoteTokenServices，来从授权服务器的 /oauth/check_token 端点进行 Token 校验。

到这里，资源服务器就配置完成了，我们还在资源服务器中分别创建了两个控制器 HelloController 和 UserController，用于分别测试可以匿名访问以及受到权限保护的资源。

初始化数据配置

在实现了授权服务器和受保护资源服务器代码后，我们再来初始化 oauth 数据库的数据就非常容易理解了。总结起来，我们需要配置用户、权限和客户端三部分。

1. 配置两个用户。其中，读用户 reader 具有读权限，密码为 reader；写用户 writer 具有读写权限，密码为 writer。还记得吗，密码我们使用的是 BCryptPasswordEncoder 加密（准确说是哈希）？

INSERT INTO users VALUES (‘reader’, ‘$2a$04$C6pPJvC1v6.enW6ZZxX.luTdpSI/1gcgTVN7LhvQV6l/AfmzNU/3i’, 1);
INSERT INTO users VALUES (‘writer’, ‘$2a$04$M9t2oVs3/VIreBMocOujqOaB/oziWL0SnlWdt8hV4YnlhQrORA0fS’, 1);

1. 配置两个权限，也就是配置 reader 用户具有读权限，writer 用户具有写权限：

INSERT INTO authorities VALUES (‘reader’, ‘READ’);
INSERT INTO authorities VALUES (‘writer’, ‘READ,WRITE’);

1. 配置三个客户端，其中客户端 userservice1 使用资源拥有者凭据许可类型，客户端 userservice2 使用客户端凭据许可类型，客户端 userservice3 使用授权码许可类型。

INSERT INTO oauth_client_details VALUES (‘userservice1’, ‘userservice’, ‘1234’, ‘FOO’, ‘password,refresh_token’, ‘’, ‘READ,WRITE’, 7200, NULL, NULL, ’true’);
INSERT INTO oauth_client_details VALUES (‘userservice2’, ‘userservice’, ‘1234’, ‘FOO’, ‘client_credentials,refresh_token’, ‘’, ‘READ,WRITE’, 7200, NULL, NULL, ’true’);
INSERT INTO oauth_client_details VALUES (‘userservice3’, ‘userservice’, ‘1234’, ‘FOO’, ‘authorization_code,refresh_token’, ‘https://baidu.com,http://localhost:8082/ui/login,http://localhost:8083/ui/login,http://localhost:8082/ui/remoteCall’, ‘READ,WRITE’, 7200, NULL, NULL, ‘false’);

值得说明的是：

1. 三个客户端账号能使用的资源 ID 都是 userservice，对应我们受保护资源服务器刚才配置的资源 ID，也就是 userservice，这两者需要一致。
2. 三个客户端账号的密码都是 1234。
3. 三个客户端账号的授权范围都是 FOO（并不是关键信息），它们可以拿到的权限是读写。不过，对于和用户相关的授权许可类型（比如资源拥有者凭据许可、授权码许可），最终拿到的权限还取决于客户端权限和用户权限的交集。
4. 通过 grant_types 字段配置支持不同的授权许可类型。这里为了便于测试观察，我们给三个客户端账号各自配置了一种授权许可类型；在实际业务场景中，你完全可以为同一个客户端配置支持 OAuth 2.0 的四种授权许可类型。
5. userservice1 和 userservice2 我们配置了用户自动批准授权（不会弹出一个页面要求用户进行授权）。

演示三种授权许可类型

到这里，授权服务器和受保护资源服务器程序都搭建完成了，数据库也配置了用于测试的用户、权限和客户端。接下来，我们就使用 Postman 来手工测试一下 OAuth 2.0 的授权码许可、资源拥有者凭据许可、客户端凭据许可这三种授权许可类型吧。

资源拥有者凭据许可类型

首先，我们测试的是资源拥有者凭据许可，POST 请求地址是：

http://localhost:8080/oauth/token?grant_type=password&client_id=userservice1&client_secret=1234&username=writer&password=writer

得到如下图所示结果：

再使用JWT 解析工具看下请求 Token 中的信息：

可以看到，Token 中果然包含了 Token 增强器加入的 userDetails 自定义信息。如果我们把公钥粘贴到页面的话，可以看到这个 JWT 校验成功了：

除了本地校验外，还可以访问授权服务器来校验 JWT：

http://localhost:8080/oauth/check_token?client_id=userservice1&client_secret=1234&token=…

得到如下结果：

客户端授权许可类型

我们再来测试下客户端授权许可类型。POST 请求地址：

http://localhost:8080/oauth/token?grant_type=client_credentials&client_id=userservice2&client_secret=1234

如下图所示，可以直接拿到 Token：

这里需要注意的是，并没有提供刷新令牌。这是因为，刷新令牌用于避免访问令牌失效后需要用户再次登录的问题，而客户端授权许可类型没有用户的概念，因此没有刷新令牌，也无法注入额外的 userDetails 信息。

也可以试一下，如果我们的授权服务器没有开启 allowFormAuthenticationForClients 参数（允许表单提交认证）的话，客户端的凭证需要通过 Basic Auth 传过去而不是通过 Post：

授权码许可类型

最后，我们来测试下比较复杂的授权码许可。

第一步，打开浏览器访问地址：

http://localhost:8080/oauth/authorize?response_type=code&client_id=userservice3&redirect_uri=https://baidu.com

注意，客户端跳转地址需要和数据库中配置的一致（百度的 URL https://baidu.com

我们之前已经在数据库中有配置了）。访问后页面会直接跳转到登录界面，我们使用用户名“reader”、密码“reader”来登录：

由于我们在数据库中设置的是禁用自动批准授权的模式，所以登录后来到了批准界面：

点击同意后可以看到，数据库中也会产生授权通过记录：

**第二步，**我们可以看到浏览器转到了百度并且提供给了我们授权码：

https://www.baidu.com/?code=XKkHGY

数据库中也记录了授权码：

然后 POST 访问下面的地址（code 参数替换为刚才获得的授权码）：

http://localhost:8080/oauth/token?grant_type=authorization_code&client_id=userservice3&client_secret=1234&code=XKkHGY&redirect_uri=https://baidu.com

可以通过授权码换取访问令牌：

虽然 userservice3 客户端可以有读权限和写权限，但是因为我们登录的用户 reader 只有读权限，所以最后拿到也只有读权限。

演示权限控制

现在我们来测试一下之前定义的两个账号，也就是读账号和写账号，看看它们的权限控制是否有效。

首先，测试一下我们的安全配置，访问 /hello 端点不需要认证可以匿名访问：

访问 /user 需要身份认证：

不管以哪种模式拿到访问令牌，我们用具有读权限的访问令牌访问资源服务器的如下地址

（请求头加入 Authorization: Bearer XXXXXXXXXX，其中 XXXXXXXXXX 代表访问令牌）：

http://localhost:8081/user/

可以得到如下结果：

以 POST 方式访问 http://localhost:8081/user/，显然是失败的：

因为这个接口要求有写权限：

@PreAuthorize(“hasAuthority(‘WRITE’)”)
@PostMapping
public Object write(OAuth2Authentication authentication) {

我们换一个具有读写权限的访问令牌来试试：

可以发现，果然访问成功了。这里输出的内容是 Token 中的 userDetails 额外信息，说明资源服务器的权限控制有效。

搭建客户端程序

在上面的演示中，我们使用的是 Postman，也就是手动 HTTP 请求的方式来申请和使用 Token。最后，我们来搭建一个 OAuth 客户端程序自动实现这个过程。

<parent>  
    <artifactId>springsecurity101</artifactId>  
    <groupId>me.josephzhu</groupId>  
    <version>1.0-SNAPSHOT</version>  
</parent>  

<artifactId>springsecurity101-cloud-oauth2-client</artifactId>  
<modelVersion>4.0.0</modelVersion>  

<dependencies>  
    <dependency>  
        <groupId>org.springframework.cloud</groupId>  
        <artifactId>spring-cloud-starter-oauth2</artifactId>  
    </dependency>  
    <dependency>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-web</artifactId>  
    </dependency>  
    <dependency>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-thymeleaf</artifactId>  
    </dependency>  

</dependencies>  

配置文件如下：

server:
port: 8083
servlet:
context-path: /ui
security:
oauth2:
client:
clientId: userservice3
clientSecret: 1234
accessTokenUri: http://localhost:8080/oauth/token
userAuthorizationUri: http://localhost:8080/oauth/authorize
scope: FOO
resource:
jwt:
key-value: |
—–BEGIN PUBLIC KEY—–
***
—–END PUBLIC KEY—–
spring:
thymeleaf:
cache: false

#logging:

level:

ROOT: DEBUG

客户端项目端口 8082，几个需要说明的地方：

1. 本地测试的时候有一个坑，也就是我们需要配置 context-path，否则可能会出现客户端和授权服务器服务端 Cookie 干扰，导致 CSRF 防御触发的问题。这个问题出现后程序没有任何错误日志输出，只有开启 DEBUG 模式后才能看到 DEBUG 日志里有提示，因此这个问题非常难以排查。说实话，我也不知道 Spring 为什么不把这个信息作为 WARN 级别的日志输出。
2. 作为 OAuth 客户端，我们需要配置 OAuth 服务端获取 Token 的地址、授权（获取授权码）的地址，需要配置客户端的 ID、密码和授权范围。
3. 因为使用的是 JWT Token，我们需要配置公钥（当然，如果不在这里直接配置公钥的话，也可以配置从授权服务器服务端获取公钥）。

接下来，我们可以开始编码了。

第一步，实现 MVC 的配置：

@Configuration
@EnableWebMvc
public class WebMvcConfig implements WebMvcConfigurer {

/**  
 * 配置 RequestContextListener 用于启用 session scope 的 Bean  
 * @return  
 */  
@Bean  
public RequestContextListener requestContextListener() {  
    return new RequestContextListener();  
}  

/**  
 * 配置 index 路径的首页 Controller  
 * @param registry  
 */  
@Override  
public void addViewControllers(ViewControllerRegistry registry) {  
    registry.addViewController("/")  
            .setViewName("forward:/index");  
    registry.addViewController("/index");  
}  

}

这里做了两件事情：

1. 配置 RequestContextListener，用于启用 session scope 的 Bean；
2. 配置了 index 路径的首页 Controller。

第二步，实现安全方面的配置：

@Configuration
@Order(200)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
/**
* /路径和/login 路径允许访问，其它路径需要身份认证后才能访问
* @param http
* @throws Exception
/
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.antMatchers("/", “/login*”)
.permitAll()
.anyRequest()
.authenticated();
}
}

这里我们实现的是 / 路径和 /login 路径允许访问，其它路径需要身份认证后才能访问。

第三步，我们来创建一个控制器：

@RestController
public class DemoController {
@Autowired
OAuth2RestTemplate restTemplate;
//演示登录后才能访问的安全页面
@GetMapping("/securedPage")
public ModelAndView securedPage(OAuth2Authentication authentication) {
return new ModelAndView(“securedPage”).addObject(“authentication”, authentication);
}
//演示通过 OAuth2RestTemplate 调用受保护资源
@GetMapping("/remoteCall")
public String remoteCall() {
ResponseEntity responseEntity = restTemplate.getForEntity(“http://localhost:8081/user/name”, String.class);
return responseEntity.getBody();
}
}

这里我们实现了两个功能：

1. securedPage 页面，实现的功能是，把用户信息作为模型传入了视图，这样打开页面后就能显示用户名和权限。
2. remoteCall 接口，实现的功能是，通过引入 OAuth2RestTemplate，在登录后就可以使用凭据直接从受保护资源服务器拿资源，不需要繁琐地实现获得访问令牌、在请求头里加入访问令牌的过程。

第四步，配置一下刚才用到的 OAuth2RestTemplate Bean，并启用 OAuth2Sso 功能：

@Configuration
@EnableOAuth2Sso //这个注解包含了@EnableOAuth2Client
public class OAuthClientConfig {
/**
* 定义了 OAuth2RestTemplate，网上一些比较老的资料给出的是手动读取配置文件来实现，最新版本已经可以自动注入 OAuth2ProtectedResourceDetails
* @param oAuth2ClientContext
* @param details
* @return
*/
@Bean
public OAuth2RestTemplate oauth2RestTemplate(OAuth2ClientContext oAuth2ClientContext,
OAuth2ProtectedResourceDetails details) {
return new OAuth2RestTemplate(details, oAuth2ClientContext);
}
}

第五步，实现首页：

以及登录后才能访问的 securedPage 页面：

演示单点登录

好，客户端程序搭建好之后，我们先来测试一下单点登录的功能。启动客户端项目，打开浏览器访问：

http://localhost:8082/ui/securedPage

可以看到，页面自动转到了授权服务器（8080 端口）的登录页面：

登录后显示了当前用户名和权限：

我们再启动另一个客户端网站，端口改为 8083，然后访问同样的地址：

可以看到直接是登录状态，单点登录测试成功。是不是很方便？其实，为了达成单点登录的效果，程序在背后自动实现了多次 302 重定向，整个流程为：

http://localhost:8083/ui/securedPage ->
http://localhost:8083/ui/login ->
http://localhost:8080/oauth/authorize?client_id=userservice3&redirect_uri=http://localhost:8083/ui/login&response_type=code&scope=FOO&state=Sobjqe ->
http://localhost:8083/ui/login?code=CDdvHa&state=Sobjqe ->
http://localhost:8083/ui/securedPage

演示客户端请求资源服务器资源

还记得吗，在上一节“搭建客户端程序”中，我们还定义了一个 remoteCall 接口，直接使用 OAuth2RestTemplate 来访问远程资源服务器的资源。现在，我们来测试一下这个接口是否可以实现自动的 OAuth 流程。访问：

http://localhost:8082/ui/remoteCall

会先转到授权服务器登录，登录后自动跳转回来：

可以看到输出了用户名，对应的资源服务器服务端接口是：

@PreAuthorize(“hasAuthority(‘READ’) or hasAuthority(‘WRITE’)”)
@GetMapping(“name”)
public String name(OAuth2Authentication authentication) {
return authentication.getName();
}

换一个 writer 用户登录试试，也能得到正确的输出：

总结

今天这一讲，我们完整演示了如何使用 Spring Cloud 的 OAuth 2.0 组件基于三个程序角色（授权服务器、受保护资源服务器和客户端）实现三种 OAuth 2.0 的授权许可类型（资源拥有者凭据许可、客户端凭据许可和授权码许可）。

我们先演示了三种授权许可类型的手动流程，然后也演示了如何实现权限控制和单点登录，以及如何使用客户端程序来实现自动的 OAuth 2.0 流程。

我把今天用到的所有代码都放到了 GitHub 上，你可以点击这个链接查看。

最后，我再提一下，将来 Spring 对于 OAuth 2.0 的支持可能会转移到由社区推进的 Spring Authorization Server 项目上来继续运作。如果你感兴趣的话，可以及时关注这个项目的进展。