Hibernate注解方式JPA（速成解析hibernate注解）

Hibernate注解方式JPA

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配置文件简析：

分类

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

一、类级别注解

• @Entity：映射实体类

• @Entity(name=“tableName”)
  name: 可选，对应数据库中的一个表。若表名与实体类名相同，则可以省略。
  注意：使用@Entity时，必须指定实体类的主键属性@Id；

• @Table（name="",catalog="",schema=""）
  @Entity配合使用，只能标注在实体的class定义处，表示实体对应的数据库表的信息。
  name：可选，映射表的名称，默认表名和实体名称一致，只有在不一致的情况下需要指定表名。
  catalog（目录）: 可选，表示Catalog名称，默认为Catalog("")。
  schema（模式）: 可选，表示Schema名称，默认为Schema("")。
  

• @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使用
     
• @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 两个实体。

     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
   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 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 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 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 能够级联删除一条记录