29、oauth2.0 资源服务器与授权服务器分离配置

最新推荐文章于 2024-06-16 09:37:21 发布
最新推荐文章于 2024-06-16 09:37:21 发布
阅读量4.4k 收藏 6
点赞数 2
分类专栏： spring cloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lixiang987654321/article/details/88133531
版权

废话刷说，这个问题已经困扰我多时，我已经经过n次尝试，n-1都是失败的，最后只有一次成功，失败是成功他妈，是血的教训，佛说千万次错过就是为了那一次邂逅。

先把我遇到的问题罗列出来：

（1）资源服务器和认证服务器分离后，配置resource.id无效；

（2）存储的secret和用户密码都必须BCEncrypt加密；

（3）认证服务器同时也是资源服务器的时候，四种授权模式不能共生（我出现的是添加上资源服务器，授权码模式无效，implicit简单模式，password模式和client credentials模式有效；认证服务器不做为资源服务器的时候四种授权模式都可以生效）。

（4）Eureka注册服务，如果配置使用了Security，并配置HttpBasic登录模式后，可能与资源服务器的授权模式会冲突（最终注册服务器使用无需用户名和密码模式）。

 

父工程POM文件：

<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.0http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <!-- 项目信息 -->

  <modelVersion>4.0.0</modelVersion>

  <groupId>com.donwait</groupId>

  <artifactId>DYS</artifactId>

  <version>0.0.1-SNAPSHOT</version>

  <packaging>pom</packaging>

  <name>道鹰4.0</name>

  <description>道鹰4.0后台集群服务</description>

 

  <!-- spring boot项目 -->

  <parent>

      <groupId>org.springframework.boot</groupId>

      <artifactId>spring-boot-starter-parent</artifactId>

      <version>2.0.4.RELEASE</version>

      <relativePath/> <!-- lookup parent from repository -->

  </parent>

 

  <!-- 项目属性 -->

  <properties>

      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

      <java.version>1.8</java.version>

      <spring-cloud.version>Finchley.RELEASE</spring-cloud.version>

      <!-- <spring-cloud.version>Finchley.BUILD-SNAPSHOT</spring-cloud.version>-->

      <lombok.version>1.16.20</lombok.version>

      <docker.registry>localhost:5000</docker.registry>

  </properties>

 

  <!-- 项目依赖管理声明，统一管理项目依赖的版本信息，继承项目无需声明版本 -->

  <dependencyManagement>

      <dependencies>

          <dependency>

              <groupId>org.springframework.cloud</groupId>

              <artifactId>spring-cloud-dependencies</artifactId>

              <version>${spring-cloud.version}</version>

              <type>pom</type>

              <scope>import</scope>

          </dependency>

          <dependency>

              <groupId>org.springframework</groupId>

              <artifactId>spring-jdbc</artifactId>

              <version>${spring.version}</version>

          </dependency>

      </dependencies>

  </dependencyManagement>

 

  <!-- 远程仓库：中央仓库找不到时候，从远程仓库中查找 -->

  <repositories>

      <repository>

          <id>spring-snapshots</id>

          <name>Spring Snapshots</name>

          <url>https://repo.spring.io/snapshot</url>

          <snapshots>

              <enabled>true</enabled>

          </snapshots>

      </repository>

      <repository>

          <id>spring-milestones</id>

          <name>Spring Milestones</name>

          <url>https://repo.spring.io/milestone</url>

          <snapshots>

              <enabled>false</enabled>

          </snapshots>

      </repository>

  </repositories>

 

  <!-- 项目依赖 -->

  <dependencies>

     <!--spring boot测试-->

     <dependency>

          <groupId>org.springframework.boot</groupId>

          <artifactId>spring-boot-starter-test</artifactId>

          <scope>test</scope>

     </dependency>

     <!-- 监控系统健康情况的工具 -->

     <dependency>

          <groupId>org.springframework.boot</groupId>

          <artifactId>spring-boot-starter-actuator</artifactId>

     </dependency>

     <!-- 修改自动检测加载工具 -->

    <dependency>

          <groupId>org.springframework.boot</groupId>

          <artifactId>spring-boot-devtools</artifactId>

          <optional>true</optional>

     </dependency>

     <!--Lombok：消除模板代码-->

     <dependency>

          <groupId>org.projectlombok</groupId>

          <artifactId>lombok</artifactId>

     </dependency>

  </dependencies>

 

  <!-- 编译插件 -->

  <build>

      <plugins>

            <!-- SpringBoot编译插件 -->

          <plugin>

              <groupId>org.springframework.boot</groupId>

              <artifactId>spring-boot-maven-plugin</artifactId>

          </plugin>

          <!-- docker编译插件docker:build -->

          <!-- mvn clean package docker:build、mvn clean package docker:build -DpushImage -->

          <plugin>

                <groupId>com.spotify</groupId>

                <artifactId>docker-maven-plugin</artifactId>

                <version>0.4.13</version>

                <configuration>

                   <!-- push到docker仓库 -->

                   <!-- <imageName>${docker.registry}/${project.name}:${project.version}</imageName>-->

                     <imageName>${project.name}:${project.version}</imageName>

                     <dockerDirectory>${project.basedir}/src/main/docker</dockerDirectory>

                     <skipDockerBuild>false</skipDockerBuild>

                   <!-- <pushImage>true</pushImage> -->

                   <!-- 这里是复制jar包到 docker容器指定目录配置，也可以写到 Docokerfile中 -->

                   <resources>

                        <resource>

                             <targetPath>/ROOT</targetPath>

                             <directory>${project.build.directory}</directory>

                             <include>${project.build.finalName}.jar</include>

                        </resource>

                   </resources>

                </configuration>

            </plugin>

      </plugins>

  </build>

 

  <!-- 项目包含子模块 -->

  <modules>

     <!-- 公共组件 -->

     <module>dys_common</module>

     <!-- 链路跟踪服务 -->

     <module>dys_zipkin_server</module>

     <!-- 全局配置中心 -->

     <module>dys_config_center</module>

     <!-- 服务注册中心 -->

     <module>dys_register_server</module>

     <!-- 配置服务：提供外部访问接口 -->

     <module>dys_config_server</module>

     <!-- 网关服务器 -->

     <module>dys_gateway_server</module>

     <!-- 认证中心 -->

     <module>dys_auth_center</module>

     <module>dys_car_server</module>

  </modules>

 

