1 /*
2  * Copyright 2013-2020 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.List;
19 import java.util.Optional;
20 import java.util.function.Supplier;
21
22 import org.springframework.beans.factory.BeanClassLoaderAware;
23 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
24 import org.springframework.beans.factory.ObjectFactory;
25 import org.springframework.beans.factory.annotation.Autowired;
26 import org.springframework.beans.factory.annotation.Qualifier;
27 import org.springframework.context.ApplicationContext;
28 import org.springframework.context.annotation.Bean;
29 import org.springframework.context.annotation.Configuration;
30 import org.springframework.core.convert.ConversionService;
31 import org.springframework.data.geo.format.DistanceFormatter;
32 import org.springframework.data.geo.format.PointFormatter;
33 import org.springframework.data.repository.support.DomainClassConverter;
34 import org.springframework.data.web.PageableHandlerMethodArgumentResolver;
35 import org.springframework.data.web.ProjectingJackson2HttpMessageConverter;
36 import org.springframework.data.web.ProxyingHandlerMethodArgumentResolver;
37 import org.springframework.data.web.SortHandlerMethodArgumentResolver;
38 import org.springframework.data.web.XmlBeamHttpMessageConverter;
39 import org.springframework.format.FormatterRegistry;
40 import org.springframework.format.support.FormattingConversionService;
41 import org.springframework.http.converter.HttpMessageConverter;
42 import org.springframework.lang.Nullable;
43 import org.springframework.util.Assert;
44 import org.springframework.util.ClassUtils;
45 import org.springframework.web.method.support.HandlerMethodArgumentResolver;
46 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
47
48 import com.fasterxml.jackson.databind.ObjectMapper;
49
50 /**
51  * Configuration class to register {@link PageableHandlerMethodArgumentResolver},
52  * {@link SortHandlerMethodArgumentResolver} and {@link DomainClassConverter}.
53  *
54  * @since 1.6
55  * @author Oliver Gierke
56  * @author Vedran Pavic
57  * @author Jens Schauder
58  */
59 @Configuration
60 public class SpringDataWebConfiguration implements WebMvcConfigurer, BeanClassLoaderAware {
61
62     private final ApplicationContext context;
63     private final ObjectFactory<ConversionService> conversionService;
64     private @Nullable ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();
65
66     private @Autowired Optional<PageableHandlerMethodArgumentResolverCustomizer> pageableResolverCustomizer;
67     private @Autowired Optional<SortHandlerMethodArgumentResolverCustomizer> sortResolverCustomizer;
68
69     public SpringDataWebConfiguration(ApplicationContext context,
70             @Qualifier("mvcConversionService") ObjectFactory<ConversionService> conversionService) {
71
72         Assert.notNull(context, "ApplicationContext must not be null!");
73         Assert.notNull(conversionService, "ConversionService must not be null!");
74
75         this.context = context;
76         this.conversionService = conversionService;
77     }
78
79     /*
80      * (non-Javadoc)
81      * @see org.springframework.beans.factory.BeanClassLoaderAware#setBeanClassLoader(java.lang.ClassLoader)
82      */
83     @Override
84     public void setBeanClassLoader(ClassLoader classLoader) {
85         this.beanClassLoader = classLoader;
86     }
87
88     /*
89      * (non-Javadoc)
90      * @see org.springframework.data.web.config.SpringDataWebConfiguration#pageableResolver()
91      */
92     @Bean
93     public PageableHandlerMethodArgumentResolver pageableResolver() {
94
95         PageableHandlerMethodArgumentResolver pageableResolver = //
96                 new PageableHandlerMethodArgumentResolver(sortResolver());
97         customizePageableResolver(pageableResolver);
98         return pageableResolver;
99     }
100
101     /*
102      * (non-Javadoc)
103      * @see org.springframework.data.web.config.SpringDataWebConfiguration#sortResolver()
104      */
105     @Bean
106     public SortHandlerMethodArgumentResolver sortResolver() {
107
108         SortHandlerMethodArgumentResolver sortResolver = new SortHandlerMethodArgumentResolver();
109         customizeSortResolver(sortResolver);
110         return sortResolver;
111     }
112
113     /*
114      * (non-Javadoc)
115      * @see org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter#addFormatters(org.springframework.format.FormatterRegistry)
116      */
117     @Override
118     public void addFormatters(FormatterRegistry registry) {
119
120         registry.addFormatter(DistanceFormatter.INSTANCE);
121         registry.addFormatter(PointFormatter.INSTANCE);
122
123         if (!(registry instanceof FormattingConversionService)) {
124             return;
125         }
126
127         FormattingConversionService conversionService = (FormattingConversionService) registry;
128
129         DomainClassConverter<FormattingConversionService> converter = new DomainClassConverter<>(conversionService);
130         converter.setApplicationContext(context);
131     }
132
133     /*
134      * (non-Javadoc)
135      * @see org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter#addArgumentResolvers(java.util.List)
136      */
137     @Override
138     public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
139
140         argumentResolvers.add(sortResolver());
141         argumentResolvers.add(pageableResolver());
142
143         ProxyingHandlerMethodArgumentResolver resolver = new ProxyingHandlerMethodArgumentResolver(conversionService, true);
144         resolver.setBeanFactory(context);
145         forwardBeanClassLoader(resolver);
146
147         argumentResolvers.add(resolver);
148     }
149
150     /*
151      * (non-Javadoc)
152      * @see org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter#extendMessageConverters(java.util.List)
153      */
154     @Override
155     public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
156
157         if (ClassUtils.isPresent("com.jayway.jsonpath.DocumentContext", context.getClassLoader())
158                 && ClassUtils.isPresent("com.fasterxml.jackson.databind.ObjectMapper", context.getClassLoader())) {
159
160             ObjectMapper mapper = getUniqueBean(ObjectMapper.class, context, ObjectMapper::new);
161
162             ProjectingJackson2HttpMessageConverter converter = new ProjectingJackson2HttpMessageConverter(mapper);
163             converter.setBeanFactory(context);
164             forwardBeanClassLoader(converter);
165
166             converters.add(0, converter);
167         }
168
169         if (ClassUtils.isPresent("org.xmlbeam.XBProjector", context.getClassLoader())) {
170
171             converters.add(0, context.getBeanProvider(XmlBeamHttpMessageConverter.class) //
172                     .getIfAvailable(() -> new XmlBeamHttpMessageConverter()));
173         }
174     }
175
176     protected void customizePageableResolver(PageableHandlerMethodArgumentResolver pageableResolver) {
177         pageableResolverCustomizer.ifPresent(c -> c.customize(pageableResolver));
178     }
179
180     protected void customizeSortResolver(SortHandlerMethodArgumentResolver sortResolver) {
181         sortResolverCustomizer.ifPresent(c -> c.customize(sortResolver));
182     }
183
184     private void forwardBeanClassLoader(BeanClassLoaderAware target) {
185
186         if (beanClassLoader != null) {
187             target.setBeanClassLoader(beanClassLoader);
188         }
189     }
190
191     /**
192      * Returns the uniquely available bean of the given type from the given {@link ApplicationContext} or the one provided
193      * by the given {@link Supplier} in case the initial lookup fails.
194      *
195      * @param type must not be {@literal null}.
196      * @param context must not be {@literal null}.
197      * @param fallback must not be {@literal null}.
198      * @return
199      */
200     private static <T> T getUniqueBean(Class<T> type, ApplicationContext context, Supplier<T> fallback) {
201
202         try {
203             return context.getBean(type);
204         } catch (NoSuchBeanDefinitionException o_O) {
205             return fallback.get();
206         }
207     }
208 }
209