SpringSecurity OAuth2中关于创建Token的实现类DefaultTokenServices及TokenStore实现类的详解

最新推荐文章于 2024-06-09 17:34:15 发布
最新推荐文章于 2024-06-09 17:34:15 发布
阅读量5.2k 收藏 26
点赞数 9
分类专栏： Spring Cloud 笔记 文章标签： SpringSecurity 单点登录 OAuth2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hou_ge/article/details/122349358
版权

1、前言

  在《SpringSecurity OAuth2 获取Token端点TokenEndpoint、Token授权TokenGranter接口 详解》中，在TokenGranter接口的几个实现类中，真正实现token生成的其实是AuthorizationServerTokenServices对象。这一篇，我们专门来分析AuthorizationServerTokenServices是如何实现token生成的。

2、AuthorizationServerTokenServices 生成Token

  AuthorizationServerTokenServices接口提供了创建Token、刷新Token、获取Token的方法，如下所示：

public interface AuthorizationServerTokenServices {

	OAuth2AccessToken createAccessToken(OAuth2Authentication authentication) throws AuthenticationException;

	OAuth2AccessToken refreshAccessToken(String refreshToken, TokenRequest tokenRequest)
			throws AuthenticationException;

	OAuth2AccessToken getAccessToken(OAuth2Authentication authentication);
}

  默认提供了DefaultTokenServices实现类，该实现类除了实现AuthorizationServerTokenServices 接口定义的方法，还实现了ResourceServerTokenServices、ConsumerTokenServices和InitializingBean接口。

  其中，实现InitializingBean接口，主要为了校验当初始化完成后，保证tokenStore属性的值不能为空。

2.1、createAccessToken()方法 创建AccessToken

  createAccessToken()方法实现了根据OAuth2Authentication对象（认证用户信息及其请求信息）创建OAuth2AccessToken对象（Token信息）的功能，即实现了创建accessToken的功能。下面我们通过代码注释，分析该方法的实现逻辑：

@Transactional
public OAuth2AccessToken createAccessToken(OAuth2Authentication authentication) throws AuthenticationException {
	//根据authentication查询已经存在的OAuth2AccessToken对象，这里使用到了TokenStore对象，后续专门分析
	OAuth2AccessToken existingAccessToken = tokenStore.getAccessToken(authentication);
	OAuth2RefreshToken refreshToken = null;
	//当存在OAuth2AccessToken对象时，进行验证是否过期
	if (existingAccessToken != null) {
		//如果OAuth2AccessToken对象已经过期，就删除tokenStore中存储的refreshToken和AccessToken对象
		if (existingAccessToken.isExpired()) {
			if (existingAccessToken.getRefreshToken() != null) {
				refreshToken = existingAccessToken.getRefreshToken();
				tokenStore.removeRefreshToken(refreshToken);
			}
			tokenStore.removeAccessToken(existingAccessToken);
		}else {//如果没有过期，说明当前accessToken可以用，就重新存储AccessToken，避免authentication已经发生变化，导致不一致，然后直接返回当前的existingAccessToken即可。
			tokenStore.storeAccessToken(existingAccessToken, authentication);
			return existingAccessToken;
		}
	}
	//如果不存在过期AccessToken关联的refreshToken，就调用haicreateRefreshToken()方法创建一个新的refreshToken对象，存在的话，尝试利旧使用
	if (refreshToken == null) {
		refreshToken = createRefreshToken(authentication);
	}
	//验证是否利旧使用，如果refreshToken过期，还是需要createRefreshToken()方法创建一个新的refreshToken对象，否则可以利旧使用
	else if (refreshToken instanceof ExpiringOAuth2RefreshToken) {
		ExpiringOAuth2RefreshToken expiring = (ExpiringOAuth2RefreshToken) refreshToken;
		if (System.currentTimeMillis() > expiring.getExpiration().getTime()) {
			refreshToken = createRefreshToken(authentication);
		}
	}
	//使用上面已经处理过的refreshToken对象和authentication对象，通过调用createAccessToken()方法创建accessToken对象
	OAuth2AccessToken accessToken = createAccessToken(authentication, refreshToken);
	//调用tokenStore的storeAccessToken()方法，存储创建好的accessToken对象
	tokenStore.storeAccessToken(accessToken, authentication);
	//调用tokenStore的storeRefreshToken()方法，存储上面处理过的refreshToken对象
	refreshToken = accessToken.getRefreshToken();
	if (refreshToken != null) {
		tokenStore.storeRefreshToken(refreshToken, authentication);
	}
	//最后，返回创建的accessToken对象即可
	return accessToken;
}
createRefreshToken()方法

   createRefreshToken()方法实现了根据OAuth2Authentication创建OAuth2RefreshToken对象的功能，实际创建的就是DefaultOAuth2RefreshToken实例对象（实际上就是一个带有value属性字段的实体类，value字段就是OAuth2RefreshToken对象的值，默认就是一个UUID的随机字符串）或DefaultExpiringOAuth2RefreshToken对象（比DefaultOAuth2RefreshToken多了一个过期时间参数）。