</project>

 

一、认证服务器

 

（1）POM配置文件配置

 

<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.0http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <artifactId>dys_auth_center</artifactId>

  <name>授权中心</name>

  <description>提供用户认证以及平台服务器之间的token检查认证</description>

  

  <parent>

    <groupId>com.donwait</groupId>

    <artifactId>DYS</artifactId>

    <version>0.0.1-SNAPSHOT</version>

  </parent>

  

  <dependencies>

     <!-- 公共信息包 -->

     <dependency>

          <groupId>com.donwait</groupId>

          <artifactId>dys_common</artifactId>

          <version>0.0.1-SNAPSHOT</version>

     </dependency>

     <!-- 中心配置client -->

     <dependency>

         <groupId>org.springframework.cloud</groupId>

          <artifactId>spring-cloud-starter-config</artifactId>

     </dependency>

     <!-- spring cloud 客户注册 -->

     <dependency>

          <groupId>org.springframework.cloud</groupId>

          <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>

     </dependency>

     <!-- oauth2认证 -->

     <dependency>

          <groupId>org.springframework.cloud</groupId>

          <artifactId>spring-cloud-starter-oauth2</artifactId>

     </dependency>

     <!-- 安全校验 -->

     <dependency>

          <groupId>org.springframework.cloud</groupId>

          <artifactId>spring-cloud-starter-security</artifactId>

     </dependency>

     <!-- redis -->

     <dependency>

          <groupId>org.springframework.boot</groupId>

          <artifactId>spring-boot-starter-data-redis</artifactId>

     </dependency>

     <!-- MySQL -->

     <dependency>

          <groupId>mysql</groupId>

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

     </dependency>

     <!-- Spring-Mybatis -->

     <dependency>

          <groupId>org.mybatis.spring.boot</groupId>

          <artifactId>mybatis-spring-boot-starter</artifactId>

          <version>1.3.0</version>

     </dependency>

    <!-- 阿里巴巴druid数据库连接池 -->

     <dependency>

          <groupId>com.alibaba</groupId>

          <artifactId>druid-spring-boot-starter</artifactId>

          <version>1.1.9</version>

     </dependency>

     <dependency>

       <groupId>com.alibaba</groupId>

       <artifactId>druid</artifactId>

       <version>1.1.10</version>

     </dependency>

     <!-- RESTFul接口文档：通过接口访问文档：http://localhost:8762/swagger-ui.html，8762为服务配置的监听端口，默认8080-->

     <dependency>

          <groupId>io.springfox</groupId>

          <artifactId>springfox-swagger2</artifactId>

          <version>2.2.2</version>

     </dependency>

     <dependency>

          <groupId>io.springfox</groupId>

          <artifactId>springfox-swagger-ui</artifactId>

          <version>2.2.2</version>

     </dependency>

  </dependencies>

  

</project>

 

（2）认证服务器配置

package com.donwait.config;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.Primary;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.security.authentication.AuthenticationManager;

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.ClientDetailsService;

import org.springframework.security.oauth2.provider.client.JdbcClientDetailsService;

import org.springframework.security.oauth2.provider.token.DefaultTokenServices;



import com.donwait.redis.MyRedisTokenStore;

import com.donwait.service.impl.UserDetailsServiceImpl;



@Configuration

@EnableAuthorizationServer

public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {



    @Autowired

    private AuthenticationManager authenticationManager;



    @Autowired

    private DataSource dataSource;

    @Autowired

    private UserDetailsServiceImpl userDetailsService;



    @Autowired

    private RedisConnectionFactory redisConnectionFactory;



    @Bean

    @Primary

    MyRedisTokenStore redisTokenStore(){

        return new MyRedisTokenStore(redisConnectionFactory);

    }



    @Override

    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {

        clients.withClientDetails(clientDetails());

    }

    @Bean

    public ClientDetailsService clientDetails() {

        return new JdbcClientDetailsService(dataSource);

    }

    @Override

    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {

        endpoints.tokenStore(redisTokenStore())

                .userDetailsService(userDetailsService)

                .authenticationManager(authenticationManager);

        endpoints.tokenServices(defaultTokenServices());

    }



    @Primary

    @Bean

    public DefaultTokenServices defaultTokenServices(){

        DefaultTokenServices tokenServices = new DefaultTokenServices();

        tokenServices.setTokenStore(redisTokenStore());

        tokenServices.setSupportRefreshToken(true);

        tokenServices.setClientDetailsService(clientDetails());

        tokenServices.setAccessTokenValiditySeconds(60*60*12);             // token有效期自定义设置，默认12小时

        tokenServices.setRefreshTokenValiditySeconds(60 * 60 * 24 * 7);    //默认30天，这里修改

        return tokenServices;

    }



    @Override

    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {

        security.tokenKeyAccess("permitAll()");

        security .checkTokenAccess("isAuthenticated()");

        security.allowFormAuthenticationForClients();

    }

}

（3）Security资源保护配置

package com.donwait.config;



import org.springframework.beans.factory.annotation.Autowired;

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.WebSecurity;

import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

import org.springframework.security.crypto.password.PasswordEncoder;



import com.donwait.service.impl.UserDetailsServiceImpl;



@Configuration

public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired

    private UserDetailsServiceImpl userDetailsService;

            

    @Bean

    public PasswordEncoder passwordEncoder() {

        return new BCryptPasswordEncoder();

    }



    @Override

    @Bean

    public AuthenticationManager authenticationManagerBean() throws Exception {

        return super.authenticationManagerBean();

    }

    @Override

    protected void configure(AuthenticationManagerBuilder auth) throws Exception {

        auth.userDetailsService(userDetailsService)

            .passwordEncoder(passwordEncoder());

    }



    @Override

    public void configure(WebSecurity web) throws Exception {

        web.ignoring().antMatchers("/favor.ioc");

    }



}

（4）配置文件配置

server:

  port: 7006

