一对多、多对一和多对多之间的区别？

Question

好吧，这可能是一个微不足道的问题，但我很难想象和理解差异以及何时使用它们。我也有点不清楚单向和双向映射等概念如何影响一对多/多对多关系。我现在正在使用 Hibernate，因此任何与 ORM 相关的解释都会有所帮助。

作为一个例子，假设我有以下设置：

public class Person {
    private Long personId;
    private Set<Skill> skills;
    //Getters and setters
}

public class Skill {
    private Long skillId;
    private String skillName;
    //Getters and setters
}

那么在这种情况下我会有什么样的映射？非常感谢这个特定示例的答案，但我也非常希望概述何时使用一对多和多对多，何时使用连接表与连接列以及单向与双向。

Answer 1

看起来每个人都在回答一对多与多对多：

一对多、之间的区别>多对一和多对多是：

一对多 vs 多对一< /code> 是一个视角问题。 单向 与双向 不会影响映射，但会对您访问数据的方式产生影响。

• 在多对一中，多端将保留一端的引用。一个很好的例子是“一个州有城市”。在本例中，State 是一侧，City 是多侧。 cities 表中会有一列 state_id。

在单向中，Person 类将具有 List技能但是
Skill不会有Person person。在双向中，两者
添加了属性，它允许您访问给定的 Person
技能（即skill.person）。




• 在一对多中，一侧将是我们的参考点。例如，“用户有地址”。在这种情况下，我们可能有三列 address_1_id、address_2_id 和 address_3_id 或一个 使用 user_id 上的多列唯一约束
  在 address_id 上。

在单向中，用户将拥有地址。 双向
将有一个额外的 ListAddress 类中的用户。

• 在多对多中，每一方的成员都可以引用另一方任意数量的成员。为了实现这一点，使用了查找表。医生和病人之间的关系就是一个例子。一个医生可以有很多病人，反之亦然。

Answer 2

一对多：一个人拥有多个技能，一个技能在人与人之间不重复使用

• 单向：一个人可以通过其集合直接引用技能
• 双向：每个“子”技能都有一个指向
  人员（代码中未显示）

多对多：一个人拥有多种技能，一项技能在人员之间重复使用

• 单向：一个人可以通过其集合双向直接引用技能
• ：技能具有与其相关的一组人员。

在一对多关系中，一个对象是“父对象”，一个对象是“子对象”。父母控制孩子的存在。在多对多中，任一类型的存在都依赖于它们两者之外的某些东西（在更大的应用程序上下文中）。

您的主题（域）应该决定关系是一对多还是多对多——但是，我发现使关系成为单向还是双向是一个工程决策，需要权衡内存、处理、性能等等。

令人困惑的是，多对多双向关系不需要是对称的！也就是说，一群人可以指向一项技能，但该技能不需要仅与这些人相关。通常是这样，但这种对称性不是必需的。以爱情为例，它是双向的（“我爱”，“爱我”），但通常是不对称的（“我爱她，但她不爱我”）！

所有这些都得到了 Hibernate 和 JPA 的良好支持。请记住，Hibernate 或任何其他 ORM 在管理双向多对多关系时不会关心保持对称性……这完全取决于应用程序。

Answer 3

1) 圆圈是实体/POJO/Bean

2) deg 是图形中度的缩写（边数）

PK=主键，FK=外键

请注意度与边名称之间的矛盾。许多对应于度＝1，而一对应于度＞1。

Answer 4

一对多

一对多表关系如下所示：

在关系数据库系统中，一对多表关系基于子表中引用父表中一条记录的主键的外键列来关联两个表。

在上表中，post_comment 表中的 post_id 列与 post 表具有 Foreign Key 关系id Primary Key 列：

    ALTER TABLE
        post_comment
    ADD CONSTRAINT
        fk_post_comment_post_id
    FOREIGN KEY (post_id) REFERENCES post

@ManyToOne 注解

在 JPA 中，映射一对多表关系的最佳方法是使用 @ManyToOne 注解。

在我们的示例中，PostComment 子实体使用 @ManyToOne 注释映射 post_id 外键列：

    @Entity(name = "PostComment")
    @Table(name = "post_comment")
    public class PostComment {
    
        @Id
        @GeneratedValue
        private Long id;
    
        private String review;
    
        @ManyToOne(fetch = FetchType.LAZY)
        private Post post;
        
    }

使用 JPA @OneToMany< /code> 注释

仅仅因为您可以选择使用 @OneToMany 注释，但这并不意味着它应该成为所有一对多的默认选项数据库关系。

JPA 集合的问题在于，我们只能在元素计数相当低的情况下使用它们。

