【Hibernate】Hibernate注解方式JPA(速成解析hibernate注解)

Hibernate注解方式JPA

文章目录

  • Hibernate注解方式JPA
    • JPA
      • hibernate配置文件简析:
    • 分类
      • 一、类级别注解
        • - @Entity:映射实体类
        • - @Entity(name="tableName")
        • - @Table(name="",catalog="",schema="")
        • - @Embeddable:
      • 二、属性级别注解
        • - **@Id**:
        • - **@GeneratedValue**
        • - **@Column**
        • - **@Embedded**
        • - **@EmbeddedId**
        • - **@Transient**
      • 三、映射关系注解
        • @OneToOne关系映射
          • 1. **通过外键的方式**
          • 2. **通过关联表的方式来保存一对一的关系。**
        • **@OneToMany 和 @ManyToOne**
        • 多对多 @ManyToMany

ORM映射文件之前使用的是配置方式,但是通过JPA规范,把ORM映射使用注解来替代配置方式。

JPA

  • 介绍

    JPA全称为Java persistence API,Java持久化API是Sun公司在Java EE5规范中提出的Java持久化接口。

    JPA吸取了目前Java持久化技术的优点,旨在规范、简化Java对象的持久化工作。使用JPA持久化对象,并不是依赖于某一个ORM框架。

  • JPA和Hibernate的关系

    • JPA是规范:JPA本质上就是一种ORM规范;
    • Hibernate是实现:Hibernate除了作为ORM框架之外,它也是一种JPA实现。
      【Hibernate】Hibernate注解方式JPA(速成解析hibernate注解)_第1张图片

hibernate配置文件简析:

【Hibernate】Hibernate注解方式JPA(速成解析hibernate注解)_第2张图片

分类

  • 类级别注解
  • 属性级别注解
  • 映射关系注解

一、类级别注解

- @Entity:映射实体类

- @Entity(name=“tableName”)

name: 可选,对应数据库中的一个表。若表名与实体类名相同,则可以省略。

注意:使用@Entity时,必须指定实体类的主键属性@Id;

- @Table(name="",catalog="",schema="")

@Entity配合使用,只能标注在实体的class定义处,表示实体对应的数据库表的信息。

name:可选,映射表的名称,默认表名和实体名称一致,只有在不一致的情况下需要指定表名。

catalog(目录): 可选,表示Catalog名称,默认为Catalog("")。

schema(模式): 可选,表示Schema名称,默认为Schema("")。

【Hibernate】Hibernate注解方式JPA(速成解析hibernate注解)_第3张图片
【Hibernate】Hibernate注解方式JPA(速成解析hibernate注解)_第4张图片

- @Embeddable:

表示一个非Entity类可以嵌入到另一个Entity类中作为属性而存在。(不作为一张表)

二、属性级别注解

- @Id:

  • 必须,定义了映射到数据库表的主键的属性,一个实体类可以有一个或者多个属性被映射为主键,可置于主键属性或者getXxxx()前。

    注意:如果有多个属性定义为主键属性,该实体类必须实现Serializable接口。

  • @SequenceGenerator

- @GeneratedValue

@GeneratedValue(strategy=GenerationType,generator="")
可选,用于定义主键生成策略。

strategy表示主键生成策略,取值有:

  1. GenerationType.AUTO:根据底层数据库自动选择(默认)

  2. GenerationType.INDENTITY:根据数据库的Identity字段生成

  3. GenerationType.SEQUENCE: 使用Sequence来决定主键的取值

  4. GenerationType.TABLE:使用指定表来决定主键取值,结合@TableGenerator使用

    【Hibernate】Hibernate注解方式JPA(速成解析hibernate注解)_第5张图片

- @Column

可将属性映射到列,使用该注解来覆盖默认值,@Column描述了数据库表中该字段的详细定义,这对于根据JPA注解生成数据库表结构的工具非常有作用。

常用属性:

