Spring Security + OAuth2.0 + JWT

最新推荐文章于 2024-10-07 08:00:00 发布
最新推荐文章于 2024-10-07 08:00:00 发布
阅读量3.3k 收藏 27
点赞数 5
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42155347/article/details/115566043
版权

文章目录

前言

基于Spring Boot项目使用Spring Security+OAuth2.0+JWT搭建用户认证中心。

一、Spring Security是什么？

Spring Security是一个强大且高度可定制的身份验证和访问控制框架。它是用于保护基于Spring的应用程序的实际标准。Spring Security官网

1.认证

1.1基于Session认证

用户登录成功后，会创建一个session保存在服务器端，session id保存在cookie中

1.2基于Token认证

使用token作为唯一标识

2.授权

3.基于角色访问控制

二、OAuth2.0是什么？

OAuth 2.0 是授权的行业标准协议。OAuth 2.0 侧重于客户端开发人员的简单性，同时为 Web 应用程序、桌面应用程序、移动电话和客厅设备提供特定的授权流。该规范及其扩展正在IETF非授权工作组内制定。

三、JWT是什么？

JSON Web Token (JWT) 是一个开放标准（RFC 7519），它定义了一种紧凑且自成一体的方式，将各方之间安全传输信息作为 JSON 对象。此信息可以进行验证和信任，因为它是以数字方式签名的。JWTs 可以使用秘密（使用HMAC算法）或使用RSA或ECDSA的公钥/私钥对进行签名。

四、代码实现

1.创建Spring Boot项目

新建一个Spring Boot项目然后通过maven引入所需依赖就可以。需要注意的是不同版本的Spring Boot和依赖包可能会出现方法过时等问题。本demo的Spring Boot的版本是2.4.4。下面是所有依赖包。

<!-- 核心依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>

<!-- 测试依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

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

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

<!-- lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

<!-- mybatis-plus -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.2</version>
</dependency>

<!-- mysql -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.22</version>
</dependency>

<!-- 数据源驱动包 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.4</version>
</dependency>

<!-- hutool -->
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.5.8</version>
</dependency>

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

<!-- jwt工具 -->
<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>3.3.0</version>
</dependency>

<!--Spring boot Redis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<!-- 日志 -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

<!-- oauth2.0 -->
<dependency>
    <groupId>org.springframework.security.oauth</groupId>
    <artifactId>spring-security-oauth2</artifactId>
    <version>2.3.6.RELEASE</version>
</dependency>

2.Spring Security

2.1基本使用

在引入Spring Security依赖之后启动项目，访问http://localhost:8080/login，Spring Security自带了一个登陆页面。如图
在这里插入图片描述
这就说明Spring Security使用成功。用户名默认是user，密码在启动项目时会显示在控制台。
在这里插入图片描述
接下来我们对Spring Security进行改造，实现一些我们自己的需求。

2.2自定义功能

2.2.1集成数据库

数据库连接省略
1.创建配置类

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true) // 开启方法级别安全
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Resource
    private UserDetailsServiceImpl userDetailsService;

    @Bean
    public BCryptPasswordEncoder bCryptPasswordEncoder() {
        return new BCryptPasswordEncoder();
    }
	
	/**
     * 一些简单的配置
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 禁用session
        http.sessionManagement().disable();
        http.csrf().disable();
        http.formLogin()
                // 自定义登录成功后路径
                .defaultSuccessUrl("/hello")
                // 自定义登录路径
                .loginProcessingUrl("/doLogin");
        // 可以匿名访问
        http.authorizeRequests()
                .antMatchers("/doLogin").anonymous()
                .anyRequest().authenticated();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 用户数据从数据库获取
        auth.userDetailsService(userDetailsService);
    }
}

2.自定义身份认证，创建一个类实现UserDetailsService

@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    @Resource
    private BCryptPasswordEncoder bCryptPasswordEncoder;

    @Resource
    private UserMapper userMapper;

    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
    	/* 用户在登录时，会进入此方法（在配置类中进行配置），参数是用户名，这里使用了mybatisplus
    	 * 做了一个简单的通过用户名查询用户，springsecurity会自动对密码进行匹配
    	 */
        QueryWrapper<com.springboot.demo.security.entity.User> wrapper = new QueryWrapper<>();
        wrapper.eq("username", s);
        com.springboot.demo.security.entity.User sysUser = userMapper.selectOne(wrapper);
        String password = sysUser.getPassword();
        List<GrantedAuthority> userList = new ArrayList<>();
        // userList是权限集合，这里也是做一个简单的权限添加
        userList.add(new SimpleGrantedAuthority("add"));
        // springsecurity5.0后密码需要加密一次，不然会报错
        return new User("user", bCryptPasswordEncoder.encode(password), userList);
    }

