Springcloud Oauth2 基础篇

最新推荐文章于 2024-03-08 09:18:05 发布
原创 最新推荐文章于 2024-03-08 09:18:05 发布 · 272 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了如何在Springcloud架构中结合Oauth2实现微服务的鉴权认证。详细讲解了Oauth2的四种授权模式，并重点讨论了在密码模式、授权码模式、简化模式和客户端模式的应用场景。文章还提供了基于JWT的实现步骤，包括环境配置、代码结构、鉴权中心和资源服务器的配置，并展示了关键代码示例。最后，通过接口测试展示了获取和使用token的流程。

微服务玩了这么久了，相信每个公司系统体系都有自己的微服务架构，包括网关、鉴权认证、权限管控、资源请求、日志管理等等。

但今天讲的是鉴权认证这两块，比较流行的一个认证方案：Oauth2，这个现在在大城市都比较流行。但其实际应用的都还是比较老的框架，Spring Security等。今天要讲的是结合Springcloud，来作微服务的架构的核心功能。

前言

Oauth2的四种授权模式

Resource Owner Password Credentials（密码模式）：client获取用户提交的用户名和密码，之后向认证服务器获取访问令牌；

Authorization Code（授权码模式）：客户端先将用户导向认证服务器，登录后获取授权码，然后进行授权，最后根据授权码获取访问令牌；

Implicit（简化模式）：和授权码模式相比，取消了获取授权码的过程，直接获取访问令牌；

Client Credentials（客户端模式）：客户端直接通过客户端认证（比如client_id和client_secret）从认证服务器获取访问令牌。

应用场景

密码模式主要用在比较信任的用户场景，比如是用户操作系统的一部分。

授权码模式是最常见的一种授权模式，在oauth2.0内是最安全和最完善的。适用于所有有Server端的应用，如Web站点、有Server端的APP。

简化模式适用于如手机/桌面客户端程序、浏览器插件，或是基于JS等脚本语言实现的应用。

客户端模式应用于APP想要以自己的名义与授权服务以及资源服务进行互动。

下面主要介绍基于JWT，结合Springcloud的Oauth2：

环境

       

    ubuntu16.04

    docker18.04

    k8s1.13.x +

    maven3.5.3

    java1.8 +

    springboot 2.1.8

代码结构：

— cas-server #鉴权中心

— admin-web #后台管理服务

— order-service #订单服务

鉴权中心：