private OAuth2RefreshToken createRefreshToken(OAuth2Authentication authentication) {
	//判断是否支持refresh_token，根据客户端信息中的grantType来进行判断，如果不支持直接返回null，说明refresh_token可能为空
	if (!isSupportRefreshToken(authentication.getOAuth2Request())) {
		return null;
	}
	//获取刷新token的有效时间，也是通过客户端信息中refreshTokenValiditySeconds字段进行自定义，系统默认为60 * 60 * 24 * 30（30天）
	int validitySeconds = getRefreshTokenValiditySeconds(authentication.getOAuth2Request());
	//刷新token的value值，UUID随机字符串
	String value = UUID.randomUUID().toString();
	//当存在有效时间时，创建DefaultExpiringOAuth2RefreshToken实例对象
	if (validitySeconds > 0) {
		return new DefaultExpiringOAuth2RefreshToken(value, new Date(System.currentTimeMillis()
				+ (validitySeconds * 1000L)));
	}
	//没有过期时间时，创建DefaultOAuth2RefreshToken对象
	return new DefaultOAuth2RefreshToken(value);
}
createAccessToken()方法

  createAccessToken()方法实现了根据OAuth2Authentication、OAuth2RefreshToken对象创建OAuth2AccessToken对象的功能，默认创建的是DefaultOAuth2AccessToken对象，该对象可以通过TokenEnhancer进行自定义access token 对象。

private OAuth2AccessToken createAccessToken(OAuth2Authentication authentication, OAuth2RefreshToken refreshToken) {
	//创建默认的DefaultOAuth2AccessToken对象，其中的value默认使用的还是UUID字符串
	DefaultOAuth2AccessToken token = new DefaultOAuth2AccessToken(UUID.randomUUID().toString());
	//和刷新token过期时间类似，首先从客户端的accessTokenValiditySeconds属性字段获取，没有的话，则使用默认值（60 * 60 * 12，12小时）
	int validitySeconds = getAccessTokenValiditySeconds(authentication.getOAuth2Request());
	//设置accessToken过期时间
	if (validitySeconds > 0) {
		token.setExpiration(new Date(System.currentTimeMillis() + (validitySeconds * 1000L)));
	}
	//设置accessToken的刷新token，有可能为空
	token.setRefreshToken(refreshToken);
	//设置accessToken的scope值
	token.setScope(authentication.getOAuth2Request().getScope());
	//如果accessTokenEnhancer 不为空，则使用accessTokenEnhancer 进行token内容自定义设置，否则，直接返回默认的token即可，关于accessTokenEnhancer如何增加自定义内容，后续再展开分析。
	return accessTokenEnhancer != null ? accessTokenEnhancer.enhance(token, authentication) : token;
}
2.2、refreshAccessToken()方法 刷新accessToken

  refreshAccessToken()方法，主要是实现accessToken的刷新功能，这里需要使用到刷新token的value值和TokenRequest对象。下面我们通过代码注释，分析该方法的实现逻辑：

