Oauth2 基于redis的认证服务器demo

最新推荐文章于 2024-03-05 23:48:18 发布
最新推荐文章于 2024-03-05 23:48:18 发布
阅读量1.1k 收藏 4
点赞数
分类专栏： 源码分析 文章标签： spring spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/beichen8641/article/details/110734492
版权

Oauth2 基于redis的可集群认证服务器demo

功能点

  • 支持授权码、账号密码、短信验证码模式获取token
  • 授权码、短信验证码基于redis存储
  • 刷新token
  • 对springSecurity内部的认证机制进行横向优雅扩展

添加依赖

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.4.RELEASE</version>
        <relativePath/>
</parent>
    
<dependencies>

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

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.security.oauth</groupId>
        <artifactId>spring-security-oauth2</artifactId>
    </dependency>
    
    <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    
    <dependency>
            <groupId>org.springframework.session</groupId>
            <artifactId>spring-session</artifactId>
    </dependency>
        

</dependencies>

在创建认证服务前，我们先定义一个MyUser对象


public class MyUser implements Serializable {
    private static final long serialVersionUID = 3497935890426858541L;

    private String userName;
    private String password;
    private boolean accountNonExpired = true;
    private boolean accountNonLocked= true;
    private boolean credentialsNonExpired= true;
    private boolean enabled= true;

    // get set 略
}



定义UserDetailService实现

public class MyUserDetailService implements UserDetailsService {
    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        MyUser user = new MyUser();
        user.setUserName(username);
        user.setPassword(this.passwordEncoder.encode("123456"));
        return new User(username, user.getPassword(), user.isEnabled(),
                user.isAccountNonExpired(), user.isCredentialsNonExpired(),
                user.isAccountNonLocked(), AuthorityUtils.commaSeparatedStringToAuthorityList("admin"));
    }
}

这里的逻辑是用什么账号登录都可以，但是密码必须为123456，并且拥有”admin”权限


定义消息渲染类，类似于在Filter做到MVC返回一个实体到前端解析成josn的功能

public class EntityResponseRenderer {

	private final Log logger = LogFactory.getLog(EntityResponseRenderer.class);

	private List<HttpMessageConverter<?>> messageConverters = geDefaultMessageConverters();

	public void setMessageConverters(List<HttpMessageConverter<?>> messageConverters) {
		this.messageConverters = messageConverters;
	}

