Spring Cloud下基于OAUTH2认证授权的实现

最新推荐文章于 2024-05-29 00:46:29 发布
置顶 最新推荐文章于 2024-05-29 00:46:29 发布
阅读量3.7w 收藏 72
点赞数 14
分类专栏： spring cloud 文章标签： Spring Cloud下基于OAUTH2认证授权的实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wflovejava/article/details/88558149
版权

Spring Cloud下基于OAUTH2认证授权的实现

使用oauth2实现微服统一认证授权。通过向oauth2认证服务器发送请求获取token。
，然后携带token访问其他微服务，此token在其他微服务是信任的（即是鉴权验证token是否可用）

模块：
eureka：服务注册和发现的基本模块
zuul：边界网关(所有微服务都在它之后)
oauth2： OAUTH2认证授权中心
service ：普通微服务，用来验证认证和鉴权

在这里插入图片描述

1. oauth-server模块代码

1.1 添加基础pom.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>springcloud-oauth2</groupId>
    <artifactId>springcloud-oauth2</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>oauth-server</module>
        <module>api-gateway</module>
        <module>eureka</module>
        <module>provide-service</module>
    </modules>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.3.RELEASE</version>
    </parent>
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <argLine>-Dfile.encoding=UTF-8</argLine>
        <skiptests>true</skiptests>
    </properties>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <!--<version>Dalston.SR4</version>-->
                <version>Finchley.SR2</version>

                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!--eureka客户端-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!--aop-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

        <!--监控-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <!--断路器-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>

        <!--feign-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

        <!--<dependency>-->
            <!--<groupId>org.glassfish.jersey.core</groupId>-->
            <!--<artifactId>jersey-common</artifactId>-->
            <!--<version>2.26</version>-->
        <!--</dependency>-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.20</version>
        </dependency>
        <!--日志动态级别修改-->
        <dependency>
            <groupId>org.jolokia</groupId>
            <artifactId>jolokia-core</artifactId>
        </dependency>
    </dependencies>
</project>

1.2 添加oauth-server的pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud-oauth2</artifactId>
        <groupId>springcloud-oauth2</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>oauth-server</artifactId>

    <dependencies>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.2</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>

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

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-oauth2</artifactId>
        </dependency>

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


        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <!-- 1.5的版本默认采用的连接池技术是jedis  2.0以上版本默认连接池是lettuce, 在这里采用jedis，所以需要排除lettuce的jar -->
            <exclusions>
                <exclusion>
                    <groupId>redis.clients</groupId>
                    <artifactId>jedis</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>lettuce-core</artifactId>
                </exclusion>
            </exclusions>

        </dependency>
    </dependencies>
</project>

代码目录：
在这里插入图片描述
1.3 添加认证的配置类，使用Redis用来存储token

@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
    @Autowired
    private AuthenticationManager authenticationManager;
    @Autowired
    private RedisConnectionFactory connectionFactory;

    @Autowired
    private UserDetailsService userDetailsService;
    @Bean
    public MyRedisTokenStore tokenStore() {
        return new MyRedisTokenStore(connectionFactory);
    }


    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints
                .authenticationManager(authenticationManager)
                .userDetailsService(userDetailsService)//若无，refresh_token会有UserDetailsService is required错误
                .tokenStore(tokenStore());
    }

    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        security
                .tokenKeyAccess("permitAll()")
                .checkTokenAccess("isAuthenticated()");
    }

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
                .withClient("wf")
                .scopes("wf")
                .secret("wf")
                .authorizedGrantTypes("password", "authorization_code", "refresh_token");
    }

Resource服务配置类
auth-server提供user信息，所以auth-server也是一个Resource Server

/**
 * Created by wf on 2019/03/15
 */
@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http
                .csrf().disable()
                .exceptionHandling()
                .authenticationEntryPoint((request, response, authException) -> response.sendError(HttpServletResponse.SC_UNAUTHORIZED))
            .and()
                .authorizeRequests()
                .anyRequest().authenticated()
            .and()
                .httpBasic();

    }
}

/**
 * @author wufei
 * @create 2019-03-13 16:31
 **/
@RestController
public class UserController {
    @GetMapping("/user")
    public Principal user(Principal user){
        return user;
    }
}

