Hibernate的注解方法的使用

1、配置映射关系的xml方式

我们知道，Hibernate是一个典型的ORM框架，用以解决对象和关系的不匹配。其思想就是将关系数据库中表的记录映射成为对象，以对象形式展现，这样一来，就可以把对数据库的操作转化为对对象的操作。

而ORM一般是采用xml的格式保存对象与关系数据表的映射，我们也可以从下面示例中看到hibernate中的一个映射配置表的表现形式：

<?xml version="1.0" encoding="utf-8"?> 
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
    <class name="com.zker.model.job.SysJob" table="SYS_JOB" lazy="true">
        <id name="jobId" column="JOB_ID">
            <generator class="sequence">
                <param name="sequence">SEQ_SYS_JOB</param>
            </generator>
        </id>
        <property name="jobName" type="string" column="JOB_NAME" />
        <property name="jobDesc" type="string" column="JOB_DESC" />
        <property name="lastModity" type="timestamp" column="LAST_MODIFY" />
        <!--与用户关联-->
        <set name="sysUsers" table="SYS_USER">
            <key column="JOB_ID" />
            <one-to-many class="com.zker.model.user.SysUser" />
        </set>

    </class>
</hibernate-mapping>

22

 

1

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

2

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

3

        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

4

5

<hibernate-mapping>

6

    <class name="com.zker.model.job.SysJob" table="SYS_JOB" lazy="true">

7

        <id name="jobId" column="JOB_ID">

8

            <generator class="sequence">

9

                <param name="sequence">SEQ_SYS_JOB</param>

10

            </generator>

11

        </id>

12

        <property name="jobName" type="string" column="JOB_NAME" />

13

        <property name="jobDesc" type="string" column="JOB_DESC" />

14

        <property name="lastModity" type="timestamp" column="LAST_MODIFY" />

15

        <!--与用户关联-->

16

        <set name="sysUsers" table="SYS_USER">

17

            <key column="JOB_ID" />

18

            <one-to-many class="com.zker.model.user.SysUser" />

19

        </set>

20

21

    </class>

22

</hibernate-mapping>

其中对应的实体类和数据库表结构如下：

public class SysJob {
    /**职位的主键ID*/
    private int jobId;

    /**职位的名称*/
    private String jobName;

    /**职位的描述*/
    private String jobDesc;

    /**职位的修改时间*/
    private Timestamp lastModity;

    /**职位所对应的用户*/
    private Set<SysUser> sysUsers = new HashSet<SysUser>();

    public int getJobId() {
        return jobId;
    }

    public void setJobId(int jobId) {
        this.jobId = jobId;
    }

    public String getJobName() {
        return jobName;
    }

    public void setJobName(String jobName) {
        this.jobName = jobName;
    }

    public String getJobDesc() {
        return jobDesc;
    }

    public void setJobDesc(String jobDesc) {
        this.jobDesc = jobDesc;
    }

    public Timestamp getLastModity() {
        return lastModity;
    }

    public void setLastModity(Timestamp lastModity) {
        this.lastModity = lastModity;
    }

    public Set<SysUser> getSysUsers() {
        return sysUsers;
    }

    public void setSysUsers(Set<SysUser> sysUsers) {
        this.sysUsers = sysUsers;
    }
}

56

 

1

public class SysJob {

2

    /**职位的主键ID*/

3

    private int jobId;

4

5

    /**职位的名称*/

6

    private String jobName;

7

8

    /**职位的描述*/

9

    private String jobDesc;

10

11

    /**职位的修改时间*/

12

    private Timestamp lastModity;

13

14

    /**职位所对应的用户*/

15

    private Set<SysUser> sysUsers = new HashSet<SysUser>();

16

17

    public int getJobId() {

18

        return jobId;

19

    }

20

21

    public void setJobId(int jobId) {

22

        this.jobId = jobId;

23

    }

24

25

    public String getJobName() {

26

        return jobName;

27

    }

28

29

    public void setJobName(String jobName) {

30

        this.jobName = jobName;

31

    }

32

33

