oauth2.0系统学习-spring sercurity+oauth2.0+JWT 单点登陆设计

最新推荐文章于 2024-03-30 22:00:00 发布
最新推荐文章于 2024-03-30 22:00:00 发布
阅读量241 收藏
点赞数
分类专栏： oauth2.0 文章标签： spring spring boot java
原文链接：https://blog.csdn.net/zhou920786312/article/details/109443177
版权

oauth2.0系统学习-spring sercurity+oauth2.0+JWT 单点登陆设计

一、spring sercurity+oauth2.0+JWT 单点登陆设计

  1. 认证服务器和资源服务器在同一台机器（网关）
  2. 密码授权模式
    1. 去掉客户端信息表
    2. 去掉用户授权表

在这里插入图片描述

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 https://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.5.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>oauth-learn2</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>oauth-learn2</name>

    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

        <!--security    end-->

        <!--数据库依赖    begin-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!--数据库依赖    end-->


        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-jwt</artifactId>
            <version>1.0.10.RELEASE</version>
        </dependency>


        <dependency>
            <groupId>org.springframework.security.oauth.boot</groupId>
            <artifactId>spring-security-oauth2-autoconfigure</artifactId>
            <version>2.3.4.RELEASE</version>
        </dependency>


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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

application.properties

spring.application.name=oauth-authorizationServer
server.port=8083

spring.datasource.url = jdbc:mysql://localhost:3306/testoauth?useUnicode=true
spring.datasource.username=root
spring.datasource.password=ylx123
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

spring.main.allow-bean-definition-overriding=true

UserBean

package com.example.oauthlearn2.bean;

import lombok.Data;

/**
 * @Description 请描述下该类是做什么的
 * @Author <a href="mailto:yuanlx@smartdot.com.cn">袁凌霄</a>
 * @Date 2021/9/25  11:13
 * @Verson 1.0
 **/

@Data
public class UserBean {
    private Long id;
    private String userName;
    private String password;

}

AuthorizationServer

package com.example.oauthlearn2.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.ClientDetailsService;
import org.springframework.security.oauth2.provider.code.AuthorizationCodeServices;
import org.springframework.security.oauth2.provider.code.InMemoryAuthorizationCodeServices;
import org.springframework.security.oauth2.provider.token.AuthorizationServerTokenServices;
import org.springframework.security.oauth2.provider.token.DefaultTokenServices;
import org.springframework.security.oauth2.provider.token.TokenEnhancerChain;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;

import java.util.Arrays;

/**
 * @Description 请描述下该类是做什么的
 * @Author <a href="mailto:yuanlx@smartdot.com.cn">袁凌霄</a>
 * @Date 2021/9/25  11:14
 * @Verson 1.0
 **/

@Configuration
@EnableAuthorizationServer // 配置授权服务。
public class AuthorizationServer extends AuthorizationServerConfigurerAdapter {


    @Autowired
    private JwtAccessTokenConverter accessTokenConverter;
    @Autowired
    // 授权码服务
    private AuthorizationCodeServices authorizationCodeServices;
    @Autowired
    // 认证管理
    private AuthenticationManager authenticationManager;
    @Autowired
    // 令牌管理服务
    private AuthorizationServerTokenServices authorizationServerTokenServices;

    @Autowired
    // 令牌存储策略
    private TokenStore tokenStore;
    @Autowired
    // 客户端详情服务,也就是configure(ClientDetailsServiceConfigurer clients)方法
    private ClientDetailsService clientDetailsService;

    @Autowired
    // 加密方式
    private PasswordEncoder passwordEncoder;