@Transactional(noRollbackFor={InvalidTokenException.class, InvalidGrantException.class})
public OAuth2AccessToken refreshAccessToken(String refreshTokenValue, TokenRequest tokenRequest)
		throws AuthenticationException {
	//如果不支持刷新token，直接抛出InvalidGrantException异常
	if (!supportRefreshToken) {
		throw new InvalidGrantException("Invalid refresh token: " + refreshTokenValue);
	}
	//查询刷新token对象，如果为空，直接抛出InvalidGrantException异常，关于tokenStore根据refreshTokenValue获取OAuth2RefreshToken 对象的方法，后续再展开分析
	OAuth2RefreshToken refreshToken = tokenStore.readRefreshToken(refreshTokenValue);
	if (refreshToken == null) {
		throw new InvalidGrantException("Invalid refresh token: " + refreshTokenValue);
	}
	//根据刷新token对象，获取对应的OAuth2Authentication 对象，用来校验用户认证信息
	OAuth2Authentication authentication = tokenStore.readAuthenticationForRefreshToken(refreshToken);
	//当authenticationManager 不为空时，重写认证用户信息，并生成新的OAuth2Authentication对象
	if (this.authenticationManager != null && !authentication.isClientOnly()) {
		Authentication user = new PreAuthenticatedAuthenticationToken(authentication.getUserAuthentication(), "", authentication.getAuthorities());
		user = authenticationManager.authenticate(user);
		Object details = authentication.getDetails();
		authentication = new OAuth2Authentication(authentication.getOAuth2Request(), user);
		authentication.setDetails(details);
	}
	//校验clientId和请求中的clientId是否一致
	String clientId = authentication.getOAuth2Request().getClientId();
	if (clientId == null || !clientId.equals(tokenRequest.getClientId())) {
		throw new InvalidGrantException("Wrong client for this refresh token: " + refreshTokenValue);
	}
	//删除当前刷新token关联的accessToken对象，避免存在多个accessToken
	tokenStore.removeAccessTokenUsingRefreshToken(refreshToken);
	//如果刷新token已经过期了，这移除该token，并抛出InvalidTokenException异常
	if (isExpired(refreshToken)) {
		tokenStore.removeRefreshToken(refreshToken);
		throw new InvalidTokenException("Invalid refresh token (expired): " + refreshToken);
	}
	//创建一个刷新使用的OAuth2Authentication对象
	authentication = createRefreshedAuthentication(authentication, tokenRequest);
	//如果refreshToken 不能被重复利用，就移除tokenStore中存储的refreshToken 对象，并重写创建一个新的refreshToken 对象，使用到的createRefreshToken()方法用来创建刷新token，前面已经分析过了，这里不再重复。
	if (!reuseRefreshToken) {
		tokenStore.removeRefreshToken(refreshToken);
		refreshToken = createRefreshToken(authentication);
	}
	//创建一个新的OAuth2AccessToken对象，即刷新了原来的OAuth2AccessToken对象，并把该对象存储到tokenStore中
	OAuth2AccessToken accessToken = createAccessToken(authentication, refreshToken);
	tokenStore.storeAccessToken(accessToken, authentication);
	//如果refreshToken 不能被重复利用，说明该对象已经被重写创建了，这里需要把该对象再存储到tokenStore中
	if (!reuseRefreshToken) {
		tokenStore.storeRefreshToken(accessToken.getRefreshToken(), authentication);
	}
	return accessToken;
}
createRefreshedAuthentication()方法

  createRefreshedAuthentication()方法主要用来创建OAuth2Authentication对象，主要刷新了OAuth2Request对象，改变了该对象的scope值，具体实现如下：

private OAuth2Authentication createRefreshedAuthentication(OAuth2Authentication authentication, TokenRequest request) {
	OAuth2Authentication narrowed = authentication;
	Set<String> scope = request.getScope();
	OAuth2Request clientAuth = authentication.getOAuth2Request().refresh(request);
	if (scope != null && !scope.isEmpty()) {
		Set<String> originalScope = clientAuth.getScope();
		if (originalScope == null || !originalScope.containsAll(scope)) {
			throw new InvalidScopeException("Unable to narrow the scope of the client authentication to " + scope
					+ ".", originalScope);
		}
		else {
			clientAuth = clientAuth.narrowScope(scope);
		}
	}
	narrowed = new OAuth2Authentication(clientAuth, authentication.getUserAuthentication());
	return narrowed;
}
2.3、getAccessToken()方法 查询accessToken

  getAccessToken()方法，主要提供了查询accessToken的功能，实际就是通过tokenStore对象，根据OAuth2Authentication参数查询OAuth2AccessToken对象，实现如下：

public OAuth2AccessToken getAccessToken(OAuth2Authentication authentication) {
	return tokenStore.getAccessToken(authentication);
}

3、TokenStore

  在AuthorizationServerTokenServices 中，无论是createAccessToken()、refreshAccessToken()方法还是getAccessToken()方法，都是基于TokenStore对象实现token的存储和查询功能的，这里我们专门学习一下TokenStore的具体实现。

3.1、TokenStore 接口

  TokenStore 定义了Token管理需要的一些方法，具体如下所示：

public interface TokenStore {

	// 根据AccessToken对象查询对应的OAuth2Authentication（认证的用户信息）
	OAuth2Authentication readAuthentication(OAuth2AccessToken token);

	// 根据AccessToken字符串查询对应的OAuth2Authentication（认证的用户信息）
	OAuth2Authentication readAuthentication(String token);

	//存储AccessToken对象，建立AccessToken对象与OAuth2Authentication对象（认证的用户信息）的关联关系
	void storeAccessToken(OAuth2AccessToken token, OAuth2Authentication authentication);

	//根据AccessToken字符串查询对应的token对象
	OAuth2AccessToken readAccessToken(String tokenValue);

	//移除AccessToken对象
	void removeAccessToken(OAuth2AccessToken token);

	//存储刷新Token，建立refreshToken 与 OAuth2Authentication（认证的用户信息）之间的关联关系
	void storeRefreshToken(OAuth2RefreshToken refreshToken, OAuth2Authentication authentication);

	//根据RefreshToken字符串查询对应的token对象
	OAuth2RefreshToken readRefreshToken(String tokenValue);

	//根据RefreshToken对象查询对应的OAuth2Authentication（认证的用户信息）
	OAuth2Authentication readAuthenticationForRefreshToken(OAuth2RefreshToken token);

	//移除OAuth2RefreshToken 对象
	void removeRefreshToken(OAuth2RefreshToken token);

