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

基于springboot+vue的后台用户管理系统（一）_基于springboot-vue的课程后台管理系统

作者：知新_RL | 2024-02-26 20:04:21

赞

踩

基于springboot-vue的课程后台管理系统

一、项目背景

1.springboot

        springboot是所有基于spring开发项目的起点。springboot的设计是为了尽可能快的启动spring应用程序，并且尽可能的减少配置文件。约定优于配置，一种软件设计范式。

        spring是javaEE的轻量化替代品，同时通过依赖注入和面向切面编程，使其功能强大；不过它的组件代码虽然是轻量化的，但是它的配置文件却是重量级的。尽管在后续的更新开发中，通过引入基于注解的组件扫描、基于java的可重构配置，一定程度上降低了程度；不过项目的依赖管理也还是一种耗时耗力的事情。

        springboot对于spring的问题进行了改善和优化，同时基于约定优于配置的思想，可以使得开发人员不必在配置和逻辑业务中进行思维的转换，全身心投入逻辑业务的代码编写中，从而大大提高开发效率，一定程度上缩短了项目周期。

2.vue

        vue是一个构建数据驱动的web界面的渐进式框架。

        vue的目标是通过尽可能简单的API实现响应的数据绑定和组合视图组件。易于上手，同时易于与第三方库或既有项目的整合。

        vue专注于MVVM的view层；它的核心是MVVM中的VM，即ViewModel，负责连接view和model，保证视图与数据的一致性，这种轻量化的架构让前端开发更加高效、便捷。

3.选择

        开发一个项目，选择更加高校、便捷而且轻量化配置的框架，能够使得开发过程中减少除业务逻辑的代码开发外的所有时间，使得开发人员能够只用专注于代码开发，能够使得开发过程十分高效。

二、项目开发配置

1.开发工具：idea 2022

        idea作为一款业界评价甚高的开发工具，具有十分强大的功能，包括智能代码助手、代码自动提示、重构、javaEE支持、各类版本工具（git、svn等）、JUnit、CVS整合、代码分析等等，同时，用户体验不够良好的eclipse、集成度不高的Vim、不够稳定的VS Code，开发者更愿意偏向使用idea作为开发工具。

2.数据库：Mysql

        Mysql是一个关系型数据库管理系统。由于其的简单易用、价格低（对于多数个人用户而言是免费的）、小巧、支持查询语言（支持Sql）、性能高校、连接稳定、安全可靠、可移植性、开放式的分发、运行速度快。

3.数据库工具：MybatisPlus

（1）Mybatis

        优点：

        简单易学，容易上手；较JDBC代码量少；并不需要手动开关连接；很好的与各种数据库兼容；提供了很多第三方插件；同时能够与spring有很好的集成；想当灵活。sql语句编写在xml文件中，与程度代码分离，减少耦合，便于管理和优化，易与重用；能够利用xml文件更好的编写动态sql语句；提供映射标签，支持关系映射。

        缺点：

        sql语句编写工作量大、sql语句依赖于数据库，移植性差。

（2）MybatisPlus

        简单来说就是一款Mybatis的增强工具，用于简化开发、提高效率。它并不需要编写sql语句、配置xml文件，只需要创捷查询类，就能够迅速连接数据库。也正因此，将service层、dao层、entity层绑定一起，耦合度太高。

三、项目开发

1.新建idea项目

        填写名称、设定项目路径、选择JDK、点击下一步；

         选择springboot的版本（建议3.0以下）、选择是否下载JDK以及Maven库、选择所需的依赖项目（勾选web->spring web）（其余依赖后续通过maven快速配置）、点击创建；

