Added convenience methods for invoking bean setters / getters in an inheritance chain including value conversion

Author: bbottema

src/main/java/org/bbottema/javareflection/BeanUtils.java

@@ -4,22 +4,22 @@
 import org.bbottema.javareflection.util.commonslang25.StringUtils;
 import org.bbottema.javareflection.model.FieldWrapper;
 import org.bbottema.javareflection.model.InvokableObject;
+import org.bbottema.javareflection.valueconverter.IncompatibleTypeException;
+import org.bbottema.javareflection.valueconverter.ValueConversionHelper;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
-import java.util.Arrays;
-import java.util.EnumSet;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 import java.util.regex.Pattern;
 
+import static java.util.EnumSet.allOf;
+import static java.util.EnumSet.of;
 import static java.util.regex.Pattern.compile;
+import static org.bbottema.javareflection.BeanUtils.BeanRestriction.YES_SETTER;
+import static org.bbottema.javareflection.BeanUtils.BeanRestriction.YES_GETTER;
 
 /**
  * A {@link Field} shorthand utility class used to collect fields from classes meeting Java Bean restrictions/requirements.
@@ -177,9 +177,9 @@ public static boolean methodIsBeanlike(Method method) {
 	 */
 	@SuppressWarnings("WeakerAccess")
 	@NotNull
