Empêcher Hibernate de supprimer les entités orphelines tout en fusionnant une entité ayant des associations d'entités avec orphanRemoval mis à true

Prendre un exemple très simple de un-à-plusieurs relations (pays -> état).

Pays (l'inverse de côté) :

@OneToMany(mappedBy = "country", fetch = FetchType.LAZY, cascade = CascadeType.ALL, orphanRemoval = true)
private List<StateTable> stateTableList=new ArrayList<StateTable>(0);

StateTable (propriétaire de côté) :

@JoinColumn(name = "country_id", referencedColumnName = "country_id")
@ManyToOne(fetch = FetchType.LAZY, cascade = {CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH, CascadeType.DETACH})
private Country country;

la méthode qui tente de mettre à jour un (detached) fourni StateTable entité au sein d'une transaction de base de données (JTA ou de ressources locales) :

public StateTable update(StateTable stateTable) {

    // Getting the original state entity from the database.
    StateTable oldState = entityManager.find(StateTable.class, stateTable.getStateId());
    // Get hold of the original country (with countryId = 67, for example).
    Country oldCountry = oldState.getCountry();
    // Getting a new country entity (with countryId = 68) supplied by the client application which is responsible for modifying the StateTable entity.
    // Country has been changed from 67 to 68 in the StateTable entity using for example, a drop-down list.
    Country newCountry = entityManager.find(Country.class, stateTable.getCountry().getCountryId());
    // Attaching a managed instance to StateTable.
    stateTable.setCountry(newCountry);

    // Check whether the supplied country and the original country entities are equal.
    // (Both not null and not equal - http://stackoverflow.com/a/31761967/1391249)
    if (ObjectUtils.notEquals(newCountry, oldCountry)) {
        // Remove the state entity from the inverse collection held by the original country entity.
        oldCountry.remove(oldState);
        // Add the state entity to the inverse collection held by the newly supplied country entity
        newCountry.add(stateTable);
    }

    return entityManager.merge(stateTable);
}

Il est à noter que orphanRemoval est réglé sur true. StateTable l'entité est fournie par une application client qui est intéressé à changer l'association entity Country (countryId = 67)StateTable pour autre chose (countryId = 68) (donc du côté inverse dans JPA, la migration d'une entité enfant de son parent (collection) à un autre parent (collection) qui orphanRemoval=true s'opposera à son tour).

Hibernate problèmes de fournisseur DELETE DML déclaration provoquant la ligne correspondant au StateTable entité à être retiré de la table sous-jacente.

Malgré le fait que orphanRemoval est réglé sur true, je m'attends à Hiberner à l'émission d'un régulierUPDATE instruction DML provoquant l'effet de orphanRemoval pour être suspendu dans son intégralité parce que le lien de parenté est migré (et non pas simplement supprimés).

EclipseLink fait exactement ce travail. Il émet un UPDATE énoncé dans le scénario donné (ayant la même relation avec orphanRemovaltrue).

lequel se comporte selon la spécification? Est-il possible de faire hiberner question UPDATE déclaration dans ce cas autre que supprimer orphanRemoval à partir de l'inverse de ce côté?

_{ce n'est qu'une tentative pour rendre une relation bidirectionnelle plus cohérente des deux côtés.}

_{les méthodes de gestion des liens défensifs à savoiradd() et remove() utilisé dans l'extrait ci-dessus, si nécessaire, sont définies dans le Country entité suivre.}

public void add(StateTable stateTable) {
    List<StateTable> newStateTableList = getStateTableList();

    if (!newStateTableList.contains(stateTable)) {
        newStateTableList.add(stateTable);
    }

    if (stateTable.getCountry() != this) {
        stateTable.setCountry(this);
    }
}

public void remove(StateTable stateTable) {
    List<StateTable> newStateTableList = getStateTableList();

    if (newStateTableList.contains(stateTable)) {
        newStateTableList.remove(stateTable);
    }
}

mise à Jour :

hibernation ne peut émettre qu'un UPDATE déclaration DML, si le code indiqué est modifié de la manière suivante.

public StateTable update(StateTable stateTable) {
    StateTable oldState = entityManager.find(StateTable.class, stateTable.getStateId());
    Country oldCountry = oldState.getCountry();
    // DELETE is issued, if getReference() is replaced by find().
    Country newCountry = entityManager.getReference(Country.class, stateTable.getCountry().getCountryId());

    // The following line is never expected as Country is already retrieved 
    // and assigned to oldCountry above.
    // Thus, oldState.getCountry() is no longer an uninitialized proxy.
    oldState.getCountry().hashCode(); // DELETE is issued, if removed.
    stateTable.setCountry(newCountry);

    if (ObjectUtils.notEquals(newCountry, oldCountry)) {
        oldCountry.remove(oldState);
        newCountry.add(stateTable);
    }

    return entityManager.merge(stateTable);
}

observez les deux lignes suivantes dans la nouvelle version du code.

// Previously it was EntityManager#find()
Country newCountry = entityManager.getReference(Country.class, stateTable.getCountry().getCountryId());
// Previously it was absent.
oldState.getCountry().hashCode();

Si la dernière ligne est absente ou EntityManager#getReference() est remplacé par EntityManager#find(), puis DELETE la déclaration DML est inattendue émettre.

Donc, ce qui se passe ici? Surtout, j'insiste sur la portabilité. Ne pas porter ce genre de base la fonctionnalité chez les différents fournisseurs JPA va à l'encontre de l'utilisation des cadres ORM.

_{je comprends la différence fondamentale entre EntityManager#getReference() et EntityManager#find().}