Spring Boot+Vue前后端分离项目练习01之网盘项目的搭建_springboot+vue+mybatisplus实现网盘

1.前期设计

一般看来，网盘系统主要实体包括：用户、存储信息、用户文件、文件、回收文件等基本功能点。

各实体对应的表结构如下所示：

表名：user（用户表）

表名：userfile （用户文件表）

表名：file （文件表）

表名：storage （存储信息表）

表名：recoveryfile （回收文件表）

2.创建项目

2.1 文件与用户

网盘系统主要功能就是对文件进行管理，因此这里就需要对网盘文件进行分类。

• 文件分为普通文件和目录文件。
• 普通文件是真实存在的，保存在磁盘上，因此它具有真实的文件路径和大小。
• 目录文件是虚拟的，它存在的目的是对普通文件进行分类归档。

在一个网盘系统中，首先实现用户登录，登录的用户就可以对文件进行管理，最主要的功能为：

• 文件的上传，删除，修改文件名，文件列表展示。
• 文件的移动，文件的复制等。

在一个网盘系统，一个用户可以拥有多个文件，一个文件被多个用户所拥有。

2.2 JPA建表

JPA（Java Persistence API)，中文名 Java 持久层 API，是 Java 持久化规范，这里可以使用这个工具，建立一个 Java 数据模型与数据库表结构之间的一种关系，并将 Java 的数据模型映射到数据库并建立数据库表结构。

2.2.1 添加依赖

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>


    <groupId>com.shiyanlou.file</groupId>
    <artifactId>qiwen-file</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>jar</packaging>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
    
</project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

2.2.2 添加配置文件

application.properties

spring.datasource.url=jdbc:mysql://localhost:3306/springboot-file
spring.datasource.username=root
spring.datasource.password=12345678

# 配置日志保存路径
logging.file.name=/Users/xuzhi/java-projects/java-WangPan/log
# 配置日志级别
logging.level.root=info

#jpa 配置
spring.jpa.properties.hibernate.hbm2ddl.auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.show-sql=true
spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.2.3 创建实体类

创建entity包，在该包下创建对应的实体类。
File.java

import lombok.Data;
import javax.persistence.*;

@Data
@Table(name = "file")
@Entity
public class File {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(columnDefinition="bigint(20) comment '文件id'")
    private Long fileId;

    @Column(columnDefinition="varchar(500) comment '时间戳名称'")
    private String timeStampName;

    @Column(columnDefinition="varchar(500) comment '文件url'")
    private String fileUrl;

    @Column(columnDefinition="bigint(10) comment '文件大小'")
    private Long fileSize;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

User.java

import lombok.Data;
import javax.persistence.*;

@Data
@Table(name = "user")
@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(columnDefinition = "bigint(20) comment '用户id'")
    private Long userId;

    @Column(columnDefinition = "varchar(30) comment '用户名'")
    private String username;

    @Column(columnDefinition = "varchar(35) comment '密码'")
    private String password;

    @Column(columnDefinition = "varchar(15) comment '手机号码'")
    private String telephone;

    @Column(columnDefinition = "varchar(20) comment '盐值'")
    private String salt;

    @Column(columnDefinition = "varchar(30) comment '注册时间'")
    private String registerTime;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

UserFile.java

import lombok.Data;
import javax.persistence.*;

@Data
@Table(name = "userfile", uniqueConstraints = {
        @UniqueConstraint(name = "fileindex", columnNames = {"fileName", "filePath", "extendName"})})
@Entity
public class UserFile {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(columnDefinition = "bigint(20) comment '用户文件id'")
    private Long userFileId;

    @Column(columnDefinition = "bigint(20) comment '用户id'")
    private Long userId;

    @Column(columnDefinition="bigint(20) comment '文件id'")
    private Long fileId;

    @Column(columnDefinition="varchar(100) comment '文件名'")
    private String fileName;

    @Column(columnDefinition="varchar(500) comment '文件路径'")
    private String filePath;

    @Column(columnDefinition="varchar(100) comment '扩展名'")
    private String extendName;

    @Column(columnDefinition="int(1) comment '是否是目录 0-否, 1-是'")
    private Integer isDir;

