Is it necessary to call a flush() (JPA interface) in this situation?

Question

Because calling a flush() to get every entities persist from memory to database. So if I use call too much unnecessary flush(), it could take much time therefore not a good choice for the performance. Here is a scenario that I don't know when to call a flush()?

//Order and Item have Bidirectional Relationships
Order ord = New ord("my first order");
Item item = New Item("tv",10);

//...process item and ord object

em.persist(ord);//em is an instance of EntityManager
em.flush();// No.1 flush()

item.setOrder(ord);
em.persist(item);

Set<Item> items= new HashSet<Item>();
items.add(item);
ord.setItems(items);

em.flush();// No.2 flush()

My question is: calling of the No.1 flush could be avoid or not?

The things I worried is: in order to do the item.setOrder(ord), we need an database id of ord. And calling only em.persist(ord) cannot generate an database id, so I have to call the em.flush() before item.setOrder(ord). So what's your opinion guys?

Thanks in advance.

Answer 1

i should first construct the structure, and after that persist everything.

Order ord = New ord("my first order");
Item item = New Item("tv",10);

item.setOrder(ord);

Set<Item> items= new HashSet<Item>();
items.add(item);
ord.setItems(items);

em.persist(ord);

In this way, you persist the whole tree in one call and is flush not needed.

In good object design, you should use the way duffymo described to wire your objects.

Answer 2

I think you should be doing all this in a transactional context and let it handle these issues for you.

You need to embed the bidirectional relationship in the objects:

class Parent
{
    private List<Child> children;

    public boolean addChild(Child c)
    {
        c.setParent(this); // this is the key piece

        return this.children.add(c);
    }
}

class Child
{
   private Parent parent;

   public void setParent(Parent p)
   {
      this.parent = p;
   }
}