配入依赖：

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




  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
    <swagger.version>2.6.1</swagger.version>
    <xstream.version>1.4.7</xstream.version>
    <pageHelper.version>4.1.6</pageHelper.version>
    <fastjson.version>1.2.51</fastjson.version>
    <springcloud.version>Greenwich.SR4</springcloud.version>
    <springcloud.kubernetes.version>1.1.1.RELEASE</springcloud.kubernetes.version>
    <mysql.version>5.1.46</mysql.version>
  </properties>




  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-dependencies</artifactId>
        <version>${springcloud.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
  
  <dependencies>
      <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
      <exclusions>
        <exclusion>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-undertow</artifactId>
    </dependency>
  
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-oauth2</artifactId>
        </dependency>
        <!-- spring-cloud-starter-oauth2包含了 spring-cloud-starter-security -->
        <!-- <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-security</artifactId>
        </dependency> -->
        
        <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.0</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>4.6.3</version>
        </dependency>
        
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>19.0</version>
        </dependency>
        
        <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        </dependency>
    


    <dependency>
        <groupId>commons-collections</groupId>
        <artifactId>commons-collections</artifactId>
        <version>3.2.2</version>
    </dependency>
    


    <!-- swagger -->
    <dependency>
      <groupId>io.springfox</groupId>
      <artifactId>springfox-swagger2</artifactId>
      <version>${swagger.version}</version>
    </dependency>
    <dependency>
      <groupId>io.springfox</groupId>
      <artifactId>springfox-swagger-ui</artifactId>
      <version>${swagger.version}</version>
    </dependency>
    


    <!--分页插件-->  
      <dependency>
        <groupId>com.github.pagehelper</groupId>  
        <artifactId>pagehelper</artifactId>  
        <version>${pageHelper.version}</version>
      </dependency>
    


    <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>
        <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>
        
        <!-- datasource pool-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.3</version>
        </dependency>
        
        <!-- 对redis支持,引入的话项目缓存就支持redis了,所以必须加上redis的相关配置,否则操作相关缓存会报异常 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    


    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>${fastjson.version}</version>
    </dependency>
    


    <dependency>
      <groupId>org.jsoup</groupId>
      <artifactId>jsoup</artifactId>
      <version>1.11.3</version>
    </dependency>




    </dependencies>

配置文件：bootstrap.yaml

management:
  endpoint:
    restart:
      enabled: true
    health:
      enabled: true
    info:
      enabled: true


spring:
  application:
    name: cas-server
  #redis: #redis相关配置
    #database: 8
    #host: localhost
    #port: 6379
    #password:  #有密码时设置
    #jedis:
      #pool:
        #max-active: 8
        #max-idle: 8
        #min-idle: 0
    #timeout: 10000ms
    
    
  http:
    encoding:
      charset: UTF-8
      enabled: true
      force: true
  mvc:
    throw-exception-if-no-handler-found: true
  main:
    allow-bean-definition-overriding: true # 当遇到同样名称时，是否允许覆盖注册

application.yaml：

server:
  port: 2000
  undertow:
    accesslog:
      enabled: false
      pattern: combined
  servlet:
    session:
      timeout: PT120M
  
logging:
  path: /data/${spring.application.name}/logs




#sso_redirect_urls: http://localhost:2001/login,http://localhost:2003/login


client:
  http:
    request:
      connectTimeout: 8000
      readTimeout: 30000
      
mybatis:
  mapperLocations: classpath:mapper/*.xml
  typeAliasesPackage: com.damon.*.model

然后新建启动类：

package com.damon;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;


/**
 * 
 * 配置最多的就是认证服务端，验证账号、密码，存储 token，检查 token ,刷新 token 等都是认证服务端的工作
 * @author Damon 
 * @date 2020年1月13日 下午9:29:42
 *
 */
@Configuration
@EnableAutoConfiguration
@ComponentScan(basePackages = {"com.damon"})
//@SpringBootApplication(scanBasePackages = { "com.damon" })
public class CasApp {
  public static void main(String[] args) {
    SpringApplication.run(CasApp.class, args);
  }
}

认证服务器配置：

package com.damon.config;


import java.util.ArrayList;
import java.util.List;


import javax.sql.DataSource;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.token.TokenEnhancer;
import org.springframework.security.oauth2.provider.token.TokenEnhancerChain;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;


import com.damon.component.JwtTokenEnhancer;
import com.damon.login.service.LoginService;


/**
 * 
 * 认证服务器配置
 * @author Damon 
 * @date 2020年1月13日 下午9:03:30
 *
 */
@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {


    @Autowired
    private PasswordEncoder passwordEncoder;


    @Autowired
    private AuthenticationManager authenticationManager;


    @Autowired
    private LoginService loginService;


    @Autowired
    @Qualifier("jwtTokenStore")
    private TokenStore tokenStore;
    @Autowired
    private JwtAccessTokenConverter jwtAccessTokenConverter;
    @Autowired
    private JwtTokenEnhancer jwtTokenEnhancer;
    
    @Autowired
    private Environment env;
    
    
    @Autowired
    private DataSource dataSource;


    /**
     * 使用密码模式需要配置
     */
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) {
        TokenEnhancerChain enhancerChain = new TokenEnhancerChain();
        List<TokenEnhancer> delegates = new ArrayList<>();
        delegates.add(jwtTokenEnhancer); //配置JWT的内容增强器
        delegates.add(jwtAccessTokenConverter);
        enhancerChain.setTokenEnhancers(delegates);
        endpoints.authenticationManager(authenticationManager)//支持 password 模式
                .userDetailsService(loginService)
                .tokenStore(tokenStore) //配置令牌存储策略
                .accessTokenConverter(jwtAccessTokenConverter)
                .tokenEnhancer(enhancerChain);
    }
    
    /**
     * redis token 方式
     */
    /*@Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.authenticationManager(authenticationManager) //支持 password 模式
                .userDetailsService(loginService)
                .tokenStore(tokenStore);


    }*/


    /**
     * 客户端配置（给谁发令牌）
     * 不同客户端配置不同
     * 
     * authorizedGrantTypes 可以包括如下几种设置中的一种或多种：
      authorization_code：授权码类型。需要redirect_uri
      implicit：隐式授权类型。需要redirect_uri
      password：资源所有者（即用户）密码类型。
      client_credentials：客户端凭据（客户端ID以及Key）类型。
      refresh_token：通过以上授权获得的刷新令牌来获取新的令牌。
     
     accessTokenValiditySeconds：token 的有效期
     scopes：用来限制客户端访问的权限，在换取的 token 的时候会带上 scope 参数，只有在 scopes 定义内的，才可以正常换取 token。
     * @param clients
     * @throws Exception
     * @author Damon 
     * @date 2020年1月13日
     *
     */
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
                .withClient("admin-web")
                .secret(passwordEncoder.encode("admin-web-123"))
                .accessTokenValiditySeconds(3600)
                .refreshTokenValiditySeconds(864000)//配置刷新token的有效期
                .autoApprove(true) //自动授权配置
                .scopes("all")//配置申请的权限范围
                .authorizedGrantTypes("password", "authorization_code", "client_credentials", "refresh_token")//配置授权模式
                .redirectUris("http://localhost:2001/login")//授权码模式开启后必须指定
                .and()
                .withClient("order-service")
                .secret(passwordEncoder.encode("order-service-123"))
                .accessTokenValiditySeconds(3600)
                .refreshTokenValiditySeconds(864000)//配置刷新token的有效期
                .autoApprove(true) //自动授权配置
                .scopes("all")
                .authorizedGrantTypes("password", "authorization_code", "client_credentials", "refresh_token")//配置授权模式
                .redirectUris("http://localhost:2003/login")//授权码模式开启后必须指定
                //.authorizedGrantTypes("authorization_code", "password", "refresh_token")//配置授权模式：authorization_code授权码模式、密码模式
                ;
    }
    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) {
      security.allowFormAuthenticationForClients();//是允许客户端访问 OAuth2 授权接口，否则请求 token 会返回 401
      security.checkTokenAccess("isAuthenticated()");//是允许已授权用户访问 checkToken 接口
        security.tokenKeyAccess("isAuthenticated()"); // security.tokenKeyAccess("permitAll()");获取密钥需要身份认证，使用单点登录时必须配置，是允许已授权用户获取 token 接口
    }
}

