SpringBoot 入门（三）——数据持久化

后端一定得与数据打交道，所以一定会做数据持久化，在 SpringBoot 中提供的 JPA 的 Api，可以很方便的实现数据的 CRUD。

一添加依赖

在数据库部分，我使用的是 MySQL，所以在 pom 文件中需要添加如下依赖：

        <!-- MySQL 连接依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- Jpa 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

二定义实体类

需要持久化的实体类，可以通过注解很方便的定义，通过给实体类添加一些注解，SpringBoot 就会自动创建表，列的约束以及表之间的关系等。

下面定义一个用户类：

package com.qinshou.springbootdemo.bean;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 * Description:用户实体类
 * Author: QinHao
 * Date: 2019/7/26 9:01
 */
@Entity
@Table(name = "user")
public class UserBean {
    /**
     * 自增长 Id
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    /**
     * 用户名
     */
    @Column(name = "username")
    private String username;
    /**
     * 密码
     */
    @Column(name = "password")
    private String password;
    /**
     * 昵称
     */
    @Column(name = "nickname")
    private String nickname;
    /**
     * 生日
     */
    @Column(name = "birthday")
    private Long birthday;
}

运行程序后可以看到建表语句（如果配置文件中设置显示 SQL 语句的话）：

2.1 数据持久化常用的注解

1.@Entity

使用了该注解的实体类表示需要持久化到数据库，SpringBoot 会创建该实体类对应的数据库。

属性：

name：表名，如果不指定，则会用下划线命名法来转换类名作为表名。表名也可以使用 @Table 注解指定。

2.@Table

该注解用于表的定义。

属性：

name：表名，如果不指定，则会使用 @Entity 注解的表名命名规则。

catalog：数据库名，一般来说，数据库名是在数据库连接语句中指定的（也就是配置文件中），如果不指定该属性，则会使用连接语句中的数据库，如果指定了，则会在指定的数据库中创建该表，但如果指定的数据库不存在则会抛出异常。

schema：

uniqueConstraints：指定唯一约束，既可以指定单列约束也可以指定多列约束，如果是单列约束的时候，效果跟在 @Column 注解上指定 unique 属性一样。

indexes：指定索引，既可以指定单个索引约束也可以指定联合索引。

3.@UniqueConstraint

该属性用在 @Table 注解的 uniqueConstraints 属性中，用于指定约束。

属性：

name：约束名，如果不指定则随机生成。

columnNames：约束的参考列，如果指定的列名不存在则会抛出异常。

4.@Index

该属性用在 @Table 注解的 indexes属性中，用于指定索引。

属性：

name：索引名，如果不指定则随机生成。

columnNames：索引的参考列，如果指定的列名不存在则会抛出异常。

unique：是否唯一，如果为 true，则效果跟使用 @UniqueConstraint 注解一样。

5.@Id

该注解用于标识该属性为主键

6.@GeneratedValue

该注解用于指定主键生成策略。

属性：

strategy：主键生成策略，可选值有：

1）TABLE：使用一个特定的数据库表格来保存主键，持久化引擎通过关系数据库的一张特定的表格来生成主键。

2）SEQUENCE：在某些数据库中，不支持主键自增长，比如 Oracle，所以提供了一种“序列”的机制来生成主键。

3）IDENTITY：主键自增长，相当于 MySQL 中的 AUTO_INCREMENT。

4）AUTO：主键生成策略交给持久化引擎决定。

generator：主键生成器的名称。

7.@Column

该注解用于列的定义。

属性：

name：列名，如果不指定，则会用下划线命名法来转换属性名作为列名。

unique：是否唯一。

nullable：是否可以为空。

insertable：使用 “INSERT” 脚本插入数据时，是否需要插入该字段的值。

updatable：使用 “UPDATE” 脚本插入数据时，是否需要插入该字段的值。

columnDefinition：自定义列的 DDL，在有一些个性化需求的时候会用到，如 “TEXT”，”NOT NULL” 等。

table：当映射多个表时，指定表的表中的字段。默认值为主表的表名。

length：指定字段的长度。

precision：当字段类型为 double 时，表示数值的总长度

scale：当字段类型为 double 时，表示小数点所占的位数。

三表与表的关系

表与表之间的关系只有三种，一对一，一对多和多对多。这三种关系都可能用到一个注解 @JoinColumn。

@JoinColumn：该注解用于指定关联列。如果不使用该注解的话有可能会生成一些中间表。

属性：

name：用于指定外键的名称。

分别用几个例子来说明一下这几种关系用到的注解。