3.访问登录页进行测试
在这里插入图片描述
登录成功后跳转到自己配置的登录成功页面
在这里插入图片描述

2.3通过注解权限控制

使用注解进行权限控制首先需要在配置类中加上注解@EnableGlobalMethodSecurity(prePostEnabled = true)，表示开启方法级安全级别。有三种机制，这里使用@PreAuthorize注解，在上述登录中我们把add这个权限分配给了用户，所以登录后直接访问的hello没有权限限制可以直接访问

@GetMapping(value = "/hello")
public String hello() {
     return "hello";
 }

@PreAuthorize("hasAuthority('add')")
@GetMapping(value = "/add")
public String add() {
    return "add";
}

@PreAuthorize("hasAuthority('del')")
@GetMapping(value = "/del")
public String del() {
   return "del";
}

有add的权限也可以访问add
在这里插入图片描述
访问del就会提示授权异常
在这里插入图片描述
springsecurity的简单应用就大功告成。

3.OAuth2.0

3.1基本使用

首先引入所需maven依赖，然后我们创建一个配置类AuthorizationJwtServerConfig集成AuthorizationServerConfigurerAdapter，先使用redis做token存储。

@Configuration
@EnableAuthorizationServer
public class AuthorizationJwtServerConfig extends AuthorizationServerConfigurerAdapter {

    @Resource
    private RedisConnectionFactory redisConnectionFactory;

    @Bean
    public TokenStore tokenStore() {
        return new RedisTokenStore(redisConnectionFactory);
    }
	/**
     * 暴露授权服务
     * @param endpoints
     * @throws Exception
     */
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.tokenStore(tokenStore());
    }
}

然后启动项目，我们可以在控制台中看到打印的内容，说明oauth2.0可以使用。在这里插入图片描述

3.2四种授权模式

3.2.1 code码授权

通过code码换取token。
在AuthorizationJwtServerConfig配置类添加配置。

@Override
public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
    clients.inMemory()
            // 第三方应用客户端id,相当于账号，可自定义
            .withClient("web")
            // 第三方应用密码，需要加密，相当于密码，可自定义
            .secret(new BCryptPasswordEncoder().encode("web"))
            // 第三方作用域，自定义
            .scopes("read")
            // 授权类型，使用code码
            .authorizedGrantTypes("authorization_code")
            // 有效时间
            .accessTokenValiditySeconds(7200)
            // 重定向url，必须是公网地址，必须是https
            .redirectUris("https://www.baidu.com");
}

重启项目后我们在浏览器上访问http://localhost:8080/oauth/authorize?response_type=code&scope=read&client_id=web&redirect_uri=https://www.baidu.com
response_type参数是授权类型code是code码授权，scope作用域对应代码配置中的作用域值，client_id也是对应代码中的配置，redirect_uri同理。
回车之后会跳转到登录页面，然后输入账号密码再次登录，会跳转到授权页面
在这里插入图片描述
确认授权后会跳转到我们配置的重定向地址，并且获得了code码
在这里插入图片描述
有了code码之后我们就要用code码去换取token，使用工具postman发送一个post请求
在这里插入图片描述
除此之外还需要配置Authorization，类型选择Basic Auth，账号密码是代码中配置的
在这里插入图片描述
发送请求之后就会获得token了
在这里插入图片描述