	//根据OAuth2RefreshToken 对象，移除关联的AccessToken对象
	void removeAccessTokenUsingRefreshToken(OAuth2RefreshToken refreshToken);

	//根据OAuth2Authentication 对象查询OAuth2AccessToken 对象
	OAuth2AccessToken getAccessToken(OAuth2Authentication authentication);
	
	//根据clientId + username 查询OAuth2AccessToken集合
	Collection<OAuth2AccessToken> findTokensByClientIdAndUserName(String clientId, String userName);

	//根据clientId 查询OAuth2AccessToken集合
	Collection<OAuth2AccessToken> findTokensByClientId(String clientId);
}
3.2、TokenStore 层级结构

在这里插入图片描述
  TokenStore 接口默认提供了如上图所示的实现类，其中，

  1. JdbcTokenStore 提供了基于JDBC存储Token的实现，其中内置了很多查询、新增、删除数据的SQL语句
  2. RedisTokenStore 提供了基于Redis存储Token的实现，需要引入Redis的支持
  3. InMemoryTokenStore 提供了基于内存存储Token的实现，其中定义了很多变量用于存储Token与认证用户间的关系
  4. JwtTokenStore 提供了基于JWT存储Token的实现，这里不需要真正的存储token，因为用户认证信息已经在token中进行存储了
  5. JwkTokenStore
3.3、InMemoryTokenStore 实现类

  在TokenStore 接口的实现类中，InMemoryTokenStore 、JdbcTokenStore 和 RedisTokenStore 三个实现类是需要实现token数据的存储工作的，无非是存储的位置不一样，这里以InMemoryTokenStore 实现类为例，分析对应方法是如何实现的。

  首先，InMemoryTokenStore 是把数据存储到内存中的，通过定义一些变量进行存储访问token、刷新token、用户认证信息、客户端信息等数据间的关系，实现存储的变量如下所示：

public class InMemoryTokenStore implements TokenStore {

	//维护accessToken字符串与OAuth2AccessToken对象的关系
	private final ConcurrentHashMap<String, OAuth2AccessToken> accessTokenStore = new ConcurrentHashMap<String, OAuth2AccessToken>();
	//维护OAuth2Authentication与OAuth2AccessToken对象的关系，其中key值是OAuth2Authentication对象经过处理得到得字符串
	private final ConcurrentHashMap<String, OAuth2AccessToken> authenticationToAccessTokenStore = new ConcurrentHashMap<String, OAuth2AccessToken>();
	//维护用户名 与 OAuth2AccessToken对象的关系，一个用户可能对应多个OAuth2AccessToken对象
	private final ConcurrentHashMap<String, Collection<OAuth2AccessToken>> userNameToAccessTokenStore = new ConcurrentHashMap<String, Collection<OAuth2AccessToken>>();
	//维护clientId 与 OAuth2AccessToken对象的关系，一个clientId可能对应多个OAuth2AccessToken对象
	private final ConcurrentHashMap<String, Collection<OAuth2AccessToken>> clientIdToAccessTokenStore = new ConcurrentHashMap<String, Collection<OAuth2AccessToken>>();
	//维护refreshToken字符串与OAuth2AccessToken对象的关系
	private final ConcurrentHashMap<String, OAuth2RefreshToken> refreshTokenStore = new ConcurrentHashMap<String, OAuth2RefreshToken>();
	//维护AccessToken对象value值与RefreshToken对象的value值的关系
	private final ConcurrentHashMap<String, String> accessTokenToRefreshTokenStore = new ConcurrentHashMap<String, String>();
	//维护AccessToken字符串与OAuth2Authentication的关系
	private final ConcurrentHashMap<String, OAuth2Authentication> authenticationStore = new ConcurrentHashMap<String, OAuth2Authentication>();
	//维护refreshToken字符串与OAuth2Authentication的关系
	private final ConcurrentHashMap<String, OAuth2Authentication> refreshTokenAuthenticationStore = new ConcurrentHashMap<String, OAuth2Authentication>();
	//维护refreshToken字符串与AccessToken字符串的关系
	private final ConcurrentHashMap<String, String> refreshTokenToAccessTokenStore = new ConcurrentHashMap<String, String>();
	//维护具有实现要求的token对象
	private final DelayQueue<TokenExpiry> expiryQueue = new DelayQueue<TokenExpiry>();
	private final ConcurrentHashMap<String, TokenExpiry> expiryMap = new ConcurrentHashMap<String, TokenExpiry>();

	//用来根据用户认证信息生产对应key值的工具类
	private AuthenticationKeyGenerator authenticationKeyGenerator = new DefaultAuthenticationKeyGenerator();
	
}

  InMemoryTokenStore 实现类实现了接口中定义的方法，其实归根结底就是维护这些数据间的关系，通过变量进行维护，而在基于JDBC的方式中，只需要一张表维护，而这里需要几个字段属性配合使用，具体实现如下所示：