spring:

  application:

    name: auth

  datasource:

    name: store_service

    type: com.alibaba.druid.pool.DruidDataSource

    druid:

      driver-class-name: com.mysql.jdbc.Driver

      url: jdbc:mysql://127.0.0.1:3306/dys_auth_center?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&useSSL=false

      username: root

      password: root

      initial-size: 5

      min-idle: 5

      max-active: 20

      max-wait: 60000

      time-between-eviction-runs-millis: 60000

      min-evictable-idle-time-millis: 300000

      validation-query: SELECT 'x'

      validation-query-timeout: 6

      test-while-idle: true

      test-on-borrow: false

      test-on-return: false

      pool-prepared-statements: false

      max-pool-prepared-statement-per-connection-size: 20

      filters: stat

      connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

mybatis:

  mapper-locations: classpath:mapping/*.xml

  type-aliases-package: com.donwait.model

 

eureka:

  instance:

    prefer-ip-address: true

    registry-fetch-interval-seconds: 30

    lease-renewal-interval-in-seconds: 10

    lease-expiration-duration-in-seconds: 30

  client:

      service-url:

        defaultZone: http://127.0.0.1:7002/eureka/,http://127.0.0.1:7003/eureka/

endpoints:

  health:

    sensitive: false

    enabled: false

  shutdown:

    enabled: true

    path: /shutdown

    sensitive: true

management:

  security:

    enabled: false

security:

  oauth2:

    resource:

      filter-order: 3

logging:

  config: classpath:logback.xml

  level:

    org:

      springframework:

        web: INFO

        security: DEBUG

#actuator:

info:

  author:

    name: 李祥祥

    email:lixiang6153@126.com

  hostory:

  - date: 2018-08-28 10:10:10

    user:lixiang6153@126.com

  - date: 2018-07-10 08:30:00

    user:test@126.com

  build:

    artifact: "@project.artifactId@"

    name: "@project.name@"

    version: "@project.version@"

 

（5）启动入口

package com.donwait;



import org.mybatis.spring.annotation.MapperScan;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.cloud.client.discovery.EnableDiscoveryClient;



/**

* http://localhost:7006/oauth/authorize?response_type=code&client_id=wx_takeout_client_id&redirect_uri=http://localhost:7010/uaa/login

* @author Administrator

*/

@SpringBootApplication                    // SpringBoot应用

@EnableDiscoveryClient                    // 开启服务发现功能

@MapperScan("com.donwait.mapper")        // 将项目中对应的mapper类的路径加进来就可以了

public class AuthServerApp {



    public static void main(String[] args) {;

        SpringApplication.run(AuthServerApp.class, args);

    }

}

 

（6）redis配置

package com.donwait.redis;



import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Date;

import java.util.List;



import org.springframework.data.redis.connection.RedisConnection;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.security.oauth2.common.ExpiringOAuth2RefreshToken;

import org.springframework.security.oauth2.common.OAuth2AccessToken;

import org.springframework.security.oauth2.common.OAuth2RefreshToken;

import org.springframework.security.oauth2.provider.OAuth2Authentication;

import org.springframework.security.oauth2.provider.token.AuthenticationKeyGenerator;

import org.springframework.security.oauth2.provider.token.DefaultAuthenticationKeyGenerator;

import org.springframework.security.oauth2.provider.token.TokenStore;

import org.springframework.security.oauth2.provider.token.store.redis.JdkSerializationStrategy;

import org.springframework.security.oauth2.provider.token.store.redis.RedisTokenStoreSerializationStrategy;

import org.springframework.stereotype.Component;



import lombok.Data;



@Data

@Component

public class MyRedisTokenStore implements TokenStore {

    private static final String ACCESS = "access:";

    private static final String AUTH_TO_ACCESS = "auth_to_access:";

    private static final String AUTH = "auth:";

    private static final String REFRESH_AUTH = "refresh_auth:";

    private static final String ACCESS_TO_REFRESH = "access_to_refresh:";

    private static final String REFRESH = "refresh:";

    private static final String REFRESH_TO_ACCESS = "refresh_to_access:";

    private static final String CLIENT_ID_TO_ACCESS = "client_id_to_access:";

    private static final String UNAME_TO_ACCESS = "uname_to_access:";

    private final RedisConnectionFactory connectionFactory;

    private AuthenticationKeyGenerator authenticationKeyGenerator = new DefaultAuthenticationKeyGenerator();

    private RedisTokenStoreSerializationStrategy serializationStrategy = new JdkSerializationStrategy();

    private String prefix = "";



    public MyRedisTokenStore(RedisConnectionFactory connectionFactory) {

        this.connectionFactory = connectionFactory;

    }

    

    private byte[] serialize(Object object) {

        return this.serializationStrategy.serialize(object);

    }

    

    private byte[] serializeKey(String object) {

        return this.serialize(this.prefix + object);

    }



    private OAuth2AccessToken deserializeAccessToken(byte[] bytes) {

        return (OAuth2AccessToken)this.serializationStrategy.deserialize(bytes, OAuth2AccessToken.class);

    }

    private OAuth2Authentication deserializeAuthentication(byte[] bytes) {

        return (OAuth2Authentication)this.serializationStrategy.deserialize(bytes, OAuth2Authentication.class);

    }

    private OAuth2RefreshToken deserializeRefreshToken(byte[] bytes) {

        return (OAuth2RefreshToken)this.serializationStrategy.deserialize(bytes, OAuth2RefreshToken.class);

    }

    

    private String deserializeString(byte[] bytes) {

        return this.serializationStrategy.deserializeString(bytes);

    }

    

    private static String getApprovalKey(OAuth2Authentication authentication) {

        String userName = authentication.getUserAuthentication() == null ? "": authentication.getUserAuthentication().getName();

        return getApprovalKey(authentication.getOAuth2Request().getClientId(), userName);

    }

    private static String getApprovalKey(String clientId, String userName) {

        return clientId + (userName == null ? "" : ":" + userName);

    }



    private RedisConnection getConnection() {

        return this.connectionFactory.getConnection();

    }

    

    @Override

    public OAuth2AccessToken getAccessToken(OAuth2Authentication authentication) {

        String key = this.authenticationKeyGenerator.extractKey(authentication);

        byte[] serializedKey = this.serializeKey(AUTH_TO_ACCESS + key);

        byte[] bytes = null;

        RedisConnection conn = this.getConnection();

        try {

            bytes = conn.get(serializedKey);

        } finally {

            conn.close();

        }

        OAuth2AccessToken accessToken = this.deserializeAccessToken(bytes);

        if (accessToken != null) {

            OAuth2Authentication storedAuthentication = this.readAuthentication(accessToken.getValue());

            if (storedAuthentication == null || !key.equals(this.authenticationKeyGenerator.extractKey(storedAuthentication))) {

                this.storeAccessToken(accessToken, authentication);

            }

        }

        return accessToken;

    }