3.2.2 静默授权

直接获取token，代码跟code码授权没有太大区别，类型换成implicit静默授权就可以了

@Override
public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
    clients.inMemory()
            // 第三方应用客户端id
            .withClient("app")
            // 第三方应用密码，需要加密
            .secret(new BCryptPasswordEncoder().encode("app"))
            // 第三方作用域
            .scopes("read")
            // 授权类型
            .authorizedGrantTypes("implicit")
            .accessTokenValiditySeconds(7200)
            .redirectUris("https://www.baidu.com");
}

重启项目，浏览器访问http://localhost:8080/oauth/authorize?response_type=token&scope=read&client_id=app&redirect_uri=https://www.baidu.com
注意这里的response_type的值是token，直接访问也会跳转到登录页面，登录成功后进行授权
在这里插入图片描述
授权成功后，token会显示在浏览器上
在这里插入图片描述

3.2.3 客户端授权
@Override
public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
    clients.inMemory()
            // 第三方应用客户端id
            .withClient("client")
            // 第三方应用密码，需要加密
            .secret(new BCryptPasswordEncoder().encode("client"))
            // 第三方作用域
            .scopes("read")
            // 授权类型
            .authorizedGrantTypes("client_credentials")
            .accessTokenValiditySeconds(7200)
            .redirectUris("https://www.baidu.com");
}

使用postman发送post请求获取token，只需grant_type一个参数
在这里插入图片描述
在这里插入图片描述

3.2.4 密码授权

首先更改WebSecurityConfig配置类，增加一个认证管理器

/**
 * 用密码模式授权认证管理器
 * @return
 * @throws
 */
@Override
@Bean
public AuthenticationManager authenticationManager() throws Exception {
    return super.authenticationManager();
}

AuthorizationJwtServerConfig类中把AuthenticationManager注入进来，暴露授权服务中加入认证管理器

@Resource
private AuthenticationManager authenticationManager;

@Override
public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
    clients.inMemory()
            // 第三方应用客户端id
            .withClient("qq")
            // 第三方应用密码，需要加密
            .secret(new BCryptPasswordEncoder().encode("qq"))
            // 第三方作用域
            .scopes("read")
            // 授权类型
            .authorizedGrantTypes("password")
            .accessTokenValiditySeconds(7200)
            .redirectUris("https://www.baidu.com");
}

/**
 * 暴露授权服务
 * @param endpoints
 * @throws Exception
 */
@Override
public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
    endpoints.tokenStore(tokenStore()).authenticationManager(authenticationManager);
}

重启项目后使用postman来测试，发送post请求
在这里插入图片描述
Authorization也需要配置
在这里插入图片描述
成功后直接获取token
在这里插入图片描述

4.JWT

4.1 基本使用

使用jwt生成token，并做token的验证

