devbox
编程革命者
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

springboot3.0+spring security6+vue3 前后分离之后端部分_spring-security6

作者：编程革命者 | 2024-02-01 13:49:31

赞

踩

spring-security6

描述

 springboot3.0 使用的jdk版本是17 

描述地址
源码地址springboot3.0+spring security6+vue3 前后分离: springboot3.0+spring security6+vue3 前后分离

springboot3.0+spring security6+vue3 前后分离之前端部分

springboot3.0+spring security6+vue3 前后分离之前端部分-CSDN博客

mysql脚本

  1. /*
  2.  Navicat Premium Data Transfer
  4.  Source Server         : localhost
  5.  Source Server Type    : MySQL
  6.  Source Server Version : 80029 (8.0.29)
  7.  Source Host           : localhost:3306
  8.  Source Schema         : sp
  10.  Target Server Type    : MySQL
  11.  Target Server Version : 80029 (8.0.29)
  12.  File Encoding         : 65001
  14.  Date: 19/12/2023 19:23:41
  15. */
  16.  
  17. SET NAMES utf8mb4;
  18. SET FOREIGN_KEY_CHECKS = 0;
  19.  
  20. -- ----------------------------
  21. -- Table structure for sys_menu
  22. -- ----------------------------
  23. DROP TABLE IF EXISTS `sys_menu`;
  24. CREATE TABLE `sys_menu`  (
  25.   `id` int NOT NULL AUTO_INCREMENT COMMENT '主键',
  26.   `name` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '菜单名称/按钮名称',
  27.   `auth` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '权限名称',
  28.   `create_time` datetime NULL DEFAULT NULL COMMENT '创建时间',
  29.   `parent_id` int NULL DEFAULT NULL COMMENT '父级id',
  30.   `is_type` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '类型  1:菜单 , 2:按钮',
  31.   `pai_xu` int NULL DEFAULT NULL COMMENT '排序序号',
  32.   `path` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '前端vue 跳转路径',
  33.   PRIMARY KEY (`id`) USING BTREE,
  34.   INDEX `idx_parent_id`(`parent_id` ASC) USING BTREE,
  35.   INDEX `idx_is_type`(`is_type` ASC) USING BTREE,
  36.   INDEX `idx_auth`(`auth` ASC) USING BTREE,
  37.   INDEX `idx_path`(`path` ASC) USING BTREE
  38. ) ENGINE = InnoDB AUTO_INCREMENT = 34 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '系统菜单/权限表' ROW_FORMAT = Dynamic;
  39.  
  40. -- ----------------------------
  41. -- Records of sys_menu
  42. -- ----------------------------
  43. INSERT INTO `sys_menu` VALUES (1, '组织管理', 'org', '2023-12-15 05:24:29', 0, '1', 1, '/org');
  44. INSERT INTO `sys_menu` VALUES (2, '组织管理二级菜单', 'org:er', '2023-12-15 05:25:51', 1, '1', 2, '/org/er');
  45. INSERT INTO `sys_menu` VALUES (3, '添加', 'org:er:add', '2023-12-15 05:26:52', 2, '2', 3, NULL);
  46. INSERT INTO `sys_menu` VALUES (4, '修改', 'org:er:edit', '2023-12-15 05:26:52', 2, '2', 4, NULL);
  47. INSERT INTO `sys_menu` VALUES (5, '用户管理', 'user', '2023-12-15 05:29:02', 0, '1', 5, '/user');
  48. INSERT INTO `sys_menu` VALUES (6, '用户管理二级菜单', 'user:er', '2023-12-15 05:29:02', 5, '1', 6, '/user/er');
  49. INSERT INTO `sys_menu` VALUES (7, '添加', 'user:er:add', '2023-12-15 05:26:52', 6, '2', 7, NULL);
  50. INSERT INTO `sys_menu` VALUES (8, '删除', 'user:er:del', '2023-12-15 05:26:52', 6, '2', 8, NULL);
  51. INSERT INTO `sys_menu` VALUES (9, '角色管理', 'role', '2023-12-15 05:29:02', 0, '1', 9, '/role');
  52. INSERT INTO `sys_menu` VALUES (10, '角色管理二级菜单', 'role:er', '2023-12-15 05:29:02', 9, '1', 10, '/role/er');
  53. INSERT INTO `sys_menu` VALUES (11, '添加', 'role:er:add', '2023-12-15 05:26:52', 10, '2', 11, NULL);
  54. INSERT INTO `sys_menu` VALUES (12, '删除', 'role:er:del', '2023-12-15 05:26:52', 10, '2', 12, NULL);
  55. INSERT INTO `sys_menu` VALUES (13, '权限管理', 'auth', '2023-12-15 05:29:02', 0, '1', 13, '/auth');
  56. INSERT INTO `sys_menu` VALUES (14, '权限管理二级菜单', 'auth:er', '2023-12-15 05:29:02', 13, '1', 14, '/auth/er');
  57. INSERT INTO `sys_menu` VALUES (15, '添加一级菜单', 'auth:er:add', '2023-12-15 05:26:52', 14, '2', 15, NULL);
  58. INSERT INTO `sys_menu` VALUES (16, '删除', 'auth:er:del', '2023-12-15 05:26:52', 14, '2', 16, NULL);
  59. INSERT INTO `sys_menu` VALUES (17, '应用管理', 'apply', '2023-12-16 20:43:40', 0, '1', 17, 'apply');
  60. INSERT INTO `sys_menu` VALUES (18, '应用管理二级菜单', 'apply:er', '2023-12-16 20:44:26', 17, '1', 18, '/apply/er');
  61. INSERT INTO `sys_menu` VALUES (19, '添加', 'apply:er:add', '2023-12-16 20:45:26', 18, '2', 19, NULL);
  62. INSERT INTO `sys_menu` VALUES (20, '修改', 'apply:er:edit', '2023-12-16 20:45:24', 18, '2', 20, NULL);
  63. INSERT INTO `sys_menu` VALUES (27, '删除', 'org:er:del', '2023-12-19 02:49:56', 2, '2', 30, NULL);
  64. INSERT INTO `sys_menu` VALUES (28, '分配角色', 'user:er:fp', '2023-12-19 02:51:05', 6, '2', 31, NULL);
  65. INSERT INTO `sys_menu` VALUES (29, '修改', 'role:er:edit', '2023-12-19 02:51:43', 10, '2', 32, NULL);
  66. INSERT INTO `sys_menu` VALUES (30, '分配权限', 'role:er:fp', '2023-12-19 02:52:02', 10, '2', 34, NULL);
  67. INSERT INTO `sys_menu` VALUES (31, '添加二级菜单', 'auth:er:add:sub', '2023-12-19 02:53:32', 14, '2', 35, NULL);
  68. INSERT INTO `sys_menu` VALUES (32, '修改', 'auth:er:edit', '2023-12-19 02:54:00', 14, '2', 37, NULL);
  69. INSERT INTO `sys_menu` VALUES (33, '添加按钮', 'auth:er:btn', '2023-12-19 07:36:36', 14, '2', 41, NULL);
  70.  
  71. -- ----------------------------
  72. -- Table structure for sys_menu_role
  73. -- ----------------------------
  74. DROP TABLE IF EXISTS `sys_menu_role`;
  75. CREATE TABLE `sys_menu_role`  (
  76.   `id` int NOT NULL AUTO_INCREMENT,
  77.   `role_id` int NULL DEFAULT NULL COMMENT '角色id',
  78.   `menu_id` int NULL DEFAULT NULL COMMENT '权限id',
  79.   PRIMARY KEY (`id`) USING BTREE,
  80.   INDEX `idx_role_id`(`role_id` ASC) USING BTREE,
  81.   INDEX `idx_menu_id`(`menu_id` ASC) USING BTREE
  82. ) ENGINE = InnoDB AUTO_INCREMENT = 575 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '权限角色关联表' ROW_FORMAT = Dynamic;
  83.  
  84. -- ----------------------------
  85. -- Records of sys_menu_role
  86. -- ----------------------------
  87. INSERT INTO `sys_menu_role` VALUES (17, 2, 1);
  88. INSERT INTO `sys_menu_role` VALUES (18, 2, 2);
  89. INSERT INTO `sys_menu_role` VALUES (19, 2, 3);
  90. INSERT INTO `sys_menu_role` VALUES (20, 2, 4);
  91. INSERT INTO `sys_menu_role` VALUES (21, 2, 5);
  92. INSERT INTO `sys_menu_role` VALUES (22, 2, 6);
  93. INSERT INTO `sys_menu_role` VALUES (23, 2, 7);
  94. INSERT INTO `sys_menu_role` VALUES (24, 2, 8);
  95. INSERT INTO `sys_menu_role` VALUES (25, 2, 9);
  96. INSERT INTO `sys_menu_role` VALUES (26, 2, 10);
  97. INSERT INTO `sys_menu_role` VALUES (27, 2, 11);
  98. INSERT INTO `sys_menu_role` VALUES (28, 2, 12);
  99. INSERT INTO `sys_menu_role` VALUES (29, 2, 13);
  100. INSERT INTO `sys_menu_role` VALUES (30, 2, 14);
  101. INSERT INTO `sys_menu_role` VALUES (31, 2, 15);
  102. INSERT INTO `sys_menu_role` VALUES (32, 2, 16);
  103. INSERT INTO `sys_menu_role` VALUES (159, 3, 3);
  104. INSERT INTO `sys_menu_role` VALUES (160, 3, 4);
  105. INSERT INTO `sys_menu_role` VALUES (161, 3, 7);
  106. INSERT INTO `sys_menu_role` VALUES (162, 3, 8);
  107. INSERT INTO `sys_menu_role` VALUES (163, 3, 11);
  108. INSERT INTO `sys_menu_role` VALUES (164, 3, 12);
  109. INSERT INTO `sys_menu_role` VALUES (165, 3, 15);
  110. INSERT INTO `sys_menu_role` VALUES (166, 3, 16);
  111. INSERT INTO `sys_menu_role` VALUES (167, 3, 32);
  112. INSERT INTO `sys_menu_role` VALUES (168, 3, 17);
  113. INSERT INTO `sys_menu_role` VALUES (169, 3, 18);
  114. INSERT INTO `sys_menu_role` VALUES (170, 3, 19);
  115. INSERT INTO `sys_menu_role` VALUES (171, 3, 20);
  116. INSERT INTO `sys_menu_role` VALUES (515, 10, 1);
  117. INSERT INTO `sys_menu_role` VALUES (516, 10, 2);
  118. INSERT INTO `sys_menu_role` VALUES (517, 10, 3);
  119. INSERT INTO `sys_menu_role` VALUES (518, 10, 4);
  120. INSERT INTO `sys_menu_role` VALUES (519, 10, 27);
  121. INSERT INTO `sys_menu_role` VALUES (520, 10, 5);
  122. INSERT INTO `sys_menu_role` VALUES (521, 10, 6);
  123. INSERT INTO `sys_menu_role` VALUES (522, 10, 7);
  124. INSERT INTO `sys_menu_role` VALUES (523, 10, 8);
  125. INSERT INTO `sys_menu_role` VALUES (524, 10, 28);
  126. INSERT INTO `sys_menu_role` VALUES (525, 10, 20);
  127. INSERT INTO `sys_menu_role` VALUES (548, 1, 1);
  128. INSERT INTO `sys_menu_role` VALUES (549, 1, 2);
  129. INSERT INTO `sys_menu_role` VALUES (550, 1, 3);
  130. INSERT INTO `sys_menu_role` VALUES (551, 1, 4);
  131. INSERT INTO `sys_menu_role` VALUES (552, 1, 27);
  132. INSERT INTO `sys_menu_role` VALUES (553, 1, 5);
  133. INSERT INTO `sys_menu_role` VALUES (554, 1, 6);
  134. INSERT INTO `sys_menu_role` VALUES (555, 1, 7);
  135. INSERT INTO `sys_menu_role` VALUES (556, 1, 8);
  136. INSERT INTO `sys_menu_role` VALUES (557, 1, 28);
  137. INSERT INTO `sys_menu_role` VALUES (558, 1, 9);
  138. INSERT INTO `sys_menu_role` VALUES (559, 1, 10);
  139. INSERT INTO `sys_menu_role` VALUES (560, 1, 11);
  140. INSERT INTO `sys_menu_role` VALUES (561, 1, 12);
  141. INSERT INTO `sys_menu_role` VALUES (562, 1, 29);
  142. INSERT INTO `sys_menu_role` VALUES (563, 1, 30);
  143. INSERT INTO `sys_menu_role` VALUES (564, 1, 13);
  144. INSERT INTO `sys_menu_role` VALUES (565, 1, 14);
  145. INSERT INTO `sys_menu_role` VALUES (566, 1, 15);
  146. INSERT INTO `sys_menu_role` VALUES (567, 1, 16);
  147. INSERT INTO `sys_menu_role` VALUES (568, 1, 31);
  148. INSERT INTO `sys_menu_role` VALUES (569, 1, 32);
  149. INSERT INTO `sys_menu_role` VALUES (570, 1, 33);
  150. INSERT INTO `sys_menu_role` VALUES (571, 1, 17);
  151. INSERT INTO `sys_menu_role` VALUES (572, 1, 18);
  152. INSERT INTO `sys_menu_role` VALUES (573, 1, 19);
  153. INSERT INTO `sys_menu_role` VALUES (574, 1, 20);
  154.  
  155. -- ----------------------------
  156. -- Table structure for sys_role
  157. -- ----------------------------
  158. DROP TABLE IF EXISTS `sys_role`;
  159. CREATE TABLE `sys_role`  (
  160.   `id` int NOT NULL AUTO_INCREMENT COMMENT '主键',
  161.   `role_code` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '角色编码',
  162.   `role_name` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '角色名称',
  163.   PRIMARY KEY (`id`) USING BTREE,
  164.   INDEX `idx_role_code`(`role_code` ASC) USING BTREE
  165. ) ENGINE = InnoDB AUTO_INCREMENT = 12 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '角色表' ROW_FORMAT = Dynamic;
  166.  
  167. -- ----------------------------
  168. -- Records of sys_role
  169. -- ----------------------------
  170. INSERT INTO `sys_role` VALUES (1, 'admin', '管理员');
  171. INSERT INTO `sys_role` VALUES (2, 'jingli', '经理');
  172. INSERT INTO `sys_role` VALUES (3, 'pt', '普通员工');
  173. INSERT INTO `sys_role` VALUES (10, 'caiwu', '财务');
  174.  
  175. -- ----------------------------
  176. -- Table structure for sys_user
  177. -- ----------------------------
  178. DROP TABLE IF EXISTS `sys_user`;
  179. CREATE TABLE `sys_user`  (
  180.   `id` int NOT NULL AUTO_INCREMENT COMMENT '主键',
  181.   `account` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '账号',
  182.   `password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '密码',
  183.   `name` varchar(30) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '姓名',
  184.   `create_time` datetime NULL DEFAULT NULL COMMENT '创建时间',
  185.   PRIMARY KEY (`id`) USING BTREE,
  186.   INDEX `idx_account`(`account` ASC) USING BTREE
  187. ) ENGINE = InnoDB AUTO_INCREMENT = 8 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '用户表' ROW_FORMAT = Dynamic;
  188.  
  189. -- ----------------------------
  190. -- Records of sys_user
  191. -- ----------------------------
  192. INSERT INTO `sys_user` VALUES (1, 'zhangsan', '$2a$10$0nZBWnCqPASXP.cnA4vx7.yg3Bdxm4h8hGOZ2MDX25uFLQh/huui.', '张三', '2023-12-15 04:37:51');
  193. INSERT INTO `sys_user` VALUES (2, 'lisi', '$2a$10$0nZBWnCqPASXP.cnA4vx7.yg3Bdxm4h8hGOZ2MDX25uFLQh/huui.', '李四', '2023-12-15 04:38:07');
  194. INSERT INTO `sys_user` VALUES (3, 'zhaoliu', '123456', '赵六', '2023-12-15 04:38:24');
  195. INSERT INTO `sys_user` VALUES (4, 'wangwu', '$2a$10$xw3X/WlHz3hm6GvelIdztO/P1OS4uizN2kgii9Fiqf6rgjZYwR2.i', '王五', '2023-12-18 21:54:38');
  196. INSERT INTO `sys_user` VALUES (5, 'laojiu', '$2a$10$tAOkYkinUU2V7FkgbSTu6e0M2wjaQ2g.oZ0b9X28jndSK0rhfq81G', '老九', '2023-12-18 22:08:46');
  197. INSERT INTO `sys_user` VALUES (7, 'wmz', '$2a$10$bopmg91MtoGac65D3SxZxuxJCb2QCWDzQbOETAbQwuVyp9KpwGA/u', '王麻子', '2023-12-19 19:06:29');
  198.  
  199. -- ----------------------------
  200. -- Table structure for sys_user_role
  201. -- ----------------------------
  202. DROP TABLE IF EXISTS `sys_user_role`;
  203. CREATE TABLE `sys_user_role`  (
  204.   `id` int NOT NULL AUTO_INCREMENT,
  205.   `role_id` int NULL DEFAULT NULL COMMENT '角色id',
  206.   `user_id` int NULL DEFAULT NULL COMMENT '用户id',
  207.   PRIMARY KEY (`id`) USING BTREE,
  208.   INDEX `idx_role_id`(`role_id` ASC) USING BTREE,
  209.   INDEX `idx_user_id`(`user_id` ASC) USING BTREE
  210. ) ENGINE = InnoDB AUTO_INCREMENT = 34 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '用户角色关联表' ROW_FORMAT = Dynamic;
  211.  
  212. -- ----------------------------
  213. -- Records of sys_user_role
  214. -- ----------------------------
  215. INSERT INTO `sys_user_role` VALUES (11, 2, 3);
  216. INSERT INTO `sys_user_role` VALUES (12, 3, 3);
  217. INSERT INTO `sys_user_role` VALUES (18, 2, 5);
  218. INSERT INTO `sys_user_role` VALUES (19, 2, 4);
  219. INSERT INTO `sys_user_role` VALUES (20, 3, 4);
  220. INSERT INTO `sys_user_role` VALUES (21, 1, 2);
  221. INSERT INTO `sys_user_role` VALUES (32, 1, 1);
  222. INSERT INTO `sys_user_role` VALUES (33, 10, 7);
  223.  
  224. SET FOREIGN_KEY_CHECKS = 1;

项目目录

 

pom.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <groupId>com.dmg</groupId>
  6.     <artifactId>sp</artifactId>
  7.     <version>0.0.1-SNAPSHOT</version>
  8.     <name>sp</name>
  9.     <description>sp</description>
  10.     <properties>
  11.         <java.version>17</java.version>
  12.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  13.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  14.         <spring-boot.version>3.0.2</spring-boot.version>
  15.     </properties>
  16.     <dependencies>
  17.         <dependency>
  18.             <groupId>org.springframework.boot</groupId>
  19.             <artifactId>spring-boot-starter-web</artifactId>
  20.         </dependency>
  21.  
  22.         <dependency>
  23.             <groupId>org.springframework.boot</groupId>
  24.             <artifactId>spring-boot-starter-test</artifactId>
  25.             <scope>test</scope>
  26.         </dependency>
  27.  
  28.         <!--必须引入webflux 否则 WebClient 不显示-->
  29.         <dependency>
  30.             <groupId>org.springframework.boot</groupId>
  31.             <artifactId>spring-boot-starter-webflux</artifactId>
  32.         </dependency>
  33.  
  34.         <dependency>
  35.             <groupId>org.springframework.boot</groupId>
  36.             <artifactId>spring-boot-starter-security</artifactId>
  37.         </dependency>
  38.  
  39.         <dependency>
  40.             <groupId>org.projectlombok</groupId>
  41.             <artifactId>lombok</artifactId>
  42.             <optional>true</optional>
  43.         </dependency>
  44.  
  45.         <!-- 添加MyBatisPlus的依赖 -->
  46.         <dependency>
  47.             <groupId>com.baomidou</groupId>
  48.             <artifactId>mybatis-plus-boot-starter</artifactId>
  49.             <version>3.5.4.1</version>
  50.         </dependency>
  51.         <!-- MySQL数据 -->
  52.         <dependency>
  53.             <groupId>mysql</groupId>
  54.             <artifactId>mysql-connector-java</artifactId>
  55.             <version>8.0.16</version>
  56.         </dependency>
  57.         <!-- druid  连接池-->
  58.         <dependency>
  59.             <groupId>com.alibaba</groupId>
  60.             <artifactId>druid</artifactId>
  61.             <version>1.1.14</version>
  62.         </dependency>
  63.         <!--JWT支持-->
  64.         <dependency>
  65.             <groupId>com.auth0</groupId>
  66.             <artifactId>java-jwt</artifactId>
  67.             <version>3.8.2</version>
  68.         </dependency>
  69.  
  70.         <!--springboot3.0的版本中 mybatis也要3.0 否则报错-->
  71.         <dependency>
  72.             <groupId>org.mybatis.spring.boot</groupId>
  73.             <artifactId>mybatis-spring-boot-starter</artifactId>
  74.             <version>3.0.0</version>
  75.         </dependency>
  76.  
  77.  
  78.     </dependencies>
  79.     <dependencyManagement>
  80.         <dependencies>
  81.             <dependency>
  82.                 <groupId>org.springframework.boot</groupId>
  83.                 <artifactId>spring-boot-dependencies</artifactId>
  84.                 <version>${spring-boot.version}</version>
  85.                 <type>pom</type>
  86.                 <scope>import</scope>
  87.             </dependency>
  88.         </dependencies>
  89.     </dependencyManagement>
  90.  
  91.     <build>
  92.         <plugins>
  93.             <plugin>
  94.                 <groupId>org.apache.maven.plugins</groupId>
  95.                 <artifactId>maven-compiler-plugin</artifactId>
  96.                 <version>3.8.1</version>
  97.                 <configuration>
  98.                     <source>17</source>
  99.                     <target>17</target>
  100.                     <encoding>UTF-8</encoding>
  101.                 </configuration>
  102.             </plugin>
  103.             <plugin>
  104.                 <groupId>org.springframework.boot</groupId>
  105.                 <artifactId>spring-boot-maven-plugin</artifactId>
  106.                 <version>${spring-boot.version}</version>
  107.                 <configuration>
  108.                     <mainClass>com.dmg.sp.SpApplication</mainClass>
  109.                     <skip>true</skip>
  110.                 </configuration>
  111.                 <executions>
  112.                     <execution>
  113.                         <id>repackage</id>
  114.                         <goals>
  115.                             <goal>repackage</goal>
  116.                         </goals>
  117.                     </execution>
  118.                 </executions>
  119.             </plugin>
  120.         </plugins>
  121.     </build>
  122.  
  123. </project>

resources

application.yml

  1. server:
  2.   port: 8083
  3. spring:
  4.   application:
  5.     name: sp
  6.   datasource:
  7.     driverClassName: com.mysql.cj.jdbc.Driver
  8.     type: com.alibaba.druid.pool.DruidDataSource
  9.     url: jdbc:mysql://localhost:3306/sp?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&useSSL=true&allowMultiQueries=true
  10.     username: root
  11.     password: 123456
  12.  
  13. mybatis-plus:
  14.   configuration:
  15.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  16.   mapper-locations: classpath:mapper/*.xml

MenuMapper.xml 

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="com.dmg.sp.dao.MenuMapper">
  4.  
  5.     <!--删除菜单关联的角色-->
  6.     <delete id="deleteRole">
  7.         DELETE from sys_menu_role
  8.         WHERE menu_id=#{id}
  9.     </delete>
  10.  
  11.  
  12.     <!--根据菜单id集合 获取对应的权限-->
  13.     <select id="getAuthList" resultType="com.dmg.sp.entity.Menu">
  14.         SELECT id,auth,path from sys_menu
  15.         WHERE id in
  16.         <foreach item="item" collection="ids" index="index" open="("
  17.                  separator="," close=")">
  18.             #{item}
  19.         </foreach>
  20.     </select>
  21.  
  22.  
  23.     <!--获取所有菜单-->
  24.     <select id="getMenuList" resultType="com.dmg.sp.entity.Menu">
  25.         SELECT * from sys_menu
  26.         ORDER BY pai_xu
  27.     </select>
  28.  
  29.  
  30.     <!--查看角色对应的权限-->
  31.     <select id="getRoleAuth" resultType="java.lang.String">
  32.         SELECT
  33.             auth
  34.         FROM
  35.             sys_menu
  36.         WHERE
  37.             id IN ( SELECT menu_id FROM sys_menu_role WHERE role_id = #{roleId} )
  38.         ORDER BY
  39.             pai_xu
  40.     </select>
  41.  
  42.     <!--查询用户关联的菜单id-->
  43.     <select id="getMenuIdsByUserId" resultType="Integer">
  44.         SELECT
  45.             menu_id
  46.         FROM
  47.             sys_menu_role
  48.         WHERE
  49.             role_id IN ( SELECT role_id FROM sys_user_role WHERE user_id = #{userId} )
  50.     </select>
  51.  
  52.     <!--根据菜单id集合查询父级id -->
  53.     <select id="getPIdsByIds" resultType="Integer">
  54.         SELECT DISTINCT
  55.         parent_id
  56.         FROM
  57.         sys_menu
  58.         WHERE
  59.         id IN
  60.         <foreach item="item" collection="ids" index="index" open="("
  61.                  separator="," close=")">
  62.             #{item}
  63.         </foreach>
  64.     </select>
  65.  
  66. </mapper>

RoleMapper.xml 

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="com.dmg.sp.dao.RoleMapper">
  4.  
  5.  
  6.     <!--为角色分配权限-->
  7.     <insert id="addRoleAuth">
  8.         INSERT INTO `sys_menu_role` (`role_id`, `menu_id`)
  9.         VALUES
  10.         <foreach collection="menuIds" item="item" index="index" separator=",">
  11.             (#{roleId},#{item})
  12.         </foreach>
  13.     </insert>
  14.  
  15.  
  16.     <!--删除角色关联的用户-->
  17.     <delete id="deleteUser">
  18.         DELETE from sys_user_role
  19.         WHERE role_id=#{id}
  20.     </delete>
  21.  
  22.     <!--删除角色关联的权限-->
  23.     <delete id="deleteAuth">
  24.         DELETE from sys_menu_role
  25.         WHERE role_id=#{id}
  26.     </delete>
  27.  
  28.     <!--查看用户对应的角色-->
  29.     <select id="getUserRole" resultType="com.dmg.sp.entity.Role">
  30.         SELECT * from sys_role
  31.         WHERE id in(
  32.             SELECT role_id from sys_user_role
  33.             WHERE user_id=#{userId}
  34.         )
  35.     </select>
  36.  
  37.  
  38. </mapper>

UserMapper.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="com.dmg.sp.dao.UserMapper">
  4.  
  5.  
  6.     <!--为用户分配角色-->
  7.     <insert id="addUserRole">
  8.         INSERT INTO `sys_user_role` (`role_id`, `user_id`)
  9.         VALUES
  10.         <foreach collection="roleIds" item="item" index="index" separator=",">
  11.             (#{item},#{userId})
  12.         </foreach>
  13.     </insert>
  14.  
  15.     <!--删除用户关联的角色-->
  16.     <delete id="deleteRole">
  17.         DELETE from sys_user_role
  18.         WHERE user_id=#{id}
  19.     </delete>
  20.  
  21.     <!--查看用户对应的角色id-->
  22.     <select id="getUserRoleIds" resultType="Integer">
  23.         SELECT role_id from sys_user_role
  24.         WHERE user_id=#{userId}
  25.     </select>
  26.  
  27. </mapper>

配置类

  1. package com.dmg.sp.config;
  2.  
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.web.cors.CorsConfiguration;
  6. import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
  7. import org.springframework.web.filter.CorsFilter;
  8. import org.springframework.web.servlet.config.annotation.CorsRegistry;
  9. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  10.  
  11. //解决跨域
  12. @Configuration
  13. public class CorsConfig implements WebMvcConfigurer {
  14.  
  15. 	@Override
  16. 	public void addCorsMappings(CorsRegistry registry) {
  17. 		//设置允许跨域的域名
  18. 		registry.addMapping("/**")
  19. 				//设置允许跨域的域名
  20. 				.allowedOriginPatterns("*")
  21. 				//是否允许cookie
  22. 				.allowCredentials(true)
  23. 				//设置允许请求的方式
  24. 				.allowedMethods(new String[]{"GET","POST","PUT","DELETE","OPTIONS"})
  25. 				//设置允许的请求头
  26. 				.allowedHeaders("*")
  27. 				//跨域允许时间
  28. 				.maxAge(3600);
  29. 	}
  30. }

  1. package com.dmg.sp.config;
  2.  
  3. import com.auth0.jwt.interfaces.Claim;
  4. import com.dmg.sp.service.UserService;
  5. import com.dmg.sp.utils.JWTUtil;
  6. import jakarta.servlet.FilterChain;
  7. import jakarta.servlet.ServletException;
  8. import jakarta.servlet.http.HttpServletRequest;
  9. import jakarta.servlet.http.HttpServletResponse;
  10. import lombok.extern.slf4j.Slf4j;
  11. import org.springframework.beans.factory.annotation.Autowired;
  12. import org.springframework.http.HttpMethod;
  13. import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
  14. import org.springframework.security.core.Authentication;
  15. import org.springframework.security.core.context.SecurityContext;
  16. import org.springframework.security.core.context.SecurityContextHolder;
  17. import org.springframework.security.core.userdetails.UserDetails;
  18. import org.springframework.security.web.SecurityFilterChain;
  19. import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
  20. import org.springframework.stereotype.Component;
  21. import org.springframework.util.AntPathMatcher;
  22. import org.springframework.util.StringUtils;
  23. import org.springframework.web.filter.OncePerRequestFilter;
  24.  
  25. import java.io.IOException;
  26. import java.util.Map;
  27.  
  28. /**
  29.  * 只登陆1次
  30.  */
  31. @Slf4j
  32. @Component
  33. public class JwtAuthenticationFilter extends OncePerRequestFilter {
  34.  
  35.     @Autowired
  36.     private UserService userService;
  37.  
  38.     /**
  39.      * 所有请求的过滤器
  40.      * @param request
  41.      * @param response
  42.      * @param filterChain
  43.      * @throws ServletException
  44.      * @throws IOException
  45.      */
  46.     @Override
  47.     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
  48.         //origin：指定可以访问本项目的IP
  49.         String origin = request.getHeader("Origin");
  50.         response.setContentType("application/json;charset=UTF-8");
  51.         response.setHeader("Access-Control-Allow-Origin", origin);
  52.         response.setHeader("Access-Control-Allow-Methods", "POST, GET, PUT, OPTIONS, DELETE");
  53.         response.setHeader("Access-Control-Max-Age", "1800");
  54.         //  设置  受支持请求标头（自定义  可以访问的请求头  例如：Token）
  55.         response.setHeader("Access-Control-Allow-Headers", "x-requested-with,Authorization,token,Origin,Content-Type,Accept");
  56.         // 指示的请求的响应是否可以暴露于该页面。当true值返回时它可以被暴露
  57.         response.setHeader("Access-Control-Allow-Credentials", "true");
  58.         //如果是OPTIONS请求，让其响应一个 200状态码，说明可以正常访问
  59.         if (HttpMethod.OPTIONS.toString().equals(request.getMethod())) {
  60.             response.setStatus(HttpServletResponse.SC_OK);
  61.             return;
  62.         }
  63.  
  64.         //获取token信息
  65.         String header=request.getHeader("Authorization");
  66.         log.info("header:{}",header);
  67.         //注意Bearer后面还有一个空格
  68.         if(StringUtils.isEmpty(header) || !StringUtils.startsWithIgnoreCase(header,"Bearer ")){
  69.             //如果请求头是空的 或者 前置没有以Bearer 开头 那么进入下一个过滤器链
  70.             filterChain.doFilter(request,response);
  71.             return;
  72.         }
  73.         //把Bearer空格去掉
  74.         String jwt=header.substring(7);
  75.         //获取token信息 第二个参数是盐值
  76.         Map<String, Claim> tokenInfo= JWTUtil.getTokenInfo(jwt,"123456789");
  77.         String account=tokenInfo.get("account").asString();
  78.  
  79.         //获取认证信息是否存在
  80.         Authentication auth = SecurityContextHolder.getContext().getAuthentication();
  81.         if(!StringUtils.isEmpty(account) && auth==null){
  82.           //如果账号不为空 并且 认证信息是空的
  83.           //获取用户信息
  84.           UserDetails userDetails = userService.loadUserByUsername(account);
  85.           if(account.equals(userDetails.getUsername())){
  86.               //如果用户信息不为空
  87.               SecurityContext securityContext=SecurityContextHolder.createEmptyContext();
  88.               //创建用户 认证token 对象
  89.               UsernamePasswordAuthenticationToken upt=new UsernamePasswordAuthenticationToken(userDetails,null,userDetails.getAuthorities());
  90.               //把web的请求信息 放到Details
  91.               upt.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
  92.               //把用户信息放到 安全上下文中
  93.               securityContext.setAuthentication(upt);
  94.               SecurityContextHolder.setContext(securityContext);
  95.           }
  96.  
  97.         }
  98.         //放行
  99.         filterChain.doFilter(request,response);
  100.     }
  101.  
  102.  
  103. }
  1. package com.dmg.sp.config;
  2.  
  3. import com.dmg.sp.utils.Result;
  4. import com.fasterxml.jackson.databind.ObjectMapper;
  5. import jakarta.servlet.ServletException;
  6. import jakarta.servlet.http.HttpServletRequest;
  7. import jakarta.servlet.http.HttpServletResponse;
  8. import lombok.extern.slf4j.Slf4j;
  9. import org.springframework.security.authentication.BadCredentialsException;
  10. import org.springframework.security.authentication.InsufficientAuthenticationException;
  11. import org.springframework.security.core.AuthenticationException;
  12. import org.springframework.security.web.AuthenticationEntryPoint;
  13. import org.springframework.stereotype.Component;
  14. import org.springframework.web.util.WebUtils;
  15.  
  16. import java.io.IOException;
  17. import java.io.PrintWriter;
  18. import java.util.HashMap;
  19. import java.util.Map;
  20.  
  21. /**
  22.  * 我的身份验证入口点
  23.  * 没有登陆认证 异常处理器
  24.  * @param
  25.  * @return
  26.  * @throws Exception
  27.  */
  28. @Slf4j
  29. @Component
  30. public class MyAuthenticationEntryPoint implements AuthenticationEntryPoint {
  31.  
  32.     @Override
  33.     public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
  34.         //返回json格式
  35.         response.setContentType("application/json;charset=utf-8");
  36.         //没有登陆 直接访问其他接口 就报401
  37.         response.setStatus(401);
  38.         Result<String> result = Result.error("401", "请先登录");
  39.         ObjectMapper objectMapper=new ObjectMapper();
  40.         String s=objectMapper.writeValueAsString(result);
  41.         //把json数据 写入 返回给前端
  42.         PrintWriter writer=response.getWriter();
  43.         writer.write(s);
  44.         writer.flush();
  45.         writer.close();
  46.     }
  47. }
  1. package com.dmg.sp.config;
  2.  
  3.  
  4. import com.baomidou.mybatisplus.core.toolkit.StringUtils;
  5. import com.dmg.sp.dao.MenuMapper;
  6. import com.dmg.sp.entity.Menu;
  7. import com.dmg.sp.service.MenuService;
  8. import lombok.extern.slf4j.Slf4j;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.context.annotation.Bean;
  11. import org.springframework.context.annotation.Configuration;
  12. import org.springframework.http.HttpMethod;
  13. import org.springframework.security.access.AccessDecisionManager;
  14. import org.springframework.security.access.AccessDecisionVoter;
  15. import org.springframework.security.access.vote.AuthenticatedVoter;
  16. import org.springframework.security.access.vote.UnanimousBased;
  17. import org.springframework.security.authentication.AnonymousAuthenticationToken;
  18. import org.springframework.security.authentication.AuthenticationManager;
  19. import org.springframework.security.authorization.AuthorizationDecision;
  20. import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
  21. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  22. import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
  23. import org.springframework.security.config.annotation.web.configuration.WebSecurityCustomizer;
  24. import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
  25. import org.springframework.security.config.http.SessionCreationPolicy;
  26. import org.springframework.security.core.GrantedAuthority;
  27. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  28. import org.springframework.security.crypto.password.PasswordEncoder;
  29. import org.springframework.security.web.SecurityFilterChain;
  30. import org.springframework.security.web.access.expression.WebExpressionVoter;
  31. import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
  32. import org.springframework.util.AntPathMatcher;
  33. import org.springframework.util.CollectionUtils;
  34.  
  35. import java.util.ArrayList;
  36. import java.util.Collection;
  37. import java.util.List;
  38.  
  39. @EnableWebSecurity
  40. @Slf4j
  41. @Configuration
  42. public class SpConfig {
  43.  
  44.     @Autowired
  45.     private JwtAuthenticationFilter jwtAuthenticationFilter;
  46.  
  47.     @Autowired
  48.     private MyAuthenticationEntryPoint myAuthenticationEntryPoint;
  49.  
  50.     @Autowired
  51.     private MenuMapper menuMapper;
  52.  
  53.  
  54.     //密码加密
  55.     @Bean
  56.     public PasswordEncoder passwordEncoder(){
  57.         return new BCryptPasswordEncoder();
  58.     }
  59.  
  60.     //安全过滤器链
  61.     @Bean
  62.     public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
  63.         
  64.         //每次都需要认证 不需要session 会话管理策略设置为无状态，这样就可以防止应用程序的会话被劫持攻击。
  65.         http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
  66.         http
  67.                 //禁用表单登录 前后分离用不上
  68.                 .formLogin().disable()
  69.                 //先进行jwt 校验 在进行账号密码登录
  70.                 .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class)
  71.                  //动态拦截所有请求 如果没有匹配上的 那么就拦截
  72.                 .authorizeHttpRequests(x->x.anyRequest().authenticated())
  73.                 //没有登录 直接返回异常信息
  74.                 .exceptionHandling(x->x.authenticationEntryPoint(myAuthenticationEntryPoint))
  75.                 //关闭csrf
  76.                 .csrf().disable();
  77.         //创建对象
  78.         return http.build();
  79.     }
  80.  
  81.  
  82.     //忽略路径 放行路径
  83.     @Bean
  84.     public WebSecurityCustomizer webSecurityCustomizer(){
  85.         //放行登录接口 这样才能登录成功
  86.         return x->x.ignoring().requestMatchers("/dengLu");
  87.     }
  88.  
  89.  
  90.     /**
  91.      * 把认证管理器注入到容器
  92.      * LoginServiceImpl类中 才能使用这个认证接口
  93.      * @param config
  94.      * @return
  95.      * @throws Exception
  96.      */
  97.     @Bean
  98.     public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception {
  99.         return config.getAuthenticationManager();
  100.     }
  101.  
  102. }

控制层

  1. package com.dmg.sp.controller;
  2.  
  3.  
  4. import com.dmg.sp.service.LoginService;
  5. import com.dmg.sp.utils.Result;
  6. import com.dmg.sp.vo.LoginVo;
  7. import lombok.extern.slf4j.Slf4j;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.web.bind.annotation.CrossOrigin;
  10. import org.springframework.web.bind.annotation.PostMapping;
  11. import org.springframework.web.bind.annotation.RequestBody;
  12. import org.springframework.web.bind.annotation.RestController;
  13.  
  14.  
  15. @Slf4j
  16. @RestController
  17. public class LoginController {
  18.  
  19.     @Autowired
  20.     private LoginService loginService;
  21.  
  22.     /**
  23.      * 登录
  24.      * @param vo
  25.      * @return
  26.      */
  27.     @PostMapping("/dengLu")
  28.     public Result dengLu(@RequestBody LoginVo vo){
  29.         return loginService.login(vo);
  30.     }
  31. }
  1. package com.dmg.sp.controller;
  2.  
  3.  
  4. import com.dmg.sp.entity.Menu;
  5. import com.dmg.sp.entity.MyUserDetails;
  6. import com.dmg.sp.entity.Role;
  7. import com.dmg.sp.service.MenuService;
  8. import com.dmg.sp.utils.Result;
  9. import com.dmg.sp.vo.IdVo;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.security.core.Authentication;
  12. import org.springframework.security.core.GrantedAuthority;
  13. import org.springframework.security.core.context.SecurityContextHolder;
  14. import org.springframework.web.bind.annotation.PostMapping;
  15. import org.springframework.web.bind.annotation.RequestBody;
  16. import org.springframework.web.bind.annotation.RestController;
  17.  
  18. import java.util.Collection;
  19. import java.util.List;
  20. import java.util.stream.Collectors;
  21.  
  22. @RestController
  23. public class MenuController {
  24.  
  25.     @Autowired
  26.     private MenuService menuService;
  27.  
  28.     /**
  29.      * 获取当前登录人的权限
  30.      * @return
  31.      */
  32.     @PostMapping("/getMyAuth")
  33.     public Result getMyAuth(){
  34.         //从认证信息上下文中 获取用户权限
  35.         Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
  36.         MyUserDetails myUserDetails =(MyUserDetails) authentication.getPrincipal();
  37.         return Result.success(myUserDetails.getAuthList());
  38.     }
  39.  
  40.     /**
  41.      * 获取所有菜单和权限(包括按钮)
  42.      * @return
  43.      */
  44.     @PostMapping("/getMenuList")
  45.     public Result getMenuList(){
  46.         //根据用户id 获取对应的菜单
  47.         List<Menu> list=menuService.getMenuList();
  48.         return Result.success(list);
  49.     }
  50.  
  51.     /**
  52.      * 添加菜单
  53.      * @return
  54.      */
  55.     @PostMapping("/addMenu")
  56.     public Result addMenu(@RequestBody Menu menu){
  57.         menuService.addMenu(menu);
  58.         return Result.success();
  59.     }
  60.  
  61.     /**
  62.      * 修改菜单
  63.      * @return
  64.      */
  65.     @PostMapping("/editMenu")
  66.     public Result editMenu(@RequestBody Menu menu){
  67.         menuService.editMenu(menu);
  68.         return Result.success();
  69.     }
  70.  
  71.     /**
  72.      * 删除菜单
  73.      * @return
  74.      */
  75.     @PostMapping("/deleteMenu")
  76.     public Result deleteMenu(@RequestBody Menu menu){
  77.         menuService.deleteMenu(menu.getId());
  78.         return Result.success();
  79.     }
  80.  
  81.     /**
  82.      * 查看菜单详情
  83.      * @return
  84.      */
  85.     @PostMapping("/getMenuById")
  86.     public Result getMenuById(@RequestBody Menu menu){
  87.         return Result.success(menuService.getMenuById(menu.getId()));
  88.     }
  89.  
  90.     /**
  91.      * 查看角色对应的权限
  92.      * @return
  93.      */
  94.     @PostMapping("/getRoleAuth")
  95.     public Result getRoleAuth(@RequestBody IdVo vo){
  96.         return Result.success(menuService.getRoleAuth(vo.getRoleId()));
  97.     }
  98. }
  1. package com.dmg.sp.controller;
  2.  
  3.  
  4. import com.dmg.sp.entity.Menu;
  5. import com.dmg.sp.entity.MyUserDetails;
  6. import com.dmg.sp.entity.Role;
  7. import com.dmg.sp.service.RoleService;
  8. import com.dmg.sp.utils.Result;
  9. import com.dmg.sp.vo.IdVo;
  10. import com.dmg.sp.vo.RoleAuthVo;
  11. import com.dmg.sp.vo.UserRoleVo;
  12. import org.springframework.beans.factory.annotation.Autowired;
  13. import org.springframework.security.core.Authentication;
  14. import org.springframework.security.core.context.SecurityContextHolder;
  15. import org.springframework.web.bind.annotation.PostMapping;
  16. import org.springframework.web.bind.annotation.RequestBody;
  17. import org.springframework.web.bind.annotation.RestController;
  18.  
  19. import java.util.List;
  20.  
  21. @RestController
  22. public class RoleController {
  23.  
  24.     @Autowired
  25.     private RoleService roleService;
  26.  
  27.     /**
  28.      * 获取所有角色
  29.      * @return
  30.      */
  31.     @PostMapping("/getRoleList")
  32.     public Result getRoleList(){
  33.         List<Role> list=roleService.getRoleList();
  34.         return Result.success(list);
  35.     }
  36.  
  37.     /**
  38.      * 添加角色
  39.      * @return
  40.      */
  41.     @PostMapping("/addRole")
  42.     public Result addRole(@RequestBody Role role){
  43.         roleService.addRole(role);
  44.         return Result.success();
  45.     }
  46.  
  47.     /**
  48.      * 修改角色
  49.      * @return
  50.      */
  51.     @PostMapping("/editRole")
  52.     public Result editRole(@RequestBody Role role){
  53.         roleService.editRole(role);
  54.         return Result.success();
  55.     }
  56.  
  57.     /**
  58.      * 删除角色
  59.      * @return
  60.      */
  61.     @PostMapping("/deleteRole")
  62.     public Result deleteRole(@RequestBody Role role){
  63.         roleService.deleteRole(role.getId());
  64.         return Result.success();
  65.     }
  66.  
  67.     /**
  68.      * 查看角色详情
  69.      * @return
  70.      */
  71.     @PostMapping("/getRoleById")
  72.     public Result getRoleById(@RequestBody Role role){
  73.         return Result.success(roleService.getRoleById(role.getId()));
  74.     }
  75.  
  76.     /**
  77.      * 查看用户对应的角色
  78.      * @return
  79.      */
  80.     @PostMapping("/getUserRole")
  81.     public Result getUserRole(@RequestBody IdVo vo){
  82.         return Result.success(roleService.getUserRole(vo.getUserId()));
  83.     }
  84.  
  85.     /**
  86.      * 为角色分配权限
  87.      * @return
  88.      */
  89.     @PostMapping("/setRoleAuth")
  90.     public Result setRoleAuth(@RequestBody RoleAuthVo vo){
  91.         roleService.setRoleAuth(vo);
  92.         return Result.success();
  93.     }
  94.  
  95. }
  1. package com.dmg.sp.controller;
  2.  
  3.  
  4. import com.dmg.sp.entity.MyUserDetails;
  5. import com.dmg.sp.entity.Role;
  6. import com.dmg.sp.entity.User;
  7. import com.dmg.sp.service.RoleService;
  8. import com.dmg.sp.service.SysUserService;
  9. import com.dmg.sp.utils.Result;
  10. import com.dmg.sp.vo.IdVo;
  11. import com.dmg.sp.vo.UserRoleVo;
  12. import org.springframework.beans.factory.annotation.Autowired;
  13. import org.springframework.security.core.Authentication;
  14. import org.springframework.security.core.context.SecurityContextHolder;
  15. import org.springframework.web.bind.annotation.PostMapping;
  16. import org.springframework.web.bind.annotation.RequestBody;
  17. import org.springframework.web.bind.annotation.RestController;
  18.  
  19. import java.util.List;
  20.  
  21. @RestController
  22. public class UserController {
  23.  
  24.  
  25.     @Autowired
  26.     private SysUserService sysUserService;
  27.  
  28.     /**
  29.      * 获取所有用户
  30.      * @return
  31.      */
  32.     @PostMapping("/getUserList")
  33.     public Result getUserList(){
  34.         List<User> list=sysUserService.getUserList();
  35.         return Result.success(list);
  36.     }
  37.  
  38.     /**
  39.      * 为用户分配角色
  40.      * @return
  41.      */
  42.     @PostMapping("/setUserRole")
  43.     public Result setUserRole(@RequestBody UserRoleVo vo){
  44.         sysUserService.setUserRole(vo);
  45.         return Result.success();
  46.     }
  47.  
  48.  
  49.     /**
  50.      * 添加用户
  51.      * @return
  52.      */
  53.     @PostMapping("/addUser")
  54.     public Result addUser(@RequestBody User user){
  55.         sysUserService.addUser(user);
  56.         return Result.success();
  57.     }
  58.  
  59.  
  60.     /**
  61.      * 获取当前登录人信息
  62.      * @return
  63.      */
  64.     @PostMapping("/getUserInfo")
  65.     public Result getUserInfo(){
  66.         //从认证信息上下文中 获取用户权限
  67.         Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
  68.         MyUserDetails myUserDetails =(MyUserDetails) authentication.getPrincipal();
  69.         User user = myUserDetails.getUser();
  70.         return Result.success(user);
  71.     }
  72.  
  73.  
  74.     /**
  75.      * 查看用户对应的角色id
  76.      * @return
  77.      */
  78.     @PostMapping("/getUserRoleIds")
  79.     public Result getUserRoleIds(@RequestBody IdVo vo){
  80.         return Result.success(sysUserService.getUserRoleIds(vo.getUserId()));
  81.     }
  82. }

dao

  1. package com.dmg.sp.dao;
  2.  
  3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  4. import com.dmg.sp.entity.Menu;
  5. import org.apache.ibatis.annotations.Param;
  6.  
  7. import java.util.List;
  8.  
  9.  
  10. public interface MenuMapper extends BaseMapper<Menu> {
  11.  
  12.  
  13.     /**
  14.      * 根据菜单id集合 获取对应的权限
  15.      * @param ids
  16.      * @return
  17.      */
  18.     public List<Menu>getAuthList(@Param("ids") List<Integer> ids);
  19.  
  20.     /**
  21.      * 获取所有菜单
  22.      * @return
  23.      */
  24.     List<Menu> getMenuList();
  25.  
  26.     /**
  27.      * 删除菜单关联的角色
  28.      * @return
  29.      */
  30.     Integer deleteRole(Integer id);
  31.  
  32.  
  33.     /**
  34.      * 查看角色对应的权限
  35.      * @return
  36.      */
  37.     public List<String> getRoleAuth(@Param("roleId") Integer roleId);
  38.  
  39.     /**
  40.      * 查询用户关联的菜单id
  41.      * @param userId
  42.      * @return
  43.      */
  44.     public List<Integer> getMenuIdsByUserId(@Param("userId") Integer userId);
  45.  
  46.     /**
  47.      * 根据菜单id集合查询父级id
  48.      * @param ids
  49.      * @return
  50.      */
  51.     public List<Integer> getPIdsByIds(@Param("ids") List<Integer> ids);
  52. }
  1. package com.dmg.sp.dao;
  2.  
  3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  4. import com.dmg.sp.entity.Role;
  5. import com.dmg.sp.entity.User;
  6. import org.apache.ibatis.annotations.Param;
  7.  
  8. import java.util.List;
  9.  
  10. public interface RoleMapper  extends BaseMapper<Role> {
  11.  
  12.     /**
  13.      * 删除角色关联的用户
  14.      * @param id
  15.      * @return
  16.      */
  17.     Integer deleteUser(@Param("id") Integer id);
  18.  
  19.     /**
  20.      * 删除角色关联的权限
  21.      * @param id
  22.      * @return
  23.      */
  24.     Integer deleteAuth(@Param("id") Integer id);
  25.  
  26.     /**
  27.      * 查看用户对应的角色
  28.      * @param userId
  29.      * @return
  30.      */
  31.     public List<Role> getUserRole(@Param("userId") Integer userId);
  32.  
  33.     /**
  34.      * 为角色分配权限
  35.      * @return
  36.      */
  37.     public Integer addRoleAuth(@Param("roleId") Integer roleId,
  38.                                @Param("menuIds") List<Integer> menuIds);
  39. }
  1. package com.dmg.sp.dao;
  2.  
  3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  4. import com.dmg.sp.entity.User;
  5. import com.dmg.sp.vo.UserRoleVo;
  6. import org.apache.ibatis.annotations.Mapper;
  7. import org.apache.ibatis.annotations.Param;
  8.  
  9. import java.util.List;
  10.  
  11.  
  12. public interface UserMapper extends BaseMapper<User> {
  13.  
  14.     /**
  15.      * 删除用户关联的角色
  16.      * @param id
  17.      * @return
  18.      */
  19.     public Integer deleteRole(@Param("id") Integer id);
  20.  
  21.     /**
  22.      * 为用户分配角色
  23.      * @return
  24.      */
  25.     public Integer addUserRole(@Param("userId") Integer userId,
  26.                                @Param("roleIds") List<Integer> roleIds);
  27.  
  28.     /**
  29.      * 查看用户对应的角色id
  30.      * @return
  31.      */
  32.     public List<Integer>getUserRoleIds(@Param("userId") Integer userId);
  33. }

entity

  1. package com.dmg.sp.entity;
  2.  
  3.  
  4. import com.baomidou.mybatisplus.annotation.IdType;
  5. import com.baomidou.mybatisplus.annotation.TableField;
  6. import com.baomidou.mybatisplus.annotation.TableId;
  7. import com.baomidou.mybatisplus.annotation.TableName;
  8. import com.fasterxml.jackson.annotation.JsonFormat;
  9. import lombok.Data;
  10.  
  11. import java.util.Date;
  12. import java.util.List;
  13.  
  14. @Data
  15. @TableName("sys_menu")
  16. public class Menu {
  17.  
  18.     @TableId(type = IdType.AUTO)
  19.     private Integer id;
  20.  
  21.     //菜单名称/按钮名称
  22.     private String name;
  23.  
  24.     //权限名称
  25.     private String auth;
  26.  
  27.     //创建日期
  28.     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
  29.     private Date createTime;
  30.  
  31.     //父级id
  32.     private Integer parentId;
  33.  
  34.     //类型  1:菜单 , 2:按钮
  35.     private String isType;
  36.  
  37.     //排序序号
  38.     private Integer paiXu;
  39.  
  40.     /**
  41.      * 前端vue 跳转路径
  42.      */
  43.     private String path;
  44.  
  45.     //子集菜单
  46.     @TableField(exist = false)
  47.     private List<Menu> children;
  48. }
  1. package com.dmg.sp.entity;
  2.  
  3. import lombok.Data;
  4. import org.springframework.security.core.GrantedAuthority;
  5. import org.springframework.security.core.authority.SimpleGrantedAuthority;
  6. import org.springframework.security.core.userdetails.UserDetails;
  7.  
  8. import java.util.Arrays;
  9. import java.util.Collection;
  10. import java.util.List;
  11. import java.util.stream.Collectors;
  12.  
  13. /**
  14.  * UserDetails 用户详细信息接口
  15.  *
  16.  * @param
  17.  * @return
  18.  * @throws Exception
  19.  */
  20. @Data
  21. public class MyUserDetails implements UserDetails {
  22.  
  23.  
  24.     private User user;
  25.  
  26.     private List<SimpleGrantedAuthority> simpleGrantedAuthorityList;
  27.  
  28.     public MyUserDetails(User user,List<SimpleGrantedAuthority> simpleGrantedAuthorityList){
  29.         this.user=user;
  30.         this.simpleGrantedAuthorityList=simpleGrantedAuthorityList;
  31.     }
  32.  
  33.     /**
  34.      * 获取所有权限
  35.      * @return
  36.      */
  37.     @Override
  38.     public Collection<? extends GrantedAuthority> getAuthorities() {
  39.         return simpleGrantedAuthorityList;
  40.     }
  41.  
  42.     @Override
  43.     public String getPassword() {
  44.         return user.getPassword();
  45.     }
  46.  
  47.     @Override
  48.     public String getUsername() {
  49.         return user.getAccount();
  50.     }
  51.  
  52.     @Override
  53.     public boolean isAccountNonExpired() {
  54.         return true;
  55.     }
  56.  
  57.     @Override
  58.     public boolean isAccountNonLocked() {
  59.         return true;
  60.     }
  61.  
  62.     @Override
  63.     public boolean isCredentialsNonExpired() {
  64.         return true;
  65.     }
  66.  
  67.     //是否启用 true:启用, false:禁用
  68.     @Override
  69.     public boolean isEnabled() {
  70.         return true;
  71.     }
  72.  
  73.     /**
  74.      * 二次处理权限
  75.      * 获取字符串集合的权限
  76.      * @return
  77.      */
  78.     public List<String>getAuthList(){
  79.         //转成list集合
  80.         return simpleGrantedAuthorityList.stream().map(x->x.getAuthority()).collect(Collectors.toList());
  81.     }
  82. }
  1. package com.dmg.sp.entity;
  2.  
  3.  
  4. import com.baomidou.mybatisplus.annotation.IdType;
  5. import com.baomidou.mybatisplus.annotation.TableId;
  6. import com.baomidou.mybatisplus.annotation.TableName;
  7. import lombok.Data;
  8.  
  9. @Data
  10. @TableName("sys_role")
  11. public class Role {
  12.  
  13.     @TableId(type = IdType.AUTO)
  14.     private Integer id;
  15.  
  16.     //角色编码
  17.     private String roleCode;
  18.  
  19.     //角色名称
  20.     private String roleName;
  21. }
  1. package com.dmg.sp.entity;
  2.  
  3. import com.baomidou.mybatisplus.annotation.IdType;
  4. import com.baomidou.mybatisplus.annotation.TableField;
  5. import com.baomidou.mybatisplus.annotation.TableId;
  6. import com.baomidou.mybatisplus.annotation.TableName;
  7. import com.fasterxml.jackson.annotation.JsonFormat;
  8. import lombok.Data;
  9.  
  10. import java.util.Date;
  11. import java.util.List;
  12.  
  13.  
  14. @Data
  15. @TableName("sys_user")
  16. public class User {
  17.  
  18.     @TableId(type = IdType.AUTO)
  19.     private Integer id;
  20.  
  21.     //账号
  22.     private String account;
  23.  
  24.     //密码
  25.     private String password;
  26.  
  27.     //姓名
  28.     private String name;
  29.  
  30.     //创建日期
  31.     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
  32.     private Date createTime;
  33.  
  34.     @TableField(exist = false)
  35.     private List<Menu> menu;
  36.  
  37. }

service

  1. package com.dmg.sp.service;
  2.  
  3. import com.dmg.sp.utils.Result;
  4. import com.dmg.sp.vo.LoginVo;
  5.  
  6. public interface LoginService {
  7.  
  8.     public Result login(LoginVo vo);
  9. }
  1. package com.dmg.sp.service;
  2.  
  3. import com.dmg.sp.entity.Menu;
  4. import org.springframework.web.bind.annotation.RequestBody;
  5.  
  6. import java.util.List;
  7.  
  8. public interface MenuService {
  9.  
  10.  
  11.     List<Menu> getMenuList();
  12.  
  13.     public void addMenu(Menu menu);
  14.     public void editMenu(Menu menu);
  15.     public void deleteMenu(Integer id);
  16.     public Menu getMenuById(Integer id);
  17.  
  18.     public List<String> getRoleAuth(Integer roleId);
  19.  
  20.     /**
  21.      * 获取当前登录人的菜单信息
  22.      * @return
  23.      */
  24.     public List<Menu> getMyMenu();
  25. }
  1. package com.dmg.sp.service;
  2.  
  3. import com.dmg.sp.entity.Role;
  4. import com.dmg.sp.utils.Result;
  5. import com.dmg.sp.vo.IdVo;
  6. import com.dmg.sp.vo.RoleAuthVo;
  7. import org.springframework.web.bind.annotation.PostMapping;
  8. import org.springframework.web.bind.annotation.RequestBody;
  9.  
  10. import java.util.List;
  11.  
  12. public interface RoleService {
  13.  
  14.     public List<Role>getRoleList();
  15.     public void addRole(Role role);
  16.     public void editRole(Role role);
  17.     public void deleteRole(Integer id);
  18.     public Role getRoleById(Integer id);
  19.     public List<Role> getUserRole(Integer userId);
  20.     public void setRoleAuth(RoleAuthVo vo);
  21.  
  22. }
  1. package com.dmg.sp.service;
  2.  
  3. import com.dmg.sp.entity.User;
  4. import com.dmg.sp.utils.Result;
  5. import com.dmg.sp.vo.UserRoleVo;
  6. import org.apache.ibatis.annotations.Param;
  7. import org.springframework.web.bind.annotation.PostMapping;
  8. import org.springframework.web.bind.annotation.RequestBody;
  9.  
  10. import java.util.List;
  11.  
  12. public interface SysUserService {
  13.  
  14.     List<User> getUserList();
  15.  
  16.     /**
  17.      * 为用户分配角色
  18.      * @return
  19.      */
  20.     public void setUserRole(UserRoleVo vo);
  21.  
  22.     public void addUser(User user);
  23.  
  24.  
  25.     /**
  26.      * 查看用户对应的角色id
  27.      * @return
  28.      */
  29.     public List<Integer>getUserRoleIds(Integer userId);
  30.  
  31. }
  1. package com.dmg.sp.service;
  2.  
  3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  4. import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
  5. import com.dmg.sp.dao.MenuMapper;
  6. import com.dmg.sp.dao.UserMapper;
  7. import com.dmg.sp.entity.Menu;
  8. import com.dmg.sp.entity.MyUserDetails;
  9. import com.dmg.sp.entity.User;
  10. import lombok.extern.slf4j.Slf4j;
  11. import org.springframework.beans.factory.annotation.Autowired;
  12. import org.springframework.security.core.authority.SimpleGrantedAuthority;
  13. import org.springframework.security.core.userdetails.UserDetails;
  14. import org.springframework.security.core.userdetails.UserDetailsService;
  15. import org.springframework.security.core.userdetails.UsernameNotFoundException;
  16. import org.springframework.stereotype.Service;
  17.  
  18. import java.util.ArrayList;
  19. import java.util.Collections;
  20. import java.util.List;
  21.  
  22. /**
  23.  * UserDetailsService 用户查询接口
  24.  *
  25.  * @param
  26.  * @return
  27.  * @throws Exception
  28.  */
  29. @Slf4j
  30. @Service
  31. public class UserService implements UserDetailsService {
  32.  
  33.     @Autowired
  34.     private UserMapper userMapper;
  35.     @Autowired
  36.     private MenuMapper menuMapper;
  37.  
  38.  
  39.     /**
  40.      * 根据账号查询用户信息
  41.      * @param
  42.      * @return
  43.      * @throws Exception
  44.      */
  45.     @Override
  46.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
  47.         log.info("根据账号查询用户信息==========================================================");
  48.         QueryWrapper<User>queryWrapper=new QueryWrapper<>();
  49.         queryWrapper.eq("account",username);
  50.         User user = userMapper.selectOne(queryWrapper);
  51.         if(user==null){
  52.             log.info("用户不存在");
  53.             throw new UsernameNotFoundException("用户不存在");
  54.         }
  55.         //根据用户id获取权限信息
  56.         List<Menu>auths=getAuthList(user.getId());
  57.         //组装权限信息 放入 SimpleGrantedAuthority
  58.         List<SimpleGrantedAuthority> simpleGrantedAuthorityList=getGrantedAuthority(auths);
  59.         //把权限放入用户对象中
  60.         user.setMenu(auths);
  61.         //最后返回UserDetails对象
  62.         return new MyUserDetails(user,simpleGrantedAuthorityList);
  63.     }
  64.  
  65.  
  66.     /**
  67.      * 组装权限信息 放入 SimpleGrantedAuthority
  68.      * @return
  69.      */
  70.     private List<SimpleGrantedAuthority> getGrantedAuthority(List<Menu>auths){
  71.         List<SimpleGrantedAuthority> list=new ArrayList<>();
  72.         for (Menu x : auths) {
  73.             SimpleGrantedAuthority simpleGrantedAuthority=new SimpleGrantedAuthority(x.getAuth());
  74.             list.add(simpleGrantedAuthority);
  75.         }
  76.         return list;
  77.     }
  78.  
  79.  
  80.     /**
  81.      * 根据用户id 获取所有权限
  82.      * 在分配权限的时候 如果只选择了按钮
  83.      * 那么也会把他的父级菜单给查询出来
  84.      *
  85.      * 只有按钮都不选择的时候 菜单才不展示
  86.      * @param userId
  87.      * @return
  88.      */
  89.     private List<Menu> getAuthList(Integer userId){
  90.         //查询用户关联的菜单id  按钮
  91.         List<Integer> menuIds = menuMapper.getMenuIdsByUserId(userId);
  92.         if(CollectionUtils.isEmpty(menuIds)){
  93.             //如果还没有授权 直接返回空
  94.             return new ArrayList<>();
  95.         }
  96.         //根据菜单id 查询父级 id  二级菜单
  97.         List<Integer> pIds=menuMapper.getPIdsByIds(menuIds);
  98.         if(CollectionUtils.isEmpty(pIds)){
  99.             //如果没有父级id 直接返回关联的权限
  100.             return menuMapper.getAuthList(menuIds);
  101.         }
  102.         //根据pIds 查询父级 id  一级菜单
  103.         List<Integer> oneIds=menuMapper.getPIdsByIds(pIds);
  104.         //通过所有的菜单id 查询权限信息
  105.         oneIds.addAll(pIds);
  106.         oneIds.addAll(menuIds);
  107.         return menuMapper.getAuthList(oneIds);
  108.     }
  109. }

impl

  1. package com.dmg.sp.service.impl;
  2.  
  3. import com.dmg.sp.entity.MyUserDetails;
  4. import com.dmg.sp.service.LoginService;
  5. import com.dmg.sp.utils.JWTUtil;
  6. import com.dmg.sp.utils.Result;
  7. import com.dmg.sp.vo.LoginVo;
  8. import lombok.extern.slf4j.Slf4j;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.security.authentication.AuthenticationManager;
  11. import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
  12. import org.springframework.security.core.Authentication;
  13. import org.springframework.stereotype.Service;
  14.  
  15. import java.util.HashMap;
  16. import java.util.Map;
  17. import java.util.Objects;
  18.  
  19. @Slf4j
  20. @Service
  21. public class LoginServiceImpl implements LoginService {
  22.  
  23.  
  24.     //认证管理器
  25.     @Autowired
  26.     private AuthenticationManager authenticationManager;
  27.  
  28.     @Override
  29.     public Result login(LoginVo vo) {
  30.         //根据账号和密码 创建 认证令牌对象
  31.         UsernamePasswordAuthenticationToken upt=new UsernamePasswordAuthenticationToken(vo.getAccount(),vo.getPassword());
  32.         //进行登录 获取认证信息
  33.         Authentication authenticate = authenticationManager.authenticate(upt);
  34.         if(authenticate==null){
  35.             throw new RuntimeException("登录失败");
  36.         }
  37.         Map<String,String> map=new HashMap<>();
  38.         map.put("account",vo.getAccount());
  39.         //第二个参数是盐值
  40.         //获取token
  41.         String token= JWTUtil.getToken(map,"123456789");
  42.         return Result.success(token);
  43.     }
  44. }
  1. package com.dmg.sp.service.impl;
  2.  
  3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  4. import com.dmg.sp.dao.MenuMapper;
  5. import com.dmg.sp.entity.Menu;
  6. import com.dmg.sp.entity.MyUserDetails;
  7. import com.dmg.sp.entity.Role;
  8. import com.dmg.sp.service.MenuService;
  9. import lombok.extern.slf4j.Slf4j;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.security.core.Authentication;
  12. import org.springframework.security.core.context.SecurityContextHolder;
  13. import org.springframework.stereotype.Service;
  14. import org.springframework.transaction.annotation.Transactional;
  15. import org.springframework.util.CollectionUtils;
  16. import org.springframework.util.StringUtils;
  17.  
  18. import java.util.ArrayList;
  19. import java.util.Date;
  20. import java.util.List;
  21.  
  22.  
  23. @Slf4j
  24. @Service
  25. public class MenuServiceImpl implements MenuService {
  26.  
  27.     @Autowired
  28.     private MenuMapper menuMapper;
  29.  
  30.  
  31.     /**
  32.      * 获取所有菜单
  33.      * @return
  34.      */
  35.     @Override
  36.     public List<Menu> getMenuList() {
  37.         List<Menu>res=new ArrayList<>();
  38.         List<Menu>list=menuMapper.getMenuList();
  39.         //递归放入 子菜单
  40.         for (Menu x : list) {
  41.             if(x.getIsType().equals("2")){
  42.                 //如果是按钮 直接跳过 因为是 最后一层
  43.                 continue;
  44.             }
  45.             dfs(x,list);
  46.             if(x.getParentId()==0){
  47.                 //只把一级菜单放入集合中 其他级别的菜单都在一级菜单的子集中
  48.                 res.add(x);
  49.             }
  50.         }
  51.         return res;
  52.     }
  53.  
  54.  
  55.     /**
  56.      * 添加菜单
  57.      * @param menu
  58.      */
  59.     @Transactional(rollbackFor = Exception.class)
  60.     @Override
  61.     public void addMenu(Menu menu) {
  62.         //根据权限查询是否存在
  63.         if(getByAuth(menu.getAuth())!=null){
  64.             throw new RuntimeException("权限已存在");
  65.         }
  66.         menu.setCreateTime(new Date());
  67.         menuMapper.insert(menu);
  68.     }
  69.  
  70.  
  71.  
  72.     /**
  73.      * 修改菜单
  74.      * @param menu
  75.      */
  76.     @Transactional(rollbackFor = Exception.class)
  77.     @Override
  78.     public void editMenu(Menu menu) {
  79.         Menu bean=menuMapper.selectById(menu.getId());
  80.         if(bean==null){
  81.             throw new RuntimeException("菜单不存在");
  82.         }
  83.         Menu item=getByAuth(menu.getAuth());
  84.         if(item!=null && !item.getAuth().equals(bean.getAuth())){
  85.             //如果不是当前菜单的权限,并且已存在 那么抛出异常
  86.             throw new RuntimeException("权限已存在");
  87.         }
  88.         menuMapper.updateById(menu);
  89.     }
  90.  
  91.  
  92.     /**
  93.      * 删除菜单
  94.      * @param id
  95.      */
  96.     @Transactional(rollbackFor = Exception.class)
  97.     @Override
  98.     public void deleteMenu(Integer id) {
  99.         //判断菜单是否存在
  100.         if(menuMapper.selectById(id)==null){
  101.             throw new RuntimeException("菜单不存在");
  102.         }
  103.         //判断当前是否有子集,如果有子集 不允许删除
  104.         if(getPIdCount(id)>0){
  105.             throw new RuntimeException("当前菜单下,还有子集,请先删除子集");
  106.         }
  107.         //删除菜单关联的角色
  108.         menuMapper.deleteRole(id);
  109.         //删除菜单
  110.         menuMapper.deleteById(id);
  111.     }
  112.  
  113.  
  114.     /**
  115.      * 根据菜单id 查看详情
  116.      * @param id
  117.      */
  118.     @Override
  119.     public Menu getMenuById(Integer id) {
  120.         return menuMapper.selectById(id);
  121.     }
  122.  
  123.     /**
  124.      * 查看角色对应的权限
  125.      * @return
  126.      */
  127.     @Override
  128.     public List<String> getRoleAuth(Integer roleId) {
  129.         return menuMapper.getRoleAuth(roleId);
  130.     }
  131.  
  132.  
  133.  
  134.  
  135.  
  136.     /**
  137.      * 递归放入父级中
  138.      * @param x
  139.      * @param list
  140.      */
  141.     private void dfs(Menu x,List<Menu>list){
  142.         for (Menu menu : list) {
  143.             if(menu.getParentId().equals(x.getId())){
  144.                 //如果子集 匹配上了父级 那么把子集放入父级中
  145.                 List<Menu> children = x.getChildren();
  146.                 if(CollectionUtils.isEmpty(children)){
  147.                     children=new ArrayList<>();
  148.                 }
  149.                 children.add(menu);
  150.                 x.setChildren(children);
  151.             }
  152.         }
  153.     }
  154.  
  155.     /**
  156.      * 根据权限获取菜单信息
  157.      * @return
  158.      */
  159.     private Menu getByAuth(String auth){
  160.         QueryWrapper<Menu> queryWrapper=new QueryWrapper();
  161.         queryWrapper.eq("auth",auth);
  162.         Menu x=menuMapper.selectOne(queryWrapper);
  163.         return x;
  164.     }
  165.  
  166.     /**
  167.      * 获取是否有子集
  168.      * @return
  169.      */
  170.     private Long getPIdCount(Integer parentId){
  171.         QueryWrapper<Menu> queryWrapper=new QueryWrapper();
  172.         queryWrapper.eq("parent_id",parentId);
  173.         return menuMapper.selectCount(queryWrapper);
  174.     }
  175.  
  176.  
  177.     /**
  178.      * 获取当前登录人的菜单信息
  179.      * @return
  180.      */
  181.     @Override
  182.     public List<Menu> getMyMenu() {
  183.         //从认证信息上下文中 获取用户权限
  184.         Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
  185.         if(authentication.getPrincipal() instanceof MyUserDetails){
  186.             MyUserDetails myUserDetails =(MyUserDetails) authentication.getPrincipal();
  187.             return myUserDetails.getUser().getMenu();
  188.         }
  189.         return new ArrayList<>();
  190.     }
  191.  
  192. }
  1. package com.dmg.sp.service.impl;
  2.  
  3. import com.dmg.sp.service.UserService;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.security.authentication.AuthenticationProvider;
  8. import org.springframework.security.authentication.BadCredentialsException;
  9. import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
  10. import org.springframework.security.core.Authentication;
  11. import org.springframework.security.core.AuthenticationException;
  12. import org.springframework.security.core.userdetails.UserDetails;
  13. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  14. import org.springframework.security.crypto.password.PasswordEncoder;
  15. import org.springframework.stereotype.Component;
  16.  
  17. /**
  18.  *
  19.  * 实现身份验证提供程序
  20.  * @param
  21.  * @return
  22.  * @throws Exception
  23.  */
  24. @Slf4j
  25. @Component
  26. public class MyAuthenticationProvider implements AuthenticationProvider {
  27.  
  28.     @Autowired
  29.     private UserService userService;
  30.  
  31.     @Autowired
  32.     private PasswordEncoder passwordEncoder;
  33.  
  34.  
  35.  
  36.     /**
  37.      * LoginServiceImpl的登录方法点击认证的时候 直接跳转到这里
  38.      * 登陆认证
  39.      * @param
  40.      * @return
  41.      * @throws Exception
  42.      */
  43.     @Override
  44.     public Authentication authenticate(Authentication authentication) throws AuthenticationException {
  45.         //从authentication获取用户名和凭证(密码)信息
  46.         String username=authentication.getName();
  47.         String password=authentication.getCredentials().toString();
  48.         log.info("密码=========================={}",password);
  49.         //查询用户是否存在
  50.         UserDetails userDetails = userService.loadUserByUsername(username);
  51.         //比较和数据库的密码是否一样
  52.         if(passwordEncoder.matches(password,userDetails.getPassword())){
  53.             //返回用户名密码认证令牌
  54.             //因为UsernamePasswordAuthenticationToken的上级父类的父类是Authentication 所以可以直接返回
  55.             return new UsernamePasswordAuthenticationToken(username,password,userDetails.getAuthorities());
  56.         }else {
  57.             throw new BadCredentialsException("用户名或者密码错误了");
  58.         }
  59.     }
  60.  
  61.     @Override
  62.     public boolean supports(Class<?> authentication) {
  63.         //保证认证和返回的对象都是UsernamePasswordAuthenticationToken
  64.         return authentication.equals(UsernamePasswordAuthenticationToken.class);
  65.     }
  66. }
  1. package com.dmg.sp.service.impl;
  2.  
  3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  4. import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
  5. import com.dmg.sp.dao.RoleMapper;
  6. import com.dmg.sp.entity.Role;
  7. import com.dmg.sp.service.RoleService;
  8. import com.dmg.sp.vo.RoleAuthVo;
  9. import lombok.extern.slf4j.Slf4j;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.stereotype.Service;
  12. import org.springframework.transaction.annotation.Transactional;
  13.  
  14. import java.util.List;
  15. @Slf4j
  16. @Service
  17. public class RoleServiceImpl implements RoleService {
  18.  
  19.     @Autowired
  20.     private RoleMapper roleMapper;
  21.  
  22.     /**
  23.      * 获取所有角色
  24.      * @return
  25.      */
  26.     @Override
  27.     public List<Role> getRoleList() {
  28.         return roleMapper.selectList(null);
  29.     }
  30.  
  31.     /**
  32.      * 添加角色
  33.      * @param role
  34.      */
  35.     @Transactional(rollbackFor = Exception.class)
  36.     @Override
  37.     public void addRole(Role role) {
  38.         //根据角色编码查询是否存在相同的角色
  39.         if(getRoleByCode(role.getRoleCode())!=null){
  40.             throw new RuntimeException("角色编码已存在");
  41.         }
  42.         roleMapper.insert(role);
  43.     }
  44.  
  45.     /**
  46.      * 修改角色
  47.      * @param role
  48.      */
  49.     @Transactional(rollbackFor = Exception.class)
  50.     @Override
  51.     public void editRole(Role role) {
  52.         Role bean=roleMapper.selectById(role.getId());
  53.         if(bean==null){
  54.             throw new RuntimeException("角色不存在");
  55.         }
  56.         Role item=getRoleByCode(role.getRoleCode());
  57.         if(item!=null && !item.getRoleCode().equals(bean.getRoleCode())){
  58.             //如果要修改的角色已存在,但是 不是当前角色的编码 那么抛出异常
  59.             throw new RuntimeException("角色编码已存在");
  60.         }
  61.         roleMapper.updateById(role);
  62.     }
  63.  
  64.     /**
  65.      * 删除角色
  66.      * @param id
  67.      */
  68.     @Transactional(rollbackFor = Exception.class)
  69.     @Override
  70.     public void deleteRole(Integer id) {
  71.         //判断角色是否存在
  72.         Role role=roleMapper.selectById(id);
  73.         if(role==null){
  74.             throw new RuntimeException("角色不存在");
  75.         }
  76.         if(role.getRoleCode().equals("admin")){
  77.             throw new RuntimeException("管理员不能删除");
  78.         }
  79.  
  80.         //删除角色关联的用户
  81.         roleMapper.deleteUser(id);
  82.         //删除角色关联的权限
  83.         roleMapper.deleteAuth(id);
  84.         //删除角色
  85.         roleMapper.deleteById(id);
  86.     }
  87.  
  88.     /**
  89.      * 根据角色id 查看角色详情
  90.      * @param id
  91.      * @return
  92.      */
  93.     @Override
  94.     public Role getRoleById(Integer id) {
  95.         return roleMapper.selectById(id);
  96.     }
  97.  
  98.     /**
  99.      * 查看用户对应的角色
  100.      * @param userId
  101.      * @return
  102.      */
  103.     @Override
  104.     public List<Role> getUserRole(Integer userId) {
  105.         return roleMapper.getUserRole(userId);
  106.     }
  107.  
  108.     /**
  109.      * 为角色分配权限
  110.      * @return
  111.      */
  112.     @Override
  113.     public void setRoleAuth(RoleAuthVo vo) {
  114.         //判断角色是否存在
  115.         if(roleMapper.selectById(vo.getRoleId())==null){
  116.             throw new RuntimeException("角色不存在");
  117.         }
  118.         if(CollectionUtils.isEmpty(vo.getMenuIds())){
  119.             throw new RuntimeException("权限不能为空");
  120.         }
  121.         //先删除旧的角色权限
  122.         roleMapper.deleteAuth(vo.getRoleId());
  123.         //在添加新的角色权限
  124.         roleMapper.addRoleAuth(vo.getRoleId(),vo.getMenuIds());
  125.     }
  126.  
  127.     /**
  128.      * 根据角色编码获取角色信息
  129.      * @param code
  130.      * @return
  131.      */
  132.     private Role getRoleByCode(String code){
  133.         QueryWrapper<Role> queryWrapper=new QueryWrapper();
  134.         queryWrapper.eq("role_code",code);
  135.         Role role=roleMapper.selectOne(queryWrapper);
  136.         return role;
  137.     }
  138. }
  1. package com.dmg.sp.service.impl;
  2.  
  3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  4. import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
  5. import com.dmg.sp.dao.UserMapper;
  6. import com.dmg.sp.entity.Role;
  7. import com.dmg.sp.entity.User;
  8. import com.dmg.sp.service.SysUserService;
  9. import com.dmg.sp.vo.UserRoleVo;
  10. import lombok.extern.slf4j.Slf4j;
  11. import org.springframework.beans.factory.annotation.Autowired;
  12. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  13. import org.springframework.stereotype.Service;
  14. import org.springframework.transaction.annotation.Transactional;
  15.  
  16. import java.util.Date;
  17. import java.util.List;
  18.  
  19. @Slf4j
  20. @Service
  21. public class SysUserServiceImpl implements SysUserService {
  22.  
  23.     @Autowired
  24.     private UserMapper userMapper;
  25.  
  26.  
  27.     /**
  28.      * 获取所有用户
  29.      * @return
  30.      */
  31.     @Override
  32.     public List<User> getUserList() {
  33.         return userMapper.selectList(null);
  34.     }
  35.  
  36.     /**
  37.      * 为用户分配角色
  38.      * @return
  39.      */
  40.     @Transactional(rollbackFor = Exception.class)
  41.     @Override
  42.     public void setUserRole(UserRoleVo vo) {
  43.         //判断用户是否存在
  44.         if(vo.getUserId()==null || userMapper.selectById(vo.getUserId())==null){
  45.             throw new RuntimeException("用户不存在");
  46.         }
  47.         if(CollectionUtils.isEmpty(vo.getRoleIds())){
  48.             throw new RuntimeException("角色不能为空");
  49.         }
  50.         //先删除旧的用户角色
  51.         userMapper.deleteRole(vo.getUserId());
  52.         //在添加新的用户角色
  53.         userMapper.addUserRole(vo.getUserId(),vo.getRoleIds());
  54.     }
  55.  
  56.  
  57.     /**
  58.      * 添加用户
  59.      * @param user
  60.      */
  61.     @Transactional(rollbackFor = Exception.class)
  62.     @Override
  63.     public void addUser(User user) {
  64.         //根据账号获取用户信息
  65.         if(getByAccount(user.getAccount())!=null){
  66.             throw new RuntimeException("该账号已存在");
  67.         }
  68.         //对密码进行加密
  69.         BCryptPasswordEncoder bCryptPasswordEncoder=new BCryptPasswordEncoder();
  70.         String encode = bCryptPasswordEncoder.encode(user.getPassword());
  71.         user.setPassword(encode);
  72.         user.setCreateTime(new Date());
  73.         userMapper.insert(user);
  74.     }
  75.  
  76.  
  77.     /**
  78.      * 查看用户对应的角色id
  79.      * @return
  80.      */
  81.     @Override
  82.     public List<Integer> getUserRoleIds(Integer userId) {
  83.         return userMapper.getUserRoleIds(userId);
  84.     }
  85.  
  86.     /**
  87.      * 根据账号获取用户信息
  88.      * @param account
  89.      * @return
  90.      */
  91.     private User getByAccount(String account){
  92.         QueryWrapper<User> queryWrapper=new QueryWrapper();
  93.         queryWrapper.eq("account",account);
  94.         User x=userMapper.selectOne(queryWrapper);
  95.         return x;
  96.     }
  97. }

utils

  1. package com.dmg.sp.utils;
  2.  
  3. import com.auth0.jwt.JWT;
  4. import com.auth0.jwt.JWTCreator;
  5. import com.auth0.jwt.algorithms.Algorithm;
  6. import com.auth0.jwt.interfaces.Claim;
  7. import com.auth0.jwt.interfaces.DecodedJWT;
  8.  
  9. import java.util.Calendar;
  10. import java.util.Map;
  11.  
  12. public class JWTUtil {
  13.     /**
  14.      * 传入payload信息获取token
  15.      */
  16.     public static String getToken(Map<String, String> map, String secret) {
  17.         JWTCreator.Builder builder = JWT.create();
  18.         //payload
  19.         map.forEach(builder::withClaim);
  20.         Calendar instance = Calendar.getInstance();
  21.         //默认7天过期
  22.         instance.add(Calendar.DATE, 7);
  23.         //指定令牌的过期时间
  24.         builder.withExpiresAt(instance.getTime());
  25.         return builder.sign(Algorithm.HMAC256(secret));
  26.     }
  27.  
  28.     /**
  29.      * 验证token 合法性
  30.      */
  31.     public static DecodedJWT verify(String token, String secret) {
  32.         //如果有任何验证异常，此处都会抛出异常
  33.         return JWT.require(Algorithm.HMAC256(secret)).build().verify(token);
  34.     }
  35.  
  36.     /**
  37.      * 获取token信息方法
  38.      */
  39.     public static Map<String, Claim> getTokenInfo(String token, String secret) {
  40.         return JWT.require(Algorithm.HMAC256(secret)).build().verify(token).getClaims();
  41.     }
  42. }
  1. package com.dmg.sp.utils;
  2.  
  3. import jakarta.servlet.http.HttpServletRequest;
  4. import jakarta.servlet.http.HttpServletResponse;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.springframework.http.HttpStatus;
  7. import org.springframework.security.authentication.BadCredentialsException;
  8. import org.springframework.security.core.userdetails.UsernameNotFoundException;
  9. import org.springframework.web.bind.annotation.ExceptionHandler;
  10. import org.springframework.web.bind.annotation.RestControllerAdvice;
  11.  
  12. import java.net.BindException;
  13.  
  14. /**
  15.  * 全局异常处理器
  16.  */
  17. @Slf4j
  18. @RestControllerAdvice
  19. public class MyGlobalExceptionHandler {
  20.  
  21.     @ExceptionHandler(UsernameNotFoundException.class)
  22.     public Result usernameNotFoundException(UsernameNotFoundException e) {
  23.         return Result.error("401",e.getMessage());
  24.     }
  25.  
  26.     @ExceptionHandler(BadCredentialsException.class)
  27.     public Result badCredentialsException(BadCredentialsException e) {
  28.         return Result.error("401",e.getMessage());
  29.     }
  30.  
  31.     @ExceptionHandler(Exception.class)
  32.     public Result exception(Exception e) {
  33.         return Result.error("500",e.getMessage());
  34.     }
  35. }
  1. package com.dmg.sp.utils;
  2.  
  3. import lombok.Data;
  4.  
  5. /**
  6.  * 返回对象
  7.  * @param <T>
  8.  */
  9. @Data
  10. public class Result<T> {
  11.  
  12.     private String code;
  13.  
  14.     private String msg;
  15.  
  16.     private T data;
  17.  
  18.     private static String SUCCESS="200";
  19.  
  20.     private static String ERROR="500";
  21.  
  22.     //禁止外部new对象
  23.     private Result(){
  24.  
  25.     }
  26.  
  27.     public static <T> Result<T> success(String code,String msg,T data){
  28.         Result result=new Result();
  29.         result.setCode(code);
  30.         result.setMsg(msg);
  31.         result.setData(data);
  32.         return result;
  33.     }
  34.  
  35.     public static <T> Result<T> success(String msg,T data){
  36.         Result result=new Result();
  37.         result.setCode(SUCCESS);
  38.         result.setMsg(msg);
  39.         result.setData(data);
  40.         return result;
  41.     }
  42.  
  43.     public static <T> Result<T> success(T data){
  44.         Result result=new Result();
  45.         result.setCode(SUCCESS);
  46.         result.setMsg(null);
  47.         result.setData(data);
  48.         return result;
  49.     }
  50.  
  51.     public static <T> Result<T> success(){
  52.         Result result=new Result();
  53.         result.setCode(SUCCESS);
  54.         result.setMsg(null);
  55.         result.setData(null);
  56.         return result;
  57.     }
  58.  
  59.     public static <T> Result<T> error(String code,String msg){
  60.         Result result=new Result();
  61.         result.setCode(code);
  62.         result.setMsg(msg);
  63.         result.setData(null);
  64.         return result;
  65.     }
  66.  
  67.     public static <T> Result<T> error(String msg){
  68.         Result result=new Result();
  69.         result.setCode(ERROR);
  70.         result.setMsg(msg);
  71.         result.setData(null);
  72.         return result;
  73.     }
  74.  
  75.     public static <T> Result<T> error(){
  76.         Result result=new Result();
  77.         result.setCode(ERROR);
  78.         result.setMsg(null);
  79.         result.setData(null);
  80.         return result;
  81.     }
  82.  
  83. }

vo

  1. package com.dmg.sp.vo;
  2.  
  3. import lombok.Data;
  4.  
  5. @Data
  6. public class IdVo {
  7.  
  8.     //用户id
  9.     private Integer userId;
  10.  
  11.     //角色id
  12.     private Integer roleId;
  13.  
  14.     //菜单id
  15.     private Integer menuId;
  16. }
  1. package com.dmg.sp.vo;
  2.  
  3.  
  4. import lombok.Data;
  5.  
  6. @Data
  7. public class LoginVo {
  8.  
  9.     //账号
  10.     private String account;
  11.  
  12.     //密码
  13.     private String password;
  14. }
  1. package com.dmg.sp.vo;
  2.  
  3. import lombok.Data;
  4.  
  5. import java.util.List;
  6.  
  7. @Data
  8. public class RoleAuthVo {
  9.  
  10.     //角色id
  11.     private Integer roleId;
  12.  
  13.     //菜单id 集合
  14.     private List<Integer> menuIds;
  15. }
  1. package com.dmg.sp.vo;
  2.  
  3. import lombok.Data;
  4.  
  5. import java.util.List;
  6.  
  7. @Data
  8. public class UserRoleVo {
  9.  
  10.     //用户id
  11.     private Integer userId;
  12.  
  13.     //角色id 集合
  14.     private List<Integer> roleIds;
  15. }

启动类

  1. package com.dmg.sp;
  2.  
  3. import org.mybatis.spring.annotation.MapperScan;
  4. import org.mybatis.spring.annotation.MapperScans;
  5. import org.springframework.boot.SpringApplication;
  6. import org.springframework.boot.autoconfigure.SpringBootApplication;
  7. import org.springframework.context.annotation.ComponentScan;
  8.  
  9. @MapperScan(basePackages = {"com.dmg.sp.dao"})
  10. @SpringBootApplication
  11. public class SpApplication {
  12.  
  13.     public static void main(String[] args) {
  14.         SpringApplication.run(SpApplication.class, args);
  15.     }
  16.  
  17. }

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号