有什么区别:

@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;
    ...
}

我想我误解了在@ManyToOne关系背景下级联的意义.

案子:

public class User {

   @OneToMany(fetch = FetchType.EAGER)
   protected Set<Address> userAddresses;

}

public class Address {

   @ManyToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
   protected User addressOwner;

}

这是什么意思cascade = CascadeType.ALL？例如,如果我从数据库中删除某个地址,我添加的事实如何cascade = CascadeType.ALL影响我的数据(User我猜)？

好的,这可能是一个微不足道的问题,但我无法想象和理解差异以及何时使用每个差异.关于单向和双向映射等概念如何影响一对多/多对多关系,我也有点不清楚.我现在正在使用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
}

那么在这种情况下我会有什么样的映射？这个具体示例的答案肯定是值得赞赏的,但我也非常希望概述何时使用一对多和多对多以及何时使用连接表与连接列以及单向与双向.

有一个实体类"A".A类可能具有相同类型"A"的子项.如果它是一个孩子,"A"也应该保留它的父母.

这可能吗？如果是这样,我应该如何映射Entity类中的关系？["A"有一个id列.]

我一直试图掌握Hibernate的逆属性,它似乎只是概念上难以解决的问题之一.

我得到的要点是,当你有一个使用一对多映射的Child对象集合的父实体(例如Parent)时,在映射上设置inverse = true告诉Hibernate'另一边(Child) )有责任更新自己以维护其表中的外键引用'.

这样做对于在代码中向集合中添加Children,然后保存Parent(使用cascade-all set)有两个好处:在数据库上保存一个不必要的命中(因为没有逆集,Hibernate认为它有两个地方更新FK关系),并根据官方文档:

如果关联的列被声明为NOT NULL,则NHibernate在创建或更新关联时可能会导致约束违规.要防止出现此问题,必须使用标记为inverse ="true"的多值结束(集合或包)的双向关联.

到目前为止,这一切似乎都有意义.我不明白是这样的:你什么时候会不希望使用逆=真正在一个一对多的关系？

错误

无法删除或更新父行:外键约束失败.

课程

class Teacher {

    /**
     *@ORM\OneToMany(targetEntity="publication", mappedBy="teacher")
     */
    protected $publications;
}

class Publication {

    /**
     * @ORM\ManyToOne(targetEntity="Teacher", inversedBy="publications")
     * @ORM\JoinColumn(name="teacher_id", referencedColumnName="id")
     */
    protected $teacher;
}

我想要

我想要的是,当你删除教师时,id_teacher被修改为NULL.我想保留出版物但不参考教授.

我不知道在Doctrine中是怎么做的,这可能吗？或者总是与老师的关系？

也许这是一个愚蠢的问题,但它让我烦恼.

我有一个双向的员工与车辆的一对多关系.当我第一次在数据库中保留一个Employee(即它没有分配的ID)时,我也希望它的相关Vehicle保持不变.

这对我来说很好,除了我保存的Vehicle实体没有自动映射关联的Employee,并且在数据库中,Vehicle表中的employee_id外键列为null.

我的问题是,在员工本身被持久化的同时,是否有可能让车辆的员工坚持下去？我意识到需要首先保存员工,然后保存车辆.JPA可以自动为我做这个吗？或者我必须做以下事情:

Vehicle vehicle1 = new Vehicle();
Set<Vehicle> vehicles = new HashSet<Vehicle>();
vehicles.add(vehicle1);

Employee newEmployee = new Employee("matt");
newEmployee.setVehicles(vehicles);
Employee savedEmployee = employeeDao.persistOrMerge(newEmployee);

vehicle1.setAssociatedEmployee(savedEmployee);
vehicleDao.persistOrMerge(vehicle1);

谢谢!

编辑:根据要求,这是我的映射(没有所有其他方法等)

@Entity
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name="employee_id")
    private Long id;

    @OneToMany(mappedBy="associatedEmployee", cascade=CascadeType.ALL)
    private Set<Vehicle> vehicles;

    ...

}