映射 @OneToMany 关联的最佳方法是依靠 @ManyToOne 端传播所有实体状态更改：

    @Entity(name = "Post")
    @Table(name = "post")
    public class Post {
    
        @Id
        @GeneratedValue
        private Long id;
    
        private String title;
    
        @OneToMany(
            mappedBy = "post", 
            cascade = CascadeType.ALL, 
            orphanRemoval = true
        )
        private List<PostComment> comments = new ArrayList<>();
    
        //Constructors, getters and setters removed for brevity
    
        public void addComment(PostComment comment) {
            comments.add(comment);
            comment.setPost(this);
        }
    
        public void removeComment(PostComment comment) {
            comments.remove(comment);
            comment.setPost(null);
        }
    }

父 Post 实体功能两个实用方法（例如addComment 和removeComment）用于同步双向关联的双方。

每当您使用双向关联时，您都应该提供这些方法，否则您将面临 非常微妙的状态传播问题。

应避免使用单向 @OneToMany 关联，因为它的效率低于使用 @ManyToOne 或双向 @OneToMany 关联。

一对一

一对一表关系如下所示：

在关系数据库系统中，一对一的表关系基于子表中的主键列链接两个表，该列也是引用主键的外键 > 父表行。

因此，我们可以说子表与父表共享主键。

在上表中，post_details 表中的 id 列与 post 也具有 Foreign Key 关系表 id Primary Key 列：

    ALTER TABLE
        post_details
    ADD CONSTRAINT
        fk_post_details_id
    FOREIGN KEY (id) REFERENCES post

使用带有 @MapsId 注释的 JPA @OneToOne 映射

< code>@OneToOne关系是使用@MapsId。这样，您甚至不需要双向关联，因为您始终可以使用 Post 实体标识符来获取 PostDetails 实体。

映射如下所示：

@Entity(name = "PostDetails")
@Table(name = "post_details")
public class PostDetails {

    @Id
    private Long id;

    @Column(name = "created_on")
    private Date createdOn;

    @Column(name = "created_by")
    private String createdBy;

    @OneToOne(fetch = FetchType.LAZY)
    @MapsId
    @JoinColumn(name = "id")
    private Post post;

    public PostDetails() {}

    public PostDetails(String createdBy) {
        createdOn = new Date();
        this.createdBy = createdBy;
    }

    //Getters and setters omitted for brevity
}

这样，id 属性既充当主键又充当外键。您会注意到，@Id 列不再使用 @GenerateValue 注释，因为标识符是用 post 关联的标识符填充的。

多对多

多对多表关系如下所示：

在关系数据库系统中，多对多表关系通过子表链接两个父表，子表包含两个引用两个父表的主键列的外键列。

在上表中，post_tag 表中的 post_id 列与 post 也具有 Foreign Key 关系表 id Primary Key 列：

    ALTER TABLE
        post_tag
    ADD CONSTRAINT
        fk_post_tag_post_id
    FOREIGN KEY (post_id) REFERENCES post

并且，post_tag 表中的 tag_id 列与tag 表 id Primary Key 列：

    ALTER TABLE
        post_tag
    ADD CONSTRAINT
        fk_post_tag_tag_id
    FOREIGN KEY (tag_id) REFERENCES tag

使用 JPA @ManyToMany 映射

这是映射多对多< /code> 与 JPA 和 Hibernate 的表关系：

    @Entity(name = "Post")
    @Table(name = "post")
    public class Post {

        @Id
        @GeneratedValue
        private Long id;

        private String title;

        @ManyToMany(cascade = { 
            CascadeType.PERSIST, 
            CascadeType.MERGE
        })
        @JoinTable(name = "post_tag",
            joinColumns = @JoinColumn(name = "post_id"),
            inverseJoinColumns = @JoinColumn(name = "tag_id")
        )
        private Set<Tag> tags = new HashSet<>();

        //Getters and setters ommitted for brevity

        public void addTag(Tag tag) {
            tags.add(tag);
            tag.getPosts().add(this);
        }

        public void removeTag(Tag tag) {
            tags.remove(tag);
            tag.getPosts().remove(this);
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Post)) return false;
            return id != null && id.equals(((Post) o).getId());
        }

        @Override
        public int hashCode() {
            return getClass().hashCode();
        }
    }

    @Entity(name = "Tag")
    @Table(name = "tag")
    public class Tag {

        @Id
        @GeneratedValue
        private Long id;

        @NaturalId
        private String name;

        @ManyToMany(mappedBy = "tags")
        private Set<Post> posts = new HashSet<>();

        //Getters and setters ommitted for brevity

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Tag tag = (Tag) o;
            return Objects.equals(name, tag.name);
        }

        @Override
        public int hashCode() {
            return Objects.hash(name);
        }
    }

