diff --git a/configuration-metadata/spring-boot-configuration-processor/src/main/java/org/springframework/boot/configurationprocessor/ConfigurationMetadataAnnotationProcessor.java b/configuration-metadata/spring-boot-configuration-processor/src/main/java/org/springframework/boot/configurationprocessor/ConfigurationMetadataAnnotationProcessor.java index 6234b422166..102e655484b 100644 --- a/configuration-metadata/spring-boot-configuration-processor/src/main/java/org/springframework/boot/configurationprocessor/ConfigurationMetadataAnnotationProcessor.java +++ b/configuration-metadata/spring-boot-configuration-processor/src/main/java/org/springframework/boot/configurationprocessor/ConfigurationMetadataAnnotationProcessor.java @@ -109,8 +109,6 @@ public class ConfigurationMetadataAnnotationProcessor extends AbstractProcessor static final String READ_OPERATION_ANNOTATION = "org.springframework.boot.actuate.endpoint.annotation.ReadOperation"; - static final String OPTIONAL_PARAMETER_ANNOTATION = "org.springframework.boot.actuate.endpoint.annotation.OptionalParameter"; - static final String NAME_ANNOTATION = "org.springframework.boot.context.properties.bind.Name"; static final String ENDPOINT_ACCESS_ENUM = "org.springframework.boot.actuate.endpoint.Access"; @@ -166,10 +164,6 @@ public class ConfigurationMetadataAnnotationProcessor extends AbstractProcessor return NAME_ANNOTATION; } - protected String optionalParameterAnnotation() { - return OPTIONAL_PARAMETER_ANNOTATION; - } - protected String endpointAccessEnum() { return ENDPOINT_ACCESS_ENUM; } @@ -194,8 +188,7 @@ public class ConfigurationMetadataAnnotationProcessor extends AbstractProcessor this.metadataEnv = new MetadataGenerationEnvironment(env, configurationPropertiesAnnotation(), configurationPropertiesSourceAnnotation(), nestedConfigurationPropertyAnnotation(), deprecatedConfigurationPropertyAnnotation(), constructorBindingAnnotation(), autowiredAnnotation(), - defaultValueAnnotation(), endpointAnnotations(), readOperationAnnotation(), - optionalParameterAnnotation(), nameAnnotation()); + defaultValueAnnotation(), endpointAnnotations(), readOperationAnnotation(), nameAnnotation()); } @Override @@ -383,18 +376,13 @@ public class ConfigurationMetadataAnnotationProcessor extends AbstractProcessor private boolean hasNoOrOptionalParameters(ExecutableElement method) { for (VariableElement parameter : method.getParameters()) { - if (!isOptionalParameter(parameter)) { + if (!this.metadataEnv.hasNullableAnnotation(parameter)) { return false; } } return true; } - private boolean isOptionalParameter(VariableElement parameter) { - return this.metadataEnv.hasNullableAnnotation(parameter) - || this.metadataEnv.hasOptionalParameterAnnotation(parameter); - } - private String getPrefix(AnnotationMirror annotation) { String prefix = this.metadataEnv.getAnnotationElementStringValue(annotation, "prefix"); if (prefix != null) { diff --git a/configuration-metadata/spring-boot-configuration-processor/src/main/java/org/springframework/boot/configurationprocessor/MetadataGenerationEnvironment.java b/configuration-metadata/spring-boot-configuration-processor/src/main/java/org/springframework/boot/configurationprocessor/MetadataGenerationEnvironment.java index b4ace8decec..ae018ed094a 100644 --- a/configuration-metadata/spring-boot-configuration-processor/src/main/java/org/springframework/boot/configurationprocessor/MetadataGenerationEnvironment.java +++ b/configuration-metadata/spring-boot-configuration-processor/src/main/java/org/springframework/boot/configurationprocessor/MetadataGenerationEnvironment.java @@ -98,8 +98,6 @@ class MetadataGenerationEnvironment { private final String readOperationAnnotation; - private final String optionalParameterAnnotation; - private final String nameAnnotation; private final String autowiredAnnotation; @@ -108,7 +106,7 @@ class MetadataGenerationEnvironment { String configurationPropertiesSourceAnnotation, String nestedConfigurationPropertyAnnotation, String deprecatedConfigurationPropertyAnnotation, String constructorBindingAnnotation, String autowiredAnnotation, String defaultValueAnnotation, Set endpointAnnotations, - String readOperationAnnotation, String optionalParameterAnnotation, String nameAnnotation) { + String readOperationAnnotation, String nameAnnotation) { this.typeUtils = new TypeUtils(environment); this.elements = environment.getElementUtils(); this.messager = environment.getMessager(); @@ -123,7 +121,6 @@ class MetadataGenerationEnvironment { this.defaultValueAnnotation = defaultValueAnnotation; this.endpointAnnotations = endpointAnnotations; this.readOperationAnnotation = readOperationAnnotation; - this.optionalParameterAnnotation = optionalParameterAnnotation; this.nameAnnotation = nameAnnotation; } @@ -382,10 +379,6 @@ class MetadataGenerationEnvironment { return getTypeUseAnnotation(element, NULLABLE_ANNOTATION) != null; } - boolean hasOptionalParameterAnnotation(Element element) { - return getAnnotation(element, this.optionalParameterAnnotation) != null; - } - private boolean isElementDeprecated(Element element) { return hasAnnotation(element, "java.lang.Deprecated") || hasAnnotation(element, this.deprecatedConfigurationPropertyAnnotation); diff --git a/configuration-metadata/spring-boot-configuration-processor/src/test/java/org/springframework/boot/configurationprocessor/EndpointMetadataGenerationTests.java b/configuration-metadata/spring-boot-configuration-processor/src/test/java/org/springframework/boot/configurationprocessor/EndpointMetadataGenerationTests.java index 264f42585ac..2c9dbdc88aa 100644 --- a/configuration-metadata/spring-boot-configuration-processor/src/test/java/org/springframework/boot/configurationprocessor/EndpointMetadataGenerationTests.java +++ b/configuration-metadata/spring-boot-configuration-processor/src/test/java/org/springframework/boot/configurationprocessor/EndpointMetadataGenerationTests.java @@ -29,7 +29,6 @@ import org.springframework.boot.configurationsample.endpoint.CustomPropertiesEnd import org.springframework.boot.configurationsample.endpoint.EnabledEndpoint; import org.springframework.boot.configurationsample.endpoint.NoAccessEndpoint; import org.springframework.boot.configurationsample.endpoint.NullableParameterEndpoint; -import org.springframework.boot.configurationsample.endpoint.OptionalParameterEndpoint; import org.springframework.boot.configurationsample.endpoint.ReadOnlyAccessEndpoint; import org.springframework.boot.configurationsample.endpoint.SimpleEndpoint; import org.springframework.boot.configurationsample.endpoint.SimpleEndpoint2; @@ -153,7 +152,7 @@ class EndpointMetadataGenerationTests extends AbstractMetadataGenerationTests { assertThat(metadata).has(access("incremental", Access.UNRESTRICTED)); assertThat(metadata).has(cacheTtl("incremental")); assertThat(metadata.getItems()).hasSize(3); - project.replaceText(IncrementalEndpoint.class, "@OptionalParameter String param", "String param"); + project.replaceText(IncrementalEndpoint.class, "@Nullable String param", "String param"); metadata = project.compile(); assertThat(metadata) .has(Metadata.withGroup("management.endpoint.incremental").fromSource(IncrementalEndpoint.class)); @@ -205,16 +204,6 @@ class EndpointMetadataGenerationTests extends AbstractMetadataGenerationTests { assertThat(metadata.getItems()).hasSize(3); } - @Test - void endpointWithOptionalParameter() { - ConfigurationMetadata metadata = compile(OptionalParameterEndpoint.class); - assertThat(metadata) - .has(Metadata.withGroup("management.endpoint.optional").fromSource(OptionalParameterEndpoint.class)); - assertThat(metadata).has(access("optional", Access.UNRESTRICTED)); - assertThat(metadata).has(cacheTtl("optional")); - assertThat(metadata.getItems()).hasSize(3); - } - private Metadata.MetadataItemCondition access(String endpointId, Access defaultValue) { return defaultAccess(endpointId, endpointId, defaultValue); } diff --git a/configuration-metadata/spring-boot-configuration-processor/src/test/java/org/springframework/boot/configurationprocessor/MetadataGenerationEnvironmentFactory.java b/configuration-metadata/spring-boot-configuration-processor/src/test/java/org/springframework/boot/configurationprocessor/MetadataGenerationEnvironmentFactory.java index c348fd2669f..f8bcd840518 100644 --- a/configuration-metadata/spring-boot-configuration-processor/src/test/java/org/springframework/boot/configurationprocessor/MetadataGenerationEnvironmentFactory.java +++ b/configuration-metadata/spring-boot-configuration-processor/src/test/java/org/springframework/boot/configurationprocessor/MetadataGenerationEnvironmentFactory.java @@ -49,7 +49,6 @@ class MetadataGenerationEnvironmentFactory implements Function events = this.auditEventRepository.find(principal, getInstant(after), type); return new AuditEventsDescriptor(events); } diff --git a/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/annotation/DiscoveredOperationMethod.java b/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/annotation/DiscoveredOperationMethod.java index 20065ab29f5..8dd7868e294 100644 --- a/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/annotation/DiscoveredOperationMethod.java +++ b/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/annotation/DiscoveredOperationMethod.java @@ -17,7 +17,6 @@ package org.springframework.boot.actuate.endpoint.annotation; import java.lang.reflect.Method; -import java.lang.reflect.Parameter; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; @@ -27,7 +26,6 @@ import org.springframework.boot.actuate.endpoint.OperationType; import org.springframework.boot.actuate.endpoint.Producible; import org.springframework.boot.actuate.endpoint.invoke.reflect.OperationMethod; import org.springframework.core.annotation.AnnotationAttributes; -import org.springframework.core.annotation.MergedAnnotations; import org.springframework.util.Assert; /** @@ -42,7 +40,7 @@ public class DiscoveredOperationMethod extends OperationMethod { public DiscoveredOperationMethod(Method method, OperationType operationType, AnnotationAttributes annotationAttributes) { - super(method, operationType, DiscoveredOperationMethod::isOptionalParameter); + super(method, operationType); Assert.notNull(annotationAttributes, "'annotationAttributes' must not be null"); List producesMediaTypes = new ArrayList<>(); producesMediaTypes.addAll(Arrays.asList(annotationAttributes.getStringArray("produces"))); @@ -50,10 +48,6 @@ public class DiscoveredOperationMethod extends OperationMethod { this.producesMediaTypes = Collections.unmodifiableList(producesMediaTypes); } - private static boolean isOptionalParameter(Parameter parameter) { - return MergedAnnotations.from(parameter).isPresent(OptionalParameter.class); - } - private & Producible> List getProducesFromProducible( AnnotationAttributes annotationAttributes) { Class type = getProducesFrom(annotationAttributes); diff --git a/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/annotation/OptionalParameter.java b/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/annotation/OptionalParameter.java deleted file mode 100644 index 2dd7a7c606e..00000000000 --- a/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/annotation/OptionalParameter.java +++ /dev/null @@ -1,36 +0,0 @@ -/* - * Copyright 2012-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.boot.actuate.endpoint.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Annotation that indicates that an operation parameter is optional. - * - * @author Phillip Webb - * @since 4.0.0 - */ -@Target({ ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD }) -@Retention(RetentionPolicy.RUNTIME) -@Documented -public @interface OptionalParameter { - -} diff --git a/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethod.java b/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethod.java index 564f69b7d3f..5a92eb4574b 100644 --- a/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethod.java +++ b/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethod.java @@ -17,9 +17,7 @@ package org.springframework.boot.actuate.endpoint.invoke.reflect; import java.lang.reflect.Method; -import java.lang.reflect.Parameter; import java.util.Locale; -import java.util.function.Predicate; import org.springframework.boot.actuate.endpoint.OperationType; import org.springframework.boot.actuate.endpoint.invoke.OperationParameters; @@ -48,28 +46,13 @@ public class OperationMethod { * Create a new {@link OperationMethod} instance. * @param method the source method * @param operationType the operation type - * @deprecated since 4.0.0 for removal in 4.2.0 in favor of - * {@link #OperationMethod(Method, OperationType, Predicate)} */ - @Deprecated(since = "4.0.0", forRemoval = true) public OperationMethod(Method method, OperationType operationType) { - this(method, operationType, (parameter) -> false); - } - - /** - * Create a new {@link OperationMethod} instance. - * @param method the source method - * @param operationType the operation type - * @param optionalParameters predicate to test if a parameter is optional - * @since 4.0.0 - */ - public OperationMethod(Method method, OperationType operationType, Predicate optionalParameters) { Assert.notNull(method, "'method' must not be null"); Assert.notNull(operationType, "'operationType' must not be null"); this.method = method; this.operationType = operationType; - this.operationParameters = new OperationMethodParameters(method, DEFAULT_PARAMETER_NAME_DISCOVERER, - optionalParameters); + this.operationParameters = new OperationMethodParameters(method, DEFAULT_PARAMETER_NAME_DISCOVERER); } /** diff --git a/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethodParameter.java b/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethodParameter.java index 89a89e4efa3..ad50efed58d 100644 --- a/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethodParameter.java +++ b/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethodParameter.java @@ -18,7 +18,6 @@ package org.springframework.boot.actuate.endpoint.invoke.reflect; import java.lang.annotation.Annotation; import java.lang.reflect.Parameter; -import java.util.function.Predicate; import org.springframework.boot.actuate.endpoint.invoke.OperationParameter; import org.springframework.core.Nullness; @@ -35,18 +34,14 @@ class OperationMethodParameter implements OperationParameter { private final Parameter parameter; - private final Predicate optional; - /** * Create a new {@link OperationMethodParameter} instance. * @param name the parameter name * @param parameter the parameter - * @param optionalParameters predicate to test if a parameter is optional */ - OperationMethodParameter(String name, Parameter parameter, Predicate optionalParameters) { + OperationMethodParameter(String name, Parameter parameter) { this.name = name; this.parameter = parameter; - this.optional = optionalParameters; } @Override @@ -61,11 +56,7 @@ class OperationMethodParameter implements OperationParameter { @Override public boolean isMandatory() { - return !isOptional(); - } - - private boolean isOptional() { - return Nullness.NULLABLE == Nullness.forParameter(this.parameter) || this.optional.test(this.parameter); + return Nullness.NULLABLE != Nullness.forParameter(this.parameter); } @Override diff --git a/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethodParameters.java b/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethodParameters.java index e5c98c2c873..7fe0c4a13ed 100644 --- a/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethodParameters.java +++ b/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethodParameters.java @@ -22,7 +22,6 @@ import java.util.ArrayList; import java.util.Collections; import java.util.Iterator; import java.util.List; -import java.util.function.Predicate; import java.util.stream.Stream; import org.jspecify.annotations.Nullable; @@ -45,26 +44,22 @@ class OperationMethodParameters implements OperationParameters { * Create a new {@link OperationMethodParameters} instance. * @param method the source method * @param parameterNameDiscoverer the parameter name discoverer - * @param optionalParameters predicate to test if a parameter is optional */ - OperationMethodParameters(Method method, ParameterNameDiscoverer parameterNameDiscoverer, - Predicate optionalParameters) { + OperationMethodParameters(Method method, ParameterNameDiscoverer parameterNameDiscoverer) { Assert.notNull(method, "'method' must not be null"); Assert.notNull(parameterNameDiscoverer, "'parameterNameDiscoverer' must not be null"); - Assert.notNull(optionalParameters, "'optionalParameters' must not be null"); @Nullable String[] parameterNames = parameterNameDiscoverer.getParameterNames(method); Parameter[] parameters = method.getParameters(); Assert.state(parameterNames != null, () -> "Failed to extract parameter names for " + method); - this.operationParameters = getOperationParameters(parameters, parameterNames, optionalParameters); + this.operationParameters = getOperationParameters(parameters, parameterNames); } - private List getOperationParameters(Parameter[] parameters, @Nullable String[] names, - Predicate optionalParameters) { + private List getOperationParameters(Parameter[] parameters, @Nullable String[] names) { List operationParameters = new ArrayList<>(parameters.length); for (int i = 0; i < names.length; i++) { String name = names[i]; Assert.state(name != null, "'name' must not be null"); - operationParameters.add(new OperationMethodParameter(name, parameters[i], optionalParameters)); + operationParameters.add(new OperationMethodParameter(name, parameters[i])); } return Collections.unmodifiableList(operationParameters); } diff --git a/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/env/EnvironmentEndpoint.java b/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/env/EnvironmentEndpoint.java index 76e5a4723b1..b970baaba57 100644 --- a/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/env/EnvironmentEndpoint.java +++ b/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/env/EnvironmentEndpoint.java @@ -34,7 +34,6 @@ import org.springframework.boot.actuate.endpoint.Sanitizer; import org.springframework.boot.actuate.endpoint.SanitizingFunction; import org.springframework.boot.actuate.endpoint.Show; import org.springframework.boot.actuate.endpoint.annotation.Endpoint; -import org.springframework.boot.actuate.endpoint.annotation.OptionalParameter; import org.springframework.boot.actuate.endpoint.annotation.ReadOperation; import org.springframework.boot.actuate.endpoint.annotation.Selector; import org.springframework.boot.context.properties.bind.PlaceholdersResolver; @@ -81,7 +80,7 @@ public class EnvironmentEndpoint { } @ReadOperation - public EnvironmentDescriptor environment(@OptionalParameter @Nullable String pattern) { + public EnvironmentDescriptor environment(@Nullable String pattern) { boolean showUnsanitized = this.showValues.isShown(true); return getEnvironmentDescriptor(pattern, showUnsanitized); } diff --git a/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/env/EnvironmentEndpointWebExtension.java b/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/env/EnvironmentEndpointWebExtension.java index 31ea738bdb1..2c2f74df6c3 100644 --- a/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/env/EnvironmentEndpointWebExtension.java +++ b/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/env/EnvironmentEndpointWebExtension.java @@ -22,7 +22,6 @@ import org.jspecify.annotations.Nullable; import org.springframework.boot.actuate.endpoint.SecurityContext; import org.springframework.boot.actuate.endpoint.Show; -import org.springframework.boot.actuate.endpoint.annotation.OptionalParameter; import org.springframework.boot.actuate.endpoint.annotation.ReadOperation; import org.springframework.boot.actuate.endpoint.annotation.Selector; import org.springframework.boot.actuate.endpoint.web.WebEndpointResponse; @@ -53,8 +52,7 @@ public class EnvironmentEndpointWebExtension { } @ReadOperation - public EnvironmentDescriptor environment(SecurityContext securityContext, - @OptionalParameter @Nullable String pattern) { + public EnvironmentDescriptor environment(SecurityContext securityContext, @Nullable String pattern) { boolean showUnsanitized = this.showValues.isShown(securityContext, this.roles); return this.delegate.getEnvironmentDescriptor(pattern, showUnsanitized); } diff --git a/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/logging/LoggersEndpoint.java b/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/logging/LoggersEndpoint.java index 07ace217c3e..54ee82cd686 100644 --- a/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/logging/LoggersEndpoint.java +++ b/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/logging/LoggersEndpoint.java @@ -29,7 +29,6 @@ import org.jspecify.annotations.Nullable; import org.springframework.aot.hint.annotation.RegisterReflectionForBinding; import org.springframework.boot.actuate.endpoint.OperationResponseBody; import org.springframework.boot.actuate.endpoint.annotation.Endpoint; -import org.springframework.boot.actuate.endpoint.annotation.OptionalParameter; import org.springframework.boot.actuate.endpoint.annotation.ReadOperation; import org.springframework.boot.actuate.endpoint.annotation.Selector; import org.springframework.boot.actuate.endpoint.annotation.WriteOperation; @@ -100,7 +99,7 @@ public class LoggersEndpoint { } @WriteOperation - public void configureLogLevel(@Selector String name, @OptionalParameter @Nullable LogLevel configuredLevel) { + public void configureLogLevel(@Selector String name, @Nullable LogLevel configuredLevel) { Assert.notNull(name, "'name' must not be empty"); LoggerGroup group = this.loggerGroups.get(name); if (group != null && group.hasMembers()) { diff --git a/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/management/HeapDumpWebEndpoint.java b/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/management/HeapDumpWebEndpoint.java index f45e971a369..8e95f98eead 100644 --- a/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/management/HeapDumpWebEndpoint.java +++ b/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/management/HeapDumpWebEndpoint.java @@ -40,7 +40,6 @@ import org.jspecify.annotations.Nullable; import org.springframework.boot.actuate.endpoint.Access; import org.springframework.boot.actuate.endpoint.annotation.Endpoint; -import org.springframework.boot.actuate.endpoint.annotation.OptionalParameter; import org.springframework.boot.actuate.endpoint.annotation.ReadOperation; import org.springframework.boot.actuate.endpoint.web.WebEndpointResponse; import org.springframework.boot.actuate.endpoint.web.annotation.WebEndpoint; @@ -78,7 +77,7 @@ public class HeapDumpWebEndpoint { } @ReadOperation - public WebEndpointResponse heapDump(@OptionalParameter @Nullable Boolean live) { + public WebEndpointResponse heapDump(@Nullable Boolean live) { try { if (this.lock.tryLock(this.timeout, TimeUnit.MILLISECONDS)) { try { diff --git a/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/metrics/export/prometheus/PrometheusScrapeEndpoint.java b/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/metrics/export/prometheus/PrometheusScrapeEndpoint.java index a5bd974574f..75f1ceac463 100644 --- a/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/metrics/export/prometheus/PrometheusScrapeEndpoint.java +++ b/module/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/metrics/export/prometheus/PrometheusScrapeEndpoint.java @@ -29,7 +29,6 @@ import io.prometheus.metrics.model.snapshots.MetricSnapshots; import org.jspecify.annotations.Nullable; import org.springframework.boot.actuate.endpoint.annotation.Endpoint; -import org.springframework.boot.actuate.endpoint.annotation.OptionalParameter; import org.springframework.boot.actuate.endpoint.annotation.ReadOperation; import org.springframework.boot.actuate.endpoint.web.WebEndpointResponse; import org.springframework.boot.actuate.endpoint.web.annotation.WebEndpoint; @@ -69,8 +68,7 @@ public class PrometheusScrapeEndpoint { } @ReadOperation(producesFrom = PrometheusOutputFormat.class) - public WebEndpointResponse scrape(PrometheusOutputFormat format, - @OptionalParameter @Nullable Set includedNames) { + public WebEndpointResponse scrape(PrometheusOutputFormat format, @Nullable Set includedNames) { try { ByteArrayOutputStream outputStream = new ByteArrayOutputStream(this.nextMetricsScrapeSize); MetricSnapshots metricSnapshots = (includedNames != null) diff --git a/module/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethodParameterTests.java b/module/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethodParameterTests.java index 644583bef62..ded4ee8b358 100644 --- a/module/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethodParameterTests.java +++ b/module/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethodParameterTests.java @@ -16,19 +16,12 @@ package org.springframework.boot.actuate.endpoint.invoke.reflect; -import java.lang.annotation.Documented; -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; import java.lang.reflect.Method; -import java.lang.reflect.Parameter; import org.junit.jupiter.api.Test; import org.springframework.boot.actuate.endpoint.annotation.Selector; import org.springframework.boot.actuate.endpoint.annotation.Selector.Match; -import org.springframework.core.annotation.MergedAnnotations; import org.springframework.util.ReflectionUtils; import static org.assertj.core.api.Assertions.assertThat; @@ -43,87 +36,60 @@ class OperationMethodParameterTests { private final Method example = ReflectionUtils.findMethod(getClass(), "example", String.class, String.class); - private final Method exampleJSpecifyNullable = ReflectionUtils.findMethod(getClass(), "exampleJSpecifyNullable", - String.class, String.class); - private final Method exampleSpringNullable = ReflectionUtils.findMethod(getClass(), "exampleSpringNullable", String.class, String.class); - private Method exampleAnnotation = ReflectionUtils.findMethod(getClass(), "exampleAnnotation", String.class); + private final Method exampleAnnotation = ReflectionUtils.findMethod(getClass(), "exampleAnnotation", String.class); @Test void getNameShouldReturnName() { - OperationMethodParameter parameter = new OperationMethodParameter("name", this.example.getParameters()[0], - this::isOptionalParameter); + OperationMethodParameter parameter = new OperationMethodParameter("name", this.example.getParameters()[0]); assertThat(parameter.getName()).isEqualTo("name"); } @Test void getTypeShouldReturnType() { - OperationMethodParameter parameter = new OperationMethodParameter("name", this.example.getParameters()[0], - this::isOptionalParameter); + OperationMethodParameter parameter = new OperationMethodParameter("name", this.example.getParameters()[0]); assertThat(parameter.getType()).isEqualTo(String.class); } @Test void isMandatoryWhenNoAnnotationShouldReturnTrue() { - OperationMethodParameter parameter = new OperationMethodParameter("name", this.example.getParameters()[0], - this::isOptionalParameter); + OperationMethodParameter parameter = new OperationMethodParameter("name", this.example.getParameters()[0]); assertThat(parameter.isMandatory()).isTrue(); } @Test - void isMandatoryWhenOptionalAnnotationShouldReturnFalse() { - OperationMethodParameter parameter = new OperationMethodParameter("name", this.example.getParameters()[1], - this::isOptionalParameter); - assertThat(parameter.isMandatory()).isFalse(); - } - - @Test - void isMandatoryWhenJSpecifyNullableAnnotationShouldReturnFalse() { - OperationMethodParameter parameter = new OperationMethodParameter("name", - this.exampleJSpecifyNullable.getParameters()[1], this::isOptionalParameter); + void isMandatoryWhenNullableAnnotationShouldReturnFalse() { + OperationMethodParameter parameter = new OperationMethodParameter("name", this.example.getParameters()[1]); assertThat(parameter.isMandatory()).isFalse(); } @Test + @Deprecated(since = "4.0.0") void isMandatoryWhenSpringNullableAnnotationShouldReturnFalse() { OperationMethodParameter parameter = new OperationMethodParameter("name", - this.exampleSpringNullable.getParameters()[1], this::isOptionalParameter); + this.exampleSpringNullable.getParameters()[1]); assertThat(parameter.isMandatory()).isFalse(); } @Test void getAnnotationShouldReturnAnnotation() { OperationMethodParameter parameter = new OperationMethodParameter("name", - this.exampleAnnotation.getParameters()[0], this::isOptionalParameter); + this.exampleAnnotation.getParameters()[0]); Selector annotation = parameter.getAnnotation(Selector.class); assertThat(annotation).isNotNull(); assertThat(annotation.match()).isEqualTo(Match.ALL_REMAINING); } - private boolean isOptionalParameter(Parameter parameter) { - return MergedAnnotations.from(parameter).isPresent(TestOptional.class); + void example(String one, @org.jspecify.annotations.Nullable String two) { } - void example(String one, @TestOptional String two) { - } - - void exampleJSpecifyNullable(String one, @org.jspecify.annotations.Nullable String two) { - } - - @SuppressWarnings("deprecation") + @Deprecated(since = "4.0.0") void exampleSpringNullable(String one, @org.springframework.lang.Nullable String two) { } void exampleAnnotation(@Selector(match = Match.ALL_REMAINING) String allRemaining) { } - @Target({ ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD }) - @Retention(RetentionPolicy.RUNTIME) - @Documented - public @interface TestOptional { - - } - } diff --git a/module/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethodParametersTests.java b/module/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethodParametersTests.java index 4974f739ded..8e1240dc657 100644 --- a/module/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethodParametersTests.java +++ b/module/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethodParametersTests.java @@ -17,12 +17,10 @@ package org.springframework.boot.actuate.endpoint.invoke.reflect; import java.lang.reflect.Method; -import java.lang.reflect.Parameter; import java.util.Iterator; import java.util.List; import java.util.Spliterator; import java.util.Spliterators; -import java.util.function.Predicate; import java.util.stream.Stream; import java.util.stream.StreamSupport; @@ -45,8 +43,6 @@ import static org.mockito.Mockito.mock; */ class OperationMethodParametersTests { - private static final Predicate NON_OPTIONAL = (parameter) -> false; - private final Method exampleMethod = ReflectionUtils.findMethod(getClass(), "example", String.class); private final Method exampleNoParamsMethod = ReflectionUtils.findMethod(getClass(), "exampleNoParams"); @@ -54,50 +50,48 @@ class OperationMethodParametersTests { @Test void createWhenMethodIsNullShouldThrowException() { assertThatIllegalArgumentException() - .isThrownBy(() -> new OperationMethodParameters(null, mock(ParameterNameDiscoverer.class), NON_OPTIONAL)) + .isThrownBy(() -> new OperationMethodParameters(null, mock(ParameterNameDiscoverer.class))) .withMessageContaining("'method' must not be null"); } @Test void createWhenParameterNameDiscovererIsNullShouldThrowException() { - assertThatIllegalArgumentException() - .isThrownBy(() -> new OperationMethodParameters(this.exampleMethod, null, NON_OPTIONAL)) + assertThatIllegalArgumentException().isThrownBy(() -> new OperationMethodParameters(this.exampleMethod, null)) .withMessageContaining("'parameterNameDiscoverer' must not be null"); } @Test void createWhenParameterNameDiscovererReturnsNullShouldThrowException() { assertThatIllegalStateException() - .isThrownBy(() -> new OperationMethodParameters(this.exampleMethod, mock(ParameterNameDiscoverer.class), - NON_OPTIONAL)) + .isThrownBy(() -> new OperationMethodParameters(this.exampleMethod, mock(ParameterNameDiscoverer.class))) .withMessageContaining("Failed to extract parameter names"); } @Test void hasParametersWhenHasParametersShouldReturnTrue() { OperationMethodParameters parameters = new OperationMethodParameters(this.exampleMethod, - new DefaultParameterNameDiscoverer(), NON_OPTIONAL); + new DefaultParameterNameDiscoverer()); assertThat(parameters.hasParameters()).isTrue(); } @Test void hasParametersWhenHasNoParametersShouldReturnFalse() { OperationMethodParameters parameters = new OperationMethodParameters(this.exampleNoParamsMethod, - new DefaultParameterNameDiscoverer(), NON_OPTIONAL); + new DefaultParameterNameDiscoverer()); assertThat(parameters.hasParameters()).isFalse(); } @Test void getParameterCountShouldReturnParameterCount() { OperationMethodParameters parameters = new OperationMethodParameters(this.exampleMethod, - new DefaultParameterNameDiscoverer(), NON_OPTIONAL); + new DefaultParameterNameDiscoverer()); assertThat(parameters.getParameterCount()).isOne(); } @Test void iteratorShouldIterateOperationParameters() { OperationMethodParameters parameters = new OperationMethodParameters(this.exampleMethod, - new DefaultParameterNameDiscoverer(), NON_OPTIONAL); + new DefaultParameterNameDiscoverer()); Iterator iterator = parameters.iterator(); assertParameters( StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, Spliterator.ORDERED), false)); @@ -106,7 +100,7 @@ class OperationMethodParametersTests { @Test void streamShouldStreamOperationParameters() { OperationMethodParameters parameters = new OperationMethodParameters(this.exampleMethod, - new DefaultParameterNameDiscoverer(), NON_OPTIONAL); + new DefaultParameterNameDiscoverer()); assertParameters(parameters.stream()); } diff --git a/module/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethodTests.java b/module/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethodTests.java index 987c7d02890..03d03165fc5 100644 --- a/module/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethodTests.java +++ b/module/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/invoke/reflect/OperationMethodTests.java @@ -17,8 +17,6 @@ package org.springframework.boot.actuate.endpoint.invoke.reflect; import java.lang.reflect.Method; -import java.lang.reflect.Parameter; -import java.util.function.Predicate; import org.junit.jupiter.api.Test; @@ -36,39 +34,35 @@ import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException */ class OperationMethodTests { - private static final Predicate NON_OPTIONAL = (parameter) -> false; - private final Method exampleMethod = ReflectionUtils.findMethod(getClass(), "example", String.class); @Test void createWhenMethodIsNullShouldThrowException() { - assertThatIllegalArgumentException() - .isThrownBy(() -> new OperationMethod(null, OperationType.READ, NON_OPTIONAL)) + assertThatIllegalArgumentException().isThrownBy(() -> new OperationMethod(null, OperationType.READ)) .withMessageContaining("'method' must not be null"); } @Test void createWhenOperationTypeIsNullShouldThrowException() { - assertThatIllegalArgumentException() - .isThrownBy(() -> new OperationMethod(this.exampleMethod, null, NON_OPTIONAL)) + assertThatIllegalArgumentException().isThrownBy(() -> new OperationMethod(this.exampleMethod, null)) .withMessageContaining("'operationType' must not be null"); } @Test void getMethodShouldReturnMethod() { - OperationMethod operationMethod = new OperationMethod(this.exampleMethod, OperationType.READ, NON_OPTIONAL); + OperationMethod operationMethod = new OperationMethod(this.exampleMethod, OperationType.READ); assertThat(operationMethod.getMethod()).isEqualTo(this.exampleMethod); } @Test void getOperationTypeShouldReturnOperationType() { - OperationMethod operationMethod = new OperationMethod(this.exampleMethod, OperationType.READ, NON_OPTIONAL); + OperationMethod operationMethod = new OperationMethod(this.exampleMethod, OperationType.READ); assertThat(operationMethod.getOperationType()).isEqualTo(OperationType.READ); } @Test void getParametersShouldReturnParameters() { - OperationMethod operationMethod = new OperationMethod(this.exampleMethod, OperationType.READ, NON_OPTIONAL); + OperationMethod operationMethod = new OperationMethod(this.exampleMethod, OperationType.READ); OperationParameters parameters = operationMethod.getParameters(); assertThat(parameters.getParameterCount()).isOne(); assertThat(parameters.iterator().next().getName()).isEqualTo("name"); diff --git a/module/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/invoke/reflect/ReflectiveOperationInvokerTests.java b/module/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/invoke/reflect/ReflectiveOperationInvokerTests.java index 89f4574aa08..a247afeb350 100644 --- a/module/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/invoke/reflect/ReflectiveOperationInvokerTests.java +++ b/module/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/invoke/reflect/ReflectiveOperationInvokerTests.java @@ -16,14 +16,9 @@ package org.springframework.boot.actuate.endpoint.invoke.reflect; -import java.lang.annotation.Documented; -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; -import java.lang.reflect.Parameter; import java.util.Collections; +import org.jspecify.annotations.Nullable; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -33,7 +28,6 @@ import org.springframework.boot.actuate.endpoint.OperationType; import org.springframework.boot.actuate.endpoint.SecurityContext; import org.springframework.boot.actuate.endpoint.invoke.MissingParametersException; import org.springframework.boot.actuate.endpoint.invoke.ParameterValueMapper; -import org.springframework.core.annotation.MergedAnnotations; import org.springframework.util.ReflectionUtils; import static org.assertj.core.api.Assertions.assertThat; @@ -58,7 +52,7 @@ class ReflectiveOperationInvokerTests { void setup() { this.target = new Example(); this.operationMethod = new OperationMethod(ReflectionUtils.findMethod(Example.class, "reverse", - ApiVersion.class, SecurityContext.class, String.class), OperationType.READ, this::isOptional); + ApiVersion.class, SecurityContext.class, String.class), OperationType.READ); this.parameterValueMapper = (parameter, value) -> (value != null) ? value.toString() : null; } @@ -103,8 +97,7 @@ class ReflectiveOperationInvokerTests { @Test void invokeWhenMissingOptionalArgumentShouldInvoke() { OperationMethod operationMethod = new OperationMethod(ReflectionUtils.findMethod(Example.class, - "reverseOptional", ApiVersion.class, SecurityContext.class, String.class), OperationType.READ, - this::isOptional); + "reverseOptional", ApiVersion.class, SecurityContext.class, String.class), OperationType.READ); ReflectiveOperationInvoker invoker = new ReflectiveOperationInvoker(this.target, operationMethod, this.parameterValueMapper); Object result = invoker @@ -121,10 +114,6 @@ class ReflectiveOperationInvokerTests { assertThat(result).isEqualTo("4321"); } - private boolean isOptional(Parameter parameter) { - return MergedAnnotations.from(parameter).isPresent(TestOptional.class); - } - static class Example { String reverse(ApiVersion apiVersion, SecurityContext securityContext, String name) { @@ -133,7 +122,7 @@ class ReflectiveOperationInvokerTests { return new StringBuilder(name).reverse().toString(); } - String reverseOptional(ApiVersion apiVersion, SecurityContext securityContext, @TestOptional String name) { + String reverseOptional(ApiVersion apiVersion, SecurityContext securityContext, @Nullable String name) { assertThat(apiVersion).isEqualTo(ApiVersion.LATEST); assertThat(securityContext).isNotNull(); return new StringBuilder(String.valueOf(name)).reverse().toString(); @@ -141,11 +130,4 @@ class ReflectiveOperationInvokerTests { } - @Target({ ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD }) - @Retention(RetentionPolicy.RUNTIME) - @Documented - public @interface TestOptional { - - } - } diff --git a/module/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/invoker/cache/CachingOperationInvokerAdvisorTests.java b/module/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/invoker/cache/CachingOperationInvokerAdvisorTests.java index 1621932fb3e..8d8575fb2d7 100644 --- a/module/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/invoker/cache/CachingOperationInvokerAdvisorTests.java +++ b/module/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/endpoint/invoker/cache/CachingOperationInvokerAdvisorTests.java @@ -16,14 +16,10 @@ package org.springframework.boot.actuate.endpoint.invoker.cache; -import java.lang.annotation.Documented; -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; import java.lang.reflect.Method; import java.util.function.Function; +import org.jspecify.annotations.Nullable; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -38,7 +34,6 @@ import org.springframework.boot.actuate.endpoint.invoke.OperationInvoker; import org.springframework.boot.actuate.endpoint.invoke.OperationParameters; import org.springframework.boot.actuate.endpoint.invoke.reflect.OperationMethod; import org.springframework.boot.actuate.endpoint.web.WebServerNamespace; -import org.springframework.core.annotation.MergedAnnotations; import org.springframework.util.ReflectionUtils; import static org.assertj.core.api.Assertions.assertThat; @@ -163,34 +158,32 @@ class CachingOperationInvokerAdvisorTests { private OperationMethod getOperationMethod(String methodName, Class... parameterTypes) { Method method = ReflectionUtils.findMethod(TestOperations.class, methodName, parameterTypes); - return new OperationMethod(method, OperationType.READ, - (parameter) -> MergedAnnotations.from(parameter).isPresent(TestOptional.class)); + return new OperationMethod(method, OperationType.READ); } - @SuppressWarnings("deprecation") static class TestOperations { String get() { return ""; } - String getWithParameters(@TestOptional String foo, String bar) { + String getWithParameters(@Nullable String foo, String bar) { return ""; } - String getWithAllOptionalParameters(@TestOptional String foo, @TestOptional String bar) { + String getWithAllOptionalParameters(@Nullable String foo, @Nullable String bar) { return ""; } - String getWithSecurityContext(SecurityContext securityContext, @TestOptional String bar) { + String getWithSecurityContext(SecurityContext securityContext, @Nullable String bar) { return ""; } - String getWithApiVersion(ApiVersion apiVersion, @TestOptional String bar) { + String getWithApiVersion(ApiVersion apiVersion, @Nullable String bar) { return ""; } - String getWithServerNamespace(WebServerNamespace serverNamespace, @TestOptional String bar) { + String getWithServerNamespace(WebServerNamespace serverNamespace, @Nullable String bar) { return ""; } @@ -200,11 +193,4 @@ class CachingOperationInvokerAdvisorTests { } - @Target({ ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD }) - @Retention(RetentionPolicy.RUNTIME) - @Documented - public @interface TestOptional { - - } - } diff --git a/module/spring-boot-cache/src/main/java/org/springframework/boot/cache/actuate/endpoint/CachesEndpoint.java b/module/spring-boot-cache/src/main/java/org/springframework/boot/cache/actuate/endpoint/CachesEndpoint.java index 15fe6c167e6..c4b36c3b857 100644 --- a/module/spring-boot-cache/src/main/java/org/springframework/boot/cache/actuate/endpoint/CachesEndpoint.java +++ b/module/spring-boot-cache/src/main/java/org/springframework/boot/cache/actuate/endpoint/CachesEndpoint.java @@ -27,7 +27,6 @@ import org.jspecify.annotations.Nullable; import org.springframework.boot.actuate.endpoint.OperationResponseBody; import org.springframework.boot.actuate.endpoint.annotation.DeleteOperation; import org.springframework.boot.actuate.endpoint.annotation.Endpoint; -import org.springframework.boot.actuate.endpoint.annotation.OptionalParameter; import org.springframework.boot.actuate.endpoint.annotation.ReadOperation; import org.springframework.boot.actuate.endpoint.annotation.Selector; import org.springframework.cache.Cache; @@ -82,8 +81,7 @@ public class CachesEndpoint { * {@code cacheManager} was provided to identify a unique candidate */ @ReadOperation - public @Nullable CacheEntryDescriptor cache(@Selector String cache, - @OptionalParameter @Nullable String cacheManager) { + public @Nullable CacheEntryDescriptor cache(@Selector String cache, @Nullable String cacheManager) { return extractUniqueCacheEntry(cache, getCacheEntries((name) -> name.equals(cache), isNameMatch(cacheManager))); } @@ -105,7 +103,7 @@ public class CachesEndpoint { * {@code cacheManager} was provided to identify a unique candidate */ @DeleteOperation - public boolean clearCache(@Selector String cache, @OptionalParameter @Nullable String cacheManager) { + public boolean clearCache(@Selector String cache, @Nullable String cacheManager) { CacheEntryDescriptor entry = extractUniqueCacheEntry(cache, getCacheEntries((name) -> name.equals(cache), isNameMatch(cacheManager))); return (entry != null && clearCache(entry)); diff --git a/module/spring-boot-cache/src/main/java/org/springframework/boot/cache/actuate/endpoint/CachesEndpointWebExtension.java b/module/spring-boot-cache/src/main/java/org/springframework/boot/cache/actuate/endpoint/CachesEndpointWebExtension.java index cadbf41fcab..6ce902debad 100644 --- a/module/spring-boot-cache/src/main/java/org/springframework/boot/cache/actuate/endpoint/CachesEndpointWebExtension.java +++ b/module/spring-boot-cache/src/main/java/org/springframework/boot/cache/actuate/endpoint/CachesEndpointWebExtension.java @@ -19,7 +19,6 @@ package org.springframework.boot.cache.actuate.endpoint; import org.jspecify.annotations.Nullable; import org.springframework.boot.actuate.endpoint.annotation.DeleteOperation; -import org.springframework.boot.actuate.endpoint.annotation.OptionalParameter; import org.springframework.boot.actuate.endpoint.annotation.ReadOperation; import org.springframework.boot.actuate.endpoint.annotation.Selector; import org.springframework.boot.actuate.endpoint.web.WebEndpointResponse; @@ -42,8 +41,7 @@ public class CachesEndpointWebExtension { } @ReadOperation - public WebEndpointResponse cache(@Selector String cache, - @OptionalParameter @Nullable String cacheManager) { + public WebEndpointResponse cache(@Selector String cache, @Nullable String cacheManager) { try { CacheEntryDescriptor entry = this.delegate.cache(cache, cacheManager); int status = (entry != null) ? WebEndpointResponse.STATUS_OK : WebEndpointResponse.STATUS_NOT_FOUND; @@ -55,8 +53,7 @@ public class CachesEndpointWebExtension { } @DeleteOperation - public WebEndpointResponse clearCache(@Selector String cache, - @OptionalParameter @Nullable String cacheManager) { + public WebEndpointResponse clearCache(@Selector String cache, @Nullable String cacheManager) { try { boolean cleared = this.delegate.clearCache(cache, cacheManager); int status = (cleared ? WebEndpointResponse.STATUS_NO_CONTENT : WebEndpointResponse.STATUS_NOT_FOUND); diff --git a/module/spring-boot-micrometer-metrics/src/main/java/org/springframework/boot/micrometer/metrics/actuate/endpoint/MetricsEndpoint.java b/module/spring-boot-micrometer-metrics/src/main/java/org/springframework/boot/micrometer/metrics/actuate/endpoint/MetricsEndpoint.java index 9f8fded2d16..50facc764c3 100644 --- a/module/spring-boot-micrometer-metrics/src/main/java/org/springframework/boot/micrometer/metrics/actuate/endpoint/MetricsEndpoint.java +++ b/module/spring-boot-micrometer-metrics/src/main/java/org/springframework/boot/micrometer/metrics/actuate/endpoint/MetricsEndpoint.java @@ -37,7 +37,6 @@ import org.jspecify.annotations.Nullable; import org.springframework.boot.actuate.endpoint.InvalidEndpointRequestException; import org.springframework.boot.actuate.endpoint.OperationResponseBody; import org.springframework.boot.actuate.endpoint.annotation.Endpoint; -import org.springframework.boot.actuate.endpoint.annotation.OptionalParameter; import org.springframework.boot.actuate.endpoint.annotation.ReadOperation; import org.springframework.boot.actuate.endpoint.annotation.Selector; @@ -78,8 +77,7 @@ public class MetricsEndpoint { } @ReadOperation - public @Nullable MetricDescriptor metric(@Selector String requiredMetricName, - @OptionalParameter @Nullable List tag) { + public @Nullable MetricDescriptor metric(@Selector String requiredMetricName, @Nullable List tag) { List tags = parseTags(tag); Collection meters = findFirstMatchingMeters(this.registry, requiredMetricName, tags); if (meters.isEmpty()) {