    public String getJobDesc() {

34

        return jobDesc;

35

    }

36

37

    public void setJobDesc(String jobDesc) {

38

        this.jobDesc = jobDesc;

39

    }

40

41

    public Timestamp getLastModity() {

42

        return lastModity;

43

    }

44

45

    public void setLastModity(Timestamp lastModity) {

46

        this.lastModity = lastModity;

47

    }

48

49

    public Set<SysUser> getSysUsers() {

50

        return sysUsers;

51

    }

52

53

    public void setSysUsers(Set<SysUser> sysUsers) {

54

        this.sysUsers = sysUsers;

55

    }

56

}

 

2、注解的优点

而完成这个ORM映射关系配置的方式，还有一种，就是使用注解。

• 充分利用 Java 的反射机制获取类结构信息，这些信息可以有效减少配置的工作
• 注释和 Java 代码位于一个文件中，有助于增强程序的内聚性，便于程序员开发
  

我们可以看如下的一个示例来感受这种形式：

@Entity
@Table(name = "t_student")
@Domain(name = "学生")
@Generated
@DataIdentify(identifies = "number")
public class Student extends BaseDomain<Student> implements Addable, Modifiable<Student>, Deletable {
	private String name;
	private String number;
	private Sex sex;

	@Basic
	@NotSemanticNull(groups = {Groups.Add.class, Groups.Update.class})
	@Property(name = "姓名")
	public String getName() {
		return name;
	}

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

        ...

}

24

 

1

@Entity

2

@Table(name = "t_student")

3

@Domain(name = "学生")

4

@Generated

5

@DataIdentify(identifies = "number")

6

public class Student extends BaseDomain<Student> implements Addable, Modifiable<Student>, Deletable {

7

    private String name;

8

    private String number;

9

    private Sex sex;

10

11

    @Basic

12

    @NotSemanticNull(groups = {Groups.Add.class, Groups.Update.class})

13

    @Property(name = "姓名")

14

    public String getName() {

15

        return name;

16

    }

17

18

    public void setName(String name) {

19

        this.name = name;

20

    }

21

22

        ...

23

24

}

3、常用注解的使用方法

3.1 类级别的注解

• @Entity     映射实体类
  
• @Table      映射数句库表
  

@Entity(name = "tableName") - 必须，注解将一个类声明为一个实体bean，即指出该Java 类为实体类，将映射到指定的数据库表

• 属性：
  
• name - 可选，对应数据库中的一个表。若表名与实体类名相同，则可以省略
  

@Table(name = "", catalog = "", schema = "")  - 可选，通常和@Entity 配合使用，只能标注在实体的 class 定义处，表示实体对应的数据库表的信息

• 属性：
  
• name - 可选，表示表的名称，默认的表名和实体名称一致，只有在不一致的情况下才需要指定表名
  
• catalog - 可选，表示Catalog 名称，默认为 Catalog("")
  
• schema - 可选 , 表示 Schema 名称 , 默认为Schema("")
  

3.2 属性级别的注解

• @Id                                 映射生成主键
  
• @GeneratedValue         定义主键生成策略
  
• @SequenceGenerator  声明了一个数据库序列
  
• @Version                       定义乐观锁
  
• @Basic                           声明属性的存取策略
  
• @Column                       映射表的列
  
• @Transient                    定义暂态属性
  

属性级别的注解，都是放在其对应的getter前。

3.2.1 与主键相关注解

@Id - 必须，定义了映射到数据库表的主键的属性，一个实体只能有一个属性被映射为主键，置于 getXxx() 前

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

• 属性：
  
• strategy - 表示主键生成策略，取值有：
  