Spring WEBSecurity配置：

package com.damon.config;


import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;


/**
 * 
 * SpringSecurity配置
 * @author Damon 
 * @date 2020年1月13日 下午9:03:55
 *
 */
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {


    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }


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


    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.csrf()
                .disable()
                .authorizeRequests()
                .antMatchers("/oauth/**", "/login/**")//"/logout/**"
                .permitAll()
                .anyRequest()
                .authenticated()
                .and()
                .formLogin()
                .permitAll();
    }
    
    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers("/css/**", "/js/**", "/plugins/**", "/favicon.ico");
    }
}

资源服务器配置：

package com.damon.config;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;


/**
 * 
 * 资源服务器配置
 * @author Damon 
 * @date 2020年1月13日 下午9:03:48
 *
 */
@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .anyRequest()
                .authenticated()
                .and()
                .requestMatchers()
                .antMatchers("/api/**");//配置需要保护的资源路径
                //.antMatchers("/user/**");//配置需要保护的资源路径
    }
}

本次开启了JWT存储token的方式，故，需要加入配置：

package com.damon.config;


import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;


import com.damon.component.JwtTokenEnhancer;


/**
 * 
 * 使用Jwt存储token的配置
 * @author Damon 
 * @date 2020年1月13日 下午9:03:38
 *
 */