2.配置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.  
  6.     <parent>
  7.         <groupId>org.springframework.boot</groupId>
  8.         <artifactId>spring-boot-starter-parent</artifactId>
  9.         <version>2.7.12</version>
  10.         <relativePath/> <!-- lookup parent from repository -->
  11.     </parent>
  12.  
  13.     <groupId>com.example</groupId>
  14.     <artifactId>System</artifactId>
  15.     <version>0.0.1-SNAPSHOT</version>
  16.     <name>System</name>
  17.     <description>System</description>
  18.  
  19.     <properties>
  20.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  21.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  22.         <java.version>11</java.version>
  23.         <mybatis-plus.version>3.2.0</mybatis-plus.version>
  24.     </properties>
  25.  
  26.     <dependencies>
  27.         <!-- 添加springmvc依赖 -->
  28.         <dependency>
  29.             <groupId>org.springframework.boot</groupId>
  30.             <artifactId>spring-boot-starter-web</artifactId>
  31.         </dependency>
  32.  
  33.         <!-- Mybatis -->
  34.         <dependency>
  35.             <groupId>org.mybatis.spring.boot</groupId>
  36.             <artifactId>mybatis-spring-boot-starter</artifactId>
  37.             <version>2.1.4</version>
  38.         </dependency>
  39.  
  40.         <!-- Mybatis-plus -->
  41.         <dependency>
  42.             <groupId>com.baomidou</groupId>
  43.             <artifactId>mybatis-plus-boot-starter</artifactId>
  44.             <version>${mybatis-plus.version}</version>
  45.         </dependency>
  46.         <dependency>
  47.             <groupId>com.baomidou</groupId>
  48.             <artifactId>mybatis-plus-generator</artifactId>
  49.             <version>${mybatis-plus.version}</version>
  50.         </dependency>
  51.  
  52.         <!-- websocket -->
  53.         <dependency>
  54.             <groupId>org.springframework.boot</groupId>
  55.             <artifactId>spring-boot-starter-websocket</artifactId>
  56.         </dependency>
  57.  
  58.         <!-- 数据库连接池 druid -->
  59.         <dependency>
  60.             <groupId>com.alibaba</groupId>
  61.             <artifactId>druid</artifactId>
  62.             <version>1.2.2</version>
  63.         </dependency>
  64.  
  65.         <!-- mysql -->
  66.         <dependency>
  67.             <groupId>mysql</groupId>
  68.             <artifactId>mysql-connector-java</artifactId>
  69.             <version>8.0.30</version>
  70.         </dependency>
  71.  
  72.         <dependency>
  73.             <groupId>cn.hutool</groupId>
  74.             <artifactId>hutool-all</artifactId>
  75.             <version>5.5.4</version>
  76.         </dependency>
  77.  
  78.         <!-- excel导出 -->
  79.         <dependency>
  80.             <groupId>org.apache.poi</groupId>
  81.             <artifactId>poi-ooxml</artifactId>
  82.             <version>4.1.2</version>
  83.         </dependency>
  84.  
  85.         <dependency>
  86.             <groupId>org.projectlombok</groupId>
  87.             <artifactId>lombok</artifactId>
  88.         </dependency>
  89.  
  90.         <dependency>
  91.             <groupId>io.springfox</groupId>
  92.             <artifactId>springfox-swagger2</artifactId>
  93.             <version>2.9.2</version>
  94.         </dependency>
  95.         <dependency>
  96.             <groupId>io.springfox</groupId>
  97.             <artifactId>springfox-swagger-ui</artifactId>
  98.             <version>2.9.2</version>
  99.         </dependency>
  100.  
  101.         <dependency>
  102.             <groupId>org.projectlombok</groupId>
  103.             <artifactId>lombok</artifactId>
  104.         </dependency>
  105.     </dependencies>
  106.  
  107.     <build>
  108.         <plugins>
  109.             <plugin>
  110.                 <groupId>org.springframework.boot</groupId>
  111.                 <artifactId>spring-boot-maven-plugin</artifactId>
  112.                 <version>2.7.12</version>
  113.                 <configuration>
  114.                     <fork>true</fork>
  115.                 </configuration>
  116.             </plugin>
  117.         </plugins>
  118.     </build>
  119.  
  120.     <repositories>
  121.         <repository>
  122.             <id>public</id>
  123.             <name>aliyun nexus</name>
  124.             <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
  125.             <releases>
  126.                 <enabled>true</enabled>
  127.             </releases>
  128.         </repository>
  129.     </repositories>
  130.  
  131.     <pluginRepositories>
  132.         <pluginRepository>
  133.             <id>public</id>
  134.             <name>aliyun nexus</name>
  135.             <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
  136.             <releases>
  137.                 <enabled>true</enabled>
  138.             </releases>
  139.             <snapshots>
  140.                 <enabled>false</enabled>
  141.             </snapshots>
  142.         </pluginRepository>
  143.     </pluginRepositories>
  144. </project>

3.配置application.yml（老版本为application.properties，可修改后缀名来修改文件格式）

  1. # 服务器端口设置
  2. server:
  3.   port: 9999
  4. spring:
  5.   # 数据库连接
  6.   datasource:
  7.     driver-class-name: com.mysql.cj.jdbc.Driver
  8.     username: root
  9.     password: 123456
  10.     url: jdbc:mysql://localhost:3306/workdatabase?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&serverTimezone=GMT%2b8
  11.     type: com.alibaba.druid.pool.DruidDataSource
  12.   # 网络服务
  13.   servlet:
  14.     multipart:
  15.       max-file-size: 100MB
  16.       max-request-size: 100MB
  17.  
  18. # mybatis配置
  19. mybatis:
  20.   mapper-locations: classpath:mapper/*.xml
  21.  
  22. logging:
  23.   level:
  24.     com:
  25.       example:
  26.         mapper:
  27.           debug

#.前期项目的后端具体结构

四、配置类

1.ListHandler类

        项目路径common.handle下，新建类，实现list转换string的类型转换。

  1. package com.example.system.common.handle;
  2.  
  3. import cn.hutool.json.JSONUtil;
  4. import org.apache.ibatis.type.BaseTypeHandler;
  5. import org.apache.ibatis.type.JdbcType;
  6.  
  7. import java.sql.CallableStatement;
  8. import java.sql.PreparedStatement;
  9. import java.sql.ResultSet;
  10. import java.sql.SQLException;
  11. import java.util.List;
  12.  
  13. /**
  14.  * list转换string
  15.  */
  16. public class ListHandler extends BaseTypeHandler<List> {
  17.  
  18.     @Override
  19.     public void setNonNullParameter(PreparedStatement preparedStatement, int i, List list, JdbcType jdbcType) throws SQLException {
  20.         preparedStatement.setObject(i, JSONUtil.toJsonStr(list));
  21.     }
  22.  
  23.     @Override
  24.     public List getNullableResult(ResultSet resultSet, String s) throws SQLException {
  25.         return JSONUtil.parseArray(resultSet.getString(s));
  26.     }
  27.  
  28.     @Override
  29.     public List getNullableResult(ResultSet resultSet, int i) throws SQLException {
  30.         return JSONUtil.parseArray(resultSet.getString(i));
  31.     }
  32.  
  33.     @Override
  34.     public List getNullableResult(CallableStatement callableStatement, int i) throws SQLException {
  35.         return JSONUtil.parseArray(callableStatement.getString(i));
  36.     }
  37. }