• GenerationType.AUTO 根据底层数据库自动选择（默认），若数据库支持自动增长类型，则为自动增长
• GenerationType.INDENTITY 根据数据库的Identity字段生成，支持DB2、MySQL、MS、SQL Server、SyBase与HyperanoicSQL数据库的Identity类型主键
• GenerationType.SEQUENCE 使用Sequence来决定主键的取值，适合Oracle、DB2等支持Sequence的数据库，一般结合@SequenceGenerator使用（Oracle没有自动增长类型，只能用Sequence）
• GenerationType.TABLE  使用指定表来决定主键取值，结合@TableGenerator使用
• generator - 表示主键生成器的名称，这个属性通常和ORM框架相关 , 例如：Hibernate 可以指定 uuid 等主键生成方式
  

@SequenceGenerator — 注解声明了一个数据库序列

• 属性：
  
• name - 表示该表主键生成策略名称，它被引用在@GeneratedValue中设置的“gernerator”值中
  
• sequenceName - 表示生成策略用到的数据库序列名称
  
• initialValue - 表示主键初始值，默认为0
  
• allocationSize - 每次主键值增加的大小，例如设置成1，则表示每次创建新记录后自动加1，默认为50
  

3.2.2 与非主键相关注解

@Version - 可以在实体bean中使用@Version注解，通过这种方式可添加对乐观锁定的支持（见参考链接）

@Basic - 用于声明属性的存取策略：

• @Basic(fetch=FetchType.EAGER)   即时获取（默认的存取策略）
  
• @Basic(fetch=FetchType.LAZY)       延迟获取
  

@Column - 可将属性映射到列，使用该注解来覆盖默认值，@Column描述了数据库表中该字段的详细定义

• 属性：
  
• name - 可选，表示数据库表中该字段的名称，默认情形属性名称一致
  
• nullable - 可选，表示该字段是否允许为 null，默认为 true
  
• unique - 可选，表示该字段是否是唯一标识，默认为 false
  
• length - 可选，表示该字段的大小，仅对 String 类型的字段有效，默认值255
  
• insertable - 可选，表示在ORM框架执行插入操作时，该字段是否应出现INSETRT语句中，默认为 true
  
• updateable - 可选，表示在ORM 框架执行更新操作时，该字段是否应该出现在UPDATE 语句中，默认为 true。对于一经创建就不可以更改的字段，该属性非常有用，如对于 birthday 字段
  
• columnDefinition - 可选，表示该字段在数据库中的实际类型。通常ORM 框架可以根据属性类型自动判断数据库中字段的类型，但是对于Date 类型仍无法确定数据库中字段类型究竟是 DATE,TIME 还是 TIMESTAMP. 此外 ,String 的默认映射类型为 VARCHAR, 如果要将 String 类型映射到特定数据库的 BLOB或 TEXT 字段类型，该属性非常有用
  

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

3.3 映射实体类的关联关系

单向一对多：一方有集合属性，包含多个多方，而多方没有一方的引用。用户--->电子邮件

单向多对一：多方有一方的引用，一方没有多方的引用。论文类别---> 类别

双向一对多：两边都有多方的引用，方便查询。班级---> 学生

双向多对一：两边都有多方的引用，方便查询。

单向多对多：需要一个中间表来维护两个实体表。论坛--->文章

单向一对一：数据唯一，数据库数据也是一对一。舰船---> 水手

主键相同的一对一：使用同一个主键，省掉外键关联。客户---> 地址

3.3.1 关联映射的一些共有属性

@JoinColumn - 可选，用于描述一个关联的字段。@JoinColumn和@Column类似，介量描述的不是一个简单字段，而是一个关联字段，例如描述一个 @ManyToOne 的字段。（即用来定义外键在我们这个表中的属性名，例如实体Order有一个User user属性来关联实体User，则Order的user属性为一个外键）

• 属性：
  
• name - 该字段的名称，由于@JoinColumn描述的是一个关联字段，如ManyToOne, 则默认的名称由其关联的实体决定
  

@OneToOne、@OneToMany、@ManyToOne、ManyToMany 的共有属性：

• fetch - 配置加载方式。取值有：
  
• Fetch.EAGER -  及时加载，多对一默认是Fetch.EAGER 
• Fetch.LAZY - 延迟加载，一对多默认是Fetch.LAZY
• cascade - 设置级联方式，取值有：
  
