root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Add ThreadLocalAccessor for LocaleContext and RequestAttributes 

Add `ThreadLocalAccessor` implementations:
- `LocaleThreadLocalAccessor`
- `RequestAttributesThreadLocalAccessor`

See gh-32243
This commit is contained in:
Tadaya Tsuyukubo 2024-02-11 17:34:17 -08:00 committed by Stéphane Nicoll
parent 5d22aa9770
commit 5bd1c1fddb
7 changed files with 295 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
framework-docs/modules/ROOT/pages/web/webmvc/mvc-ann-async.adoc
View File

@ -445,6 +445,13 @@ directly. For example:
}
----
The following `ThreadLocalAccessor` implementations are provided out of the box:
* `LocaleContextThreadLocalAccessor` -- propagates `LocaleContext` via `LocaleContextHolder`
* `RequestAttributesThreadLocalAccessor` -- propagates `RequestAttributes` via `RequestContextHolder`
The above are not registered automatically. You need to register them via `ContextRegistry.getInstance()` on startup.
For more details, see the
https://micrometer.io/docs/contextPropagation[documentation] of the Micrometer Context
Propagation library.

1
spring-context/spring-context.gradle
View File

@ -13,6 +13,7 @@ dependencies {
api(project(":spring-expression"))
api("io.micrometer:micrometer-observation")
optional(project(":spring-instrument"))
optional("io.micrometer:context-propagation")
optional("io.projectreactor:reactor-core")
optional("jakarta.annotation:jakarta.annotation-api")
optional("jakarta.ejb:jakarta.ejb-api")

55
spring-context/src/main/java/org/springframework/context/i18n/LocaleContextThreadLocalAccessor.java Normal file
View File

@ -0,0 +1,55 @@
/*
* Copyright 2002-2024 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.context.i18n;
import io.micrometer.context.ThreadLocalAccessor;
/**
* Adapt {@link LocaleContextHolder} to the {@link ThreadLocalAccessor} contract to assist
* the Micrometer Context Propagation library with {@link LocaleContext} propagation.
* @author Tadaya Tsuyukubo
* @since 6.2
*/
public class LocaleContextThreadLocalAccessor implements ThreadLocalAccessor<LocaleContext> {
/**
* Key under which this accessor is registered in
* {@link io.micrometer.context.ContextRegistry}.
*/
public static final String KEY = LocaleContextThreadLocalAccessor.class.getName() + ".KEY";
@Override
public Object key() {
return KEY;
}
@Override
public LocaleContext getValue() {
return LocaleContextHolder.getLocaleContext();
}
@Override
public void setValue(LocaleContext value) {
LocaleContextHolder.setLocaleContext(value);
}
@Override
public void setValue() {
LocaleContextHolder.resetLocaleContext();
}
}

87
spring-context/src/test/java/org/springframework/context/i18n/LocaleContextThreadLocalAccessorTests.java Normal file
View File

@ -0,0 +1,87 @@
/*
* Copyright 2002-2024 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.context.i18n;
import java.util.Locale;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Stream;
import io.micrometer.context.ContextRegistry;
import io.micrometer.context.ContextSnapshot;
import io.micrometer.context.ContextSnapshotFactory;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import org.springframework.lang.Nullable;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link LocaleContextThreadLocalAccessor}.
*
* @author Tadaya Tsuyukubo
*/
class LocaleContextThreadLocalAccessorTests {
private final ContextRegistry registry = new ContextRegistry()
.registerThreadLocalAccessor(new LocaleContextThreadLocalAccessor());
@AfterEach
void cleanUp() {
LocaleContextHolder.resetLocaleContext();
}
@ParameterizedTest
@MethodSource
void propagation(@Nullable LocaleContext previous, LocaleContext current) throws Exception {
LocaleContextHolder.setLocaleContext(current);
ContextSnapshot snapshot = ContextSnapshotFactory.builder()
.contextRegistry(this.registry)
.clearMissing(true)
.build()
.captureAll();
AtomicReference<LocaleContext> previousHolder = new AtomicReference<>();
AtomicReference<LocaleContext> currentHolder = new AtomicReference<>();
CountDownLatch latch = new CountDownLatch(1);
new Thread(() -> {
LocaleContextHolder.setLocaleContext(previous);
try (ContextSnapshot.Scope scope = snapshot.setThreadLocals()) {
currentHolder.set(LocaleContextHolder.getLocaleContext());
}
previousHolder.set(LocaleContextHolder.getLocaleContext());
latch.countDown();
}).start();
latch.await(1, TimeUnit.SECONDS);
assertThat(previousHolder).hasValueSatisfying(value -> assertThat(value).isSameAs(previous));
assertThat(currentHolder).hasValueSatisfying(value -> assertThat(value).isSameAs(current));
}
private static Stream<Arguments> propagation() {
LocaleContext previous = new SimpleLocaleContext(Locale.ENGLISH);
LocaleContext current = new SimpleLocaleContext(Locale.ENGLISH);
return Stream.of(
Arguments.of(null, current),
Arguments.of(previous, current)
);
}
}

3
spring-web/spring-web.gradle
View File

@ -20,7 +20,7 @@ dependencies {
optional("com.google.protobuf:protobuf-java-util")
optional("com.rometools:rome")
optional("com.squareup.okhttp3:okhttp")
optional("io.reactivex.rxjava3:rxjava")
optional("io.micrometer:context-propagation")
optional("io.netty:netty-buffer")
optional("io.netty:netty-handler")
optional("io.netty:netty-codec-http")
@ -31,6 +31,7 @@ dependencies {
optional("io.netty:netty5-transport")
optional("io.projectreactor.netty:reactor-netty-http")
optional("io.projectreactor.netty:reactor-netty5-http")
optional("io.reactivex.rxjava3:rxjava")
optional("io.undertow:undertow-core")
optional("jakarta.el:jakarta.el-api")
optional("jakarta.faces:jakarta.faces-api")

55
spring-web/src/main/java/org/springframework/web/context/request/RequestAttributesThreadLocalAccessor.java Normal file
View File

@ -0,0 +1,55 @@
/*
* Copyright 2002-2024 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.web.context.request;
import io.micrometer.context.ThreadLocalAccessor;
/**
* Adapt {@link RequestContextHolder} to the {@link ThreadLocalAccessor} contract to assist
* the Micrometer Context Propagation library with {@link RequestAttributes} propagation.
* @author Tadaya Tsuyukubo
* @since 6.2
*/
public class RequestAttributesThreadLocalAccessor implements ThreadLocalAccessor<RequestAttributes> {
/**
* Key under which this accessor is registered in
* {@link io.micrometer.context.ContextRegistry}.
*/
public static final String KEY = RequestAttributesThreadLocalAccessor.class.getName() + ".KEY";
@Override
public Object key() {
return KEY;
}
@Override
public RequestAttributes getValue() {
return RequestContextHolder.getRequestAttributes();
}
@Override
public void setValue(RequestAttributes value) {
RequestContextHolder.setRequestAttributes(value);
}
@Override
public void setValue() {
RequestContextHolder.resetRequestAttributes();
}
}

88
spring-web/src/test/java/org/springframework/web/context/request/RequestAttributesThreadLocalAccessorTests.java Normal file
View File

@ -0,0 +1,88 @@
/*
* Copyright 2002-2024 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.web.context.request;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Stream;
import io.micrometer.context.ContextRegistry;
import io.micrometer.context.ContextSnapshot;
import io.micrometer.context.ContextSnapshotFactory;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import org.springframework.lang.Nullable;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
/**
* Tests for {@link RequestAttributesThreadLocalAccessor}.
*
* @author Tadaya Tsuyukubo
*/
class RequestAttributesThreadLocalAccessorTests {
private final ContextRegistry registry = new ContextRegistry()
.registerThreadLocalAccessor(new RequestAttributesThreadLocalAccessor());
@AfterEach
void cleanUp() {
RequestContextHolder.resetRequestAttributes();
}
@ParameterizedTest
@MethodSource
void propagation(@Nullable RequestAttributes previous, RequestAttributes current) throws Exception {
RequestContextHolder.setRequestAttributes(current);
ContextSnapshot snapshot = ContextSnapshotFactory.builder()
.contextRegistry(this.registry)
.clearMissing(true)
.build()
.captureAll();
AtomicReference<RequestAttributes> previousHolder = new AtomicReference<>();
AtomicReference<RequestAttributes> currentHolder = new AtomicReference<>();
CountDownLatch latch = new CountDownLatch(1);
new Thread(() -> {
RequestContextHolder.setRequestAttributes(previous);
try (ContextSnapshot.Scope scope = snapshot.setThreadLocals()) {
currentHolder.set(RequestContextHolder.getRequestAttributes());
}
previousHolder.set(RequestContextHolder.getRequestAttributes());
latch.countDown();
}).start();
latch.await(1, TimeUnit.SECONDS);
assertThat(previousHolder).hasValueSatisfying(value -> assertThat(value).isSameAs(previous));
assertThat(currentHolder).hasValueSatisfying(value -> assertThat(value).isSameAs(current));
}
private static Stream<Arguments> propagation() {
RequestAttributes previous = mock(RequestAttributes.class);
RequestAttributes current = mock(RequestAttributes.class);
return Stream.of(
Arguments.of(null, current),
Arguments.of(previous, current)
);
}
}