Compare commits

...

4 Commits

Author SHA1 Message Date
Dmytro Nosan 877877462d
Merge e2731f695c into 7e6874ad80 2025-10-07 23:10:35 +03:00
Sam Brannen 7e6874ad80 Polish @⁠Autowired section of the reference manual
Build and Deploy Snapshot / Build and Deploy Snapshot (push) Waiting to run Details
Build and Deploy Snapshot / Verify (push) Blocked by required conditions Details
Deploy Docs / Dispatch docs deployment (push) Waiting to run Details
2025-10-07 17:17:27 +02:00
Sam Brannen 097463e3b7 Remove outdated reference to JSR 305 in the reference documentation
Closes gh-35580
2025-10-07 17:10:40 +02:00
Dmytro Nosan e2731f695c Fix SingletonSupplier incorrectly handling null result
Previously, SingletonSupplier stored "null" in singletonInstance when
the supplied instance was "null". On subsequent get() calls, this was
treated as "uninitialized" and triggered another attempt to obtain an instance.

This commit ensures that a "null" returned from the instanceSupplier or
defaultSupplier is handled correctly, so that subsequent calls to get()
return "null" consistently instead of repeatedly invoking the supplier.

Signed-off-by: Dmytro Nosan <dimanosan@gmail.com>
2025-08-25 12:50:54 +03:00
4 changed files with 222 additions and 35 deletions

View File