    @Override

    public OAuth2Authentication readAuthentication(OAuth2AccessToken token) {

        return this.readAuthentication(token.getValue());

    }

    @Override

    public OAuth2Authentication readAuthentication(String token) {

        byte[] bytes = null;

        RedisConnection conn = this.getConnection();

        try {

            bytes = conn.get(this.serializeKey("auth:" + token));

        } finally {

            conn.close();

        }

        OAuth2Authentication auth = this.deserializeAuthentication(bytes);

        return auth;

    }

    @Override

    public OAuth2Authentication readAuthenticationForRefreshToken(OAuth2RefreshToken token) {

        return this.readAuthenticationForRefreshToken(token.getValue());

    }

    public OAuth2Authentication readAuthenticationForRefreshToken(String token) {

        RedisConnection conn = getConnection();

        try {

            byte[] bytes = conn.get(serializeKey(REFRESH_AUTH + token));

            OAuth2Authentication auth = deserializeAuthentication(bytes);

            return auth;

        } finally {

            conn.close();

        }

    }

    @Override

    public void storeAccessToken(OAuth2AccessToken token, OAuth2Authentication authentication) {

        byte[] serializedAccessToken = serialize(token);

        byte[] serializedAuth = serialize(authentication);

        byte[] accessKey = serializeKey(ACCESS + token.getValue());

        byte[] authKey = serializeKey(AUTH + token.getValue());

        byte[] authToAccessKey = serializeKey(AUTH_TO_ACCESS + authenticationKeyGenerator.extractKey(authentication));

        byte[] approvalKey = serializeKey(UNAME_TO_ACCESS + getApprovalKey(authentication));

        byte[] clientId = serializeKey(CLIENT_ID_TO_ACCESS + authentication.getOAuth2Request().getClientId());

        RedisConnection conn = getConnection();

        try {

            conn.openPipeline();

            conn.stringCommands().set(accessKey, serializedAccessToken);

            conn.stringCommands().set(authKey, serializedAuth);

            conn.stringCommands().set(authToAccessKey, serializedAccessToken);

            if (!authentication.isClientOnly()) {

                conn.rPush(approvalKey, serializedAccessToken);

            }

            conn.rPush(clientId, serializedAccessToken);

            if (token.getExpiration() != null) {

                int seconds = token.getExpiresIn();

                conn.expire(accessKey, seconds);

                conn.expire(authKey, seconds);

                conn.expire(authToAccessKey, seconds);

                conn.expire(clientId, seconds);

                conn.expire(approvalKey, seconds);

            }

            OAuth2RefreshToken refreshToken = token.getRefreshToken();

            if (refreshToken != null && refreshToken.getValue() != null) {

                byte[] refresh = serialize(token.getRefreshToken().getValue());

                byte[] auth = serialize(token.getValue());

                byte[] refreshToAccessKey = serializeKey(REFRESH_TO_ACCESS + token.getRefreshToken().getValue());

                conn.stringCommands().set(refreshToAccessKey, auth);

                byte[] accessToRefreshKey = serializeKey(ACCESS_TO_REFRESH + token.getValue());

                conn.stringCommands().set(accessToRefreshKey, refresh);

                if (refreshToken instanceof ExpiringOAuth2RefreshToken) {

                    ExpiringOAuth2RefreshToken expiringRefreshToken = (ExpiringOAuth2RefreshToken) refreshToken;

                    Date expiration = expiringRefreshToken.getExpiration();

                    if (expiration != null) {

                        int seconds = Long.valueOf((expiration.getTime() - System.currentTimeMillis()) / 1000L)

                                .intValue();

                        conn.expire(refreshToAccessKey, seconds);

                        conn.expire(accessToRefreshKey, seconds);

                    }

                }

            }

            conn.closePipeline();

        } finally {

            conn.close();

        }

    }

    @Override

    public void removeAccessToken(OAuth2AccessToken accessToken) {

        this.removeAccessToken(accessToken.getValue());

    }

    @Override

    public OAuth2AccessToken readAccessToken(String tokenValue) {

        byte[] key = serializeKey(ACCESS + tokenValue);

        byte[] bytes = null;

        RedisConnection conn = getConnection();

        try {

            bytes = conn.get(key);

        } finally {

            conn.close();

        }

        OAuth2AccessToken accessToken = deserializeAccessToken(bytes);

        return accessToken;

    }

    public void removeAccessToken(String tokenValue) {

        byte[] accessKey = serializeKey(ACCESS + tokenValue);

        byte[] authKey = serializeKey(AUTH + tokenValue);

        byte[] accessToRefreshKey = serializeKey(ACCESS_TO_REFRESH + tokenValue);

        RedisConnection conn = getConnection();

        try {

            conn.openPipeline();

            conn.get(accessKey);

            conn.get(authKey);

            conn.del(accessKey);

            conn.del(accessToRefreshKey);

            // Don't remove the refresh token - it's up to the caller to do that

            conn.del(authKey);

            List<Object> results = conn.closePipeline();

            byte[] access = (byte[]) results.get(0);

            byte[] auth = (byte[]) results.get(1);

            OAuth2Authentication authentication = deserializeAuthentication(auth);

            if (authentication != null) {

                String key = authenticationKeyGenerator.extractKey(authentication);

                byte[] authToAccessKey = serializeKey(AUTH_TO_ACCESS + key);

                byte[] unameKey = serializeKey(UNAME_TO_ACCESS + getApprovalKey(authentication));

                byte[] clientId = serializeKey(CLIENT_ID_TO_ACCESS + authentication.getOAuth2Request().getClientId());

                conn.openPipeline();

                conn.del(authToAccessKey);

                conn.lRem(unameKey, 1, access);

                conn.lRem(clientId, 1, access);

                conn.del(serialize(ACCESS + key));

                conn.closePipeline();

            }

        } finally {

            conn.close();

        }

    }

    @Override

