Merge pull request #5803 from Grzegorz Poznachowski

* gh-5803:
  Apply standard Jackson2ObjectMapperBuilder config via a customizer
  Make it easier to customize auto-configured Jackson2ObjectMapperBuilder

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jackson/Jackson2ObjectMapperBuilderCustomizer.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2012-2016 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
+ *
+ *      http://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.boot.autoconfigure.jackson;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
+
+/**
+ * Callback interface that can be implemented by beans wishing to further customize the
+ * {@link ObjectMapper} via {@link Jackson2ObjectMapperBuilder} retaining its default
+ * auto-configuration.
+ *
+ * @author Grzegorz Poznachowski
+ * @since 1.4.0
+ */
+public interface Jackson2ObjectMapperBuilderCustomizer {
+
+	/**
+	 * Customize the jacksonObjectMapperBuilder.
+	 * @param jacksonObjectMapperBuilder the jacksonObjectMapperBuilder to customize
+	 */
+	void customize(Jackson2ObjectMapperBuilder jacksonObjectMapperBuilder);
+}

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jackson/JacksonAutoConfiguration.java

@@ -20,6 +20,7 @@ import java.lang.reflect.Field;
 import java.text.DateFormat;
 import java.text.SimpleDateFormat;
 import java.util.Collection;
+import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -51,6 +52,7 @@ import org.springframework.context.ApplicationContext;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Primary;
+import org.springframework.core.Ordered;
 import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
