Pig4Cloud之登陆验证（二）发放token

最新推荐文章于 2024-04-16 09:20:34 发布
最新推荐文章于 2024-04-16 09:20:34 发布
阅读量1.5k 收藏 3
点赞数
分类专栏： 后端 文章标签： java c# 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Devilli0310/article/details/128219691
版权

上一篇介绍了客户端认证处理，那是令牌颁发的前提。这篇开始，我们就来研究下令牌颁发。

令牌颁发

授权服务器提供令牌颁发接口（/oauth2/token），由客户端发起请求，授权服务器生成访问令牌（access_token）返回，客户端使用此令牌才能去调用资源服务器的接口。

Spring Authorization Server 目前支持如下三种令牌颁发策略：Authorization Code、Client Credentials、Refresh Token，分别对应 授权码模式、客户端凭证模式、刷新令牌模式。

Authorization Code（授权码模式）

客户端访问授权链接，用户授权，客户端获得授权码code，通过code获取令牌

  • 传参

    • grant_type：固定值 authorization_code
    • code：授权码

  • 核心类

    • OAuth2AuthorizationCodeAuthenticationConverter
    • OAuth2AuthorizationCodeAuthenticationProvider

Client Credentials（客户端凭证模式）

  • 传参
    • grant_type：固定值 client_credentials
  • 核心类
    • OAuth2ClientCredentialsAuthenticationConverter
    • OAuth2ClientCredentialsAuthenticationProvider

Refresh Token（刷新令牌模式）

当客户端支持刷新令牌时，授权服务器颁发访问令牌(access_token)时会同时颁发刷新令牌(refresh_token)，客户端可以使用刷新令牌重新获取访问令牌。（由于访问令牌时效比较短，刷新令牌时效比较长，通过刷新令牌获取访问令牌，避免多次授权）

  • 传参
    • grant_type：固定值 refresh_token
    • refresh_token：刷新令牌
  • 核心类
    • OAuth2RefreshTokenAuthenticationConverter
    • OAuth2RefreshTokenAuthenticationProvider

OAuth2TokenEndpointFilter

实现令牌颁发功能的拦截器就是 OAuth2TokenEndpointFilter。OAuth2TokenEndpointFilter 会接收通过上文 OAuth2ClientAuthenticationFilter 客户端认证的请求,其核心代码如下：

@Override
	protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
			throws ServletException, IOException {
        //step1
		if (!this.tokenEndpointMatcher.matches(request)) {
			filterChain.doFilter(request, response);
			return;
		}

		try {
			String[] grantTypes = request.getParameterValues(OAuth2ParameterNames.GRANT_TYPE);
			if (grantTypes == null || grantTypes.length != 1) {
				throwError(OAuth2ErrorCodes.INVALID_REQUEST, OAuth2ParameterNames.GRANT_TYPE);
			}
        //step2
			Authentication authorizationGrantAuthentication = this.authenticationConverter.convert(request);
			if (authorizationGrantAuthentication == null) {
				throwError(OAuth2ErrorCodes.UNSUPPORTED_GRANT_TYPE, OAuth2ParameterNames.GRANT_TYPE);
			}
			if (authorizationGrantAuthentication instanceof AbstractAuthenticationToken) {
				((AbstractAuthenticationToken) authorizationGrantAuthentication)
						.setDetails(this.authenticationDetailsSource.buildDetails(request));
			}
        //step3
			OAuth2AccessTokenAuthenticationToken accessTokenAuthentication =
					(OAuth2AccessTokenAuthenticationToken) this.authenticationManager.authenticate(authorizationGrantAuthentication);
        //step4
			this.authenticationSuccessHandler.onAuthenticationSuccess(request, response, accessTokenAuthentication);
		} catch (OAuth2AuthenticationException ex) {
			SecurityContextHolder.clearContext();
			this.authenticationFailureHandler.onAuthenticationFailure(request, response, ex);
		}
	}

step1.判断此次请求是否是 “令牌颁发” 请求，若是，则继续授权模式检验，否则跳过
step2.解析请求中的参数，构建成一个 Authentication（组装登陆认证对象）
step3.认证管理器对 Authentication 进行认证
step4.到这一步说明access_token生成好了， 将access_token和相关信息响应给请求方。

客户端认证 OAuth2ClientAuthenticationFilter 中也正是用的这种实现套路。将不同实现策略抽象为 AuthenticationConverter 和 AuthenticationProvider 接口。每种策略实际上就是一个 AuthenticationConverter 实现类 加上一个 AuthenticationProvider实现类。

组装认证对象

Authentication authorizationGrantAuthentication = this.authenticationConverter.convert(request);

AuthenticationConverter 会根据请求中的参数和授权类型组装成对应的授权认证对象。
image

授权认证调用

