写在前面

前面我们对OAuth2.0中四种授权模式进行了学习，接下来将通过一个完整的实例来研究密码模式，深入理解其中的各个流程。

实例架构

密码模式是用户把用户密码直接告诉客户端（第三方应用），客户端使用这些信息向授权服务器申请令牌。这就需要用户对客户端高度信任，如客户端和服务提供商是同一家公司。它涉及到资源所有者、客户端（第三方应用）、授权服务器和资源服务器这四个角色。由于用户就是笔者，因此无需提供项目实例，而其他三者这里就提供各自的项目实例，各实例项目名称、角色名称和端口如下表所示：

项目名称	角色名称	端口
auth-server	授权服务器	8080
user-server	资源服务器	8081
client-app	客户端（第三方应用）	8082

空Maven父工程搭建

使用Maven新建一个空白的父工程，名称为password，之后我们将在这个父工程中搭建子项目。

授权服务器搭建

在password父工程中新建一个子模块，名称为auth-server，在选择依赖的时候选择如下三个依赖：Web、Spring Cloud Security和Spring Cloud OAuth2依赖：

第一步，将父工程password项目的pom.xml依赖文件修改为如下所示配置：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.envy</groupId>
    <artifactId>password</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>password</name>
    <description>OAuth2.0密码模式实例</description>
    <packaging>pom</packaging>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <modules>
        <module>auth-server</module>
    </modules>
</project>

第二步，回到子模块auth-server中，在其项目目录下新建一个config包，之后在该类中新建一个SecurityConfig类，注意这个类需要继承WebSecurityConfigurerAdapter类，里面的代码如下所示：

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Bean
    PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder(10);
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
                .withUser("envy").password(new BCryptPasswordEncoder().encode("1234")).roles("admin")
                .and()
                .withUser("hello").password(new BCryptPasswordEncoder().encode("1234")).roles("user");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests().anyRequest().authenticated()
                .and().formLogin()
                .and().csrf().disable();
    }
}

注意由于本系列笔记主要是学习如何使用OAuth2.0，因此不会详细介绍Spring Security的相关知识。这里出于简单起见，并没有将用户存入数据库中，而是直接存在内存中。此处首先提供了一个密码加密PasswordEncoder类的实例，之后在其中定义了两个用户，并定义了他们的用户名、密码和对应角色。接着还使用了系统默认的登录表单，这样便于后续用户登录。举个例子，开发者想让微信登录第三方网站，那么这有一个前提就是得让用户先登录微信，而登录微信需要用户名和密码，因此此处配置的其实就是用户登录所需的信息。同时此处提供了一个authenticationManagerBean()方法，该方法用于返回一个AuthenticationManager对象，因为使用了密码模式就要求用户输入密码，那么就需要对密码进行验证。

第三步，在完成了用户的基本信息配置后，接下来开始配置授权服务器。在config包内新建一个AccessTokenConfig类，其中的代码如下所示：

@Configuration
public class AccessTokenConfig {
    @Bean
    TokenStore tokenStore(){
        return new InMemoryTokenStore();
    }
}

可以看到这里我们需要提供一个TokenStore实例，该实例表示将生成的token存放在何处，可以将其存在Redis中，内存中，也可以将其存储在数据库中。其实这个TokenStore是一个接口，它有很多实现类，如下所示：

出于简单考虑，这里依旧将其存入内存中，故选择使用InMemoryTokenStore这一实现类。

接着在config包内新建一个AuthorizationServerConfig类，注意这个类需要继承AuthorizationServerConfigurerAdapter类，里面的代码如下所示：

@EnableAuthorizationServer
@Configuration
public class AuthorizationServerConfig  extends AuthorizationServerConfigurerAdapter {
    @Autowired
    private TokenStore tokenStore;

    @Autowired
    private ClientDetailsService clientDetailsService;

    @Autowired
    private AuthenticationManager authenticationManager;

    @Bean
    AuthorizationServerTokenServices tokenServices(){
        DefaultTokenServices services = new DefaultTokenServices();
        services.setClientDetailsService(clientDetailsService);
        services.setSupportRefreshToken(true);
        services.setTokenStore(tokenStore);
        services.setAccessTokenValiditySeconds(60*60*2);
        services.setRefreshTokenValiditySeconds(60*60*24*3);
        return services;
    }

    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        security.checkTokenAccess("permitAll()")
                .allowFormAuthenticationForClients();
    }

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
                .withClient("envythink").secret(new BCryptPasswordEncoder().encode("1234"))
                .resourceIds("res1").authorizedGrantTypes("password","refresh_token")
                .scopes("all").redirectUris("http://127.0.0.1:8082/index.html");
    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.authenticationManager(authenticationManager).tokenServices(tokenServices());
    }
}