    @Column(columnDefinition="varchar(25) comment '上传时间'")
    private String uploadTime;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

在JPA中，主要的注解作用如下：

• @Entity 表明该类是一个实体类，添加了该注解后，才能被 jpa 扫描到
• @Table 可以自定义表名，让实体类的类名和数据库中表名进行对应
• @Id 用来声明主键
• @GeneratedValue 设置主键生成方式，主要有四种类型，这里将 strategy 属性设置为 GenerationType.IDENTITY，表明主键由数据库生成，为自动增长型
• @Column 可以自定义列名或者定义其他的数据类型

接着启动项目就会在数据库中创建对应的表。

3.整合MyBatis与MyBatis plus

在完整的项目中，一般会使用成熟的持久层框架来操作数据库，这里就选用mybatis和mybatis plus进行持久层操作。

3.1 添加依赖

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.1</version>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.1</version>
        </dependency>
1
2
3
4
5
6
7
8
9
10
11

3.2 添加配置

# mybatis配置
mybatis.config-location=classpath:mybatis/mybatis-config.xml
mybatis.mapper-locations=classpath:mybatis/mapper/*.xml

mybatis-plus.mapper-locations=classpath:mybatis/mapper/*.xml
mybatis-plus.configuration.map-underscore-to-camel-case=false
1
2
3
4
5
6

在启动类上添加@MapperScan注解，用于指定扫描的mapper接口。

3.3 创建mapper接口

创建mapper包，在该包下创建实体类对应的mapper接口。
FileMapper

public interface FileMapper {

}
1
2
3

UserfileMapper

public interface UserfileMapper {
    
}
1
2
3

UserMapper

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.picacho.entity.User;

import java.util.List;

public interface UserMapper extends BaseMapper<User> {
    void insertUser(User user);
    List<User> selectUser();
}
1
2
3
4
5
6
7
8
9

在 resources 文件夹下创建mybatis文件夹，并在该文件夹下创建配置文件 mybatis-config.xml ，该配置文件主要用来指定 MyBatis 基础配置文件和实体类映射文件的地址。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    <typeAliases>
        <typeAlias alias="Integer" type="java.lang.Integer" />
        <typeAlias alias="Long" type="java.lang.Long" />
        <typeAlias alias="HashMap" type="java.util.HashMap" />
        <typeAlias alias="LinkedHashMap" type="java.util.LinkedHashMap" />
        <typeAlias alias="ArrayList" type="java.util.ArrayList" />
        <typeAlias alias="LinkedList" type="java.util.LinkedList" />
    </typeAliases>
</configuration>
1
2
3
4
5
6
7
8
9
10
11
12
13

3.4 创建mapper对应的xml文件

在mybatis文件夹下创建mapper文件夹，在该文件夹下创建UserMapper.xml文件。

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.picacho.mapper.UserMapper">
    <insert id="insertUser" parameterType="com.picacho.entity.User">
        insert into user (username, password, telephone)
            value (#{username}, #{password}, #{telephone})
    </insert>

    <select id="selectUser" resultType="com.picacho.entity.User">
        select * from user
    </select>
</mapper>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.5 进行测试

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testInsert() {
        User user = new User();
        user.setUsername("picacho1");
        user.setPassword("123456");
        user.setTelephone("12345566789");
        userMapper.insertUser(user);
        
        System.out.println("数据库字段查询结果显示");
        List<User> list = userMapper.selectUser();
        list.forEach(System.out::println);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3.6 使用MyBatis Plus功能

在之前已经创建的三个实体类中，需要添加 MyBatis Plus相关注解，这里需要用到的注解有两个，分别是 @TableName 和 @TableId。

• @TableName(“表名”) 实体类添加，如果不添加，会按照默认规则进行表明的映射，比如 UserTable->user_table
• @TableId(type = IdType.AUTO) 用来标注实体类主键

使用mybatis plus自带的方法实现测试。

    @Test
    public void testInsert2() {
        User user = new User();
        user.setUsername("picacho2");
        user.setPassword("123456");
        user.setTelephone("123456678");
        userMapper.insert(user);
        List<User> list = userMapper.selectList(null);
        System.out.println("数据库字段查询结果显示");
        list.forEach(System.out::println);
    }
1
2
3
4
5
6
7
8
9
10
11

测试结果：

4.统一返回结果封装

在前后端分离的项目中，一般需要统一封装响应的结果。

首先就需要定义响应码对应的枚举类。创建common包，在该包下创建状态码枚举类ResultCodeEnum.java。

import lombok.Getter;

/**
 * 结果类枚举
 */
@Getter
public enum ResultCodeEnum {
    
    SUCCESS(true,200,"成功"),
    UNKNOWN_ERROR(false,201,"未知错误"),
    PARAM_ERROR(false,202,"参数错误"),
    NULL_POINT(false, 203, "空指针异常"),
    INDEX_OUT_OF_BOUNDS(false, 204, "下标越界异常"),
    ;

    // 响应是否成功
    private Boolean success;
    // 响应状态码
    private Integer code;
    // 响应信息
    private String message;

