Change:

@Override @Begin
public void create() {
    super.create();
}

To:

@Override @Begin(flushMode=FlushModeType.MANUAL)
public void create() {
    super.create();
}

That will prevent the automatic flushing. Now, think of how you are going to architect this next. The first reaction might be to override the update and persist methods and remove the entityManager.flush(); method, but remember, it is needed for the persist method to actually set the ID, and the flush is the only effective line in the update method, so you should rearchitect your view or add more buttons.

The other and better option, now that I am reading your original post again, is to forget everything I said above, and just override the persist method like so:

@Transactional
   public String persist()
   {
      //Do your additional validation here before persisting
      getEntityManager().persist( getInstance() );
      getEntityManager().flush();
      assignId( PersistenceProvider.instance().getId( getInstance(), getEntityManager() ) );
      createdMessage();
      raiseAfterTransactionSuccessEvent();
      return "persisted";
   }

Also, have you considered writing your own hibernate validators?

Within your custom validator, you could create an instance of import org.jboss.seam.ui.validator.ModelValidator and invoke the model validation. You can put it before or after your own validation and it uses the hibernate annotations on your entity bean (if this is what you are looking for).

Nice idea with the custom validator. Unfortunately, I couldn't find good documentation about that topic in a rush. Do you mean implementing the custom validation by using the EntityListeners like described here?

Do you have any good bookmarks regarding that topic?

Thank you very much! That was a good idea. Unfortunately, it didn't work for me but you gave me an idea how to solve it.

The problem was caused by invoking the setters of the entity when a form was submitted. With the code snippet above you gave me an idea how to solve it. It is really simple:

public String update() {
    if (!valid()) {
        // rollback the updates caused by the setters
        Transaction.instance.rollback();
    }
    super.update();
}

I hope that this solution do not have any bad side effects. What do you think of this solution?