• CascadeType.PERSIST - 保存  - 调用JPA规范中的persist()，不适用于Hibernate的save()方法
• CascadeType.REMOVE - 删除  - 调用JPA规范中的remove()时，适用于Hibernate的delete()方法
• CascadeType.MERGE - 修改  - 调用JPA规范中merge()时，不适用于Hibernate的update()方法 
• CascadeType.REFRESH - 刷新  - 调用JPA规范中的refresh()时，适用于Hibernate的flush()方法
• CascadeType.ALL - 全部  - JPA规范中的所有持久化方法
• targetEntity - 配置集合属性类型，如：@OneToMany(targetEntity=Book.class)
  

@OneToOne – 表示一个一对一的映射

主表类A与从表类B的主键值相对应
主表：
@OneToOne(cascade = CascadeType.ALL)
@PrimaryKeyJoinColumn
public B getB(){
  return b;
}

从表：无   

9

 

1

主表类A与从表类B的主键值相对应

2

主表：

3

@OneToOne(cascade = CascadeType.ALL)

4

@PrimaryKeyJoinColumn

5

public B getB(){

6

  return b;

7

}

8

9

从表：无   

主表A中有一个从表属性是B类型的b
主表：
@OneToOne(cascade = CascadeType.ALL)
@JoinColumn(name="主表外键")   //这里指定的是数据库中的外键字段。
public B getB(){
  return b;
}

从表：无

9

 

1

主表A中有一个从表属性是B类型的b

2

主表：

3

@OneToOne(cascade = CascadeType.ALL)

4

@JoinColumn(name="主表外键")   //这里指定的是数据库中的外键字段。

5

public B getB(){

6

  return b;

7

}

8

9

从表：无

主表A中有一个从表属性是B类型的b，同时，从表B中有一个主表属性是A类型的a
主表：
@OneToOne(cascade = CascadeType.ALL)
@JoinColumn(name="主表外键")   //这里指定的是数据库中的外键字段。
public B getB(){
  return b;
}

从表：
@OneToOne(mappedBy = "主表类中的从表属性")
public 主表类 get主表类(){
  return 主表对象
}

13

 

1

主表A中有一个从表属性是B类型的b，同时，从表B中有一个主表属性是A类型的a

2

主表：

3

@OneToOne(cascade = CascadeType.ALL)

4

@JoinColumn(name="主表外键")   //这里指定的是数据库中的外键字段。

5

public B getB(){

6

  return b;

7

}

8

9

从表：

10

@OneToOne(mappedBy = "主表类中的从表属性")

11

public 主表类 get主表类(){

12

  return 主表对象

13

}

@ManyToOne - 表示一个多对一的映射，该注解标注的属性通常是数据库表的外键

单向多对一：多方有一方的引用，一方没有多方的引用
在多方
@ManyToOne(targetEntity=XXXX.class)   //指定关联对象
@JoinColumn(name="")                 //指定产生的外键字段名

4

 

1

单向多对一：多方有一方的引用，一方没有多方的引用

2

在多方

3

@ManyToOne(targetEntity=XXXX.class)   //指定关联对象

4

@JoinColumn(name="")                 //指定产生的外键字段名

双向多对一：配置方式同双向一对多

1

 

1

双向多对一：配置方式同双向一对多

// 示例
// 订单 Order 和用户 User 是一个 ManyToOne 的关系
// 在 Order 类中定义
@ManyToOne()
@JoinColumn(name="USER")
public User getUser() {
  return user;
}

8

 

1

// 示例

2

// 订单 Order 和用户 User 是一个 ManyToOne 的关系

3

// 在 Order 类中定义

4

@ManyToOne()

5

@JoinColumn(name="USER")

6

public User getUser() {

7

  return user;

8

}

@OneToMany - 描述一个一对多的关联，该属性应该为集合类型，在数据库中并没有实际字段

单向一对多：一方有集合属性，包含多个多方，而多方没有一方的引用
@OneToMany  默认会使用连接表做一对多关联
添加@JoinColumn(name="xxx_id") 后，就会使用外键关联，而不使用连接表了

