spring security oauth2 授权码模式（一）使用内存配置方式进行认证授权获取access_token

最新推荐文章于 2024-05-01 13:47:40 发布
最新推荐文章于 2024-05-01 13:47:40 发布
阅读量1.5k 收藏 4
点赞数
分类专栏： # spring security oauth2 文章标签： 授权码模式 spring security oauth2 inMemory 认证授权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yssa1125001/article/details/106693041
版权

模块化开发方式创建项目：

oauth2 父pom配置：

<?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>

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

    <groupId>com.gbx</groupId>
    <artifactId>spring-security-oauth2</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <url>http://www.gbx.com</url>

    <modules>
        <module>spring-security-dependencies</module>
        <module>spring-security-authorization</module>
    </modules>

    <properties>
        <java.version>1.8</java.version>
        <maven.compiler.source>${java.version}</maven.compiler.source>
        <maven.compiler.target>${java.version}</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    </properties>

    <licenses>
        <license>
            <name>Apache 2.0</name>
            <url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
        </license>
    </licenses>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.gbx</groupId>
                <artifactId>spring-security-dependencies</artifactId>
                <version>${project.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <profiles>
        <profile>
            <id>default</id>
            <activation>
                <activeByDefault>true</activeByDefault>
            </activation>
            <properties>
                <spring-javaformat.version>0.0.7</spring-javaformat.version>
            </properties>
            <build>
                <plugins>
                    <plugin>
                        <groupId>io.spring.javaformat</groupId>
                        <artifactId>spring-javaformat-maven-plugin</artifactId>
                        <version>${spring-javaformat.version}</version>
                    </plugin>

                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-surefire-plugin</artifactId>
                        <configuration>
                            <!-- 打包时执行的测试用例  -->
                            <includes>
                                <include>**/*Tests.java</include>
                            </includes>
                            <!-- 打包时 不 执行的测试用例  -->
                            <excludes>
                                <exclude>**/Abstract*.java</exclude>
                            </excludes>
                            <systemPropertyVariables>
                                <java.security.egd>file:/dev/./urandom</java.security.egd>
                                <java.awt.headless>true</java.awt.headless>
                            </systemPropertyVariables>
                        </configuration>
                    </plugin>

                    <!-- mvn clean package的时候，会在console中打印出来冲突的jar版本和其父pom  -->
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-enforcer-plugin</artifactId>
                        <executions>
                            <execution>
                                <id>enforce-rules</id>
                                <goals>
                                    <goal>enforce</goal>
                                </goals>
                                <configuration>
                                    <rules>
                                        <bannedDependencies>
                                            <!-- 彻底排除使用 -->
                                            <excludes>
                                                <exclude>commons-logging:*:*</exclude>
                                            </excludes>
                                            <!-- 是否搜索间接传递性依赖 -->
                                            <searchTransitive>true</searchTransitive>
                                        </bannedDependencies>
                                    </rules>
                                    <fail>true</fail>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>

                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-install-plugin</artifactId>
                        <configuration>
                            <skip>true</skip>
                        </configuration>
                    </plugin>

                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-javadoc-plugin</artifactId>
                        <configuration>
                            <skip>true</skip>
                        </configuration>
                        <inherited>true</inherited>
                    </plugin>
                </plugins>
            </build>
        </profile>
    </profiles>

    <pluginRepositories>
        <pluginRepository>
            <id>spring-milestone</id>
            <name>Spring Milestone</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
        <pluginRepository>
            <id>spring-snapshot</id>
            <name>Spring Snapshot</name>
            <url>https://repo.spring.io/snapshot</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>
</project>

dependencies pom依赖：

<?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>com.gbx</groupId>
    <artifactId>spring-security-dependencies</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <url>http://www.gbx.com</url>

    <properties>
        <spring-cloud.version>Hoxton.RELEASE</spring-cloud.version>
        <spring-boot-web-version>2.2.1.RELEASE</spring-boot-web-version>
        <spring-boot-test-version>2.2.6.RELEASE</spring-boot-test-version>
        <spring-cloud-oauth2-version>2.1.4.RELEASE</spring-cloud-oauth2-version>
    </properties>

    <licenses>
        <license>
            <name>Apache 2.0</name>
            <url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
        </license>
    </licenses>

    <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>

            <!-- Spring Boot -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <version>${spring-boot-web-version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <version>${spring-boot-test-version}</version>
            </dependency>

            <!-- Spring Security -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-oauth2</artifactId>
                <version>${spring-cloud-oauth2-version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <pluginRepositories>
        <pluginRepository>
            <id>spring-milestone</id>
            <name>Spring Milestone</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
        <pluginRepository>
            <id>spring-snapshot</id>
            <name>Spring Snapshot</name>
            <url>https://repo.spring.io/snapshot</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>

</project>

authorization pom依赖：

<?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>

    <parent>
        <groupId>com.gbx</groupId>
        <artifactId>spring-security-oauth2</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>

    <artifactId>spring-security-authorization</artifactId>
    <url>http://www.gbx.com</url>

    <licenses>
        <license>
            <name>Apache 2.0</name>
            <url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
        </license>
    </licenses>

    <dependencies>
        <!-- Spring Boot -->
        <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>
        </dependency>

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <mainClass>com.gbx.spring.security.authorization.AuthorizationApplication</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

>>   pom依赖关系：父pom依赖dependencies，子pom依赖父pom，根据依赖传递，所以dependencies可以管理pom依赖

authorization的 application.yml配置：

spring:
  application:
    name: spring-security-authorization

server:
  port: 8080

config包下添加的配置类：

package com.gbx.spring.security.authorization.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
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;

@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfiguration extends AuthorizationServerConfigurerAdapter {
    @Autowired
    private BCryptPasswordEncoder passwordEncoder;

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        //基于内存存储
        clients.inMemory()
                //client_id(请求授权码的客户端/应用id)
                .withClient("client_id")
                //client_secret(请求授权码的客户端/应用密钥)
                .secret(passwordEncoder.encode("client_secret"))
                //授权模式（分为：简单模式，授权码模式，密码模式，客户端模式）
                .authorizedGrantTypes("authorization_code")
                //客户端/应用授权范围
                .scopes("app")
                //授权码模式下通过回调地址返回授权码给gateway或者app应用
                .redirectUris("http://localhost:8080");
    }
}

package com.gbx.spring.security.authorization.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
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;

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true, jsr250Enabled = true)//全局方法拦截
public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {
    @Bean
    public BCryptPasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        //配置内存模式默认账户用以认证
        auth.inMemoryAuthentication()
                //账户名
                .withUser("admin")
                //密码（必须encode加密）
                .password(passwordEncoder().encode("123456"))
                //角色
                .roles("ADMIN")
                .and()
                .withUser("guest")
                .password(passwordEncoder().encode("123456"))
                .roles("GUEST");
    }
}