    public void storeRefreshToken(OAuth2RefreshToken refreshToken, OAuth2Authentication authentication) {

        byte[] refreshKey = serializeKey(REFRESH + refreshToken.getValue());

        byte[] refreshAuthKey = serializeKey(REFRESH_AUTH + refreshToken.getValue());

        byte[] serializedRefreshToken = serialize(refreshToken);

        RedisConnection conn = getConnection();

        try {

            conn.openPipeline();

            conn.stringCommands().set(refreshKey, serializedRefreshToken);

            conn.stringCommands().set(refreshAuthKey, serialize(authentication));

            if (refreshToken instanceof ExpiringOAuth2RefreshToken) {

                ExpiringOAuth2RefreshToken expiringRefreshToken = (ExpiringOAuth2RefreshToken) refreshToken;

                Date expiration = expiringRefreshToken.getExpiration();

                if (expiration != null) {

                    int seconds = Long.valueOf((expiration.getTime() - System.currentTimeMillis()) / 1000L)

                            .intValue();

                    conn.expire(refreshKey, seconds);

                    conn.expire(refreshAuthKey, seconds);

                }

            }

            conn.closePipeline();

        } finally {

            conn.close();

        }

    }

    @Override

    public OAuth2RefreshToken readRefreshToken(String tokenValue) {

        byte[] key = serializeKey(REFRESH + tokenValue);

        byte[] bytes = null;

        RedisConnection conn = getConnection();

        try {

            bytes = conn.get(key);

        } finally {

            conn.close();

        }

        OAuth2RefreshToken refreshToken = deserializeRefreshToken(bytes);

        return refreshToken;

    }

    @Override

    public void removeRefreshToken(OAuth2RefreshToken refreshToken) {

        this.removeRefreshToken(refreshToken.getValue());

    }

    public void removeRefreshToken(String tokenValue) {

        byte[] refreshKey = serializeKey(REFRESH + tokenValue);

        byte[] refreshAuthKey = serializeKey(REFRESH_AUTH + tokenValue);

        byte[] refresh2AccessKey = serializeKey(REFRESH_TO_ACCESS + tokenValue);

        byte[] access2RefreshKey = serializeKey(ACCESS_TO_REFRESH + tokenValue);

        RedisConnection conn = getConnection();

        try {

            conn.openPipeline();

            conn.del(refreshKey);

            conn.del(refreshAuthKey);

            conn.del(refresh2AccessKey);

            conn.del(access2RefreshKey);

            conn.closePipeline();

        } finally {

            conn.close();

        }

    }

    @Override

    public void removeAccessTokenUsingRefreshToken(OAuth2RefreshToken refreshToken) {

        this.removeAccessTokenUsingRefreshToken(refreshToken.getValue());

    }

    private void removeAccessTokenUsingRefreshToken(String refreshToken) {

        byte[] key = serializeKey(REFRESH_TO_ACCESS + refreshToken);

        List<Object> results = null;

        RedisConnection conn = getConnection();

        try {

            conn.openPipeline();

            conn.get(key);

            conn.del(key);

            results = conn.closePipeline();

        } finally {

            conn.close();

        }

        if (results == null) {

            return;

        }

        byte[] bytes = (byte[]) results.get(0);

        String accessToken = deserializeString(bytes);

        if (accessToken != null) {

            removeAccessToken(accessToken);

        }

    }

    public Collection<OAuth2AccessToken> findTokensByClientIdAndUserName(String clientId, String userName) {

        byte[] approvalKey = serializeKey(UNAME_TO_ACCESS + getApprovalKey(clientId, userName));

        List<byte[]> byteList = null;

        RedisConnection conn = getConnection();

        try {

            byteList = conn.lRange(approvalKey, 0, -1);

        } finally {

            conn.close();

        }

        if (byteList == null || byteList.size() == 0) {

            return Collections.<OAuth2AccessToken> emptySet();

        }

        List<OAuth2AccessToken> accessTokens = new ArrayList<OAuth2AccessToken>(byteList.size());

        for (byte[] bytes : byteList) {

            OAuth2AccessToken accessToken = deserializeAccessToken(bytes);

            accessTokens.add(accessToken);

        }

        return Collections.<OAuth2AccessToken> unmodifiableCollection(accessTokens);

    }

    @Override

    public Collection<OAuth2AccessToken> findTokensByClientId(String clientId) {

        byte[] key = serializeKey(CLIENT_ID_TO_ACCESS + clientId);

        List<byte[]> byteList = null;

        RedisConnection conn = getConnection();

        try {

            byteList = conn.lRange(key, 0, -1);

        } finally {

            conn.close();

        }

        if (byteList == null || byteList.size() == 0) {

            return Collections.<OAuth2AccessToken> emptySet();

        }

        List<OAuth2AccessToken> accessTokens = new ArrayList<OAuth2AccessToken>(byteList.size());

        for (byte[] bytes : byteList) {

            OAuth2AccessToken accessToken = deserializeAccessToken(bytes);

            accessTokens.add(accessToken);

        }

        return Collections.<OAuth2AccessToken> unmodifiableCollection(accessTokens);

    }

}

（7）redis密码比对

package com.donwait.redis;



import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

import org.springframework.security.crypto.factory.PasswordEncoderFactories;

import org.springframework.security.crypto.password.PasswordEncoder;



/**

* PasswordEncoder密码验证clientId的时候会报错，因为5.0新特性中需要在密码前方需要加上{Xxx}来判别。

* 所以需要自定义一个类，重新BCryptPasswordEncoder的match方法

* MyBCryptPasswordEncoder类是我自定义的一个类，用来重新match方法

* @author Administrator

*/

public class MyBCryptPasswordEncoder extends BCryptPasswordEncoder {

    @Override

    public boolean matches(CharSequence rawPassword, String encodedPassword) {

        PasswordEncoder passwordEncoder = PasswordEncoderFactories.createDelegatingPasswordEncoder();

        String presentedPassword = passwordEncoder.encode(rawPassword);

        return passwordEncoder.matches(rawPassword, presentedPassword);

    }

}

（8）UserDetailsService接口实现

package com.donwait.service.impl;



import java.util.HashSet;

import java.util.List;

import java.util.Set;



import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.security.core.GrantedAuthority;

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.UserDetailsService;

import org.springframework.security.core.userdetails.UsernameNotFoundException;