	public void writeHttpEntityResponse(Object responseObj,
										HttpStatus httpStatus,
										ServletRequest request, ServletResponse response) {
		try {
			HttpHeaders headers = new HttpHeaders();
			ResponseEntity responseEntity=new ResponseEntity(responseObj,headers, httpStatus);
			HttpServletRequest req = (HttpServletRequest) request;
			HttpServletResponse res = (HttpServletResponse) response;
			ServletWebRequest webRequest=new ServletWebRequest(req, res);
			if (responseEntity == null) {
				return;
			}
			HttpInputMessage inputMessage = createHttpInputMessage(webRequest);
			HttpOutputMessage outputMessage = createHttpOutputMessage(webRequest);
			if (responseEntity instanceof ResponseEntity && outputMessage instanceof ServerHttpResponse) {
				((ServerHttpResponse) outputMessage).setStatusCode(((ResponseEntity<?>) responseEntity).getStatusCode());
			}
			HttpHeaders entityHeaders = responseEntity.getHeaders();
			if (!entityHeaders.isEmpty()) {
				outputMessage.getHeaders().putAll(entityHeaders);
			}
			Object body = responseEntity.getBody();
			if (body != null) {
				writeWithMessageConverters(body, inputMessage, outputMessage);
			}
			else {
				// flush headers
				outputMessage.getBody();
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	@SuppressWarnings({ "unchecked", "rawtypes" })
	private void writeWithMessageConverters(Object returnValue, HttpInputMessage inputMessage,
			HttpOutputMessage outputMessage) throws IOException, HttpMediaTypeNotAcceptableException {
		List<MediaType> acceptedMediaTypes = inputMessage.getHeaders().getAccept();
		if (acceptedMediaTypes.isEmpty()) {
			acceptedMediaTypes = Collections.singletonList(MediaType.ALL);
		}
		MediaType.sortByQualityValue(acceptedMediaTypes);
		Class<?> returnValueType = returnValue.getClass();
		List<MediaType> allSupportedMediaTypes = new ArrayList<MediaType>();
		for (MediaType acceptedMediaType : acceptedMediaTypes) {
			for (HttpMessageConverter messageConverter : messageConverters) {
				if (messageConverter.canWrite(returnValueType, acceptedMediaType)) {
					messageConverter.write(returnValue, acceptedMediaType, outputMessage);
					if (logger.isDebugEnabled()) {
						MediaType contentType = outputMessage.getHeaders().getContentType();
						if (contentType == null) {
							contentType = acceptedMediaType;
						}
						logger.debug("Written [" + returnValue + "] as \"" + contentType + "\" using ["
								+ messageConverter + "]");
					}
					return;
				}
			}
		}
		for (HttpMessageConverter messageConverter : messageConverters) {
			allSupportedMediaTypes.addAll(messageConverter.getSupportedMediaTypes());
		}
		throw new HttpMediaTypeNotAcceptableException(allSupportedMediaTypes);
	}

	private List<HttpMessageConverter<?>> geDefaultMessageConverters() {
		List<HttpMessageConverter<?>> result = new ArrayList<HttpMessageConverter<?>>();
		result.addAll(new RestTemplate().getMessageConverters());
		result.add(new JaxbOAuth2ExceptionMessageConverter());
		return result;
	}

	private HttpInputMessage createHttpInputMessage(NativeWebRequest webRequest) throws Exception {
		HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
		return new ServletServerHttpRequest(servletRequest);
	}

	private HttpOutputMessage createHttpOutputMessage(NativeWebRequest webRequest) throws Exception {
		HttpServletResponse servletResponse = (HttpServletResponse) webRequest.getNativeResponse();
		return new ServletServerHttpResponse(servletResponse);
	}

}

定义基于redis的授权码存储器

/**
 * 默认的授权码存储为InMemoryAuthorizationCodeServices， 不适用于微服务场景， 需要
 * 自定义一个基于redis的授权码存储器
 * @program: spring-security-demo
 * @description:
 * @author: chenzejie
 * @create: 2019-09-04 13:49
 **/
public class InRedisAuthorizationCodeServices  extends RandomValueAuthorizationCodeServices {
    private RedisTemplate<String,OAuth2Authentication> redisTemplate;
    private String prefix="authorization:code:";
    public InRedisAuthorizationCodeServices(RedisTemplate<String,OAuth2Authentication> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    @Override
    protected void store(String code, OAuth2Authentication authentication) {
        redisTemplate.opsForValue().set(key(code),authentication,120, TimeUnit.SECONDS);
    }

    public String key(String code){
        return prefix+code;
    }


    @Override
    protected OAuth2Authentication remove(String code) {
        OAuth2Authentication oAuth2Authentication=redisTemplate.opsForValue().get(key(code));
        if(oAuth2Authentication!=null){
            redisTemplate.delete(key(code));
        }
        return oAuth2Authentication;
    }
}

定义oauth2 登出过滤器

/**
 * @program: spring-security-demo
 * @description: oauth2登出过滤器
 * @author: chenzejie
 * @create: 2019-09-06 17:00
 **/
public class Oauth2LogoutFilter extends GenericFilterBean {

    private RequestMatcher requiresLogoutRequestMatcher;
    private String logoutSucessResponse;
    private TokenStore tokenStore;
    private EntityResponseRenderer entityResponseRenderer=new EntityResponseRenderer();

    /**
     * 默认构造参数需要接收一个请求匹配器，用于处理指定的登出请求
     * @param requiresLogoutRequestMatcher
     */
    public Oauth2LogoutFilter(RequestMatcher requiresLogoutRequestMatcher) {
        this.requiresLogoutRequestMatcher=requiresLogoutRequestMatcher;
    }


    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        /**
         * 如果请求不符合登出请求则忽略
         */
        if(!requiresLogout((HttpServletRequest)request)){
            chain.doFilter(request, response);
            return;
        }

        /**
         * 因为当前过滤器是绑定在OAuth2AuthenticationProcessingFilter后面的， OAuth2AuthenticationProcessingFilter
         * 是负责校验token的合法性， 当到达这里时证明身份已经通过校验，则可以拿到上下文的身份信息
         */
        Authentication authentication=SecurityContextHolder.getContext().getAuthentication();
        if(authentication!=null){
            /**
             * OAuth2AuthenticationProcessingFilter 通过校验后会把token存放在request的作用域里
             * key为OAuth2AuthenticationDetails.ACCESS_TOKEN_VALUE
             */
            String access_token=(String)request.getAttribute(OAuth2AuthenticationDetails.ACCESS_TOKEN_VALUE);
            //设置当前上下文的身份信息为null
            SecurityContextHolder.getContext().setAuthentication(null);
            //从token存储器中获取OAuth2AccessToken
            OAuth2AccessToken oAuth2AccessToken=tokenStore.readAccessToken(access_token);

            /**
             * 使用token存储器删除accessToken 和 refreshToken
             */
            if(oAuth2AccessToken!=null){
                tokenStore.removeAccessToken(oAuth2AccessToken);
            }
            if(oAuth2AccessToken.getRefreshToken()!=null){
                tokenStore.removeRefreshToken(oAuth2AccessToken.getRefreshToken());
            }
            /**
             * 成功退出后的处理， 里面暂时做了输出一窜成功登出的字符串， 你可以在里面
             * 扩展自己的用户退出逻辑
             */
            onSuccessLogout(request,response);
            return;
        }

    }

    private void onSuccessLogout(ServletRequest request, ServletResponse response) throws IOException {
        entityResponseRenderer.writeHttpEntityResponse(
                new MessageEntity(logoutSucessResponse, HttpStatus.OK.value()),
                HttpStatus.OK,
                request,
                response
        );
    }

    protected boolean requiresLogout(HttpServletRequest request) {
        return requiresLogoutRequestMatcher.matches(request);
    }

    public void setLogoutSucessResponse(String logoutSucessResponse) {
        this.logoutSucessResponse = logoutSucessResponse;
    }


    public void setTokenStore(TokenStore tokenStore) {
        this.tokenStore = tokenStore;
    }


}


/**
 * @program: spring-security-demo
 * @description: 登出过滤器的配置项，委派给HttpSecurity调用
 * @author: chenzejie
 * @create: 2019-09-06 17:23
 **/
public class Oauth2LogoutConfigurer extends
        SecurityConfigurerAdapter<DefaultSecurityFilterChain, HttpSecurity> {
    /**
     * 处理退出请求的地址
     */
    private String defaultLogoutUrl="/oauth2/logout";
    /**
     * 退出成功后的字符串信息
     */
    private String logoutSuccessResponse="{'code':1,'message':'成功退出'}";
    /**
     * token存储器
     */
    private TokenStore tokenStore;
    @Override
    public void configure(HttpSecurity http) throws Exception {
        Oauth2LogoutFilter filter=new Oauth2LogoutFilter(new AntPathRequestMatcher(defaultLogoutUrl));
        filter.setTokenStore(tokenStore);
        filter.setLogoutSucessResponse(logoutSuccessResponse);
        //把Oauth2LogoutFilter作用在OAuth2AuthenticationProcessingFilter后
        http.addFilterAfter(filter, OAuth2AuthenticationProcessingFilter.class);
    }

    public Oauth2LogoutConfigurer defaultLogoutUrl(String defaultLogoutUrl) {
        this.defaultLogoutUrl = defaultLogoutUrl;
        return this;
    }

    public Oauth2LogoutConfigurer logoutSuccessResponse(String logoutSuccessResponse) {
        this.logoutSuccessResponse = logoutSuccessResponse;
        return this;
    }

    public Oauth2LogoutConfigurer tokenStore(TokenStore tokenStore) {
        this.tokenStore = tokenStore;
        return this;
    }
}

手机验证码认证相关代码

Redis操作手机验证码相关代码

/**
 * Redis操作手机验证码服务
 */
@Service
public class RedisCodeService {

    private final static String SMS_CODE_PREFIX = "SMS_CODE:";
    private final static Integer TIME_OUT = 300;

    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * 保存验证码到 redis
     *
     * @param smsCode 短信验证码
     */
    public void save(String smsCode, String mobile) {
        redisTemplate.opsForValue().set(key( mobile), smsCode , TIME_OUT, TimeUnit.SECONDS);
    }

    /**
     * 获取验证码
     *
     * @return 验证码
     */
    public String get( String mobile)  {
        return redisTemplate.opsForValue().get(key( mobile));
    }

    /**
     * 移除验证码
     *
     */
    public void remove( String mobile) {
        redisTemplate.delete(key( mobile));
    }

    private String key( String mobile)  {
        return SMS_CODE_PREFIX + ":" + mobile;
    }
}

定义基于短信认证的异常

/**
 * @program: spring-security-demo
 * @description:  定义基于短信认证的异常
 * @author: chenzejie
 * @create: 2019-09-02 16:44
 **/
public class SmsAuthenicationException extends AuthenticationException {
    public SmsAuthenicationException(String msg, Throwable t) {
        super(msg, t);
    }

    public SmsAuthenicationException(String msg) {
        super(msg);
    }
}

短信验证码授权过滤器

/**
 * @program: spring-security-demo
 * @description:    短信验证码授权过滤器，用于给用户发送短信验证码
 * @author: chenzejie
 * @create: 2019-09-02 16:37
 **/
public class SmsAuthorizeFilter extends GenericFilterBean {
    private RedisCodeService redisCodeService;
    private RequestMatcher requiresAuthenticationRequestMatcher;
    private EntityResponseRenderer entityResponseRenderer=new EntityResponseRenderer();
    public SmsAuthorizeFilter() {
        processesUrl("/oauth/sms/authorize");
    }

    public RedisCodeService getRedisCodeService() {
        return redisCodeService;
    }

    public void setRedisCodeService(RedisCodeService redisCodeService) {
        this.redisCodeService = redisCodeService;
    }


    @Override
    public void afterPropertiesSet() throws ServletException {
        Assert.notNull(redisCodeService, "RedisCodeService must be specified");
    }

    public void processesUrl(String filterProcessesUrl) {
        this.requiresAuthenticationRequestMatcher=new AntPathRequestMatcher(filterProcessesUrl);
    }

    protected boolean requiresAuthentication(HttpServletRequest request) {
        return requiresAuthenticationRequestMatcher.matches(request);
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse res = (HttpServletResponse) response;


        if (!requiresAuthentication((HttpServletRequest)request)) {
            chain.doFilter(request, response);
            return;
        }
        String mobile=request.getParameter("mobile");

        if(StringUtils.isEmpty(mobile)){
            entityResponseRenderer.writeHttpEntityResponse(
                    new MessageEntity("手机号不能为空",HttpStatus.UNAUTHORIZED.value()),
                    HttpStatus.UNAUTHORIZED,
                    request,
                    response
            );
           return;
        }

        String code=new Random().nextInt(999999)+"";
        redisCodeService.save(code,mobile);

        entityResponseRenderer.writeHttpEntityResponse(
                new MessageEntity("短信发送成功:"+code,HttpStatus.OK.value()),
                HttpStatus.OK,
                request,
                response
        );

    }
}

基于短信认证的token

/**
 * @program: spring-security-demo
 * @description:  基于短信认证的token
 * @author: chenzejie
 * @create: 2019-09-02 16:16
 **/
public class SmsAuthenicationToken extends AbstractAuthenticationToken {
    private static final long serialVersionUID = SpringSecurityCoreVersion.SERIAL_VERSION_UID;

    private final Object principal;
    private final Object credentials;
    public SmsAuthenicationToken(Object principal, Object credentials) {
        super(null);
        this.principal = principal;
        this.credentials=credentials;
        setAuthenticated(false);
    }

    public SmsAuthenicationToken(Object principal, Object credentials,
                                               Collection<? extends GrantedAuthority> authorities) {
        super(authorities);
        this.principal = principal;
        this.credentials = credentials;
        super.setAuthenticated(true); // must use super, as we override
    }

    @Override
    public Object getCredentials() {
        return credentials;
    }

    @Override
    public Object getPrincipal() {
        return this.principal;
    }

    @Override
    public void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException {
        if (isAuthenticated) {
            throw new IllegalArgumentException(
                    "Cannot set this token to trusted - use constructor which takes a GrantedAuthority list instead");
        }

        super.setAuthenticated(false);
    }

    @Override
    public void eraseCredentials() {
        super.eraseCredentials();
    }
}

基于短信的身份认证器

/**
 * @program: spring-security-demo
 * @description: 基于短信的身份认证器
 * @author: chenzejie
 * @create: 2019-09-02 16:14
 **/
public class SmsAuthenicationProvider implements AuthenticationProvider {
    private UserDetailsService userDetailService;
    private RedisCodeService redisCodeService;

    public SmsAuthenicationProvider(UserDetailsService userDetailService) {
        this.userDetailService = userDetailService;
    }

    public RedisCodeService getRedisCodeService() {
        return redisCodeService;
    }

    public void setRedisCodeService(RedisCodeService redisCodeService) {
        this.redisCodeService = redisCodeService;
    }

    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        SmsAuthenicationToken smsAuthenicationToken=(SmsAuthenicationToken)authentication;
        String mobile=smsAuthenicationToken.getPrincipal().toString();
        String redisCode=redisCodeService.get(mobile);
        String code=smsAuthenicationToken.getCredentials().toString();
        if(StringUtils.isEmpty(redisCode)) {
            throw new SmsAuthenicationException("请重新发送验证码");
        }

        if(!redisCode.equals(code)) {
            throw new SmsAuthenicationException("验证码错误");
        }


        UserDetails userDetail= userDetailService.loadUserByUsername(mobile);
        SmsAuthenicationToken result=new SmsAuthenicationToken(userDetail,null, userDetail.getAuthorities());
        //最后要删掉验证码
        redisCodeService.remove(mobile);
        return result;
    }

    @Override
    public boolean supports(Class<?> authentication) {
        /**
         * 当 authentication的类型为SmsAuthenicationToken 会使用本类的认证器进行身份认证
         */
        return (SmsAuthenicationToken.class
                .isAssignableFrom(authentication));
    }
}

为springSecurity扩展基于短信的身份认证器的配置项

/**
 * @program: spring-security-demo
 * @description:
 * 为springSecurity扩展基于短信的身份认证器 SmsAuthenicationProvider,
 * 的配置项，委派给HttpSecurity调用
 * @author: chenzejie
 * @create: 2019-09-24 18:11
 **/
public class SmsAuthenticationConfigurerAdapter extends GlobalAuthenticationConfigurerAdapter {
    private final ApplicationContext context;

    public SmsAuthenticationConfigurerAdapter(ApplicationContext context) {
        this.context = context;
    }

    /**
     * 这里需要添加springSecurity默认的账号密码验证器 DaoAuthenticationProvider，
     * DaoAuthenticationProvider默认在 InitializeUserDetailsBeanManagerConfigurer 进行配置， 如果
     * 对springSecurity的身份验证器进行扩展则会失效。所以在这里我们需要配置一个
     * 默认的账号密码验证器 DaoAuthenticationProvider
     *
     * @param auth
     */
    private void buildDefaultUserDetailsManager(AuthenticationManagerBuilder auth){
        UserDetailsService userDetailsService = getBeanOrNull(
                UserDetailsService.class);

        if (userDetailsService == null) {
            return;
        }
        PasswordEncoder passwordEncoder = getBeanOrNull(PasswordEncoder.class);

        DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
        provider.setUserDetailsService(userDetailsService);
        if (passwordEncoder != null) {
            provider.setPasswordEncoder(passwordEncoder);
        }
        auth.authenticationProvider(provider);
    }


    @Override
    public void init(AuthenticationManagerBuilder auth) throws Exception {
        buildDefaultUserDetailsManager(auth);
        UserDetailsService userDetailsService = getBeanOrNull(
                UserDetailsService.class);
        if (userDetailsService == null) {
            return;
        }
        RedisCodeService redisCodeService=getBeanOrNull(
                RedisCodeService.class);
        SmsAuthenicationProvider smsAuthenicationProvider=new SmsAuthenicationProvider(userDetailsService);
        smsAuthenicationProvider.setRedisCodeService(redisCodeService);
        auth.authenticationProvider(smsAuthenicationProvider);

    }

    /**
     * @return
     */
    private <T> T getBeanOrNull(Class<T> type) {
        String[] userDetailsBeanNames = this.context
                .getBeanNamesForType(type);
        if (userDetailsBeanNames.length != 1) {
            return null;
        }
        return this.context
                .getBean(userDetailsBeanNames[0], type);
    }

}

扩展spring security的token获取方式


/**
 * @program: spring-security-demo
 * @description: 扩展spring security的token获取方式,原生的的token获取方式只支持 password\authorization_code 这些
 * 如果需要扩展短信验证码获取token需要继承AbstractTokenGranter 进行扩展
 * @author: chenzejie
 * @create: 2019-09-24 13:43
 **/
public class ResourceOwnerSmsTokenGranter extends AbstractTokenGranter {


    private static final String GRANT_TYPE = "sms";

    private final AuthenticationManager authenticationManager;

    public ResourceOwnerSmsTokenGranter(AuthenticationManager authenticationManager,
                                             AuthorizationServerTokenServices tokenServices, ClientDetailsService clientDetailsService, OAuth2RequestFactory requestFactory) {
        this(authenticationManager, tokenServices, clientDetailsService, requestFactory, GRANT_TYPE);
    }

    protected ResourceOwnerSmsTokenGranter(AuthenticationManager authenticationManager, AuthorizationServerTokenServices tokenServices,
                                                ClientDetailsService clientDetailsService, OAuth2RequestFactory requestFactory, String grantType) {
        super(tokenServices, clientDetailsService, requestFactory, grantType);
        this.authenticationManager = authenticationManager;
    }

    @Override
    protected OAuth2Authentication getOAuth2Authentication(ClientDetails client, TokenRequest tokenRequest) {

        Map<String, String> parameters = new LinkedHashMap<String, String>(tokenRequest.getRequestParameters());
        String mobile = parameters.get("username");
        String validCode = parameters.get("code");
        // Protect from downstream leaks of password
        parameters.remove("code");
        /**
         * 构造要进行认证的AbstractAuthenticationToken ， 这里我们创建SmsAuthenicationToken，这样就会委派给
         * SmsAuthenicationProvider进行认证
         */
        Authentication userAuth = new SmsAuthenicationToken(mobile,validCode);
        ((AbstractAuthenticationToken) userAuth).setDetails(parameters);
        try {
            userAuth = authenticationManager.authenticate(userAuth);
        }
        catch (AccountStatusException ase) {
            //covers expired, locked, disabled cases (mentioned in section 5.2, draft 31)
            throw new InvalidGrantException(ase.getMessage());
        }
        catch (BadCredentialsException e) {
            // If the username/password are wrong the spec says we should send 400/invalid grant
            throw new InvalidGrantException(e.getMessage());
        }
        if (userAuth == null || !userAuth.isAuthenticated()) {
            throw new InvalidGrantException("Could not authenticate user: " + mobile);
        }

        OAuth2Request storedOAuth2Request = getRequestFactory().createOAuth2Request(client, tokenRequest);
        return new OAuth2Authentication(storedOAuth2Request, userAuth);
    }
}

启动配置相关代码

application.properties

security.basic.enabled=false
spring.redis.host=10.0.0.77
spring.redis.port=6379
#Session集群处理   把session的存储方式修改为redis，实现session集群
spring.session.store-type=redis

Spring配置类入口

/**
 * 配置入口， 初始化相关的bean，并加载 AuthorizationServerConfig   ResourceServerConfig
 */
@Configuration
@Import({AuthorizationServerConfig.class,ResourceServerConfig.class})
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    private UserDetailsService userDetailService;
    @Autowired
    private RedisCodeService redisCodeService;


    /**
     * 创建MyUserDetailService实例 并在IOC容器注册
     * @return
     */
    @Bean(name = BeanIds.USER_DETAILS_SERVICE)
    public UserDetailsService userDetailService(){
        this.userDetailService=new MyUserDetailService();
        return this.userDetailService;
    }

    /**
     * 为springSecurity扩展基于短信的身份认证器 SmsAuthenicationProvider的配置项
     * springSecurity在启动后会调用在IOC容器所有的GlobalAuthenticationConfigurerAdapter实现类的init方法,
     * 为spring security的身份认证进行扩展
     */
    @Bean
    public GlobalAuthenticationConfigurerAdapter smsAuthenticationConfigurerAdapter(
            ApplicationContext applicationContext,
            RedisCodeService redisCodeService
            ){
        return new SmsAuthenticationConfigurerAdapter(applicationContext);
    }


    /**
     * 创建RedisToken存储，并在IOC容器注册,默认spring oauth2使用的是InMemoryTokenStore, 不适用于微服务场景
     * @param redisConnectionFactory  依赖于RedisConnectionFactory 需要spring注入
     * @return
     */
    @Bean
    @Autowired
    public TokenStore tokenStore(RedisConnectionFactory redisConnectionFactory){
        RedisTokenStore redisTokenStore=new RedisTokenStore(redisConnectionFactory);
        return redisTokenStore;
    }

    /**
     * 密码加密器,并在IOC容器注册
     * @return
     */
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    /**
     * 创建基于redis的授权码存储服务，并在IOC容器注册
     * @return
     */
    @Autowired
    @Bean
    public InRedisAuthorizationCodeServices inRedisAuthorizationCodeServices(RedisTemplate redisTemplate){
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        return new InRedisAuthorizationCodeServices(redisTemplate);
    }


    @Override
    protected void configure(HttpSecurity http) throws Exception {
        /**
         * 构造短信发送过滤器，并把该过滤器绑定到ExceptionTranslationFilter前面
         */
        SmsAuthorizeFilter smsAuthorizeFilter=new SmsAuthorizeFilter();
        smsAuthorizeFilter.setRedisCodeService(redisCodeService);

        String authorizeSmsPath="/oauth/sms/authorize";
        /**
         *  当前的权限拦截器组只拦截 /login /oauth/authorize /oauth/sms/authorize 3个请求
         *  /oauth/authorize： spring-security的获取授权码的接口地址，并跳转到第三方地址的接口地址，
         *  但是默认的spring-security-oauth2  的AuthorizationServerSecurityConfiguration
         *  构造的拦截器组没有对/oauth/authorize 进行拦截，导致若没进行身份认证， 访问该接口则会抛异常,所以在本过滤器组添加拦截
         *
         *  /oauth/sms/authorize： 获取手机验证码， 不需要进行身份认证
         *
         *  /login： 用户获取授权码时候，会进行身份校验， 若未登陆会跳转到/login 登录页 也需要显示声明该拦截地址
         *
         */
        http.requestMatchers()
                .antMatchers("/login","/oauth/authorize",authorizeSmsPath).and()
                .formLogin().and()
                .authorizeRequests()
                .antMatchers(authorizeSmsPath).permitAll()
                .anyRequest().authenticated()
                .and()
                .csrf().disable()
                .addFilterAfter(smsAuthorizeFilter, ExceptionTranslationFilter.class)
        ;

    }

}

认证服务配置


/**
 * @program: spring-security-demo
 * @description:   认证服务配置
 * @author: chenzejie
 * @create: 2019-09-02 09:49
 **/
@EnableAuthorizationServer
public class AuthorizationServerConfig  extends AuthorizationServerConfigurerAdapter {
    @Autowired
    private AuthenticationManager authenticationManager;
    @Autowired
    private InRedisAuthorizationCodeServices inRedisAuthorizationCodeServices;
    @Autowired
    private RedisConnectionFactory redisConnectionFactory;
    @Autowired
    private TokenStore tokenStore;
    @Autowired
    private PasswordEncoder passwordEncoder;
    @Autowired
    private UserDetailsService userDetailsService;