接下来对上述代码进行分析：
（1）自定义AuthorizationServerConfig类，并继承AuthorizationServerConfigurerAdapter类，用来对授权服务器做更为详细的配置。请注意，此时需要在该类上添加@EnableAuthorizationServer注解，表示开启授权服务器的自动化配置。
（2）在自定义的AuthorizationServerConfig类中重写三个方法，这些方法分别用于对令牌端点安全、客户端信息、令牌访问端点和服务等内容进行详细配置。
（3）重写configure(AuthorizationServerSecurityConfigurer security)方法，该方法用于配置令牌端点的安全约束，即这个端点谁能访问，谁不能访问。接着我们调用checkTokenAccess()方法，里面设置值为permitAll()，表示该端点可以直接访问（后面当资源服务器收到token之后，需要校验token是否合法，此时就会访问这个端点）。查看源码可以知道该值默认为denyAll()表示都拒绝。
（4）重写configure(ClientDetailsServiceConfigurer clients)方法，该方法用于配置客户端的详细信息。在前面我们说过，授权服务器会进行两个方面的校验，一是校验客户端；而是校验用户。我们知道Spring Security与用户存储相关的类是UserDetailsService，由于我们将用户直接保持在内存中，因此系统默认就会通过这个类去校验用户。那么接下来就是校验客户端，需要注入ClientDetailsService对象。这里其实就是配置客户端的信息，同样出于简单考虑，这里依旧将其配置到内存中。此处配置了客户端的id、secret、资源id、授权类型、授权范围以及重定向URL。可以看到此处的authorizedGrantTypes参数的值已经变成了password，表示使用密码模式。
（5）重写configure(AuthorizationServerEndpointsConfigurer endpoints)方法，该方法用于配置令牌的访问端点和令牌服务。首先注入之前在SecurityConfig类中定义的AuthenticationManager实例对象，接着去掉之前在授权码模式中添加的AuthorizationCodeServices配置，采用刚刚注入的AuthenticationManager实例对象。先调用authenticationManager()方法将注入的AuthenticationManager实例对象设置进去。接着调用tokenServices()方法，来配置token的存储位置。
（6）请注意，前面我们定义了tokenStore()方法，该方法仅仅是配置了token的存储位置，但是对于token并没有进行设置。接下来需要提供一个AuthorizationServerTokenServices实例，开发者可以在该实例中配置token的基本信息，如token是否支持刷新、token的存储位置、token的过期时间以及刷新token的有效期。所谓的“刷新token的有效期”是指当token快要过期的时候，我们肯定是需要获取一个新的token，而在获取新的token的时候，需要有一个凭证信息，注意这个凭证信息不是旧的token，而是另外一个refresh_token，而这个refresh_token也是有有效期的。

第四步，在项目application.properties配置文件中新增如下用于配置项目端口的代码：

1	server.port=8080

以上就是授权服务器的搭建工作，那么接下来就启动该授权服务器。

资源服务器搭建

在完成了授权服务器的搭建工作之后，接下来开始搭建资源服务器。如果用户的项目属于中小型时，那么通常都会将资源服务器和授权服务器放在一起，但是如果是大型项目，那么都会将两者进行分离。因此本篇就假设用户正在开发的是大型项目，就将两者进行分离。

资源服务器，顾名思义就是用来存放用户的资源，这里就是用户的基本信息，如使用微信登录，那么就可能是头像、姓名、openid等信息。用户从授权服务器上获取到access_token之后，接着就会通过access_token去资源服务器上获取数据。

第一步，在password父工程中新建一个子模块，名称为user-server，在选择依赖的时候选择如下三个依赖：Web、Spring Cloud Security和Spring Cloud OAuth2依赖：

第二步，在父工程password项目的pom.xml依赖文件中新增如下所示配置：

<modules>
    <module>auth-server</module>
    <module>user-server</module>
</modules>

第三步，回到子模块user-server中，在其项目目录下新建一个config包，之后在该类中新建一个ResourceServerConfig类，注意这个类需要继承ResourceServerConfigurerAdapter类，里面的代码如下所示：

@Configuration
@EnableResourceServer
public class ResourceServerConfig  extends ResourceServerConfigurerAdapter {
    @Bean
    RemoteTokenServices tokenServices(){
        RemoteTokenServices services = new RemoteTokenServices();
        services.setCheckTokenEndpointUrl("http://127.0.0.1:8080/oauth/check_token");
        services.setClientId("envythink");
        services.setClientSecret("1234");
        return services;
    }

    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
        resources.resourceId("res1").tokenServices(tokenServices());
    }

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests().antMatchers("/admin/**").hasRole("admin")
                .anyRequest().authenticated();
    }
}