import org.springframework.stereotype.Service;



import com.donwait.model.Right;

import com.donwait.service.RightService;

import com.donwait.service.UserService;



@Service

public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired

    private UserService userService;                // 用户服务

    @Autowired

    private RightService rightService;                // 权限服务



    @Override

    public UserDetails loadUserByUsername(String userName) throws UsernameNotFoundException {

        // 查找用户

        com.donwait.model.User user = userService.findByUsername(userName);

        if (null == user) {

            throw new UsernameNotFoundException("用户:" + userName + ",不存在!");

        }

        

        // 设置用户权限

        Set<GrantedAuthority> grantedAuthorities = new HashSet<GrantedAuthority>();

        List<Right> rights = rightService.findByUsername(userName);

        for(Right right : rights) {

            GrantedAuthority authority = new SimpleGrantedAuthority(right.getName());

            grantedAuthorities.add(authority);

        }       

        

        // 标识位设置

        boolean enabled = true;                         // 可用性 :true:可用 false:不可用

        boolean accountNonExpired = true;                 // 过期性 :true:没过期 false:过期

        boolean credentialsNonExpired = true;             // 有效性 :true:凭证有效 false:凭证无效

        boolean accountNonLocked = true;                 // 锁定性 :true:未锁定 false:已锁定

        

        return new User(user.getUsername(), user.getPassword(), enabled, accountNonExpired, credentialsNonExpired, accountNonLocked, grantedAuthorities);

    }

}

（9）注销token配置

package com.donwait.endpoint;



import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.security.oauth2.provider.endpoint.FrameworkEndpoint;

import org.springframework.security.oauth2.provider.token.ConsumerTokenServices;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.ResponseBody;



@FrameworkEndpoint

public class RevokeTokenEndpoint {

    @Autowired

    private ConsumerTokenServices consumerTokenServices;



    @RequestMapping(value = "/oauth/token", method= RequestMethod.DELETE)

    public @ResponseBody

    String revokeToken(String access_token){

        String msg = "";

        if (consumerTokenServices.revokeToken(access_token)){

            msg = "注销成功";

        }else {

            msg = "注销失败";

        }

        return msg;

    }

}

二、资源服务器配置

 

（1）POM配置

<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.0http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <artifactId>dys_car_server</artifactId>

  <name>车辆服务</name>

  <description>提供平台车辆管理、车牌报警等相关服务</description>

 

  <parent>

    <groupId>com.donwait</groupId>

    <artifactId>DYS</artifactId>

    <version>0.0.1-SNAPSHOT</version>

  </parent>

 

  <dependencies>

     <!-- 公共信息包 -->

     <dependency>

          <groupId>com.donwait</groupId>

          <artifactId>dys_common</artifactId>

          <version>0.0.1-SNAPSHOT</version>

     </dependency>

     <!-- SpringMVC -->

     <dependency>

          <groupId>org.springframework.boot</groupId>

          <artifactId>spring-boot-starter-web</artifactId>

     </dependency>

     <!-- 配置客户端 -->

     <dependency>

         <groupId>org.springframework.cloud</groupId>

         <artifactId>spring-cloud-starter-config</artifactId>

     </dependency>

     <!-- spring cloud 客户注册 -->

     <dependency>

          <groupId>org.springframework.cloud</groupId>

          <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>

     </dependency>

     <!-- MySQL -->

     <dependency>

          <groupId>mysql</groupId>

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

     </dependency>

     <!-- Spring-Mybatis -->

     <dependency>

          <groupId>org.mybatis.spring.boot</groupId>

          <artifactId>mybatis-spring-boot-starter</artifactId>

          <version>1.3.0</version>

     </dependency> 

    <!-- 阿里巴巴druid数据库连接池 -->

     <dependency>

          <groupId>com.alibaba</groupId>

          <artifactId>druid-spring-boot-starter</artifactId>

          <version>1.1.9</version>

     </dependency>

     <dependency>

       <groupId>com.alibaba</groupId>

       <artifactId>druid</artifactId>

       <version>1.1.10</version>

     </dependency>

     <!-- RESTFul接口文档：通过接口访问文档：http://localhost:8762/swagger-ui.html，8762为服务配置的监听端口，默认8080-->

     <dependency>

          <groupId>io.springfox</groupId>

          <artifactId>springfox-swagger2</artifactId>

          <version>2.2.2</version>

     </dependency>

     <dependency>

          <groupId>io.springfox</groupId>

          <artifactId>springfox-swagger-ui</artifactId>

          <version>2.2.2</version>

     </dependency>

     <!-- 消息中间件RabbitMQ -->

     <dependency>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-amqp</artifactId>

     </dependency>

     <!-- protobuf -->

     <dependency>

     <groupId>com.google.protobuf</groupId>

     <artifactId>protobuf-java</artifactId>

     <version>3.5.1</version>

    </dependency>

    <!-- 资源服务器 -->

    <dependency>

        <groupId>org.springframework.cloud</groupId>

        <artifactId>spring-cloud-starter-security</artifactId>

    </dependency>

    <dependency>

        <groupId>org.springframework.security.oauth.boot</groupId>

        <artifactId>spring-security-oauth2-autoconfigure</artifactId>

    </dependency>

  </dependencies>

 

</project>

 

(2)资源服务器配置

package com.donwait.config;



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;

import org.springframework.security.oauth2.config.annotation.web.configurers.ResourceServerSecurityConfigurer;



@Configuration

@EnableResourceServer

public class ResourceServerConfiguration extends ResourceServerConfigurerAdapter {

    // 改资源服务器id必须在数据库记录中有配置，也就是对应token的用户必须该资源访问权限(密文：test_resource_secret)

    // 例如，我的数据库记录：'wx_takeout_client_id','test_resource_id','$2a$10$I28j9B0T/roapkMEqfIHguARt0GgLyXwC/DOnFwPpXuQ0xTkrd632','user_info','authorization_code,refresh_token,implicit,password','http://localhost:7010/uaa/login','ROLE_ADMIN,ROLE_DEVICE,ROLE_VIDEO',3600,7200,'{\"systemInfo\":\"Atlas System\"}','true'

    // 通过授权模式或简化模式获取的token（对应用户为wx_takeout_client_id）具有访问资源服务器test_resource_id的权限，所以将改资源服务器id要与数据库的对应，否则无法访问

