Hibernate 映射类型

Hibernate 提供了多种映射类型，这些映射类型用于描述 Java 对象与数据库表之间的关系。这些映射类型可以分为几个主要类别，包括基本类型的映射、集合类型的映射、一对一（One-to-One）、一对多（One-to-Many）、多对一（Many-to-One）以及多对多（Many-to-Many）关系的映射等。

下面是这些映射类型的概述：

1. 基本类型的映射

这是最简单的映射类型，它将 Java 类中的一个属性映射到数据库表中的一个列。例如，一个 String 属性可以映射到一个 VARCHAR 列。

示例代码：

public class Employee {
    private Integer id;
    private String name;
    // 其他属性和方法...
}
1
2
3
4
5

映射文件（或注解）示例：

<class name="com.example.model.Employee" table="employee">
    <id name="id" column="id">
        <generator class="increment"/>
    </id>
    <property name="name" column="name"/>
</class>
1
2
3
4
5
6

或者使用 JPA 注解：

@Entity
@Table(name = "employee")
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    @Column(name = "name")
    private String name;
    // 其他属性和方法...
}
1
2
3
4
5
6
7
8
9
10
11

2. 集合类型的映射

集合类型的映射用于处理列表、数组或集合类型的属性。Hibernate 支持映射不同类型的集合，如 Set, List, Map, 和 Bag。

示例代码：

public class Employee {
    private Integer id;
    private Set<PhoneNumber> phoneNumbers;
    // 其他属性和方法...
}

public class PhoneNumber {
    private Integer id;
    private String number;
    // 其他属性和方法...
}
1
2
3
4
5
6
7
8
9
10
11

映射文件（或注解）示例：

<class name="com.example.model.Employee" table="employee">
    <id name="id" column="id">
        <generator class="increment"/>
    </id>
    <set name="phoneNumbers" inverse="true" cascade="all-delete-orphan">
        <key column="emp_id"/>
        <one-to-many class="com.example.model.PhoneNumber"/>
    </set>
</class>

<class name="com.example.model.PhoneNumber" table="phone_number">
    <id name="id" column="id">
        <generator class="increment"/>
    </id>
    <property name="number" column="number"/>
    <many-to-one name="employee" class="com.example.model.Employee" column="emp_id"/>
</class>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

或者使用 JPA 注解：

@Entity
@Table(name = "employee")
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    @OneToMany(mappedBy = "employee", cascade = CascadeType.ALL, orphanRemoval = true)
    private Set<PhoneNumber> phoneNumbers;
    // 其他属性和方法...
}

@Entity
@Table(name = "phone_number")
public class PhoneNumber {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    @Column(name = "number")
    private String number;
    
    @ManyToOne
    @JoinColumn(name = "emp_id")
    private Employee employee;
    // 其他属性和方法...
}
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

3. 关系类型的映射

关系类型的映射用于处理实体之间的关系，包括一对一、一对多、多对一和多对多。

一对一映射

@Entity
@Table(name = "employee")
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    @OneToOne(mappedBy = "employee")
    private Address address;
    // 其他属性和方法...
}

@Entity
@Table(name = "address")
public class Address {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    @Column(name = "street")
    private String street;
    
    @OneToOne
    @JoinColumn(name = "emp_id")
    private Employee employee;
    // 其他属性和方法...
}
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

一对多映射

@Entity
@Table(name = "employee")
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    @OneToMany(mappedBy = "employee", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Project> projects;
    // 其他属性和方法...
}

@Entity
@Table(name = "project")
public class Project {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    @ManyToOne
    @JoinColumn(name = "emp_id")
    private Employee employee;
    // 其他属性和方法...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

多对一映射

@Entity
@Table(name = "project")
public class Project {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    @ManyToOne
    @JoinColumn(name = "emp_id")
    private Employee employee;
    // 其他属性和方法...
}

@Entity
@Table(name = "employee")
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    @OneToMany(mappedBy = "employee", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Project> projects;
    // 其他属性和方法...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

多对多映射

@Entity
@Table(name = "employee")
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    @ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE})
    @JoinTable(
        name = "employee_project",
        joinColumns = @JoinColumn(name = "emp_id"),
        inverseJoinColumns = @JoinColumn(name = "proj_id")
    )
    private List<Project> projects;
    // 其他属性和方法...
}

@Entity
@Table(name = "project")
public class Project {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    @ManyToMany(mappedBy = "projects")
    private List<Employee> employees;
    // 其他属性和方法...
}
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

4. 其他高级映射

除了上述基本映射类型之外，Hibernate 还支持一些更高级的映射特性，如继承映射、组件映射、枚举映射等。

组件映射

public class Address {
    private String street;
    private String city;
    private String zipCode;
    // 其他属性和方法...
}

@Entity
@Table(name = "employee")
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    @Embedded
    private Address address;
    // 其他属性和方法...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

枚举映射

@Entity
@Table(name = "employee")
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    @Enumerated(EnumType.STRING)
    private Gender gender;
    // 其他属性和方法...
}

public enum Gender {
    MALE, FEMALE, OTHER
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

这些映射类型涵盖了 Hibernate 中最常见的关系映射场景。根据你的具体需求选择合适的映射类型，可以帮助你更好地管理实体之间的关系。