    /**
     * 自定义token授权器
     * spring-security默认的token生成器在AuthorizationServerEndpointsConfigurer.getDefaultTokenGranters()
     * 生成， 如果开发者想扩展自己的token生成器， 需要把原有的逻辑代码拷贝过来， 并追加自己的token生成器，本方法就是
     * 沿袭getDefaultTokenGranters()的代码逻辑， 并追加了ResourceOwnerSmsTokenGranter 短信token生成器
     *
     * @return
     */
    public TokenGranter customTokenGranter(ClientDetailsService clientDetails
    ,AuthorizationServerTokenServices tokenServices, AuthorizationCodeServices authorizationCodeServices,
    OAuth2RequestFactory requestFactory
    ){

        List<TokenGranter> defaultTokenGranters = new ArrayList<TokenGranter>();
        defaultTokenGranters.add(new AuthorizationCodeTokenGranter(tokenServices, authorizationCodeServices, clientDetails,
                requestFactory));
        defaultTokenGranters.add(new RefreshTokenGranter(tokenServices, clientDetails, requestFactory));
        ImplicitTokenGranter implicit = new ImplicitTokenGranter(tokenServices, clientDetails, requestFactory);
        defaultTokenGranters.add(implicit);
        defaultTokenGranters.add(new ClientCredentialsTokenGranter(tokenServices, clientDetails, requestFactory));
        if (authenticationManager != null) {
            defaultTokenGranters.add(new ResourceOwnerPasswordTokenGranter(authenticationManager, tokenServices,
                    clientDetails, requestFactory));

            defaultTokenGranters.add(new ResourceOwnerSmsTokenGranter(authenticationManager, tokenServices,
                    clientDetails, requestFactory));
        }

        TokenGranter tokenGranter=new CompositeTokenGranter(defaultTokenGranters);
        return tokenGranter;

    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) {
        /**
         *  对认证的token接口进行配置
         *  tokenStore(tokenStore): 配置基于redis的token存储器
         *  authorizationCodeServices(inRedisAuthorizationCodeServices):配置基于redis的授权码存储器
         *  authenticationManager(authenticationManager)：配置身份认证服务，如果不配置则不支持基于密码的授权模式
         *  .tokenGranter(): 配置自定义token生成器
         *  .userDetailsService(userDetailsService):  主要作用于刷新token操作重新读取用户信息
         */
        endpoints
        .tokenStore(tokenStore)
        .authorizationCodeServices(inRedisAuthorizationCodeServices)
        .authenticationManager(authenticationManager)
        .userDetailsService(userDetailsService)
        .tokenGranter(
                customTokenGranter(endpoints.getClientDetailsService(),endpoints.getTokenServices(),
                        endpoints.getAuthorizationCodeServices(),endpoints.getOAuth2RequestFactory()
                        )
        )
        ;
    }

    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        //如果AppId的秘钥是进行加密的，则需要添加为AuthorizationServerSecurityConfigurer配置密码加密器
        security.passwordEncoder(passwordEncoder);
    }

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        /**
         * 配置appClient详情， 下面演示的是基于内存存储的， 不可在程序运行期间进行修改，不推荐使用
         * 建议使用clients.jdbc()， 把appClient存储在数据库里，你也可以扩展基于redis mongodb的appClient
         * 读取器， 需要实现ClientDetailsService
         *
         */
        clients.inMemory()
                //appId
                .withClient("test")
                //秘钥
                .secret(passwordEncoder.encode("test1234"))
                //token失效时间(秒)
                .accessTokenValiditySeconds(3600)
                //刷新token失效时间(秒)
                .refreshTokenValiditySeconds(864000)
                //作用域
                .scopes("all")
                //app注册跳转地址
                .redirectUris("http://www.baidu.com")
                //支持的token生成模式， 这里把常见的密码模式、授权码模式、刷新token模式、短信认证模式都加上了
                .authorizedGrantTypes("password","authorization_code","refresh_token","sms")
                ;
    }

}

