Grails Webflow - manter as coisas * a * do escopo fluxo

Question

Eu estou faltando alguma coisa ....

Eu tenho um Grails Webflow parecida com esta: -

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 é serializável. mas eu recebo este erro: -

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

Por alguma razão o objeto "alvo" que está dentro do Target.list (). Cada {} fechamento é conseguir colocar no escopo de fluxo, e eu não consigo descobrir como marcá-lo como transitória.

Eu tenho algum código em um serviço que tem objetos colocados no âmbito fluxo quando eu não quero que eles também.

Como faço para parar de variáveis ??temporárias locais em fechamentos de ser colocado no âmbito do fluxo?

Answer 1

Refino a resposta acima, em vez de limpar o PersistenceContext nós simplesmente expulsar os casos que terminar com eles, assim:

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

Este ainda é um trabalho em torno de não ser capaz de marcar as variáveis ??de fechamento como transitória

Answer 2

A resposta para a minha pergunta é:?

o objeto fluxo está um mapa que contenha uma referência ao "PersistenceContext" que é uma org.hibernate.impl.SessionImpl então fluxo tenta armazenar toda a sessão, mesmo se os objetos não são alterados (por contexto Suponho )

este incorreta exemplo do Grails 1.1.x doc nos dá uma idéia do que fazer:?

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" 
}

O flow.clear () limpa o mapa de fluxo inteiro, incluindo o PersistenceContext ou a sessão, que, em seguida, faz com que todo o fluxo falhar devido à falta de uma sessão.

de modo a "solução" intermediária é usar o PersistenceContext e neste caso limpá-la. Então isso funciona: -

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'
        }

O problema óbvio com isso é que a sessão é apagado completamente, em vez de apenas manter as coisas que eu não quero no fluxo.

Answer 3

por falta de uma melhor maneira, aqui está uma solução generalizada que remove quaisquer objetos não serializáveis ??do PersistenceContext do fluxo. Este poderia ser um método de serviço dado o fluxo: -

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

Answer 4

Se gosta de mim você precisa para expulsar todos talvez você gostaria de fazer

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