1.4 添加安全配置类

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {



    @Bean
    public UserDetailsService userDetailsService(){
        return new DomainUserDetailsService();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return NoOpPasswordEncoder.getInstance();//new BCryptPasswordEncoder();
    }


    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth
                .userDetailsService(userDetailsService())
                .passwordEncoder(passwordEncoder());
    }

    @Bean
    public SecurityEvaluationContextExtension securityEvaluationContextExtension() {
        return new SecurityEvaluationContextExtension();
    }

    //不定义没有password grant_type
    @Override
    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
}

1.5 直接使用RedisTokenStore存储token会出现NoSuchMethodError RedisConnection.set([B[B)V错误

解决方案：自己编写一个MyRedisTokenStore，复制RedisTokenStore类中代码，并将代码中conn.set(accessKey,
serializedAccessToken)修改为conn.stringCommands().set(accessKey,
serializedAccessToken);

1.6 添加操作db类

/**
 * @author wufei
 * @create 2019-03-14 9:15
 **/
@Data
public class User {
    private int id;
    private String username;
    private String password;

}
@Mapper
public interface UserMapper {
    @Select("SELECT * FROM user WHERE username = #{username}")
    User findByUserName(@Param("username") String username);
}


@Service("userDetailsService")
@Slf4j
public class DomainUserDetailsService implements UserDetailsService {
    @Autowired
    private UserMapper userMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
         User user =  userMapper.findByUserName(username);
        List<? extends GrantedAuthority> authorities = new ArrayList();
        return  new org.springframework.security.core.userdetails.User(user.getUsername(),user.getPassword(),authorities);
    }
}

1.7 添加OauthServerApplication启动类

@SpringBootApplication
@EnableDiscoveryClient
@MapperScan("com.wf.oauth.db")
public class OauthServerApplication implements CommandLineRunner {

    private final UserMapper userMapper;

    public OauthServerApplication(UserMapper userMapper) {
        this.userMapper = userMapper;
    }


    public static void main(String[] args) {
        SpringApplication.run(OauthServerApplication.class,args);
    }

    @Override
    public void run(String... args) {
        User user = this.userMapper.findByUserName("admin");
        if(user != null){
            System.out.println("================: "+user.getUsername());
        }
    }
}

1.8 配置文件：

server:
  port: 8082
  tomcat:
    accept-count: 1000
    max-threads: 1000
    max-connections: 2000
spring:
  application:
      name: auth-server
  datasource:
      url: jdbc:mysql://192.168.3.1:3306/test?useUnicode=true&characterEncoding=utf8&allowMultiQueries=true
      username: xx
      driver-class-name: com.mysql.jdbc.Driver
      password: xx
  redis:
    host: 192.168.3.1
    port: 6380
    password: xinleju
    database: 15
    jedis:
      pool:
        max-active: 8
        max-wait: -1ms
        max-idle: 8
        min-idle: 0

logging:
  level:
    org:
      springframework:
        security: DEBUG
wf:
  oauth:
    clientid: wf_oauth
    secret: wf_secret
eureka:
  client:
    service-url:
      defaultZone: http://localhost:1111/eureka/
  instance:
    prefer-ip-address: true #显示服务器IP

2. provide-server模块代码

provide-service是一个简单的微服务，使用auth-server进行认证授权，在它的配置文件指定用户信息在auth-server的地址即可：

info:
  version: "v1"
  name: "provide"
management:
  endpoints:
    web:
      exposure:
        include: '*'
#端口号
server:
   port: 8081
   tomcat:
     max-threads: 200
spring:
  application:
    name: provide-server
eureka:
  client:
    service-url:
      defaultZone: http://localhost:1111/eureka/
  instance:
    prefer-ip-address: true #显示服务器IP
security:
  oauth2:
    resource:
      id: service
      user-info-uri: http://localhost:9999/uaa/user # 使用auth-server进行认证授权，
      prefer-token-info: false

2.1 配置资源服务

@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
        super.configure(resources);
    }

    @Override
    public void configure(HttpSecurity http) throws Exception {
                http.authorizeRequests().antMatchers("/test/test2").permitAll().and() //不需要授权认证                    .csrf().disable()
                .exceptionHandling()
                .authenticationEntryPoint((request, response, authException) -> response.sendError(HttpServletResponse.SC_UNAUTHORIZED))
                .and()
                .authorizeRequests()
                .anyRequest().authenticated()
                .and()
                .httpBasic();
    }
}
@RestController
@RequestMapping("test")
public class UserController {

