我如何在Hibernate4和Spring中使用注释来定义不同类型的关系？

Question

public class Foo {
     private Long fooId;

     private Bar bar;
     //Yes, this doesn't actually make any sense,
     //having both a list and a single object here, its an example.
     private List<Bar> bars;
}

public class Bar {
    private Long barId;

    private Foo foo;
}

此外，我如何配置我的一对多用于孤立删除、惰性加载，以及在处理集合时是什么导致LazyInitialiaizationException以及如何解决问题？

Answer 1

_{假设所有类都带有@entity和@table}注释

单向一对一关系

public class Foo{
    private UUID fooId;

    @OneToOne
    private Bar bar;
}

public class Bar{
    private UUID barId;
    //No corresponding mapping to Foo.class
}

foo.class管理的双向一对一关系

public class Foo{
    private UUID fooId;

    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "barId")
    private Bar bar;
}

public class Bar{
    private UUID barId;

    @OneToOne(mappedBy = "bar")
    private Foo foo;
}

public class Foo{
    private UUID fooId;

    @OneToMany
    @JoinTable(name="FOO_BAR",
        joinColumns = @JoinColumn(name="fooId"),
        inverseJoinColumns = @JoinColumn(name="barId"))
    private List<Bar> bars;
}

public class Bar{
    private UUID barId;

    //No Mapping specified here.
}

@Entity
@Table(name="FOO_BAR")
public class FooBar{
    private UUID fooBarId;

    @ManyToOne
    @JoinColumn(name = "fooId")
    private Foo foo;

    @ManyToOne
    @JoinColumn(name = "barId")
    private Bar bar;

    //You can store other objects/fields on this table here.
}

public class Foo{
    private UUID fooId;

    @OneToMany(mappedBy = "bar")
    private List<Bar> bars;
}

public class Bar{
    private UUID barId;

    @ManyToOne
    @JoinColumn(name = "fooId")
    private Foo foo;
}

public class Foo{
    private UUID fooId;

    @OneToMany
    @JoinTable(name="FOO_BAR",
        joinColumns = @JoinColumn(name="fooId"),
        inverseJoinColumns = @JoinColumn(name="barId"))
    private List<Bar> bars;
}

public class Bar{
    private UUID barId;

    @OneToMany
    @JoinTable(name="FOO_BAR",
        joinColumns = @JoinColumn(name="barId"),
        inverseJoinColumns = @JoinColumn(name="fooId"))
    private List<Foo> foos;
}

public class Foo{
    private UUID fooId;

    @OneToMany(mappedBy = "bar")
    private List<FooBar> bars;
}

public class Bar{
    private UUID barId;

    @OneToMany(mappedBy = "foo")
    private List<FooBar> foos;
}

@Entity
@Table(name="FOO_BAR")
public class FooBar{
    private UUID fooBarId;

    @ManyToOne
    @JoinColumn(name = "fooId")
    private Foo foo;

    @ManyToOne
    @JoinColumn(name = "barId")
    private Bar bar;

    //You can store other objects/fields on this table here.
}

默认情况下，Hibernate对集合使用惰性选择提取，对单值关联使用惰性代理提取。这些默认值对于大多数应用程序中的大多数关联都是有意义的。

当在对象上使用FetchType.lazy和FetchType.Eage时，请考虑这一点。如果您知道50%的情况下不需要访问父对象上的集合，那么我将使用fetchType.lazy。

这样做的性能优势是巨大的，并且只会随着向集合中添加更多对象而增长。这是因为对于一个急切加载的集合，Hibernate会进行大量的幕后检查，以确保没有任何数据过期。虽然我确实提倡对集合使用Hibernate，但请注意，使用FetchType.Eager存在性能损失^**。但是，以我们的Person对象为例。很可能，当我们加载人员时，我们希望了解他们执行什么角色。我通常会将此集合标记为FetchType.Eager。不要仅仅为了绕过LazyInitializationException而反射性地将集合标记为FetchType.Eager。这不仅仅是因为性能原因，它通常表明您有设计问题。扪心自问，这个集合实际上应该是一个急切加载的集合，还是我这样做只是为了访问这个方法中的集合。Hibernate有解决这一问题的方法，它不会对操作的性能产生同样大的影响。如果您希望仅为这一次调用初始化缓慢加载的集合，则可以在service层中使用以下代码。

//Service Class
@Override
@Transactional
public Person getPersonWithRoles(UUID personId){
    Person person = personDAO.find(personId);

    Hibernate.initialize(person.getRoles());

    return person;
}

//DAO
@Override
public Person findPersonWithRoles(UUID personId){
    Criteria criteria = sessionFactory.getCurrentSession().createCritiera(Person.class);

    criteria.add(Restrictions.idEq(personId);
    criteria.setFetchMode("roles", FetchMode.SUBSELECT);
}

public User saveOrUpdate(User user){
    getCurrentSession.saveOrUpdate(user);
    return user;
}

//Assume that user has no roles in the list, but has been saved to the
//database at a cost of 1 insert.
public void saveOrUpdateRoles(User user, List<Roles> listOfRoles){
    for(Role role : listOfRoles){
        role.setUser(user);
        getCurrentSession.saveOrUpdate(role);
    }
}

如果删除与对象的所有关联，Hibernate可以为您解决问题。假设您有一个用户,他有一个角色的列表,该列表中有5个不同角色的链接。假设您删除了一个名为ROLE_EXAMPLE>的角色,但碰巧该ROLE_EXAMPLE>不存在于任何其他用户对象上。如果在@OneTomany批注上设置了orphanremove=true，Hibernate将通过级联从数据库中删除现在为“孤立”的角色对象。

不应在每一种情况下都启用孤儿移除。事实上，在上面的示例中使用孤儿移除是没有意义的。仅仅因为没有用户可以执行ROLE_EXAMPLE对象所表示的任何操作，这并不意味着任何未来的用户将永远无法执行该操作。

这篇问答意在补充官方的Hibernate文档，该文档中有大量针对这些关系的XML配置。