Spring Security Oauth2 JWT

已于 2023-03-26 21:01:57 修改
阅读量250 收藏 2
点赞数
分类专栏： Oauth2   Security  文章标签： spring Powered by 金山文档
于 2023-03-11 12:07:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73282829/article/details/129387944
版权

1.添加授权模块所需依赖

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-data</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-oauth2</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.security.oauth.boot</groupId>
                    <artifactId>spring-security-oauth2-autoconfigure</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.springframework.security.oauth.boot</groupId>
            <artifactId>spring-security-oauth2-autoconfigure</artifactId>
            <version>2.1.3.RELEASE</version>
        </dependency>
      <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <dependency>
            <groupId>你的项目结构如:com.demo</groupId>
            <artifactId>依赖自己的实体类模块如:home_user_api</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>
</dependencies>

2.application.yml配置文件配置

server:
  port: 9200  #运行端口
spring:
  application:
    name: user-auth
  datasource:
    driver-class-name: com.mysql.jdbc.Driver   #mysql数据库
    url: jdbc:mysql://127.0.0.1:3306/数控库名?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowMultiQueries=true&serverTimezone=UTC  #数据库库名
    username: root  #数据库用户名
    password: ok    #数据库密码
  main:
    allow-bean-definition-overriding: true
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848  #nacos注册中心配置
auth:
  ttl: 3600  #token存储到redis的过期时间
  clientId: accp   #注1
  clientSecret: accp #注1
  cookieDomain: localhost
  cookieMaxAge: -1
encrypt:
  key-store:
    location: classpath:/wfshop.jks #注2
    secret: wfshop 
    alias: wfshop 
    password: wfshop

注1解:两个accp数据库中授权用户列表下的 关于资源模块传向授权模块的授权名与密码

从数据库中获取授权用户信息

注2解:wfshop.jks是放于授权模块resources文件夹下的秘钥文件的详细名称如

3.启动类

package com.zb;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;


@SpringBootApplication //spring boot启动注解
@EnableDiscoveryClient //spring cloud微服务注册中心
@EnableFeignClients //注解告诉框架扫描所有使用注解@FeignClient定义的feign客户端
public class OAuthApplication {

    public static void main(String[] args) {

        SpringApplication.run(OAuthApplication.class,args);
    }


    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

}

4.添加4个配置类与2个工具类

工具类

4.1添加工具类UserJwt继承User类
package com.zb.oauth.util;


import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.User;

import java.util.Collection;


public class    UserJwt extends User {
    private String id;    //用户ID
    private String name;  //用户名字

    private String comny;//设置公司

    public UserJwt(String username, String password, Collection<? extends GrantedAuthority> authorities) {
        super(username, password, authorities);
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

ps.此类中的元素如id,name为需要向token里封装的数据可自行更改

4.2添加AuthToken工具类
package com.zb.oauth.util;

import java.io.Serializable;


public class AuthToken implements Serializable{

    //令牌信息
    String accessToken;
    //刷新token(refresh_token)
    String refreshToken;
    //jwt短令牌
    String jti;

    public String getAccessToken() {
        return accessToken;
    }

    public void setAccessToken(String accessToken) {
        this.accessToken = accessToken;
    }

    public String getRefreshToken() {
        return refreshToken;
    }

    public void setRefreshToken(String refreshToken) {
        this.refreshToken = refreshToken;
    }

    public String getJti() {
        return jti;
    }

    public void setJti(String jti) {
        this.jti = jti;
    }
}

添加配置类文件

4.1 添加配置类AuthorizationServerConfig
package com.zb.oauth.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.bootstrap.encrypt.KeyProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.core.userdetails.UserDetailsService;
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;
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.DefaultAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;
import org.springframework.security.oauth2.provider.token.store.KeyStoreKeyFactory;

import javax.annotation.Resource;
import javax.sql.DataSource;
import java.security.KeyPair;


@Configuration
@EnableAuthorizationServer
class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
    //数据源，用于从数据库获取数据进行认证操作，测试可以从内存中获取
    @Autowired
    private DataSource dataSource;
    //jwt令牌转换器
    @Autowired
    private JwtAccessTokenConverter jwtAccessTokenConverter;
    //SpringSecurity 用户自定义授权认证类
    @Autowired
    UserDetailsService userDetailsService;
    //授权认证管理器
    @Autowired
    AuthenticationManager authenticationManager;
    //令牌持久化存储接口
    @Autowired
    TokenStore tokenStore;
    @Autowired
    private CustomUserAuthenticationConverter customUserAuthenticationConverter;

    /***
     * 客户端信息配置
     * @param clients
     * @throws Exception
     */
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
/**修改客户端加载源
修改oaut-server的com.zb.oauth.config.AuthorizationServerConfig类的configure方法，将之前静态的客户端数据变成从数据库加载*/

        clients.jdbc(dataSource).clients(this.clientDetails());//数据库加载

/**静态加载如下
        clients.inMemory()
                .withClient("changgou")          //客户端id
                .secret("changgou")                      //秘钥
                .redirectUris("http://localhost")       //重定向地址
                .accessTokenValiditySeconds(3600)          //访问令牌有效期
                .refreshTokenValiditySeconds(3600)         //刷新令牌有效期
                .authorizedGrantTypes(
                        "authorization_code",          //根据授权码生成令牌
                        "client_credentials",          //客户端认证
                        "refresh_token",                //刷新令牌
                        "password")                     //密码方式认证
                .scopes("app");                         //客户端范围，名称自定义，必填*/
    }