-	public static Map<Class<?>, List<FieldWrapper>> collectFields(final Class<?> _class, final Class<?> boundaryMarker,
+	public static LinkedHashMap<Class<?>, List<FieldWrapper>> collectFields(final Class<?> _class, final Class<?> boundaryMarker,
 																  final EnumSet<Visibility> visibility, final EnumSet<BeanRestriction> beanRestrictions) {
-		final Map<Class<?>, List<FieldWrapper>> fields = new HashMap<>();
+		final LinkedHashMap<Class<?>, List<FieldWrapper>> fields = new LinkedHashMap<>();
 		final Field[] allFields = _class.getDeclaredFields();
 		final List<FieldWrapper> filteredFields = new LinkedList<>();
 		for (final Field field : allFields) {
@@ -261,4 +261,49 @@ static FieldWrapper resolveBeanProperty(final Field field, final EnumSet<BeanRes
 			return null;
 		}
 	}
+
+	/**
+	 * Calls the setters for the first field that matches given fieldName. Attempts to convert the value in case the type is incorrect.
+	 *
+	 * @return The actual value used in the bean setter.
+	 */
+	@SuppressWarnings("ConstantConditions")
+	static public Object invokeBeanSetter(Object o, String fieldName, Object value) {
+		for (List<FieldWrapper> fieldWrappers : collectFields(o.getClass(), Object.class, allOf(Visibility.class), of(YES_SETTER)).values()) {
+			for (FieldWrapper fieldWrapper : fieldWrappers) {
+				if (fieldWrapper.getField().getName().equals(fieldName) ) {
+					Object assignedValue = value;
+					try {
+						MethodUtils.invokeMethodSimple(fieldWrapper.getSetter(), o, value);
+					} catch (final IllegalArgumentException ie) {
+						try {
+							assignedValue = ValueConversionHelper.convert(value, fieldWrapper.getField().getType());
+						} catch (IncompatibleTypeException e) {
+							throw new RuntimeException(new NoSuchMethodException(e.getMessage()));
+						}
+						MethodUtils.invokeMethodSimple(fieldWrapper.getSetter(), o, assignedValue);
+					}
+					return assignedValue;
+				}
+			}
+		}
+		throw new RuntimeException(new NoSuchMethodException("Bean setter for " + fieldName));
+	}
+
+	/**
+	 * Calls the setters for the first field that matches given fieldName. Attempts to convert the value in case the type is incorrect.
+	 *
+	 * @return The actual value used in the bean setter.
+	 */
+	@SuppressWarnings("ConstantConditions")
+	static public Object invokeBeanGetter(Object o, String fieldName) {
+		for (List<FieldWrapper> fieldWrappers : collectFields(o.getClass(), Object.class, allOf(Visibility.class), of(YES_GETTER)).values()) {
+			for (FieldWrapper fieldWrapper : fieldWrappers) {
+				if (fieldWrapper.getField().getName().equals(fieldName) ) {
+					return MethodUtils.invokeMethodSimple(fieldWrapper.getGetter(), o);
+				}
+			}
+		}
+		throw new RuntimeException(new NoSuchMethodException("Bean getter for " + fieldName));
+	}
 }

src/main/java/org/bbottema/javareflection/MethodUtils.java

@@ -69,7 +69,21 @@
 public final class MethodUtils {
 
 	private static final Logger LOGGER = getLogger(MethodUtils.class);
-	
+
+    @Nullable
+    @SuppressWarnings({"unchecked"})
+    public static <T> T invokeMethodSimple(final Method method, final Object subject, final Object... args) {
+        try {
+            return (T) method.invoke(subject, args);
+        } catch (SecurityException e) {
+            throw new RuntimeException("unable to invoke method; security problem", e);
+        } catch (IllegalAccessException e) {
+            throw new RuntimeException("unable to access method", e);
+        } catch (InvocationTargetException e) {
+            throw new RuntimeException("unable to invoke method", e);
+        }
+    }
+
 	/**
      * Locates a method on an Object using serveral searchmodes for optimization. First of all a {@link Method} cache is being maintained to quickly
      * fetch heavily used methods. If not cached before and if a simple search (autoboxing and supertype casts) fails a more complex search is done

src/test/java/org/bbottema/javareflection/BeanUtilsTest.java

@@ -7,6 +7,7 @@
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
+import java.math.BigDecimal;
 import java.util.EnumSet;
 import java.util.List;
 import java.util.Map;
@@ -321,6 +322,79 @@ public void testResolveBeanPropertyExceptions()
 			// ok
 		}
 	}
+
+	@Test
+	public void testInvokeBeanSetter_SimpleSuccess() {
+		BeanFields subject = new BeanFields();
+
+		assertThat(BeanUtils.invokeBeanSetter(subject, "withSetter", 123)).isEqualTo(123);
+		assertThat(BeanUtils.invokeBeanSetter(subject, "withGetterAndSetter", true)).isEqualTo(true);
+		assertThat(BeanUtils.invokeBeanSetter(subject, "primitiveBoolean", true)).isEqualTo(true);
+
+		assertThat(subject.withSetter).isEqualTo(123);
+		assertThat(subject.getWithGetterAndSetter()).isEqualTo(true);
+		assertThat(subject.isPrimitiveBoolean()).isTrue();
+	}
+
+	@Test
+	public void testInvokeBeanSetter_WithConversionSuccess() {
+		BeanFields subject = new BeanFields();
+
+		assertThat(BeanUtils.invokeBeanSetter(subject, "primitiveBoolean", "true")).isEqualTo(true);
+		assertThat(subject.isPrimitiveBoolean()).isTrue();
+		assertThat(BeanUtils.invokeBeanSetter(subject, "primitiveBoolean", "false")).isEqualTo(false);
+		assertThat(subject.isPrimitiveBoolean()).isFalse();
+	}
+
+	@Test
+	public void testInvokeBeanSetter_NoSetterForField() {
+		BeanFields subject = new BeanFields();
+
+		try {
+			BeanUtils.invokeBeanSetter(subject, "withGetter", 123);
+			fail("expected exception");
+		} catch (RuntimeException e) {
+			assertThat(e.getCause()).isInstanceOf(NoSuchMethodException.class);
+			assertThat(e.getCause().getMessage()).isEqualTo("Bean setter for withGetter");
+		}
+	}
+
+	@Test
+	public void testInvokeBeanSetter_NoSetterForFieldWithCorrectType() {
+		BeanFields subject = new BeanFields();
+
+		try {
+			BeanUtils.invokeBeanSetter(subject, "primitiveBoolean", new Thread());
+			fail("expected exception");
+		} catch (RuntimeException e) {
+			assertThat(e.getCause()).isInstanceOf(NoSuchMethodException.class);
+			assertThat(e.getCause().getMessage()).contains("error: unable to convert value");
+		}
+	}
+
+	@Test
+	public void testInvokeBeanGetter_SimpleSuccess() {
+		BeanFields subject = new BeanFields();
+		subject.setWithGetterAndSetter(true);
+		subject.setPrimitiveBoolean(true);
+
+		assertThat(BeanUtils.invokeBeanGetter(subject, "withGetterAndSetter")).isEqualTo(true);
+		assertThat(BeanUtils.invokeBeanGetter(subject, "primitiveBoolean")).isEqualTo(true);
+	}
+
+	@Test
+	public void testInvokeBeanGetter_NoGetterForField() {
+		BeanFields subject = new BeanFields();
+		subject.setWithSetter(true);
+
+		try {
+			BeanUtils.invokeBeanGetter(subject, "withSetter");
+			fail("expected exception");
+		} catch (RuntimeException e) {
+			assertThat(e.getCause()).isInstanceOf(NoSuchMethodException.class);
+			assertThat(e.getCause().getMessage()).contains("Bean getter for withSetter");
+		}
+	}
 
 	@SuppressWarnings("unused")
 	private static class BeanFields {