PS：用户密码和client secret必须encode加密

启动类：

package com.gbx.spring.security.authorization;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

启动应用，然后在浏览器输入（授权码获取是get方式）：

http://localhost:8080/oauth/authorize?client_id=client_id&response_type=code

回车后跳转到页面：

输入前面配置的两个账户任一信息成功后会询问用户是否授权客户端：

同意后重定向到之前设置的重定向地址并附加授权码： 

 此code即为获得的授权码，根据授权码才可以获得access_token，下一步要用到postman发送post请求（access_token获取是post方式，url格式：http://clientId:clientSecret@host:port/oauth/token）：

使用如图所示，设置参数和发送方式及格式等发送请求，成功获得access_token

yssa1125001
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
shiro如何返回token给前端_Spring Boot+OAuth2，如何自定义返回的 Token 信息？
weixin_35810012的博客
01-09 656
在本系列前面的文章中，正常情况下，OAuth2 返回的 access_token 信息一共包含五项：分别是：access_tokentoken_typerefresh_tokenexpires_inscope具体如下：{"access_token":"b9c9e345-90c9-49f5-80ab-6ce5ed5a07c9","token_type":"bearer",...
SpringSecurity & OAuth2实现短信验证码方式获取AccessToken
恒宇少年De成长之路
12-06 2061
Spring提供的原生的OAuth2依赖内置了几种比较常用的授权方式：password、authorization-code、client_credentials、refresh_token、implicit等，虽然可以满足我们日常的需求，不过针对一些特殊的需求还是捉襟见肘，有点无奈，比如：微信登录、短信登录...，针对这一点ApiBoot通过修改Spring OAuth2依赖的源码，可以根据业务...
一套解决Spring Security OAuth2授权模式扩展以及应用实战
最新发布
2401_83977696的博客
05-01 47
我还为大家准备了一套体系化的架构师学习资料包以及BAT面试资料，供大家参考及学习已经将知识体系整理好（源码，笔记，PPT，学习视频）@Override2.2 微信小程序接入微信授权模式同样是在 mall-app 的接口文件中 /api/user.js，先让我们看下小程序端如何传值？复制代码123456789101112131415161718JAVASCRIPT// 小程序授权登录params: {iv:iv,},headers: {
【OAuth2】Spring Security OAuth2 授权码模式
hkk666123的博客
05-06 1241
文章目录背景介绍扩展（1）`spring-security-oauth2`获取code的controller：（2）扩展的`userApprovalHandler`生效应用（1）获取code值（2）获取accessToken（有效期暂定72h）（3）获取refreshToken（4）访问资源（用户信息） 背景 由于业务实现中涉及到接入第三方系统（app接入有赞商城等），所以涉及到第三方系统需要获取用户信息（用户手机号、姓名等），为了保证用户信息的安全和接入方式的统一，采用Oauth2四种模式之一的授权码模式
spring security oauth2 authorization code模式
weixin_33905756的博客
12-04 145
序 前面两篇文章讲了client credentials以及password授权模式，本文就来讲一下authorization code授权码模式。 配置 security config @EnableWebSecurity @EnableGlobalMethodSecurity(prePostEnabled = true) public class SecurityConfig extends ...
springsecurity-oauth2令牌 access_token验证
clonetx的博客
06-21 4107
springsecurity oauth2 令牌access_token验证源码分析
Spring Security OAuth2 授权码模式的实现
08-18
Spring Security OAuth2 授权码模式是 OAuth 2.0 授权流程中的一种常见模式，该模式要求用户登录并对第三方应用（客户端）进行授权，出示授权码交给客户端，客户端凭授权码换取 access_token（访问凭证）。...
demo-oauth2-spring-security：带有Spring Security OAuth 2的简单密码流演示
01-30
demo-oauth2-spring-security 一个带有Spring Security OAuth 2的简单密码流演示 测验 您可以使用进行测试。 首先，您需要获取access_token 为该地址创建POST请求： 您也必须通过基本身份验证，这是客户端凭据，...
OAuth2获取token报错invalid stream header
12-14
在整合springcloud gateway、eureka、security、OAuth2的时候，采用授权码模式，用授权码去访问/oauth/token获取token时，遇到invalid stream header异常。 解决方法： 检查需要创建的OAuth2的几张表：oauth_access_...
spring security oauth2整合
07-27
Spring Security OAuth2 是一个基于 Spring Security 框架的 OAuth 2.0 授权协议实现。OAuth 2.0 是一个标准化的授权协议/框架，使得第三方应用程序可以通过协调资源所有者和 HTTP 服务之间的批准交互来代替资源...
hope-oauth:最精简的oauth2授权认证服务：认证服务，资源服务，授权码模式，数据库持久化令牌，客户端
03-24
技术栈：Spring-Boot2 Oauth2 Spring-Security 开发人员：低调小熊猫（aodeng） 使用文档 Oauth2支持的授权方式目前有5类 GRANT_TYPE 描述 授权码 授权码模式（即先登录凭证，再获取令牌）[最常用] 密码 密码模式...
springboot 整合security 实现基于内存管理资源,数据库管理token
liukangjie520的博客
08-08 420
如题security管理权限的方式有很多,这里我采用的是使用内存管理资源权限,token存放到数据库中返回前端cookie的是 remember-me信息. pom.xml 主要用的到jar. 这里不再添加数据库部分(就是很常规的用户,角色,权限 五张基本表. 要说的是如果业务需求权限和资源必须分开的话就加张资源表即可, 具体看业务. 我这里权限和资源是放到一起的. 资源主要就是控住url的,如果想拥有某个路径下的所有权限使用 (例:/user/**) 即可访问user下所有的方法). ...
springboot-oauth2-access_token验证
weixin_44401399的博客
12-02 1710
http /** * 只拦截oauth2 请求需要认证服务验证 * 类似于 http://localhost:8080/oauth2/xxx?access_token=code */ .antMatcher("/oauth2/**") .authorizeRequests() ...
SpringBoot2.0+SpringSecurity+Oauth2获取AccessToken跨域CORS访问终极解决方案
坐看云起时_雨宣
06-15 6670
今天在搭建项目的时候遇到了Oauth2获取AccessToken跨域访问的问题，之前关于这块都是自己去实现，这次打算用Oauth2来集成SpringBoot。项目依赖如下： <dependency> <groupId>org.springframework.security.oauth</groupId> <artifactId&g...
自定义spring security oauth /auth/token的返回内容格式
u013905744的专栏
09-08 1万+
场景 在前后端分离的项目中，一般后端返回给前端的格式是一个固定的json格式。 在这个前提下，spring security oauth 生成access token的请求/auth/token的返回内容就需要自定义 原返回值 我们希望使用我们自己固定的json格式 需求 我们的BaseResponse类 public class BaseResponse { pri...
Spring Cloud2.0之Oauth2环境搭建(授权码模式和密码授权模式)
热门推荐
art_code的博客
01-27 1万+
Spring Cloud2.0之Oauth2环境搭建(授权码模式和密码授权模式) oauth2 server 微服务授权中心， github源码 https://github.com/spring-cloud/spring-cloud-security 对微服务接口做一些权限控制。要给合作伙伴。 通过授权码或者通过密码方式获取accessToken，通过token去获取调用权限。...
SpringCloud-OAuth2.0-JWT 认证授权(授权码模式)
qq_42962779的博客
02-01 3137
OAuth2.0提供了四种授权模式 ,refresh_token, 是否刷新token 授权码模式 authorization_code 密码模式 password 简化模式 implicit 客户端模式 client_credentials 此案例目前完成授权码模式，其他模式还没测试，后续会完善 学习笔记，直接上代码了 创建springboot项目，引入基本的依赖，mysql，...
Java项目对jar包加密流程
weixin_33815613的博客
10-10 3235
Java 开发语言以其安全性高、代码优化、跨平台等特性，迅速取代了很多传统高级语言，占据了企业级网络应用开发等诸多领域的霸主地位。特别是近年来大数据、互联网+、云计算技术的不断发展，Java 开发语言更具有不可替代的地位。不过，Java 最突出的跨平台优势使其要以中间代码的形式运行在虚拟机环境中，因此 Java 代码反编译要比其他开发语言更容易实现，并且反编译的代码经过优化后...
Spring Security OAuth2根据授权码获取Token源码
weixin_45795312的博客
07-06 2285
OAuth2根据授权码获取Token
spring security oauth2 怎么用code 换 access_token
06-10
使用Spring Security OAuth2进行code换取access_token的步骤如下： 1.客户端向认证服务器发出授权请求，包括客户端ID、访问范围、重定向URI和response_type=code参数。 2.认证服务器对用户进行认证，如果用户认证通过，认证服务器将生成授权码(code)。 3.认证服务器将授权码(code)发送给客户端重定向URI中。 4.客户端收到授权码(code)后，使用code和client_secret向认证服务器请求access_token。 5.认证服务器验证code和client_secret，如果验证通过，将生成access_token。 6.客户端收到access_token后，即可使用该token访问受保护的资源。 示例代码如下： ``` RestTemplate restTemplate = new RestTemplate(); MultiValueMap<String, String> params= new LinkedMultiValueMap<>(); params.add("grant_type", "authorization_code"); params.add("code", code); params.add("redirect_uri", redirectUri); params.add("client_id", clientId); params.add("client_secret", clientSecret); HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED); HttpEntity<MultiValueMap<String, String>> requestEntity = new HttpEntity<>(params, headers); ResponseEntity<String> responseEntity = restTemplate.postForEntity(tokenUrl, requestEntity, String.class); ``` 其中，code是授权码，redirectUri是客户端重定向URI，clientId和clientSecret是客户端ID和密钥，tokenUrl是认证服务器的地址。授权服务器将返回一个JSON格式的字符串，其中包含access_token等信息。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值