Add support for Jakarta Nullability Annotations.

Author: mp911de

pom.xml

@@ -33,6 +33,7 @@
 		<scala>2.11.7</scala>
 		<xmlbeam>1.4.24</xmlbeam>
 		<java-module-name>spring.data.commons</java-module-name>
+		<jakarta-annotation-api>2.1.1</jakarta-annotation-api>
 		<kotlin.api.target>1.8</kotlin.api.target>
 	</properties>
 
@@ -41,40 +42,48 @@
 			<groupId>org.springframework</groupId>
 			<artifactId>spring-core</artifactId>
 		</dependency>
+
 		<dependency>
 			<groupId>org.springframework</groupId>
 			<artifactId>spring-beans</artifactId>
 		</dependency>
+
 		<dependency>
 			<groupId>org.springframework</groupId>
 			<artifactId>spring-context</artifactId>
 			<optional>true</optional>
 		</dependency>
+
 		<dependency>
 			<groupId>org.springframework</groupId>
 			<artifactId>spring-expression</artifactId>
 			<optional>true</optional>
 		</dependency>
+
 		<dependency>
 			<groupId>org.springframework</groupId>
 			<artifactId>spring-tx</artifactId>
 			<optional>true</optional>
 		</dependency>
+
 		<dependency>
 			<groupId>org.springframework</groupId>
 			<artifactId>spring-oxm</artifactId>
 			<optional>true</optional>
 		</dependency>
+
 		<dependency>
 			<groupId>com.fasterxml.jackson.core</groupId>
 			<artifactId>jackson-databind</artifactId>
 			<optional>true</optional>
 		</dependency>
+
 		<dependency>
 			<groupId>org.springframework</groupId>
 			<artifactId>spring-web</artifactId>
 			<optional>true</optional>
 		</dependency>
+
 		<dependency>
 			<groupId>org.springframework</groupId>
 			<artifactId>spring-webflux</artifactId>
@@ -92,12 +101,14 @@
 			<artifactId>jakarta.servlet-api</artifactId>
 			<scope>provided</scope>
 		</dependency>
+
 		<dependency>
 			<groupId>jakarta.xml.bind</groupId>
 			<artifactId>jakarta.xml.bind-api</artifactId>
 			<version>${jaxb}</version>
 			<scope>provided</scope>
 		</dependency>
+
 		<dependency>
 			<groupId>jakarta.annotation</groupId>
 			<artifactId>jakarta.annotation-api</artifactId>

src/main/java/org/springframework/data/util/NullabilityIntrospector.java

@@ -18,7 +18,6 @@
 import java.lang.annotation.Annotation;
 import java.lang.annotation.ElementType;
 import java.lang.reflect.AnnotatedElement;
-import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Parameter;
 import java.util.ArrayList;
@@ -53,6 +52,10 @@ class NullabilityIntrospector implements Nullability.Introspector {
 			providers.add(new Jsr305Provider());
 		}
 
+		if (JakartaAnnotation.isAvailable()) {
+			providers.add(new JakartaAnnotation());
+		}
+
 		providers.add(new SpringProvider());
 	}
 
@@ -270,9 +273,59 @@ static boolean isNullable(Annotation annotation) {
 		}
 	}
 