name:可选,表示数据库表中该字段的名称,默认情形属性名称一致。

nullable:可选,表示该字段是否允许为null,默认为true。

unique:可选,表示该字段是否是唯一标识,默认为false。

length:可选,表示该字段的大小,仅对String类型的字段有效,默认值为255.(如果是主键不能使用默认值)

insertable:可选,表示在ORM框架执行插入操作时,该字段是否应出现insert语句中,默认为true。

updateable:可选,表示在ORM框架执行更新操作时,该字段是否应该出现在UPDATE语句中,默认为true。对于一经创建就不可以更改的字段,该属性非常有用,如对于birthday字段。

- @Embedded

是注释属性的,表示该属性的类是嵌入类。

使用该注解,就必须在嵌入类中使用@Embeddable。

- @EmbeddedId

使用嵌入式主键类实现复合主键。

嵌入式主键类必须实现Serializable接口,必须有默认的public无参数的构造方法、必须覆盖equals和hashCode方法。

  • @Lob

  • @Version

  • @Basic

- @Transient

可选,表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性,如果一个属性并非数据库表的字段映射,就务必将其标示为@Transient,否则ORM框架默认其注解为@Basic。

三、映射关系注解

  • @OneToOne关系映射

    JPA使用@OneToOne来标注一对一的关系。

    实体 People :用户。

    实体 Address:家庭住址。

    People 和 Address 是一对一的关系。

    这里用两种方式描述JPA的一对一关系。

    一种是通过外键的方式(一个实体通过外键关联到另一个实体的主键);

    另外一种是通过一张关联表来保存两个实体一对一的关系。

    1. 通过外键的方式

    people 表(id,name,sex,birthday,address_id

    address 表(id,phone,zipcode,address)

    People.java
    @Entity
    @Data
    public class People {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        @Column(name = "id", nullable = false)
        private Long id;//id
        @Column(name = "name", nullable = true, length = 20)
        private String name;//姓名
        @Column(name = "sex", nullable = true, length = 1)
        private String sex;//性别
        @Column(name = "birthday", nullable = true)
        private Timestamp birthday;//出生日期
        @OneToOne(cascade=CascadeType.ALL)//People是关系的维护端,当删除 people,会级联删除 address
        @JoinColumn(name = "address_id", referencedColumnName = "id")//people中的address_id字段参考address表中的id字段
        private Address address;//地址
    }
    

    关联的实体的主键一般是用来做外键的。但如果此时不想主键作为外键,则需要设置referencedColumnName属性。当然这里关联实体(Address)的主键 id 是用来做主键,所以这里第16行的 referencedColumnName = “id” 实际可以省略。

    Address.java
    @Entity
    @Data
    public class Address {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        @Column(name = "id", nullable = false)
        private Long id;//id
        @Column(name = "phone", nullable = true, length = 11)
        private String phone;//手机
        @Column(name = "zipcode", nullable = true, length = 6)
        private String zipcode;//邮政编码
        @Column(name = "address", nullable = true, length = 100)
        private String address;//地址
        //如果不需要根据Address级联查询People,可以注释掉
    //    @OneToOne(mappedBy = "address", cascade = {CascadeType.MERGE, CascadeType.REFRESH}, optional = false)
    //    private People people;
    }
     
    
2. 通过关联表的方式来保存一对一的关系。
 people 表(**id**,name,sex,birthday)

 address 表 (**id**,phone,zipcode,address)

 people_address (**people_id**,**address_id**)

 只需要创建 People 和 Address 两个实体。

 ```java
 People.java
 @Entity
 @Data
 public class People {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     @Column(name = "id", nullable = false)
     private Long id;//id
     @Column(name = "name", nullable = true, length = 20)
     private String name;//姓名
     @Column(name = "sex", nullable = true, length = 1)
     private String sex;//性别
     @Column(name = "birthday", nullable = true)
     private Timestamp birthday;//出生日期
     @OneToOne(cascade=CascadeType.ALL)//People是关系的维护端
     @JoinTable(name = "people_address",
             joinColumns = @JoinColumn(name="people_id"),
             inverseJoinColumns = @JoinColumn(name = "address_id"))//通过关联表保存一对一的关系
     private Address address;//地址
 }
 ```
  • @OneToMany 和 @ManyToOne

    实体 Author:作者。

    实体 Article:文章。

    Author 和 Article 是一对多关系(双向)。那么在JPA中,如何表示一对多的双向关联呢?

    JPA使用@OneToMany和@ManyToOne来标识一对多的双向关联。一端(Author)使用@OneToMany,多端(Article)使用@ManyToOne。

    在JPA规范中,一对多的双向关系由多端(Article)来维护。就是说多端(Article)为关系维护端,负责关系的增删改查。一端(Author)则为关系被维护端,不能维护关系。

    一端(Author)使用@OneToMany注释的mappedBy="author"属性表明Author是关系被维护端。

    多端(Article)使用@ManyToOne和@JoinColumn来注释属性 author,@ManyToOne表明Article是多端,@JoinColumn设置在article表中的关联字段(外键)。

    Author.java
    @Entity
    @Data
    public class Author {
        @Id // 主键
        @GeneratedValue(strategy = GenerationType.IDENTITY) // 自增长策略
        private Long id; //id
        @NotEmpty(message = "姓名不能为空")
        @Size(min=2, max=20)
        @Column(nullable = false, length = 20)
        private String name;//姓名
        @OneToMany(mappedBy = "author",cascade=CascadeType.ALL,fetch=FetchType.LAZY)
        //级联保存、更新、删除、刷新;延迟加载。当删除用户,会级联删除该用户的所有文章
        //拥有mappedBy注解的实体类为关系被维护端
         //mappedBy="author"中的author是Article中的author属性
        private List<Article> articleList;//文章列表
    }
    
    Article.java
    @Entity
    @Data
    public class Article {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY) // 自增长策略
        @Column(name = "id", nullable = false)
        private Long id;
        @NotEmpty(message = "标题不能为空")
        @Size(min = 2, max = 50)
        @Column(nullable = false, length = 50) // 映射为字段,值不能为空
        private String title;
        @Lob  // 大对象,映射 MySQL 的 Long Text 类型
        @Basic(fetch = FetchType.LAZY) // 懒加载
        @NotEmpty(message = "内容不能为空")
        @Size(min = 2)
        @Column(nullable = false) // 映射为字段,值不能为空
        private String content;//文章全文内容
        @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},optional=false)//可选属性optional=false,表示author不能为空。删除文章,不影响用户
        @JoinColumn(name="author_id")//设置在article表中的关联字段(外键)
        private Author author;//所属作者
    }
    

    最终生成的表结构

    article 表(id,title,conten,author_id)

    author 表(id,name)

    注意:

    关于级联,一定要注意,要在关系的维护端,即 One 端。

    比如 作者和文章,作者是One,文章是Many;文章和评论,文章是One,评论是Many。

    cascade = CascadeType.ALL 只能写在 One 端,只有One端改变Many端,不准Many端改变One端。

    特别是删除,因为 ALL 里包括更新,删除。

    如果删除一条评论,就把文章删了,那算谁的。所以,在使用的时候要小心。一定要在 One 端使用。

  • 多对多 @ManyToMany

    实体 User:用户。

    实体 Authority:权限。

    用户和权限是多对多的关系。一个用户可以有多个权限,一个权限也可以被很多用户拥有。

    JPA中使用@ManyToMany来注解多对多的关系,由一个关联表来维护。这个关联表的表名默认是:主表名+下划线+从表名。(主表是指关系维护端对应的表,从表指关系被维护端对应的表)。这个关联表只有两个外键字段,分别指向主表ID和从表ID。字段的名称默认为:主表名+下划线+主表中的主键列名,从表名+下划线+从表中的主键列名。

    注意:

    1、多对多关系中一般不设置级联保存、级联删除、级联更新等操作。

    2、可以随意指定一方为关系维护端,在这个例子中,我指定 User 为关系维护端,所以生成的关联表名称为: user_authority,关联表的字段为:user_id 和 authority_id。

    3、多对多关系的绑定由关系维护端来完成,即由 User.setAuthorities(authorities) 来绑定多对多的关系。关系被维护端不能绑定关系,即Game不能绑定关系。

    4、多对多关系的解除由关系维护端来完成,即由Player.getGames().remove(game)来解除多对多的关系。关系被维护端不能解除关系,即Game不能解除关系。

    5、如果 User 和 Authority 已经绑定了多对多的关系,那么不能直接删除 Authority,需要由 User 解除关系后,才能删除 Authority。但是可以直接删除 User,因为 User 是关系维护端,删除 User 时,会先解除 User 和 Authority 的关系,再删除 Authority。

    User.java
    @Entity
    @Data
    public class User {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
        @NotEmpty(message = "账号不能为空")
        @Size(min=3, max=20)
        @Column(nullable = false, length = 20, unique = true)
        private String username; // 用户账号,用户登录时的唯一标识
        @NotEmpty(message = "密码不能为空")
        @Size(max=100)
        @Column(length = 100)
        private String password; // 登录时密码
        @ManyToMany
        @JoinTable(name = "user_authority",joinColumns = @JoinColumn(name = "user_id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id"))
        //1、关系维护端,负责多对多关系的绑定和解除
        //2、@JoinTable注解的name属性指定关联表的名字,joinColumns指定外键的名字,关联到关系维护端(User)
        //3、inverseJoinColumns指定外键的名字,要关联的关系被维护端(Authority)
        //4、其实可以不使用@JoinTable注解,默认生成的关联表名称为主表表名+下划线+从表表名,
        //即表名为user_authority
        //关联到主表的外键名:主表名+下划线+主表中的主键列名,即user_id
        //关联到从表的外键名:主表中用于关联的属性名+下划线+从表的主键列名,即authority_id
        //主表就是关系维护端对应的表,从表就是关系被维护端对应的表
        private List<Author> authorList;
    }
    

    注意:如注释中所言,上面的第17-18行的@JoinTable可以省略,默认可以生成

    Authority.java
    @Entity
    @Data
    public class Authority {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Integer id;
        @Column(nullable = false)
        private String name; //权限名
        @ManyToMany(mappedBy = "authorList")
        private List<User> userList;
    }
    

