L'attribut Spring @Transactional fonctionne-t-il sur une méthode privée?

Si j'ai une annotation @Transactional sur une méthode privée dans un bean Spring, l'annotation a-t-elle un effet?

Si l' @Transactionalannotation est sur une méthode publique, elle fonctionne et ouvre une transaction.

public class Bean {
  public void doStuff() {
     doPrivateStuff();
  }
  @Transactional
  private void doPrivateStuff() {

  }
}

...

Bean bean = (Bean)appContext.getBean("bean");
bean.doStuff();

La question n'est pas privée ou publique, la question est: comment est-elle invoquée et quelle implémentation AOP vous utilisez!

Si vous utilisez (par défaut) Spring Proxy AOP, toutes les fonctionnalités AOP fournies par Spring (comme @Transational) ne seront prises en compte que si l'appel passe par le proxy. - C'est normalement le cas si la méthode annotée est invoquée depuis un autre bean.

Cela a deux implications:

• Étant donné que les méthodes privées ne doivent pas être appelées à partir d'un autre bean (l'exception est la réflexion), leur @Transactionalannotation n'est pas prise en compte.
• Si la méthode est publique, mais qu'elle est invoquée à partir du même bean, elle ne sera pas prise en compte non plus (cette instruction n'est correcte que si (par défaut) Spring Proxy AOP est utilisé).

@See Spring Reference: Chapitre 9.6 9.6 Mécanismes de proxy

À mon humble avis, vous devriez utiliser le mode aspectJ, au lieu des Spring Proxies, qui résoudra le problème. Et les aspects transactionnels AspectJ sont tissés même dans des méthodes privées (vérifié pour Spring 3.0).

La réponse à votre question est non - @Transactionaln'aura aucun effet si elle est utilisée pour annoter des méthodes privées. Le générateur de proxy les ignorera.

Ceci est documenté dans le chapitre 10.5.6 du manuel Spring :

Visibilité de la méthode et @Transactional

Lorsque vous utilisez des proxys, vous devez appliquer l' @Transactionalannotation uniquement aux méthodes avec visibilité publique. Si vous annotez des méthodes protégées, privées ou visibles par package avec l' @Transactionalannotation, aucune erreur n'est générée, mais la méthode annotée ne présente pas les paramètres transactionnels configurés. Envisagez l'utilisation d'AspectJ (voir ci-dessous) si vous devez annoter des méthodes non publiques.

Par défaut, l' @Transactionalattribut ne fonctionne que lors de l'appel d'une méthode annotée sur une référence obtenue à partir de applicationContext.

public class Bean {
  public void doStuff() {
    doTransactionStuff();
  }
  @Transactional
  public void doTransactionStuff() {

  }
}

Cela ouvrira une transaction:

Bean bean = (Bean)appContext.getBean("bean");
bean.doTransactionStuff();

Cela ne va pas:

Bean bean = (Bean)appContext.getBean("bean");
bean.doStuff();

Référence Spring: utilisation de @Transactional

Remarque: En mode proxy (qui est la valeur par défaut), seuls les appels de méthode «externes» entrant via le proxy seront interceptés. Cela signifie que «l'auto-invocation», c'est-à-dire une méthode dans l'objet cible appelant une autre méthode de l'objet cible, ne conduira pas à une transaction réelle au moment de l'exécution même si la méthode invoquée est marquée avec @Transactional!

Envisagez l'utilisation du mode AspectJ (voir ci-dessous) si vous vous attendez à ce que les auto-invocations soient également enveloppées de transactions. Dans ce cas, il n'y aura pas de proxy en premier lieu; à la place, la classe cible sera «tissée» (c'est-à-dire que son code d'octets sera modifié) afin de se transformer @Transactionalen comportement d'exécution sur n'importe quel type de méthode.