2.Result类

        结果信息处理类，实现对各类处理信息的响应。

  1. package com.example.system.common.handle;
  2.  
  3. /**
  4.  * 处理结果
  5.  * @param <T>
  6.  */
  7. public class Result<T> {
  8.     private String code; // 状态码
  9.     private String msg; // 信息
  10.     private T data; // 数据
  11.  
  12.     public String getCode() {
  13.         return code;
  14.     }
  15.  
  16.     public void setCode(String code) {
  17.         this.code = code;
  18.     }
  19.  
  20.     public String getMsg() {
  21.         return msg;
  22.     }
  23.  
  24.     public void setMsg(String msg) {
  25.         this.msg = msg;
  26.     }
  27.  
  28.     public T getData() {
  29.         return data;
  30.     }
  31.  
  32.     public void setData(T data) {
  33.         this.data = data;
  34.     }
  35.  
  36.     public Result() {
  37.     }
  38.  
  39.     public Result(T data) {
  40.         this.data = data;
  41.     }
  42.  
  43.     // 结果成功
  44.     public static Result success() {
  45.         Result result = new Result<>();
  46.         result.setCode("0");
  47.         result.setMsg("成功");
  48.         return result;
  49.     }
  50.  
  51.     public static <T> Result<T> success(T data) {
  52.         Result<T> result = new Result<>(data);
  53.         result.setCode("0");
  54.         result.setMsg("成功");
  55.         return result;
  56.     }
  57.  
  58.     // 结果失败
  59.     public static Result error(String code, String msg) {
  60.         Result result = new Result();
  61.         result.setCode(code);
  62.         result.setMsg(msg);
  63.         return result;
  64.     }
  65. }

五、用户实体类entity

1.用户类User

（1）需求分析

        作为一个管理系统，首先得要有用户（基础属性），无论是管理员（权限属性），还是普通用户，在访问系统时都是一名用户。

        而用户所具备的属性应该有：用户登录账号（用户名、密码）、用户使用系统时个性化（昵称、头像）、用户的个人信息（邮箱、手机号码、地址、年龄）。

        同时对于权限属性应该有：权限、许可（对于权限属性分析具备两个属性，需求分析见权限类）。

        基于此，实体类User的创建：

        属性值：

                a.数据库表主键：数据库对应的id；

                b.基础属性：用户名username、用户密码password、用户昵称nickName、用户邮箱email、用户手机号码phone、用户头像avatar、用户地址address、用户年龄age；

                c.权限属性：权限role、许可premission。

（2）源码：

  1. package com.example.system.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.baomidou.mybatisplus.extension.activerecord.Model;
  8. import com.example.system.common.handle.ListHandler;
  9. import lombok.Data;
  10.  
  11. import java.util.List;
  12.  
  13. /**
  14.  * 用户：访问系统需要具备一个的身份
  15.  */
  16.  
  17. @Data
  18. @TableName(value = "user", autoResultMap = true)
  19. public class User extends Model<User> {
  20.  
  21.     /**
  22.      * 主键
  23.      */
  24.     @TableId(value = "id", type = IdType.AUTO)
  25.     private long id;
  26.  
  27.     private String username;
  28.     private String password;
  29.     private String nickName;
  30.     private String email;
  31.     private String phone;
  32.     private String avatar;
  33.     private String address;
  34.     private Integer age;
  35.  
  36.     // 设置权限
  37.     @TableField(typeHandler = ListHandler.class)
  38.     private List<Long> role;
  39.  
  40.     @TableField(exist = false)
  41.     private List<Permission> permission;
  42.  
  43. }

2.权限类Role

（1）需求分析

        不同用户访问系统，所能够访问的功能应有所不同，因此需要给用户添加权限设置；系统功能可添加删除，具备多样性，可面向不同用户，因此权限类不是指用户具有的访问不同功能的权限，而是一个权限角色；对于许多的功能，为了完成不同用户访问功能时的限制，给予不同功能设置许可；而对于权限角色，则是不同权限角色具备一定的功能许可；为角色添加限制时，是为角色绑定上权限角色，从而获取所绑定的权限角色所具有的许可，以此具备访问功能的权限。

        属性值：

                a.数据库表主键：数据库对应的id；

                b.权限角色的名字：name；

                c.对权限角色的描述：description；

                d.具有的功能许可：permission。

（2）源码

  1. package com.example.system.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.baomidou.mybatisplus.extension.activerecord.Model;
  8. import com.example.system.common.handle.ListHandler;
  9. import lombok.Data;
  10.  
  11. import java.util.List;
  12.  
  13. /**
  14.  * 权限角色：用户访问系统内部不同功能。需要具备不同权限，设置不同的权限角色，具备不同功能所需要的许可；
  15.  * <p>具体解释</p>
  16.  * 访问功能 ----> 需要权限 ----> 权限角色具备一定的许可 ---->
  17.  *     用户被设定为权限角色 ----> 用户具备权限角色所具备的权限许可 ----> 用户得以访问功能
  18.  */
  19.  
  20. @Data
  21. @TableName(value = "role", autoResultMap = true)
  22. public class Role extends Model<Role> {
  23.  
  24.     @TableId(value = "id", type = IdType.AUTO)
  25.     public Long id;
  26.  
  27.     private String name;
  28.     private String description;
  29.  
  30.     @TableField(typeHandler = ListHandler.class)
  31.     private List<Long> permission;
  32.  
  33. }

3.许可类Premission

（1）需求分析

        根据对系统用户的权限的需求分析，了解到需要对用户访问系统的功能添加许可，再利用权限角色间接限制用户对系统功能的访问。

        属性值：

                a.数据库表主键：数据库对应的id；

                b.许可所对应的功能名字：name；

                c.对改功能的描述：description；

                d.访问路径：path；

                e.权限图片：icon；