    /***
     * 授权服务器端点配置
     * @param endpoints
     * @throws Exception
     */
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.accessTokenConverter(jwtAccessTokenConverter)
                .authenticationManager(authenticationManager)//认证管理器
                .tokenStore(tokenStore)                       //令牌存储
                .userDetailsService(userDetailsService);     //用户信息service
    }

    /***
     * 授权服务器的安全配置
     * @param oauthServer
     * @throws Exception
     */
    @Override
    public void configure(AuthorizationServerSecurityConfigurer oauthServer) throws Exception {
        oauthServer.allowFormAuthenticationForClients()
                .passwordEncoder(new BCryptPasswordEncoder())
                .tokenKeyAccess("permitAll()")
                .checkTokenAccess("isAuthenticated()");
    }


    //读取密钥的配置
    @Bean("keyProp")
    public KeyProperties keyProperties() {
        return new KeyProperties();
    }

    @Resource(name = "keyProp")
    private KeyProperties keyProperties;

    //客户端配置
    @Bean
    public ClientDetailsService clientDetails() {
        return new JdbcClientDetailsService(dataSource);
    }

    @Bean
    @Autowired
    public TokenStore tokenStore(JwtAccessTokenConverter jwtAccessTokenConverter) {
        return new JwtTokenStore(jwtAccessTokenConverter);
    }

    /****
     * JWT令牌转换器
     * @param customUserAuthenticationConverter
     * @return
     */
    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter(CustomUserAuthenticationConverter customUserAuthenticationConverter) {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        KeyPair keyPair = new KeyStoreKeyFactory(
                keyProperties.getKeyStore().getLocation(),                          //证书路径 wfshop.jks
                keyProperties.getKeyStore().getSecret().toCharArray())             
                .getKeyPair(
                        keyProperties.getKeyStore().getAlias(),                     //证书别名 wfshop
                        keyProperties.getKeyStore().getPassword().toCharArray());   //证书密码 wfshop
        converter.setKeyPair(keyPair);
        //配置自定义的CustomUserAuthenticationConverter
        DefaultAccessTokenConverter accessTokenConverter = (DefaultAccessTokenConverter) converter.getAccessTokenConverter();
        accessTokenConverter.setUserTokenConverter(customUserAuthenticationConverter);
        return converter;
    }
}
4.2添加配置类CustomUserAuthenticationConverter文件
package com.zb.oauth.config;

import com.zb.oauth.util.UserJwt;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.oauth2.provider.token.DefaultUserAuthenticationConverter;
import org.springframework.stereotype.Component;

import java.util.LinkedHashMap;
import java.util.Map;

@Component
public class CustomUserAuthenticationConverter extends DefaultUserAuthenticationConverter {

    @Autowired
    UserDetailsService userDetailsService;

    @Override
    public Map<String, ?> convertUserAuthentication(Authentication authentication) {
        LinkedHashMap response = new LinkedHashMap();
        String name = authentication.getName();
        response.put("username", name);

        Object principal = authentication.getPrincipal();
        UserJwt userJwt = null;
        if(principal instanceof  UserJwt){
            userJwt = (UserJwt) principal;
        }else{
            //refresh_token默认不去调用userdetailService获取用户信息，这里我们手动去调用，得到 UserJwt
            UserDetails userDetails = userDetailsService.loadUserByUsername(name);
            userJwt = (UserJwt) userDetails;
        }
        response.put("name", userJwt.getName());
        response.put("id", userJwt.getId());
        //公司 response.put("compy", "songsi");
        if (authentication.getAuthorities() != null && !authentication.getAuthorities().isEmpty()) {
            response.put("authorities", AuthorityUtils.authorityListToSet(authentication.getAuthorities()));
        }
        return response;
    }

}