测试:

//添加:
@SpringBootTest
@RunWith(SpringRunner.class)
public class UserRepositoryTest {
    @Autowired
    private UserRepository userRepository;
    @Autowired
    private AuthorityRepository authorityRepository;
    @Test
    public void saveAuthority() {
        Authority authority = new Authority();
        authority.setId(1);
        authority.setName("ROLE_ADMIN");
        authorityRepository.save(authority);
    }
    @Test
    public void saveUser() {
        User user = new User();
        user.setUsername("admin");
        user.setPassword("123456");
        Authority authority = authorityRepository.findById(1).get();
        List<Authority> authorityList = new ArrayList<>();
        authorityList.add(authority);
        user.setAuthorList(authorityList);
        userRepository.save(user);
    }
}
/*先运行 saveAuthority 添加一条权限记录,
然后运行 saveUser 添加一条用户记录,与此同时,user_authority 表中也自动插入了一条记录*/

//删除
@SpringBootTest
@RunWith(SpringRunner.class)
public class UserRepositoryTest {
    @Autowired
    private UserRepository userRepository;
    @Test
    public void deleteUser() {
        userRepository.deleteById(1L);
    }
}
//user 表中删除一条记录,同时 user_authority 能够级联删除一条记录

你可能感兴趣的:(后端,hibernate,JPA,注解)