（2）源码

  1. package com.example.system.entity;
  2.  
  3. import com.baomidou.mybatisplus.annotation.IdType;
  4. import com.baomidou.mybatisplus.annotation.TableId;
  5. import com.baomidou.mybatisplus.annotation.TableName;
  6. import com.baomidou.mybatisplus.extension.activerecord.Model;
  7. import lombok.Data;
  8.  
  9. /**
  10.  * 权限的许可：具备许可的权限角色能够访问对应的功能
  11.  */
  12.  
  13. @Data
  14. @TableName("permission")
  15. public class Permission extends Model<Permission> {
  16.  
  17.     /**
  18.      * 主键
  19.      */
  20.     @TableId(value = "id", type = IdType.AUTO)
  21.     private Long id;
  22.  
  23.     private String name;
  24.     private String path;
  25.     private String description;
  26.     private String icon;
  27.  
  28. }

六、异常处理

1.CustomException类

        用户在访问系统时，并不总是能够完成网络的请求与响应，当发生运行时错误，应当有响应的错误提示信息。

  1. package com.example.system.exception;
  2.  
  3. /**
  4.  * 运行异常的处理
  5.  */
  6. public class CustomException extends RuntimeException {
  7.  
  8.     private String code; // 状态码
  9.     private String msg; // 信息
  10.  
  11.     public CustomException(String code, String msg) {
  12.         this.code = code;
  13.         this.msg = msg;
  14.     }
  15.  
  16.     public String getCode() {
  17.         return code;
  18.     }
  19.  
  20.     public void setCode(String code) {
  21.         this.code = code;
  22.     }
  23.  
  24.     public String getMsg() {
  25.         return msg;
  26.     }
  27.  
  28.     public void setMsg(String msg) {
  29.         this.msg = msg;
  30.     }
  31.  
  32. }

2.GlobalExceptionHandler类

        全局异常统一处理

  1. package com.example.system.exception;
  2.  
  3. import cn.hutool.log.Log;
  4. import cn.hutool.log.LogFactory;
  5. import com.example.system.common.handle.Result;
  6. import org.springframework.validation.BindingResult;
  7. import org.springframework.validation.FieldError;
  8. import org.springframework.web.bind.MethodArgumentNotValidException;
  9. import org.springframework.web.bind.annotation.ControllerAdvice;
  10. import org.springframework.web.bind.annotation.ExceptionHandler;
  11. import org.springframework.web.bind.annotation.ResponseBody;
  12.  
  13. import javax.servlet.http.HttpServletRequest;
  14. import java.util.List;
  15.  
  16. /**
  17.  * 全局异常的统一处理
  18.  */
  19. @ControllerAdvice(basePackages="com.example.system.controller")
  20. public class GlobalExceptionHandler {
  21.  
  22.     private static final Log log = LogFactory.get();
  23.  
  24.     //统一异常处理@ExceptionHandler,主要用于Exception
  25.     @ExceptionHandler(Exception.class)
  26.     @ResponseBody//返回json串
  27.     public Result<?> error(HttpServletRequest request, Exception e){
  28.         log.error("异常信息：",e);
  29.         return Result.error("-1", "系统异常");
  30.     }
  31.  
  32.     // 方法参数无效异常
  33.     @ExceptionHandler(MethodArgumentNotValidException.class)
  34.     @ResponseBody//返回json串
  35.     public Result<?> notValidExceptionError(MethodArgumentNotValidException e){
  36.  
  37.         BindingResult result = e.getBindingResult();
  38.         StringBuilder errorMsg = new StringBuilder() ;
  39.  
  40.         // 提交错误信息
  41.         if (result.hasErrors()) {
  42.             List<FieldError> fieldErrors = result.getFieldErrors();
  43.             errorMsg.append(fieldErrors.get(fieldErrors.size() - 1).getDefaultMessage()).append("!");
  44.         }
  45.  
  46.         return Result.error("-1", errorMsg.toString());
  47.     }
  48.  
  49.     // 运行时异常
  50.     @ExceptionHandler(CustomException.class)
  51.     @ResponseBody//返回json串
  52.     public Result<?> customError(HttpServletRequest request, CustomException e){
  53.         return Result.error(e.getCode(), e.getMsg());
  54.     }
  55.  
  56. }

七、用户mapper层

        通过继承mybatis-plus的BaseMapper来完成接口的创建。

1.UserMapper类

  1. package com.example.system.mapper;
  2.  
  3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  4. import com.example.system.entity.User;
  5.  
  6. public interface UserMapper extends BaseMapper<User> {}

2.RoleMapper类

  1. package com.example.system.mapper;
  2.  
  3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  4. import com.example.system.entity.Role;
  5.  
  6. public interface RoleMapper extends BaseMapper<Role> {}

3.PermissionMapper类

  1. package com.example.system.mapper;
  2.  
  3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  4. import com.example.system.entity.Permission;
  5.  
  6. public interface PermissionMapper extends BaseMapper<Permission> {}

八、用户service层

1.UserService类

（1）需求分析

        用户进入系统访问系统功能，需要拥有一个系统认可的访问角色——用户user；而拥有一个这样的身份需要进行注册register；因为用户注册是面向用户的，仅需要用户提交一定的用户信息，此时需要系统自行对用户的权限进行设置getPermissions；当用户完成身份的注册后，访问系统需要进行登录login；最后，还需要确认用户名是否重复，进行对用户名的查询。