    // 用来配置客户端详情服务
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        // 这里是第三方合作用户的客户id，秘钥的配置
        // 使用in-memory存储
        clients.inMemory()
                // client_id，用户账号
                .withClient(OauthCanstant.clientId)
                // 客户端密钥
                .secret(new BCryptPasswordEncoder().encode(OauthCanstant.secret))
                // 资源列表，资源标识
                .resourceIds(OauthCanstant.resourceIds)
                // 授权类型（4种）
                .authorizedGrantTypes(OauthCanstant.authorizedGrantTypes)
                // 客戶端允许的授权范围
                .scopes(OauthCanstant.scopes)
                // false跳转到授权页面，让用户点击授权，如果是true,相当于自动点击授权，就不跳转授权页面
                .autoApprove(OauthCanstant.autoApprove)//
                // 加上验证回调地址，返回授权码信息
                .redirectUris(OauthCanstant.redirectUris);
    }

    // 令牌管理服务
    @Bean
    public AuthorizationServerTokenServices authorizationServerTokenServices() {
        DefaultTokenServices service = new DefaultTokenServices();
        service.setClientDetailsService(clientDetailsService);
        service.setSupportRefreshToken(true);// 支持刷新
        service.setTokenStore(tokenStore);// 令牌存储

        // 令牌增强
        TokenEnhancerChain tokenEnhancerChain = new TokenEnhancerChain();
        tokenEnhancerChain.setTokenEnhancers(Arrays.asList(accessTokenConverter));
        service.setTokenEnhancer(tokenEnhancerChain);

        service.setAccessTokenValiditySeconds(OauthCanstant.accessTokenValiditySeconds); // 令牌默认有效期2小时
        service.setRefreshTokenValiditySeconds(OauthCanstant.refreshTokenValiditySeconds); // 刷新令牌默认有效期3天
        return service;
    }

    @Override
    // 用来配置令牌（token）的访问端点
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) {
        endpoints
                // 指定认证管理器
                .authenticationManager(authenticationManager)
                // 授权码模式需要
                .authorizationCodeServices(authorizationCodeServices)
                // 令牌管理服务
                .tokenServices(authorizationServerTokenServices)
                // jwt格式Token
                .accessTokenConverter(accessTokenConverter)
                // 允许post提交
                .allowedTokenEndpointRequestMethods(HttpMethod.POST);
    }

    @Bean
    // 授权码服务器
    public AuthorizationCodeServices authorizationCodeServices() {
        // 授权码模式的授权码采用内存方式存储
        return new InMemoryAuthorizationCodeServices();
    }
    @Override
    // 用来配置令牌端点的安全约束,拦截规则
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {

        security
                // 提供公有密匙的端点，如果你使用JWT令牌的话, 允许
                .tokenKeyAccess(OauthCanstant.permitAll)
                // oauth/check_token：用于资源服务访问的令牌解析端点，允许
                .checkTokenAccess(OauthCanstant.permitAll)
                // 表单认证,申请令牌
                .allowFormAuthenticationForClients();
    }

}

OauthCanstant

package com.example.oauthlearn2.config;

/**
 * @Description 请描述下该类是做什么的
 * @Author <a href="mailto:yuanlx@smartdot.com.cn">袁凌霄</a>
 * @Date 2021/9/25  11:15
 * @Verson 1.0
 **/

public interface OauthCanstant {
    String clientId = "c1";
    String secret = "secret";
    String resourceIds = "res1";
    String authorizedGrantTypes = "password";
    String scopes = "all";
    boolean autoApprove = false;
    String redirectUris = "http://www.baidu.com";
    String permitAll = "permitAll()";
    // 令牌默认有效期2小时
    int accessTokenValiditySeconds = 7200;
    // 刷新令牌默认有效期3天
    int refreshTokenValiditySeconds = 259200;

    // 对称秘钥，资源服务器使用该秘钥来验证
    String SIGNING_KEY = "uaa123";

}

ResouceServerConfig

package com.example.oauthlearn2.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
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;
import org.springframework.security.oauth2.provider.token.TokenStore;

/**
 * @Description 请描述下该类是做什么的
 * @Author <a href="mailto:yuanlx@smartdot.com.cn">袁凌霄</a>
 * @Date 2021/9/25  11:15
 * @Verson 1.0
 **/

@Configuration
@EnableResourceServer
public class ResouceServerConfig extends ResourceServerConfigurerAdapter {

    @Autowired
    // 令牌存储策略
    private TokenStore tokenStore;



    @Override
    public void configure(ResourceServerSecurityConfigurer resources) {
        resources
                // 资源 id
                .resourceId(OauthCanstant.resourceIds)
                //                // 令牌服务
                .tokenStore(tokenStore)
                .stateless(true);
    }

    @Override
    public void configure(HttpSecurity http) throws Exception {

        http

                .authorizeRequests().antMatchers("/**")
                // 所有的访问,授权访问都要是all,和认证服务器的授权范围一一对应
                .access("#oauth2.hasScope('"+OauthCanstant.scopes+"')")
                //去掉防跨域攻击
                .and().csrf().disable()
                //session管理
                .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    }


}

TokenConfig

package com.example.oauthlearn2.config;

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

/**
 * @Description 请描述下该类是做什么的
 * @Author <a href="mailto:yuanlx@smartdot.com.cn">袁凌霄</a>
 * @Date 2021/9/25  11:16
 * @Verson 1.0
 **/

@Configuration
public class TokenConfig {


    @Bean
    public TokenStore tokenStore() {
        // JWT令牌存储方案
        return new JwtTokenStore(accessTokenConverter());
    }