OAuth2AccessTokenAuthenticationToken accessTokenAuthentication =
					(OAuth2AccessTokenAuthenticationToken) this.authenticationManager.authenticate(authorizationGrantAuthentication);

image
在OAuth2ResourceOwnerBaseAuthenticationProvider中
image

认证逻辑

	Authentication usernamePasswordAuthentication = authenticationManager
					.authenticate(usernamePasswordAuthenticationToken);

根据认证方法传入的参数判定进入到AbstractUserDetailsAuthenticationProvider

@Override
	public Authentication authenticate(Authentication authentication) throws AuthenticationException {
		Assert.isInstanceOf(UsernamePasswordAuthenticationToken.class, authentication,
				() -> this.messages.getMessage("AbstractUserDetailsAuthenticationProvider.onlySupports",
						"Only UsernamePasswordAuthenticationToken is supported"));
		String username = determineUsername(authentication);
		boolean cacheWasUsed = true;
		UserDetails user = this.userCache.getUserFromCache(username);
		if (user == null) {
			cacheWasUsed = false;
			try {
				user = retrieveUser(username, (UsernamePasswordAuthenticationToken) authentication);
			}
			catch (UsernameNotFoundException ex) {
				this.logger.debug("Failed to find user '" + username + "'");
				if (!this.hideUserNotFoundExceptions) {
					throw ex;
				}
				throw new BadCredentialsException(this.messages
						.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
			}
			Assert.notNull(user, "retrieveUser returned null - a violation of the interface contract");
		}
		try {
			this.preAuthenticationChecks.check(user);
			additionalAuthenticationChecks(user, (UsernamePasswordAuthenticationToken) authentication);
		}
		catch (AuthenticationException ex) {
			if (!cacheWasUsed) {
				throw ex;
			}
			// There was a problem, so try again after checking
			// we're using latest data (i.e. not from the cache)
			cacheWasUsed = false;
			user = retrieveUser(username, (UsernamePasswordAuthenticationToken) authentication);
			this.preAuthenticationChecks.check(user);
			additionalAuthenticationChecks(user, (UsernamePasswordAuthenticationToken) authentication);
		}
		this.postAuthenticationChecks.check(user);
		if (!cacheWasUsed) {
			this.userCache.putUserInCache(user);
		}
		Object principalToReturn = user;
		if (this.forcePrincipalAsString) {
			principalToReturn = user.getUsername();
		}
		return createSuccessAuthentication(principalToReturn, authentication, user);
	}

查询用户信息
image

retrieveUser方法

protected abstract UserDetails retrieveUser(String username, UsernamePasswordAuthenticationToken authentication)
			throws AuthenticationException;

PigDaoAuthenticationProvider继承了AbstractUserDetailsAuthenticationProvider并重写
retrieveUser方法。返回值为UserDetails。
image

用户密码校验
image
PigDaoAuthenticationProvider继承了AbstractUserDetailsAuthenticationProvider并重写
additionalAuthenticationChecks方法。

@Override
	@SuppressWarnings("deprecation")
	protected void additionalAuthenticationChecks(UserDetails userDetails,
			UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {

		// app 模式不用校验密码
		String grantType = WebUtils.getRequest().get().getParameter(OAuth2ParameterNames.GRANT_TYPE);
		if (StrUtil.equals(SecurityConstants.APP, grantType)) {
			return;
		}

		if (authentication.getCredentials() == null) {
			this.logger.debug("Failed to authenticate since no credentials provided");
			throw new BadCredentialsException(this.messages
					.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
		}
		String presentedPassword = authentication.getCredentials().toString();
		if (!this.passwordEncoder.matches(presentedPassword, userDetails.getPassword())) {
			this.logger.debug("Failed to authenticate since password does not match stored value");
			throw new BadCredentialsException(this.messages
					.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
		}
	}

构建token

认证成功后返回OAuth2ResourceOwnerBaseAuthenticationProvider接着看
image
CustomeOAuth2AccessTokenGenerator实现OAuth2TokenGenerator接口.

Token 存储持久化

image

image

RedisOAuth2AuthorizationService实现OAuth2AuthorizationService
save方法

@Override
	public void save(OAuth2Authorization authorization) {
		Assert.notNull(authorization, "authorization cannot be null");

		if (isState(authorization)) {
			String token = authorization.getAttribute("state");
			redisTemplate.setValueSerializer(RedisSerializer.java());
			redisTemplate.opsForValue().set(buildKey(OAuth2ParameterNames.STATE, token), authorization, TIMEOUT,
					TimeUnit.MINUTES);
		}

		if (isCode(authorization)) {
			OAuth2Authorization.Token<OAuth2AuthorizationCode> authorizationCode = authorization
					.getToken(OAuth2AuthorizationCode.class);
			OAuth2AuthorizationCode authorizationCodeToken = authorizationCode.getToken();
			long between = ChronoUnit.MINUTES.between(authorizationCodeToken.getIssuedAt(),
					authorizationCodeToken.getExpiresAt());
			redisTemplate.setValueSerializer(RedisSerializer.java());
			redisTemplate.opsForValue().set(buildKey(OAuth2ParameterNames.CODE, authorizationCodeToken.getTokenValue()),
					authorization, between, TimeUnit.MINUTES);
		}

		if (isRefreshToken(authorization)) {
			OAuth2RefreshToken refreshToken = authorization.getRefreshToken().getToken();
			long between = ChronoUnit.SECONDS.between(refreshToken.getIssuedAt(), refreshToken.getExpiresAt());
			redisTemplate.setValueSerializer(RedisSerializer.java());
			redisTemplate.opsForValue().set(buildKey(OAuth2ParameterNames.REFRESH_TOKEN, refreshToken.getTokenValue()),
					authorization, between, TimeUnit.SECONDS);
		}

		if (isAccessToken(authorization)) {
			OAuth2AccessToken accessToken = authorization.getAccessToken().getToken();
			long between = ChronoUnit.SECONDS.between(accessToken.getIssuedAt(), accessToken.getExpiresAt());
			redisTemplate.setValueSerializer(RedisSerializer.java());
			redisTemplate.opsForValue().set(buildKey(OAuth2ParameterNames.ACCESS_TOKEN, accessToken.getTokenValue()),
					authorization, between, TimeUnit.SECONDS);
		}
	}

onAuthenticationSuccess

image
PigAuthenticationSuccessEventHandler实现AuthenticationSuccessHandler

@SneakyThrows
	@Override
	public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
			Authentication authentication) {
		OAuth2AccessTokenAuthenticationToken accessTokenAuthentication = (OAuth2AccessTokenAuthenticationToken) authentication;
		Map<String, Object> map = accessTokenAuthentication.getAdditionalParameters();
		if (MapUtil.isNotEmpty(map)) {
			// 发送异步日志事件
			PigUser userInfo = (PigUser) map.get(SecurityConstants.DETAILS_USER);
			log.info("用户：{} 登录成功", userInfo.getName());
			SecurityContextHolder.getContext().setAuthentication(accessTokenAuthentication);
			SysLog logVo = SysLogUtils.getSysLog();
			logVo.setTitle("登录成功");
			String startTimeStr = request.getHeader(CommonConstants.REQUEST_START_TIME);
			if (StrUtil.isNotBlank(startTimeStr)) {
				Long startTime = Long.parseLong(startTimeStr);
				Long endTime = System.currentTimeMillis();
				logVo.setTime(endTime - startTime);
			}
			logVo.setCreateBy(userInfo.getName());
			logVo.setUpdateBy(userInfo.getName());
			SpringContextHolder.publishEvent(new SysLogEvent(logVo));
		}

		// 输出token
		sendAccessTokenResponse(request, response, authentication);
	}

输出token

private void sendAccessTokenResponse(HttpServletRequest request, HttpServletResponse response,
			Authentication authentication) throws IOException {

		OAuth2AccessTokenAuthenticationToken accessTokenAuthentication = (OAuth2AccessTokenAuthenticationToken) authentication;

		OAuth2AccessToken accessToken = accessTokenAuthentication.getAccessToken();
		OAuth2RefreshToken refreshToken = accessTokenAuthentication.getRefreshToken();
		Map<String, Object> additionalParameters = accessTokenAuthentication.getAdditionalParameters();

		OAuth2AccessTokenResponse.Builder builder = OAuth2AccessTokenResponse.withToken(accessToken.getTokenValue())
				.tokenType(accessToken.getTokenType()).scopes(accessToken.getScopes());
		if (accessToken.getIssuedAt() != null && accessToken.getExpiresAt() != null) {
			builder.expiresIn(ChronoUnit.SECONDS.between(accessToken.getIssuedAt(), accessToken.getExpiresAt()));
		}
		if (refreshToken != null) {
			builder.refreshToken(refreshToken.getTokenValue());
		}
		if (!CollectionUtils.isEmpty(additionalParameters)) {
			builder.additionalParameters(additionalParameters);
		}
		OAuth2AccessTokenResponse accessTokenResponse = builder.build();
		ServletServerHttpResponse httpResponse = new ServletServerHttpResponse(response);

		// 无状态 注意删除 context 上下文的信息
		SecurityContextHolder.clearContext();
		this.accessTokenHttpResponseConverter.write(accessTokenResponse, null, httpResponse);
	}

博客园
腾讯云
掘金
简书

一觉睡到丶小时候
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
pig4cloud服务架构使用
m0_67401228的博客
08-02 756
先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。以上就为此次源码最重要的几个模块，框架复杂度主要在启动上，每次都要依次把pig-register，pig-gateway，pig-auth，pig-upms服务的application启动起来。微服务架构存在多个服务项目，在项目开发中不可能让前端不停置换调用服务和接口，所以和出现了网关组件，保证前端直接调用网关可以分配到对应的服务接口。可以对访问的URL过滤，进行切面处理；...
Spring Cloud Feign统一设置验证token实现方法解析
08-18
在微服务架构中， token验证是非常重要的安全机制之一，本文将主要介绍如何使用Spring Cloud Feign统一设置验证token实现方法解析。 首先，我们需要了解Feign组件的工作机制。Feign组件是一个基于Annotation的接口...
pig4cloud怎样实现远程调用?
最新发布
大连赵哥的博客
04-16 490
pig4cloud怎样实现远程调用?
Pig4Cloud之登陆验证（一）客户端认证处理
少年闰土的博客
12-07 1835
Pig4Cloud之登陆验证（一）客户端认证处理
Pig4Cloud之检验token
少年闰土的博客
12-07 826
Pig4Cloud之检验token
pig4cloud
pig4cloud的博客
10-14 1141
hello world
【PIG】pig4cloud整合 knife4j
zhao3154075的博客
03-21 2125
【PIG】pig4cloud整合 knife4j
activiti表结构 .pig4cloud
洪君的博客
05-15 592
${flag.equals('同意')} ${flag.equals('驳回')} 驳回线
Spring Cloud Gateway使用Token验证详解
08-26
主要介绍了Spring Cloud Gateway使用Token验证详解，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
基于redis实现token验证用户是否登陆
01-19
基于项目需求， 我们要实现一个基于redis实现token登录验证，该如何实现呢： 后端实现： 1.引入redis相关的依赖 <groupId>org.springframework.boot <artifactId>spring-boot-starter-data-redis <groupId>...
vue+koa2实现session、token登陆状态验证的示例
10-16
主要介绍了vue+koa2实现session、token登陆状态验证的示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
PigCloud项目的使用解析一
zouyang920的博客
03-15 5248
1.项目结构 2.父模块分析 pom.xml： <?xml version="1.0" encoding="UTF-8"?> <!-- ~ Copyright (c) 2020 pig4cloud Authors. All Rights Reserved. ~ ~ Licensed under the Apache License, Version 2.0 (the "License"); ~ you may not use this file except in com
PigCloud项目的使用解析二
zouyang920的博客
03-16 1617
1.mc-edu模块结构 这面一样是使用了熔断工厂类，远程调用下面第三方接口，失败则执行熔断器的异常逻辑处理。 FamousSchoolController： package com.hst.mc.cms.controller; import cn.hutool.core.util.StrUtil; import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.core.toolkit.Wra
Spring Authorization Server OAuth2TokenEndpointFilter源码分析
maoye的博客
05-31 1768
OAuth2TokenEndpointFilter OAuth2TokenEndpointFilter是负责办法token的过滤器。 AuthenticationConverter 负责将提交的参数转换为Authentication. 该属性的实力为DelegatingAuthenticationConverter, 是一个委派转换器,委派给下面的Convert执行 下面三个convert 0 = {OAuth2AuthorizationCodeAuthenticationConverter@7035} 1
Spring 围炉夜话
Liuqz2009的专栏
10-08 276
Spring POM
【JAVA】spring cloud微服务中使用spring security auth2登录认证流程和自定义手机号认证(1)
Hey-Girl
12-07 3044
hey-girl原创文章，若有歧义可留言，若需转载需标明出处。 1.概括：本文主要根据微服务pig<v3.3.3>项目pig码云地址，学习安全登录流程。通过扩展登录需求,自定义其他登录模式，比如常见的手机号登录或者微信登录等。 2.涉及服务介绍： gateway:9999(网关服务) auth:3000(认证服务) upms:4000(资源服务) common-security(安全模块) 3.先看看pig项目中登录大致流程图: #mermaid-svg-XsEXxUni7CgjXiIP .la
Java登陆token详细流程_java基于token验证之登陆验证
05-29
Java基于token验证的登陆验证流程大致如下： 1. 用户在客户端输入用户名和密码提交登陆请求； 2. 服务器接收到登陆请求后，验证用户名和密码是否正确； 3. 如果用户名和密码验证通过，服务器生成一个token，将token存储到服务器端，并将token返回给客户端； 4. 客户端将token保存到本地，可以使用cookie或localStorage等技术进行保存； 5. 客户端在每次请求需要验证的接口时，将token通过请求头或参数的形式发送给服务器； 6. 服务器接收到请求后，从存储的token中验证该token是否有效； 7. 如果token验证通过，服务器返回请求所需的数据，否则返回错误信息。 需要注意的是，为了保证token的安全性，服务器需要对token进行加密处理，防止被恶意攻击者窃取或伪造。此外，token还需要设置过期时间，以保证安全性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值