Spring boot+Spring security+JWT实现前后端分离登录认证及权限控制

最新推荐文章于 2024-06-03 10:33:57 发布
最新推荐文章于 2024-06-03 10:33:57 发布
阅读量859 收藏 2
点赞数
分类专栏： 面试 学习路线 阿里巴巴 文章标签： spring spring boot java 后端 mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sebeefe/article/details/125243070
版权
借鉴文章：Springboot + Spring Security 实现前后端分离登录认证及权限控制_I_am_Rick_Hu的博客-CSDN博客_springsecurity前后端分离登录认证最近一段时间，公司给我安排了一个公司子系统的后台管理系统，让我实现权限管理。此时我就考虑到Spring全家桶的Spring security来权限管理。Spring security大致分为认证和授权两个功能，底层也是通过JavaWeb的Filter过滤器来实现，在Spring security中维护了一个过滤器链用
摘要由CSDN通过智能技术生成

借鉴文章：

Springboot + Spring Security 实现前后端分离登录认证及权限控制_I_am_Rick_Hu的博客-CSDN博客_springsecurity前后端分离登录认证

最近一段时间，公司给我安排了一个公司子系统的后台管理系统，让我实现权限管理。此时我就考虑到Spring全家桶的Spring security来权限管理。Spring security大致分为认证和授权两个功能，底层也是通过JavaWeb的Filter过滤器来实现，在Spring security中维护了一个过滤器链用来一层的一层的做过滤实现认证和授权，这里就不过多的介绍了，下面用案例来介绍。

项目前的准备：

整体架构为Spring boot+Spring security+Mybatis-plus+jwt。整体项目的结构如下：

整个项目依赖如下：

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


    <dependencies>
        <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>
            <scope>test</scope>
        </dependency>

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

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

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

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.13</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!--JSON-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.76</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.8.1</version>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.4.1</version>
        </dependency>

        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.1</version>
        </dependency>

        <!-- JWT-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.0</version>
        </dependency>
    </dependencies>


    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
    </build>

数据库的脚本如下：

大家可以去Mybatis-Plus官网copy到逆向生成的代码，链接如下

代码生成器（新） | MyBatis-Plus

