Hibernate OneToOne 延迟加载和级联

Question

这就是我正在尝试做的事情。

1. 创建与子级具有 OneToOne 关系的
2. 父级 父级必须使用延迟加载来获取子级
3. 如果父级被删除，子级也会被删除
4. 如果子级被删除，父级不应受到影响
5. 级联更新和删除必须进行转换进入 DDL

class Parent

@OneToOne(mappedBy = "parent", cascade = CascadeType.ALL)
public Child getChild()

class Child

@OneToOne(fetch = FetchType.LAZY)
@OnDelete(action = OnDeleteAction.CASCADE)
@JoinColumn(name="parent_id")
public Parent getParent()

我已经完全实现了第 1、3、4 点，第 5 点部分实现了正在工作，还需要解决如何翻译更新部分印度DDL。

第2点是这里的一个大问题，在我当前的解决方案中，父级不会延迟加载子级。然而，子级确实会延迟加载父级，但反转注释会扰乱级联（第 3、4 和 5 点）。

我现在很困惑，希望我错过了一些明显的事情，所以任何帮助将不胜感激。

编辑： Adeel Ansari

'fetch=FetchType.LAZY' 请求的代码已添加到 Parent 类中，其他与上面相同。

IParentDAO parentDAO = DAOFactory.getFactory().getParentDAO();

parentDAO.beginTransaction();
//findByPrimaryKey uses 'org.hibernate.Session.get(Class clazz, Serializable id)'
parentDAO.findByPrimaryKey(1l);
parentDAO.commitTransaction();

生成的 hibernate 查询，一个获取 Parent，一个获取 Child：

Hibernate: select parent0_.id as id0_0_ from parents parent0_ where parent0_.id=?
Hibernate: select child0_.id as id1_0_, child0_.parent_id as parent2_1_0_ from childs child0_ where child0_.parent_id=?

这是 findByPrimaryKey 的代码：

public class HibernateParentDAO extends HibernateDAO<Parent, Long> implements IParentDAO {

    public HibernateParentDAO() {
        super(Parent.class);
    }
}

public abstract class HibernateDAO<T, ID extends Serializable> implements IGenericDAO<T, ID> {
    private Class<T> persistentClass;

    public HibernateDAO(Class<T> c) {
        persistentClass = c;
    }

    @SuppressWarnings("unchecked")
    public T findByPrimaryKey(ID id) {
        return (T) HibernateUtil.getSession().get(persistentClass, id);
    }
}

Answer 1

我也遇到过类似的问题。有几种不同的解决方案，但它们都是解决方法。

简短的回答是：Hibernate 不支持惰性一对一关系。

长答案（解决方法）是：

1. 将关系声明为一对一的关系（子级）和一对多的关系（父级）。因此，parent.getchild() 返回一个集合，但它将能够使用延迟加载。

2. 您可以尝试让父级和子级共享主键，但这需要您更改架构。

3. 您可以尝试在数据库中配置一个视图来反映这种一对一关系。

Answer 2

[这部分不再成立]

在您的Parent中修改此内容，如下所示，

@OneToOne(mappedBy = "parent", cascade = CascadeType.ALL, fetch=FetchType.LAZY)
public Child getChild()

应该可以工作。

---

[编辑解释为什么它不起作用]

加载B后，您可以立即调用
getCee() 获取 C。但是看，
getCee() 是您的类的方法，并且
Hibernate 无法控制它。
Hibernate不知道什么时候有人
将调用 getCee()。这意味着
Hibernate 必须放置一个适当的
值转化为“cee”属性
从数据库加载 B 的那一刻。

如果为 C、Hibernate 启用代理
可以放置一个 C 代理对象，但它不是
尚未加载，但将在以下时间加载
有人使用它。这给了懒惰
一对一加载。

但是现在想象一下你的 B 对象可能或者
可能没有关联的 C
（约束=“假”）。应该做什么
当特定 B 执行时 getCee() 返回
没有C？无效的。但请记住，
Hibernate 必须设置正确的值
“cee”此时设置 B（因为
它不知道什么时候有人会打电话来
getCee())。代理在这里没有帮助
因为代理本身已经
非空对象。

如果您的 B->C 映射是
强制（约束= true），
Hibernate将为C使用代理
导致延迟初始化。但
如果你允许 B 而没有 C，Hibernate
只需检查 C 是否存在
加载 B 的那一刻。但是 SELECT 到
检查存在效率很低
因为同一个 SELECT 可能不只是
检查存在，但加载整个
目的。所以延迟加载消失了。

参考：http://community.jboss.org/wiki/Someexplanationsonlazyloadingone-to-one< /a>

---

[编辑以包含解决方法]

您可以使用 optional=false 和@LazyToOne 用于非可选关系。不要忘记包含 cascade={CascadeType.PERSIST,CascadeType.REMOVE}。因为，对于非可选关系来说，这是显而易见的。下面是一个示例，

@OneToOne(mappedBy="parent", optional=false, fetch=FetchType.LAZY, cascade={CascadeType.PERSIST,CascadeType.REMOVE})
@LazyToOne(LazyToOneOption.PROXY)
public Child getChild(){...}

这应该适合您，因为我可以看到您正在使用 cascade=CascadeType.ALL，这意味着不可选。不是吗？但对于可选关系，您可能需要考虑iliaden，此处给出的解决方法。

Answer 3

您是否尝试过@OneToOne(fetch = FetchType.LAZY，可选= false)？
另请查看此博客和此主题。

Answer 4

@一对一关系不支持延迟初始化。
要获取对象，您不要将 FetchType.LAZY 放入子类中并获取所有子对象。

class Parent

@OneToOne(mappedBy = "parent", cascade = CascadeType.REMOVE)
public Child getChild()

class Child

@OneToOne(cascade = CascadeType.REMOVE)
public Parent getParent()