此处:

response.put("name", userJwt.getName());

response.put("id", userJwt.getId());

对应于UserJwt类中自己定义的元素,其为token加密的信息

4.3添加UserDetailsServiceImpl配置实现类
package com.zb.oauth.config;

import com.zb.client.TbUserFeignClient;
import com.zb.dto.UserDto;
import com.zb.oauth.util.UserJwt;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.context.SecurityContextHolder;
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.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.oauth2.provider.ClientDetails;
import org.springframework.security.oauth2.provider.ClientDetailsService;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;

/*****
 * 自定义授权认证类
 */
@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    ClientDetailsService clientDetailsService;


    @Autowired
    private TbUserFeignClient userFeignClient;

    /****
     * 自定义授权认证
     * @param username
     * @return
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //取出身份，如果身份为空说明没有认证
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        //没有认证统一采用httpbasic认证，httpbasic中存储了client_id和client_secret，开始认证client_id和client_secret
        if (authentication == null) {
            ClientDetails clientDetails = clientDetailsService.loadClientByClientId(username);
            if (clientDetails != null) {
                //秘钥
                String clientSecret = clientDetails.getClientSecret();
                //静态方式
//                return new User(username,new BCryptPasswordEncoder().encode(clientSecret), AuthorityUtils.commaSeparatedStringToAuthorityList(""));
                //数据库查找方式
                return new User(username, clientSecret, AuthorityUtils.commaSeparatedStringToAuthorityList(""));
            }
        }

        if (StringUtils.isEmpty(username)) {
            return null;
        }
            
      ;

        if (ObjectUtils.isEmpty( userFeignClient.info(username))) {
            return null;
        }

      //调用用户模块中的方法获取用户对象再get用户密码
        String pwd =  userFeignClient.info(username).getPassword();
        //创建User对象

        //用户权力
//这里是写死了也可以根据数据库自定义
        String permissions = "goods_list,seckill_list";

//将用户名,用户密码,和分隔后的权限集合封装
        UserJwt userDetails = new UserJwt(username, pwd, AuthorityUtils.commaSeparatedStringToAuthorityList(permissions));


        return userDetails;
    }
}

*TbUserFeignClient 是Feign封装的用户服务器旗下的info方法的作用是根据用户名查询用户表中对应的用户信息

4.4添加WebSecurityConfig配置文件
package com.zb.oauth.config;

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

@Configuration
@EnableWebSecurity
@Order(-1)
class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    /***
     * 忽略安全拦截的URL
     * @param web
     * @throws Exception
     */
    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers(
                "/my-auth/login/**",//放行的控制器下的方法
                "/user/logout");
    }

    /***
     * 创建授权管理认证对象
     * @return
     * @throws Exception
     */
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        AuthenticationManager manager = super.authenticationManagerBean();
        return manager;
    }

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

    /***
     * 采用BCryptPasswordEncoder对密码进行编码
     * @return
     */
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    /****
     *
     * @param http
     * @throws Exception
     */
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .httpBasic()        //启用Http基本身份验证
                .and()
                .formLogin()       //启用表单身份验证
                .and()
                .authorizeRequests()    //限制基于Request请求访问
                .anyRequest()
                .authenticated();       //其他请求都需要经过验证

    }
}

5.编写service层

1创建AuthService接口和AuthService的实现类AuthServiceImpl

2引入类RestTemplate 和DiscoveryClient

3调用

3从注册中心获取自己服务器本身然后设置登录模式与授权信息

4提交授权信息并获取返回内容

5将返回的token信息封装进authToken后返回值

package com.zb.oauth.service.impl;
import com.zb.oauth.service.AuthService;
import com.zb.oauth.util.AuthToken;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.stereotype.Service;
import org.springframework.util.Base64Utils;
import org.springframework.web.client.RestTemplate;