@@ -160,137 +162,189 @@ public class JacksonAutoConfiguration {
 
 	@Configuration
 	@ConditionalOnClass({ ObjectMapper.class, Jackson2ObjectMapperBuilder.class })
-	@EnableConfigurationProperties(JacksonProperties.class)
 	static class JacksonObjectMapperBuilderConfiguration {
 
 		private final ApplicationContext applicationContext;
 
-		private final JacksonProperties jacksonProperties;
-
 		JacksonObjectMapperBuilderConfiguration(ApplicationContext applicationContext,
-				JacksonProperties jacksonProperties) {
+				JacksonProperties jacksonProperties,
+				List<Jackson2ObjectMapperBuilderCustomizer> customizers) {
 			this.applicationContext = applicationContext;
-			this.jacksonProperties = jacksonProperties;
 		}
 
 		@Bean
 		@ConditionalOnMissingBean(Jackson2ObjectMapperBuilder.class)
-		public Jackson2ObjectMapperBuilder jacksonObjectMapperBuilder() {
+		public Jackson2ObjectMapperBuilder jacksonObjectMapperBuilder(
+				List<Jackson2ObjectMapperBuilderCustomizer> customizers) {
 			Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder();
 			builder.applicationContext(this.applicationContext);
-			if (this.jacksonProperties.getDefaultPropertyInclusion() != null) {
+			customize(builder, customizers);
-				builder.serializationInclusion(
-						this.jacksonProperties.getDefaultPropertyInclusion());
-			}
-			if (this.jacksonProperties.getTimeZone() != null) {
-				builder.timeZone(this.jacksonProperties.getTimeZone());
-			}
-			configureFeatures(builder, this.jacksonProperties.getDeserialization());
-			configureFeatures(builder, this.jacksonProperties.getSerialization());
-			configureFeatures(builder, this.jacksonProperties.getMapper());
-			configureFeatures(builder, this.jacksonProperties.getParser());
-			configureFeatures(builder, this.jacksonProperties.getGenerator());
-			configureDateFormat(builder);
-			configurePropertyNamingStrategy(builder);
-			configureModules(builder);
-			configureLocale(builder);
 			return builder;
 		}
 
-		private void configureFeatures(Jackson2ObjectMapperBuilder builder,
+		private void customize(Jackson2ObjectMapperBuilder builder,
-				Map<?, Boolean> features) {
+				List<Jackson2ObjectMapperBuilderCustomizer> customizers) {
-			for (Entry<?, Boolean> entry : features.entrySet()) {
+			for (Jackson2ObjectMapperBuilderCustomizer customizer : customizers) {
-				if (entry.getValue() != null && entry.getValue()) {
+				customizer.customize(builder);
-					builder.featuresToEnable(entry.getKey());
-				}
-				else {
-					builder.featuresToDisable(entry.getKey());
-				}
 			}
 		}
 
-		private void configureDateFormat(Jackson2ObjectMapperBuilder builder) {
+	}
-			// We support a fully qualified class name extending DateFormat or a date
+
-			// pattern string value
+	@Configuration
-			String dateFormat = this.jacksonProperties.getDateFormat();
+	@ConditionalOnClass({ ObjectMapper.class, Jackson2ObjectMapperBuilder.class })
-			if (dateFormat != null) {
+	@EnableConfigurationProperties(JacksonProperties.class)
-				try {
+	static class Jackson2ObjectMapperBuilderCustomizerConfiguration {
-					Class<?> dateFormatClass = ClassUtils.forName(dateFormat, null);
+
-					builder.dateFormat(
+		@Bean
-							(DateFormat) BeanUtils.instantiateClass(dateFormatClass));
+		public StandardJackson2ObjectMapperBuilderCustomizer standardJacksonObjectMapperBuilderCustomizer(
+				ApplicationContext applicationContext,
+				JacksonProperties jacksonProperties) {
+			return new StandardJackson2ObjectMapperBuilderCustomizer(applicationContext,
+					jacksonProperties);
+		}
+
+		private static final class StandardJackson2ObjectMapperBuilderCustomizer
+				implements Jackson2ObjectMapperBuilderCustomizer, Ordered {
+
+			private final ApplicationContext applicationContext;
+
+			private final JacksonProperties jacksonProperties;
+
+			StandardJackson2ObjectMapperBuilderCustomizer(
+					ApplicationContext applicationContext,
+					JacksonProperties jacksonProperties) {
+				this.applicationContext = applicationContext;
+				this.jacksonProperties = jacksonProperties;
+			}
+
+			@Override
+			public int getOrder() {
+				return 0;
+			}
+
+			@Override
+			public void customize(Jackson2ObjectMapperBuilder builder) {
+
+				if (this.jacksonProperties.getDefaultPropertyInclusion() != null) {
+					builder.serializationInclusion(
+							this.jacksonProperties.getDefaultPropertyInclusion());
 				}
-				catch (ClassNotFoundException ex) {
+				if (this.jacksonProperties.getTimeZone() != null) {
-					SimpleDateFormat simpleDateFormat = new SimpleDateFormat(dateFormat);
+					builder.timeZone(this.jacksonProperties.getTimeZone());
-					// Since Jackson 2.6.3 we always need to set a TimeZone (see gh-4170)
+				}
-					// If none in our properties fallback to the Jackson's default
+				configureFeatures(builder, this.jacksonProperties.getDeserialization());
-					TimeZone timeZone = this.jacksonProperties.getTimeZone();
+				configureFeatures(builder, this.jacksonProperties.getSerialization());
-					if (timeZone == null) {
+				configureFeatures(builder, this.jacksonProperties.getMapper());
-						timeZone = new ObjectMapper().getSerializationConfig()
+				configureFeatures(builder, this.jacksonProperties.getParser());
-								.getTimeZone();
+				configureFeatures(builder, this.jacksonProperties.getGenerator());
+				configureDateFormat(builder);
+				configurePropertyNamingStrategy(builder);
+				configureModules(builder);
+				configureLocale(builder);
+			}
+
+			private void configureFeatures(Jackson2ObjectMapperBuilder builder,
+					Map<?, Boolean> features) {
+				for (Entry<?, Boolean> entry : features.entrySet()) {
+					if (entry.getValue() != null && entry.getValue()) {
+						builder.featuresToEnable(entry.getKey());
+					}
+					else {
+						builder.featuresToDisable(entry.getKey());
 					}
-					simpleDateFormat.setTimeZone(timeZone);
-					builder.dateFormat(simpleDateFormat);
 				}
 			}
-		}
 
-		private void configurePropertyNamingStrategy(
+			private void configureDateFormat(Jackson2ObjectMapperBuilder builder) {
-				Jackson2ObjectMapperBuilder builder) {
+				// We support a fully qualified class name extending DateFormat or a date
-			// We support a fully qualified class name extending Jackson's
+				// pattern string value
-			// PropertyNamingStrategy or a string value corresponding to the constant
+				String dateFormat = this.jacksonProperties.getDateFormat();
-			// names in PropertyNamingStrategy which hold default provided implementations
+				if (dateFormat != null) {
-			String strategy = this.jacksonProperties.getPropertyNamingStrategy();
+					try {
-			if (strategy != null) {
+						Class<?> dateFormatClass = ClassUtils.forName(dateFormat, null);
-				try {
+						builder.dateFormat(
-					configurePropertyNamingStrategyClass(builder,
+								(DateFormat) BeanUtils.instantiateClass(dateFormatClass));
-							ClassUtils.forName(strategy, null));
+					}
+					catch (ClassNotFoundException ex) {
+						SimpleDateFormat simpleDateFormat = new SimpleDateFormat(
+								dateFormat);
+						// Since Jackson 2.6.3 we always need to set a TimeZone (see
+						// gh-4170). If none in our properties fallback to the Jackson's
+						// default
+						TimeZone timeZone = this.jacksonProperties.getTimeZone();
+						if (timeZone == null) {
+							timeZone = new ObjectMapper().getSerializationConfig()
+									.getTimeZone();
+						}
+						simpleDateFormat.setTimeZone(timeZone);
+						builder.dateFormat(simpleDateFormat);
+					}
 				}
-				catch (ClassNotFoundException ex) {
+			}
-					configurePropertyNamingStrategyField(builder, strategy);
+
+			private void configurePropertyNamingStrategy(
+					Jackson2ObjectMapperBuilder builder) {
+				// We support a fully qualified class name extending Jackson's
+				// PropertyNamingStrategy or a string value corresponding to the constant
+				// names in PropertyNamingStrategy which hold default provided
+				// implementations
+				String strategy = this.jacksonProperties.getPropertyNamingStrategy();
+				if (strategy != null) {
+					try {
+						configurePropertyNamingStrategyClass(builder,
+								ClassUtils.forName(strategy, null));
+					}
+					catch (ClassNotFoundException ex) {
+						configurePropertyNamingStrategyField(builder, strategy);
+					}
 				}
 			}
-		}
 
-		private void configurePropertyNamingStrategyClass(
+			private void configurePropertyNamingStrategyClass(
-				Jackson2ObjectMapperBuilder builder,
+					Jackson2ObjectMapperBuilder builder,
-				Class<?> propertyNamingStrategyClass) {
+					Class<?> propertyNamingStrategyClass) {
-			builder.propertyNamingStrategy((PropertyNamingStrategy) BeanUtils
+				builder.propertyNamingStrategy((PropertyNamingStrategy) BeanUtils
-					.instantiateClass(propertyNamingStrategyClass));
+						.instantiateClass(propertyNamingStrategyClass));
-		}
+			}
 
-		private void configurePropertyNamingStrategyField(
+			private void configurePropertyNamingStrategyField(
-				Jackson2ObjectMapperBuilder builder, String fieldName) {
+					Jackson2ObjectMapperBuilder builder, String fieldName) {
-			// Find the field (this way we automatically support new constants
+				// Find the field (this way we automatically support new constants
-			// that may be added by Jackson in the future)
+				// that may be added by Jackson in the future)
-			Field field = ReflectionUtils.findField(PropertyNamingStrategy.class,
+				Field field = ReflectionUtils.findField(PropertyNamingStrategy.class,
-					fieldName, PropertyNamingStrategy.class);
+						fieldName, PropertyNamingStrategy.class);
-			Assert.notNull(field, "Constant named '" + fieldName + "' not found on "
+				Assert.notNull(field, "Constant named '" + fieldName + "' not found on "
-					+ PropertyNamingStrategy.class.getName());
+						+ PropertyNamingStrategy.class.getName());
-			try {
+				try {
-				builder.propertyNamingStrategy((PropertyNamingStrategy) field.get(null));
+					builder.propertyNamingStrategy(
+							(PropertyNamingStrategy) field.get(null));
+				}
+				catch (Exception ex) {
+					throw new IllegalStateException(ex);
+				}
 			}
-			catch (Exception ex) {
+
-				throw new IllegalStateException(ex);
+			private void configureModules(Jackson2ObjectMapperBuilder builder) {
+				Collection<Module> moduleBeans = getBeans(this.applicationContext,
+						Module.class);
+				builder.modulesToInstall(
+						moduleBeans.toArray(new Module[moduleBeans.size()]));
 			}
-		}
 
-		private void configureModules(Jackson2ObjectMapperBuilder builder) {
+			private void configureLocale(Jackson2ObjectMapperBuilder builder) {
-			Collection<Module> moduleBeans = getBeans(this.applicationContext,
+				Locale locale = this.jacksonProperties.getLocale();
-					Module.class);
+				if (locale != null) {
-			builder.modulesToInstall(moduleBeans.toArray(new Module[moduleBeans.size()]));
+					builder.locale(locale);
-		}
+				}
+			}
 
-		private void configureLocale(Jackson2ObjectMapperBuilder builder) {
+			private static <T> Collection<T> getBeans(ListableBeanFactory beanFactory,
-			Locale locale = this.jacksonProperties.getLocale();
+					Class<T> type) {
-			if (locale != null) {
+				return BeanFactoryUtils.beansOfTypeIncludingAncestors(beanFactory, type)
-				builder.locale(locale);
+						.values();
 			}
-		}
 
-		private static <T> Collection<T> getBeans(ListableBeanFactory beanFactory,
-				Class<T> type) {
-			return BeanFactoryUtils.beansOfTypeIncludingAncestors(beanFactory, type)
-					.values();
 		}
 
 	}

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jackson/JacksonAutoConfigurationTests.java

@@ -72,6 +72,7 @@ import static org.mockito.Mockito.mock;
  * @author Marcel Overdijk
  * @author Sebastien Deleuze
  * @author Johannes Edmeier
+ * @author Grzegorz Poznachowski
  */
 public class JacksonAutoConfigurationTests {
 
@@ -419,6 +420,15 @@ public class JacksonAutoConfigurationTests {
 				.isEqualTo("\"Koordinierte Universalzeit\"");
 	}
 
+	@Test
+	public void additionalJacksonBuilderCustomization() throws Exception {
+		this.context.register(JacksonAutoConfiguration.class,
+				ObjectMapperBuilderCustomConfig.class);
+		this.context.refresh();
+		ObjectMapper mapper = this.context.getBean(ObjectMapper.class);
+		assertThat(mapper.getDateFormat()).isInstanceOf(MyDateFormat.class);
+	}
+
 	@Test
 	public void parameterNamesModuleIsAutoConfigured() {
 		assertParameterNamesModuleCreatorBinding(Mode.DEFAULT,
@@ -510,6 +520,22 @@ public class JacksonAutoConfigurationTests {
 
 	}
 
+	@Configuration
+	protected static class ObjectMapperBuilderCustomConfig {
+
+		@Bean
+		public Jackson2ObjectMapperBuilderCustomizer customDateFormat() {
+			return new Jackson2ObjectMapperBuilderCustomizer() {
+				@Override
+				public void customize(
+						Jackson2ObjectMapperBuilder jackson2ObjectMapperBuilder) {
+					jackson2ObjectMapperBuilder.dateFormat(new MyDateFormat());
+				}
+			};
+		}
+
+	}
+
 	protected static final class Foo {
 
 		private String name;