（2）源码

  1. package com.example.system.service;
  2.  
  3. import cn.hutool.core.collection.CollUtil;
  4. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
  5. import com.baomidou.mybatisplus.core.toolkit.Wrappers;
  6. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  7. import com.example.system.entity.Permission;
  8. import com.example.system.entity.Role;
  9. import com.example.system.entity.User;
  10. import com.example.system.exception.CustomException;
  11. import com.example.system.mapper.UserMapper;
  12. import org.springframework.stereotype.Service;
  13.  
  14. import javax.annotation.Resource;
  15. import java.util.ArrayList;
  16. import java.util.List;
  17.  
  18. @Service
  19. public class UserService extends ServiceImpl<UserMapper, User> {
  20.  
  21.     @Resource
  22.     private RoleService roleService;
  23.     @Resource
  24.     private PermissionService permissionService;
  25.  
  26.     /**
  27.      * 登录
  28.      *
  29.      * @param user
  30.      * @return
  31.      */
  32.     public User login(User user) {
  33.  
  34.         // 获取用户登录表单数据，并查询数据库
  35.         LambdaQueryWrapper<User> queryWrapper = Wrappers.<User>lambdaQuery().eq(User::getUsername, user.getUsername()).eq(User::getPassword, user.getPassword());
  36.         User one = getOne(queryWrapper);
  37.  
  38.         // 数据库中没有此数据
  39.         if (one == null) {
  40.             throw new CustomException("-1", "账号或密码错误");
  41.         }
  42.  
  43.         // 设置用户角色权限
  44.         one.setPermission(getPermissions(one.getId()));
  45.         return one;
  46.  
  47.     }
  48.  
  49.     /**
  50.      * 注册
  51.      *
  52.      * @param user
  53.      * @return
  54.      */
  55.     public User register(User user) {
  56.  
  57.         // 获取表单数据，并查询数据库
  58.         User one = getOne((Wrappers.<User>lambdaQuery().eq(User::getUsername, user.getUsername())));
  59.  
  60.         // 数据库有此数据
  61.         if (one != null) {
  62.             throw new CustomException("-1", "用户已注册");
  63.         }
  64.  
  65.         // 未设置密码，默认设置123456
  66.         if (user.getPassword() == null) {
  67.             user.setPassword("123456");
  68.         }
  69.  
  70.         // 默认普通用户角色
  71.         user.setRole(CollUtil.newArrayList(2L));
  72.         save(user);
  73.  
  74.         return getOne((Wrappers.<User>lambdaQuery().eq(User::getUsername, user.getUsername())));
  75.  
  76.     }
  77.  
  78.     /**
  79.      * 设置权限
  80.      *
  81.      * @param userId
  82.      * @return
  83.      */
  84.     public List<Permission> getPermissions(Long userId) {
  85.  
  86.         // 查询此用户，获得用户的权限角色
  87.         User user = getById(userId);
  88.         List<Long> role = user.getRole();
  89.  
  90.         // 创建空许可对象
  91.         List<Permission> permissions = new ArrayList<>();
  92.  
  93.         // 判断，用户的权限角色所具备的许可，与权限角色id对应库中的权限角色的许可，少则添加
  94.         if (role != null) {
  95.             for (Object roleId : role) {
  96.                 Role realRole = roleService.getById((int) roleId);
  97.                 if (CollUtil.isNotEmpty(realRole.getPermission())) {
  98.                     for (Object permissionId : realRole.getPermission()) {
  99.                         Permission permission = permissionService.getById((int) permissionId);
  100.                         if (permission != null && permissions.stream().noneMatch(p -> p.getPath().equals(permission.getPath()))) {
  101.                             permissions.add(permission);
  102.                         }
  103.                     }
  104.                 }
  105.             }
  106.             // 将许可分配给用户
  107.             user.setPermission(permissions);
  108.         }
  109.  
  110.         return permissions;
  111.  
  112.     }
  113.  
  114.     /**
  115.      * 根据用户名查询
  116.      *
  117.      * @param username
  118.      * @return
  119.      */
  120.     public User getByUsername(String username) {
  121.  
  122.         // 获取用户名
  123.         User one = getOne((Wrappers.<User>lambdaQuery().eq(User::getUsername, username)));
  124.  
  125.         // 设置权限
  126.         one.setPermission(getPermissions(one.getId()));
  127.  
  128.         return one;
  129.  
  130.     }
  131.  
  132. }

2.RoleService类

  1. package com.example.system.service;
  2.  
  3. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  4. import com.example.system.entity.Role;
  5. import com.example.system.mapper.RoleMapper;
  6. import org.springframework.stereotype.Service;
  7.  
  8. @Service
  9. public class RoleService extends ServiceImpl<RoleMapper, Role> { }

3.PermissionService类

（1）需求分析

        功能许可类，根据权限角色查询功能的许可；重新分配权限事务。