接下来对上述代码进行分析：
（1）自定义ResourceServerConfig类，并继承ResourceServerConfigurerAdapter类，用来对资源服务器做更为详细的配置。请注意，此时需要在该类上添加@EnableResourceServer注解，表示开启资源服务器的自动化配置。
（2）在自定义的ResourceServerConfig类中重写两个方法，这些方法分别用于对资源信息和页面访问等内容进行详细配置。
（3）重写configure(ResourceServerSecurityConfigurer resources)方法，该方法用于对资源进行配置。这里配置了资源的id，同时调用tokenServices()来配置token的存储位置。由于此处将资源服务器和授权服务器进行了分离，因此需要提供一个RemoteTokenServices对象，言外之意就是当资源服务器和授权服务器放在一起时，就不必提供一个RemoteTokenServices对象。
（4）我们定义了一个tokenServices()方法，该方法用于返回（3）中所需要的RemoteTokenServices对象，在RemoteTokenServices对象中，我们配置了access_token的的校验地址、客户端id，客户端秘钥等，其实这就是授权服务器的地址信息。这样当用户来资源服务器请求资源时，会携带一个access_token，通过此处的配置，它就能检验这个token是否正确。
（5）重写configure(HttpSecurity http)方法，该方法用于对访问页面进行配置。其实就是对资源进行拦截，这里就是判断当用户访问URL是以/admin开头的时候，需要用户具备admin角色才能访问。
第四步，既然是资源服务器，那么我们就需要提供资源，这里提供两个接口。在项目目录下新建一个controller包，之后在该类中新建一个HelloController类，里面的代码如下所示：

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello(){
        return "hello";
    }

    @GetMapping("admin/hello")
    public String admin(){
        return "admin";
    }
}

第五步，在项目application.properties配置文件中新增如下用于配置项目端口的代码：

1	server.port=8081

以上就是资源服务器的搭建工作，那么接下来就启动该资源服务器。

客户端（第三方应用）搭建

请注意，客户端（第三方应用）并非必须的，开发者可以使用诸如Postman等测试工具来进行测试。此处为了案例的完整性，依旧搭建了一个普通的Spring Boot项目。

第一步，在password父工程中新建一个子模块，名称为client-app，在选择依赖的时候选择如下两个依赖：Web和Thymeleaf依赖：

第二步，在父工程password项目的pom.xml依赖文件中新增如下所示配置：

<modules>
    <module>auth-server</module>
    <module>user-server</module>
    <module>client-app</module>
</modules>

第三步，回到子模块client-app中，在其resources/templates目录下新建一个login.html文件，其中的代码如下所示：

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>用户登录</title>
</head>
<body>
<div style="text-align: center">
    <h1>你好余思！</h1>
    <form action="/login" method="post">
        <tr>
            <td>用户名：</td>
            <td><input type="text" name="username"></td>
        </tr>
        <tr>
            <td>密码：</td>
            <td><input type="password" name="password"></td>
        </tr>
        <tr>
            <td><button type="submit" value="登录">登录</button></td>
        </tr>
    </form>
    <h1 th:text="${msg}"></h1>
</div>
</body>
</html>

可以看到此处定义了一个登陆页面，内容非常简单，因此就不过多介绍。
第四步，回到子模块client-app中，在其项目目录下新建一个controller包，并在该包内新建一个HelloController类，其中的代码如下所示：

@Controller
public class HelloController {
    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/index.html")
    public String hello(){
        return "login";
    }

    @PostMapping("/login")
    public String login(String username, String password, Model model){
        MultiValueMap<String,String> map =new LinkedMultiValueMap<>();
        map.add("username",username);
        map.add("password",password);
        map.add("client_secret","1234");
        map.add("client_id","envythink");
        map.add("grant_type","password");
        Map<String,String> respMap= restTemplate.postForObject("http://127.0.0.1:8080/oauth/token",map, Map.class);
        String access_token = respMap.get("access_token");
        System.out.println(access_token);

        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.add("Authorization","Bearer"+access_token);
        HttpEntity<Object> httpEntity = new HttpEntity<>(httpHeaders);
        ResponseEntity<String> entity = restTemplate.exchange("http://127.0.0.1:8081/admin/hello", HttpMethod.GET,httpEntity,String.class);
        model.addAttribute("msg",entity.getBody());
        return "login";
    }
}

我们在此处的HelloController类中先定义了一个hello方法，该方法用于访问/login.html接口。接着定义了一个login方法，该方法用于处理/login接口，也就是之前提交表单之后的逻辑。也就是先获取用户提交的信息，然后通过使用restTemplate对象来发送一个POST请求，请注意在此POST请求中的grant_type参数的值为password，表示此为密码模式。通过这个POST请求，我们可以获取授权服务器返回的access_token信息，就像下面这样的：

1	{access_token=2c54bdde-0f8b-4af0-98f2-39d381972fcd,token_type=bearer,refresh_token=9r82beif-9e6h-5y8i-93f6-93gy77uiw59d,expires_in=7199,scope=all}

之后我们就提取出access_token信息，并再次使用restTemplate对象来发送一个GET请求去访问资源服务器，并将获取到的数据放在model中进行返回。
第五步，在项目application.properties配置文件中新增如下用于配置项目端口的代码：

1	server.port=8082

请注意，如果在上面提示缺少一个RestTemplate对象，那么就需要开发者自行提供一个Bean方法用于返回一个RestTemplate实例。以上就是客户端（第三方应用）的搭建工作，那么接下来就启动该客户端（第三方应用）。

项目测试

在确认三个项目都已经正确启动之后，接下来打开浏览器，访问http://127.0.0.1:8082/index.html链接，此时页面显示如下信息：

然后用户输入在授权服务器中配置的用户信息，之后点击登录按钮进行登录，登录成功后的页面如下所示：

可以看到其下方多出了一个admin字段，这其实就是/admin/hello接口提供的信息。这样就说明我们的密码模式实例就配置成功了。

（完）