Introduce SimpleValueStyler for use with ToStringCreator

DefaultValueStyler hard codes conventions for styling that are verbose
and do not align well with standard toString() implementations in the
JDK for arrays, collections, and maps. Furthermore, the default styling
for classes and methods may not be suitable or desirable for certain
use cases.

To address these shortcomings, this commit introduces a
SimpleValueStyler for use with ToStringCreator. The default behavior of
SimpleValueStyler aligns with toString() implementations for arrays,
collections, and maps in the JDK, and styling for classes and methods
is configurable via a dedicated constructor.

Closes gh-29381

spring-core/src/main/java/org/springframework/core/style/SimpleValueStyler.java

@@ -0,0 +1,141 @@
+/*
+ * Copyright 2002-2022 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.core.style;
+
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Map;
+import java.util.StringJoiner;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * {@link ValueStyler} that converts objects to String form — generally for
+ * debugging purposes — using simple styling conventions that mimic the
+ * {@code toString()} styling conventions for standard JDK implementations of
+ * collections, maps, and arrays.
+ *
+ * <p>Uses the reflective visitor pattern underneath the hood to nicely
+ * encapsulate styling algorithms for each type of styled object.
+ *
+ * <p>Favor {@link SimpleValueStyler} over {@link DefaultValueStyler} when you
+ * wish to use styling similar to the JDK or when you need configurable control
+ * over the styling of classes and methods.
+ *
+ * @author Sam Brannen
+ * @since 6.0
+ */
+public class SimpleValueStyler extends DefaultValueStyler {
+
+	/**
+	 * Default {@link Class} styling function: {@link Class#getCanonicalName()}.
+	 */
+	public static final Function<Class<?>, String> DEFAULT_CLASS_STYLER = Class::getCanonicalName;
+
+	/**
+	 * Default {@link Method} styling function: converts the supplied {@link Method}
+	 * to a simple string representation of the method's signature in the form of
+	 * {@code <method name>(<parameter types>)}, where {@code <parameter types>}
+	 * is a comma-separated list of the {@linkplain Class#getSimpleName() simple names}
+	 * of the parameter types.
+	 * <p>For example, if the supplied method is a reference to
+	 * {@link String#getBytes(java.nio.charset.Charset)}, this function will
+	 * return {@code "getBytes(Charset)"}.
+	 */
+	public static final Function<Method, String> DEFAULT_METHOD_STYLER = SimpleValueStyler::toSimpleMethodSignature;
+
+
+	private final Function<Class<?>, String> classStyler;
+
+	private final Function<Method, String> methodStyler;
+
+
+	/**
+	 * Create a {@code SimpleValueStyler} using the {@link #DEFAULT_CLASS_STYLER}
+	 * and {@link #DEFAULT_METHOD_STYLER}.
+	 */
+	public SimpleValueStyler() {
+		this(DEFAULT_CLASS_STYLER, DEFAULT_METHOD_STYLER);
+	}
+
+	/**
+	 * Create a {@code SimpleValueStyler} using the supplied class and method stylers.
+	 * @param classStyler a function that applies styling to a {@link Class}
+	 * @param methodStyler a function that applies styling to a {@link Method}
+	 */
+	public SimpleValueStyler(Function<Class<?>, String> classStyler, Function<Method, String> methodStyler) {
+		this.classStyler = classStyler;
+		this.methodStyler = methodStyler;
+	}
+
+
+	@Override
+	protected String styleNull() {
+		return "null";
+	}
+
+	@Override
+	protected String styleString(String str) {
+		return "\"" + str + "\"";
+	}
+
+	@Override
+	protected String styleClass(Class<?> clazz) {
+		return this.classStyler.apply(clazz);
+	}
+
+	@Override
+	protected String styleMethod(Method method) {
+		return this.methodStyler.apply(method);
+	}
+
+	@Override
+	protected <K, V> String styleMap(Map<K, V> map) {
+		StringJoiner result = new StringJoiner(", ", "{", "}");
+		for (Map.Entry<K, V> entry : map.entrySet()) {
+			result.add(style(entry));
+		}
+		return result.toString();
+	}
+
+	@Override
+	protected String styleCollection(Collection<?> collection) {
+		StringJoiner result = new StringJoiner(", ", "[", "]");
+		for (Object element : collection) {
+			result.add(style(element));
+		}
+		return result.toString();
+	}
+
+	@Override
+	protected String styleArray(Object[] array) {
+		StringJoiner result = new StringJoiner(", ", "[", "]");
+		for (Object element : array) {
+			result.add(style(element));
+		}
+		return result.toString();
+	}
+
+	private static String toSimpleMethodSignature(Method method) {
+		String parameterList = Arrays.stream(method.getParameterTypes())
+				.map(Class::getSimpleName)
+				.collect(Collectors.joining(", "));
+		return String.format("%s(%s)", method.getName(), parameterList);
+	}
+
+}

spring-core/src/test/java/org/springframework/core/style/SimpleValueStylerTests.java

