Primavera avviare una transazione con oggetto creato da nuovo

Question

Ho una classe POJO con un metodo annotato con @Transactional

public class Pojo {

    @Transactional
    public void doInTransaction() {
        ...
    }
}

Primavera gestione dichiarativa delle transazioni è basata su AOP, ma non ho alcuna esperienza con questo. La mia domanda è: È possibile che quando si richiama il (new Pojo).doInTransaction() da solo, Primavera inizierà una transazione.

Answer 1

Spring dichiarativa delle transazioni di gestione si basa su APO, ma io no hanno alcuna esperienza con questo.

mi sento di raccomandare di iniziare a lavorare con esso e si otterrà l'esperienza di utilizzo consigli transazione utilizzando AOP. Un buon punto di partenza è href="http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/transaction.html" qui .

E 'possibile che quando si richiama il (Nuova Pojo) .doInTransaction () da solo, Primavera inizierà una transazione.

No, non si può pretendere di Primavera di essere a conoscenza di un fagiolo che è stato richiamato manualmente. Tuttavia, sembra che si vogliono evitare di gestione dichiarativa delle transazioni e di fare la gestione delle transazioni programmatica. C'è un modo per farlo con la Primavera utilizzando il modello di transazione . E 'questo quello che cercavi?

Answer 2

E 'un po' possibile, ma in modo ingombrante: È necessario utilizzare il AutowireCapableBeanFactory meccanismo.

Ecco una classe transazionale come ad esempio

public interface FooBar{
    void fooIze(Object foo);
}

public class FooBarImpl implements FooBar{
    @Transactional
    @Override
    public void fooIze(final Object foo){
        // do stuff here
    }
}

Ed ecco come possiamo usarlo:

public class FooService implements ApplicationContextAware{

    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(
    final ApplicationContext applicationContext){
        this.applicationContext = applicationContext;
    }

    public void serviceMethod(){

        //declare variable as interface, initialize to implementation
        FooBar fooBar = new FooBarImpl();

        // try to use it, won't work, as it's not a proxy yet
        Object target = new Object[0];
        fooBar.fooIze(target); // no transaction

        // now let spring create the proxy and re-assign the variable
        // to the proxy:
        fooBar = // this is no longer an instance of FooBarImpl!!!
            (FooBar) applicationContext
                .getAutowireCapableBeanFactory()
                .applyBeanPostProcessorsAfterInitialization(fooBar,
                    "someBeanName");
        fooBar.fooIze(fooBar); // this time it should work

    }

}

Questa non è una pratica migliore. Per prima cosa, rende l'applicazione molto consapevoli della Spring Framework e anche, esso viola i principi iniezione di dipendenza. Quindi utilizzare questo solo se non c'è altro modo!

Answer 3

Si, è possibile. Primavera non richiedere l'uso di proxy dinamici per @Transactional al lavoro. Invece, è possibile utilizzare "vero AOP", come previsto dalla AspectJ.

Per i dettagli, vedere http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/transaction.html#transaction-declarative-aspectj

Answer 4

La maniglia Primavera modo in cui la transazione attraverso annotazione sta usando AOP come hai detto. Il bit AOP viene implementato utilizzando Dynamic Proxy (vedi doc )

Quindi, al fine di farlo avrete bisogno di recuperare un'istanza della classe (Pojo qui) attraverso il contenitore primavera dal momento che per farlo funzionare, Primavera restituirà un proxy dinamico sopra la vostra Pojo che verrà automaticamente surround a qualsiasi annotato il metodo con il codice di gestione delle transazioni.

Se semplicemente fare un

Pojo p = new Pojo();
p.doInTransaction();

Primavera non ha alcun ruolo da svolgere e la chiamata metodo non sarà all'interno di una transazione.

in modo che cosa dovete fare è qualcosa di simile

ApplicationContext springContext = ...;
Pojo p = (Pojo) springContext.getBean("your.pojo.id");
p.doInTransaction();

Nota: questo è un esempio, si dovrebbe preferire l'iniezione di dipendenza invece di recuperare il bean manualmente dal contesto

In questo modo, e con un contesto Primavera configurato correttamente, Primavera dovrebbe avere vedetta vostre classi per la scansione per l'annotazione transazionale e avvolto automaticamente i fagioli in annotazione a conoscenza istanze proxy dinamici. Dal tuo punto di vista che non cambia nulla, ci si può comunque lanciare l'oggetto alle proprie classi, ma se si tenta di stampare il nome della classe del contesto primavera Pojo di fagioli, si otterrà qualcosa come proxy $. .. e non il tuo nome della classe originale.

Date un'occhiata a questo link in ogni caso: link di testo