readAuthentication()方法

  查询OAuth2Authentication（认证的用户信息），提供了如下两个方法。

//根据AccessToken对象查询对应的OAuth2Authentication（认证的用户信息），实际调用了readAuthentication(String token)实现
public OAuth2Authentication readAuthentication(OAuth2AccessToken token) {
	return readAuthentication(token.getValue());
}
// 根据AccessToken字符串查询对应的OAuth2Authentication（认证的用户信息）
public OAuth2Authentication readAuthentication(String token) {
	return this.authenticationStore.get(token);
}
removeAccessToken()方法

  移除acessToken对象。

public void removeAccessToken(OAuth2AccessToken accessToken) {
	removeAccessToken(accessToken.getValue());
}
//需要移除所有关联的acessToken对象
public void removeAccessToken(String tokenValue) {
	//移除accessTokenStore中存在的acessToken对象
	OAuth2AccessToken removed = this.accessTokenStore.remove(tokenValue);
	//移除accessTokenToRefreshTokenStore中的acessToken
	this.accessTokenToRefreshTokenStore.remove(tokenValue);
	//移除authenticationStore中的acessToken，并获取OAuth2Authentication对象，后续根据clientId、username移除对应的acessToken
	OAuth2Authentication authentication = this.authenticationStore.remove(tokenValue);
	if (authentication != null) {
		//根据OAuth2Authentication 生成的key移除AccessToken
		this.authenticationToAccessTokenStore.remove(authenticationKeyGenerator.extractKey(authentication));
		Collection<OAuth2AccessToken> tokens;
		String clientId = authentication.getOAuth2Request().getClientId();
		//获取clientId+username对应的OAuth2AccessToken集合
		tokens = this.userNameToAccessTokenStore.get(getApprovalKey(clientId, authentication.getName()));
		if (tokens != null) {
			//移除上述集合中的值为tokenValue的OAuth2AccessToken 对象
			tokens.remove(removed);
		}
		//同理，移除clientIdToAccessTokenStore中的值为tokenValue的OAuth2AccessToken 对象
		tokens = this.clientIdToAccessTokenStore.get(clientId);
		if (tokens != null) {
			tokens.remove(removed);
		}
		//根据OAuth2Authentication 生成的key移除AccessToken
		this.authenticationToAccessTokenStore.remove(authenticationKeyGenerator.extractKey(authentication));
	}
}
storeAccessToken()方法

  维护OAuth2AccessToken对象与OAuth2Authentication对象的关系，定期（默认每存储1000次就会移除带有时限的token）清理过期token，为了清除过期token，维护了一个expiryQueue队列。

public void storeAccessToken(OAuth2AccessToken token, OAuth2Authentication authentication) {
	//定期清理缓存中过期的token数据，实际调用了removeAccessToken()方法时限，同时维护expiryQueue队列
	if (this.flushCounter.incrementAndGet() >= this.flushInterval) {
		//维护expiryQueue队列,并清除对应的 token数据
		flush();
		//重新计时
		this.flushCounter.set(0);
	}
	//下面代码主要就是操作对应的变量，维护token与其他对象的关系
	this.accessTokenStore.put(token.getValue(), token);
	this.authenticationStore.put(token.getValue(), authentication);
	this.authenticationToAccessTokenStore.put(authenticationKeyGenerator.extractKey(authentication), token);
	if (!authentication.isClientOnly()) {
		addToCollection(this.userNameToAccessTokenStore, getApprovalKey(authentication), token);
	}
	addToCollection(this.clientIdToAccessTokenStore, authentication.getOAuth2Request().getClientId(), token);
	//如果是有时限要求的token,需要放到队列进行管理
	if (token.getExpiration() != null) {
		TokenExpiry expiry = new TokenExpiry(token.getValue(), token.getExpiration());
		// Remove existing expiry for this token if present
		expiryQueue.remove(expiryMap.put(token.getValue(), expiry));
		this.expiryQueue.put(expiry);
	}
	//如果存在刷新token，就维护刷新token与accessToken的对应关系
	if (token.getRefreshToken() != null && token.getRefreshToken().getValue() != null) {
		this.refreshTokenToAccessTokenStore.put(token.getRefreshToken().getValue(), token.getValue());
		this.accessTokenToRefreshTokenStore.put(token.getValue(), token.getRefreshToken().getValue());
	}
}
readAccessToken()方法

  根据AccessToken的value值查询对应的token对象。其实就是通过accessTokenStore变量直接获取即可，代码非常简单，如下所示：

public OAuth2AccessToken readAccessToken(String tokenValue) {
	return this.accessTokenStore.get(tokenValue);
}
storeRefreshToken()方法

  存储刷新Token，建立refreshToken 与 OAuth2Authentication（认证的用户信息）之间的关联关系，其实就是维护对应的变量，实现非常简单，如下所示：