资源服务配置


/**
 * @program: spring-security-demo
 * @description: 资源服务配置， 主要作用是做登出的处理，因为登出需要依赖于token校验，
 * token校验的过滤器 OAuth2AuthenticationProcessingFilter 在ResourceServerConfiguration进行配置
 * 所以需要加载资源服务的配置项
 * @author: chenzejie
 * @create: 2019-09-02 10:44
 **/
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
    @Autowired
    private TokenStore tokenStore;
    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {

    }

    @Override
    public void configure(HttpSecurity http) throws Exception {
        super.configure(http);
        //把OAuth2登出配置类委派给HttpSecurity调用
        http.apply(new Oauth2LogoutConfigurer()).tokenStore(tokenStore);
    }
}

测试基于密码模式获取token

使用postman发送POST请求localhost:8080/oauth/token：

image

grant_type填password，表示密码模式，然后填写用户名和密码，除了这几个参数外，
我们还需要在请求头中填写：

image

key为Authorization，value为Basic加上client_id:client_secret经过base64加密后的值: Basic dGVzdDp0ZXN0MTIzNA==


你可以在下面提供的在线加密链接进行加密测试
（http://tool.chinaz.com/Tools/Base64.aspx）:

image

参数填写无误后，点击发送便可以获取到令牌Token：