@Service
public class AuthServiceImpl implements AuthService {

    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private DiscoveryClient discoveryClient;

@Override
    public AuthToken login(String username, String passwd, String clientId, String clientSecret) {

    List<ServiceInstance> instances=discoveryClient.getInstances("user-auth");
    ServiceInstance serviceInstance = instances.get(0);
    String url="http://" + serviceInstance.getHost() + ":" + serviceInstance.getPort() + "/oauth/token";
    System.out.println("============>"+url);
    LinkedMultiValueMap<String ,String > body=new LinkedMultiValueMap<>();
    body.add("grant_type", "password");
    body.add("username", username);
    body.add("password", passwd);
    LinkedMultiValueMap<String, String> header = new LinkedMultiValueMap<String, String>();
    header.add("Authorization", myEncoder(clientId, clientSecret));
    ResponseEntity<Map> response= restTemplate.exchange(url, HttpMethod.POST,new HttpEntity<>(body, header), Map.class);

    Map map = response.getBody();
    System.out.println(map);
    AuthToken authToken = new AuthToken();
    authToken.setAccessToken(map.get("access_token").toString());
    authToken.setJti(map.get("jti").toString());
    authToken.setRefreshToken(map.get("refresh_token").toString());
    return authToken;
   
    }

    public String myEncoder(String clientId,String clientSecret){
    String str=clientId+":"+clientSecret;
        byte[] encode = Base64Utils.encode(str.getBytes());
        return "Basic "+new String(encode);
    }
}

6.编写controller控制器

控制器调用service层向内传入用户名,用户密码,授权名,授权码

