Empêcher le bulldozer de déclencher le chargement différé d'Hibernate

Je suis en utilisant le Printemps des transactions de sorte que la transaction est toujours actif quand POJO à DTO conversion se produit.

Je voudrais empêcher les Bulldozers de déclencher le chargement paresseux, de sorte que caché des requêtes sql ne jamais se produire : tout l'extraction doit être fait explicitement via HQL (pour obtenir le meilleur contrôle sur les spectacles).

  1. Est-ce une bonne pratique (je ne le trouve pas documenté partout) ?
  2. Comment le faire en toute sécurité ?

J'ai essayé cela avant DTO conversion :

PlatformTransactionManager tm = (PlatformTransactionManager) SingletonFactoryProvider.getSingletonFactory().getSingleton("transactionManager");
tm.commit(tm.getTransaction(new DefaultTransactionDefinition()));

Je ne sais pas ce qui se passe à l'opération, mais la session Hibernate n'est pas fermé, et le chargement paresseux se produit encore.

J'ai essayé ceci :

SessionFactory sf = (SessionFactory) SingletonFactoryProvider.getSingletonFactory().getSingleton("sessionFactory");
sf.getCurrentSession().clear();
sf.getCurrentSession().close();

Et il empêche le chargement paresseux, mais est-ce une bonne pratique à manipuler session directement dans la couche d'application (qui est appelé la "façade" de mon projet) ? Qui effets secondaires négatifs aurais-je peur ? (J'ai déjà vu que les tests impliquant des POJO -> DTO conversions pourraient ne plus être lancé par AbstractTransactionnalDatasource Printemps classes de test, parce que cela les classes d'essayer de déclencher une restauration sur une transaction qui n'est pas plus liée à une session active).

J'ai aussi essayé de mettre de la propagation de NOT_SUPPORTED ou REQUIRES_NEW, mais il réutilisation de l'actuelle session Hibernate, et n'empêche pas le chargement paresseux.

source d'informationauteur Tristan

  1. 24

    La seule solution générique que j'ai trouvé pour la gestion de ce (après recherche dans des Convertisseurs, des Écouteurs d'Événements & Proxy Résolveurs) par la mise en œuvre d'un Champ Personnalisé de Mapper. J'ai trouvé cette fonctionnalité niché dans le Bulldozer de l'API (je ne crois pas qu'il est documenté dans le Guide de l'Utilisateur).

    Un exemple simple est la suivante;

    public class MyCustomFieldMapper implements CustomFieldMapper 
{
    public boolean mapField(Object source, Object destination, Object sourceFieldValue, ClassMap classMap, FieldMap fieldMapping) 
    {       
        //Check if field is a Hibernate collection proxy
        if (!(sourceFieldValue instanceof AbstractPersistentCollection)) {
            //Allow dozer to map as normal
            return false;
        }

        //Check if field is already initialized
        if (((PersistentSet) sourceFieldValue).wasInitialized()) {
            //Allow dozer to map as normal
            return false;
        }

        //Set destination to null, and tell dozer that the field is mapped
        destination = null;
        return true;
    }   
}

    Ce sera le retour de toute non-initialisé PersistentSet objets comme null. Je fais cela de sorte que quand ils sont transférés au client, je peux faire la différence entre un NULL (non chargé) collecte et le vide de la collection. Cela me permet de définir des génériques de comportement dans le client d'utiliser le pré-chargé de définir ou de faire un autre appel de service afin de récupérer l'ensemble (si nécessaire). En outre, si vous décidez de vous avec impatience de charger toutes les collections à l'intérieur de la couche de service, puis ils seront mappés comme d'habitude.

    J'ai injecter le champ personnalisé mappeur à l'aide de printemps:

    <bean id="dozerMapper" class="org.dozer.DozerBeanMapper" lazy-init="false">
    <property name="mappingFiles">
        ...
    </property>
    <property name="customFieldMapper" ref="dozerCustomFieldMapper" />
</bean>
<bean id="dozerCustomFieldMapper" class="my.project.MyCustomFieldMapper" />

    J'espère que cela aide quelqu'un à la recherche d'une solution pour cela, que je n'ai pas réussi à trouver des exemples lors de la recherche Internet.

  2. 9

    Une variation sur la version populaire ci-dessus, permet de s'assurer d'attraper les deux PersistentBags, PersistentSets, you name it...

    public class LazyLoadSensitiveMapper implements CustomFieldMapper {

public boolean mapField(Object source, Object destination, Object sourceFieldValue, ClassMap classMap, FieldMap fieldMapping) {
    //if field is initialized, Dozer will continue mapping

    //Check if field is derived from Persistent Collection
    if (!(sourceFieldValue instanceof AbstractPersistentCollection)) {
        //Allow dozer to map as normal
        return false;
    }

    //Check if field is already initialized
    if (((AbstractPersistentCollection) sourceFieldValue).wasInitialized()) {
        //Allow dozer to map as normal
        return false;
    }

    return true;
}

    }

  3. 5

    Je n'ai pas la ci-dessus pour travailler (sans doute différentes versions). Toutefois, cela fonctionne très bien

    public class HibernateInitializedFieldMapper implements CustomFieldMapper {
    public boolean mapField(Object source, Object destination, Object sourceFieldValue, ClassMap classMap, FieldMap fieldMapping) {
        //if field is initialized, Dozer will continue mapping
        return !Hibernate.isInitialized(sourceFieldValue));
    }
}
  4. 3

    Avez-vous pensé à désactiver le chargement paresseux?

    Il n'a pas vraiment l'air de jive avec les patrons vous de l'état que vous souhaitez utiliser:

    Je voudrais empêcher les Bulldozers de déclencher le chargement paresseux, de sorte que caché des requêtes sql ne jamais se produire : tout l'extraction doit être fait explicitement via HQL (pour obtenir le meilleur contrôle sur les spectacles).

    Cela suggère que vous ne voulez pas utiliser le chargement paresseux.

    De terrassement et mise en veille prolongée adossés à des haricots que vous transmettez sont béatement ignorant les uns les autres; tous les Bulldozers sait, c'est qu'il est accéder aux propriétés de la fève et de la mise en veille prolongée-soutenu bean est de répondre à des appels à get() un chargement paresseux collection comme il le ferait si vous étiez l'accès à ces propriétés vous-même.

    Toutes les astuces pour faire des Bulldozers au courant de l'Hibernation des procurations, les haricots ou vice versa serait, de l'OMI, de briser les couches de votre application.

    Si vous ne voulez pas de "caché requêtes SQL", tiré à des moments inattendus, il suffit de désactiver le chargement différé.

  5. 0

    Version courte de ce mappeur sera

    return sourceFieldValue instanceof AbstractPersistentCollection && 
!( (AbstractPersistentCollection) sourceFieldValue ).wasInitialized();
  6. 0

    À l'aide de CustomFieldMapper peut être pas une bonne idée car il va invoquer pour tous les champs de votre source de classe,mais notre souci est seulement paresseux cartographie de l'association de l'enfant(liste d'objets),de sorte que nous pouvons définir la valeur null dans les getter de l'entité objet,

    public Set<childObject> getChild() {
if(Hibernate.isInitialized(child){
    return childObject;
}else
 return null;
}