    @RequestMapping("test1")
    public  Object test(){
        return "ok";
    }
}

2.2 ProvideApplication启动类：

@SpringCloudApplication
public class ProvideApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProvideApplication.class,args);
        System.out.println("ProvideApplication 启动Ok！");
    }
}

2.3 添加pom配置文件

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

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-oauth2</artifactId>
        </dependency>
    </dependencies>

3. api-gataway

3.1 添加pom文件

<dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
        </dependency>
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
        </dependency>

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

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-oauth2</artifactId>
        </dependency>
    </dependencies>

3.2 关闭csrf并开启Oauth2 client支持

/**
 * 关闭csrf跨站请求伪造并开启Oauth2 client支持
 * @author wufei
 * @create 2019-03-15 9:16
 **/
@Configuration
@EnableOAuth2Sso
public class SecurityConfig  extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable();
    }

}

3.3 配置文件

info:
  version: "v1"
  name: "zuul"
management:
  endpoints:
    web:
      exposure:
        include: '*'
#端口号
server:
   port: 9999
   tomcat:
     max-threads: 200
spring:
  application:
    name: zuul
eureka:
  client:
    service-url:
      defaultZone: http://localhost:1111/eureka/
  instance:
    prefer-ip-address: true #显示服务器IP
zuul:
  routes:
    uaa:
      sensitiveHeaders:
      serviceId: auth-server
    provide:
      sensitiveHeaders:
      serviceId: provide-server
  add-proxy-headers: true

security:
  oauth2:
    client:
      access-token-uri: http://localhost:9999/uaa/oauth/token #网关的地址
      user-authorization-uri: http://localhost:9999/uaa/oauth/authorize
      client-id: wf
    resource:
      user-info-uri: http://localhost:9999/uaa/user
      prefer-token-info: false

3.4添加启动类ApiGateWayApplication
开启支持Sso

@SpringBootApplication
@EnableZuulProxy
@EnableDiscoveryClient
@EnableOAuth2Sso
public class ApiGateWayApplication {
    public static void main(String[] args) {
        SpringApplication.run(ApiGateWayApplication.class, args);
    }

}

4. 演示

分别启动eureka、zuul、auth-server、provide服务
4.1 客户端Postman调用
使用Postman通过网关http://localhost:9999/uaa/oauth/token发送请求获得access_token，用户名和密码分别是admin、admin，授权方式为password
在这里插入图片描述
在这里插入图片描述

2.携带token访问provide-server服务
在这里插入图片描述

4.2 客户端httpclient调用

/**
 * @author wufei
 * @create 2019-03-14 14:38
 **/
public class TokenTest {
    private static HttpClientContext context = HttpClientContext.create();

    public static void main(String[] args) {

        String loginUrl = "http://localhost:9999/uaa/oauth/token";

        String username  = "admin";
        String password = "admin";

        String scope = "wf";

        String clientId = "wf";

        String clientSecret = "wf";

        CloseableHttpClient httpClient = HttpClientPool.getHttpClient();//HttpClientBuilder.create().setDefaultRequestConfig(requestConfig).build();
        HttpPost httpPost = new HttpPost(loginUrl);
        List<NameValuePair> values = new ArrayList<NameValuePair>();
        values.add(new BasicNameValuePair("grant_type", "password"));
        values.add(new BasicNameValuePair("username", username));
        values.add(new BasicNameValuePair("password", password));
        values.add(new BasicNameValuePair("scope", scope));
        UrlEncodedFormEntity entity = new UrlEncodedFormEntity(values, Consts.UTF_8);
        httpPost.setEntity(entity);
        CloseableHttpResponse response = null;
        try {
            httpPost.setHeader("authorization", "Basic " + Base64.getEncoder().encodeToString((clientId + ":" + clientSecret).getBytes("utf-8")));
            String body = "";
            response = httpClient.execute(httpPost, context);
            HttpEntity httpEntity = response.getEntity();
            if (httpEntity != null) {
                try {
                    body = EntityUtils.toString(httpEntity, Consts.UTF_8);
                    System.out.println("=======================body: "+body);
                    EntityUtils.consume(httpEntity);
                } catch (IOException e) {

                }
            }
        } catch (IOException e) {

        } finally {
            try {
                response.close();
            } catch (Exception e) {

            }
        }
    }
}

