Работает ли атрибут Spring @Transactional с закрытым методом?

Если у меня есть аннотация @Transactional для закрытого метода в бине Spring, оказывает ли аннотация какое-либо влияние?

Если @Transactionalаннотация находится в открытом методе, она работает и открывает транзакцию.

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

  }
}

...

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

Вопрос не является частным или публичным, вопрос в том, как он вызывается и какую реализацию AOP вы используете!

Если вы используете (по умолчанию) Spring Proxy AOP, то все функциональные возможности AOP, предоставляемые Spring (например @Transational), будут приниматься во внимание, только если вызов проходит через прокси. - Обычно это так, если аннотированный метод вызывается из другого компонента.

Это имеет два значения:

• Поскольку закрытые методы не должны вызываться из другого компонента (исключение составляет отражение), их @Transactionalаннотация не учитывается.
• Если метод общедоступен, но вызывается из того же компонента, он также не будет учитываться (это утверждение верно только в том случае, если используется (по умолчанию) Spring Proxy AOP).

@ См. Spring Reference: Глава 9.6 9.6 Механизмы прокси

ИМХО, вы должны использовать режим aspectJ вместо Spring Proxies, который решит проблему. А транзакционные аспекты AspectJ вплетены даже в приватные методы (проверено на Spring 3.0).

Ответ на ваш вопрос - нет - не @Transactionalбудет иметь никакого эффекта, если используется для аннотирования частных методов. Прокси-генератор будет игнорировать их.

Это задокументировано в руководстве по весне, глава 10.5.6 :

Видимость метода и @Transactional

При использовании прокси вы должны применять @Transactionalаннотацию только к методам с публичной видимостью. Если вы аннотируете защищенные, частные или видимые пакетами методы с @Transactionalаннотацией, ошибка не возникает, но аннотированный метод не отображает настроенные параметры транзакции. Рассмотрите возможность использования AspectJ (см. Ниже), если вам нужно аннотировать закрытые методы.

По умолчанию @Transactionalатрибут работает только при вызове аннотированного метода для ссылки, полученной из applicationContext.

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

  }
}

Это откроет транзакцию:

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

Это не будет:

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

Spring Reference: Использование @Transactional

Примечание. В режиме прокси (который используется по умолчанию) будут перехватываться только вызовы внешних методов, поступающие через прокси. Это означает, что «самовывоз», то есть метод в целевом объекте, вызывающий какой-либо другой метод целевого объекта, не приведет к реальной транзакции во время выполнения, даже если вызываемый метод помечен знаком @Transactional!

Подумайте об использовании режима AspectJ (см. Ниже), если вы ожидаете, что самообращения будут также обернуты транзакциями. В этом случае, во-первых, не будет прокси; вместо этого целевой класс будет «соткан» (т. е. его байтовый код будет изменен), чтобы превратить его @Transactionalв поведение во время выполнения для любого метода.

Да, можно использовать @Transactional для частных методов, но, как уже упоминали другие, это не будет работать из коробки. Вам нужно использовать AspectJ. Мне потребовалось некоторое время, чтобы понять, как заставить это работать. Я поделюсь своими результатами.

Я решил использовать ткачество во время компиляции, а не ткачество во время загрузки, потому что я думаю, что это в целом лучший вариант. Кроме того, я использую Java 8, поэтому вам может потребоваться настроить некоторые параметры.

Сначала добавьте зависимость для aspectjrt.

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

Затем добавьте плагин AspectJ, чтобы выполнить фактическое переплетение байт-кода в Maven (это может быть не минимальным примером).

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

Наконец добавьте это в ваш класс конфигурации

@EnableTransactionManagement(mode = AdviceMode.ASPECTJ)

Теперь вы должны иметь возможность использовать @Transactional для закрытых методов.

Одно предостережение об этом подходе: вам нужно будет сконфигурировать свою среду IDE, чтобы иметь представление об AspectJ, иначе, если вы запустите приложение, например, через Eclipse, оно может не работать. Удостоверьтесь, что вы проверяете против прямой сборки Maven как проверку работоспособности.

Если вам нужно обернуть закрытый метод внутри транзакции и не хотите использовать aspectj, вы можете использовать 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(){
        //...
    }

}

Весенние Документы объясняют это

В режиме прокси (который используется по умолчанию) перехватываются только внешние вызовы методов, поступающие через прокси. Это означает, что самовывоз, по сути, метод в целевом объекте, вызывающий другой метод целевого объекта, не приведет к фактической транзакции во время выполнения, даже если вызванный метод помечен @Transactional.

Подумайте об использовании режима AspectJ (см. Атрибут mode в таблице ниже), если вы ожидаете, что самовыводы также будут обернуты транзакциями. В этом случае, во-первых, не будет прокси; вместо этого целевой класс будет соткан (то есть его байт-код будет изменен), чтобы превратить @Transactional в поведение во время выполнения любого метода.

Другим способом является пользователь BeanSelfAware

Ответ - нет. Пожалуйста, смотрите Spring Reference: Использование @Transactional :

@TransactionalАннотаций может быть помещен перед определением интерфейса, метод на интерфейс, определение класса, или общественный способ по классу

Так же, как @loonis предложил использовать TransactionTemplate, можно использовать этот вспомогательный компонент (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()
    }
}

Использование:

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

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

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

Не знаю, TransactionTemplateиспользовать повторно существующую транзакцию или нет, но этот код определенно делает.