@ -37,18 +37,18 @@ Kotlin::
----
======
[NOTE]
[TIP]
====
As of Spring Framework 4.3, an `@Autowired` annotation on such a constructor is no longer
necessary if the target bean defines only one constructor to begin with. However, if
several constructors are available and there is no primary/default constructor, at least
one of the constructors must be annotated with `@Autowired` in order to instruct the
container which one to use. See the discussion on
xref:core/beans/annotation-config/autowired.adoc#beans-autowired-annotation-constructor-resolution[constructor resolution] for details.
An `@Autowired` annotation on such a constructor is not necessary if the target bean
defines only one constructor. However, if several constructors are available and there is
no primary or default constructor, at least one of the constructors must be annotated
with `@Autowired` in order to instruct the container which one to use. See the discussion
on xref:core/beans/annotation-config/autowired.adoc#beans-autowired-annotation-constructor-resolution[constructor resolution]
for details.
====
You can also apply the `@Autowired` annotation to _traditional_ setter methods,
as the following example shows:
You can apply the `@Autowired` annotation to _traditional_ setter methods, as the
following example shows:
[tabs]
======
@ -84,8 +84,8 @@ Kotlin::
----
======
You can also apply the annotation to methods with arbitrary names and multiple
arguments, as the following example shows:
You can apply `@Autowired` to methods with arbitrary names and multiple arguments, as the
following example shows:
[tabs]
======
@ -176,14 +176,15 @@ Kotlin::
====
Make sure that your target components (for example, `MovieCatalog` or `CustomerPreferenceDao`)
are consistently declared by the type that you use for your `@Autowired`-annotated
injection points. Otherwise, injection may fail due to a "no type match found" error at runtime.
injection points. Otherwise, injection may fail due to a "no type match found" error at
runtime.
For XML-defined beans or component classes found via classpath scanning, the container
usually knows the concrete type up front. However, for `@Bean` factory methods, you need
to make sure that the declared return type is sufficiently expressive. For components
that implement several interfaces or for components potentially referred to by their
implementation type, consider declaring the most specific return type on your factory
method (at least as specific as required by the injection points referring to your bean).
implementation type, declare the most specific return type on your factory method (at
least as specific as required by the injection points referring to your bean).
====
.[[beans-autowired-annotation-self-injection]]Self Injection
@ -312,8 +313,8 @@ through `@Order` values in combination with `@Primary` on a single bean for each
====
Even typed `Map` instances can be autowired as long as the expected key type is `String`.
The map values contain all beans of the expected type, and the keys contain the
corresponding bean names, as the following example shows:
The map values are all beans of the expected type, and the keys are the corresponding
bean names, as the following example shows:
[tabs]
======
@ -431,7 +432,7 @@ annotated constructor does not have to be public.
====
Alternatively, you can express the non-required nature of a particular dependency
through Java 8's `java.util.Optional`, as the following example shows:
through Java's `java.util.Optional`, as the following example shows:
[source,java,indent=0,subs="verbatim,quotes"]
----
@ -445,8 +446,8 @@ through Java 8's `java.util.Optional`, as the following example shows:
----
You can also use a parameter-level `@Nullable` annotation (of any kind in any package --
for example, `javax.annotation.Nullable` from JSR-305) or just leverage Kotlin built-in
null-safety support:
for example, `org.jspecify.annotations.Nullable` from JSpecify) or just leverage Kotlin's
built-in null-safety support:
[tabs]
======
@ -477,13 +478,6 @@ Kotlin::
----
======
[NOTE]
====
A type-level `@Nullable` annotation such as from JSpecify is not supported in Spring
Framework 6.2 yet. You need to upgrade to Spring Framework 7.0 where the framework
detects type-level annotations and consistently declares JSpecify in its own codebase.
====
You can also use `@Autowired` for interfaces that are well-known resolvable
dependencies: `BeanFactory`, `ApplicationContext`, `Environment`, `ResourceLoader`,
`ApplicationEventPublisher`, and `MessageSource`. These interfaces and their extended
@ -528,5 +522,6 @@ class MovieRecommender {
The `@Autowired`, `@Inject`, `@Value`, and `@Resource` annotations are handled by Spring
`BeanPostProcessor` implementations. This means that you cannot apply these annotations
within your own `BeanPostProcessor` or `BeanFactoryPostProcessor` types (if any).
These types must be 'wired up' explicitly by using XML or a Spring `@Bean` method.
====

View File

@ -47,6 +47,7 @@ public class SingletonSupplier<T extends @Nullable Object> implements Supplier<T
private volatile @Nullable T singletonInstance;
private volatile boolean initialized;
/**
* Guards access to write operations on the {@code singletonInstance} field.
*/
@ -63,6 +64,7 @@ public class SingletonSupplier<T extends @Nullable Object> implements Supplier<T
this.instanceSupplier = null;
this.defaultSupplier = defaultSupplier;
this.singletonInstance = instance;
this.initialized = (instance != null);
}
/**
@ -85,6 +87,7 @@ public class SingletonSupplier<T extends @Nullable Object> implements Supplier<T
this.instanceSupplier = null;
this.defaultSupplier = null;
this.singletonInstance = singletonInstance;
this.initialized = (singletonInstance != null);
}
@ -94,26 +97,24 @@ public class SingletonSupplier<T extends @Nullable Object> implements Supplier<T
*/
@Override
public @Nullable T get() {
T instance = this.singletonInstance;
if (instance == null) {
if (!this.initialized) {
this.writeLock.lock();
try {
instance = this.singletonInstance;
if (instance == null) {
if (!this.initialized) {
if (this.instanceSupplier != null) {
instance = this.instanceSupplier.get();
this.singletonInstance = this.instanceSupplier.get();
}
if (instance == null && this.defaultSupplier != null) {
instance = this.defaultSupplier.get();
if (this.singletonInstance == null && this.defaultSupplier != null) {
this.singletonInstance = this.defaultSupplier.get();
}
this.singletonInstance = instance;
this.initialized = true;
}
}
finally {
this.writeLock.unlock();
}
}
return instance;
return this.singletonInstance;
}
/**

View File

@ -0,0 +1,190 @@
/*
* Copyright 2002-present the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.util.function;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Supplier;
import org.junit.jupiter.api.RepeatedTest;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
/**
* Tests for {@link SingletonSupplier}.
*
* @author Dmytro Nosan
*/
class SingletonSupplierTests {
@Test
void shouldReturnDefaultWhenInstanceSupplierReturnsNull() {
SingletonSupplier<String> singletonSupplier = new SingletonSupplier<>(() -> null, () -> "Default");
assertThat(singletonSupplier.get()).isEqualTo("Default");
}
@Test
void shouldReturnNullForOfNullableWithNullInstance() {
SingletonSupplier<String> singletonSupplier = SingletonSupplier.ofNullable((String) null);
assertThat(singletonSupplier).isNull();
}
@Test
void shouldReturnNullForOfNullableWithNullSupplier() {
SingletonSupplier<String> singletonSupplier = SingletonSupplier.ofNullable((Supplier<String>) null);
assertThat(singletonSupplier).isNull();
}
@Test
void shouldReturnNullWhenAllSuppliersReturnNull() {
SingletonSupplier<String> singletonSupplier = new SingletonSupplier<>(() -> null, () -> null);
assertThat(singletonSupplier.get()).isNull();
}
@Test
void shouldReturnNullWhenNoInstanceOrDefaultSupplier() {
SingletonSupplier<String> singletonSupplier = new SingletonSupplier<>((String) null, null);
assertThat(singletonSupplier.get()).isNull();
}
@Test
void shouldReturnSingletonInstanceOnMultipleCalls() {
SingletonSupplier<String> singletonSupplier = SingletonSupplier.of("Hello");
assertThat(singletonSupplier.get()).isEqualTo("Hello");
assertThat(singletonSupplier.get()).isEqualTo("Hello");
}
@Test
void shouldReturnSingletonInstanceOnMultipleSupplierCalls() {
SingletonSupplier<String> singletonSupplier = SingletonSupplier.of(new HelloStringSupplier());
assertThat(singletonSupplier.get()).isEqualTo("Hello 0");
assertThat(singletonSupplier.get()).isEqualTo("Hello 0");
}
@Test
void shouldReturnSupplierForOfNullableWithNonNullInstance() {
SingletonSupplier<String> singletonSupplier = SingletonSupplier.ofNullable("Hello");
assertThat(singletonSupplier).isNotNull();
assertThat(singletonSupplier.get()).isEqualTo("Hello");
}
@Test
void shouldReturnSupplierForOfNullableWithNonNullSupplier() {
SingletonSupplier<String> singletonSupplier = SingletonSupplier.ofNullable(() -> "Hello");
assertThat(singletonSupplier).isNotNull();
assertThat(singletonSupplier.get()).isEqualTo("Hello");
}
@Test
void shouldThrowWhenObtainCalledAndNoInstanceAvailable() {
SingletonSupplier<String> singletonSupplier = new SingletonSupplier<>((String) null, null);
assertThatThrownBy(singletonSupplier::obtain).isInstanceOf(IllegalStateException.class)
.hasMessage("No instance from Supplier");
}
@Test
void shouldUseDefaultSupplierWhenInstanceIsNull() {
SingletonSupplier<String> singletonSupplier = new SingletonSupplier<>((String) null, () -> "defaultSupplier");
assertThat(singletonSupplier.get()).isEqualTo("defaultSupplier");
}
@Test
void shouldUseDefaultSupplierWhenInstanceSupplierReturnsNull() {
SingletonSupplier<String> singletonSupplier = new SingletonSupplier<>((Supplier<String>) null, () -> "defaultSupplier");
assertThat(singletonSupplier.get()).isEqualTo("defaultSupplier");
}
@Test
void shouldUseInstanceSupplierWhenProvidedAndIgnoreDefaultSupplier() {
AtomicInteger defaultValue = new AtomicInteger();
SingletonSupplier<Integer> singletonSupplier = new SingletonSupplier<>(() -> -1, defaultValue::incrementAndGet);
assertThat(singletonSupplier.get()).isEqualTo(-1);
assertThat(defaultValue.get()).isEqualTo(0);
}
@Test
void shouldUseInstanceWhenProvidedAndIgnoreDefaultSupplier() {
AtomicInteger defaultValue = new AtomicInteger();
SingletonSupplier<Integer> singletonSupplier = new SingletonSupplier<>(-1, defaultValue::incrementAndGet);
assertThat(singletonSupplier.get()).isEqualTo(-1);
assertThat(defaultValue.get()).isEqualTo(0);
}
@Test
void shouldReturnConsistentlyNullSingletonInstanceOnMultipleSupplierCalls() {
SingletonSupplier<String> singletonSupplier = SingletonSupplier.of(new Supplier<>() {
int count = 0;
@Override
public String get() {
if (this.count++ == 0) {
return null;
}
return "Hello";
}
});
assertThat(singletonSupplier.get()).isNull();
assertThat(singletonSupplier.get()).isNull();
}
@RepeatedTest(100)
void shouldReturnSingletonInstanceOnMultipleConcurrentSupplierCalls() throws Exception {
int numberOfThreads = 4;
CountDownLatch ready = new CountDownLatch(numberOfThreads);
CountDownLatch start = new CountDownLatch(1);
List<Future<String>> futures = new ArrayList<>();
SingletonSupplier<String> singletonSupplier = SingletonSupplier.of(new HelloStringSupplier());
ExecutorService executorService = Executors.newFixedThreadPool(numberOfThreads);
try {
for (int i = 0; i < numberOfThreads; i++) {
futures.add(executorService.submit(() -> {
ready.countDown();
start.await();
return singletonSupplier.obtain();
}));
}
ready.await();
start.countDown();
assertThat(futures).extracting(Future::get).containsOnly("Hello 0");
}
finally {
executorService.shutdown();
}
}
private static final class HelloStringSupplier implements Supplier<String> {
private final AtomicInteger count = new AtomicInteger();
@Override
public String get() {
return "Hello " + this.count.getAndIncrement();
}
}
}

View File

@ -209,6 +209,7 @@ class SQLErrorCodeSQLExceptionTranslatorTests {
reset(dataSource);
given(dataSource.getConnection()).willReturn(connection);
translator = new SQLErrorCodeSQLExceptionTranslator(dataSource);
assertThat(translator.translate("test", null, duplicateKeyException))
.isInstanceOf(DuplicateKeyException.class);