3.1 一对一

用户实体类：

package com.qinshou.springbootdemo.bean;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;

/**
 * Description:用户实体类
 * Author: QinHao
 * Date: 2019/7/26 9:01
 */
@Entity()
@Table(name = "user")
public class UserBean {
    /**
     * 自增长 Id
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;
    /**
     * 用户名
     */
    @Column(name = "username")
    private String username;
    /**
     * 密码
     */
    @Column(name = "password")
    private String password;
    /**
     * 昵称
     */
    @Column(name = "nickname")
    private String nickname;
    /**
     * 生日
     */
    @Column(name = "birthday")
    private Long birthday;
    /**
     * 驾照
     */
    @JoinColumn(name = "driving_license_id")
    @OneToOne(cascade = CascadeType.ALL,orphanRemoval = true)
    private DrivingLicenseBean mDrivingLicenseBean;

    ...
}

驾照实体类：

package com.qinshou.springbootdemo.bean;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;

/**
 * Description:驾照实体类
 * Author: QinHao
 * Date: 2019/7/26 15:08
 */
@Entity
@Table(name = "driving_license")
public class DrivingLicenseBean {
    /**
     * 自增长 Id
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;
    /**
     * 编号
     */
    @Column(name = "number")
    private String number;
    /**
     * 用户
     */
    @OneToOne(mappedBy = "mDrivingLicenseBean")
    private UserBean mUserBean;

    @Override
    public String toString() {
        return "DrivingLicenseBean{" +
                "id=" + id +
                ", number='" + number + '\'' +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public UserBean getUserBean() {
        return mUserBean;
    }

    public void setUserBean(UserBean userBean) {
        mUserBean = userBean;
    }
}

@OneToOne

该注解表示一对一关系，如一个丈夫对应一个妻子，一个人对应一本驾照等。

属性：

targetEntity：对应实体类的 class，如果不指定该属性则会是 @OneToOne 注解修饰的成员变量的 class。一般不用指定。

cascade：级联关系，如果该属性指定得不对，在做对应操作时会抛出异常。级联关系通常在维护关系的一方中设置。

1）CascadeType.PERSIST：级联插入。

2）CascadeType.REMOVE：级联删除。

3）CascadeType.REFRESH：级联刷新，这个刷新不同于更新，是每次操作一方时，会先重新查询一下另一方的数据的意思。

4）CascadeType.MERGE：级联更新。

4）CascadeType.ALL：以上四种全部操作。

fetch：对应实体类的加载方式。

1）FetchType.EAGER：默认方式，查询时也立即把对应另一方的数据查询出来。

2）FetchType.LAZY：懒加载，什么时候用到了什么时候才会查询另一方的数据。

optional：表示对应实体类是否可以存在 null 值，true 表示可以，false 表示不可以。

mapperBy：用在被维护方，设置了该属性后，被维护方的表就不会生成对应列，注意该属性的值必须是维护方中指定被维护方的变量名，如上方的 mDrivingLicenseBean。

orphanRemoval：是否删除孤儿数据，设置为 true 时，当被维护方的数据没有被维护方关联时会自动删除，比如当一个人的驾照更新，这个人会与新的驾照数据建立关联，与旧的驾照数据也会解除关联，如果该属性为 true，则旧驾照的数据会自动删除。

3.2 一对多（多对一）

用户实体类：

package com.qinshou.springbootdemo.bean;

import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.Table;

/**
 * Description:用户实体类
 * Author: QinHao
 * Date: 2019/7/26 9:01
 */
@Entity()
@Table(name = "user")
public class UserBean {
    /**
     * 自增长 Id
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;
    /**
     * 用户名
     */
    @Column(name = "username")
    private String username;
    /**
     * 密码
     */
    @Column(name = "password")
    private String password;
    /**
     * 昵称
     */
    @Column(name = "nickname")
    private String nickname;
    /**
     * 生日
     */
    @Column(name = "birthday")
    private Long birthday;
    /**
     * 驾照
     */
    @JoinColumn(name = "driving_license_id")
    @OneToOne(cascade = CascadeType.ALL, orphanRemoval = true)
    private DrivingLicenseBean mDrivingLicenseBean;
    /**
     * 拥有的汽车
     */
    @JoinColumn(name = "user_id")
    @OneToMany(cascade = CascadeType.ALL)
    private List<CarBean> mCarBeanList;

