Spring démarrer une transaction avec un objet créé par la nouvelle

Question

J'ai une classe POJO avec une méthode annotée avec @Transactional

public class Pojo {

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

gestion des transactions Spring déclarative est basé sur AOP, mais je n'ai aucune expérience avec cela. Ma question est: Est-il possible que lors de l'appel du (new Pojo).doInTransaction() seul, le printemps va commencer une transaction.

Answer 1

  

Spring transaction déclarative   la gestion est basée sur APO mais je ne le font pas   ont une expérience avec cela.

Je recommande de commencer à travailler avec elle et vous obtiendrez l'expérience de l'utilisation des conseils de transaction en utilisant AOP. Un bon point de départ est ici .

  

Est-il possible que lors de l'appel du   (Nouveau Pojo) .doInTransaction () seul,   Le printemps va commencer une transaction.

Non, vous ne pouvez pas attendre printemps à être au courant d'un haricot que vous invoquez manuellement. Cependant, il semble que vous êtes désireux d'éviter la gestion déclarative des transactions et faire la gestion programmatique des transactions. Il y a une façon de le faire avec le printemps en utilisant la Transaction modèle . Est-ce que vous cherchez?

Answer 2

Il est un peu possible, mais d'une manière lourde: Vous devez utiliser le AutowireCapableBeanFactory mécanisme.

Voici une classe transactionnelle comme exemple

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

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

Et voici comment nous pouvons l'utiliser:

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

    }

}

Ce n'est pas une meilleure pratique. D'une part, il rend votre application très au courant du printemps-cadre et aussi, il viole les principes d'injection de dépendance. Il faut donc utiliser ce que s'il n'y a pas d'autre moyen!

Answer 3

Oui, possible. Le printemps fait pas exiger l'utilisation de procurations dynamiques pour @Transactional au travail. , Vous pouvez utiliser la "vraie AOP", tel que fourni par AspectJ.

Pour les détails, voir http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/transaction.html#transaction-declarative-aspectj

Answer 4

La façon dont la poignée de ressort de la transaction par Annotation utilise AOP comme vous l'avez dit. Le bit AOP est mis en œuvre à l'aide dynamique proxies (voir rel="nofollow"> )

Ainsi, afin de le faire, vous aurez besoin de récupérer une instance de votre classe (Pojo ici) à travers le récipient de printemps depuis pour le faire fonctionner, Spring vous renvoie un proxy dynamique sur votre Pojo qui automatiquement entourent toutes les annotée méthode avec le code de gestion des transactions.

Si vous faites simplement

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

Le printemps ne jouait aucun rôle à jouer et votre appel de méthode ne sera pas dans une transaction.

donc ce que vous devez faire est quelque chose comme ceci

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

Note: ceci est un exemple, vous devriez préférer l'injection de dépendance au lieu de récupérer votre bean manuellement à partir du contexte

En agissant ainsi, et avec un contexte printemps correctement configuré, le printemps devrait avoir vigie vos classes à analyser pour l'annotation transactionnelle et emballé automatiquement vos haricots dans les instances de serveurs proxy dynamiques d'annotation consciente. De votre point de vue qui ne change rien, vous aurez toujours votre objet à jeté vos propres classes, mais si vous essayez d'imprimer le nom de la classe de votre contexte de printemps haricot Pojo, vous obtenez quelque chose comme proxy $. .. et non votre nom de classe d'origine.

Jetez un oeil à ce lien de toute façon: texte du lien