3

 

1

单向一对多：一方有集合属性，包含多个多方，而多方没有一方的引用

2

@OneToMany  默认会使用连接表做一对多关联

3

添加@JoinColumn(name="xxx_id") 后，就会使用外键关联，而不使用连接表了

双向一对多：
1）在多方
@ManyToOne
@JoinColumn(name="自己的数据库外键列名")
 
2）在一方
@OneToMany(mappedBy="多端的关联属性名") //mappedBy相当于inverse，维护外键的控制权，不能和JoinColumn同时使用
@JoinColumn(name="对方的数据库外键列名")

8

 

1

双向一对多：

2

1）在多方

3

@ManyToOne

4

@JoinColumn(name="自己的数据库外键列名")

5

6

2）在一方

7

@OneToMany(mappedBy="多端的关联属性名") //mappedBy相当于inverse，维护外键的控制权，不能和JoinColumn同时使用

8

@JoinColumn(name="对方的数据库外键列名")

注意：对于外键的维护，如果是双向一对多，希望双方均可以维护外键，则不能使用mappedBy，而应该双方都使用@JoinColumn

@ManyToMany - 可选，描述一个多对多的关联

• 属性：
  
• targetEntity - 表示多对多关联的另一个实体类的全名，例如：package.Book.class
  
• mappedBy - 用在双向关联中，把关系的维护权翻转。    
  

单向多对多关联：
在主控方加入@ManyToMany注解即可。

2

 

1

单向多对多关联：

2

在主控方加入@ManyToMany注解即可。

双向多对多关联：
两个实体间互相关联的属性必须标记为@ManyToMany，并相互指定targetEntity属性。
有且只有一个实体的@ManyToMany注解需要指定mappedBy属性，指向targetEntity的集合属性名称。

3

 

1

双向多对多关联：

2

两个实体间互相关联的属性必须标记为@ManyToMany，并相互指定targetEntity属性。

3

有且只有一个实体的@ManyToMany注解需要指定mappedBy属性，指向targetEntity的集合属性名称。

3.3.2 关联映射的其他补充

@JoinTable其实同时也是配合@ManyToMany使用的，@ManyToMany注释表示该对象是多对多关系的一端，然后利用@JoinTable来定义关联关系（利用中间表来建立联系，原因戳这里），其中name属性指定中间表名称，joinColumns定义中间表与该表的外键关系，inverseJoinColumns属性定义了中间表与另外一端的外键关系。

@JoinTable - 定义关联表， 该关联表包含了指回实体表的外键(通过@JoinTable.joinColumns) 以及指向目标实体表的外键(通过@JoinTable.inverseJoinColumns)

e.g.
如下表示：该属性对应字段为"resource_type"，该字段实际在另外一张名"r_role_x_resource_type"表中，与该表（"p_role"）通过"role_id"进行外键链接

（class Role --> table "p_role"）
@ElementCollection
@JoinTable(name = "r_role_x_resource_type", joinColumns = @JoinColumn(name = "role_id"))
@Column(name = "resource_type")
@JSONField(serialize = false)
@Cache(usage = CacheConcurrencyStrategy.NONE)
public List<Class<? extends Resourceable>> getResourceTypeList() {
	return resourceTypeList;
}

12

 

1

e.g.

2

如下表示：该属性对应字段为"resource_type"，该字段实际在另外一张名"r_role_x_resource_type"表中，与该表（"p_role"）通过"role_id"进行外键链接

3

4

（class Role --> table "p_role"）

5

@ElementCollection

6

@JoinTable(name = "r_role_x_resource_type", joinColumns = @JoinColumn(name = "role_id"))

7

@Column(name = "resource_type")

8

@JSONField(serialize = false)

9

@Cache(usage = CacheConcurrencyStrategy.NONE)

10

public List<Class<? extends Resourceable>> getResourceTypeList() {

11

    return resourceTypeList;

12

}