@Configuration
public class JwtTokenStoreConfig {


  @Bean
    public TokenStore jwtTokenStore() {
        return new JwtTokenStore(jwtAccessTokenConverter());
    }


    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter() {
        JwtAccessTokenConverter accessTokenConverter = new JwtAccessTokenConverter();
        accessTokenConverter.setSigningKey("test_jwt_sign_key");//配置JWT使用的秘钥
        return accessTokenConverter;
    }


    @Bean
    public JwtTokenEnhancer jwtTokenEnhancer() {
        return new JwtTokenEnhancer();
    }
}

Jwt内容增强器：

package com.damon.component;


import org.springframework.security.oauth2.common.DefaultOAuth2AccessToken;
import org.springframework.security.oauth2.common.OAuth2AccessToken;
import org.springframework.security.oauth2.provider.OAuth2Authentication;
import org.springframework.security.oauth2.provider.token.TokenEnhancer;


import java.util.HashMap;
import java.util.Map;


/**
 * Jwt内容增强器
 * @author Damon 
 * @date 2020年1月13日 下午9:04:43
 *
 */
public class JwtTokenEnhancer implements TokenEnhancer {
    @Override
    public OAuth2AccessToken enhance(OAuth2AccessToken accessToken, OAuth2Authentication authentication) {
        Map<String, Object> info = new HashMap<>();
        info.put("jwt-enhance", "jwt enhance info");
        ((DefaultOAuth2AccessToken) accessToken).setAdditionalInformation(info);
        return accessToken;
    }
}

到目前为止，主要代码已经贴出来了，如果需要加数据库等，自己可根据需要添加，此处代码不贴了。

接下来看认证主要逻辑：

package com.damon.login.service.impl;


import java.util.List;


import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.oauth2.common.OAuth2AccessToken;
import org.springframework.security.oauth2.provider.token.ConsumerTokenServices;
import org.springframework.stereotype.Service;


import com.damon.commons.Response;
import com.damon.constant.Constant;
import com.damon.constant.LoginEnum;
import com.damon.login.dao.UserMapper;
import com.damon.login.model.SysUser;
import com.damon.login.service.LoginService;
import com.damon.utils.IpUtil;
import com.google.common.collect.Lists;


/**
 * @author wangshoufa
 * @date 2018年11月15日 下午12:01:53
 *
 */
@Service
public class LoginServiceImpl implements LoginService {


  Logger logger = LoggerFactory.getLogger(LoginServiceImpl.class);
    
  @Autowired
    private PasswordEncoder passwordEncoder;
    
    @Autowired
  private UserMapper userMapper;
    
    @Autowired
    private HttpServletRequest req;
    
    /**
     * Auth
     * 登录认证
     * 实际中从数据库获取信息
     * 这里为了做演示，把用户名、密码和所属角色都写在代码里了，正式环境中，这里应该是从数据库或者其他地方根据用户名将加密后的密码及所属角色查出来的。账号 damon ，
     * 密码123456，稍后在换取 token 的时候会用到。并且给这个用户设置 "ROLE_ADMIN" 角色。
     * 
     */
    @Override
  public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
      logger.info("clientIp is: {} ,username: {}", IpUtil.getClientIp(req), username);
    logger.info("serverIp is: {}", IpUtil.getCurrentIp());
    // 查询数据库操作
    SysUser user = userMapper.getUserByUsername(username);
    if (user == null) {
      logger.error("user not exist");
      throw new UsernameNotFoundException("username is not exist");
      //throw new UsernameNotFoundException("the user is not found");
    }
    else {
      // 用户角色也应在数据库中获取，这里简化
      String role = "";
      if(user.getIsAdmin() == 1) {
        role = "admin";
      }
      List<SimpleGrantedAuthority> authorities = Lists.newArrayList();
      authorities.add(new SimpleGrantedAuthority(role));
      //String password = passwordEncoder.encode("123456");// 123456是密码
      //return new User(username, password, authorities);
      // 线上环境应该通过用户名查询数据库获取加密后的密码
      return new User(username, user.getPassword(), authorities);
    }
  }


  @Override
  public Response<Object> login(String username, String password) {
    // TODO Auto-generated method stub
    return null;
  }


  @Override
  public Response<Object> verify(HttpServletRequest request, String token) {
    // TODO Auto-generated method stub
    return null;
  }


  @Override
  public Response<Object> updatePwd(HttpServletRequest req, String username, String oldPwd, String newPwd) {
    // TODO Auto-generated method stub
    return null;
  }
}

