diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java index baa50d95661..6df2757ab9c 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java @@ -979,7 +979,7 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto for (String beanName : beanNames) { Object singletonInstance = getSingleton(beanName); if (singletonInstance instanceof SmartInitializingSingleton smartSingleton) { - StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize") + StartupStep smartInitialize = getApplicationStartup().start("spring.beans.smart-initialize") .tag("beanName", beanName); smartSingleton.afterSingletonsInstantiated(); smartInitialize.end(); diff --git a/spring-context/src/main/java/org/springframework/context/support/DefaultLifecycleProcessor.java b/spring-context/src/main/java/org/springframework/context/support/DefaultLifecycleProcessor.java index b38035d6da0..89a029475aa 100644 --- a/spring-context/src/main/java/org/springframework/context/support/DefaultLifecycleProcessor.java +++ b/spring-context/src/main/java/org/springframework/context/support/DefaultLifecycleProcessor.java @@ -112,9 +112,10 @@ public class DefaultLifecycleProcessor implements LifecycleProcessor, BeanFactor /** - * Specify the maximum time allotted in milliseconds for the shutdown of - * any phase (group of SmartLifecycle beans with the same 'phase' value). - *

The default value is 30 seconds. + * Specify the maximum time allotted in milliseconds for the shutdown of any + * phase (group of {@link SmartLifecycle} beans with the same 'phase' value). + *

The default value is 30000 milliseconds (30 seconds). + * @see SmartLifecycle#getPhase() */ public void setTimeoutPerShutdownPhase(long timeoutPerShutdownPhase) { this.timeoutPerShutdownPhase = timeoutPerShutdownPhase; diff --git a/spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceTransactionManagerTests.java b/spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceTransactionManagerTests.java index f6cb99fbfca..dea00432629 100644 --- a/spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceTransactionManagerTests.java +++ b/spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceTransactionManagerTests.java @@ -83,7 +83,7 @@ public class DataSourceTransactionManagerTests { @AfterEach public void verifyTransactionSynchronizationManagerState() { - assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue(); + assertThat(TransactionSynchronizationManager.getResourceMap()).isEmpty(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); @@ -136,10 +136,8 @@ public class DataSourceTransactionManagerTests { final DataSource dsToUse = (lazyConnection ? new LazyConnectionDataSourceProxy(ds) : ds); tm = new DataSourceTransactionManager(dsToUse); TransactionTemplate tt = new TransactionTemplate(tm); - boolean condition3 = !TransactionSynchronizationManager.hasResource(dsToUse); - assertThat(condition3).as("Hasn't thread connection").isTrue(); - boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition2).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override @@ -165,10 +163,8 @@ public class DataSourceTransactionManagerTests { } }); - boolean condition1 = !TransactionSynchronizationManager.hasResource(dsToUse); - assertThat(condition1).as("Hasn't thread connection").isTrue(); - boolean condition = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); if (autoCommit && (!lazyConnection || createStatement)) { InOrder ordered = inOrder(con); @@ -229,10 +225,8 @@ public class DataSourceTransactionManagerTests { final DataSource dsToUse = (lazyConnection ? new LazyConnectionDataSourceProxy(ds) : ds); tm = new DataSourceTransactionManager(dsToUse); TransactionTemplate tt = new TransactionTemplate(tm); - boolean condition3 = !TransactionSynchronizationManager.hasResource(dsToUse); - assertThat(condition3).as("Hasn't thread connection").isTrue(); - boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition2).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); final RuntimeException ex = new RuntimeException("Application exception"); assertThatRuntimeException().isThrownBy(() -> @@ -256,10 +250,8 @@ public class DataSourceTransactionManagerTests { })) .isEqualTo(ex); - boolean condition1 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition1).as("Hasn't thread connection").isTrue(); - boolean condition = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); if (autoCommit && (!lazyConnection || createStatement)) { InOrder ordered = inOrder(con); @@ -279,10 +271,8 @@ public class DataSourceTransactionManagerTests { public void testTransactionRollbackOnly() throws Exception { tm.setTransactionSynchronization(DataSourceTransactionManager.SYNCHRONIZATION_NEVER); TransactionTemplate tt = new TransactionTemplate(tm); - boolean condition2 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition2).as("Hasn't thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); ConnectionHolder conHolder = new ConnectionHolder(con, true); TransactionSynchronizationManager.bindResource(ds, conHolder); @@ -292,10 +282,8 @@ public class DataSourceTransactionManagerTests { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); - boolean condition = !status.isNewTransaction(); - assertThat(condition).as("Is existing transaction").isTrue(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); + assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse(); throw ex; } }); @@ -303,16 +291,14 @@ public class DataSourceTransactionManagerTests { } catch (RuntimeException ex2) { // expected - boolean condition = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); assertThat(ex2).as("Correct exception thrown").isEqualTo(ex); } finally { TransactionSynchronizationManager.unbindResource(ds); } - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); } @Test @@ -330,10 +316,8 @@ public class DataSourceTransactionManagerTests { if (failEarly) { tm.setFailEarlyOnGlobalRollbackOnly(true); } - boolean condition2 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition2).as("Hasn't thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); TransactionStatus ts = tm.getTransaction(new DefaultTransactionDefinition()); TestTransactionSynchronization synch = @@ -348,21 +332,18 @@ public class DataSourceTransactionManagerTests { tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - boolean condition1 = !status.isNewTransaction(); - assertThat(condition1).as("Is existing transaction").isTrue(); + assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse(); assertThat(status.isRollbackOnly()).as("Is not rollback-only").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue(); - boolean condition = !status.isNewTransaction(); - assertThat(condition).as("Is existing transaction").isTrue(); + assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse(); status.setRollbackOnly(); } }); - boolean condition = !status.isNewTransaction(); - assertThat(condition).as("Is existing transaction").isTrue(); + assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse(); assertThat(status.isRollbackOnly()).as("Is rollback-only").isTrue(); } }); @@ -385,8 +366,7 @@ public class DataSourceTransactionManagerTests { } } - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); assertThat(synch.beforeCommitCalled).isFalse(); assertThat(synch.beforeCompletionCalled).isTrue(); assertThat(synch.afterCommitCalled).isFalse(); @@ -399,10 +379,8 @@ public class DataSourceTransactionManagerTests { public void testParticipatingTransactionWithIncompatibleIsolationLevel() throws Exception { tm.setValidateExistingTransaction(true); - boolean condition2 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition2).as("Hasn't thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); assertThatExceptionOfType(IllegalTransactionStateException.class).isThrownBy(() -> { final TransactionTemplate tt = new TransactionTemplate(tm); @@ -424,8 +402,7 @@ public class DataSourceTransactionManagerTests { }); }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); verify(con).rollback(); verify(con).close(); } @@ -435,10 +412,8 @@ public class DataSourceTransactionManagerTests { willThrow(new SQLException("read-only not supported")).given(con).setReadOnly(true); tm.setValidateExistingTransaction(true); - boolean condition2 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition2).as("Hasn't thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); assertThatExceptionOfType(IllegalTransactionStateException.class).isThrownBy(() -> { final TransactionTemplate tt = new TransactionTemplate(tm); @@ -461,18 +436,15 @@ public class DataSourceTransactionManagerTests { }); }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); verify(con).rollback(); verify(con).close(); } @Test public void testParticipatingTransactionWithTransactionStartedFromSynch() throws Exception { - boolean condition2 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition2).as("Hasn't thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); @@ -498,14 +470,12 @@ public class DataSourceTransactionManagerTests { } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); assertThat(synch.beforeCommitCalled).isTrue(); assertThat(synch.beforeCompletionCalled).isTrue(); assertThat(synch.afterCommitCalled).isTrue(); assertThat(synch.afterCompletionCalled).isTrue(); - boolean condition3 = synch.afterCompletionException instanceof IllegalStateException; - assertThat(condition3).isTrue(); + assertThat(synch.afterCompletionException).isInstanceOf(IllegalStateException.class); verify(con, times(2)).commit(); verify(con, times(2)).close(); } @@ -516,10 +486,8 @@ public class DataSourceTransactionManagerTests { final Connection con2 = mock(); given(ds2.getConnection()).willReturn(con2); - boolean condition2 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition2).as("Hasn't thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); final TransactionTemplate tt = new TransactionTemplate(tm); @@ -540,8 +508,7 @@ public class DataSourceTransactionManagerTests { } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); assertThat(synch.beforeCommitCalled).isTrue(); assertThat(synch.beforeCompletionCalled).isTrue(); assertThat(synch.afterCommitCalled).isTrue(); @@ -558,10 +525,8 @@ public class DataSourceTransactionManagerTests { DataSourceTransactionManager tm2 = new DataSourceTransactionManager(ds); // tm has no synch enabled (used at outer level), tm2 has synch enabled (inner level) - boolean condition2 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition2).as("Hasn't thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); TransactionStatus ts = tm.getTransaction(new DefaultTransactionDefinition()); final TestTransactionSynchronization synch = @@ -573,21 +538,18 @@ public class DataSourceTransactionManagerTests { tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - boolean condition1 = !status.isNewTransaction(); - assertThat(condition1).as("Is existing transaction").isTrue(); + assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse(); assertThat(status.isRollbackOnly()).as("Is not rollback-only").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue(); - boolean condition = !status.isNewTransaction(); - assertThat(condition).as("Is existing transaction").isTrue(); + assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse(); status.setRollbackOnly(); } }); - boolean condition = !status.isNewTransaction(); - assertThat(condition).as("Is existing transaction").isTrue(); + assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse(); assertThat(status.isRollbackOnly()).as("Is rollback-only").isTrue(); TransactionSynchronizationManager.registerSynchronization(synch); } @@ -596,8 +558,7 @@ public class DataSourceTransactionManagerTests { tm.commit(ts); }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); assertThat(synch.beforeCommitCalled).isFalse(); assertThat(synch.beforeCompletionCalled).isTrue(); assertThat(synch.afterCommitCalled).isFalse(); @@ -610,10 +571,8 @@ public class DataSourceTransactionManagerTests { public void testPropagationRequiresNewWithExistingTransaction() throws Exception { final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); - boolean condition2 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition2).as("Hasn't thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override @@ -639,8 +598,7 @@ public class DataSourceTransactionManagerTests { } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); verify(con).rollback(); verify(con).commit(); verify(con, times(2)).close(); @@ -659,12 +617,9 @@ public class DataSourceTransactionManagerTests { final TransactionTemplate tt2 = new TransactionTemplate(tm2); tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); - boolean condition4 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition4).as("Hasn't thread connection").isTrue(); - boolean condition3 = !TransactionSynchronizationManager.hasResource(ds2); - assertThat(condition3).as("Hasn't thread connection").isTrue(); - boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition2).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.hasResource(ds2)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override @@ -690,10 +645,8 @@ public class DataSourceTransactionManagerTests { } }); - boolean condition1 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition1).as("Hasn't thread connection").isTrue(); - boolean condition = !TransactionSynchronizationManager.hasResource(ds2); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.hasResource(ds2)).as("Hasn't thread connection").isFalse(); verify(con).commit(); verify(con).close(); verify(con2).rollback(); @@ -714,12 +667,9 @@ public class DataSourceTransactionManagerTests { final TransactionTemplate tt2 = new TransactionTemplate(tm2); tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); - boolean condition4 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition4).as("Hasn't thread connection").isTrue(); - boolean condition3 = !TransactionSynchronizationManager.hasResource(ds2); - assertThat(condition3).as("Hasn't thread connection").isTrue(); - boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition2).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.hasResource(ds2)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); assertThatExceptionOfType(CannotCreateTransactionException.class).isThrownBy(() -> tt.execute(new TransactionCallbackWithoutResult() { @@ -738,10 +688,8 @@ public class DataSourceTransactionManagerTests { } })).withCause(failure); - boolean condition1 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition1).as("Hasn't thread connection").isTrue(); - boolean condition = !TransactionSynchronizationManager.hasResource(ds2); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.hasResource(ds2)).as("Hasn't thread connection").isFalse(); verify(con).rollback(); verify(con).close(); } @@ -750,10 +698,8 @@ public class DataSourceTransactionManagerTests { public void testPropagationNotSupportedWithExistingTransaction() throws Exception { final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); - boolean condition2 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition2).as("Hasn't thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override @@ -765,11 +711,9 @@ public class DataSourceTransactionManagerTests { tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - boolean condition1 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition1).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue(); - boolean condition = !status.isNewTransaction(); - assertThat(condition).as("Isn't new transaction").isTrue(); + assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse(); assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); status.setRollbackOnly(); @@ -781,8 +725,7 @@ public class DataSourceTransactionManagerTests { } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); verify(con).commit(); verify(con).close(); } @@ -791,10 +734,8 @@ public class DataSourceTransactionManagerTests { public void testPropagationNeverWithExistingTransaction() throws Exception { final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); - boolean condition2 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition2).as("Hasn't thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); assertThatExceptionOfType(IllegalTransactionStateException.class).isThrownBy(() -> tt.execute(new TransactionCallbackWithoutResult() { @@ -812,8 +753,7 @@ public class DataSourceTransactionManagerTests { } })); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); verify(con).rollback(); verify(con).close(); } @@ -822,10 +762,8 @@ public class DataSourceTransactionManagerTests { public void testPropagationSupportsAndRequiresNew() throws Exception { TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS); - boolean condition2 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition2).as("Hasn't thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override @@ -846,8 +784,7 @@ public class DataSourceTransactionManagerTests { } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); verify(con).commit(); verify(con).close(); } @@ -861,10 +798,8 @@ public class DataSourceTransactionManagerTests { final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS); - boolean condition2 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition2).as("Hasn't thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override @@ -888,8 +823,7 @@ public class DataSourceTransactionManagerTests { } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); verify(con1).close(); verify(con2).commit(); verify(con2).close(); @@ -904,8 +838,7 @@ public class DataSourceTransactionManagerTests { tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); tt.setIsolationLevel(TransactionDefinition.ISOLATION_SERIALIZABLE); tt.setReadOnly(true); - boolean condition1 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition1).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) { @@ -915,8 +848,7 @@ public class DataSourceTransactionManagerTests { } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); InOrder ordered = inOrder(con); ordered.verify(con).setReadOnly(true); ordered.verify(con).setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE); @@ -939,8 +871,7 @@ public class DataSourceTransactionManagerTests { TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); tt.setReadOnly(true); - boolean condition1 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition1).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) { @@ -950,8 +881,7 @@ public class DataSourceTransactionManagerTests { } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); InOrder ordered = inOrder(con, stmt); ordered.verify(con).setReadOnly(true); ordered.verify(con).setAutoCommit(false); @@ -973,8 +903,7 @@ public class DataSourceTransactionManagerTests { TransactionTemplate tt = new TransactionTemplate(tm); tt.setTimeout(timeout); - boolean condition1 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition1).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); try { tt.execute(new TransactionCallbackWithoutResult() { @@ -1008,8 +937,7 @@ public class DataSourceTransactionManagerTests { } } - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); if (timeout > 1) { verify(ps).setQueryTimeout(timeout - 1); verify(con).commit(); @@ -1029,8 +957,7 @@ public class DataSourceTransactionManagerTests { given(con.getWarnings()).willThrow(new SQLException()); TransactionTemplate tt = new TransactionTemplate(tm); - boolean condition1 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition1).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) { @@ -1051,8 +978,7 @@ public class DataSourceTransactionManagerTests { } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); InOrder ordered = inOrder(con); ordered.verify(con).setAutoCommit(false); ordered.verify(con).commit(); @@ -1066,8 +992,7 @@ public class DataSourceTransactionManagerTests { final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionTemplate.PROPAGATION_REQUIRES_NEW); - boolean condition1 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition1).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override @@ -1111,8 +1036,7 @@ public class DataSourceTransactionManagerTests { } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); InOrder ordered = inOrder(con); ordered.verify(con).setAutoCommit(false); ordered.verify(con).commit(); @@ -1126,8 +1050,7 @@ public class DataSourceTransactionManagerTests { final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionTemplate.PROPAGATION_REQUIRES_NEW); - boolean condition1 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition1).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override @@ -1172,8 +1095,7 @@ public class DataSourceTransactionManagerTests { } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); InOrder ordered = inOrder(con); ordered.verify(con).setAutoCommit(false); ordered.verify(con).commit(); @@ -1197,8 +1119,7 @@ public class DataSourceTransactionManagerTests { } })); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); verify(con).close(); } @@ -1215,8 +1136,7 @@ public class DataSourceTransactionManagerTests { } })); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); verify(con).close(); } @@ -1234,8 +1154,7 @@ public class DataSourceTransactionManagerTests { } })); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); verify(con).rollback(); verify(con).close(); } @@ -1254,8 +1173,7 @@ public class DataSourceTransactionManagerTests { } })); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); InOrder ordered = inOrder(con); ordered.verify(con).setAutoCommit(false); ordered.verify(con).rollback(); @@ -1267,65 +1185,53 @@ public class DataSourceTransactionManagerTests { public void testTransactionWithPropagationSupports() throws Exception { TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS); - boolean condition1 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition1).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - boolean condition1 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition1).as("Hasn't thread connection").isTrue(); - boolean condition = !status.isNewTransaction(); - assertThat(condition).as("Is not new transaction").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(status.isNewTransaction()).as("Is not new transaction").isFalse(); assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); } @Test public void testTransactionWithPropagationNotSupported() throws Exception { TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED); - boolean condition1 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition1).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - boolean condition1 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition1).as("Hasn't thread connection").isTrue(); - boolean condition = !status.isNewTransaction(); - assertThat(condition).as("Is not new transaction").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(status.isNewTransaction()).as("Is not new transaction").isFalse(); } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); } @Test public void testTransactionWithPropagationNever() throws Exception { TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NEVER); - boolean condition1 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition1).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - boolean condition1 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition1).as("Hasn't thread connection").isTrue(); - boolean condition = !status.isNewTransaction(); - assertThat(condition).as("Is not new transaction").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(status.isNewTransaction()).as("Is not new transaction").isFalse(); } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); } @Test @@ -1350,37 +1256,32 @@ public class DataSourceTransactionManagerTests { final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED); - boolean condition2 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition2).as("Hasn't thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") + .isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertThat(status.isNewTransaction()).as("Is new transaction").isTrue(); - boolean condition1 = !status.hasSavepoint(); - assertThat(condition1).as("Isn't nested transaction").isTrue(); + assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse(); for (int i = 0; i < count; i++) { tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue(); - boolean condition = !status.isNewTransaction(); - assertThat(condition).as("Isn't new transaction").isTrue(); + assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse(); assertThat(status.hasSavepoint()).as("Is nested transaction").isTrue(); } }); } assertThat(status.isNewTransaction()).as("Is new transaction").isTrue(); - boolean condition = !status.hasSavepoint(); - assertThat(condition).as("Isn't nested transaction").isTrue(); + assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse(); } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); verify(con, times(count)).releaseSavepoint(sp); verify(con).commit(); verify(con).close(); @@ -1397,36 +1298,31 @@ public class DataSourceTransactionManagerTests { final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED); - boolean condition2 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition2).as("Hasn't thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") + .isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertThat(status.isNewTransaction()).as("Is new transaction").isTrue(); - boolean condition1 = !status.hasSavepoint(); - assertThat(condition1).as("Isn't nested transaction").isTrue(); + assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue(); - boolean condition = !status.isNewTransaction(); - assertThat(condition).as("Isn't new transaction").isTrue(); + assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse(); assertThat(status.hasSavepoint()).as("Is nested transaction").isTrue(); status.setRollbackOnly(); } }); assertThat(status.isNewTransaction()).as("Is new transaction").isTrue(); - boolean condition = !status.hasSavepoint(); - assertThat(condition).as("Isn't nested transaction").isTrue(); + assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse(); } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); verify(con).rollback(sp); verify(con).releaseSavepoint(sp); verify(con).commit(); @@ -1444,25 +1340,22 @@ public class DataSourceTransactionManagerTests { final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED); - boolean condition2 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition2).as("Hasn't thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") + .isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertThat(status.isNewTransaction()).as("Is new transaction").isTrue(); - boolean condition1 = !status.hasSavepoint(); - assertThat(condition1).as("Isn't nested transaction").isTrue(); + assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse(); assertThatIllegalStateException().isThrownBy(() -> tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue(); - boolean condition = !status.isNewTransaction(); - assertThat(condition).as("Isn't new transaction").isTrue(); + assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse(); assertThat(status.hasSavepoint()).as("Is nested transaction").isTrue(); TransactionTemplate ntt = new TransactionTemplate(tm); ntt.execute(new TransactionCallbackWithoutResult() { @@ -1470,23 +1363,19 @@ public class DataSourceTransactionManagerTests { protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue(); - boolean condition1 = !status.isNewTransaction(); - assertThat(condition1).as("Isn't new transaction").isTrue(); - boolean condition = !status.hasSavepoint(); - assertThat(condition).as("Is regular transaction").isTrue(); + assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse(); + assertThat(status.hasSavepoint()).as("Is regular transaction").isFalse(); throw new IllegalStateException(); } }); } })); assertThat(status.isNewTransaction()).as("Is new transaction").isTrue(); - boolean condition = !status.hasSavepoint(); - assertThat(condition).as("Isn't nested transaction").isTrue(); + assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse(); } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); verify(con).rollback(sp); verify(con).releaseSavepoint(sp); verify(con).commit(); @@ -1504,25 +1393,22 @@ public class DataSourceTransactionManagerTests { final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED); - boolean condition2 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition2).as("Hasn't thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") + .isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertThat(status.isNewTransaction()).as("Is new transaction").isTrue(); - boolean condition1 = !status.hasSavepoint(); - assertThat(condition1).as("Isn't nested transaction").isTrue(); + assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse(); assertThatExceptionOfType(UnexpectedRollbackException.class).isThrownBy(() -> tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue(); - boolean condition = !status.isNewTransaction(); - assertThat(condition).as("Isn't new transaction").isTrue(); + assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse(); assertThat(status.hasSavepoint()).as("Is nested transaction").isTrue(); TransactionTemplate ntt = new TransactionTemplate(tm); ntt.execute(new TransactionCallbackWithoutResult() { @@ -1530,23 +1416,19 @@ public class DataSourceTransactionManagerTests { protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue(); - boolean condition1 = !status.isNewTransaction(); - assertThat(condition1).as("Isn't new transaction").isTrue(); - boolean condition = !status.hasSavepoint(); - assertThat(condition).as("Is regular transaction").isTrue(); + assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse(); + assertThat(status.hasSavepoint()).as("Is regular transaction").isFalse(); status.setRollbackOnly(); } }); } })); assertThat(status.isNewTransaction()).as("Is new transaction").isTrue(); - boolean condition = !status.hasSavepoint(); - assertThat(condition).as("Isn't nested transaction").isTrue(); + assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse(); } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); verify(con).rollback(sp); verify(con).releaseSavepoint(sp); verify(con).commit(); @@ -1564,10 +1446,9 @@ public class DataSourceTransactionManagerTests { final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED); - boolean condition2 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition2).as("Hasn't thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") + .isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override @@ -1579,8 +1460,7 @@ public class DataSourceTransactionManagerTests { } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); verify(con).releaseSavepoint(sp); verify(con).commit(); verify(con).close(); @@ -1598,10 +1478,8 @@ public class DataSourceTransactionManagerTests { final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED); - boolean condition2 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition2).as("Hasn't thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override @@ -1613,8 +1491,7 @@ public class DataSourceTransactionManagerTests { } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); verify(con).rollback(sp); verify(con).commit(); verify(con).close(); @@ -1624,10 +1501,8 @@ public class DataSourceTransactionManagerTests { public void testTransactionWithPropagationNested() throws Exception { final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED); - boolean condition2 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition2).as("Hasn't thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override @@ -1636,8 +1511,7 @@ public class DataSourceTransactionManagerTests { } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); verify(con).commit(); verify(con).close(); } @@ -1646,10 +1520,8 @@ public class DataSourceTransactionManagerTests { public void testTransactionWithPropagationNestedAndRollback() throws Exception { final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED); - boolean condition2 = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition2).as("Hasn't thread connection").isTrue(); - boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive(); - assertThat(condition1).as("Synchronization not active").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override @@ -1659,8 +1531,7 @@ public class DataSourceTransactionManagerTests { } }); - boolean condition = !TransactionSynchronizationManager.hasResource(ds); - assertThat(condition).as("Hasn't thread connection").isTrue(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); verify(con).rollback(); verify(con).close(); } diff --git a/spring-jdbc/src/test/java/org/springframework/jdbc/support/JdbcTransactionManagerTests.java b/spring-jdbc/src/test/java/org/springframework/jdbc/support/JdbcTransactionManagerTests.java index 23bf666db42..7ceb54b2883 100644 --- a/spring-jdbc/src/test/java/org/springframework/jdbc/support/JdbcTransactionManagerTests.java +++ b/spring-jdbc/src/test/java/org/springframework/jdbc/support/JdbcTransactionManagerTests.java @@ -143,8 +143,7 @@ public class JdbcTransactionManagerTests { tm = new JdbcTransactionManager(dsToUse); TransactionTemplate tt = new TransactionTemplate(tm); assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override @@ -171,8 +170,7 @@ public class JdbcTransactionManagerTests { }); assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); if (autoCommit && (!lazyConnection || createStatement)) { InOrder ordered = inOrder(con); @@ -234,8 +232,7 @@ public class JdbcTransactionManagerTests { tm = new JdbcTransactionManager(dsToUse); TransactionTemplate tt = new TransactionTemplate(tm); assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); final RuntimeException ex = new RuntimeException("Application exception"); assertThatRuntimeException().isThrownBy(() -> @@ -260,8 +257,7 @@ public class JdbcTransactionManagerTests { .isEqualTo(ex); assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); if (autoCommit && (!lazyConnection || createStatement)) { InOrder ordered = inOrder(con); @@ -282,8 +278,7 @@ public class JdbcTransactionManagerTests { tm.setTransactionSynchronization(JdbcTransactionManager.SYNCHRONIZATION_NEVER); TransactionTemplate tt = new TransactionTemplate(tm); assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); ConnectionHolder conHolder = new ConnectionHolder(con, true); TransactionSynchronizationManager.bindResource(ds, conHolder); @@ -293,8 +288,7 @@ public class JdbcTransactionManagerTests { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse(); throw ex; } @@ -303,8 +297,7 @@ public class JdbcTransactionManagerTests { } catch (RuntimeException ex2) { // expected - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); assertThat(ex2).as("Correct exception thrown").isEqualTo(ex); } finally { @@ -330,8 +323,7 @@ public class JdbcTransactionManagerTests { tm.setFailEarlyOnGlobalRollbackOnly(true); } assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); TransactionStatus ts = tm.getTransaction(new DefaultTransactionDefinition()); TestTransactionSynchronization synch = @@ -394,8 +386,7 @@ public class JdbcTransactionManagerTests { tm.setValidateExistingTransaction(true); assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); assertThatExceptionOfType(IllegalTransactionStateException.class).isThrownBy(() -> { final TransactionTemplate tt = new TransactionTemplate(tm); @@ -428,8 +419,7 @@ public class JdbcTransactionManagerTests { tm.setValidateExistingTransaction(true); assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); assertThatExceptionOfType(IllegalTransactionStateException.class).isThrownBy(() -> { final TransactionTemplate tt = new TransactionTemplate(tm); @@ -460,8 +450,7 @@ public class JdbcTransactionManagerTests { @Test public void testParticipatingTransactionWithTransactionStartedFromSynch() throws Exception { assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); @@ -504,8 +493,7 @@ public class JdbcTransactionManagerTests { given(ds2.getConnection()).willReturn(con2); assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); final TransactionTemplate tt = new TransactionTemplate(tm); @@ -544,8 +532,7 @@ public class JdbcTransactionManagerTests { // tm has no synch enabled (used at outer level), tm2 has synch enabled (inner level) assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); TransactionStatus ts = tm.getTransaction(new DefaultTransactionDefinition()); final TestTransactionSynchronization synch = @@ -591,8 +578,7 @@ public class JdbcTransactionManagerTests { final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override @@ -639,8 +625,7 @@ public class JdbcTransactionManagerTests { assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); assertThat(TransactionSynchronizationManager.hasResource(ds2)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override @@ -690,8 +675,7 @@ public class JdbcTransactionManagerTests { assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); assertThat(TransactionSynchronizationManager.hasResource(ds2)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); assertThatExceptionOfType(CannotCreateTransactionException.class).isThrownBy(() -> tt.execute(new TransactionCallbackWithoutResult() { @@ -721,8 +705,7 @@ public class JdbcTransactionManagerTests { final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override @@ -734,8 +717,7 @@ public class JdbcTransactionManagerTests { tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection") - .isFalse(); + assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue(); assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse(); assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); @@ -759,8 +741,7 @@ public class JdbcTransactionManagerTests { final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); assertThatExceptionOfType(IllegalTransactionStateException.class).isThrownBy(() -> tt.execute(new TransactionCallbackWithoutResult() { @@ -788,8 +769,7 @@ public class JdbcTransactionManagerTests { TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS); assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override @@ -825,8 +805,7 @@ public class JdbcTransactionManagerTests { TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS); assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override @@ -1586,8 +1565,7 @@ public class JdbcTransactionManagerTests { final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED); assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override @@ -1610,8 +1588,7 @@ public class JdbcTransactionManagerTests { final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED); assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override @@ -1630,8 +1607,7 @@ public class JdbcTransactionManagerTests { final TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED); assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active") - .isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isFalse(); tt.execute(new TransactionCallbackWithoutResult() { @Override diff --git a/spring-jms/src/main/java/org/springframework/jms/listener/AbstractJmsListeningContainer.java b/spring-jms/src/main/java/org/springframework/jms/listener/AbstractJmsListeningContainer.java index a04ebc79caf..058a508f4cd 100644 --- a/spring-jms/src/main/java/org/springframework/jms/listener/AbstractJmsListeningContainer.java +++ b/spring-jms/src/main/java/org/springframework/jms/listener/AbstractJmsListeningContainer.java @@ -125,18 +125,19 @@ public abstract class AbstractJmsListeningContainer extends JmsDestinationAccess } /** - * Specify the phase in which this container should be started and - * stopped. The startup order proceeds from lowest to highest, and - * the shutdown order is the reverse of that. By default this value - * is Integer.MAX_VALUE meaning that this container starts as late - * as possible and stops as soon as possible. + * Specify the lifecycle phase in which this container should be started and stopped. + *

The startup order proceeds from lowest to highest, and the shutdown order + * is the reverse of that. The default is {@link #DEFAULT_PHASE} meaning that + * this container starts as late as possible and stops as soon as possible. + * @see SmartLifecycle#getPhase() */ public void setPhase(int phase) { this.phase = phase; } /** - * Return the phase in which this container will be started and stopped. + * Return the lifecycle phase in which this container will be started and stopped. + * @see #setPhase */ @Override public int getPhase() {