@Entity 
public class Vehicle {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name="vehicle_id")
    private Long id;

    @ManyToOne
    @JoinColumn(name="employee_id")
    private Employee associatedEmployee;

    ...
}

我刚刚意识到我应该在Employee类上定义以下方法:

public void addVehicle(Vehicle vehicle) {
    vehicle.setAssociatedEmployee(this);
    vehicles.add(vehicle);
}

现在上面的代码如下所示:

Vehicle …

我有一个一对多关系的2个类和一个有点奇怪的HQL查询.即使我已经阅读了一些已经发布的问题,但我似乎并不清楚.

Class Department{
   @OneToMany(fetch=FetchType.EAGER, mappedBy="department")
   Set<Employee> employees;
}
Class Employee{
   @ManyToOne
   @JoinColumn(name="id_department")
   Department department;
}

当我使用以下查询时,我得到重复的Department对象:

session.createQuery("select dep from Department as dep left join dep.employees");

因此,我必须使用不同的:

session.createQuery("select distinct dep from Department as dep left join dep.employees");

这种行为是预期的吗？我认为这与SQL有所不同.

我有三个类,其中一个名称是User,这个用户有其他类实例.像这样;

public class User{
    @OneToMany(fetch=FetchType.LAZY, cascade = CascadeType.ALL)
    public List<APost> aPosts;

    @OneToMany(fetch=FetchType.LAZY, cascade = CascadeType.ALL)
    public List<BPost> bPosts;
}




   public class BPost extends Post {

    @ManyToOne(fetch=FetchType.LAZY)    
    public User user;
 }

    public class APost extends Post {

     @ManyToOne(fetch=FetchType.LAZY) 
     public User user;
 }

它的工作方式与此类似,但在db中生成emty表.哪个必须包含外键.当我尝试使用mappedBy和JoinColumn annotains时,我失败了.我该如何解决这个问题？

额外的信息:

当我换了;

 @ManyToOne(fetch=FetchType.LAZY)
 @JoinColumn(name="id")
 public User user;

和

 @OneToMany(fetch=FetchType.LAZY, cascade = CascadeType.ALL, mappedBy="id")
 public List<APost> aPosts;

我越来越

发生JPA错误(无法构建EntityManagerFactory):实体映射中的重复列:models.post.APost列:id(应使用insert ="false"update ="false"映射)

最终编辑:最后,我对jpa注释完全错了.:(当我改变

@OneToMany(fetch=FetchType.LAZY, cascade = CascadeType.ALL, mappedBy="id")

至

@OneToMany(fetch=FetchType.LAZY, cascade = CascadeType.ALL, mappedBy="user")

和

@ManyToOne(fetch=FetchType.LAZY)
@JoinColumn(name="user_id")

everthing工作正常.:)

我有以下两个实体:

1-播放列表:

@OneToMany(fetch = FetchType.EAGER, mappedBy = "playlist", orphanRemoval = true, cascade =   CascadeType.ALL)
@OrderBy("adOrder")
private Set<PlaylistadMap> PlaylistadMaps = new HashSet<PlaylistadMap>(0);

• CascadeType.ALL:在保存或更新播放列表实体时,需要在PlaylistadMap集合上进行保存和更新.
• 删除播放列表实体时需要使用orphanRemoval = true:还应删除PlaylistadMap引用.

2- PlaylistadMap:

@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name = "fk_playlist", referencedColumnName = "pkid", nullable = false)
private Playlist playlist;

使用getCurrentSession().delete();我删除播放列表时,我收到以下异常:

org.springframework.dao.InvalidDataAccessApiUsageException: deleted object would be re-saved by cascade (remove deleted object from associations): [com.xeno.advertisingsuite.web.domain.PlaylistadMap#6]; nested exception is org.hibernate.ObjectDeletedException: deleted object would be re-saved by cascade (remove deleted object from associations): …