    @Bean
    public JwtAccessTokenConverter accessTokenConverter() {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        converter.setSigningKey(OauthCanstant.SIGNING_KEY); // 对称秘钥，资源服务器使用该秘钥来验证
        return converter;
    }

}

WebSecurityConfig

package com.example.oauthlearn2.config;

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

/**
 * @Description 请描述下该类是做什么的
 * @Author <a href="mailto:yuanlx@smartdot.com.cn">袁凌霄</a>
 * @Date 2021/9/25  11:16
 * @Verson 1.0
 **/

@Configuration
// @EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    // 认证管理器
    @Override
    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    // 密码编码器
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    // 安全拦截机制
    @Override
    protected void configure(HttpSecurity http) throws Exception {

        http.authorizeRequests().anyRequest().authenticated()// 所有其他请求必须认证通过
                .and().formLogin().loginPage("/login").successForwardUrl("/login-success")// 自定义登录成功的页面地址
                .permitAll().and().logout().permitAll().and()// 会话管理
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.IF_REQUIRED);// 会话管理

    }
}

LoginController

package com.example.oauthlearn2.controller;

import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Description 请描述下该类是做什么的
 * @Author <a href="mailto:yuanlx@smartdot.com.cn">袁凌霄</a>
 * @Date 2021/9/25  11:17
 * @Verson 1.0
 **/

@RestController
public class LoginController {

    @RequestMapping(value = "/login-success")
    public String loginSuccess() {
        return getUsername() + " login-success 登录成功";
    }

    /**
     * 测试资源1
     *
     * @return
     */
    @GetMapping(value = "/admin/p1")
    // @PreAuthorize("hasAuthority('p1')")//拥有p1权限才可以访问
    public String r1() {
        return " /admin/p1 " + getUsername() + "访问资源1";
    }

    /**
     * 测试资源2
     *
     * @return
     */
    @GetMapping(value = "/user/p2")
    // @PreAuthorize("hasAuthority('p2')")//拥有p2权限才可以访问
    public String r2() {
        return "/user/p2 " + getUsername() + "访问资源2";
    }

    // 获取当前用户信息
    private String getUsername() {
        String username = null;
        // 当前认证通过的用户身份
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        // 用户身份
        Object principal = authentication.getPrincipal();
        if (principal == null) {
            username = "匿名";
        }
        if (principal instanceof UserDetails) {
            UserDetails userDetails = (UserDetails) principal;
            username = userDetails.getUsername();
        } else {
            username = principal.toString();
        }
        return username;
    }
}

UserDao

package com.example.oauthlearn2.dao;

import com.example.oauthlearn2.bean.UserBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * @Description 请描述下该类是做什么的
 * @Author <a href="mailto:yuanlx@smartdot.com.cn">袁凌霄</a>
 * @Date 2021/9/25  11:17
 * @Verson 1.0
 **/

@Repository
public class UserDao {
    @Autowired
    JdbcTemplate jdbcTemplate;

    // 根据账号查询用户信息
    public UserBean getUserByUsername(String username) {
        String sql = "select * from user where user_name = ?";
        // 连接数据库查询用户
        List<UserBean> list = jdbcTemplate.query(sql, new Object[] { username },
                new BeanPropertyRowMapper<>(UserBean.class));
        if (list != null && list.size() == 1) {
            return list.get(0);
        }
        return null;
    }

}

SpringDataUserDetailsService

package com.example.oauthlearn2.service;

import com.example.oauthlearn2.bean.UserBean;
import com.example.oauthlearn2.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
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;

/**
 * @Description 请描述下该类是做什么的
 * @Author <a href="mailto:yuanlx@smartdot.com.cn">袁凌霄</a>
 * @Date 2021/9/25  11:18
 * @Verson 1.0
 **/

@Service
public class SpringDataUserDetailsService implements UserDetailsService {

    @Autowired
    UserDao userDao;

    // 根据账号查询用户信息,
    // 通过@Service将SpringDataUserDetailsService注入容器，通过UserDetailsService接口表明该类的类型是UserDetailsService
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {

        // 将来连接数据库根据账号查询用户信息
        UserBean bean = userDao.getUserByUsername(username);
        if (bean == null) {
            // 如果用户查不到，返回null，由provider来抛出异常
            return null;
        }


        // 添加p1权限,权限是随便加的，这里已经没有意义了
        UserDetails userDetails = User.withUsername(bean.getUserName()).password(bean.getPassword()).authorities("p1")
                .build();
        return userDetails;
    }
}

测试

获取admin的token