返回结果：

=======================body: {"access_token":"277ab3a0-f415-4c03-b48b-1e590324afef","token_type":"bearer","refresh_token":"63243753-5ed3-421c-bf02-096f65bc8c9c","expires_in":36738,"scope":"wf"}

4.3 如果有些接口不需要oauth2认证呢？

 解决方案：在ResourceServerConfig配置上添加如下：
        http.authorizeRequests().antMatchers("/test/test2").permitAll().and() //不需要授权认证

现在我们provide-service服务有两个接口test1和test2，test2设置了不需要验证，
现在我们直接访问test2接口，
在这里插入图片描述
然后在访问test1，出现需要授权访问401
在这里插入图片描述
最后我们携带token访问test1接口，访问成功
在这里插入图片描述
最后：模拟用户登录

@RequestMapping("/login")
public String login(){
    //1验证用户和密码是否正确
    //2.清空原来的用户token
    //3.请求认证信息，颁发token
    //4.返回用户信息和token信息
    return null;
}

git源码地址：https://github.com/wflovejava/springcloud-oauth2.git

wflovejava
关注
  • 14
    点赞
  • 踩
  • 72
    收藏
    觉得还不错? 一键收藏
  • 19
    评论
专栏目录
SpringCloud+SpringBoot+OAuth2+Spring Security+Redis实现的微服务统一认证授权.doc
04-01
SpringCloud+SpringBoot+OAuth2+Spring Security+Redis实现的微服务统一认证授权
这可能是全网最详细的 Spring Cloud OAuth2 单点登录使用教程了，妈妈再也不用担心我被面试官吊打了！
2401_83916283的博客
04-08 1658
spring-cloud-starter-oauth2包含了 spring-cloud-starter-security，所以不用再单独引入了。之所以引入 redis 包，是因为下面会介绍一种用 redis 存储 token 的方式。2、配置好 application.yml将项目基本配置设置好，并加入有关 redis 的配置，稍后会用到。spring:redis:jedis:pool:server:port: 6001endpoint:health:
SpringCloud之SSO单点登录-基于Gateway和OAuth2的跨系统统一认证和鉴权详解
最新发布
踏雨歌青春，诗酒趁年华
05-29 1万+
本文详述了如何利用SpringCloud、Gateway和OAuth2实现跨系统的统一认证和鉴权。文章介绍了SSO单点登录的概念和优势，通过具体的配置和代码示例，讲解了如何搭建一个安全、高效的认证中心，实现用户只需一次登录即可访问多个系统的目标，从而提高系统安全性和用户体验。
Springcloud之OAuth2
xiaopang2020的博客
08-22 8008
springcloud之OAuth2
Spring cloud OAuth2
lpz658798的博客
03-07 2022
Spring cloud OAuth2 实战开发流程（让你从不会到一站式开发）
spring-cloud-starter-oauth2使用
yx444535180的专栏
07-02 7201
**OAuth2主要用于校验客户端合法性、产生token、校验token** **Sercurity主要用于用户名密码校验、接口权限控制** 因此OAuth2与Sercurity整合之后，校验顺序： 校验客户端合法性——校验用户名密码——产生token——校验token——校验接口权限............
spring-cloud-starter-security和spring-cloud-starter-oauth2
热门推荐
qq_30359369的博客
12-02 2万+
之前学过spring-security,最近又在学习spring-cloud-starter-security和spring-cloud-starter-oauth2, 脑子里顿时冒出一个问题: 之前学的spring-security和最近学的spring-cloud-starter-security有什么关系, spring-cloud-starter-security和spring-clou......
Spring Cloud下基于OAUTH2认证授权的实现示例
08-27
Spring Cloud下基于OAUTH2认证授权的实现示例 本文主要介绍了Spring Cloud下基于OAUTH2认证授权的实现示例，主要分为四大部分：服务注册和发现、OAUTH2认证授权中心、普通微服务和边界网关。通过OAUTH2实现多个...
Spring Cloud下OAUTH2注销的实现示例
08-27
Spring Cloud 下 OAUTH2 注销的实现示例 在本文中，我们将探讨 Spring Cloud 下 OAUTH2 注销的实现示例。首先，让我们了解什么是 OAUTH2 和为什么需要注销。 OAUTH2 是一种授权协议，用于确保客户端应用程序能够...
Spring Cloud 集成OAuth2实现身份认证和单点登录
07-20
本篇将深入探讨如何利用Spring Cloud集成OAuth2来实现身份认证和单点登录（Single Sign-On，简称SSO）。 OAuth2是一种授权框架，它允许第三方应用获取资源所有者的特定资源，同时保护了资源所有者的隐私信息。在...
springCloud之OAuth2
一起coding，一起嗨。
03-03 2768
服务器根据规则携带token重定向至http://localhost:8201/login。
从零开始SpringCloud Alibaba实战（32）——spring-cloud-starter-oauth2认证授权服务
liuerchong的博客
08-14 2586
OAuth2.0介绍 OAuth（开放授权）是一个开放标准，允许用户授权第三方应用访问他们存储在另外的服务提供者上的信息，而不需要将用户名和密码提供给第三方应用或分享他们数据的所有内容。OAuth2.0是OAuth协议的延续版本，但不向后兼容OAuth 1.0即完全废止了OAuth1.0。很多大公司如Google，Yahoo，Microsoft等都提供了OAUTH认证服务，这些都足以说明OAUTH标准逐渐成为开放资源授权的标准。 Oauth协议目前发展到2.0版本，1.0版本过于复杂，2.0版本已得到广泛应
Spring Cloud OAuth2 简介及使用
rzpy_qifengxiaoyue的博客
09-08 7083
1. 微服务架构下统一认证思路 基于Session的认证方式 在分布式的环境下，基于session的认证会出现一个问题，每个应用服务都需要在session中存储用 户身份信息，通过负载均衡将本地的请求分配到另一个应用服务需要将session信息带过去，否则 会重新认证。我们可以使用Session共享、Session黏贴等方案。 Session方案也有缺点，比如基于cookie，移动端不能有效使用等 基于token的认证方式 基于token的认证方式，服务端不用存储认证数据，易维护扩展性强， 客户端可
spring-cloud-starter-oauth2 密码模式认证过程
yx444535180的专栏
07-12 4182
上文讲到在密码模式下 OAuth2主要用于校验客户端合法性、产生token、校验token Sercurity主要用于用户名密码校验、接口权限控制 OAuth2与Sercurity整合之后，校验顺序： 获取token请求：校验客户端合法性——校验用户名密码——产生token 受保护的接口请求：校验token——校验接口权限 下面就来看下，每个步骤在源码中是如何实现的客户端合法性校验，第一步校验client_id、client_secret，就是客户端id和密码；第二步校验grant_type；第三步校验sc
springcloud整合oauth2-----鉴权服务篇
weixin_45592424的博客
09-10 1223
鉴权服务
关于spring-cloud-starter-oauth2的研究学习总结
livemegoodboy的博客
05-27 2029
先看oauth2的四种模式： 密码模式（resource owner password credentials） 使用client_id和client_secret以及用户名密码直接获取秘钥 授权码模式（authorization code） 设计了auth code，通过这个code再获取token 使用client_id和client_secret换取授权码（code），再通过授权码换取令牌 简化模式（implicit） 这种模式比授权码模式少了code环节，回调url
Spring Cloud OAuth2 认证服务器
凉茶铺的博客
08-31 2972
Spring Cloud OAuth2 是 Spring Cloud 体系对OAuth2协议的实现，可以用来做多个微服务的统一认证（验证身份合法性）授权（验证权限）。通过向OAuth2服务（统一认证授权服务）发送某个类型的grant_type进行集中认证和授权，从而获得access_token（访问令牌），而这个token是受其他微服务信任的。............
springcloud + oauth2
qq_43675092的博客
09-04 1054
springcloud + oauth2
spring cloud oauth2认证
06-28
Spring Cloud OAuth2是一个基于Spring Cloud的OAuth2认证和授权框架。它提供了一组工具和库，用于构建安全的分布式系统。Spring Cloud OAuth2支持多种OAuth2授权流程，包括授权码模式、密码模式、客户端模式和简化...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值