此类中 loadUserByUsername 方法实现了认证过程。

写个接口测试类：

package com.damon.login.controller;


import java.nio.charset.StandardCharsets;


import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.oauth2.provider.token.ConsumerTokenServices;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


import com.damon.commons.Response;
import com.damon.constant.Constant;
import com.damon.constant.LoginEnum;
import com.damon.utils.IpUtil;


import cn.hutool.core.util.StrUtil;


import com.damon.login.service.LoginService;


import io.jsonwebtoken.Jwts;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;


/**
 * 
 * @author Damon 
 * @date 2020年1月13日 下午9:35:16
 *
 */
@RestController
@RequestMapping("/api")
@Api(value = "LoginController", description = "登录")
public class LoginController {
  
  private static final Logger logger = LoggerFactory.getLogger(LoginController.class);
  
  
  @Autowired
  private LoginService loginService;
  
  @Autowired
    private ConsumerTokenServices consumerTokenServices;
  
    @GetMapping("/getCurrentUser")
    public Object getCurrentUser(Authentication authentication, HttpServletRequest request) {
      logger.debug("start ...");
        String header = request.getHeader("Authorization");
        String token = StrUtil.subAfter(header, "bearer ", false);
        return Jwts.parser()
                .setSigningKey("test_jwt_sign_key".getBytes(StandardCharsets.UTF_8))
                .parseClaimsJws(token)
                .getBody();
    }
}

接下来请求：

  1. 获取token令牌

      

    curl -i -X POST -d "username=admin&password=123456&grant_type=password&client_id=order-service&client_secret=order-service-123" http://localhost:2000/oauth/token


    返回：

    HTTP/1.1 200 OK
Cache-Control: no-store
X-XSS-Protection: 1; mode=block
Pragma: no-cache
X-Frame-Options: DENY
Date: Wed, 15 Jan 2020 06:06:01 GMT
Connection: keep-alive
X-Content-Type-Options: nosniff
Transfer-Encoding: chunked
Content-Type: application/json;charset=UTF-8
{
    "access_token": "00c3a41b-45bb-4048-8005-34c141c8508f",
    "token_type": "bearer",
    "refresh_token": "5a632d3c-22a6-42dd-9faf-f6600aaeca9e",
    "expires_in": 3599,
    "scope": "all"
}

    OR postman：

  2. 通过令牌访问资源服务器

    curl -i -H "Accept: application/json" -H "Authorization:bearer 00c3a41b-45bb-4048-8005-34c141c8508f" -X GET http://localhost:2003/api/order/getCurrentOrderUser

    OR postman：

    OR Bearer Token

    OR Header bearer token

到此，Oauth2的单点登录演示完成了，以上代码如果存在疑问，可以关注我星球或者公众号，留言咨询。