http://localhost:8083/oauth/token?client_id=c1&client_secret=secret&grant_type=password&username=admin&password=admin

在这里插入图片描述

admin请求可以访问的资源：

http://localhost:8083/admin/p1

头部信息中添加 Authorization，值为：“Bearer ” + token

在这里插入图片描述

ylx814056815
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jwt实现oauth2.0 java_基于JWT实现SSO单点登录流程图解
weixin_39908070的博客
02-17 392
一、基于JWT实现SSO单点登录原理1、什么是单点登录所谓单点登录就是有多个应用部署在不同的服务器上，只需登录一次就可以互相访问不同服务器上的资源。2、单点登录流程当一个访问请求发给应用A，如果这个请求需要登录以后才能访问，那么应用A就会向认证服务器请求授权，这时候就把用户引导到认证服务器上。用户在认证服务器上完成认证并授权。认证授权完成后，认证服务器返回给应用A一个授权码，应用A携带授权码到认证...
验证服务：Spring Security + OAuth2.0 + JWT
02-21
更改日志2018.9.1版本升到2.0-SNAPSHOT ，要使用sb1.5.x版本，请切换到TAG 1.0-RELEASE Spring Cloud Security升级到Finchley.RELEASE ，Spring Boot由1.5.X升级到2.0.X。 < dependency> < groupId>org.spring...
Oauth2.0 + JWT 实现单点登录
m0_37122623的博客
02-25 3502
上一节，我们讲述了Oauth2.0 配合security的使用，配合redis去存token，或者配合Jwt去存token。这篇文章，我们主要来系统的串起来讲一下，从宏观的层面来讲述一下单点登录，并且来实现一个demo。 首先，我们来借助一个真实的案例来切入： 相信大家都登录过码云吧：（https://gitee.com/） 在登录选项里我们选择使用三方账号进行登录（QQ） 然后他就会跳转到下面这个地址： https://graph.qq.com/oauth2.0/show?which=Login&amp
OAuth2.0 实现单点登录（四种授权方式）
最新发布
qq_52066082的博客
03-30 1608
OAuth2.0 实现单点登录（四种授权方式）
OAuth2与JWT（单点登录）
qq_42296117的博客
07-29 1609
什么是单点登录？ 现在的应用几乎都是分布式，实现一方遍登录，分布的模块都不需要在进行登录授权 比如你在百度贴吧上登录了你的百度账号，在进入到贴吧的网页版，此时你是不需要重新登录就可以访问贴吧模块 那么单点登录的实现？ 1:使用session广播：将存入sesion的信息分发到各分布的模块中，进行复制。这种方式的话在如今局限比较大，在并发小的时候是可以用。因为这种方式限制了横向session的扩张，每个模块中的session都是所有模块的session信息 2:使用redis+cookie实现：使用re
SpringSecurity+OAuth2.0+JWT实现单点登录应用
玩转Java
12-12 3105
oauth
Oauth2和Jwt两种单点登录方式
喝醉酒的小白
08-05 496
是一种授权框架，用于允许应用程序访问受保护的资源，而无需直接使用用户的凭据。在OAuth 2.0中，有三个主要的角色：资源所有者（用户）、客户端（应用程序）和授权服务器。OAuth 2.0使用令牌作为对资源的访问凭证，这些令牌通常具有有限的生命周期，并且可以在过期后进行刷新。这样一来，应用程序无需保存用户的凭据，而是利用令牌进行安全的资源访问。是一种开放标准（RFC 7519），定义了一种紧凑且自包含的方式来传输信息的格式。两者可以结合使用，以实现基于令牌的单点登录方案。
springsecurity+oauth2+jwt实现单点登录demo
06-06
该资源是springsecurity+oauth2+jwt实现的单点登录demo，模式为授权码模式，实现自定义登录页面和自定义授权页面。应用数据存在内存中或者存在数据库中（附带数据库表结构），token存储分为数据库或者Redis。demo...
Spring Security Oauth2.0 实现短信验证码登录示例
08-28
本篇文章主要介绍了Spring Security Oauth2.0 实现短信验证码登录示例，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
基于springcloud+security+oauth2.0实现的权限管理系统.zip
10-08
基于springcloud+security+oauth2.0实现的权限管理系统.zip
spring security 基于oauth 2.0 实现 sso 单点登录Demo.zip
06-12
spring security 基于oauth 2.0 实现 sso 单点登录Demo 使用 spring security 基于oauth 2.0 实现 sso 单点登录Demo spring boot + spring security + spring security oauth
基于JWT OAUTH2 SpringSecurity单点登录
01-30
基于JWT OAUTH2 SpringSecurity单点登录 . 单点登录流: 1. 访问client1 2. `client1`将请求导向`sso-server` 3. 同意授权 4. 携带授权码`code`返回`client1` 5. `client1`拿着授权码请求令牌 6. 返回`JWT`令牌 7. `client1`解析令牌并登录 8. `client1`访问`client2` 9. `client2`将请求导向`sso-server` 10. 同意授权 11. 携带授权码`code`返回`client2` 12. `client2`拿着授权码请求令牌 13. 返回`JWT`令牌 14. `client2`解析令牌并登录
Spring cloud入门-OAuth 2.0(四)授权之基于JWT完成单点登录
weixin_42324034的博客
11-02 1282
授权之基于JWT完成单点登录摘要单点登录简介创建oauth2-client网页单点服务验证服务调用验证 摘要 Spring Cloud Security 为构建安全的SpringBoot应用提供了一系列解决方案，结合Oauth2可以实现单点登录功能，本文将对其单点登录用法进行详细介绍。 单点登录简介 单点登录简称SSO，只的是当有多个系统需要登录时，用户只需要登录一个系统就无须登录其他的系统 创建oauth2-client 这里新建一个oauth2-client作为客服端，使用oauth2-jwt-ser
OAuth2.0 实现单点登录
热门推荐
qq15035899256的博客
03-17 2万+
本文是对OAuth2.0的学习，了解了它的4种授权方式，学会了如何搭建验证服务器，使用 postman对四种模式作了接口测试。并且学会了资源服务器实现单点登录的两种方式，也成功解决了远程调用时没有携带 token 的问题。最后也学会了使用 JWT 存储 Token，大大提高了安全性。
Spring Security + OAuth2 + JWT 基本使用
weixin_45032957的博客
05-20 455
1.3、授权模式 oauth2根据使用场景不同，分成了4种模式 授权码模式（authorization code） 简化模式（implicit） 密码模式（resource owner password credentials） 客户端模式（client credentials） 授权码模式使用到了回调地址，是最为复杂的方式，通常网站中经常出现的微博，qq第三方登录，都会采用这个形式。简化模式不常用。 2、配置 使用oauth2保护你的应用，可以分为简易的分为三个步骤 配置资源服务器 配置授权服务器 配置s
OAuth2.0二 JWT以及Oauth2实现SSO
东风麦芽糖
09-02 383
一 JWT 1.1 什么是JWT JSON Web Token（JWT）是一个开放的行业标准（RFC 7519），它定义了一种简介的、自包含的协议格式，用于在通信双方传递json对象，传递的信息经过数字签名可以被验证和信任。JWT可以使用HMAC算法或使用RSA的公钥/私钥对来签名，防止被篡改。 官网： https://jwt.io/ 标准： https://tools.ietf.org/html/rfc7519 JWT令牌的优点： jwt基于json，非常方便解析。 可以在令牌中自定义丰富的内容，易扩展
微服务授权 springsecurity+auth2基本入门
银魄清辉自夜凝的博客
07-08 2927
微服务登录问题： 解决方式： 我们使用客户端Token+oauth2+jwt+springsecurity oauth2：简易，开放，安全，不接触账号密码 oauth2四种模式： 授权码模式 简化模式：没有授权码，直接token，安全性降低 密码模式：一般在自己系统中用（不接触三方） 客户端模式：不要用户名密码，直接返回token，在自己的服务器中使用，比如认证服务访问资源模式，你来访问我就直接返回token 实现 建立几个微服务 1导包 2搭建eureka，配置yml 注册
SpringSecurity+Jwt+Autho2整合(一)
https://juejin.cn/user/4248168663101239/posts
08-08 1094
SpringSecurity+JWT+Autho2整合一. SpringSecurity简介二. SpringSecurity快速入门①. 导入依赖②. 登录页面③. 访问页面④. UserDetailsService详解⑤. UserDetails详解⑥. PasswordEncoder 密码解析器详解⑦. 自定义登录逻辑_修改配置类1. 登录页面配置2. 失败跳转3. 添加控制器的方法4. 设置请求账户和密码的参数名5. 自定义登录成功处理器6. 自定义登录失败处理器7. 访问控制url匹配8. 内置访
前后端分离oauth2.0 - springsecurity + spring-authorization-server 密码模式
07-11
Spring Authorization Server是Spring Security中用于实现授权服务器的模块，它支持OAuth 2.0的各种授权模式。 密码模式是OAuth 2.0中的一种授权模式，它允许用户通过提交用户名和密码来获取访问令牌，然后使用该...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值