    private static final String DEMO_RESOURCE_ID = "test_resource_id";

    

    /**

     * 以代码形式配置资源服务器id，配置文件配置不生效

     */

    @Override

    public void configure(ResourceServerSecurityConfigurer resources) {

        resources.resourceId(DEMO_RESOURCE_ID).stateless(true);

    }

    

    @Override

    public void configure(HttpSecurity http) throws Exception {

        http

        .authorizeRequests()

        .antMatchers("/add/**")

        .authenticated();

    }

}

（3）控制器

package com.donwait.controller;



import org.springframework.security.core.Authentication;

import org.springframework.security.core.context.SecurityContextHolder;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;



import io.swagger.annotations.Api;

import io.swagger.annotations.ApiOperation;

import lombok.extern.slf4j.Slf4j;



@Slf4j

@Api(value = "车牌服务控制器", description = "提供车牌抓拍搜索等相关接口")

@RestController

public class CarAlarmController {

    

    @ApiOperation(value="增加车牌抓拍报警", notes="上传车牌识别报警信息并入库")

    @RequestMapping("/add/{id}")

    public String add(@PathVariable String id) {

        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();

        log.debug("授权信息:{}",authentication);        

        return "Add car alarm";

    }

}

（4）程序入口

package com.donwait;



import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.boot.autoconfigure.security.oauth2.client.EnableOAuth2Sso;



@SpringBootApplication

@EnableOAuth2Sso

public class CarApp {



    public static void main(String[] args) {

        SpringApplication.run(CarApp.class, args);

    }



}

三、使用流程

（1）使用授权码模式获取token

打开浏览器，输入：http://localhost:7006/oauth/authorize?response_type=code&client_id=wx_takeout_client_id&redirect_uri=http://localhost:7010/uaa/login

 

重定向到登录页面：输入用户名密码

 

登录成功后重定向到redirect_uri并携带了code授权码

 

 

使用postman，输入授权码和其他参数，换取token

 

（2）通过从认证服务器换取的token访问资源服务器

 

使用GET方式，携带上token授权码，授权码放在header中：

注意：这里必须选择bearer token，这是oauth默认的认证方式，发送后即可返回结果

 

备注：当然获取token的过程可以使用四种授权模式的任意一种，比如可以使用password模式：

此处的授权认证的username为client_id密码为client_secret, 登录的用户名是lixx，用户名lixx的密码为dw123456

 

重点： 另外一种配置方式：

security: 

  oauth2:

    resource:

      filter-order: 3

      id: test_resource_id

      tokenInfoUri: http://localhost:7006/oauth/check_token

      preferTokenInfo: true

      

最后两行改为，不使用tokeninfo验证，使用用户信息验证：

      user-info-uri:http://localhost:7006/user/principal

        prefer-token-info: false

 

此时资源请求方式为： 直接在url后面带上access_token=xxx, 并且头部不使用授权方式：

 

 

快来成为我的朋友或合作伙伴，一起交流，一起进步！
QQ群：961179337
微信：lixiang6153
邮箱：lixx2048@163.com
公众号：IT技术快餐
更多资料等你来拿！

 