    ResultCodeEnum(boolean success, Integer code, String message) {
        this.success = success;
        this.code = code;
        this.message = message;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

接着需要创建统一结果返回类RestResult.java。

import lombok.Data;

/**
 * 统一结果返回
 *
 * @param <T>
 */
@Data
public class RestResult<T> {
    private Boolean success = true;
    private Integer code;
    private String message;
    private T data;

    // 通用返回成功
    public static RestResult success() {
        RestResult r = new RestResult();
        r.setSuccess(ResultCodeEnum.SUCCESS.getSuccess());
        r.setCode(ResultCodeEnum.SUCCESS.getCode());
        r.setMessage(ResultCodeEnum.SUCCESS.getMessage());
        return r;
    }

    // 通用返回失败，未知错误
    public static RestResult fail() {
        RestResult r = new RestResult();
        r.setSuccess(ResultCodeEnum.UNKNOWN_ERROR.getSuccess());
        r.setCode(ResultCodeEnum.UNKNOWN_ERROR.getCode());
        r.setMessage(ResultCodeEnum.UNKNOWN_ERROR.getMessage());
        return r;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

4.1 测试效果

添加控制器，测试通用统一返回结果的效果。创建controller包，在该包下创建控制器UserController.java。

import com.picacho.common.RestResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/user")
public class UserController {

    /**
     * 成功响应测试
     */
    @GetMapping(value="/testSuccess")
    @ResponseBody
    public RestResult testSuccess(){
        return RestResult.success();
    }

    /**
     * 失败响应测试
     */
    @GetMapping(value="/testFail")
    @ResponseBody
    public RestResult testFail(){
        return RestResult.fail();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

启动项目测试其效果：


这里返回通用的情况，但是有时候会有一种情况，我们需要给前端返回自定义消息的响应结果。因此需要在RestResult.java添加自定义的返回方法。

    // 自定义返回数据
    public RestResult data(T param) {
        this.setData(param);
        return this;
    }

    // 自定义状态信息
    public RestResult message(String message) {
        this.setMessage(message);
        return this;
    }

    // 自定义状态码
    public RestResult code(Integer code) {
        this.setCode(code);
        return this;
    }

    // 设置结果，形参为结果枚举
    public static RestResult setResult(ResultCodeEnum result) {
        RestResult r = new RestResult();
        r.setSuccess(result.getSuccess());
        r.setCode(result.getCode());
        r.setMessage(result.getMessage());
        return r;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

5.统一异常处理

对控制层进行切面拦截，当发生异常时就会执行异常处理类，在Spring Boot项目中创建统一异常处理类。

创建advice包，在该包下创建GlobalExceptionHandlerAdvice.java类。

import com.picacho.common.RestResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

@Slf4j
@ControllerAdvice
public class GlobalExceptionHandlerAdvice {
    
    /**-------- 通用异常处理方法 --------**/
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public RestResult error(Exception e) {
        e.printStackTrace();
        log.error("全局异常捕获：" + e);

        return RestResult.fail();    // 通用异常结果
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在全局异常处理中，主要使用以下三个注解。

• @ControllerAdvice 这是一个增强的 Controller。使用这个 Controller ，可以实现三个方面的功能：1、全局异常处理， 2、全局数据绑定， 3、全局数据预处理
• @ExceptionHandler 该注解用来指明异常的处理类型
• @ResponseBody 该注解为 Spring Boot 响应体注解，用在这里的目的就是当出现异常时，直接将错误返回给前台

这里除了可以处理Exception异常，也可以处理其他异常或者自定义异常。

    /**
     * 处理空指针异常
     * @param e
     * @return
     */
    @ExceptionHandler(NullPointerException.class)
    @ResponseBody
    public RestResult error(NullPointerException e) {
        e.printStackTrace();
        log.error("全局异常捕获：" + e);
        return RestResult.setResult(ResultCodeEnum.NULL_POINT);
    }

    /**
     * 越界异常
     * @param e
     * @return
     */
    @ExceptionHandler(IndexOutOfBoundsException.class)
    @ResponseBody
    public RestResult error(IndexOutOfBoundsException e) {
        e.printStackTrace();
        log.error("全局异常捕获：" + e);
        return RestResult.setResult(ResultCodeEnum.INDEX_OUT_OF_BOUNDS);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

在UserController.java中添加测试方法，测试异常处理效果：

    /**
     * 空指针异常响应测试
     */
    @GetMapping(value="/testNullException")
    @ResponseBody
    public RestResult testNullException(){
        String s = null;
        int index = s.length();
        return RestResult.success();
    }
1
2
3
4
5
6
7
8
9
10

项目demo源码下载地址：源码下载