public void storeRefreshToken(OAuth2RefreshToken refreshToken, OAuth2Authentication authentication) {
	this.refreshTokenStore.put(refreshToken.getValue(), refreshToken);
	this.refreshTokenAuthenticationStore.put(refreshToken.getValue(), authentication);
}
readRefreshToken()方法

  根据RefreshToken的value值查询对应的刷新token对象，实现如下：

public OAuth2RefreshToken readRefreshToken(String tokenValue) {
	return this.refreshTokenStore.get(tokenValue);
}
readAuthenticationForRefreshToken()方法

  根据RefreshToken对象查询对应的OAuth2Authentication（认证的用户信息）,实现如下：

public OAuth2Authentication readAuthenticationForRefreshToken(OAuth2RefreshToken token) {
	return readAuthenticationForRefreshToken(token.getValue());
}

public OAuth2Authentication readAuthenticationForRefreshToken(String token) {
	return this.refreshTokenAuthenticationStore.get(token);
}
removeRefreshToken()方法

  移除OAuth2RefreshToken 对象，实现如下：

public void removeRefreshToken(OAuth2RefreshToken refreshToken) {
	removeRefreshToken(refreshToken.getValue());
}

public void removeRefreshToken(String tokenValue) {
	this.refreshTokenStore.remove(tokenValue);
	this.refreshTokenAuthenticationStore.remove(tokenValue);
	this.refreshTokenToAccessTokenStore.remove(tokenValue);
}
removeAccessTokenUsingRefreshToken()方法

  据OAuth2RefreshToken 对象，移除关联的AccessToken对象，实现如下：

public void removeAccessTokenUsingRefreshToken(OAuth2RefreshToken refreshToken) {
	removeAccessTokenUsingRefreshToken(refreshToken.getValue());
}

private void removeAccessTokenUsingRefreshToken(String refreshToken) {
	String accessToken = this.refreshTokenToAccessTokenStore.remove(refreshToken);
	if (accessToken != null) {
		removeAccessToken(accessToken);
	}
}
getAccessToken()方法

  根据OAuth2Authentication 对象查询OAuth2AccessToken 对象，实现如下：

public OAuth2AccessToken getAccessToken(OAuth2Authentication authentication) {
	//查询OAuth2Authentication 对应的key值
	String key = authenticationKeyGenerator.extractKey(authentication);
	//查询对应的OAuth2AccessToken 对象
	OAuth2AccessToken accessToken = authenticationToAccessTokenStore.get(key);
	//根据查询的accessToken 反查对应的OAuth2Authentication 对象，然后对比key是否已知，不一致，重新再维护对应关系，避免下次无法被查询到
	if (accessToken != null&& !key.equals(authenticationKeyGenerator.extractKey(readAuthentication(accessToken.getValue())))) {
		storeAccessToken(accessToken, authentication);
	}
	return accessToken;
}
findTokensByClientIdAndUserName()方法、findTokensByClientId()方法

  前者，根据clientId + username 查询OAuth2AccessToken集合；后者，根据clientId 查询OAuth2AccessToken集合。

public Collection<OAuth2AccessToken> findTokensByClientIdAndUserName(String clientId, String userName) {
	Collection<OAuth2AccessToken> result = userNameToAccessTokenStore.get(getApprovalKey(clientId, userName));
	return result != null ? Collections.<OAuth2AccessToken> unmodifiableCollection(result) : Collections
			.<OAuth2AccessToken> emptySet();
}

public Collection<OAuth2AccessToken> findTokensByClientId(String clientId) {
	Collection<OAuth2AccessToken> result = clientIdToAccessTokenStore.get(clientId);
	return result != null ? Collections.<OAuth2AccessToken> unmodifiableCollection(result) : Collections
			.<OAuth2AccessToken> emptySet();
}

4、最后

  这里分析了TokenStore接口的实现类InMemoryTokenStore，其实归根结底就是维护访问token、刷新token、用户认证信息、客户端信息等数据间的关系，并实现这些数据的存储（持久化）工作，而JdbcTokenStore 、RedisTokenStore 本质上也是实现这些数据的持久化工作，只是因为存储方式的不同，实现有所区别而已，这里不再重复。但是关于JwtTokenStore 的实现确实有所不同的，该实现类没有实现token的存储，所有数据都是通过token进行转化而来，这样带来了实现方式的不同，下一节我们专门来分析JwtTokenStore 是如何实现和使用的。

