使用过SpringSecurity Oauth2的小伙伴都知道，authorization_code、password、client_credentials、refresh_token几种授权模式获取token调用的接口都是/oauth/token，同时也都需要携带 client_id、client_secret 两个参数，或者说携带请求头
Authorization: Basic base64Encode(client_id_value:client_secret_value)这里的 Basic token 对应由 SpringSecurity 的过滤器 BasicAuthenticationFilter 进行验证处理。
1 BasicAuthenticationFilter
不同版本的springcloud中，doFilterInternal 的实现写法可能不同，但是核心逻辑是一样的。
了解 SpringSecurity 认证机制的小伙伴们看到下面的 authenticationManager.authenticate()方法就可以知道，这个过滤器用 client_id和client_secret 作为用户名和密码进行了一次认证，而对应的provider用来查询用户信息的实际就是ClientDetailsUserDetailsService。
在认证成功后将client的认证信息放在了SecurityContextHolder的线程变量中。
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
try {
UsernamePasswordAuthenticationToken authRequest = this.authenticationConverter.convert(request);
if (authRequest == null) {
this.logger.trace("Did not process authentication request since failed to find username and password in Basic Authorization header");
chain.doFilter(request, response);
return;
}
String username = authRequest.getName();
this.logger.trace(LogMessage.format("Found username '%s' in Basic Authorization header", username));
if (this.authenticationIsRequired(username)) {
//核心代码
Authentication authResult = this.authenticationManager.authenticate(authRequest);
SecurityContext context = SecurityContextHolder.createEmptyContext();
context.setAuthentication(authResult);
SecurityContextHolder.setContext(context);
if (this.logger.isDebugEnabled()) {
this.logger.debug(LogMessage.format("Set SecurityContextHolder to %s", authResult));
}
this.rememberMeServices.loginSuccess(request, response, authResult);
this.onSuccessfulAuthentication(request, response, authResult);
}
} catch (AuthenticationException var8) {
SecurityContextHolder.clearContext();
this.logger.debug("Failed to process authentication request", var8);
this.rememberMeServices.loginFail(request, response);
this.onUnsuccessfulAuthentication(request, response, var8);
if (this.ignoreFailure) {
chain.doFilter(request, response);
} else {
this.authenticationEntryPoint.commence(request, response, var8);
}
return;
}
chain.doFilter(request, response);
}2 TokenEndpoint
与一般的认证流程略有不同，上面的 this.onSuccessfulAuthentication(request, response, authResult);是空实现，因此，认证成功后，过滤器就会放行，然后请求进入TokenEndpoint。
当我们看到下面的代码的@RequestMapping就知道，这里一定就是生成token的入口了。可能有部分小伙伴会疑惑，为什么TokenEndpoint的注解是@FrameworkEndpoint而不是@Controller，看到@Component也就恍然了。
@Component
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FrameworkEndpoint {
}postAccessToken()方法的入参有两个，parameters 比较好理解，就是request中的参数，而 principal 其实就是从 SecurityContextHolder线程变量拿到的上一步的认证信息
@FrameworkEndpoint
public class TokenEndpoint extends AbstractEndpoint {
......
@RequestMapping( value = {"/oauth/token"},method = {RequestMethod.POST})
public ResponseEntity<OAuth2AccessToken> postAccessToken(Principal principal, @RequestParam Map<String, String> parameters) throws HttpRequestMethodNotSupportedException {
if (!(principal instanceof Authentication)) {
throw new InsufficientAuthenticationException("There is no client authentication. Try adding an appropriate authentication filter.");
} else {
String clientId = this.getClientId(principal);
ClientDetails authenticatedClient = this.getClientDetailsService().loadClientByClientId(clientId);
TokenRequest tokenRequest = this.getOAuth2RequestFactory().createTokenRequest(parameters, authenticatedClient);
if (clientId != null && !clientId.equals("") && !clientId.equals(tokenRequest.getClientId())) {
throw new InvalidClientException("Given client ID does not match authenticated client");
} else {
if (authenticatedClient != null) {
this.oAuth2RequestValidator.validateScope(tokenRequest, authenticatedClient);
}
if (!StringUtils.hasText(tokenRequest.getGrantType())) {
throw new InvalidRequestException("Missing grant type");
} else if (tokenRequest.getGrantType().equals("implicit")) {
//这里不支持implicit模式获取token
throw new InvalidGrantException("Implicit grant type not supported from token endpoint");
} else {
if (this.isAuthCodeRequest(parameters) && !tokenRequest.getScope().isEmpty()) {
this.logger.debug("Clearing scope of incoming token request");
tokenRequest.setScope(Collections.emptySet());
}
if (this.isRefreshTokenRequest(parameters)) {
tokenRequest.setScope(OAuth2Utils.parseParameterList((String)parameters.get("scope")));
}
OAuth2AccessToken token = this.getTokenGranter().grant(tokenRequest.getGrantType(), tokenRequest);
if (token == null) {
throw new UnsupportedGrantTypeException("Unsupported grant type: " + tokenRequest.getGrantType());
} else {
return this.getResponse(token);
}
}
}
}
}
......
}抛开校验逻辑，这段代码比较重要的就是下面几行。
1、首先查询了客户端信息（对应的数据库表就是oauth_client_details）
2、接下来用客户端信息和request中的参数构建了一个TokenRequest对象，
3、最后以tokenRequest作为参数，生成了我们最终需要的token.
显然，这里最重要的部分就是this.getTokenGranter().grant()方法
......
ClientDetails authenticatedClient = this.getClientDetailsService().loadClientByClientId(clientId);
TokenRequest tokenRequest = this.getOAuth2RequestFactory().createTokenRequest(parameters, authenticatedClient);
......
OAuth2AccessToken token = this.getTokenGranter().grant(tokenRequest.getGrantType(), tokenRequest);关于TokenRequest，我们通过它的构造器基本上就可以了解这个对象包含了哪些属性。
public TokenRequest(Map<String, String> requestParameters, String clientId, Collection<String> scope, String grantType) {
this.setClientId(clientId);
this.setRequestParameters(requestParameters);
this.setScope(scope);
this.grantType = grantType;
}而对于 this.getTokenGranter()，它的具体实现是在AuthorizationServerEndpointsConfigurer#tokenGranter()方法，那么接下来的重点源码就是AuthorizationServerEndpointsConfigurer类了。
至于为什么具体实现是上面这个方法，可以看TokenEndpoint 实例在初始化时的设置。 在AuthorizationServerEndpointsConfiguration.java 有这样一段代码。（有一点我不太明白，@Bean 和 @Componet 都是将bean注册到spring容器中，为什么可以同时存在）
@Bean
public TokenEndpoint tokenEndpoint() throws Exception {
TokenEndpoint tokenEndpoint = new TokenEndpoint();
tokenEndpoint.setClientDetailsService(clientDetailsService);
tokenEndpoint.setProviderExceptionHandler(exceptionTranslator());
tokenEndpoint.setTokenGranter(tokenGranter());//设置token生成器
tokenEndpoint.setOAuth2RequestFactory(oauth2RequestFactory());
tokenEndpoint.setOAuth2RequestValidator(oauth2RequestValidator());
tokenEndpoint.setAllowedRequestMethods(allowedTokenEndpointRequestMethods());
return tokenEndpoint;
}3 AuthorizationServerEndpointsConfigurer
SpringSecurity实现OAuth2分为两个服务，Authorization Server和Resource Server分别作为授权服务器和资源服务器，我们在配置授权服务器的时候会有如下配置。显然这里的配置就是为了生成token使用的。
@Override
public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
endpoints
.pathMapping("/oauth/token","/clonetx/token")
.allowedTokenEndpointRequestMethods(HttpMethod.GET, HttpMethod.POST)//允许的请求方式
//tokenStore默认内存存储，重启服务token就会失效
.tokenStore(new InMemoryTokenStore())
//.accessTokenConverter(jwtAccessTokenConverter())
//用于配置密码式的授权方式，如果不设置，密码模式请求token是，token为null,TokenEndpoint会提示不支持password授权模式
//其实这里配置就是parent AuthenticationManager
//.authenticationManager(authenticationManager())
/*.tokenGranter(new TokenGranter() {
@Override
public OAuth2AccessToken grant(String s, TokenRequest tokenRequest) {
return null;
}
})*/
;
}在分析this.getTokenGranter().grant()方法的源码之前，我们先看下 TokenGranter 的类图。
通过类图，能够清晰的看到，TokenGranter 有6个实现类，其中通过名称我们就能知道，其中5个实现类分别对应refresh_token、client_credentials、password、authorization_code、implicit几种grantType。（其中implicit模式不由/oauth/token处理，具体可以看上面略过的校验逻辑，这里不进行展开）。
我们带着剩下的 CompositeTokenGranter 实现类来看下面这段代码，可以知道，如果配置AuthorizationServerEndpointsConfigurer endpoints的时侯没有指定token生成器，那么默认就会使用 CompositeTokenGranter
private TokenGranter tokenGranter() {
if (tokenGranter == null) {
tokenGranter = new TokenGranter() {
private CompositeTokenGranter delegate;
@Override
public OAuth2AccessToken grant(String grantType, TokenRequest tokenRequest) {
if (delegate == null) {
// 获取 oauth2 的 5 种 token 生成器
delegate = new CompositeTokenGranter(getDefaultTokenGranters());
}
// 把auth2 的 5 种 token 生成器遍历了一次，根据grantType 选择对应的生成器，都不满足的就返回空
return delegate.grant(grantType, tokenRequest);
}
};
}
return tokenGranter;
}显然，CompositeTokenGranter是那 5 种 token 生成器的代理类，根据 grantType 来选择对应的生成器，并通过代理对象的grant()方法生成token。（这里我们需要关注一下 tokenServices() 方法，后面生成token的逻辑就在它的实现代码中。可以发现endpoints配置中没有指定就会默认DefaultTokenServices，当然对于其它配置也是一样的，不在endpoints配置中指定就会取默认的，这里就不展开说明了）
private List<TokenGranter> getDefaultTokenGranters() {
ClientDetailsService clientDetails = clientDetailsService();
//设置了产生token的service
AuthorizationServerTokenServices tokenServices = tokenServices();
AuthorizationCodeServices authorizationCodeServices = authorizationCodeServices();
OAuth2RequestFactory requestFactory = requestFactory();
//token 生成器
List<TokenGranter> tokenGranters = new ArrayList<TokenGranter>();
//N# 1 授权码模式token生成器
tokenGranters.add(new AuthorizationCodeTokenGranter(tokenServices, authorizationCodeServices, clientDetails,
requestFactory));
//N# 2 刷新token 生成器
tokenGranters.add(new RefreshTokenGranter(tokenServices, clientDetails, requestFactory));
//N# 3 隐藏式生成器
ImplicitTokenGranter implicit = new ImplicitTokenGranter(tokenServices, clientDetails, requestFactory);
tokenGranters.add(implicit);
//N# 4 客户端模式生成器
tokenGranters.add(new ClientCredentialsTokenGranter(tokenServices, clientDetails, requestFactory));
if (authenticationManager != null) {//密码模式要求自定义一个authenticationManager parent
//N# 5 密码式生成器
tokenGranters.add(new ResourceOwnerPasswordTokenGranter(authenticationManager, tokenServices,
clientDetails, requestFactory));
}
return tokenGranters;
}
private AuthorizationServerTokenServices tokenServices() {
if (tokenServices != null) {
return tokenServices;
}
this.tokenServices = createDefaultTokenServices();
return tokenServices;
}
private DefaultTokenServices createDefaultTokenServices() {
DefaultTokenServices tokenServices = new DefaultTokenServices();
tokenServices.setTokenStore(tokenStore());
tokenServices.setSupportRefreshToken(true);
tokenServices.setReuseRefreshToken(reuseRefreshToken);
tokenServices.setClientDetailsService(clientDetailsService());
tokenServices.setTokenEnhancer(tokenEnhancer());//token增强器
addUserDetailsService(tokenServices, this.userDetailsService);
return tokenServices;
}继续跟踪 delegate.grant() 方法，我们会发现，无论是无论是哪种授权模式，都会调用 AbstractTokenGranter中的grant方法。
4 AbstractTokenGranter
下面代码中的tokenServices 在 getDefaultTokenGranters()#tokenServices() 方法中已经指定，没指定默认就是DefaultTokenServices。
public OAuth2AccessToken grant(String grantType, TokenRequest tokenRequest) {
if (!this.grantType.equals(grantType)) {
return null;
} else {
String clientId = tokenRequest.getClientId();
ClientDetails client = this.clientDetailsService.loadClientByClientId(clientId);
this.validateGrantType(grantType, client);
this.logger.debug("Getting access token for: " + clientId);
return this.getAccessToken(client, tokenRequest);
}
}
protected OAuth2AccessToken getAccessToken(ClientDetails client, TokenRequest tokenRequest) {
return this.tokenServices.createAccessToken(this.getOAuth2Authentication(client, tokenRequest));
}
//这里RefreshTokenGranter是个例外，重写了getAccessToken 方法
//@Override
//protected OAuth2AccessToken getAccessToken(ClientDetails client, TokenRequest tokenRequest) {
// String refreshToken = tokenRequest.getRequestParameters().get("refresh_token");
// return getTokenServices().refreshAccessToken(refreshToken, tokenRequest);
//}5 DefaultTokenServices
分析这段代码，首先是尝试从 tokenStore 中获取token，简单看一下TokenStore的部分实现类，就能推测出不同的实现类其实就是把token存放在不同的地方，默认是内存中，也是可以在endpoints配置的。
那么这段逻辑就是，判断一下是否已经为这个authentication生成过token，如果已经存在token，判断是否已经过期，没过期就返回这个token；否则就把 refreshToken 和 existingAccessToken从存储中先清理掉。
然后在来判断 refreshToken，如果不存在，说明以前没认证过，那就先生成一个refreshToken，如果存在但是过期了，也重新生成一个refreshToken。
最后就是利用 refreshToken 和 authentication重新生成一个accessToken了。然后再把新的token放到存储中。
@Transactional
public OAuth2AccessToken createAccessToken(OAuth2Authentication authentication) throws AuthenticationException {
OAuth2AccessToken existingAccessToken = this.tokenStore.getAccessToken(authentication);
OAuth2RefreshToken refreshToken = null;
if (existingAccessToken != null) {
if (!existingAccessToken.isExpired()) {
this.tokenStore.storeAccessToken(existingAccessToken, authentication);
return existingAccessToken;
}
if (existingAccessToken.getRefreshToken() != null) {
refreshToken = existingAccessToken.getRefreshToken();
this.tokenStore.removeRefreshToken(refreshToken);
}
this.tokenStore.removeAccessToken(existingAccessToken);
}
if (refreshToken == null) {
refreshToken = this.createRefreshToken(authentication);
} else if (refreshToken instanceof ExpiringOAuth2RefreshToken) {
ExpiringOAuth2RefreshToken expiring = (ExpiringOAuth2RefreshToken)refreshToken;
if (System.currentTimeMillis() > expiring.getExpiration().getTime()) {
refreshToken = this.createRefreshToken(authentication);
}
}
OAuth2AccessToken accessToken = this.createAccessToken(authentication, refreshToken);
this.tokenStore.storeAccessToken(accessToken, authentication);
refreshToken = accessToken.getRefreshToken();
if (refreshToken != null) {
this.tokenStore.storeRefreshToken(refreshToken, authentication);
}到这里我们终于一层层的揭开了SpringSecurity Oauth2令牌生成的面纱，上面我们在注释中有提到过RefreshTokenGranter是个例外，它重写了getAccessToken 方法，但最终的实现也是调用的下面代码。
private OAuth2AccessToken createAccessToken(OAuth2Authentication authentication, OAuth2RefreshToken refreshToken) {
DefaultOAuth2AccessToken token = new DefaultOAuth2AccessToken(UUID.randomUUID().toString());
int validitySeconds = getAccessTokenValiditySeconds(authentication.getOAuth2Request());
if (validitySeconds > 0) {
token.setExpiration(new Date(System.currentTimeMillis() + (validitySeconds * 1000L)));
}
token.setRefreshToken(refreshToken);
token.setScope(authentication.getOAuth2Request().getScope());
return accessTokenEnhancer != null ? accessTokenEnhancer.enhance(token, authentication) :我们看到accessToken原来就是个uuid。
客户端授权模式token例子
{
"access_token": "b1394c16-0b9a-4101-b0ba-9237dbeb27ae",
"token_type": "bearer",
"expires_in": 1526,
"scope": "test"
}不过到这并没完，还有一个扎眼的 accessTokenEnhancer.enhance(token, authentication)方法。我们上文在createDefaultTokenServices()的代码中，看到初始化tokenServices时设置了一个TokenEnhancer，见名知意，它可以对 token 进行额外的处理。这就不得不提到 JWT了，我们下次开一篇单独分析TokenEnhancer。