Oui, il est possible d'utiliser @Transactional sur des méthodes privées, mais comme d'autres l'ont mentionné, cela ne fonctionnera pas hors de la boîte. Vous devez utiliser AspectJ. Il m'a fallu un certain temps pour comprendre comment le faire fonctionner. Je partagerai mes résultats.

J'ai choisi d'utiliser le tissage au moment de la compilation au lieu du tissage au temps de chargement parce que je pense que c'est une meilleure option globale. En outre, j'utilise Java 8, vous devrez donc peut-être ajuster certains paramètres.

Tout d'abord, ajoutez la dépendance pour aspectjrt.

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.8.8</version>
</dependency>

Ajoutez ensuite le plugin AspectJ pour effectuer le tissage de bytecode réel dans Maven (ce n'est peut-être pas un exemple minimal).

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>aspectj-maven-plugin</artifactId>
    <version>1.8</version>
    <configuration>
        <complianceLevel>1.8</complianceLevel>
        <source>1.8</source>
        <target>1.8</target>
        <aspectLibraries>
            <aspectLibrary>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
            </aspectLibrary>
        </aspectLibraries>
    </configuration>
    <executions>
        <execution>
            <goals>
                <goal>compile</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Enfin, ajoutez ceci à votre classe de configuration

@EnableTransactionManagement(mode = AdviceMode.ASPECTJ)

Vous devriez maintenant pouvoir utiliser @Transactional sur des méthodes privées.

Une mise en garde à cette approche: vous devrez configurer votre IDE pour être au courant d'AspectJ sinon si vous exécutez l'application via Eclipse par exemple, cela peut ne pas fonctionner. Assurez-vous de tester par rapport à une construction Maven directe comme test de santé mentale.

Si vous devez encapsuler une méthode privée dans une transaction et que vous ne souhaitez pas utiliser aspectj, vous pouvez utiliser TransactionTemplate .

@Service
public class MyService {

    @Autowired
    private TransactionTemplate transactionTemplate;

    private void process(){
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                processInTransaction();
            }
        });

    }

    private void processInTransaction(){
        //...
    }

}

Spring Docs explique que

En mode proxy (qui est la valeur par défaut), seuls les appels de méthode externes entrant via le proxy sont interceptés. Cela signifie que l'auto-invocation, en effet, une méthode dans l'objet cible appelant une autre méthode de l'objet cible, ne conduira pas à une transaction réelle au moment de l'exécution même si la méthode invoquée est marquée avec @Transactional.

Envisagez l'utilisation du mode AspectJ (voir l'attribut mode dans le tableau ci-dessous) si vous vous attendez à ce que les auto-invocations soient également enveloppées de transactions. Dans ce cas, il n'y aura pas de mandataire en premier lieu; à la place, la classe cible sera tissée (c'est-à-dire que son code d'octets sera modifié) afin de transformer @Transactional en comportement d'exécution sur n'importe quel type de méthode.

Un autre moyen est l'utilisateur BeanSelfAware

La réponse est non. Veuillez consulter Spring Reference: Using @Transactional :

L' @Transactionalannotation peut être placée avant une définition d'interface, une méthode sur une interface, une définition de classe ou une méthode publique sur une classe

De la même manière que @loonis a suggéré d'utiliser TransactionTemplate, on peut utiliser ce composant d'assistance (Kotlin):

@Component
class TransactionalUtils {
    /**
     * Execute any [block] of code (even private methods)
     * as if it was effectively [Transactional]
     */
    @Transactional
    fun <R> executeAsTransactional(block: () -> R): R {
        return block()
    }
}

Usage:

@Service
class SomeService(private val transactionalUtils: TransactionalUtils) {

    fun foo() {
        transactionalUtils.executeAsTransactional { transactionalFoo() }
    }

    private fun transactionalFoo() {
        println("This method is executed within transaction")
    }
}

Je ne sais pas si TransactionTemplateréutiliser la transaction existante ou non, mais ce code le fait certainement.