-	private static ElementType getElementType(AnnotatedElement element) {
-		return element instanceof Method ? ElementType.METHOD
-				: element instanceof Field ? ElementType.FIELD : ElementType.PARAMETER;
+	/**
+	 * Provider based on the JSR-305 (dormant) spec. Elements can be either annotated with
+	 * {@code @Nonnull}/{@code @Nullable} directly or through meta-annotations that are composed of
+	 * {@code @Nonnull}/{@code @Nullable} and {@code @TypeQualifierDefault}.
+	 */
+	static class JakartaAnnotation extends NullabilityProvider {
+
+		private static final Class<Annotation> NON_NULL = findClass("jakarta.annotation.Nonnull");
+		private static final Class<Annotation> NULLABLE = findClass("jakarta.annotation.Nullable");
+
+		public static boolean isAvailable() {
+			return NON_NULL != null && NULLABLE != null;
+		}
+
+		@Override
+		Spec evaluate(AnnotatedElement element, ElementType elementType) {
+
+			if (element.isAnnotationPresent(NULLABLE) || MergedAnnotations.from(element).isPresent(NULLABLE)) {
+				return Spec.NULLABLE;
+			}
+
+			Annotation[] annotations = element.getAnnotations();
+
+			for (Annotation annotation : annotations) {
+
+				if (test(NON_NULL, annotation)) {
+					return Spec.NON_NULL;
+				}
+
+				if (test(NULLABLE, annotation)) {
+					return Spec.NULLABLE;
+				}
+			}
+
+			return Spec.UNSPECIFIED;
+		}
+
+		private static boolean test(Class<Annotation> annotationClass, Annotation annotation) {
+
+			if (annotation.annotationType().equals(annotationClass)) {
+				return true;
+			}
+
+			MergedAnnotations annotations = MergedAnnotations.from(annotation.annotationType());
+			if (annotations.isPresent(annotationClass)) {
+				Annotation meta = annotations.get(annotationClass).synthesize();
+
+				return true;
+			}
+
+			return false;
+		}
+
 	}
 
 	@Nullable

src/test/java/org/springframework/data/util/NullableUtilsUnitTests.java

@@ -71,6 +71,28 @@ void packageAnnotatedShouldConsiderNonNullAnnotationForMethod() {
 		assertThat(NullableUtils.isNonNull(NonNullOnPackage.class, ElementType.PACKAGE)).isFalse();
 	}
 
+	@Test //
+	void shouldConsiderJakartaNonNullParameters() {
+
+		var method = ReflectionUtils.findMethod(org.springframework.data.util.nonnull.jakarta.NonNullOnPackage.class, "someMethod", String.class, String.class);
+		Nullability.Introspector introspector = Nullability.introspect(method.getDeclaringClass());
+		Nullability mrt = introspector.forReturnType(method);
+
+		assertThat(mrt.isDeclared()).isTrue();
+		assertThat(mrt.isNonNull()).isTrue();
+		assertThat(mrt.isNullable()).isFalse();
+
+		Nullability pn0 = introspector.forParameter(MethodParameter.forExecutable(method, 0));
+		assertThat(pn0.isDeclared()).isTrue();
+		assertThat(pn0.isNullable()).isFalse();
+		assertThat(pn0.isNonNull()).isTrue();
+
+		Nullability pn1 = introspector.forParameter(MethodParameter.forExecutable(method, 1));
+		assertThat(pn1.isDeclared()).isTrue();
+		assertThat(pn1.isNullable()).isTrue();
+		assertThat(pn1.isNonNull()).isFalse();
+	}
+
 	@Test // DATACMNS-1154
 	void shouldConsiderJsr305NonNullParameters() {
 
@@ -158,7 +180,7 @@ void shouldConsiderParametersNullableAnnotation() {
 	}
 
 	@Test // DATACMNS-1154
-	void shouldConsiderParametersJsr305NullableMetaAnnotation() {
+	void shouldConsiderMethodReturnJsr305NullableMetaAnnotation() {
 
 		var method = ReflectionUtils.findMethod(NullableAnnotatedType.class, "jsr305NullableReturn");
 
@@ -172,7 +194,7 @@ void shouldConsiderParametersJsr305NullableMetaAnnotation() {
 	}
 
 	@Test // DATACMNS-1154
-	void shouldConsiderParametersJsr305NonnullAnnotation() {
+	void shouldConsiderMethodReturnJsr305NonnullAnnotation() {
 
 		var method = ReflectionUtils.findMethod(NullableAnnotatedType.class, "jsr305NullableReturnWhen");
 
@@ -184,4 +206,28 @@ void shouldConsiderParametersJsr305NonnullAnnotation() {
 		assertThat(mrt.isNullable()).isTrue();
 		assertThat(mrt.isNonNull()).isFalse();
 	}
+
+	@Test //
+	void shouldConsiderMethodReturnJakartaNonnullAnnotation() {
+
+		var method = ReflectionUtils.findMethod(NullableAnnotatedType.class, "jakartaNonnullReturnWhen");
+
+		Nullability mrt = Nullability.forMethodReturnType(method);
+
+		assertThat(mrt.isDeclared()).isTrue();
+		assertThat(mrt.isNullable()).isFalse();
+		assertThat(mrt.isNonNull()).isTrue();
+	}
+
+	@Test //
+	void shouldConsiderMethodReturnJakartaNullableAnnotation() {
+
+		var method = ReflectionUtils.findMethod(NullableAnnotatedType.class, "jakartaNullableReturnWhen");
+
+		Nullability mrt = Nullability.forMethodReturnType(method);
+
+		assertThat(mrt.isDeclared()).isTrue();
+		assertThat(mrt.isNullable()).isTrue();
+		assertThat(mrt.isNonNull()).isFalse();
+	}
 }

src/test/java/org/springframework/data/util/nonnull/NullableAnnotatedType.java

@@ -34,4 +34,10 @@ public interface NullableAnnotatedType {
 
 	@javax.annotation.Nonnull(when = When.MAYBE)
 	String jsr305NullableReturnWhen();
+
+	@jakarta.annotation.Nonnull
+	String jakartaNonnullReturnWhen();
+
+	@jakarta.annotation.Nullable
+	String jakartaNullableReturnWhen();
 }

src/test/java/org/springframework/data/util/nonnull/jakarta/NonNullOnPackage.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2017-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.data.util.nonnull.jakarta;
+
+import jakarta.annotation.Nullable;
+
+/**
+ * @author Mark Paluch
+ */
+public interface NonNullOnPackage {
+
+	String someMethod(String arg, @Nullable String nullableArg);
+}

src/test/java/org/springframework/data/util/nonnull/jakarta/package-info.java

@@ -0,0 +1,23 @@
+/*
+ * Copyright 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.
+ */
+
+/**
+ * @author Mark Paluch
+ */
+@Nonnull
+package org.springframework.data.util.nonnull.jakarta;
+
+import jakarta.annotation.Nonnull;