e.g.
如下表示：关联的表为“r_role_x_permission"，其中关联外键为"role_id"，该表又通过"permission_id"链接第三张表，即目标实体表

（class Role --> table "p_role"）
@ManyToMany
@JoinTable(name = "r_role_x_permission", joinColumns = @JoinColumn(name = "role_id"),
	inverseJoinColumns = @JoinColumn(name = "permission_id"))
public List<Permission> getPermissionList() {
	return permissionList;
}

x

 

1

e.g.

2

如下表示：关联的表为“r_role_x_permission"，其中关联外键为"role_id"，该表又通过"permission_id"链接第三张表，即目标实体表

3

4

（class Role --> table "p_role"）

5

@ManyToMany

6

@JoinTable(name = "r_role_x_permission", joinColumns = @JoinColumn(name = "role_id"),

7

    inverseJoinColumns = @JoinColumn(name = "permission_id"))

8

public List<Permission> getPermissionList() {

9

    return permissionList;

10

}

4、其他注解

@DiscriminatorValue - 一张表对应一整棵类继承树时，该类别对应的“表part”

首先参考这篇文章，很重要：hibernate映射继承关系(一)：一张表对应一整棵类继承树，从文中可以知道，用一个表来存储对应的整个类别的数据，比如有Cat和Animal，Cat是Animal的子类，我仅用Animal一个表来存储Animal和Cat的字段和数据，而不是分成两个表。那么当我进行映射关系的时候，假如我要Cat类映射到Animal中Cat的部分，如何处理？在Animal中定义一个字段用来区分不同的表，比如Animal表中我额外增加字段名为Type，那么在Animal这一张表中，我们本属于Animal表内容的，该字段我们设置为animal，本属于Cat表的，该字段我们设置为cat。你可以理解为，新增加字段来用以在同一个表中区分不同类别的内容。

所以对应在注解上的使用的一个映射关系表示，就是这样的：对于”父类“，即准备用来囊括所有内容的那个表，我们需要定义这个对应的类为 @DiscriminatorColumn(name = "xxx", discriminatorType = DiscriminatorType.xxx) ，这里的name就是指定表中用来区别各类内容的字段，而对于”子类“，我们需要注解标明@DiscriminatorValue(xxx)，这里的xxx即对应了父类中的 “区别用字段” 里的标识。

举例来说，就是假如我们希望将Animal和Cat的内容都只存储在Animal这张表里，那么为了区分内容，我们对于Animal这个表新增某字段如 type；Animal的类，注解为@DiscriminatorColumn(name = "type", discriminatorType = DiscriminatorType.STRING) ，同时设置@DiscriminatorValue("animal")；Cat extends Animal，Cat的类，注解为@DiscriminatorValue(“cat")；那么Animal这个表中，字段type中，为animal的元组映射Animal类，为cat的元组映射Cat类。

而这种方式，多用于数据库字典概念。

@Transient

如果某个属性不需要被持久化，可以加上 @javax.persistence.Transient 注解或者使用 java 的 transient 关键字。

@Lob

实体BLOB、CLOB类型的注解：

• BLOB类型属性声明为byte[]或者java.sql.Blob，多用来直接将文件存储在数据库字段中（如图片）；
• CLOB类型的属性声明为String或java.sql.Clob （详可见参考链接中《Hibernate的Annotation实体BLOB、CLOB类型注解》）
  

5、参考链接

• 注解的力量 -----Spring 2.5 JPA hibernate 使用方法的点滴整理（一）：消除hibernate中<mapping resouce 的xxxx. hbm.xml文件
  
• Hibernate注解方法使用总结
  
• Hibernate注解配置与XML配置区别
  
• 乐观锁与悲观锁——解决并发问题
  
• 乐观锁与悲观锁的区别
  
• hibernate映射继承关系(一)：一张表对应一整棵类继承树
  
• Hibernate的注释该如何使用？每一个注释代表什么意思？ 
  
• 说说 Hibernate 的映射策略
  
• Hibernate的Annotation中实体BLOB、CLOB类型的注解