（2）源码

  1. package com.example.system.service;
  2.  
  3. import cn.hutool.core.collection.CollUtil;
  4. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  5. import com.example.system.entity.Permission;
  6. import com.example.system.entity.Role;
  7. import com.example.system.mapper.PermissionMapper;
  8. import org.springframework.stereotype.Service;
  9. import org.springframework.transaction.annotation.Transactional;
  10.  
  11. import javax.annotation.Resource;
  12. import java.util.ArrayList;
  13. import java.util.List;
  14.  
  15. @Service
  16. public class PermissionService extends ServiceImpl<PermissionMapper, Permission> {
  17.  
  18.     @Resource
  19.     private RoleService roleService;
  20.  
  21.     /**
  22.      * 根据权限角色查询许可
  23.      *
  24.      * @param roles
  25.      * @return
  26.      */
  27.     public List<Permission> getByRoles(List<Role> roles) {
  28.  
  29.         // 新建空许可对象
  30.         List<Permission> permissions = new ArrayList<>();
  31.  
  32.         // 判断，权限角色所具备的许可，与其id对应的库中权限角色所具备的许可，少则添加
  33.         for (Role role : roles) {
  34.             Role r = roleService.getById(role.getId());
  35.             if (CollUtil.isNotEmpty(r.getPermission())) {
  36.                 for (Object permissionId : r.getPermission()) {
  37.                     Permission permission = getById((int) permissionId);
  38.                     if (permissions.stream().noneMatch(p -> p.getPath().equals(permission.getPath()))) {
  39.                         permissions.add(permission);
  40.                     }
  41.                 }
  42.             }
  43.         }
  44.  
  45.         return permissions;
  46.  
  47.     }
  48.  
  49.     @Transactional
  50.     public void delete(Long id) {
  51.  
  52.         // 删除角色分配的菜单
  53.         removeById(id);
  54.  
  55.         List<Role> list = roleService.list();
  56.  
  57.         // 重新分配权限
  58.         for (Role role : list) {
  59.             List<Long> newP = new ArrayList<>();
  60.             for (Object p : role.getPermission()) {
  61.                 Long pl = Long.valueOf(p + "");
  62.                 if (!id.equals(pl)) {
  63.                     newP.add(Long.valueOf(p + ""));
  64.                 }
  65.             }
  66.             role.setPermission(newP);
  67.             roleService.updateById(role);
  68.         }
  69.     }
  70.  
  71. }

九.用户controller层

1.UserController类

（1）需求分析

        首先，应当需要处理用户的登录login；其次，应当需要处理用户的注册register；然后还有，用户退出系统的logout；用户的查询（在线、所有、根据id、根据用户名、分页）；用户的增删改查。

