Generate random data, depends on Spring ReflectionUtils

public class RandomDataFactory {

    private static final String UNGENERATED_VALUE_MARKER = "UNGENERATED_VALUE_MARKER";

    private static void randomlyPopulateFields(Object object) {
        new RandomValueFieldPopulator().populate(object);
    }

    /**
     * Instantiates a single object with random data
     */
    public static <T> T getSingle(Class<T> clazz) throws IllegalAccessException, InstantiationException {
        T object = clazz.newInstance();
        randomlyPopulateFields(object);
        return object;
    }

    /**
     * Returns an unmodifiable list of specified type objects with random data
     *
     * @param clazz     the myPojo.class to be instantiated with random data
     * @param maxLength the length of list to be returned
     */
    public static <T> List<T> getList(Class<T> clazz, int maxLength) throws IllegalAccessException, InstantiationException {
        List<T> list = new ArrayList<T>(maxLength);
        for (int i = 0; i < maxLength; i++) {
            T object = clazz.newInstance();
            randomlyPopulateFields(object);
            list.add(i, object);
        }
        return Collections.unmodifiableList(list);
    }

    /**
     * Returns a unmodifiable list of specified type T objects with random data
     * <p>List length will be 3</p>
     *
     * @param clazz the myPojo.class to be instantiated with random data
     */
    public static <T> List<T> getList(Class<T> clazz) throws InstantiationException, IllegalAccessException {
        return getList(clazz, 3);
    }

    public static <T> T getPrimitive(Class<T> clazz) {
        return (T) RandomValueFieldPopulator.generateRandomValue(clazz);
    }

    public static <T> List<T> getPrimitiveList(Class<T> clazz) {
        return getPrimitiveList(clazz, 3);
    }

    public static <T> List<T> getPrimitiveList(Class<T> clazz, int length) {
        List<T> randoms = new ArrayList<T>(length);
        for (int i = 0; i < length; i++) {
            randoms.add(getPrimitive(clazz));
        }
        return randoms;
    }

    private static class RandomValueFieldPopulator {
        public static Object generateRandomValue(Class<?> fieldType) {
            Random random = new Random();
              if (fieldType.equals(String.class)) {
                return UUID.randomUUID().toString();
            } else if (Date.class.isAssignableFrom(fieldType)) {
                return new Date(System.currentTimeMillis() - random.nextInt());
            } else if (LocalDate.class.isAssignableFrom(fieldType)) {
                Date date = new Date(System.currentTimeMillis() - random.nextInt());
                return new LocalDate(date);
            } else if (fieldType.equals(Character.class) || fieldType.equals(Character.TYPE)) {
                return (char) (random.nextInt(26) + 'a');
            } else if (fieldType.equals(Integer.TYPE) || fieldType.equals(Integer.class)) {
                return random.nextInt();
            } else if (fieldType.equals(Short.TYPE) || fieldType.equals(Short.class)) {
                return (short) random.nextInt();
            } else if (fieldType.equals(Long.TYPE) || fieldType.equals(Long.class)) {
                return random.nextLong();
            } else if (fieldType.equals(Float.TYPE) || fieldType.equals(Float.class)) {
                return random.nextFloat();
            } else if (fieldType.equals(Double.TYPE)) {
                return random.nextInt(); //if double is used, jsonPath uses bigdecimal to convert back
            } else if (fieldType.equals(Double.class)) {
                return random.nextDouble(); //if double is used, jsonPath uses bigdecimal to convert back
            } else if (fieldType.equals(Boolean.TYPE) || fieldType.equals(Boolean.class)) {
                return random.nextBoolean();
            } else if (fieldType.equals(BigDecimal.class)) {
                return new BigDecimal(random.nextFloat());
            } else if (Enum.class.isAssignableFrom(fieldType)) {
                Object[] enumValues = fieldType.getEnumConstants();
                return enumValues[random.nextInt(enumValues.length)];
            } else if (Number.class.isAssignableFrom(fieldType)) {
                return random.nextInt(Byte.MAX_VALUE) + 1;
            } else {
                return UNGENERATED_VALUE_MARKER;
            }

        public void populate(Object object) {
            ReflectionUtils.doWithFields(object.getClass(), new RandomValueFieldSetterCallback(object));
        }

        private static class RandomValueFieldSetterCallback implements ReflectionUtils.FieldCallback {
            private final Object targetObject;

            public RandomValueFieldSetterCallback(Object targetObject) {
                this.targetObject = targetObject;
            }

            @Override
            public void doWith(Field field) throws IllegalAccessException {
                Class<?> fieldType = field.getType();
                if (!Modifier.isFinal(field.getModifiers())) {
                    Object value = generateRandomValue(fieldType);
                    if (!value.equals(UNGENERATED_VALUE_MARKER)) {
                        ReflectionUtils.makeAccessible(field);
                        field.set(targetObject, value);
                    }
                }
            }
        }
    }
}