姠惢荇者
关注
  • 9
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
OAuth2.0协议原理与实现：TOKEN生成算法
weixin_34419321的博客
03-11 5000
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring Cloud OAuth2 认证服务器
凉茶铺的博客
08-31 2981
Spring Cloud OAuth2 是 Spring Cloud 体系对OAuth2协议的实现，可以用来做多个微服务的统一认证（验证身份合法性）授权（验证权限）。通过向OAuth2服务（统一认证授权服务）发送某个类型的grant_type进行集中认证和授权，从而获得access_token（访问令牌），而这个token是受其他微服务信任的。............
Spring Cloud Oauth2 扩展
凉茶铺的博客
09-01 910
OAuth2帮我们生成的JWT令牌载荷部分信息有限，关于用户信息只有一个user_name，有些场景下我们希望放入一些扩展信息项，比如，之前我们经常向session中存入userId，或者现在我希望在JWT的载荷部分存入当时请求令牌的客户端IP，客户端携带令牌访问资源服务时，可以对比当前请求的客户端真实IP和令牌中存放的客户端IP是否匹配，不匹配拒绝请求，以此进一步提高安全性。获取到扩展信息后，就可以做其他的处理了，比如根据userId进一步处理，或者根据clientIp处理，或者其他都是可以的了。...
DefaultTokenServices源码
最新发布
pscool的博客
06-09 281
DefaultTokenServices是掌握spring security oauth2 颁发令牌的重要实现，它有着`发放令牌`，`存储令牌`，`令牌校验`，`令牌撤销`等功能； DefaultTokenServices实现了3个接口：AuthorizationServerTokenServices、`ResourceServerTokenServices`、`ConsumerTokenServices`
Springsecurity普通登录认证和OAuth2产生token的认证流程
join_null的博客
08-10 5719
一、普通登录认证过程 1.用户发起登录请求，请求登录接口/login（springsecurity默认登录接口地址） 2.过滤器UsernamePasswordAuthenticationFilter验证当前请求是否是在请求登录接口/login,如果是调用attemptAuthentication方法开始认证 3.attemptAuthentication方法在请求中获取到username、password参数封装成一个Authentication对象，调用...
spring-security-oauth2-authorization-server（二）Token生成分析之JWT Token和Opaque Token
weixin_42229668的博客
09-17 3569
因为SpringBoot3.x是目前最新的版本，整合spring-security-oauth2-authorization-server的资料很少，所以产生了这篇文章，主要为想尝试SpringBoot高版本，想整合最新的spring-security-oauth2-authorization-server的初学者，旨在为大家提供一个简单上手的参考，如果哪里写得不对或可以优化的还请大家踊跃评论指正。前面一篇文章。
spring cloud笔记 oauth2授权服务 默认tokenService配置源码
路过君的博客
03-23 3100
AuthorizationServerEndpointsConfiguration ... private AuthorizationServerEndpointsConfigurer endpoints = new AuthorizationServerEndpointsConfigurer(); ... //注册工厂 @Bean public FactoryBean<Authorizat...
Spring Security OAuth2认证授权示例详解
08-25
在Spring Security OAuth2中，创建一个授权服务器需要使用`@EnableAuthorizationServer`注解，并且扩展`AuthorizationServerConfigurerAdapter`类。以下是一个配置示例： ```java @Configuration @...
Spring Security整合Oauth2实现流程详解
09-07
在`pom.xml`文件中，引入Spring Security、Spring Web、OAuth2的客户端库以及Spring Data Redis，用于存储令牌。注意，这里的OAuth2是Spring Security的实现，而不是Spring Boot自带的。 ```xml <groupId>org....
详解OAuth2 Token 一定要放在请求头中吗
08-18
在本文中，我们详细介绍了 OAuth2 Token 是否一定要放在请求头中的问题，我们也了解了 Spring Security OAuth2 的解析过程及其扩展点的应用场景。我们可以看到，OAuth2 Token 不一定要放在请求头中，我们可以从多个...
spring security oauth2 实现jwt sso
11-14
Spring Security OAuth2 与 JWT 实现的SSO详解 在当今的互联网应用中，单点登录（Single Sign-On，简称SSO）已经成为一种常见的身份验证机制，它允许用户在一个系统中登录后，无需再次登录就能访问其他关联系统。在...
spring security oauth2整合
07-27
Spring Security OAuth2 整合详解 Spring Security OAuth2 是一个基于 Spring Security 框架的 OAuth 2.0 授权协议实现。OAuth 2.0 是一个标准化的授权协议/框架，使得第三方应用程序可以通过协调资源所有者和 ...
Spring Security Oauth2使用JWT生成Token
LiaoHongHB的博客
11-13 7732
转载务必说明出处：https://blog.csdn.net/LiaoHongHB/article/details/84031281 在我们平时使用oauth2的协议中，生成的token是基于oauth2协议本身的生成策略，如下面的代码（一般在登陆成功的handler中生成token）.： package com.car.springsecurity.handle; import com....
SpringSecurity-Oauth2 之JWT令牌详解
qq_42861526的博客
08-06 3596
这两个时机的执行都是依靠JwtAccessTokenConverter来完成的注意：上面说的只是组件，JWT暴露给SpringSecurity的服务是tokenService，SpringSecurity也是通过tokenService来完成token的生成、解析以及存储的 （二) 组件之间的依赖关系 JWT暴露给tokenService使用的类是tokenStore，而tokenStore又依赖于accessTokenConvert和authenticationConvert完成token的生成和解析
spring boot oauth2 支持不同登录类型 自定义token信息返回
Riteny的博客
06-09 1165
近期在项目需求上需要用到不同的用户类型，并且不同的用户，check_token 返回的信息也需要不一样 在这里例子发上来，希望能够帮到别人，同时也给自己留个记录 首先，先添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</arti
Oauth2密码模式获取Token过程
lthym的博客
05-28 1809
因在工作中经常使用到Oauth2协议密码模式，特此写一篇关于密码模式认证生成token流程。在本文中指明主要的方法。 1.进入AbstractAuthenticationProcessingFilter类中,调用attemptAuthentication()获取Authentication. 2.获取client_id,client_secret，封装authentication对对象，下一步调用ProviderManager类中authenticate方法 未完。。。。 ...
FastAPI 基于OAuth2和JWT的Token认证机制(一)生成token
高压锅博客
06-18 1070
1. OAuth2PasswordBearer OAuth2PasswordBearer是接收URL作为参数的一个类：客户端会向该URL发送username和password参数，然后得到一个token值。 OAuth2PasswordBearer并不会创建相应的URL路径操作，只是指明了客户端用来获取token的目标URL。 当请求到来的时候，FastAPI会检查请求的Authorization头信息，如果没有找到Authorization头信息，或者头信息的内容不是Bearer token，它会返
Spring Security OAuth2 实现登录互踢
weixin_52996020的博客
11-18 1477
Spring Security OAuth2 实现登录互踢 工作中遇到的问题，通过网上查找资料，解决问题，记录一下，防止丢失。 1、重写DefaultTokenServices中的方法 ​ 自定义一个TokenService类继承DefaultTokenServices，重写里面的createAccessToken、setTokenStore和setTokenEnhancer方法，代码如下： public class TokenService extends DefaultTokenServices {
spring security oauth2 令牌生成源码解析
攻城狮子的博客
05-09 2582
spring security oauth2 令牌生成流程为（蓝色字体为类，红色字体为接口）：/oauth/token/请求  --&gt; TokenEndpoint --&gt;  ClientDetailsService(InMemoryClientDetailsService) --&gt; ClientDetails --&gt; TokenRequest --&gt; TokenGra...
Spring security oauth2 Authorization Server Token增强
06-03
Spring Security OAuth2 Authorization Server可以通过Token增强器（Token Enhancer）来为授权后返回的Access Token添加额外的信息。Token增强器是一个接口，它接收一个Access Token并返回一个增强后的Access Token。在Authorization Server配置类中，可以通过调用tokenEnhancer()方法来设置Token增强器，示例代码如下： ```java @Configuration @EnableAuthorizationServer public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter { @Autowired private AuthenticationManager authenticationManager; @Autowired private UserDetailsService userDetailsService; @Autowired private DataSource dataSource; @Bean public TokenStore tokenStore() { return new JdbcTokenStore(dataSource); } @Bean public JwtAccessTokenConverter accessTokenConverter() { JwtAccessTokenConverter converter = new JwtAccessTokenConverter(); converter.setSigningKey("123456"); return converter; } @Bean public TokenEnhancer tokenEnhancer() { return new CustomTokenEnhancer(); } @Override public void configure(ClientDetailsServiceConfigurer clients) throws Exception { clients.jdbc(dataSource); } @Override public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception { endpoints.authenticationManager(authenticationManager) .userDetailsService(userDetailsService) .tokenStore(tokenStore()) .accessTokenConverter(accessTokenConverter()) .tokenEnhancer(tokenEnhancer()); } @Override public void configure(AuthorizationServerSecurityConfigurer oauthServer) throws Exception { oauthServer.tokenKeyAccess("permitAll()") .checkTokenAccess("isAuthenticated()") .allowFormAuthenticationForClients(); } } ``` 在上面的代码中，CustomTokenEnhancer是一个自定义的Token增强器，它可以在Access Token中添加额外的信息。示例代码如下： ```java public class CustomTokenEnhancer implements TokenEnhancer { @Override public OAuth2AccessToken enhance(OAuth2AccessToken accessToken, OAuth2Authentication authentication) { Map<String, Object> additionalInfo = new HashMap<>(); additionalInfo.put("organization", authentication.getName() + "@test.com"); ((DefaultOAuth2AccessToken) accessToken).setAdditionalInformation(additionalInfo); return accessToken; } } ``` 在上面的代码中，我们向Access Token中添加了一个名为“organization”的信息，它的值为当前用户的用户名加上@test.com。这种方式可以为Access Token添加任何我们需要的信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

姠惢荇者

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值