（2）源码

  1. package com.example.controller;
  2.  
  3. import cn.hutool.core.collection.CollUtil;
  4. import cn.hutool.core.io.FileUtil;
  5. import cn.hutool.core.io.IoUtil;
  6. import cn.hutool.core.util.StrUtil;
  7. import cn.hutool.poi.excel.ExcelUtil;
  8. import cn.hutool.poi.excel.ExcelWriter;
  9. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
  10. import com.baomidou.mybatisplus.core.metadata.IPage;
  11. import com.baomidou.mybatisplus.core.toolkit.Wrappers;
  12. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
  13. import com.example.common.Result;
  14. import com.example.entity.User;
  15. import com.example.exception.CustomException;
  16. import com.example.service.LogService;
  17. import com.example.service.UserService;
  18. import org.springframework.web.bind.annotation.*;
  19.  
  20. import javax.annotation.Resource;
  21. import javax.servlet.ServletOutputStream;
  22. import javax.servlet.http.HttpServletRequest;
  23. import javax.servlet.http.HttpServletResponse;
  24. import java.io.IOException;
  25. import java.net.URLEncoder;
  26. import java.util.*;
  27. import java.util.concurrent.ConcurrentHashMap;
  28.  
  29. @RestController
  30. @RequestMapping("/api/user")
  31. public class UserController {
  32.     public static final ConcurrentHashMap<String, User> MAP = new ConcurrentHashMap<>();
  33.  
  34.     @Resource
  35.     private UserService userService;
  36.  
  37.     @Resource
  38.     private LogService logService;
  39.     @Resource
  40.     private HttpServletRequest request;
  41.  
  42.     public User getUser() {
  43.         User user = (User) request.getSession().getAttribute("user");
  44.         if (user == null) {
  45.             throw new CustomException("-1", "请登录");
  46.         }
  47.         return user;
  48.     }
  49.  
  50.  
  51.     /**
  52.      * 登录
  53.      *
  54.      * @param user
  55.      * @param request
  56.      * @return
  57.      */
  58.     @PostMapping("/login")
  59.     public Result<User> login(@RequestBody User user, HttpServletRequest request) {
  60.         User res = userService.login(user);
  61.         request.getSession().setAttribute("user", res);
  62.         MAP.put(res.getUsername(), res);
  63.  
  64.         logService.log(StrUtil.format("用户 {} 登录系统", user.getUsername()));
  65.         return Result.success(res);
  66.     }
  67.  
  68.     /**
  69.      * 注册
  70.      *
  71.      * @param user
  72.      * @param request
  73.      * @return
  74.      */
  75.     @PostMapping("/register")
  76.     public Result<User> register(@RequestBody User user, HttpServletRequest request) {
  77.         if (user.getPassword() == null) {
  78.             user.setPassword("123456");
  79.         }
  80.         User dbUser = userService.register(user);
  81.         request.getSession().setAttribute("user", user);
  82.  
  83.         logService.log(StrUtil.format("用户 {} 注册账号成功", user.getUsername()));
  84.         return Result.success(dbUser);
  85.     }
  86.  
  87.     @GetMapping("/logout")
  88.     public Result<?> logout(HttpServletRequest request) {
  89.         User user = (User) request.getSession().getAttribute("user");
  90.         if (user != null) {
  91.             logService.log(StrUtil.format("用户 {} 退出系统", user.getUsername()));
  92.             request.getSession().removeAttribute("user");
  93.             MAP.remove(user.getUsername());
  94.         }
  95.         return Result.success();
  96.     }
  97.  
  98.     @GetMapping("/online")
  99.     public Result<Collection<User>> online(HttpServletRequest request) {
  100.         return Result.success(MAP.values());
  101.     }
  102.  
  103.     @GetMapping("/session")
  104.     public Result<User> session() {
  105.         return Result.success(getUser());
  106.     }
  107.  
  108.     @PostMapping
  109.     public Result<?> save(@RequestBody User user) {
  110.         if (user.getPassword() == null) {
  111.             user.setPassword("123456");
  112.         }
  113.         logService.log(StrUtil.format("新增用户：{} ", user.getUsername()));
  114.         return Result.success(userService.save(user));
  115.     }
  116.  
  117.     @PutMapping
  118.     public Result<?> update(@RequestBody User user) {
  119.         logService.log(StrUtil.format("更新用户：{} ", user.getUsername()));
  120.         return Result.success(userService.updateById(user));
  121.     }
  122.  
  123.     @DeleteMapping("/{id}")
  124.     public Result<?> delete(@PathVariable Long id) {
  125.         User user = userService.getById(id);
  126.         logService.log(StrUtil.format("删除用户 {} ", user.getUsername()));
  127.  
  128.         userService.removeById(id);
  129.         return Result.success();
  130.     }
  131.  
  132.     @GetMapping("/{id}")
  133.     public Result<User> findById(@PathVariable Long id) {
  134.         return Result.success(userService.getById(id));
  135.     }
  136.  
  137.     @GetMapping("/detail/{username}")
  138.     public Result<User> findByUsername(@PathVariable String username) {
  139.         return Result.success(userService.getbyUsername(username));
  140.     }
  141.  
  142.     @GetMapping
  143.     public Result<List<User>> findAll() {
  144.         return Result.success(userService.list( Wrappers.<User>lambdaQuery().ne(User::getUsername, "admin")));
  145.     }
  146.  
  147.     @GetMapping("/page")
  148.     public Result<IPage<User>> findPage(@RequestParam(required = false, defaultValue = "") String name,
  149.                                         @RequestParam(required = false, defaultValue = "1") Integer pageNum,
  150.                                         @RequestParam(required = false, defaultValue = "10") Integer pageSize) {
  151.         LambdaQueryWrapper<User> wrapper = Wrappers.<User>lambdaQuery().ne(User::getUsername, "admin").like(User::getUsername, name).orderByDesc(User::getId);
  152.         return Result.success(userService.page(new Page<>(pageNum, pageSize), wrapper));
  153.     }
  154.  
  155.     @GetMapping("/export")
  156.     public void export(HttpServletResponse response) throws IOException {
  157.  
  158.         List<Map<String, Object>> list = CollUtil.newArrayList();
  159.  
  160.         List<User> all = userService.list();
  161.         for (User user : all) {
  162.             Map<String, Object> row1 = new LinkedHashMap<>();
  163.             row1.put("名称", user.getUsername());
  164.             row1.put("手机", user.getPhone());
  165.             row1.put("邮箱", user.getEmail());
  166.             list.add(row1);
  167.         }
  168.  
  169.         // 2. 写excel
  170.         ExcelWriter writer = ExcelUtil.getWriter(true);
  171.         writer.write(list, true);
  172.  
  173.         response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=utf-8");
  174.         String fileName = URLEncoder.encode("用户信息", "UTF-8");
  175.         response.setHeader("Content-Disposition", "attachment;filename=" + fileName + ".xlsx");
  176.  
  177.         ServletOutputStream out = response.getOutputStream();
  178.         writer.flush(out, true);
  179.         writer.close();
  180.         IoUtil.close(System.out);
  181.     }
  182.  
  183.     @GetMapping("/upload/{fileId}")
  184.     public Result<?> upload(@PathVariable String fileId) {
  185.         String basePath = System.getProperty("user.dir") + "/src/main/resources/static/file/";
  186.         List<String> fileNames = FileUtil.listFileNames(basePath);
  187.         String file = fileNames.stream().filter(name -> name.contains(fileId)).findAny().orElse("");
  188.         List<List<Object>> lists = ExcelUtil.getReader(basePath + file).read(1);
  189.         List<User> saveList = new ArrayList<>();
  190.         for (List<Object> row : lists) {
  191.             User user = new User();
  192.             user.setUsername((String) row.get(0));
  193.             user.setNickName((String) row.get(1));
  194.             user.setEmail((String) row.get(2));
  195.             user.setPhone((String) row.get(3));
  196.             saveList.add(user);
  197.         }
  198.         userService.saveBatch(saveList);
  199.         return Result.success();
  200.     }
  201.  
  202. }

2.RoleController类

（1）需求分析

        权限角色的增删改查；权限角色的查询（根据id、所有、分页）。

