Skip to content

Commit a839690

Browse files
matiasahmp911de
matiasah
authored and
mp911de
committed
DATACMNS-1785 - Add ReactiveQuerydslPredicateArgumentResolver and ReactiveQuerydslWebConfiguration.
We now provide ReactiveQuerydslPredicateArgumentResolver to resolve Querydsl Predicates when using Spring WebFlux. Related ticket: #2200. Original pull request: #2274.
1 parent a8b5f43 commit a839690

4 files changed

+314
-93
lines changed

‎src/main/java/org/springframework/data/web/config/ReactiveQuerydslWebConfiguration.java

+78
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,78 @@
1+
/*
2+
* Copyright 2015-2021 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.web.config;
17+
18+
import java.util.Optional;
19+
20+
import org.springframework.beans.factory.BeanFactory;
21+
import org.springframework.beans.factory.ObjectFactory;
22+
import org.springframework.beans.factory.ObjectProvider;
23+
import org.springframework.beans.factory.annotation.Autowired;
24+
import org.springframework.beans.factory.annotation.Qualifier;
25+
import org.springframework.context.annotation.Bean;
26+
import org.springframework.context.annotation.Configuration;
27+
import org.springframework.context.annotation.Lazy;
28+
import org.springframework.core.convert.ConversionService;
29+
import org.springframework.data.querydsl.EntityPathResolver;
30+
import org.springframework.data.querydsl.SimpleEntityPathResolver;
31+
import org.springframework.data.querydsl.binding.QuerydslBindingsFactory;
32+
import org.springframework.data.web.querydsl.ReactiveQuerydslPredicateArgumentResolver;
33+
import org.springframework.web.reactive.config.WebFluxConfigurer;
34+
import org.springframework.web.reactive.result.method.annotation.ArgumentResolverConfigurer;
35+
36+
/**
37+
* Querydsl-specific web configuration for Spring Data. Registers a {@link HandlerMethodArgumentResolver} that builds up
38+
* {@link Predicate}s from web requests.
39+
*
40+
* @author Matías Hermosilla
41+
* @since 1.11
42+
* @soundtrack Anika Nilles - Alter Ego
43+
*/
44+
@Configuration(proxyBeanMethods = false)
45+
public class ReactiveQuerydslWebConfiguration implements WebFluxConfigurer {
46+
47+
@Autowired
48+
@Qualifier("webFluxConversionService") ObjectFactory<ConversionService> conversionService;
49+
@Autowired ObjectProvider<EntityPathResolver> resolver;
50+
@Autowired BeanFactory beanFactory;
51+
52+
/**
53+
* Default {@link ReactiveQuerydslPredicateArgumentResolver} to create Querydsl {@link Predicate} instances for
54+
* Spring WebFlux controller methods.
55+
*
56+
* @return
57+
*/
58+
@Lazy
59+
@Bean
60+
public ReactiveQuerydslPredicateArgumentResolver querydslPredicateArgumentResolver() {
61+
return new ReactiveQuerydslPredicateArgumentResolver(
62+
beanFactory.getBean("querydslBindingsFactory", QuerydslBindingsFactory.class),
63+
Optional.of(conversionService.getObject()));
64+
}
65+
66+
@Lazy
67+
@Bean
68+
public QuerydslBindingsFactory querydslBindingsFactory() {
69+
return new QuerydslBindingsFactory(resolver.getIfUnique(() -> SimpleEntityPathResolver.INSTANCE));
70+
}
71+
72+
@Override
73+
public void configureArgumentResolvers(ArgumentResolverConfigurer configurer) {
74+
configurer.addCustomResolver(beanFactory.getBean("querydslPredicateArgumentResolver",
75+
ReactiveQuerydslPredicateArgumentResolver.class));
76+
}
77+
78+
}

‎src/main/java/org/springframework/data/web/querydsl/QuerydslPredicateArgumentResolver.java

+4-93
Original file line numberDiff line numberDiff line change
@@ -15,22 +15,18 @@
1515
*/
1616
package org.springframework.data.web.querydsl;
1717

18-
import java.lang.reflect.Method;
1918
import java.util.Arrays;
2019
import java.util.Map.Entry;
2120
import java.util.Optional;
2221

