相关疑难解决方法(0)

有什么区别:

@Entity
public class Company {

    @OneToMany(cascade = CascadeType.ALL , fetch = FetchType.LAZY)
    @JoinColumn(name = "companyIdRef", referencedColumnName = "companyId")
    private List<Branch> branches;
    ...
}

和

@Entity
public class Company {

    @OneToMany(cascade = CascadeType.ALL , fetch = FetchType.LAZY, mappedBy = "companyIdRef")
    private List<Branch> branches;
    ...
}

我正在使用Zend Framework 2和Doctrine 2开发我的应用程序.

虽然书面方式说明,我无法理解之间的差异mappedBy和inversedBy.

我应该什么时候使用mappedBy？

我应该什么时候使用inversedBy？

我什么时候不用？

这是一个例子:

 /**
 *
 * @ORM\OneToOne(targetEntity="\custMod\Entity\Person", mappedBy="customer")
 * @ORM\JoinColumn(name="personID", referencedColumnName="id")
 */
protected $person;

/**
 *
 * @ORM\OneToOne(targetEntity="\Auth\Entity\User")
 * @ORM\JoinColumn(name="userID", referencedColumnName="id")
 */
protected $user;

/**
 *
 * @ORM\ManyToOne (targetEntity="\custMod\Entity\Company", inversedBy="customer")
 * @ORM\JoinColumn (name="companyID", referencedColumnName="id")
 */
protected $company;

我做了一个快速搜索,发现了以下内容,但我仍感到困惑:

• 例1
• 例2
• 例3

我正在尝试将 MySql 数据库迁移到 Postgresql。我正在使用 JPA，并使用 Eclipse Link 作为 MySQL 数据库，但我正在切换到 Hibernate 作为 Postgresql 数据库。

以下 JPA 注释可与 EclipseLink 配合使用：

UserBean.java：

@OneToMany(mappedBy = "sender", cascade = CascadeType.ALL)
@JoinTable(name = "MESSAGES_SENT")
private List<MessageBean> messagesSent;

@OneToMany(mappedBy = "receiver", cascade = CascadeType.ALL)
@JoinTable(name = "MESSAGES_RECEIVED")
private List<MessageBean> messagesReceived;

MessageBean.java：

@ManyToOne
private UserBean sender;

@ManyToOne
private UserBean receiver;

使用 Hibernate，我收到以下错误消息：

org.hibernate.AnnotationException：标记为mappedBy的关联不得定义数据库映射，如@JoinTable或@JoinColumn

我怎样才能让它与 Hibernate 一起工作？重要的是数据库架构不要更改，因为我想将 MySql 数据库转储到 Postgresql 数据库中，而不修改任何表或列名。

干杯，
多米尼克

我有一个实体Course和一个实体User.有一个多到许多课程和用户之间的关系的船,因为一门课程可以有很多的用户,并且用户可以在许多课程中注册.在两个实体中,我都将@ManyToMany注释放在特定字段上,也就是说,Course我已经:

@ManyToMany
private List<RegisteredUser> members;

在User我有:

@ManyToMany
private List<Course> coursesTaken;

现在,我知道这种多对多关系通常由第三个表表示.我也知道有注释@JoinTable可以让我们这样做.我不知道的是,我是否应该@JoinTable在两个不同实体的两个字段中添加此注释.顺便说一句,如果我需要添加到两者,名称需要匹配正确吗？

尽管我的问题专门针对使用Hibernate的Play框架中描述实体关系的方式,但我确信这是一般概念.

当我们有一对多关系时,我们总是被要求指定拥有方.

所以,例如,如果我们在Person和PhoneNumber之间有一对多的关系,我们就会编写这样的代码.

@Entity
class Person {
    @OneToMany(mappedBy="person")
    public Set<PhoneNumber> phoneNumbers;
}

@Entity
class PhoneNumber {
    @ManyToOne
    public Person person;
}