4.1.1 token过滤器
@Configuration
public class JwtTokenFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {
        String path = httpServletRequest.getRequestURI();
        String method = httpServletRequest.getMethod();
        // 对于登录直接放行
        if ("/login".equals(path) && "POST".equals(method)) {
            filterChain.doFilter(httpServletRequest, httpServletResponse);
            return;
        }
        // 获取token并验证
        String authorization = httpServletRequest.getHeader("Authorization");
        if (!StrUtil.hasBlank(authorization)) {
            String jwt = authorization.replaceAll("bearer ", "");
            // 创建一个token解析器（test作为jwt生成token的签名是自定义的，一般是作为配置固定值）
            JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256("test")).build();
            DecodedJWT decodedJwt;
            try {
                decodedJwt = jwtVerifier.verify(jwt);
            } catch (Exception e) {
                httpServletResponse.getWriter().write("token验证失败");
                return;
            }
            // 获取用户名，密码，角色权限
            String username = decodedJwt.getClaim("username").asString();
            String password = decodedJwt.getClaim("password").asString();
            List<String> roles = decodedJwt.getClaim("role").asList(String.class);
            List<SimpleGrantedAuthority> roleList = new ArrayList<>();
            roles.forEach(role -> {
                roleList.add(new SimpleGrantedAuthority(role));
            });
            UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken =
                    new UsernamePasswordAuthenticationToken(username, password, roleList);      
            SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
            filterChain.doFilter(httpServletRequest, httpServletResponse);
            return;
        }
        httpServletResponse.getWriter().write("token验证失败");
    }
}
4.1.2 WebSecurityConfig
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Resource
    private UserDetailsServiceImpl userDetailsService;

    @Resource
    private JwtTokenFilter jwtTokenFilter;

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @Bean
    public BCryptPasswordEncoder bCryptPasswordEncoder() {
        return new BCryptPasswordEncoder();
    }

    /**
     * 一些简单的配置
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 登录之前验证token
        http.addFilterBefore(jwtTokenFilter, UsernamePasswordAuthenticationFilter.class);
        // 禁用session
        http.sessionManagement().disable();
        http.csrf().disable();
        http.formLogin()
                // 登录成功处理器
                .successHandler(authenticationSuccessHandler())
                // 登录失败处理器
                .failureHandler(authenticationFailureHandler());
        // 除了登录可以匿名访问
        http.authorizeRequests()
                .antMatchers("/login").anonymous()
                .anyRequest().authenticated();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 用户数据从数据库获取
        auth.userDetailsService(userDetailsService);
    }
	
	/**
	 * 登录成功处理器
	 */
    @Bean
    public AuthenticationSuccessHandler authenticationSuccessHandler() {
        return ((httpServletRequest, httpServletResponse, authentication) -> {
            httpServletResponse.setContentType("application/json;charset=utf-8");
            User user = (User)authentication.getPrincipal();
            // 用户名
            String username = user.getUsername();
            // 密码
            String password = user.getPassword();
            // 权限
            Collection<GrantedAuthority> grantedAuthorities =  user.getAuthorities();
            List<String> roleList = new ArrayList<>();
            grantedAuthorities.forEach(grantedAuthority -> {
                roleList.add(grantedAuthority.getAuthority());
            });
            String[] roles = new String[roleList.size()];
            // 用jwt生成token
            HashMap<String, Object> headMap = new HashMap<>(16);
            // 使用的算法
            headMap.put("alg", "HS256");
            headMap.put("typ", "JWT");
            Date nowDate = new Date();
            // 过期时间可以自定义
            Date expDate = new Date(nowDate.getTime() + 2 * 60 * 60 * 1000);
            String jwt = JWT.create().withHeader(headMap)
                    .withIssuedAt(nowDate)
                    .withExpiresAt(expDate)
                    // 主题，自定义
                    .withSubject("demo")
                    .withClaim("username", username)
                    .withClaim("password", password)
                    .withArrayClaim("role", roleList.toArray(roles))
                    // 签名，自定义，同一个项目中签名是唯一
                    .sign(Algorithm.HMAC256("test"));
            // 保存token到redis
            redisTemplate.opsForValue().set("token:" + jwt, user, 7200);
            // 返回token
            HashMap<String, Object> hashMap = new HashMap<>(16);
            hashMap.put("username", username);
            hashMap.put("create_time", nowDate);
            hashMap.put("expires_time", expDate);
            hashMap.put("access_token", jwt);
            hashMap.put("type", "bearer");
            ObjectMapper objectMapper = new ObjectMapper();
            String s = objectMapper.writeValueAsString(hashMap);
            PrintWriter printWriter = httpServletResponse.getWriter();
            printWriter.write(s);
            printWriter.flush();
            printWriter.close();
        });
    }

	/**
	 * 登录失败处理器
	 */
    @Bean
    public AuthenticationFailureHandler authenticationFailureHandler() {
        return ((httpServletRequest, httpServletResponse, e) -> {
            HashMap<String, Object> hashMap = new HashMap<>(16);
            hashMap.put("error", e);
            hashMap.put("message", "登录失败");
            ObjectMapper objectMapper = new ObjectMapper();
            String s = objectMapper.writeValueAsString(hashMap);
            PrintWriter printWriter = httpServletResponse.getWriter();
            printWriter.write(s);
            printWriter.flush();
            printWriter.close();
        });
    }
}
4.1.3 AuthorizationJwtServerConfig
@Configuration
@EnableAuthorizationServer
public class AuthorizationJwtServerConfig extends AuthorizationServerConfigurerAdapter {

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

