Compare commits
4 Commits
5a42c72515
...
877877462d
Author | SHA1 | Date |
---|---|---|
|
877877462d | |
|
7e6874ad80 | |
|
097463e3b7 | |
|
e2731f695c |
|
@ -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.
|
||||
====
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
@ -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();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
|
@ -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);
|
||||
|
||||
|
|
Loading…
Reference in New Issue