贝壳里的沙
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
spring security +oauth2（授权服务和资源服务分离） 解决getPrincipal只返回用户名的问题
sehor2012的博客
11-26 2776
spring security +oauth2（授权服务和资源服务分离） 解决Principal只返回用户名的问题
webapi基于Owin中间件的oauth2.0身份认证
10-07
OAuth2.0的核心是将认证和授权分离，提高了安全性，同时也方便了开发者。 **.NET中的OAuth2.0实现** 在.NET环境中，我们可以利用Owin中间件来实现OAuth2.0身份认证。Owin是.NET平台下的一套标准接口，用于构建自...
搭建spring-security-oauth2授权服务(服务)和资源服务(模块)（二）—— 搭建资源模块
疯子也是猖狂
03-05 425
上一张简单搭建了一下授权服务 由于采用的是微服务，所以创建一个资源模块，然后各个服务引入比较合适 目录结构 资源模块就很好配置了，主要就是拦截和验证呗。TokenJsonDomain是我token中存的信息，因为比较常用，所以就存一下。 一个核心配置文件直接搞定一大半 package com.zz.zzsecurityoauthres.config; import com.zz.constant.Oauth2Constant; import com.zz.zzsecurityoauthre
最新版微服务架构鉴权解决方案Spring Cloud Gateway + Oauth2.0+mybatis+mysql+redis+nacos 统一认证和鉴权
Dream_it_possible！的博客
04-29 1万+
环境列表 网关服务。以springboot+springcloud+gateway 实现的网关服务。 Nacos server注册中心。本地或云上的Nacos server。 普通微服务: user-service。需要将user-service注册到Nacos。 Auth2 server 授权服务器。 需要将Auth2 server注册到Nacos。 资源服务器。 将user-service 配置成资源服务器。Oauth2.0原理简介 授权服务器: 给具有权限的资源拥有者对
使用Spring Boot实现OAuth2授权与资源服务器
最新发布
gitblog_00097的博客
06-16 389
使用Spring Boot实现OAuth2授权与资源服务器 项目简介 项目地址:https://gitcode.com/FrontierPsychiatrist/spring-oauth-example 该项目是一个基于Spring Boot和Spring Security OAuth2的示例应用，演示了如何构建一个授权服务器和资源服务器。此外，还包含了几个客户端应用程序实例，用于向你展示如何与资...
SpringSecurity + Oauth2.0搭建授权服务中心集中鉴权
qq_16047373的博客
06-01 1047
采用oauth2.0 + SpringSecurity 搭建一个oauth2.0授权服务中心和一些资源服务器（密码模式测试可用），实现简单的微服务接口安全和权限控制。 Spring-Security存在于各个微服务系统中实现对url的访问控制，oauth2实现对微服务所有的rest接口的权限控制。 这是一个资源服务器和授权中心分离的demo，token存到表中保存。 0 软件环境 1、jdk1.8 2、springboot 2.0.7.release 3、spring-security 5
Spring Security OAuth2.0 - AuthorizationServer和ResourceServer分离
weixin_30457065的博客
04-19 1930
《Spring Security实现OAuth2.0授权服务 - 基础版》和《Spring Security实现OAuth2.0授权服务 - 进阶版》两篇文章中介绍如何搭建OAuth2.0授权服务器和资源服务器。 本文将继续优化，将授权服务器和资源服务器分离，部署在不同的服务器上面。 一、简要说明 Spring Security OAuth2.0既可以把授权服务器(Auth...
springSecurity+oauth2实现权限认证系统(资源服务器与授权服务器分离，client信息入库，token存入redis持久化)
a624193873的博客
05-29 9472
文章目录前言oAuth2授权码模式认证流程权限认证系统的三个角色客户端资源服务器认证服务器完整流程演示项目地址 前言 本文章侧重实战，是为线上系统做的一个demo。适合对oauth2有一定理解后再阅读。 如果对oauth2理解还不够深入，建议先阅读芋道 Spring Security Oauth2入门来夯实一下基础。 这个demo主要实现了资源服务器与授权服务器分离，client信息入库，token信息在redis中持久化，demo的github地址会在文末贴出。 oAuth2授权码模式认证流程 权限认证系
【Nacos】【OAuth2】密码模式-授权服务器与资源服务器分离
lorogy的博客
06-09 1122
密码模式粗浅理解 认证（授权）服务器（Authorization Server）：用于认证用户，如果客户端认证通过，则发放给其访问资源服务器的令牌 资源服务器（Resource Server）：拥有受保护资源，如果请求包含正确的访问令牌，则可以访问资源，可以是提供管理后台、客户端 API 的服务 客户端（Client）：可以是浏览器、客户端，也可以是内部服务 资源拥有者（Resource Owner）：最终用户，他有访问资源的账号与密码，可以简单把资源拥有者理解成人，他在使用客户端访问资源 （A）用户
spring security oauth2.0授权服务器和资源服务器
New_CJ的博客
07-13 1169
使用@EnableAuthorizationServer并且继承AuthorizationServerConfigurerAdapter开启授权服务器 AuthorizationServerSecurityConfigurer ：用于配置授权服务的安全策略 AuthenticationEntryPoint：这个用于ExceptionTranslationFilter AccessD...
scala-oauth2-provider：用Scala编写的OAuth 2.0服务器端实现
02-05
`scala-oauth2-provider`是用Scala语言实现的一个OAuth 2.0授权服务器的库，它提供了一套完整的解决方案来构建自己的OAuth 2.0服务器。这个库的主要目标是帮助开发者快速、安全地集成OAuth 2.0授权机制到他们的应用...
oauth2全套（授权服务器+资源服务器+客户端独立版）
04-10
独立的授权服务器，资源服务器，客户端单点登录系统。 采用Oauth2进行token认证，模拟用户信息进行登录。
PWMIS.OAuth2.0:PWMIS OAuth 2.0演示和工具
05-01
PWMIS.OAuth2.0 授权认证服务程序说明 主要目的 本示例演示了OAuth 2.0的具体使用过程，与网络上其它示例不同的是，本示例的系统各个角色是分开，即授权服务器和资源服务器是分开设计部署的 ASP.NET站点。同时，还有...
cas3.5.0集成oauth2.0协议
03-21
OAuth2.0的核心是将用户的授权过程与实际的服务提供者分离，这样第三方应用可以在用户不泄露其登录凭证的情况下，获取到授权进行操作。 **CAS3.5.0集成OAuth2.0** CAS（Central Authentication Service）是一款...
API接口设计 OAuth2.0认证
08-13
API接口设计OAuth2.0认证是一种广泛应用于现代Web服务的安全授权框架，用于保护资源服务器上的敏感数据。OAuth2.0允许第三方应用在用户许可的情况下访问其存储在特定服务提供商（如Google、Facebook）上的信息，而...
SpringCloud-oauth2探索实现授权服务器和资源服务器的分离
m0_37676106的博客
08-28 1921
本人此前没有接触过OAuth2的相关知识，现在要实现一个Demo，使用Oauth2 的微服务相互调用的 设计与编写。 目标是： 有授权服务器 A，资源服务器 B，资源服务器 C 用户调用资源服务器B 接口，资源服务器通过oauth2 协议调用资源服务器C 接口得到结果并返回用户。 忙活了一个多星期，原理和过程也没深入完全了解清楚，不过功能都实现了，在此进行记录。 网上很多都是引用了spring-cloud-starter-security这个包，但是我用的是spring-cloud-s..
Spring Cloud Security OAuth2授权模式和资源服务器
热门推荐
学习记录和总结
05-15 1万+
Spring Cloud Security OAuth2授权模式和资源服务器
从零开始超详细的Spring Security OAuth2.0实现分布式系统授权（注册中心+网关+认证授权服务（JWT令牌验证）+资源调用服务）
爱吃鸡腿的明仔
01-22 2575
一。OAuth2.0 1.介绍 OAuth（开放授权）是一个开放标准，允许用户授权第三方应用访问他们存储在另外的服务提供者上的信息，而不 需要将用户名和密码提供给第三方应用或分享他们数据的所有内容。OAuth2.0是OAuth协议的延续版本，但不向 后兼容OAuth 1.0即完全废止了OAuth1.0。很多大公司如Google，Yahoo，Microsoft等都提供了OAUTH认证服 务，这些都足以说明OAUTH标准逐渐成为开放资源授权的标准。 Oauth协议目前发展到2.0版本，1.0版本过于复杂，2.0
OAuth2资源访问控制 OAuth2.0认证服务器配置和资源服务器配置（OAuth2.0学习第二天）
tianlong1569的专栏
09-03 4655
本文代码接着第一天的内容进行更新。（OAuth2.0基础配置信息，OAuth2.0学习第一天地址-https://blog.csdn.net/tianlong1569/article/details/108366395） 在前文中我们已经获得了access_token，但是当通过access_token调用相关的接口的时候报出下面异常 { "timestamp": "2020-09-03T06:57:33.443+0000", "status": 401, "error": "
理解OAuth2.0：安全授权协议详解
OAuth2.0 的主要组成部分包括四个角色：资源所有者（Resource Owner）、客户端（Client）、资源服务器（Resource Server）和授权服务器（Authorization Server）。资源所有者是拥有需要保护资源的用户；客户端是需要...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

贝壳里的沙

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

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

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

打赏作者

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

抵扣说明：

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

余额充值