{
    "access_token": "b52ab19a-dc6c-453a-900f-9563c7f5ce3b",
    "token_type": "bearer",
    "refresh_token": "92423cbc-75e0-415d-be94-af1f7ee032de",
    "expires_in": 3599,
    "scope": "all"
}

测试基于短信模式获取token

1、使用postman发送获取短信请求：
localhost:8080/oauth/sms/authorize?mobile=13242404681

image


2、使用postman发送POST请求：localhost:8080/oauth/token

image
grant_type填sms，表示短信验证码模式，code填收到的短信，头部也需要填写Authorization信息，内容和密码模式介绍的一致，这里就不截图了。点击发送，也可以获得令牌：


{
    "access_token": "b52ab19a-dc6c-453a-900f-9563c7f5ce3b",
    "token_type": "bearer",
    "refresh_token": "92423cbc-75e0-415d-be94-af1f7ee032de",
    "expires_in": 3599,
    "scope": "all"
}

测试基于授权码模式获取token

接下来开始往认证服务器请求授权码。打开浏览器，访问

http://localhost:8080/oauth/authorize?response_type=code&client_id=test&redirect_uri=http://www.baidu.com&scope=all&state=hello

URL中的几个参数,response_type必须为code，表示授权码模式，client_id就是刚刚在配置文件中手动指定的test，redirect_uri这里为客户端配置的跳转地址，主要是用来重定向获取授权码的，scope指定为all，表示所有权限。

