1

我需要弄清楚如何将级联保存到 playframework 1.x 中的特定类扩展模型中。我需要钩子，以便我可以执行一段代码，该代码将在持久性之前重新计算对象上的数据字段，使用的数据最终来自属于级联到对象的其他类的模型对象的数据字段。

由 .save() 启动的实际过程似乎对挂钩非常有抵抗力。我无法挂钩 saveAndCascade() 并且创建 setWillBeSaved() 方法也没有提供挂钩，即使 playframework 文档似乎建议它应该这样做。

我有一个解决方案，但它似乎是一个相当“糟糕”的解决方案，它涉及在不需要的时候欺骗 hibernate 进行写入的黑客攻击。

hack 解决方案是向对象添加一个“hack”布尔字段，并在每次加载、持久化或更新对象时切换该字段。这是为了使它永远不干净。

这样做是因为到目前为止我能找到的唯一钩子是一个用@PrePersist 和@PreUpdate 注释的方法。问题是，如果 hibernate 不相信对象是脏的，它就不会调用带注释的方法。当数据字段在级联到相关对象中的一个相关对象中发生更改时，这会产生问题，这应该提示重新计算，这会使干净的对象变脏，但是重新计算不会发生，因为休眠认为对象是干净的。

这是我正在使用的解决方案的简单版本（圣桶添加了 4 个烦人的空格）。持久化以下任何一个对象都会导致对象 A 以正确的 a 值持久化。

@Entity
public class A extends Model
{
    @OneToMany(mappedBy="a", cascade = CascadeType.ALL)
    private List<B> bList = new ArrayList<B>();
    private Integer a = 0;
    private Boolean hack = true;

    //algorithm that only matters to the question so far as it uses data fields from B and C.
    public Integer getA()
    {
        Integer returnValue = 0;

        for(B b : bList)
        {
            returnValue = returnValue + b.getB();

            for(C c : b.getCList())
            {
                returnValue = returnValue + c.getC();
            }
        }

    return  returnValue;
    }

    public void setBList(List<B> bList)
    {
        this.bList = bList;
    }

    public List<B> getBList()
    {
        return bList;
    }

    //Hibernate will not call this method if it believes the object to be clean.
    @PrePersist
    @PreUpdate
    private void recalculateA()
    {
        hack = !hack; //remove the dirt and cross our fingers that hibernate won't write if the object is no longer dirty.
        a = getA(); //recalculate the value of A, reflecting the changes made in the objects cascading into A.
    }

    //Hack to put dirt on every clean object to force hibernate to call recalculateA whenever someone tries to save A.
    @PostPersist
    @PostUpdate
    @PostLoad
    private void hack()
    {
        hack = !hack;
    }

}

-

@Entity
public class B extends Model
{
    @ManyToOne(cascade = CascadeType.ALL)
    private A a;

    @OneToMany(mappedBy = "b",  cascade = CascadeType.ALL)
    private List<C> cList = new ArrayList<C>();

    private Integer b = 0;

    public List<C> getCList()
    {
        return cList;
    }

    public void setCList(List<C> cList)
    {
        this.cList = cList;
    }

    public void setA(A a)
    {
        this.a = a;
    }

    public void setB(Integer b)
    {
        this.b = b;
    }

    public Integer getB()
    {
        return b;
    }

}

@Entity
public class C extends Model
{
    @ManyToOne(cascade = CascadeType.ALL)
    private B b;

    private Integer c = 0;

    public C(Integer c)
    {
        this.c = c;
    }

    public Integer getC()
    {
        return c;
    }

    public void setC(Integer c)
    {
        this.c = c;
    }

    public void setB(B b)
    {
        this.b = b;
    }
}

我的“必须有更好的方法来做到这一点”的感觉非常刺痛。

4

2 回答 2

0

您可以覆盖您保存的根对象上的保存方法，并从那里调用您的计算方法。

对我来说，将业务计算隐藏到持久化流程中并不是一件好事，因为您确保每次都调用它，但是您将其隐藏到需要技术知识的流程中。

通过某种“calculateAndSave”方法显式调用这个计算方法，会更清楚。

于 2012-11-19T06:49:33.513 回答
0

另一种解决方案是强制hibernate通过getA方法获取a值

@Entity
public class A extends Model
{
    @OneToMany(mappedBy="a", cascade = CascadeType.ALL)
    private List<B> bList = new ArrayList<B>();
    @Transient
    private Integer a = 0;
    private Boolean calculated = false;

    @Access(AccessType.PROPERTY)
    public Integer getA()
    {
        if (!calculated) {
            Integer returnValue = 0;

            for(B b : bList)
            {
                returnValue = returnValue + b.getB();

                for(C c : b.getCList())
                {
                    returnValue = returnValue + c.getC();
                }
            }

            a = returnValue;
            calculated = true;
        }
        return a;
    }

    public void setBList(List<B> bList)
    {
        this.bList = bList;
        calculated = false;
    }

    public List<B> getBList()
    {
        return bList;
    }
}

但这意味着你可以在每次计算源发生变化时使计算标志无效，这在 b 对象的 cList 发生变化时可能会很困难。

如果您的计算不是那么繁重，您也可以避免计算标志并在每次调用 getA 时重做这是最简单的解决方案，但不是最高性能

于 2012-11-20T06:43:51.480 回答