（2）源码

  1. package com.example.system.controller;
  2.  
  3. import com.baomidou.mybatisplus.core.metadata.IPage;
  4. import com.baomidou.mybatisplus.core.toolkit.Wrappers;
  5. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
  6. import com.example.system.common.handle.Result;
  7. import com.example.system.entity.Role;
  8. import com.example.system.service.RoleService;
  9. import org.springframework.web.bind.annotation.*;
  10.  
  11. import javax.annotation.Resource;
  12. import java.util.List;
  13.  
  14. @RestController
  15. @RequestMapping("/api/role")
  16. public class RoleController {
  17.     @Resource
  18.     private RoleService roleService;
  19.  
  20.     /**
  21.      * 增加权限角色
  22.      *
  23.      * @param role
  24.      * @return
  25.      */
  26.     @PostMapping
  27.     public Result<?> save(@RequestBody Role role) {
  28.         return Result.success(roleService.save(role));
  29.     }
  30.  
  31.     /**
  32.      * 更新权限角色
  33.      *
  34.      * @param role
  35.      * @return
  36.      */
  37.     @PutMapping
  38.     public Result<?> update(@RequestBody Role role) {
  39.         return Result.success(roleService.updateById(role));
  40.     }
  41.  
  42.     /**
  43.      * 根据id删除权限角色
  44.      *
  45.      * @param id
  46.      * @return
  47.      */
  48.     @DeleteMapping("/{id}")
  49.     public Result<?> delete(@PathVariable Long id) {
  50.  
  51.         roleService.removeById(id);
  52.         return Result.success();
  53.  
  54.     }
  55.  
  56.     /**
  57.      * 根据id查询
  58.      *
  59.      * @param id
  60.      * @return
  61.      */
  62.     @GetMapping("/{id}")
  63.     public Result<Role> findById(@PathVariable Long id) {
  64.         return Result.success(roleService.getById(id));
  65.     }
  66.  
  67.     /**
  68.      * 查询所有
  69.      *
  70.      * @return
  71.      */
  72.     @GetMapping
  73.     public Result<List<Role>> findAll() {
  74.         return Result.success(roleService.list());
  75.     }
  76.  
  77.     /**
  78.      * 分页查询
  79.      *
  80.      * @param name
  81.      * @param pageNum
  82.      * @param pageSize
  83.      * @return
  84.      */
  85.     @GetMapping("/page")
  86.     public Result<IPage<Role>> findPage(@RequestParam(required = false, defaultValue = "") String name,
  87.                                         @RequestParam(required = false, defaultValue = "1") Integer pageNum,
  88.                                         @RequestParam(required = false, defaultValue = "10") Integer pageSize) {
  89.         return Result.success(roleService.page(new Page<>(pageNum, pageSize), Wrappers.<Role>lambdaQuery().like(Role::getName, name)));
  90.     }
  91.  
  92. }

3.PermissionController类

（1）需求分析

        许可的增删改查；许可的查询（根据id、所有、分页、通过权限用户）。

（2）源码

  1. package com.example.system.controller;
  2.  
  3. import com.baomidou.mybatisplus.core.metadata.IPage;
  4. import com.baomidou.mybatisplus.core.toolkit.Wrappers;
  5. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
  6. import com.example.system.common.handle.Result;
  7. import com.example.system.entity.Permission;
  8. import com.example.system.entity.Role;
  9. import com.example.system.service.PermissionService;
  10. import org.springframework.web.bind.annotation.*;
  11.  
  12. import javax.annotation.Resource;
  13. import java.util.List;
  14.  
  15. @RestController
  16. @RequestMapping("/api/permission")
  17. public class PermissionController {
  18.     @Resource
  19.     private PermissionService permissionService;
  20.  
  21.     /**
  22.      * 新增许可
  23.      * 
  24.      * @param permission
  25.      * @return
  26.      */
  27.     @PostMapping
  28.     public Result<?> save(@RequestBody Permission permission) {
  29.         return Result.success(permissionService.save(permission));
  30.     }
  31.  
  32.     /**
  33.      * 更新许可
  34.      * 
  35.      * @param permission
  36.      * @return
  37.      */
  38.     @PutMapping
  39.     public Result<?> update(@RequestBody Permission permission) {
  40.         return Result.success(permissionService.updateById(permission));
  41.     }
  42.  
  43.     /**
  44.      * 删除许可
  45.      * 
  46.      * @param id
  47.      * @return
  48.      */
  49.     @DeleteMapping("/{id}")
  50.     public Result<?> delete(@PathVariable Long id) {
  51.         Permission permission = permissionService.getById(id);
  52.         permissionService.delete(id);
  53.         return Result.success();
  54.     }
  55.  
  56.     /**
  57.      * 根据id查询许可
  58.      * 
  59.      * @param id
  60.      * @return
  61.      */
  62.     @GetMapping("/{id}")
  63.     public Result<Permission> findById(@PathVariable Long id) {
  64.         return Result.success(permissionService.getById(id));
  65.     }
  66.  
  67.     /**
  68.      * 查询所有
  69.      * 
  70.      * @return
  71.      */
  72.     @GetMapping
  73.     public Result<List<Permission>> findAll() {
  74.         return Result.success(permissionService.list());
  75.     }
  76.  
  77.     /**
  78.      * 分页查询许可
  79.      * 
  80.      * @param name
  81.      * @param pageNum
  82.      * @param pageSize
  83.      * @return
  84.      */
  85.     @GetMapping("/page")
  86.     public Result<IPage<Permission>> findPage(@RequestParam(required = false, defaultValue = "") String name,
  87.                                               @RequestParam(required = false, defaultValue = "1") Integer pageNum,
  88.                                               @RequestParam(required = false, defaultValue = "10") Integer pageSize) {
  89.         return Result.success(permissionService.page(new Page<>(pageNum, pageSize), Wrappers.<Permission>lambdaQuery().like(Permission::getName, name)));
  90.     }
  91.  
  92.     /**
  93.      * 通过权限角色查询权限角色所拥有的许可
  94.      * 
  95.      * @param roles
  96.      * @return
  97.      */
  98.     @PostMapping("/getByRoles")
  99.     public Result<List<Permission>> getByRoles(@RequestBody List<Role> roles) {
  100.         return Result.success(permissionService.getByRoles(roles));
  101.     }
  102.  
  103. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/146595
推荐阅读
相关标签

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

  

闽ICP备14008679号