史山搬运工
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用spring-security-oauth2和spring-security-oauth2-autoconfigure依赖来实现OAuth 2.0+JWT，及介绍迁移到更现代的解决方案
Ead_Y的博客
03-18 1163
关于早些时候的Spring Security版本中，可以使用和依赖来实现OAuth 2.0。然而，随着新版本的发布，Spring Security 5 引入了新的OAuth2客户端和资源服务器支持，而且Spring Security团队已经推出了一个新的项目Spring Authorization Server来替代作为授权服务器。本文为复现通过和实现OAuth 2.0及介绍迁移到更现代的解决方案。通常将一个项目配置成资源服务器以保护资源，另一个项目配置成授权服务器以发放令牌。
Spring Security 学习笔记（六）--OAuth2.0
SuperArc1999的博客
01-08 1770
6.1OAuth2.0介绍 OAuth（开放授权）是一个开放标准，允许用户授权第三方应用访问他们存储在另外的服务提供者上的信息。而不需要将用户名和密码提供给第三方应用或分享他们数据的所有内容。OAuth2.0是OAuth协议的延续版本，但不向后兼容OAuth1.0。即完全废止了OAuth1.0。很多大公司如Google，Yahoo，Microsoft等都提供了OAuth认证服务，这些足以证明OAuth标准逐渐成为开放资源授权的标准。 OAuth2.0已被广泛应用。 下面是OAuth2.0的认证流程
芋道 Spring Security OAuth2 入门
竹林幽深
03-24 3322
芋道 Spring Security OAuth2 入门 总阅读量:28123次 《Dubbo 实现原理与源码解析 —— 精品合集》 《Netty 实现原理与源码解析 —— 精品合集》 《Spring 实现原理与源码解析 —— 精品合集》 《MyBatis 实现原理与源码解析 —— 精品合集》 《Spring MVC 实现原理与源码解析 —— 精品合集》 《数据库实体设计合集》 《Spring Boot 实现原理与源码解析 —— 精品合集》 《Java 面试题 .
springsecurity+oauth2.0分布式认证授权案例 JWT令牌服务配置5
健康平安的活着的专栏
08-29 2203
一 jwt 1.1 jwt？ JSON Web Token（JWT）是一个开放的行业标准（RFC 7519），它定义了一种简介的、自包含的协议格式，用于在通信双方传递json对象，传递的信息经过数字签名可以被验证和信任。JWT可以使用HMAC算法或使用RSA的公钥/私钥对来签名，防止被篡改。 1.2 解决问题 当资源服务和授权服务不在一起时资源服务使用RemoteTokenServices 远程请求授权 服务验证token，如果访问量较大将会影响系统的性能 。 解决上边问题： 令牌采用J
Spring Security 与 JWT、OAuth 2.0 整合详解：构建安全可靠的认证与授权机制
微笑听雨
06-13 4962
将 JWT（JSON Web Token）与 OAuth 2.0 整合到 Spring Security 中可以为应用程序提供强大的认证和授权功能。以下是详细的整合步骤和代码示例。
权限管理 springboot集成springSecurity Oauth2 JWT
qq_50909707的博客
10-06 6773
实现SpringSecurity里的UserDetailsService接口的LoadUserByUsername方法便可以实现自定义登录逻辑。以下代码将实现用户名为admin，密码为123的登录。一旦使用了自定义登录逻辑，原本的user和打印的password登录将不再生效。此时，通过admin 123便可登录。对于登出SpringSecurity也提供了一个/logout的接口。
spring-security oauth2 +jwt
Lycode
04-20 144
概念： JSON Web Token (JWT) JWT是一种安全标准。基本思路就是用户提供用户名和密码给认证服务器，服务器验证用户提交信息信息的合法性；如果验证成功，会产生并返回一个Token（令牌），用户可以使用这个token访问服务器上受保护的资源 一个token包含三部分： header.claims.signature claims 部分是整个token的核心，表示要发送...
学成在线 - Spring Security Oauth2 JWT 资料.zip
07-30
总的来说，这个压缩包提供了学习和实践Spring Security、OAuth2和JWT集成的全套资源，包括数据库配置、公钥管理和实际的项目代码。通过研究这些材料，开发者可以深入理解如何构建一个安全的、基于令牌的身份验证和...
Springboot整合Spring security+Oauth2+JWT搭建认证服务器，网关，微服务之间权限认证及授权
04-22
本教程将探讨如何使用Spring Boot结合Spring Security、OAuth2和JWT（JSON Web Token）来搭建一个认证服务器、API网关以及微服务之间的权限认证和授权机制。 首先，Spring Security是Spring框架的一个模块，专门...
springsecurity+oauth2+jwt实现单点登录demo
06-06
该资源是springsecurity+oauth2+jwt实现的单点登录demo，模式为授权码模式，实现自定义登录页面和自定义授权页面。应用数据存在内存中或者存在数据库中（附带数据库表结构），token存储分为数据库或者Redis。demo...
spring security oauth2 实现jwt sso
11-14
Spring Security OAuth2 与 JWT 实现的SSO详解 在当今的互联网应用中，单点登录（Single Sign-On，简称SSO）已经成为一种常见的身份验证机制，它允许用户在一个系统中登录后，无需再次登录就能访问其他关联系统。在...
Spring Security OAuth2实现使用JWT的示例代码
08-27
Spring Security OAuth2 实现使用 JWT 的示例代码 在本文中，我们将讨论如何使用 Spring Security OAuth2 实现使用 JSON Web Tokens（JWT），并提供了一个完整的示例代码。 Spring Security OAuth2 介绍 Spring ...
spring-security-oauth2（授权模式入门简单使用）
IABQL的博客
08-13 2757
当前应用需要实现第三方登入，那么第三方是如何进行授权认证的？这就是oauth2协议。模拟实现微信端是如何进行授权认证登入。举例：豆瓣就是客户应用，授权服务器、资源服务器就是微信端持有。豆瓣需要向微信的授权服务器获取授权，获取到授权后再向资源服务器获取用户信息。那么我们就需要1.需要配置一个授权服务器（发放授权码）2.配置一个资源服务器（获取用户信息接口需要令牌才能访问）3.配置一个接口（获取返回用户信息）4.还要实现模拟用户的登入（因为授权服务器需要向用户发起是否允许授权的请求）......
spring-security-oauth2集成jwt
u013008898的博客
06-12 831
JwtTokenStoreConfig: AuthorizationServerConfig:
Spring Security OAuth2
qq_60257417的博客
04-01 356
CustomUserAuthenticationConverter类。AuthorizationServerConfig类。UserDetailsServiceImpl类。configure()方法给登录退出接口放行。WebSecurityConfig类。AutoServiceImpl类。service.impl包。AuthToken类。
Spring Security OAuth2.0(四)-----OAuth2+JWT
qq_42264638的博客
05-08 2082
Spring Security OAuth2.0(四)-----OAuth2+JWT
Spring Cloud Oauth2 搭建授权认证中心 简化版本不复杂
又逢乱世
05-18 2565
1，创建一个springboot项目 我的版本使用的是springboot2.2.1版本 2，创建WebSecurityConfigurerAdapter的实现类WebSecurityConfig.java import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.security
Spring security知识整理
qq_25705173的博客
07-07 785
1） Spring Security中进行身份验证的是AuthenticationManager接口，ProviderManager是它的一个默认实现，但它并不用来处理身份认证，而是委托给配置好的AuthenticationProvider，每个AuthenticationProvider会轮流检查身份认证。检查后或者返回Authentication对象或者抛出异常。 验证身份就是加载响应的UserDetails，看看是否和用户输入的账号、密码、权限等信息匹配。此步骤由实现AuthenticationPro
spring中的事务
最新发布
menghuannvxia的专栏
08-13 214
方法发生异常就会触发事务管理，在spring中想进行事务回滚必须加上@Transactional注解，下边是出现异常进行捕获进行回滚的源代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值