访问这个链接后，页面如下所示：

image
如果要自定义登陆页面， 在SecurityConfig里为HttpSecurity配置formLogin的loginPage方法配置

需要登录认证，根据我们前面定义的UserDetailService逻辑，这里用户名随便输，密码为123456即可。输入后，页面跳转如下所示：

image

选择同意Approve，然后点击Authorize按钮后，页面跳转到了我们指定的redirect_uri，并且带上了授权码信息:

image

到这里我们就可以用这个授权码从认证服务器获取令牌Token了。

使用postman发送如下请求POST请求localhost:8080/oauth/token：

image
grant_type固定填authorization_code，code为上一步获取到的授权码，client_id和redirect_uri、scope必须和我们上面定义的一致。 头部也需要填写Authorization信息，内容和密码模式介绍的一致，这里就不截图了。点击发送，也可以获得令牌：

{
    "access_token": "60d373b3-3ad1-46d7-99fd-1501d5cac572",
    "token_type": "bearer",
    "refresh_token": "c9688f78-836d-4b32-9a64-a0890c87c81e",
    "expires_in": 3599,
    "scope": "all"
}

自定义授权页

在这里我们看到登陆页面和授权页面很简陋， 不符合线上的需求，自定义页面的配置很简单，这里就不概述了，在这里介绍下如何自定义授权页面，在上面的代码基础下， 我们增加如下配置：