1. Post 实体中的 tags 关联仅定义 PERSIST 和 MERGE > 级联类型。 REMOVE 实体状态转换对于 @ManyToMany JPA 关联没有任何意义，因为它可能会触发链删除，最终擦除关联的双方。
2. 如果您使用双向关联，则添加/删除实用程序方法是必需的，以便您可以确保关联的双方保持同步。
3. Post 实体使用实体标识符来实现平等，因为它缺少任何唯一的业务密钥。您可以使用实体标识符来实现相等，只要确保它在所有实体状态转换中保持一致即可。
4. Tag 实体有一个唯一的业务键，它用 Hibernate 特定的 @NaturalId 注解进行标记。在这种情况下，唯一的业务密钥是平等检查的最佳候选 。
5. Tag 实体中 posts 关联的 mappedBy 属性标记，在此双向关系中，Post 实体拥有该协会。这是必需的，因为只有一侧可以拥有关系，并且更改仅从该特定一侧传播到数据库。
6. Set 是首选，因为使用 List 和 @ManyToMany 效率较低。

Answer 5

我会这样解释：

OneToOne - OneToOne
（一个人有一个鼻子 -
一鼻子有一个人）

@OneToOne
Person person;

@OneToOne
Nose nose;

OneToMany - ManyToOne
（一个牧羊人有很多只羊 -
一只羊有一个牧羊人）

@OneToMany
Shepherd shepherd;

@ManyToOne
List<Sheep> sheeps;

ManyToMany - ManyToMany
（许多旅行者有很多目的地 -
许多目的地都有许多旅客）

@ManyToMany
List<Traveler> travelers;

@ManyToMany
List<Destination> destinations;

Answer 6

看一下这篇文章：映射对象关系

映射时需要关注两类对象关系。第一类基于多样性，包括三种类型：

*One-to-one relationships.  This is a relationship where the maximums of each of its multiplicities is one, an example of which is holds relationship between Employee and Position in Figure 11.  An employee holds one and only one position and a position may be held by one employee (some positions go unfilled).
*One-to-many relationships. Also known as a many-to-one relationship, this occurs when the maximum of one multiplicity is one and the other is greater than one.  An example is the works in relationship between Employee and Division.  An employee works in one division and any given division has one or more employees working in it.
*Many-to-many relationships. This is a relationship where the maximum of both multiplicities is greater than one, an example of which is the assigned relationship between Employee and Task.  An employee is assigned one or more tasks and each task is assigned to zero or more employees. 

第二类基于
方向性，它包含两个
类型、单向关系
和双向关系。

*Uni-directional relationships.  A uni-directional relationship when an object knows about the object(s) it is related to but the other object(s) do not know of the original object.  An example of which is the holds relationship between Employee and Position in Figure 11, indicated by the line with an open arrowhead on it.  Employee objects know about the position that they hold, but Position objects do not know which employee holds it (there was no requirement to do so).  As you will soon see, uni-directional relationships are easier to implement than bi-directional relationships.
*Bi-directional relationships.  A bi-directional relationship exists when the objects on both end of the relationship know of each other, an example of which is the works in relationship between Employee and Division.  Employee objects know what division they work in and Division objects know what employees work in them. 

Answer 7

这可能需要多对多关系，如下所示，

public class Person{

    private Long personId;
    @manytomany

    private Set skills;
    //Getters and setters
}

public class Skill{
    private Long skillId;
    private String skillName;
    @manyToMany(MappedBy="skills,targetClass="Person")
    private Set persons; // (people would not be a good convenion)
    //Getters and setters
}

您可能需要定义一个 joinTable + JoinColumn 但它也可以在没有...的情况下工作

Answer 8

首先，阅读所有细则。请注意，NHibernate（因此，我假设也是 Hibernate）关系映射与数据库和对象图映射有一个有趣的对应关系。例如，一对一关系通常被实现为多对一关系。

其次，在我们告诉您应该如何编写 O/R 映射之前，我们还必须查看您的数据库。尤其是，一个技能可以被多人拥有吗？如果是这样，那么你们之间就是多对多关系；否则，就是多对一。

第三，我不喜欢直接实现多对多关系，而是在域模型中对“连接表”进行建模 - 即，将其视为一个实体，如下所示：

class PersonSkill 
{
    Person person;
    Skill skill;    
}

那么你看到你拥有什么了吗？您有两个一对多关系。 （在这种情况下，Person 可能有 PersonSkills 的集合，但不会有 Skills 的集合。）但是，有些人会更喜欢使用多对多关系（Person 和 Skill 之间）；这是有争议的。

第四，如果您确实有双向关系（例如，Person 不仅有 Skills 的集合，而且 Skill 也有 Persons 的集合），NHibernate 不会在您的 BL 中为您强制执行双向性；它仅出于持久性目的而理解关系的双向性。

第五，多对一在 NHibernate（我假设是 Hibernate）中比一对多（集合映射）更容易正确使用。

祝你好运！