¿El atributo Spring @Transactional funciona en un método privado?

Si tengo una anotación @Transactional en un método privado en un bean Spring, ¿tiene algún efecto la anotación?

Si la @Transactionalanotación está en un método público, funciona y abre una transacción.

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

  }
}

...

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

La pregunta no es privada ni pública, la pregunta es: ¿cómo se invoca y qué implementación de AOP utiliza?

Si usa Spring Proxy AOP de Spring (predeterminado), toda la funcionalidad de AOP proporcionada por Spring (like @Transational) solo se tendrá en cuenta si la llamada pasa por el proxy. - Este suele ser el caso si el método anotado se invoca desde otro bean.

Esto tiene dos implicaciones:

• Como los métodos privados no deben invocarse desde otro bean (la excepción es la reflexión), su @Transactional Anotación no se tiene en cuenta.
• Si el método es público, pero se invoca desde el mismo bean, tampoco se tendrá en cuenta (esta declaración solo es correcta si se usa Spring Proxy AOP (predeterminado)).

@Ver Spring Reference: Capítulo 9.6 9.6 Mecanismos de representación

En mi humilde opinión, debe utilizar el modo aspectoJ, en lugar de los Spring Proxies, que resolverá el problema. Y los Aspectos transaccionales de AspectJ se entrelazan incluso en métodos privados (verificado para Spring 3.0).

La respuesta a su pregunta es no: no @Transactionaltendrá ningún efecto si se utiliza para anotar métodos privados. El generador proxy los ignorará.

Esto está documentado en Spring Manual, capítulo 10.5.6 :

Método de visibilidad y @Transactional

Al usar proxies, debe aplicar la @Transactionalanotación solo a los métodos con visibilidad pública. Si anota métodos protegidos, privados o visibles en el paquete con la @Transactionalanotación, no se genera ningún error, pero el método anotado no muestra la configuración transaccional configurada. Considere el uso de AspectJ (ver más abajo) si necesita anotar métodos no públicos.

Por defecto, el @Transactionalatributo solo funciona cuando se llama a un método anotado en una referencia obtenida de applicationContext.

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

  }
}

Esto abrirá una transacción:

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

Esto no:

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

Referencia de Spring: Uso de @Transactional

Nota: En el modo proxy (que es el predeterminado), solo se interceptarán las llamadas de método 'externas' que ingresen a través del proxy. Esto significa que la 'autoinvocación', es decir, un método dentro del objeto de destino que llama a algún otro método del objeto de destino, no dará lugar a una transacción real en tiempo de ejecución, incluso si el método invocado está marcado con@Transactional !

Considere el uso del modo AspectJ (ver más abajo) si espera que las autoinvocaciones también se envuelvan con transacciones. En este caso, no habrá un proxy en primer lugar; en su lugar, la clase objetivo se 'tejirá' (es decir, se modificará su código de bytes) para que se convierta @Transactionalen un comportamiento de tiempo de ejecución en cualquier tipo de método.

Sí, es posible usar @Transactional en métodos privados, pero como otros han mencionado, esto no funcionará de inmediato. Necesitas usar AspectJ. Me tomó un tiempo descubrir cómo hacerlo funcionar. Compartiré mis resultados.

Elegí usar el tejido en tiempo de compilación en lugar del tejido en tiempo de carga porque creo que es una mejor opción en general. Además, estoy usando Java 8, por lo que es posible que deba ajustar algunos parámetros.

Primero, agregue la dependencia para Aspectjrt.

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

Luego agregue el complemento AspectJ para hacer el tejido de código de bytes real en Maven (esto puede no ser un ejemplo mínimo).

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

Finalmente agregue esto a su clase de configuración

@EnableTransactionManagement(mode = AdviceMode.ASPECTJ)

Ahora debería poder usar @Transactional en métodos privados.

Una advertencia para este enfoque: necesitará configurar su IDE para conocer AspectJ; de lo contrario, si ejecuta la aplicación a través de Eclipse, por ejemplo, puede que no funcione. Asegúrate de probar contra una construcción directa de Maven como un control de cordura.

Si necesita ajustar un método privado dentro de una transacción y no desea usar Aspectj, puede usar 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 explican que

En el modo proxy (que es el predeterminado), solo se interceptan las llamadas a métodos externos que ingresan a través del proxy. Esto significa que la auto invocación, en efecto, un método dentro del objeto de destino que llama a otro método del objeto de destino, no dará lugar a una transacción real en tiempo de ejecución, incluso si el método invocado está marcado con @Transactional.

Considere el uso del modo AspectJ (consulte el atributo de modo en la tabla a continuación) si espera que las autoinvocaciones también se envuelvan con transacciones. En este caso, no habrá un proxy en primer lugar; en su lugar, la clase objetivo será tejida (es decir, su código de byte será modificado) para convertir @Transactional en comportamiento de tiempo de ejecución en cualquier tipo de método.

Otra forma es el usuario BeanSelfAware

La respuesta es no. Consulte la Referencia de Spring: Uso de @Transactional :

La @Transactionalanotación se puede colocar antes de una definición de interfaz, un método en una interfaz, una definición de clase o un método público en una clase

De la misma manera que @loonis sugirió usar TransactionTemplate, uno puede usar este componente auxiliar (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()
    }
}

Uso:

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

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

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

No sé si TransactionTemplatereutilizar la transacción existente o no, pero este código definitivamente lo hace.