    /**
     * jwt token转换器
     * @return
     */
    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter() {
        JwtAccessTokenConverter jwtAccessTokenConverter = new JwtAccessTokenConverter();
        // 签名
        jwtAccessTokenConverter.setSigningKey("test");
        return jwtAccessTokenConverter;
    }

    /**
     * 暴露授权服务
     * @param endpoints
     * @throws Exception
     */
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.accessTokenConverter(jwtAccessTokenConverter());
    }
}

然后启动项目，使用postman测试
登录获取token
在这里插入图片描述
使用token访问接口
在这里插入图片描述

4.1.4 登出

登出就相当于是删除redis缓存的token

@PostMapping(value = "/doLogout")
    public Object logout() {
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = requestAttributes.getRequest();
        String head = request.getHeader("Authorization");
        if (!StrUtil.isBlank(head)) {
            String jwt = head.replaceAll("bearer ", "");
            if (!StrUtil.hasBlank(jwt)) {
                redisTemplate.delete("token:" + jwt);
                return "登出成功";
            }
        }
        return "登出失败";
    }
qq_42155347
关注
专栏目录
Spring Security OAuth2整合JWT
weixin_38927257的博客
11-22 1898
文章目录引言JWT的三个特点自包含：密签：签名：加密：可扩展：JWT组成HeaderClaims (Payload)SignatureJWT流程示意图Spring Security Oauth2 实现JWT配置TokenStoreConfig用于存储TokenMerryyouJwtTokenEnhancer配置认证服务器配置资源服务器解析扩展的Token测试方法刷新令牌： 引言 Json we...
Gateway+Springsecurity+OAuth2.0+JWT 实现分布式统一认证授权
01-23
这个项目“Gateway+Springsecurity+OAuth2.0+JWT 实现分布式统一认证授权”旨在构建一个强大的、分布式的认证与授权系统，以保护微服务架构中的各种服务。下面我们将深入探讨其中涉及的关键技术点。 1. **Gateway**...
Spring Cloud Security：Oauth2结合JWT使用
smart_an的专栏
04-18 1302
JWT是JSON WEB TOKEN的缩写，它是基于 RFC 7519 标准定义的一种可以安全传输的的JSON对象，由于使用了数字签名，所以是可信任和安全的。
详细分析Spring Security OAuth2中的JwtAccessTokenConverter基本知识（附Demo）
最新发布
码农研究僧的博客
10-07 1857
JwtAccessTokenConverter 是 Spring Security OAuth2 中的一个重要组件，主要用于生成和验证 JSON Web Token (JWT) JWT 的结构： JWT 由三部分组成：头部（Header）、负载（Payload）和签名（Signature） 头部通常包含令牌的类型（JWT）和签名算法（如 HMAC SHA256） 负载部分包含声明（Claims），即与用户相关的信息，例如权限、过期时间等 签名是使用头部和负载生成的，用于验证令牌的完整性
Spring Security 与 JWT、OAuth 2.0 整合详解：构建安全可靠的认证与授权机制
微笑听雨
06-13 5223
将 JWT（JSON Web Token）与 OAuth 2.0 整合到 Spring Security 中可以为应用程序提供强大的认证和授权功能。以下是详细的整合步骤和代码示例。
SpringSecurity OAuth2+JWT+网关实现认证授权中心
我神级欧文的博客
02-17 8808
之前利用SpringSecurity OAuth2搭建了一个认证服务器，并且结合网关搭建了一个安全认证的架构，而这个架构也是有缺点的，很明显的就是用户的信息是通过加在请求头到微服务去取出来的，这样就会容易泄露用户的信息并且很容易被别人截获请求伪造用户信息，而且网关每一次都要请求认证服务器去验证token是否正确，加重了认证服务器的负担。那么这里我们解决这两个问题用的就是jwt。 什么是JWT？ ...
SpringSecurity+Oauth2+JWT
m0_54765221的博客
07-03 874
SpringSecurity+Oauth2+JWTSpringSecurity+Oauth2+JWT快速入门自定义登入自定义登入成功失败处理器权限判断自定义异常返回自定义方法实现权限控制注解实现权限控制记住我实现退出登入CSRFOauth2认证Oauth2入门授权码模式Oauth2密码模式Jwt入门Oauth2整合JwtJwt扩展存储内容Jwt解析SpringSecurityOauth2整合SSOSecurity+Jwt SpringSecurity+Oauth2+JWT 快速入门 1. 创建基础项目 fi
springsecurity+oauth2+jwt实现单点登录demo
06-06
该资源是springsecurity+oauth2+jwt实现的单点登录demo，模式为授权码模式，实现自定义登录页面和自定义授权页面。应用数据存在内存中或者存在数据库中（附带数据库表结构），token存储分为数据库或者Redis。demo...
Springboot整合Spring security+Oauth2+JWT搭建认证服务器，网关，微服务之间权限认证及授权
04-22
本教程将探讨如何使用Spring Boot结合Spring Security、OAuth2和JWT（JSON Web Token）来搭建一个认证服务器、API网关以及微服务之间的权限认证和授权机制。 首先，Spring Security是Spring框架的一个模块，专门...
基于spring security + oauth2 + jwt ，可优雅集成第三方登录.zip
05-20
本项目以"基于spring security + oauth2 + jwt，可优雅集成第三方登录"为主题，旨在提供一个能够无缝整合第三方登录系统的解决方案。 Spring Security是一个强大的安全框架，它为Java和Java EE应用程序提供了全面的...
微服务商城系统（十） Spring Security Oauth2 + JWT 用户认证
weixin_41750142的博客
04-01 2279
文章目录一、用户认证分析1、认证 与 授权2、单点登录3、第三方账号登录4、第三方认证 一、用户认证分析      上面流程图 描述了用户要操作的各个微服务，用户查看个人信息 需要访问 用户微服务，下单 需要访问 订单微服务，秒杀抢购商品 需要访问 秒杀微服务。每个服务都需要认证用户的身份，身份认证成功后，需要识别用户的角色，然后授权访问对应的功能，比如管理员 和 普通用户的权限对应的功能 是不一样的。      1、认证 与
【安全框架】Spring Security、Oauth2、JWT 这一篇就够了
小源同学的博客
01-17 7559
文章目录Spring Security1. 安全框架概述2. Spring Security 简述3.Spring Security3.1 创建项目3.2 项目依赖3.3 页面3.3.1 login.html3.3.2 main.html3.4 测试3.4.1 启动项目3.4.2 打开浏览器3.5 自定义登录逻辑3.5.1 Security 的配置类3.5.2 UserDetailsService 的实现类3.5.3 重启测试3.6 自定义登陆页面3.6.1 login.html3.6.2 Security
springsecurity整合oauth2+JWT，数据库配置客户端
zifengye520的专栏
07-13 7434
springsecurity整合oauth2+JWT，数据库配置客户端
springscrity 单点_学成在线（第16天）Spring Security Oauth2
weixin_39939530的博客
12-19 564
用户认证需求分析用户认证需求分析用户认证与授权什么是用户身份认证？用户身份认证即用户去访问系统资源时系统要求验证用户的身份信息，身份合法方可继续访问。常见的用户身份认证表现形式有：用户名密码登录，指纹打卡等方式。什么是用户授权？用户认证通过后去访问系统的资源，系统会判断用户是否拥有访问资源的权限，只允许访问有权限的系统资源，没有权限的资源将无法访问，这个过程叫用户授权。单点登录需求单点登录(Sin...
Spring Security + OAuth2 + JWT 基本使用
weixin_45032957的博客
05-20 510
1.3、授权模式 oauth2根据使用场景不同，分成了4种模式 授权码模式（authorization code） 简化模式（implicit） 密码模式（resource owner password credentials） 客户端模式（client credentials） 授权码模式使用到了回调地址，是最为复杂的方式，通常网站中经常出现的微博，qq第三方登录，都会采用这个形式。简化模式不常用。 2、配置 使用oauth2保护你的应用，可以分为简易的分为三个步骤 配置资源服务器 配置授权服务器 配置s
Spring Security OAuth2.0认证授权三：使用JWT令牌
狂盗一枝梅的专栏
01-11 989
Spring Security OAuth2.0系列文章： Spring Security OAuth2.0认证授权一：框架搭建和认证测试 Spring Security OAuth2.0认证授权二：搭建资源服务 前面两篇文章详细讲解了如何基于spring boot + oath2.0搭建认证中心和资源中心，本篇文章将会讲解集成jwt以及将客户端信息和授权码信息保存到数据库。 一、 JWT 1. JWT简介 JSON Web Token（JWT）是一个开放的行业标准（RFC 7519），它定义了一种简介
Spring security + Oauth2 + Jwt认证鉴权方案
TylerGuoj的博客
05-20 5231
基础概念 用户身份认证 用户去访问系统资源时系统要求验证用户的身份信息，身份合法方可继续访问。常见的用户身份认证表现形式有：用户名密码登录，指纹打卡等方式 用户授权 用户认证通过后去访问系统的资源，系统会判断用户是否拥有访问资源的权限，只允许访问有权限的系统资源，没有权限的资源将无法访问 http 3xx 重定向状态码 重定向状态码用来告诉浏览器客户端，它们访问的资源已被移动， Web服务器发送一个重定向状态码, 告诉客户端新的资源地址在哪。浏览器客户端会根据提供的地址，重新发送新的Reques
Spring Security OAuth 2.0 资源服务器— JWT
深圳市多克创新科技有限公司
11-04 1710
Spring Security OAuth 2.0 资源服务器— JWT
spring security+jwt+oauth2.0 pdf
07-13
Spring Security是一个功能强大的安全框架，用于在Java应用程序中实现身份验证和授权。JWT（JSON Web Token）是一种轻量级的身份验证和授权机制，其中包含了验证用户身份的加密信息。OAuth 2.0是一种开放标准的授权协议，它允许用户授权第三方应用程序访问受保护的资源。 Spring Security可以与JWT和OAuth 2.0结合使用，以提供更强大的身份验证和授权功能。使用JWT作为身份验证机制，可以在用户登录成功后生成一个JWT令牌，并将其加入到HTTP请求的Header中。服务端可以使用JWT中的信息，如用户名和权限，对请求进行验证，确保用户的身份是有效的。而OAuth 2.0允许用户通过授权服务器颁发的token来访问受保护的资源，Spring Security可以集成OAuth 2.0来实现授权验证的逻辑。 通过使用Spring Security结合JWT和OAuth 2.0，可以轻松实现可伸缩、安全的身份验证和授权机制。开发人员可以使用Spring Security提供的各种功能，如用户认证、角色授权和访问控制，来保护应用程序中的敏感操作和数据。此外，使用JWT和OAuth 2.0，可以实现无状态的API身份验证和授权，提高系统的可扩展性和性能。 总之，Spring Security与JWT和OAuth 2.0的结合为应用程序提供了安全、可靠的身份验证和授权机制。开发人员可以根据具体的需求配置和使用这些功能，以保护应用程序的安全和数据的机密性。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值