Grails Webflow - garder les choses * * hors du champ d'écoulement

Question

Je manque quelque chose ....

J'ai un webflow Grails qui ressemble à ceci: -

def childFlow = {
        start {
            action {
                def targets = []
                Target.list().each {target ->
                    targets.add(new TargetCommand(name: target.name, id: target.id))
                }
                log.debug "targets are $targets"
                [children: targets]
            }
            on('success').to('selectChild')
        }
        ...

TargetCommand est sérialisable. mais je reçois cette erreur: -

Caused by: java.io.NotSerializableException: com.nerderg.groupie.donate.Target

Pour une raison quelconque l'objet « cible » qui est à l'intérieur du client.list (). Chaque {} fermeture devient mis dans le champ d'écoulement et je ne peux pas comprendre comment le marquer comme transitoire.

J'ai un code dans un service qui a des objets placés dans le champ d'écoulement lorsque je ne veux pas qu'ils aussi.

Comment puis-je arrêter les variables transitoires locales des fermetures étant mis dans le champ d'écoulement?

Answer 1

Affinage la réponse ci-dessus au lieu de dégager la persistenceContext nous simplement expulser les instances que nous finissons avec eux, comme suit:

    Target.list().each {
        targets.add(new TargetCommand(name: it.name, id: it.id))
        flow.persistenceContext.evict(it)
    }

Il est encore un travail autour pour ne pas être en mesure de marquer les variables de fermeture comme transitoire

Answer 2

La réponse à ma question est:

l'objet d'écoulement est une carte qui contient une référence à la « persistenceContext » qui est un org.hibernate.impl.SessionImpl de sorte que le flux essaie de stocker toute la session, même si les objets ne sont pas modifiés (pour le contexte, je suppose )

incorrect par exemple de Grails 1.1.x doc nous donne une idée de ce qu'il faut faire:

processPurchaseOrder  {
     action {
         def a =  flow.address
         def p = flow.person
         def pd = flow.paymentDetails
         def cartItems = flow.cartItems
         flow.clear()

    def o = new Order(person:p, shippingAddress:a, paymentDetails:pd) 
    o.invoiceNumber = new Random().nextInt(9999999) cartItems.each { o.addToItems(it) }
    o.save() 
    [order:o] } 
    on("error").to "confirmPurchase" 
    on(Exception).to "confirmPurchase" 
    on("success").to "displayInvoice" 
}

Le flow.clear () efface la totalité de la carte de débit, y compris la persistenceContext ou la session, ce qui rend alors tout le flux échouent à cause du manque d'une session.

de sorte que la « solution » intermédiaire est d'utiliser la persistenceContext et dans ce cas il clair. Donc, cela fonctionne: -

def childFlow = {
        start {
            action {
                sponsorService.updateTargetsFromTaggedContent()
                def targets = []

                Target.list().each {
                    targets.add(new TargetCommand(name: it.name, id: it.id))
                }

                flow.persistenceContext.clear()
                [children: targets]
            }
            on('success').to('selectChild')
            on(Exception).to 'finish'
        }

Le problème évident avec ceci est que la session est effacée complètement, au lieu de simplement garder les choses que je ne veux pas dans le flux.

Answer 3

faute d'une meilleure façon, voici une solution généralisée qui supprime tout objet non Serializable de la persistenceContext du flux. Cela pourrait être une méthode de service donné le débit: -

def remove = []
flow.persistenceContext.getPersistenceContext().getEntitiesByKey().values().each { entity ->
    if(!entity instanceof Serializable){
        remove.add(entity)
    }
}
remove.each {flow.persistenceContext.evict(it)}

Answer 4

Si comme moi vous avez besoin d'expulser tout peut-être que vous aimez faire

flow.persistenceContext.flush()
flow.persistenceContext.persistenceContext.clear()