Skip to content

Commit 016e8c2

Browse files
christophstroblmp911de
christophstrobl
authored and
mp911de
committed
Register reflection hints for Querydsl Q types.
This commit introduced support for registering GraalVM native reflection type hints for Querydsl Q types that target domain types used in the repository interface declaration. At this point we only do a simple lookup for Q types based in the very same package that implement EntityPath. More advanced configuration (eg. base package and type prefix), potentially available via EntityPathResolver are not taken into account as this would require eager bean resolution from the application context, which is likely to trigger additional infrastructure. In this case the user is required to register Q types manually. Closes: #2721 Original pull request: #2743.
1 parent 14d76ab commit 016e8c2

7 files changed

+284
-6
lines changed

‎src/main/java/org/springframework/data/aot/ManagedTypesBeanRegistrationAotProcessor.java

+5-2
Original file line numberDiff line numberDiff line change
@@ -31,6 +31,7 @@
3131
import org.springframework.beans.factory.support.RootBeanDefinition;
3232
import org.springframework.core.ResolvableType;
3333
import org.springframework.data.domain.ManagedTypes;
34+
import org.springframework.data.util.QTypeContributor;
3435
import org.springframework.data.util.TypeContributor;
3536
import org.springframework.data.util.TypeUtils;
3637
import org.springframework.lang.Nullable;
@@ -134,9 +135,11 @@ protected void contributeType(ResolvableType type, GenerationContext generationC
134135

135136
Set<String> annotationNamespaces = Collections.singleton(TypeContributor.DATA_NAMESPACE);
136137

137-
TypeContributor.contribute(type.toClass(), annotationNamespaces, generationContext);
138+
Class<?> resolvedType = type.toClass();
139+
TypeContributor.contribute(resolvedType, annotationNamespaces, generationContext);
140+
QTypeContributor.contributeEntityPath(resolvedType, generationContext, resolvedType.getClassLoader());
138141

139-
TypeUtils.resolveUsedAnnotations(type.toClass()).forEach(
142+
TypeUtils.resolveUsedAnnotations(resolvedType).forEach(
140143
annotation -> TypeContributor.contribute(annotation.getType(), annotationNamespaces, generationContext));
141144
}
142145

‎src/main/java/org/springframework/data/repository/config/RepositoryRegistrationAotContribution.java

+7-4
Original file line numberDiff line numberDiff line change
@@ -42,14 +42,15 @@
4242
import org.springframework.core.ResolvableType;
4343
import org.springframework.core.annotation.AnnotationUtils;
4444
import org.springframework.data.aot.AotContext;
45-
import org.springframework.data.util.TypeContributor;
46-
import org.springframework.data.util.TypeUtils;
4745
import org.springframework.data.projection.EntityProjectionIntrospector;
4846
import org.springframework.data.projection.TargetAware;
4947
import org.springframework.data.repository.Repository;
5048
import org.springframework.data.repository.core.RepositoryInformation;
5149
import org.springframework.data.repository.core.support.RepositoryFactoryBeanSupport;
5250
import org.springframework.data.repository.core.support.RepositoryFragment;
51+
import org.springframework.data.util.QTypeContributor;
52+
import org.springframework.data.util.TypeContributor;
53+
import org.springframework.data.util.TypeUtils;
5354
import org.springframework.lang.Nullable;
5455
import org.springframework.stereotype.Component;
5556
import org.springframework.util.Assert;
@@ -263,10 +264,12 @@ private void contributeRepositoryInfo(AotRepositoryContext repositoryContext, Ge
263264
contribution.getRuntimeHints().reflection()
264265
.registerType(repositoryInformation.getRepositoryInterface(),
265266
hint -> hint.withMembers(MemberCategory.INVOKE_PUBLIC_METHODS))
266-
.registerType(repositoryInformation.getRepositoryBaseClass(),
267-
hint -> hint.withMembers(MemberCategory.INVOKE_DECLARED_CONSTRUCTORS, MemberCategory.INVOKE_PUBLIC_METHODS));
267+
.registerType(repositoryInformation.getRepositoryBaseClass(), hint -> hint
268+
.withMembers(MemberCategory.INVOKE_DECLARED_CONSTRUCTORS, MemberCategory.INVOKE_PUBLIC_METHODS));
268269

269270
TypeContributor.contribute(repositoryInformation.getDomainType(), contribution);
271+
QTypeContributor.contributeEntityPath(repositoryInformation.getDomainType(), contribution,
272+
repositoryContext.getClassLoader());
270273

271274
// Repository Fragments
272275
for (RepositoryFragment<?> fragment : getRepositoryInformation().getFragments()) {

‎src/main/java/org/springframework/data/util/QTypeContributor.java

+109
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,109 @@
1+
/*
2+
* Copyright 2022 the original author or authors.
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License");
5+
* you may not use this file except in compliance with the License.
6+
* You may obtain a copy of the License at
7+
*
8+
* https://www.apache.org/licenses/LICENSE-2.0
9+
*
10+
* Unless required by applicable law or agreed to in writing, software
11+
* distributed under the License is distributed on an "AS IS" BASIS,
12+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
* See the License for the specific language governing permissions and
14+
* limitations under the License.
15+
*/
16+
package org.springframework.data.util;
17+
18+
import java.util.Map;
19+
import java.util.WeakHashMap;
20+
import java.util.function.Function;
21+
22+
import org.apache.commons.logging.Log;
23+
import org.apache.commons.logging.LogFactory;
24+
import org.springframework.aot.generate.GenerationContext;
25+
import org.springframework.aot.hint.MemberCategory;
26+
import org.springframework.aot.hint.TypeReference;
27+
import org.springframework.lang.Nullable;
28+
import org.springframework.util.ClassUtils;
29+
30+
/**
31+
* @author Christoph Strobl
32+
* @since 4.1
33+
*/
34+
public class QTypeContributor {
35+
36+
private final static Log logger = LogFactory.getLog(QTypeContributor.class);
37+
private static Function<ClassLoader, Class<?>> entityPathType = cacheOf(QTypeContributor::getEntityPathType);
38+
39+
public static void contributeEntityPath(Class<?> type, GenerationContext context, @Nullable ClassLoader classLoader) {
40+
41+
Class<?> entityPathType = QTypeContributor.entityPathType.apply(classLoader);
42+
if (entityPathType == null) {
43+
return;
44+
}
45+
46+
String queryClassName = getQueryClassName(type);
47+
if (ClassUtils.isPresent(queryClassName, classLoader)) {
48+
try {
49+
if (ClassUtils.isAssignable(entityPathType, ClassUtils.forName(queryClassName, classLoader))) {
50+
51+
logger.debug("Registering Q type %s for %s.");
52+
context.getRuntimeHints().reflection().registerType(TypeReference.of(queryClassName),
53+
MemberCategory.INVOKE_PUBLIC_METHODS, MemberCategory.INVOKE_DECLARED_CONSTRUCTORS,
54+
MemberCategory.INTROSPECT_DECLARED_METHODS, MemberCategory.DECLARED_FIELDS);
55+
} else {
56+
logger.debug("Skipping Q type %s. Not an EntityPath.");
57+
}
58+
} catch (ClassNotFoundException e) {
59+
throw new IllegalStateException("%s could not be loaded".formatted(queryClassName), e);
60+
}
61+
}
62+
}
63+
64+
@Nullable
65+
private static Class<?> getEntityPathType(ClassLoader classLoader) {
66+
67+
if (!ClassUtils.isPresent("com.querydsl.core.types.EntityPath", classLoader)) {
68+
return null;
69+
}
70+
71+
try {
72+
return ClassUtils.forName("com.querydsl.core.types.EntityPath", classLoader);
73+
} catch (ClassNotFoundException e) {
74+
throw new RuntimeException(e);
75+
}
76+
}
77+
78+
private static Function<ClassLoader, Class<?>> cacheOf(Function<ClassLoader, Class<?>> inFunction) {
79+
Map<ClassLoader, Class<?>> cache = new WeakHashMap<>();
80+
return in -> cache.computeIfAbsent(in, inFunction::apply);
81+
}
82+
83+
/**
84+
* Returns the name of the query class for the given domain class.
85+
*
86+
* @param domainClass
87+
* @return
88+
*/
89+
private static String getQueryClassName(Class<?> domainClass) {
90+
91+
String simpleClassName = ClassUtils.getShortName(domainClass);
92+
String pkgName = domainClass.getPackage().getName();
93+
94+
return String.format("%s.Q%s%s", pkgName, getClassBase(simpleClassName), domainClass.getSimpleName());
95+
}
96+
97+
/**
98+
* Analyzes the short class name and potentially returns the outer class.
99+
*
100+
* @param shortName
101+
* @return
102+
*/
103+
private static String getClassBase(String shortName) {
104+
105+
String[] parts = shortName.split("\\.");
106+
107+
return parts.length < 2 ? "" : parts[0] + "_";
108+
}
109+
}

‎src/test/java/org/springframework/data/aot/sample/ConfigWithQuerydslPredicateExecutor.java

+49
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,49 @@
1+
/*
2+
* Copyright 2022 the original author or authors.
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License");
5+
* you may not use this file except in compliance with the License.
6+
* You may obtain a copy of the License at
7+
*
8+
* https://www.apache.org/licenses/LICENSE-2.0
9+
*
10+
* Unless required by applicable law or agreed to in writing, software
11+
* distributed under the License is distributed on an "AS IS" BASIS,
12+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
* See the License for the specific language governing permissions and
14+
* limitations under the License.
15+
*/
16+
package org.springframework.data.aot.sample;
17+
18+
import javax.annotation.processing.Generated;
19+
20+
import com.querydsl.core.types.dsl.BeanPath;
21+
import com.querydsl.core.types.dsl.EntityPathBase;
22+
import org.springframework.context.annotation.ComponentScan.Filter;
23+
import org.springframework.context.annotation.FilterType;
24+
import org.springframework.data.aot.sample.ConfigWithQuerydslPredicateExecutor.MyRepo;
25+
import org.springframework.data.querydsl.QuerydslPredicateExecutor;
26+
import org.springframework.data.repository.CrudRepository;
27+
import org.springframework.data.repository.config.EnableRepositories;
28+
29+
/**
30+
* @author Christoph Strobl
31+
*/
32+
@EnableRepositories(includeFilters = { @Filter(type = FilterType.ASSIGNABLE_TYPE, value = MyRepo.class) },
33+
basePackageClasses = ConfigWithQuerydslPredicateExecutor.class, considerNestedRepositories = true)
34+
public class ConfigWithQuerydslPredicateExecutor {
35+
36+
public interface MyRepo extends CrudRepository<Person, String>, QuerydslPredicateExecutor<Person> {
37+
38+
}
39+
40+
public static class Person {
41+
42+
Address address;
43+
44+
}
45+
46+
public static class Address {
47+
String street;
48+
}
49+
}

‎src/test/java/org/springframework/data/aot/sample/QConfigWithQuerydslPredicateExecutor_Person.java

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
/*
2+
* Copyright 2022 the original author or authors.
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License");
5+
* you may not use this file except in compliance with the License.
6+
* You may obtain a copy of the License at
7+
*
8+
* https://www.apache.org/licenses/LICENSE-2.0
9+
*
10+
* Unless required by applicable law or agreed to in writing, software
11+
* distributed under the License is distributed on an "AS IS" BASIS,
12+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
* See the License for the specific language governing permissions and
14+
* limitations under the License.
15+
*/
16+
package org.springframework.data.aot.sample;
17+
18+
import com.querydsl.core.types.dsl.EntityPathBase;
19+
import org.springframework.data.aot.sample.ConfigWithQuerydslPredicateExecutor.Person;
20+
21+
public class QConfigWithQuerydslPredicateExecutor_Person extends EntityPathBase<Person> {
22+
23+
public QConfigWithQuerydslPredicateExecutor_Person(Class type, String variable) {
24+
super(type, variable);
25+
}
26+
}

‎src/test/java/org/springframework/data/repository/aot/RepositoryRegistrationAotProcessorIntegrationTests.java

+17
Original file line numberDiff line numberDiff line change
@@ -34,9 +34,12 @@
3434
import org.springframework.data.aot.sample.ConfigWithFragments;
3535
import org.springframework.data.aot.sample.ConfigWithQueryMethods;
3636
import org.springframework.data.aot.sample.ConfigWithQueryMethods.ProjectionInterface;
37+
import org.springframework.data.aot.sample.ConfigWithQuerydslPredicateExecutor;
38+
import org.springframework.data.aot.sample.ConfigWithQuerydslPredicateExecutor.Person;
3739
import org.springframework.data.aot.sample.ConfigWithSimpleCrudRepository;
3840
import org.springframework.data.aot.sample.ConfigWithTransactionManagerPresent;
3941
import org.springframework.data.aot.sample.ConfigWithTransactionManagerPresentAndAtComponentAnnotatedRepository;
42+
import org.springframework.data.aot.sample.QConfigWithQuerydslPredicateExecutor_Person;
4043
import org.springframework.data.aot.sample.ReactiveConfig;
4144
import org.springframework.data.domain.Page;
4245
import org.springframework.data.repository.PagingAndSortingRepository;
@@ -275,6 +278,20 @@ void doesNotCareAboutNonDataAnnotations() {
275278
});
276279
}
277280

281+
@Test // GH-2721
282+
void registersQTypeIfPresent() {
283+
284+
RepositoryRegistrationAotContribution repositoryBeanContribution = computeAotConfiguration(
285+
ConfigWithQuerydslPredicateExecutor.class).forRepository(ConfigWithQuerydslPredicateExecutor.MyRepo.class);
286+
287+
assertThatContribution(repositoryBeanContribution) //
288+
.codeContributionSatisfies(contribution -> {
289+
contribution.contributesReflectionFor(Person.class);
290+
contribution.contributesReflectionFor(
291+
QConfigWithQuerydslPredicateExecutor_Person.class);
292+
});
293+
}
294+
278295
RepositoryRegistrationAotContributionBuilder computeAotConfiguration(Class<?> configuration) {
279296
return computeAotConfiguration(configuration, new AnnotationConfigApplicationContext());
280297
}

‎src/test/java/org/springframework/data/util/QTypeContributorUnitTests.java

+71
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,71 @@
1+
/*
2+
* Copyright 2022 the original author or authors.
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License");
5+
* you may not use this file except in compliance with the License.
6+
* You may obtain a copy of the License at
7+
*
8+
* https://www.apache.org/licenses/LICENSE-2.0
9+
*
10+
* Unless required by applicable law or agreed to in writing, software
11+
* distributed under the License is distributed on an "AS IS" BASIS,
12+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
* See the License for the specific language governing permissions and
14+
* limitations under the License.
15+
*/
16+
package org.springframework.data.util;
17+
18+
import static org.assertj.core.api.Assertions.*;
19+
20+
import org.junit.jupiter.api.Test;
21+
import org.springframework.aot.generate.ClassNameGenerator;
22+
import org.springframework.aot.generate.DefaultGenerationContext;
23+
import org.springframework.aot.generate.GenerationContext;
24+
import org.springframework.aot.generate.InMemoryGeneratedFiles;
25+
import org.springframework.aot.hint.predicate.RuntimeHintsPredicates;
26+
import org.springframework.data.aot.sample.ConfigWithQuerydslPredicateExecutor.Person;
27+
import org.springframework.data.aot.sample.QConfigWithQuerydslPredicateExecutor_Person;
28+
import org.springframework.data.classloadersupport.HidingClassLoader;
29+
import org.springframework.javapoet.ClassName;
30+
31+
import com.querydsl.core.types.EntityPath;
32+
33+
class QTypeContributorUnitTests {
34+
35+
@Test // GH-2721
36+
void addsQTypeHintIfPresent() {
37+
38+
GenerationContext generationContext = new DefaultGenerationContext(
39+
new ClassNameGenerator(ClassName.get(this.getClass())), new InMemoryGeneratedFiles());
40+
41+
QTypeContributor.contributeEntityPath(Person.class, generationContext, null);
42+
43+
assertThat(generationContext.getRuntimeHints())
44+
.matches(RuntimeHintsPredicates.reflection().onType(QConfigWithQuerydslPredicateExecutor_Person.class));
45+
}
46+
47+
@Test // GH-2721
48+
void doesNotAddQTypeHintIfTypeNotPresent() {
49+
50+
GenerationContext generationContext = new DefaultGenerationContext(
51+
new ClassNameGenerator(ClassName.get(this.getClass())), new InMemoryGeneratedFiles());
52+
53+
QTypeContributor.contributeEntityPath(Person.class, generationContext,
54+
HidingClassLoader.hideTypes(QConfigWithQuerydslPredicateExecutor_Person.class));
55+
56+
assertThat(generationContext.getRuntimeHints()).matches(
57+
RuntimeHintsPredicates.reflection().onType(QConfigWithQuerydslPredicateExecutor_Person.class).negate());
58+
}
59+
60+
@Test // GH-2721
61+
void doesNotAddQTypeHintIfQuerydslNotPresent() {
62+
63+
GenerationContext generationContext = new DefaultGenerationContext(
64+
new ClassNameGenerator(ClassName.get(this.getClass())), new InMemoryGeneratedFiles());
65+
66+
QTypeContributor.contributeEntityPath(Person.class, generationContext, HidingClassLoader.hide(EntityPath.class));
67+
68+
assertThat(generationContext.getRuntimeHints()).matches(
69+
RuntimeHintsPredicates.reflection().onType(QConfigWithQuerydslPredicateExecutor_Person.class).negate());
70+
}
71+
}

0 commit comments

Comments
 (0)