在上面的代码中,拥有实体是PhoneNumber.任何一方作为拥有实体的利弊是什么？

我知道当拥有的实体是PhoneNUmber时,表示的关系是ManyToOne,它不会产生连接表,而当拥有方是Person时,描述的关系将是OneToMany,在这种情况下将创建关系表.

这是确定拥有方的主要原因,还是还有其他原因？

更新: 我刚刚意识到这个线程提供了部分答案,但我希望也可能有其他要点.

1. 在双向多对多关系中设置MappedBy的原因是什么？
2. 当一个表有大量的记录,而其他表有几个,哪一方更好地放置mappedBy？

我有以下实体：

@Entity
public class A {

  // id, etc..

  @OneToOne
  private B b;
}

该表a已经存在，当我向其中添加新字段b时，hibernate 执行以下操作：

alter table a add column b_id int8
alter table a add constraint FKg76mxqt8whi8t8p4i7el95910 foreign key (b_id) references b

如您所见，外键列b_id不是唯一的。为什么会这样？一对一关系不是意味着外键必须是唯一的吗？这也是我在单向一对一关系的 JPA 规范中发现的内容：

[...] 外键列与表 B 的主键类型相同，并且有一个唯一键约束。

为了使其工作，我必须明确地将@JoinColumn(unique=true)注释添加到该字段。为什么我必须明确地这样做？

我有一个非常简单的设置来尝试带注释的双向映射:

@Entity
public class TypeA extends AbstractModel<TypeA> {

    @Id
    @GeneratedValue
    private int id;

    @OneToMany(mappedBy="a")
    private Collection<TypeB> bs;

    // Getters & Setters ... 
}

和

@Entity
public class TypeB extends AbstractModel<TypeB> {

    private static final long serialVersionUID = -3526384868922938604L;

    @Id
    @GeneratedValue
    private int id;

    @ManyToOne()
    @JoinColumn(name="a_id")
    private TypeA a;
}

当我设置属性TypeA.bs时,这不会影响映射,尽管它应该.请参阅以下示例:

TypeB b = new TypeB();
this.typeBDao.save(b);

TypeA a = new TypeA();
a.setBs(ListUtils.createList(b));

System.out.println(a.getBs()); // output: [TypeB@25fe4d40]

this.typeADao.save(a);

System.out.println(a.getBs()); // output: [TypeB@25fe4d40]

this.typeADao.refresh(a);

System.out.println(a.getBs()); // output: []

this.typeBDao.refresh(b);
System.out.println(b.getA()); // output: …

我有三个实体，Session、Order 和 User（我的在线电影票项目的一部分）。在我的域模型中，Order 保留了 User 和 Session 的 fk。正如你在我的代码中看到的：

@Table(name="Orders")
@Entity

public class Order {
    @ManyToOne
    @JoinColumn(nullable = false)
    private User user;

    @ManyToOne
    private Session session;
    ...
}



@Entity 
@Table(name="Session")

public class Session {
    @OneToMany(fetch=FetchType.LAZY,
               cascade = CascadeType.ALL,
               mappedBy = "session")
    private List<Order> orders = new ArrayList<Order>();
    ...
}



@Table(name="User")
@Entity

public class User {
    @OneToMany(cascade = {  CascadeType.PERSIST,
                            CascadeType.MERGE,
                            CascadeType.REMOVE },
               mappedBy = "user")
    private @Getter Set<Order> orders = new HashSet<>();
    ...
}

我的问题是，我可以CascadeType.ALL在 Session 和 User …

我owning side and non-owning在学习 hibernate 时遇到了 ie side这两个术语。例如：- 这是关于mappedby 元素在一对一映射中的用法的声明

如果关系是双向的，非拥有方必须使用注解的 mappedBy元素OneToOne来指定拥有方的关系字段或属性。

但我没有得到真正的owning side and non-owning一面是什么？