添加模板依赖

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

配置模板文件
在application.properties追下如下内容

spring.thymeleaf.prefix=classpath:/views/
spring.thymeleaf.suffix=.html
spring.thymeleaf.cache=false

在resources/views 新建base-grant.html 授权页面文件

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8"/>
    <title>授权</title>
</head>

<style>

    html{
        padding: 0px;
        margin: 0px;
    }

    .title {
        background-color: #E9686B;
        height: 50px;
        padding-left: 20%;
        padding-right: 20%;
        color: white;
        line-height: 50px;
        font-size: 18px;
    }
    .title-left{
        float: right;
    }
    .title-right{
        float: left;
    }
    .title-left a{
        color: white;
    }
    .container{
        clear: both;
        text-align: center;
    }
    .btn {
        width: 350px;
        height: 35px;
        line-height: 35px;
        cursor: pointer;
        margin-top: 20px;
        border-radius: 3px;
        background-color: #E9686B;
        color: white;
        border: none;
        font-size: 15px;
    }
</style>
<body style="margin: 0px">
<div class="title">
    <div class="title-right">OAUTH-BOOT 授权</div>
    <div class="title-left">
        <a href="#help">帮助</a>
    </div>
</div>
<div class="container">
    <h3 th:text="${clientId}+' 请求授权，该应用将获取你的以下信息'"></h3>
    <p>昵称，头像和性别</p>
    授权后表明你已同意 <a  href="#boot" style="color: #E9686B">OAUTH-BOOT 服务协议</a>
    <form method="post" action="/oauth/authorize">

        <input type="hidden" name="user_oauth_approval" value="true"/>

        <div th:each="item:${scopes}">
            <input type="radio" th:name="'scope.'+${item}" value="true" hidden="hidden" checked="checked"/>
        </div>

        <button class="btn" type="submit"> 同意/授权</button>

    </form>
</div>
</body>
</html>

定义界面Controller

spring-security内部跳转授权页面的地址为/oauth/confirm_access，所以你的接口地址定义为/oauth/confirm_access即可覆盖spring-security默认的授权页面

@Controller
@SessionAttributes("authorizationRequest")
public class BootGrantController {
 
    @RequestMapping("/oauth/confirm_access")
    public ModelAndView getAccessConfirmation(Map<String, Object> model, HttpServletRequest request) throws Exception {
 
        AuthorizationRequest authorizationRequest = (AuthorizationRequest) model.get("authorizationRequest");
        ModelAndView view = new ModelAndView();
        view.setViewName("base-grant");
        view.addObject("clientId", authorizationRequest.getClientId());
        view.addObject("scopes",authorizationRequest.getScope());
        return view;
    }
 
}

效果图
image


测试刷新token

我们回顾前面获取到的token内容：


{
    "access_token": "54438695-8c98-4553-ab71-764e8b8ccdbe",
    "token_type": "bearer",
    "refresh_token": "20ca6925-76d8-405a-b67e-00c9534a28c8",
    "expires_in": 3521,
    "scope": "all"
}

其中access_token是我们访问资源服务器所需要携带的令牌，但是这个令牌会有过期时间，过期时间为expires_in字段信息，默认为1小时,当过期后我们需要重新获取新的token，除了前面说的几种获取token方式外，还有一种是根据刷新令牌获取新的token，实例如下：

使用postman发送如下请求POST请求localhost:8080/oauth/token：

image

image grant_type固定填refresh_token，refresh_token 为获取到的刷新token。 头部也需要填写Authorization信息，内容和密码模式介绍的一致，这里就不截图了。点击发送，也可以获得令牌：