记得要加上逆向生成的依赖哦，笔者提供的maven依赖中没有写。

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for sys_permission
-- ----------------------------
DROP TABLE IF EXISTS `sys_permission`;
CREATE TABLE `sys_permission` ?(
? `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键id',
? `permission_code` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '权限code',
? `permission_name` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '权限名',
? PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 5 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '权限表' ROW_FORMAT = Compact;

-- ----------------------------
-- Records of sys_permission
-- ----------------------------
INSERT INTO `sys_permission` VALUES (1, 'create_user', '创建用户');
INSERT INTO `sys_permission` VALUES (2, 'query_user', '查看用户');
INSERT INTO `sys_permission` VALUES (3, 'delete_user', '删除用户');
INSERT INTO `sys_permission` VALUES (4, 'modify_user', '修改用户');

-- ----------------------------
-- Table structure for sys_request_path
-- ----------------------------
DROP TABLE IF EXISTS `sys_request_path`;
CREATE TABLE `sys_request_path` ?(
? `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键id',
? `url` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '请求路径',
? `description` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '路径描述',
? PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '请求路径' ROW_FORMAT = Compact;

-- ----------------------------
-- Records of sys_request_path
-- ----------------------------
INSERT INTO `sys_request_path` VALUES (1, '/getUser', '查询用户');
INSERT INTO `sys_request_path` VALUES (2, '/deleteUser', '删除用户');

-- ----------------------------
-- Table structure for sys_request_path_permission_relation
-- ----------------------------
DROP TABLE IF EXISTS `sys_request_path_permission_relation`;
CREATE TABLE `sys_request_path_permission_relation` ?(
? `id` int(11) NULL DEFAULT NULL COMMENT '主键id',
? `url_id` int(11) NULL DEFAULT NULL COMMENT '请求路径id',
? `permission_id` int(11) NULL DEFAULT NULL COMMENT '权限id'
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '路径权限关联表' ROW_FORMAT = Compact;

-- ----------------------------
-- Records of sys_request_path_permission_relation
-- ----------------------------
INSERT INTO `sys_request_path_permission_relation` VALUES (1, 1, 2);
INSERT INTO `sys_request_path_permission_relation` VALUES (2, 2, 3);

-- ----------------------------
-- Table structure for sys_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_role`;
CREATE TABLE `sys_role` ?(
? `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键id',
? `role_code` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '角色值',
? `role_name` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '角色名',
? `role_description` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '角色说明',
? PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '用户角色表' ROW_FORMAT = Compact;

-- ----------------------------
-- Records of sys_role
-- ----------------------------
INSERT INTO `sys_role` VALUES (1, 'admin', '管理员', '管理员，拥有所有权限');
INSERT INTO `sys_role` VALUES (2, 'user', '普通用户', '普通用户，拥有部分权限');

-- ----------------------------
-- Table structure for sys_role_permission_relation
-- ----------------------------
DROP TABLE IF EXISTS `sys_role_permission_relation`;
CREATE TABLE &
最低0.47元/天 解锁文章
sebeefe
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring-Boot结合Security+JWT 简单实现前后端分离用户登录、授权案例
07-12
Spring-Security结合JWT 实现前后端分离完成权限验证功能案例，案例中，主要完成用户登录获取Token，通过Token访问Rest接口，没有权限或授权失败时返回JSON，前端根据状态码进行重新登录；案例中的用户名称： jake_j，密码：123。用户、角色、及菜单权限都是代码中指定的，未实现查询数据库相关数据。正常开发需要和现有系统数据库结合，这里只是简单说明整体用户认证、授权流程逻辑说明。 仓库地址：https://gitee.com/JakeRhino/spring-security-jwt-demo
SpringBoot+SpringSecurity+JWT前后端分离（一）
m0_49844045的博客
09-15 500
1、引入坐标 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> 2、实现UserDetails接口实体 /* * @description: 用户信息封装 */ @Data public class SecurityUs
SpringBoot-06-Security(前后端分离)
最新发布
m0_74353020的博客
06-03 1571
当然我们每次都会先走一下我们的自己定义的过滤器,我们当时写的是如果都身份令牌没有问题,并且能在redis中查询到,就存放到Security上下文当中,但是我们只是存放了用户名密码,并没有存放身份,这里我们存放一下我们的身份信息//我们的token是存放在请求头中的if(!StringUtils.hasText(token)){//请求头没有就放行return;//解析tokentry{throw new RuntimeException("token非法");//从redis中获取。
基于springBoot+springSecurity+jwt实现前后端分离用户权限认证
12-09
主要基于前后端分离情况下用户权限认证, 当用户登录认证成功后，每个用户会获取到自己的token，在请求其他接口时只需携带token即可,后端会通过token来识别用户身份。springSecurity也有很多种权限认证方式，本项目主要实现基于接口授权，也就是说通过注解给controller赋予权限，用户只有拥有某个接口的权限才能成功访问这个接口，从而实现不同用户拥有不同访问权限;
Springboot + Spring Security 实现前后端分离登录认证及权限控制
热门推荐
I_am_Hutengfei的博客
09-05 10万+
Springboot + Spring Security 实现前后端分离登录认证及权限控制前言本文主要的功能文章目录一、数据库表设计建表语句初始化表数据语句二、Spring Security核心配置：WebSecurityConfig三、用户登录认证逻辑：UserDetailsService1、创建自定义UserDetailsService2、准备service和dao层方法（1）根据用户名查询...
springBoot整合spring security+JWT实现单点登录与权限管理前后端分离--筑基中期
qq_43788185的博客
09-05 1435
写在前面 在前一篇文章当中，我们介绍了springBoot整合spring security单体应用版，在这篇文章当中，我将介绍springBoot整合spring secury+JWT实现单点登录与权限管理。 本文涉及的权限管理模型是基于资源的动态权限管理。数据库设计的表有 user 、role、user_role、permission、role_permission。 单点登录当中，关于访问者信息的存储有多种解决方案。如将其以key-value的形式存储于redis数据库中，访问者令牌中存放key。校验
SpringBoot+SpringSecurity前后端分离+Jwt的权限认证（改造记录）
z_ssyy的博客
05-31 1457
一般来说，我们用SpringSecurity默认的话是前后端整在一起的，比如thymeleaf或者Freemarker，SpringSecurity还自带login登录页,还让你配置登出页,错误页。但是现在前后端分离才是正道，前后端分离的话，那就需要将返回的页面换成Json格式交给前端处理了。
【springboot进阶】jwt在前后端分离的最佳实践方式（一）
06-05 1134
了解前后端分离的背景，session技术和token技术的差异，jwt的组成和应用
Springboot+SpringSecurity+JWT实现用户登录和权限认证示例
08-19
以下是实现Spring Boot + Spring Security + JWT登录和权限认证的主要步骤： 1. **项目初始化**：创建一个新的Spring Boot项目，添加`spring-boot-starter-web`、`spring-boot-starter-security`、`spring-security...
SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统
04-30
基于当前流行技术组合的前后端分离商城系统：SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统， 包含商城、sku、运费模板、素材库、小程序直播、拼团、砍价、商户管理、 秒杀、优惠券...
基于SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端商城系统源码
05-13
yshop基于当前流行技术组合的前后端分离商城系统： SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统， 包含分类、sku、运费模板、素材库、小程序直播、拼团、砍价、商户管理、 秒杀、...
【SpringBoot框架篇】16.security整合jwt实现对前后端分离的项目进行权限认证
皓亮君的博客
08-01 4609
使用Spring Security+JWT实现对前后端分离的项目进行权限认证
【SpringBoot整合JWT】
蛋饼吧的博客
05-18 8670
1.认证方式我们知道，http协议本身是一种无状态的协议，而这就意味着如果用户向我们的应用提供了用户名和密码来进行用户认证，那么下一次请求时，用户还要再一次进行用户认证才行，因为根据http协议，我们并不能知道是哪个用户发出的请求，所以为了让我们的应用能识别是哪个用户发出的请求，我们只能在服务器存储一份用户登录的信息，这份登录信息会在响应时传递给浏览器，告诉其保存为cookie,以便下次请求时发送给我们的应用，这样我们的应用就能识别请求来自哪个用户了,这就是传统的基于session认证。
SpringBoot集成jwt,解决前后端分离token跨域验证问题
weixin_46608377的博客
07-17 992
在之前进行登录验证的，主要用的是session的方式，session是由客户端首次发起请求，后端为此创建空间，返回给前端用来身份识别标识sessionId,前端基于cookie存储起来，在后面的请求中都会携带sessionId，后端就会根据这sessionId识别出身份信息。前端sessionid是基于cookie进行存储的。这种方式会存在安全问题，如果被不法分子拦截这个sessionId或cookie信息，就能跳过后端验证，从而盗取你的信息。而且seesion这种方式容易占用到服务端的内存空间。
JWT
m0_46487331的博客
12-14 799
Author：Allen_Huang Version：1.0.0 一. JWT简介 什么是JWT？ JWT(JSON Web Token)是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准。 它将用户信息加密到token里，服务器不保存任何用户信息。服务器通过使用保存的密钥验证token的正确性，只要正确即通过验证；应用场景如用户登录。JWT详细讲解请见 github：https://github.com/jwtk/jjwt 为什么使用JWT？ 随着技术的发展，分布式web应用的普.
SpringSecurity实现前后端分离认证授权
startqbb的博客
04-15 1457
SpringBoot整合SpringSecurity实现前后端分离认证授权
Spring+Boot+Spring+Security+JWT+实现+RESTful+Api+认证+（一）
09-20
Spring Boot和Spring Security可以很好地结合使用来实现RESTful API的认证。而JWT（JSON Web Token）是一种用于认证和授权的安全传输方式。 要在Spring Boot中实现JWT认证，可以遵循以下步骤： 1. 添加依赖：在`pom.xml`文件中添加以下依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.9.1</version> </dependency> ``` 2. 创建JWT工具类：创建一个JWT工具类来生成和解析JWT。可以使用JJWT库来简化这个过程。 3. 创建认证过滤器：创建一个继承自`OncePerRequestFilter`的认证过滤器，在该过滤器中检查请求中的JWT，并进行认证。 4. 配置Spring Security：将认证过滤器添加到Spring Security的配置中，以便在每个请求到达之前进行JWT认证。 5. 创建登录接口：创建一个登录接口，用于验证用户的身份并生成JWT。 这是一个简单的示例代码，说明如何在Spring Boot中实现JWT认证： ```java // JWT工具类 public class JwtUtils { private static final String SECRET_KEY = "your-secret-key"; private static final long EXPIRATION_TIME = 864_000_000; // 10天 public static String generateToken(Authentication authentication) { UserDetailsImpl userPrincipal = (UserDetailsImpl) authentication.getPrincipal(); Date expirationDate = new Date(System.currentTimeMillis() + EXPIRATION_TIME); return Jwts.builder() .setSubject(userPrincipal.getUsername()) .setIssuedAt(new Date()) .setExpiration(expirationDate) .signWith(SignatureAlgorithm.HS512, SECRET_KEY) .compact(); } public static String getUsernameFromToken(String token) { return Jwts.parser() .setSigningKey(SECRET_KEY) .parseClaimsJws(token) .getBody() .getSubject(); } public static boolean validateToken(String token) { try { Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token); return true; } catch (SignatureException | MalformedJwtException | ExpiredJwtException | UnsupportedJwtException | IllegalArgumentException e) { return false; } } } // 认证过滤器 public class JwtAuthenticationFilter extends OncePerRequestFilter { @Autowired private UserDetailsService userDetailsService; @Autowired private JwtUtils jwtUtils; @Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { String authorizationHeader = request.getHeader("Authorization"); if (StringUtils.hasText(authorizationHeader) && authorizationHeader.startsWith("Bearer ")) { String token = authorizationHeader.substring(7); if (jwtUtils.validateToken(token)) { String username = jwtUtils.getUsernameFromToken(token); UserDetails userDetails = userDetailsService.loadUserByUsername(username); UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities()); authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request)); SecurityContextHolder.getContext().setAuthentication(authentication); } } filterChain.doFilter(request, response); } } // Spring Security配置类 @Configuration @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Autowired private UserDetailsService userDetailsService; @Autowired private JwtAuthenticationFilter jwtAuthenticationFilter; @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } @Override protected void configure(AuthenticationManagerBuilder auth) throws Exception { auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder()); } @Override protected void configure(HttpSecurity http) throws Exception { http.csrf().disable() .authorizeRequests() .antMatchers("/login").permitAll() .anyRequest().authenticated() .and() .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS); http.addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class); } } // 登录接口 @RestController public class AuthController { @Autowired private AuthenticationManager authenticationManager; @PostMapping("/login") public ResponseEntity<?> authenticateUser(@RequestBody LoginRequest loginRequest) { Authentication authentication = authenticationManager.authenticate( new UsernamePasswordAuthenticationToken(loginRequest.getUsername(), loginRequest.getPassword()) ); SecurityContextHolder.getContext().setAuthentication(authentication); String token = JwtUtils.generateToken(authentication); return ResponseEntity.ok(new JwtResponse(token)); } } // 登录请求DTO public class LoginRequest { private String username; private String password; // getters and setters } // JWT响应DTO public class JwtResponse { private String token; // constructor and getter } // 用户详情实现类 @Service public class UserDetailsServiceImpl implements UserDetailsService { @Autowired private UserRepository userRepository; @Override public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { User user = userRepository.findByUsername(username) .orElseThrow(() -> new UsernameNotFoundException("User Not Found with username: " + username)); return UserDetailsImpl.build(user); } } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值