    ...
}

汽车实体类：

package com.qinshou.springbootdemo.bean;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

/**
 * Description:汽车实体类
 * Author: QinHao
 * Date: 2019/7/26 14:29
 */
@Entity
@Table(name = "car")
public class CarBean {
    /**
     * 自增长 Id
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;
    /**
     * 品牌
     */
    @Column(name = "brand")
    private String brand;
    /**
     * 型号
     */
    @Column(name = "model")
    private String model;
    /**
     * 车主
     */
    @JoinColumn(name = "user_id")
    @ManyToOne()
    private UserBean user;

    ...
}

@OneToMany

该注解表示一对多中的一方，如一个人拥有多辆车，一个部门有多个员工等，通常“一”方也是维护关系的一方。它的各属性跟 @OneToOne 差不多，需要注意的是，使用了该注解的属性，应该也要使用 @JoinColumn 注解，并且 @JoinColumn 注解的 name 属性的值应该是一方的参考列，参考上面代码。

@ManyToOne

该注解表示一对多中的多方。它的各属性也跟 @OneToOne 差不多，需要注意的是，使用了该注解的属性，应该也要使用 @JoinColumn 注解，并且 @JoinColumn 注解的 name 属性的值应该是一方的参考列，参考上面代码，如果不加 @JoinColumn 注解则会多生成一张关系表。

3.3 多对多

老师实体类：

package com.qinshou.springbootdemo.bean;

import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

/**
 * Description:老师实体类
 * Author: QinHao
 * Date: 2019/7/31 9:31
 */
@Entity
@Table(name = "teacher")
public class TeacherBean {
    /**
     * 自增长 Id
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;
    /**
     * 姓名
     */
    @Column(name = "name")
    private String name;
    /**
     * 学生列表
     */
    @JoinTable(name = "teacher_student_rel"
            , joinColumns = {@JoinColumn(name = "teacher_id", referencedColumnName = "id")}
            , inverseJoinColumns = {@JoinColumn(name = "student_id", referencedColumnName = "id")})
    @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    private List<StudentBean> mStudentBeanList;

    public TeacherBean() {
    }

    public TeacherBean(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "TeacherBean{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", mStudentBeanList=" + mStudentBeanList +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<StudentBean> getStudentBeanList() {
        return mStudentBeanList;
    }

    public void setStudentBeanList(List<StudentBean> studentBeanList) {
        mStudentBeanList = studentBeanList;
    }
}

学生实体类：

package com.qinshou.springbootdemo.bean;

import java.util.List;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

/**
 * Description:学生实体类
 * Author: QinHao
 * Date: 2019/7/31 9:31
 */
@Entity
@Table(name = "student")
public class StudentBean {
    /**
     * 自增长 Id
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;
    /**
     * 姓名
     */
    @Column(name = "name")
    private String name;
    /**
     * 老师列表
     */
    @ManyToMany(fetch = FetchType.LAZY, mappedBy = "mStudentBeanList")
    private List<TeacherBean> mTeacherBeanList;

    public StudentBean() {
    }

    public StudentBean(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "StudentBean{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<TeacherBean> getTeacherBeanList() {
        return mTeacherBeanList;
    }

    public void setTeacherBeanList(List<TeacherBean> teacherBeanList) {
        mTeacherBeanList = teacherBeanList;
    }
}

@ManyToMany

该注解表示多对多关系，如一个老师可以有多个学生，一个学生也可以有多个老师；一个学生可以选多门选修课，一门选修课也可以被多个学生选。该注解和 @JoinTable 注解更配哦，@JoinTable 等一下记录。因为都是多方，所以两方都是使用 @ManyToMany 注解来标识，但是一般也会指定一个关系维护方，一般维护方会设置级联关系，加载方式是瞬时加载，@JoinTable 也是加在维护方的，而被维护方一般都是懒加载。

@JoinTable

该注解用于设置多对多关系的中间表，一般是关系维护方才会加该注解。

属性：

name：关系表的名字。

joinColumns：该属性用于指定自己这一方中在关系表的列。该属性的值是 @JoinColumn 注解数组，@JoinColumn 的 name 表示此方在关系表中的列名，referencedColumnName 表示关系表中外键的参考字段。

inverseJoinColumns：该属性指定对方在关系表的列，该属性的值跟 joinColumns 的值一样。

四小结

至此，数据持久化常用的注解基本就是这些，当然有了这些注解还不够，这只是利用注解定义了对应的表，还没有进行 CRUD 的操作，后面就会接着学习如何使用 JPA 来进行数据的 CRUD。

原文链接：https://blog.csdn.net/zgcqflqinhao/article/details/97368289

一 添加依赖

二 定义实体类