@@ -0,0 +1,197 @@
+/*
+ * Copyright 2002-2022 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.core.style;
+
+import java.lang.reflect.Method;
+import java.nio.charset.Charset;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Unit tests for {@link SimpleValueStyler}.
+ *
+ * @author Sam Brannen
+ * @since 6.0
+ */
+class SimpleValueStylerTests {
+
+	@Nested
+	class CommonStyling {
+
+		private final SimpleValueStyler styler = new SimpleValueStyler();
+
+		@Test
+		void styleBasics() throws NoSuchMethodException {
+			assertThat(styler.style(null)).isEqualTo("null");
+			assertThat(styler.style(true)).isEqualTo("true");
+			assertThat(styler.style(99.9)).isEqualTo("99.9");
+			assertThat(styler.style("str")).isEqualTo("\"str\"");
+		}
+
+		@Test
+		void stylePlainObject() {
+			Object obj = new Object();
+
+			assertThat(styler.style(obj)).isEqualTo(String.valueOf(obj));
+		}
+
+		@Test
+		void styleMaps() {
+			assertThat(styler.style(Map.of())).isEqualTo("{}");
+			assertThat(styler.style(Map.of("key", 1))).isEqualTo("{\"key\" -> 1}");
+
+			Map<String, Integer> map = new LinkedHashMap<>() {{
+				put("key1", 1);
+				put("key2", 2);
+			}};
+			assertThat(styler.style(map)).isEqualTo("{\"key1\" -> 1, \"key2\" -> 2}");
+		}
+
+		@Test
+		void styleMapEntries() {
+			Map<String, Integer> map = Map.of("key1", 1, "key2", 2);
+
+			assertThat(map.entrySet()).map(styler::style).containsExactlyInAnyOrder("\"key1\" -> 1", "\"key2\" -> 2");
+		}
+
+		@Test
+		void styleLists() {
+			assertThat(styler.style(List.of())).isEqualTo("[]");
+			assertThat(styler.style(List.of(1))).isEqualTo("[1]");
+			assertThat(styler.style(List.of(1, 2))).isEqualTo("[1, 2]");
+		}
+
+		@Test
+		void stylePrimitiveArrays() {
+			int[] array = new int[0];
+			assertThat(styler.style(array)).isEqualTo("[]");
+
+			array = new int[] { 1 };
+			assertThat(styler.style(array)).isEqualTo("[1]");
+
+			array = new int[] { 1, 2 };
+			assertThat(styler.style(array)).isEqualTo("[1, 2]");
+		}
+
+		@Test
+		void styleObjectArrays() {
+			String[] array = new String[0];
+			assertThat(styler.style(array)).isEqualTo("[]");
+
+			array = new String[] { "str1" };
+			assertThat(styler.style(array)).isEqualTo("[\"str1\"]");
+
+			array = new String[] { "str1", "str2" };
+			assertThat(styler.style(array)).isEqualTo("[\"str1\", \"str2\"]");
+		}
+
+	}
+
+	@Nested
+	class DefaultClassAndMethodStylers {
+
+		private final SimpleValueStyler styler = new SimpleValueStyler();
+
+		@Test
+		void styleClass() {
+			assertThat(styler.style(String.class)).isEqualTo("java.lang.String");
+			assertThat(styler.style(getClass())).isEqualTo(getClass().getCanonicalName());
+			assertThat(styler.style(String[].class)).isEqualTo("java.lang.String[]");
+			assertThat(styler.style(int[][].class)).isEqualTo("int[][]");
+		}
+
+		@Test
+		void styleMethod() throws NoSuchMethodException {
+			assertThat(styler.style(String.class.getMethod("toString"))).isEqualTo("toString()");
+			assertThat(styler.style(String.class.getMethod("getBytes", Charset.class))).isEqualTo("getBytes(Charset)");
+		}
+
+		@Test
+		void styleClassMap() {
+			Map<String, Class<?>> map = new LinkedHashMap<>() {{
+				put("key1", Integer.class);
+				put("key2", DefaultClassAndMethodStylers.class);
+			}};
+			assertThat(styler.style(map)).isEqualTo(
+					"{\"key1\" -> java.lang.Integer, \"key2\" -> %s}",
+					DefaultClassAndMethodStylers.class.getCanonicalName());
+		}
+
+		@Test
+		void styleClassList() {
+			assertThat(styler.style(List.of(Integer.class, String.class)))
+					.isEqualTo("[java.lang.Integer, java.lang.String]");
+		}
+
+		@Test
+		void styleClassArray() {
+			Class<?>[] array = new Class<?>[] { Integer.class, getClass() };
+			assertThat(styler.style(array))
+					.isEqualTo("[%s, %s]", Integer.class.getCanonicalName(), getClass().getCanonicalName());
+		}
+
+	}
+
+	@Nested
+	class CustomClassAndMethodStylers {
+
+		private final SimpleValueStyler styler = new SimpleValueStyler(Class::getSimpleName, Method::toGenericString);
+
+		@Test
+		void styleClass() {
+			assertThat(styler.style(String.class)).isEqualTo("String");
+			assertThat(styler.style(getClass())).isEqualTo(getClass().getSimpleName());
+			assertThat(styler.style(String[].class)).isEqualTo("String[]");
+			assertThat(styler.style(int[][].class)).isEqualTo("int[][]");
+		}
+
+		@Test
+		void styleMethod() throws NoSuchMethodException {
+			Method method = String.class.getMethod("toString");
+			assertThat(styler.style(method)).isEqualTo(method.toGenericString());
+		}
+
+		@Test
+		void styleClassMap() {
+			Map<String, Class<?>> map = new LinkedHashMap<>() {{
+				put("key1", Integer.class);
+				put("key2", CustomClassAndMethodStylers.class);
+			}};
+			assertThat(styler.style(map)).isEqualTo(
+					"{\"key1\" -> %s, \"key2\" -> %s}",
+					Integer.class.getSimpleName(), CustomClassAndMethodStylers.class.getSimpleName());
+		}
+		@Test
+		void styleClassList() {
+			assertThat(styler.style(List.of(Integer.class, String.class))).isEqualTo("[Integer, String]");
+		}
+
+		@Test
+		void styleClassArray() {
+			Class<?>[] array = new Class<?>[] { Integer.class, getClass() };
+			assertThat(styler.style(array)).isEqualTo("[%s, %s]", Integer.class.getSimpleName(), getClass().getSimpleName());
+		}
+
+	}
+
+}