微服务认证系列一：SpringCloud OAuth2
wanping15825992341的博客
08-12 1076
OAuth(开放授权)是一个开放协议/标准，允许用户授权第三方应用访问他们存储在另外的服务提供者上的信息，而不需要将用户名和密码提供给第三方应用或分享他们数据的所有内容。OAuth2.0是OAuth协议的延续版本，但不向后兼容OAuth 1.0即完全废止了OAuth1.0Spring Cloud OAuth2 是 Spring Cloud 体系对OAuth2协议的实现，可以用来做多个微服务的统一认证(验证身份合法性)授权(验证权限)。
【Spring底层原理高级进阶】【SpringCloud整合Spring Security OAuth2】深入了解 Spring Security OAuth2：底层解析＋使用方法+实战
终于等到你啦~欢迎来到我的知识空间 这里是苏泽的成神之路
02-24 8959
OAuth2（Open Authorization 2.0）是一种用于授权的开放标准协议，用于通过第三方应用程序访问用户在某个服务提供商上存储的资源，而无需共享用户的凭证（例如用户名和密码）。它允许用户授权给第三方应用程序访问受保护的资源，同时确保用户的凭证信息不被直接暴露给第三方应用程序。OAuth2协议的设计目标是简化授权流程和提高安全性，通过委托授权的方式和使用令牌来实现用户和第三方应用程序之间的安全通信。它已成为许多互联网服务提供商和开发者在构建应用程序时常用的授权标准。
Spring Cloud 集成OAuth2实现身份认证和单点登录
07-20
Spring Cloud 安全：集成OAuth2实现身份认证和单点登录 示例代码
springcloud-security-oauth2：安全整合oauth2
02-21
springcloud-security-oauth2 安全整合oauth2
Springcloud之OAuth2
xiaopang2020的博客
08-22 8678
springcloud之OAuth2
spring cloud OAuth2
a18792721831的博客
03-21 4379
1.spring cloud oauth的原理 2.spring cloud oauth的配置 3.spring cloud oauth的实例 4.总结
SpringCloud-OAuth2（一）：基础篇
weixin_45985053的博客
07-27 732
首先，OAuth不是API或服务它是开放的授权标准，任何人都可以实现。更具体地说，OAuth是应用程序可用于向客户端应用程序提供“安全委托访问”的标准。OAuth通过HTTPS进行工作，并使用访问令牌（而不是凭据）对设备，API，服务器和应用程序进行授权。什么是JWT？JSONWebToken（JWT）是⼀个开放的⾏业标准（RFC7519），它定义了⼀种简介的、⾃包含的协议格式，⽤于在通信双⽅传递json对象，传递的信息经过数字签名可以被验证和信任。JWT可以使⽤。...
springcloud整合oauth2和jwt
04-09
本篇文章将深入探讨如何在Spring Cloud项目中整合OAuth2和JWT，以及与MyBatis的集成。 首先，OAuth2是一个开放标准，主要用于授权。它允许第三方应用在用户许可的情况下访问其私有资源，而无需获取用户的用户名和...
Spring Cloud系列 Spring Cloud OAuth2授权码模式(authorization code)
ssaiwey的博客
06-22 2117
OAuth 2 有四种授权模式，分别是授权码模式（authorization code）、简化模式（implicit）、密码模式（resource owner password credentials）、客户端模式（client credentials），具体 OAuth2 是什么，可以参考这篇文章(http://www.ruanyifeng.com/blog/2014/05/oauth_2_0.html) 实现统一认证功能 本篇先介绍密码模式实现的单点登录，下一篇再继续说授权码模式 ...
Spring Cloud系列 Spring Cloud OAuth2密码模式(resource owner password credentials)
ssaiwey的博客
06-25 1712
OAuth 2 有四种授权模式，分别是授权码模式（authorization code）、简化模式（implicit）、密码模式（resource owner password credentials）、客户端模式（client credentials），具体 OAuth2 是什么，可以参考这篇文章(http://www.ruanyifeng.com/blog/2014/05/oauth_2_0.html) ———————————————— 上篇讲解的是授权码模式，本篇主要讲解密码模式。平常主要使用的就是这
Spring Cloud 集成OAuth2实现身份认证和单点登录源代码
01-21
Spring Cloud 集成OAuth2实现身份认证和单点登录，绝对有帮助
Spring Cloud OAuth2 实现用户认证及单点登录
最新发布
杜海的博客
03-08 1334
OAuth 2 有四种授权模式，分别是授权码模式（authorization code）、简化模式（implicit）、密码模式（resource owner password credentials）、客户端模式（client credentials），具体 OAuth2 是什么，可以参考这篇文章。本文我们将使用授权码模式和密码模式两种方式来实现用户认证和授权管理。OAuth2 其实是一个关于授权的网络标准，它制定了设计思路和运行流程，利用这个标准我们其实是可以自己实现 OAuth2 的认证过程的。
Spring cloud OAuth2
lpz658798的博客
03-07 2637
Spring cloud OAuth2 实战开发流程（让你从不会到一站式开发）
spring-cloud-oauth2
ljy
03-03 576
一.参考文章 Spring Security OAuth2 开发指南 理解OAuth2.0 3.Spring Security oAuth2简介 二.oauth2知识整理 2.1 基本概念 oauth： OAuth就是一种授权机制。数据的所有者告诉系统，同意授权第三方应用进入系统，获取这些数据。系统从而产生一个短期的进入令牌（token），用来代替密码，供第三方应用使用。 ...
第七章 SpringCloud OAuth2认证中心-搭建认证中心
热门推荐
无证程序员
11-07 3万+
本章完整源码地址：https://github.com/kwang2003/springcloud-study-ch07.git 1.项目概要 这一章节的内容以第六章的代码为基础改造而成https://github.com/kwang2003/springcloud-study-ch06.git。 经过前几个章节的内容，我们的微服务项目架构逐渐完善了起来，这一章节的重点是通过给已
Spring Cloud OAuth2
liu1390910的博客
01-17 648
OAuth2优点在于，它允许开发人员与第三方服务提供商集成，使用这些服务进行用户验证授权，而无须不断的将用户凭据信息传递给第三方服务。 OAuth2简介 OAuth2是一个基于令牌的安全验证授权框架。它将安全性分解为一下4部分： 受保护资源：例如微服务，确保通过验证并具有适当授权的用户才能访问。 资源所有者：定义那些应用程序可以调用其服务，那些用户可以访问该服务，以及可以使用服务完成哪些事...
Spring Cloud OAuth2 认证服务器
凉茶铺的博客
08-31 3289
Spring Cloud OAuth2 是 Spring Cloud 体系对OAuth2协议的实现，可以用来做多个微服务的统一认证（验证身份合法性）授权（验证权限）。通过向OAuth2服务（统一认证授权服务）发送某个类型的grant_type进行集中认证和授权，从而获得access_token（访问令牌），而这个token是受其他微服务信任的。............
Spring Cloud Oauth2 JWT
kkkyyyoo的博客
01-28 757
SpringSecurityOauth2实现类Oauth2并分为了两大模块，认证授权服务和资源服务。认证授权服务一般负责认证逻辑和加载用户的权限以及认证成功后为用户颁发令牌，资源服务器一般值我们提供的微服务，在资源服务器中需要对用户的令牌做检查（是否通过了认证且是否拥有访问该服务的权限）。所以我们会去创建一个认证授权的微服务，用户登录做认证和加载用户的权限。 1.导入依赖，开启启动类，配置yml文件 <dependencies> <!--微服务基础依赖-->
springCloud之OAuth2
一起coding，一起嗨。
03-03 3109
服务器根据规则携带token重定向至http://localhost:8201/login。
SpringCloud OAuth2 SSO 深度解析：@EnableOAuth2Sso注解与单点登录实现
"这篇文档详细分析了`@EnableOAuth2SSO`注解在实现Spring Cloud环境下OAuth2单点登录（SSO）中的作用。通过深入源码，讲解了相关配置和组件，如`OAuth2Client`、`OAuth2SsoProperties`、`OAuth2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值