{
    "access_token": "188d997c-8c0e-4a70-adf7-3d69c06d1645",
    "token_type": "bearer",
    "refresh_token": "20ca6925-76d8-405a-b67e-00c9534a28c8",
    "expires_in": 3599,
    "scope": "all"
}
到这里，认证服务器的相关知识都讲完了， 接下来我们看下一篇资源服务器的配置，如何用token访问受保护的资源
麻布二狗
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
SpringCloud+SpringBoot+OAuth2+Spring Security+Redis实现的微服务统一认证授权
2401_84008985的博客
04-18 358
金三银四到了，送上一个小福利！《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！配置文件server:port: 1202自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
oAuth2.0简单使用与Demo
u014463199的博客
05-24 4776
一、关于oAuth2.0 关于什么是oAuth2.0，以及相关的名词网上有很多解释，再次不做赘述，本文将直接结合一个实例，来描述oAuth2.0的原理流程。 二、前提说明 本文的案例的环境为SpringBoot（其实这个并不重要），以使用码云的账号登录为例子，所以需要先注册一个码云的账号。 三、Demo 首先创建一个WEB项目，并且写一个最简单的登录页面。 这是一个简单到不能在简单的登陆页面了，...
OAuth2令牌存入Redis
qq_34136709的博客
04-27 1601
OAuth2令牌存入Redis 首先我们需要安装redis: 目前有四种方式获取一个 Redis，这里简单介绍一下后期具体说 直接编译安装（推荐使用） 使用 Docker 也可以直接安装 还有一个在线体验的方式，通过在线体验，可以直接使用 Redis 的功能http://try.redis.io/ 这里我们使用第一种 提前准备好 gcc 环境。 yum install gcc-c++ 接下来...
微服务实战（一）基于OAUTH2.0统一认证授权的微服务基础架构
热门推荐
仰望星空 脚踏实地
06-04 16万+
1.架构图 技术团队通过一段时间的积累后，我们打算对往后的一些新项目采用Spring Cloud技术栈来实现。大概微服务的架构如下： Euraka注册中心集群 Zuul网关集群 各模块微服务集群 Nginx实现负载均衡 Spring Cloud Config 统一配置中心 Monitor微服务监控 代码传送：https://github.com/babylikebird/Micro-
Spring-Security+OAuth2+redis实现密码登录
梅子黄时雨
07-14 2290
Spring-Security+OAuth2+redis实现密码登录
oauth2 spring-authorization-server 分析
tof
01-19 1万+
spring boot,spring security,oauth2,spring-authorization-server
SpringCloud+SpringBoot+OAuth2+Spring Security+Redis实现的微服务统一认证授权.doc
04-01
SpringCloud+SpringBoot+OAuth2+Spring Security+Redis实现的微服务统一认证授权
基于SpringBoot整合oauth2实现token认证
08-25
主要介绍了基于SpringBoot整合oauth2实现token 认证,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
基于Spring Security的OAuth2.1和OIDC1.0认证服务器设计源码
最新发布
06-02
本源码提供了一个基于Spring Security框架的OAuth2.1和OIDC1.0认证服务器实现。项目包含102个文件，主要使用Java（51个文件）、JSP（12个文件）、XML（10个文件）、HTML（9个文件）等编程语言和标记语言开发。此外，...
oauth2-server-redis:OAuth2-Server的Redis存储后端
04-24
oauth2-server-redis Redis存储后端 特征 在Redis中存储以下内容： 访问令牌 刷新令牌 授权码 使用HMSET将所有数据存储为键（令牌或代码为哈希） 遵守TTL设置，以便条目在正确的时间过期 要求 Node.js 10以上 ...
微服务框架搭建 基于oauth2 认证中心服务
03-26
项目采用spring cloud、oauth2、spring security # 依赖环境 JDK8、 Maven、 Mysql、 Redis 、nacos 注册中心采用阿里巴巴 nacos 缓存使用的是redis oauth2数据存储在数据库中 username: test password: 123456...
定制化OAuth2的授权服务器
傻了积威的博客
03-22 187
定制化OAuth2授权服务器，通过Redis保存授权码，自定义认证逻辑，支持多种认证方式
分布式认证中心实现方案：OAuth2.0 + Redis，refresh_token无感知刷新
qq_52030824的博客
03-05 1025
分布式认证中心实现方案：OAuth2.0 + Redis，refresh_token无感知刷新
SpringCloud微服务——基于security+oauth2的安全保护（四）：授权服务之redis存储token
fyk的博客
08-13 3860
文章目录加入jar包加入配置修改授权服务配置问题 在SpringCloud微服务——基于security+oauth2的安全保护（二）：授权服务该文中，存储token信息使用的是jdbc的方式。这里介绍一种使用redis存储的方法（本文是建立在授权服务之上的，以它为基础改造）。 为了多样化，就不删除以前的功能了，可以通过配置来决定使用哪个。 加入jar包 以前的jar包不要动，加入redis的就可...
Spring Security OAuth2 使用Redis存储token键值详解
OceanSky的专栏
07-27 2万+
1.Spring Security OAuth2存储token值的方式由多种，所有的实现方式都是实现了TokenStore接口 InMemoryTokenStore:token存储在本机的内存之中 JdbcTokenStore:token存储在数据库之中 JwtTokenStore:token不会存储到任何介质中 RedisTokenStore:token存储在Redis数据库之中 2.看下R...
SpringCloud - Oauth2认证授权（Redis缓存用户信息、为用户名密码登陆添加细节）
zhangdm的博客
01-21 3225
文章目录前言添加引用先获取一下Redis的配置创建一个TokenGranterConfig，重新配置一下授权设置继承AbstractTokenGranter ，实现自定义的密码认证实现UserDetailsService 获取用户信息的具体逻辑继承AuthorizationServerConfigurerAdapter 进行授权/认证服务器的配置继承WebSecurityConfigurerAdapter类，复写方法实现自定义安全访问策略关于服务端，我们也要配置Oauth2，拦截请求必须带有认证信息且认证有
oauth2 AuthorizationServerConfigurerAdapter 引入 RedisTokenStore 问题
happyzwh的专栏
01-20 1184
1、 @Configuration public class RedisTokenStoreConfig { @Autowired private RedisConnectionFactory redisConnectionFactory; @Bean public TokenStore redisTokenStore(){ RedisTokenStore redisTokenStore = new RedisTokenStore(redisConne
OAuth 2 深入介绍
互扯程序的博客
04-08 1433
1、前言 OAuth 2 是一个授权框架，或称授权标准，它可以使第三方应用程序或客户端获得对HTTP服务上（例如 Google，GitHub ）用户帐户信息的有限访问权限。OAuth 2 通过将用户身份验证委派给托管用户帐户的服务以及授权客户端访问用户帐户进行工作。综上，OAuth 2 可以为 Web 应用 和桌面应用以及移动应用提供授权流程。 本文将从OAuth 2 角色，授权许...
搭建基于OAuth2和SSO的开放平台
heartlifes
09-08 1万+
搭建基于OAuth2和SSO的开放平台原创文章，转载或摘录请说明文章来源:http://heartlifes.com开放平台介绍什么是开放平台开放平台在百科中的定义： 开放平台（Open Platform） 在软件行业和网络中，开放平台是指软件系统通过公开其应用程序编程接口（API）或函数（function)来使外部的程序可以增加该软件系统的功能或使用该软件系统的资源，而不需要更改该软件系统的源代
oauth2 jwt redis
09-29
JwtTokenEnhancer是一个用于增强OAuth2访问令牌的类。它实现了TokenEnhancer接口，通过添加自定义拓展字段来增强令牌。在enhance方法中，它将自定义字段添加到OAuth2AccessToken对象的additionalInformation属性中。 OAuth2是一种开放标准，用于授权访问资源的框架。JWT（JSON Web Token）是OAuth2中常用的一种令牌类型，用于表示授权信息。JWT通常被用作OAuth2的访问令牌。 Redis是一种高性能的键值存储数据库，常用于缓存和会话管理。在OAuth2中，Redis可以用来存储和管理令牌的信息，以提高系统的性能和可扩展性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值