From ee6a4e7c1e3245bd758c1a553f21ae8b3a8a6dbc Mon Sep 17 00:00:00 2001 From: Stephane Nicoll Date: Mon, 11 Jul 2022 16:37:12 -0400 Subject: [PATCH] Add predicates for Serialization hints Closes gh-28772 --- .../aot/hint/RuntimeHintsPredicates.java | 10 ++++ .../hint/SerializationHintsPredicates.java | 60 +++++++++++++++++++ .../SerializationHintsPredicatesTests.java | 52 ++++++++++++++++ 3 files changed, 122 insertions(+) create mode 100644 spring-core/src/main/java/org/springframework/aot/hint/SerializationHintsPredicates.java create mode 100644 spring-core/src/test/java/org/springframework/aot/hint/SerializationHintsPredicatesTests.java diff --git a/spring-core/src/main/java/org/springframework/aot/hint/RuntimeHintsPredicates.java b/spring-core/src/main/java/org/springframework/aot/hint/RuntimeHintsPredicates.java index 4c01a3a837..12b8b3fb31 100644 --- a/spring-core/src/main/java/org/springframework/aot/hint/RuntimeHintsPredicates.java +++ b/spring-core/src/main/java/org/springframework/aot/hint/RuntimeHintsPredicates.java @@ -37,6 +37,8 @@ public abstract class RuntimeHintsPredicates { private static final ResourceHintsPredicates resource = new ResourceHintsPredicates(); + private static final SerializationHintsPredicates serialization = new SerializationHintsPredicates(); + private static final ProxyHintsPredicates proxies = new ProxyHintsPredicates(); @@ -59,6 +61,14 @@ public abstract class RuntimeHintsPredicates { return resource; } + /** + * Return a predicate generator for {@link SerializationHints serialization hints}. + * @return the predicate generator + */ + public static SerializationHintsPredicates serialization() { + return serialization; + } + /** * Return a predicate generator for {@link ProxyHints proxy hints}. * @return the predicate generator diff --git a/spring-core/src/main/java/org/springframework/aot/hint/SerializationHintsPredicates.java b/spring-core/src/main/java/org/springframework/aot/hint/SerializationHintsPredicates.java new file mode 100644 index 0000000000..4e87eaf1e8 --- /dev/null +++ b/spring-core/src/main/java/org/springframework/aot/hint/SerializationHintsPredicates.java @@ -0,0 +1,60 @@ +/* + * Copyright 2002-2022 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.aot.hint; + +import java.util.function.Predicate; + +import org.springframework.util.Assert; + +/** + * Generator of {@link SerializationHints} predicates, testing whether the + * given hints match the expected behavior for serialization. + * + * @author Stephane Nicoll + * @since 6.0 + */ +public class SerializationHintsPredicates { + + SerializationHintsPredicates() { + } + + /** + * Return a predicate that checks whether a {@link SerializationHints + * serialization hint} is registered for the given type. + * @param type the type to check + * @return the {@link RuntimeHints} predicate + * @see java.lang.reflect.Proxy + */ + public Predicate onType(Class type) { + Assert.notNull(type, "'type' should not be null"); + return onType(TypeReference.of(type)); + } + + /** + * Return a predicate that checks whether a {@link SerializationHints + * serialization hint} is registered for the given type reference. + * @param typeReference the type to check + * @return the {@link RuntimeHints} predicate + * @see java.lang.reflect.Proxy + */ + public Predicate onType(TypeReference typeReference) { + Assert.notNull(typeReference, "'typeReference' should not be null"); + return hints -> hints.serialization().javaSerialization().anyMatch( + hint -> hint.getType().equals(typeReference)); + } + +} diff --git a/spring-core/src/test/java/org/springframework/aot/hint/SerializationHintsPredicatesTests.java b/spring-core/src/test/java/org/springframework/aot/hint/SerializationHintsPredicatesTests.java new file mode 100644 index 0000000000..46e13bffdb --- /dev/null +++ b/spring-core/src/test/java/org/springframework/aot/hint/SerializationHintsPredicatesTests.java @@ -0,0 +1,52 @@ +/* + * Copyright 2002-2022 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.aot.hint; + +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * Tests for {@link SerializationHintsPredicates}. + * + * @author Stephane Nicoll + */ +class SerializationHintsPredicatesTests { + + private final SerializationHintsPredicates serialization = new SerializationHintsPredicates(); + + private final RuntimeHints runtimeHints = new RuntimeHints(); + + @Test + void shouldMatchRegisteredClass() { + runtimeHints.serialization().registerType(String.class); + assertThat(serialization.onType(String.class).test(runtimeHints)).isTrue(); + } + + @Test + void shouldMatchRegisteredTypeReference() { + runtimeHints.serialization().registerType(TypeReference.of(String.class)); + assertThat(serialization.onType(String.class).test(runtimeHints)).isTrue(); + } + + @Test + void shouldNotMatchUnregisteredType() { + runtimeHints.serialization().registerType(Integer.class); + assertThat(serialization.onType(Long.class).test(runtimeHints)).isFalse(); + } + +}