2322
import org.springframework.core.MethodParameter;
2423
import org.springframework.core.ResolvableType;
2524
import org.springframework.core.convert.ConversionService;
26-
import org.springframework.core.convert.support.DefaultConversionService;
2725
import org.springframework.data.querydsl.binding.QuerydslBinderCustomizer;
2826
import org.springframework.data.querydsl.binding.QuerydslBindings;
2927
import org.springframework.data.querydsl.binding.QuerydslBindingsFactory;
3028
import org.springframework.data.querydsl.binding.QuerydslPredicate;
31-
import org.springframework.data.querydsl.binding.QuerydslPredicateBuilder;
3229
import org.springframework.data.util.CastUtils;
33-
import org.springframework.data.util.ClassTypeInformation;
3430
import org.springframework.data.util.TypeInformation;
3531
import org.springframework.lang.Nullable;
3632
import org.springframework.util.LinkedMultiValueMap;
@@ -49,50 +45,15 @@
4945
*
5046
* @author Christoph Strobl
5147
* @author Oliver Gierke
48+
* @author Matías Hermosilla
5249
* @since 1.11
5350
*/
54-
public class QuerydslPredicateArgumentResolver implements HandlerMethodArgumentResolver {
51+
public class QuerydslPredicateArgumentResolver extends QuerydslPredicateArgumentResolverSupport
52+
implements HandlerMethodArgumentResolver {
5553

56-
private static final ResolvableType PREDICATE = ResolvableType.forClass(Predicate.class);
57-
private static final ResolvableType OPTIONAL_OF_PREDICATE = ResolvableType.forClassWithGenerics(Optional.class,
58-
PREDICATE);
59-
60-
private final QuerydslBindingsFactory bindingsFactory;
61-
private final QuerydslPredicateBuilder predicateBuilder;
62-
63-
/**
64-
* Creates a new {@link QuerydslPredicateArgumentResolver} using the given {@link ConversionService}.
65-
*
66-
* @param factory
67-
* @param conversionService defaults to {@link DefaultConversionService} if {@literal null}.
68-
*/
6954
public QuerydslPredicateArgumentResolver(QuerydslBindingsFactory factory,
7055
Optional<ConversionService> conversionService) {
71-
72-
this.bindingsFactory = factory;
73-
this.predicateBuilder = new QuerydslPredicateBuilder(conversionService.orElseGet(DefaultConversionService::new),
74-
factory.getEntityPathResolver());
75-
}
76-
77-
/*
78-
* (non-Javadoc)
79-
* @see org.springframework.web.method.support.HandlerMethodArgumentResolver#supportsParameter(org.springframework.core.MethodParameter)
80-
*/
81-
@Override
82-
public boolean supportsParameter(MethodParameter parameter) {
83-
84-
ResolvableType type = ResolvableType.forMethodParameter(parameter);
85-
86-
if (PREDICATE.isAssignableFrom(type) || OPTIONAL_OF_PREDICATE.isAssignableFrom(type)) {
87-
return true;
88-
}
89-
90-
if (parameter.hasParameterAnnotation(QuerydslPredicate.class)) {
91-
throw new IllegalArgumentException(String.format("Parameter at position %s must be of type Predicate but was %s.",
92-
parameter.getParameterIndex(), parameter.getParameterType()));
93-
}
94-
95-
return false;
56+
super(factory, conversionService);
9657
}
9758

9859
/*
@@ -133,54 +94,4 @@ public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewC
13394
: result;
13495
}
13596

136-
/**
137-
* Obtains the domain type information from the given method parameter. Will favor an explicitly registered on through
138-
* {@link QuerydslPredicate#root()} but use the actual type of the method's return type as fallback.
139-
*
140-
* @param parameter must not be {@literal null}.
141-
* @return
142-
*/
143-
static TypeInformation<?> extractTypeInfo(MethodParameter parameter) {
144-
145-
Optional<QuerydslPredicate> annotation = Optional
146-
.ofNullable(parameter.getParameterAnnotation(QuerydslPredicate.class));
147-
148-
return annotation.filter(it -> !Object.class.equals(it.root()))//
149-
.<TypeInformation<?>> map(it -> ClassTypeInformation.from(it.root()))//
150-
.orElseGet(() -> detectDomainType(parameter));
151-
}
152-
153-
private static TypeInformation<?> detectDomainType(MethodParameter parameter) {
154-
155-
Method method = parameter.getMethod();
156-
157-
if (method == null) {
158-
throw new IllegalArgumentException("Method parameter is not backed by a method!");
159-
}
160-
161-
return detectDomainType(ClassTypeInformation.fromReturnTypeOf(method));
162-
}
163-
164-
private static TypeInformation<?> detectDomainType(TypeInformation<?> source) {
165-
166-
if (source.getTypeArguments().isEmpty()) {
167-
return source;
168-
}
169-
170-
TypeInformation<?> actualType = source.getActualType();
171-
172-
if (actualType == null) {
173-
throw new IllegalArgumentException(String.format("Could not determine domain type from %s!", source));
174-
}
175-
176-
if (source != actualType) {
177-
return detectDomainType(actualType);
178-
}
179-
180-
if (source instanceof Iterable) {
181-
return source;
182-
}
183-
184-
return detectDomainType(source.getRequiredComponentType());
185-
}
18697
}

‎src/main/java/org/springframework/data/web/querydsl/QuerydslPredicateArgumentResolverSupport.java

+138
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,138 @@
1+
/*
2+
* Copyright 2015-2021 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.web.querydsl;
17+
18+
import java.lang.reflect.Method;
19+
import java.util.Optional;
20+
21+
import org.springframework.core.MethodParameter;
22+
import org.springframework.core.ResolvableType;
23+
import org.springframework.core.convert.ConversionService;
24+
import org.springframework.core.convert.support.DefaultConversionService;
25+
import org.springframework.data.querydsl.binding.QuerydslBindingsFactory;
26+
import org.springframework.data.querydsl.binding.QuerydslPredicate;
27+
import org.springframework.data.querydsl.binding.QuerydslPredicateBuilder;
28+
import org.springframework.data.util.ClassTypeInformation;
29+
import org.springframework.data.util.TypeInformation;
30+
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
31+
32+
import com.querydsl.core.types.Predicate;
33+
34+
/**
35+
* {@link HandlerMethodArgumentResolver} to allow injection of {@link com.querydsl.core.types.Predicate} into Spring MVC
36+
* controller methods.
37+
*
38+
* @author Christoph Strobl
39+
* @author Oliver Gierke
40+
* @author Matías Hermosilla
41+
* @since 1.11
42+
*/
43+
public abstract class QuerydslPredicateArgumentResolverSupport {
44+
45+
private static final ResolvableType PREDICATE = ResolvableType.forClass(Predicate.class);
46+
protected static final ResolvableType OPTIONAL_OF_PREDICATE = ResolvableType.forClassWithGenerics(Optional.class,
47+
PREDICATE);
48+
49+
protected final QuerydslBindingsFactory bindingsFactory;
50+
protected final QuerydslPredicateBuilder predicateBuilder;
51+
52+
/**
53+
* Creates a new {@link QuerydslPredicateArgumentResolver} using the given {@link ConversionService}.
54+
*
55+
* @param factory
56+
* @param conversionService defaults to {@link DefaultConversionService} if {@literal null}.
57+
*/
58+
public QuerydslPredicateArgumentResolverSupport(QuerydslBindingsFactory factory,
59+
Optional<ConversionService> conversionService) {
60+
61+
this.bindingsFactory = factory;
62+
this.predicateBuilder = new QuerydslPredicateBuilder(conversionService.orElseGet(DefaultConversionService::new),
63+
factory.getEntityPathResolver());
64+
}
65+
66+
/*
67+
* (non-Javadoc)
68+
* @see org.springframework.web.method.support.HandlerMethodArgumentResolver#supportsParameter(org.springframework.core.MethodParameter)
69+
*/
70+
public boolean supportsParameter(MethodParameter parameter) {
71+
72+
ResolvableType type = ResolvableType.forMethodParameter(parameter);
73+
74+
if (PREDICATE.isAssignableFrom(type) || OPTIONAL_OF_PREDICATE.isAssignableFrom(type)) {
75+
return true;
76+
}
77+
78+
if (parameter.hasParameterAnnotation(QuerydslPredicate.class)) {
79+
throw new IllegalArgumentException(
80+
String.format("Parameter at position %s must be of type Predicate but was %s.",
81+
parameter.getParameterIndex(), parameter.getParameterType()));
82+
}
83+
84+
return false;
85+
}
86+
87+
/**
88+
* Obtains the domain type information from the given method parameter. Will favor an explicitly registered on
89+
* through {@link QuerydslPredicate#root()} but use the actual type of the method's return type as fallback.
90+
*
91+
* @param parameter must not be {@literal null}.
92+
* @return
93+
*/
94+
protected static TypeInformation<?> extractTypeInfo(MethodParameter parameter) {
95+
96+
Optional<QuerydslPredicate> annotation = Optional
97+
.ofNullable(parameter.getParameterAnnotation(QuerydslPredicate.class));
98+
99+
return annotation.filter(it -> !Object.class.equals(it.root()))//
100+
.<TypeInformation<?>> map(it -> ClassTypeInformation.from(it.root()))//
101+
.orElseGet(() -> detectDomainType(parameter));
102+
}
103+
104+
private static TypeInformation<?> detectDomainType(MethodParameter parameter) {
105+
106+
Method method = parameter.getMethod();
107+
108+
if (method == null) {
109+
throw new IllegalArgumentException("Method parameter is not backed by a method!");
110+
}
111+
112+
return detectDomainType(ClassTypeInformation.fromReturnTypeOf(method));
113+
}
114+
115+
private static TypeInformation<?> detectDomainType(TypeInformation<?> source) {
116+
117+
if (source.getTypeArguments().isEmpty()) {
118+
return source;
119+
}
120+
121+
TypeInformation<?> actualType = source.getActualType();
122+
123+
if (actualType == null) {
124+
throw new IllegalArgumentException(String.format("Could not determine domain type from %s!", source));
125+
}
126+
127+
if (source != actualType) {
128+
return detectDomainType(actualType);
129+
}
130+
131+
if (source instanceof Iterable) {
132+
return source;
133+
}
134+
135+
return detectDomainType(source.getRequiredComponentType());
136+
}
137+
138+
}

0 commit comments

Comments
 (0)