Question

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

由.save（）启动的实际进程似乎非常适合挂钩。我无法挂钩saveAndCascade（）并且创建setWillBeSaved（）方法也没有提供钩子，即使playframework文档似乎表明它应该。

我有一个解决方案，但它似乎是一个相当“糟糕”的解决方案，它涉及到一个hack来欺骗hibernate写入它不应该的时候。

黑客解决方案是向对象添加“hack”布尔字段，并在每次加载，保留或更新对象时切换字段。这是为了使它永远不干净。

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

这是我正在使用的解决方案的简单版本（神圣的桶增加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;
    }
}

我的“必须有一个更好的方法来做到这一点”感觉很刺激。

Answer 1

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

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

通过某种“calculateAndSave”方法显式调用此计算方法使其更清晰。

Answer 2

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

@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时重做它这是最简单的解决方案但不是最高效的

我需要在play framework 1.x中挂钩级联保存

}

2 个答案: