Example usage for org.springframework.util ReflectionUtils makeAccessible

List of usage examples for org.springframework.util ReflectionUtils makeAccessible

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.util.*
  5. ReflectionUtils
  6. makeAccessible

Introduction

In this page you can find the example usage for org.springframework.util ReflectionUtils makeAccessible.

Prototype

@SuppressWarnings("deprecation") 
public static void makeAccessible(Field field)

Source Link

Document

Make the given field accessible, explicitly setting it accessible if necessary.

Usage

From source file:org.springframework.test.util.ReflectionTestUtils.java

/**
 * Set the {@linkplain Field field} with the given {@code name}/{@code type}
 * on the provided {@code targetObject}/{@code targetClass} to the supplied
 * {@code value}.//from   w  w w  . j a  v a  2 s.  c o  m
 * <p>If the supplied {@code targetObject} is a <em>proxy</em>, it will
 * be {@linkplain AopTestUtils#getUltimateTargetObject unwrapped} allowing
 * the field to be set on the ultimate target of the proxy.
 * <p>This method traverses the class hierarchy in search of the desired
 * field. In addition, an attempt will be made to make non-{@code public}
 * fields <em>accessible</em>, thus allowing one to set {@code protected},
 * {@code private}, and <em>package-private</em> fields.
 * @param targetObject the target object on which to set the field; may be
 * {@code null} if the field is static
 * @param targetClass the target class on which to set the field; may
 * be {@code null} if the field is an instance field
 * @param name the name of the field to set; may be {@code null} if
 * {@code type} is specified
 * @param value the value to set
 * @param type the type of the field to set; may be {@code null} if
 * {@code name} is specified
 * @since 4.2
 * @see ReflectionUtils#findField(Class, String, Class)
 * @see ReflectionUtils#makeAccessible(Field)
 * @see ReflectionUtils#setField(Field, Object, Object)
 * @see AopTestUtils#getUltimateTargetObject(Object)
 */
public static void setField(@Nullable Object targetObject, @Nullable Class<?> targetClass,
        @Nullable String name, @Nullable Object value, @Nullable Class<?> type) {

    Assert.isTrue(targetObject != null || targetClass != null,
            "Either targetObject or targetClass for the field must be specified");

    if (targetObject != null && springAopPresent) {
        targetObject = AopTestUtils.getUltimateTargetObject(targetObject);
    }
    if (targetClass == null) {
        targetClass = targetObject.getClass();
    }

    Field field = ReflectionUtils.findField(targetClass, name, type);
    if (field == null) {
        throw new IllegalArgumentException(
                String.format("Could not find field '%s' of type [%s] on %s or target class [%s]", name, type,
                        safeToString(targetObject), targetClass));
    }

    if (logger.isDebugEnabled()) {
        logger.debug(String.format("Setting field '%s' of type [%s] on %s or target class [%s] to value [%s]",
                name, type, safeToString(targetObject), targetClass, value));
    }
    ReflectionUtils.makeAccessible(field);
    ReflectionUtils.setField(field, targetObject, value);
}

From source file:org.springframework.test.util.ReflectionTestUtils.java

/**
 * Get the value of the {@linkplain Field field} with the given {@code name}
 * from the provided {@code targetObject}/{@code targetClass}.
 * <p>If the supplied {@code targetObject} is a <em>proxy</em>, it will
 * be {@linkplain AopTestUtils#getUltimateTargetObject unwrapped} allowing
 * the field to be retrieved from the ultimate target of the proxy.
 * <p>This method traverses the class hierarchy in search of the desired
 * field. In addition, an attempt will be made to make non-{@code public}
 * fields <em>accessible</em>, thus allowing one to get {@code protected},
 * {@code private}, and <em>package-private</em> fields.
 * @param targetObject the target object from which to get the field; may be
 * {@code null} if the field is static//from   ww w .  java  2  s  .c  om
 * @param targetClass the target class from which to get the field; may
 * be {@code null} if the field is an instance field
 * @param name the name of the field to get; never {@code null}
 * @return the field's current value
 * @since 4.2
 * @see #getField(Object, String)
 * @see #getField(Class, String)
 * @see ReflectionUtils#findField(Class, String, Class)
 * @see ReflectionUtils#makeAccessible(Field)
 * @see ReflectionUtils#getField(Field, Object)
 * @see AopTestUtils#getUltimateTargetObject(Object)
 */
@Nullable
public static Object getField(@Nullable Object targetObject, @Nullable Class<?> targetClass, String name) {
    Assert.isTrue(targetObject != null || targetClass != null,
            "Either targetObject or targetClass for the field must be specified");

    if (targetObject != null && springAopPresent) {
        targetObject = AopTestUtils.getUltimateTargetObject(targetObject);
    }
    if (targetClass == null) {
        targetClass = targetObject.getClass();
    }

    Field field = ReflectionUtils.findField(targetClass, name);
    if (field == null) {
        throw new IllegalArgumentException(String.format("Could not find field '%s' on %s or target class [%s]",
                name, safeToString(targetObject), targetClass));
    }

    if (logger.isDebugEnabled()) {
        logger.debug(String.format("Getting field '%s' from %s or target class [%s]", name,
                safeToString(targetObject), targetClass));
    }
    ReflectionUtils.makeAccessible(field);
    return ReflectionUtils.getField(field, targetObject);
}

From source file:org.springframework.test.util.ReflectionTestUtils.java

/**
 * Invoke the setter method with the given {@code name} on the supplied
 * target object with the supplied {@code value}.
 * <p>This method traverses the class hierarchy in search of the desired
 * method. In addition, an attempt will be made to make non-{@code public}
 * methods <em>accessible</em>, thus allowing one to invoke {@code protected},
 * {@code private}, and <em>package-private</em> setter methods.
 * <p>In addition, this method supports JavaBean-style <em>property</em>
 * names. For example, if you wish to set the {@code name} property on the
 * target object, you may pass either &quot;name&quot; or
 * &quot;setName&quot; as the method name.
 * @param target the target object on which to invoke the specified setter
 * method// w w  w.  j av a 2s. com
 * @param name the name of the setter method to invoke or the corresponding
 * property name
 * @param value the value to provide to the setter method
 * @param type the formal parameter type declared by the setter method
 * @see ReflectionUtils#findMethod(Class, String, Class[])
 * @see ReflectionUtils#makeAccessible(Method)
 * @see ReflectionUtils#invokeMethod(Method, Object, Object[])
 */
public static void invokeSetterMethod(Object target, String name, @Nullable Object value,
        @Nullable Class<?> type) {
    Assert.notNull(target, "Target object must not be null");
    Assert.hasText(name, "Method name must not be empty");
    Class<?>[] paramTypes = (type != null ? new Class<?>[] { type } : null);

    String setterMethodName = name;
    if (!name.startsWith(SETTER_PREFIX)) {
        setterMethodName = SETTER_PREFIX + StringUtils.capitalize(name);
    }

    Method method = ReflectionUtils.findMethod(target.getClass(), setterMethodName, paramTypes);
    if (method == null && !setterMethodName.equals(name)) {
        setterMethodName = name;
        method = ReflectionUtils.findMethod(target.getClass(), setterMethodName, paramTypes);
    }
    if (method == null) {
        throw new IllegalArgumentException(
                String.format("Could not find setter method '%s' on %s with parameter type [%s]",
                        setterMethodName, safeToString(target), type));
    }

    if (logger.isDebugEnabled()) {
        logger.debug(String.format("Invoking setter method '%s' on %s with value [%s]", setterMethodName,
                safeToString(target), value));
    }

    ReflectionUtils.makeAccessible(method);
    ReflectionUtils.invokeMethod(method, target, value);
}

From source file:org.springframework.test.util.ReflectionTestUtils.java

/**
 * Invoke the getter method with the given {@code name} on the supplied
 * target object with the supplied {@code value}.
 * <p>This method traverses the class hierarchy in search of the desired
 * method. In addition, an attempt will be made to make non-{@code public}
 * methods <em>accessible</em>, thus allowing one to invoke {@code protected},
 * {@code private}, and <em>package-private</em> getter methods.
 * <p>In addition, this method supports JavaBean-style <em>property</em>
 * names. For example, if you wish to get the {@code name} property on the
 * target object, you may pass either &quot;name&quot; or
 * &quot;getName&quot; as the method name.
 * @param target the target object on which to invoke the specified getter
 * method//  ww w  .jav  a2s  .  c  om
 * @param name the name of the getter method to invoke or the corresponding
 * property name
 * @return the value returned from the invocation
 * @see ReflectionUtils#findMethod(Class, String, Class[])
 * @see ReflectionUtils#makeAccessible(Method)
 * @see ReflectionUtils#invokeMethod(Method, Object, Object[])
 */
@Nullable
public static Object invokeGetterMethod(Object target, String name) {
    Assert.notNull(target, "Target object must not be null");
    Assert.hasText(name, "Method name must not be empty");

    String getterMethodName = name;
    if (!name.startsWith(GETTER_PREFIX)) {
        getterMethodName = GETTER_PREFIX + StringUtils.capitalize(name);
    }
    Method method = ReflectionUtils.findMethod(target.getClass(), getterMethodName);
    if (method == null && !getterMethodName.equals(name)) {
        getterMethodName = name;
        method = ReflectionUtils.findMethod(target.getClass(), getterMethodName);
    }
    if (method == null) {
        throw new IllegalArgumentException(String.format("Could not find getter method '%s' on %s",
                getterMethodName, safeToString(target)));
    }

    if (logger.isDebugEnabled()) {
        logger.debug(
                String.format("Invoking getter method '%s' on %s", getterMethodName, safeToString(target)));
    }
    ReflectionUtils.makeAccessible(method);
    return ReflectionUtils.invokeMethod(method, target);
}

From source file:org.springframework.web.bind.annotation.support.HandlerMethodInvoker.java

public final Object invokeHandlerMethod(Method handlerMethod, Object handler, NativeWebRequest webRequest,
        ExtendedModelMap implicitModel) throws Exception {

    Method handlerMethodToInvoke = BridgeMethodResolver.findBridgedMethod(handlerMethod);
    try {/*from w  w w .j a  v  a2 s .  c om*/
        boolean debug = logger.isDebugEnabled();
        for (String attrName : this.methodResolver.getActualSessionAttributeNames()) {
            Object attrValue = this.sessionAttributeStore.retrieveAttribute(webRequest, attrName);
            if (attrValue != null) {
                implicitModel.addAttribute(attrName, attrValue);
            }
        }
        for (Method attributeMethod : this.methodResolver.getModelAttributeMethods()) {
            Method attributeMethodToInvoke = BridgeMethodResolver.findBridgedMethod(attributeMethod);
            Object[] args = resolveHandlerArguments(attributeMethodToInvoke, handler, webRequest,
                    implicitModel);
            if (debug) {
                logger.debug("Invoking model attribute method: " + attributeMethodToInvoke);
            }
            String attrName = AnnotationUtils.findAnnotation(attributeMethod, ModelAttribute.class).value();
            if (!"".equals(attrName) && implicitModel.containsAttribute(attrName)) {
                continue;
            }
            ReflectionUtils.makeAccessible(attributeMethodToInvoke);
            Object attrValue = attributeMethodToInvoke.invoke(handler, args);
            if ("".equals(attrName)) {
                Class<?> resolvedType = GenericTypeResolver.resolveReturnType(attributeMethodToInvoke,
                        handler.getClass());
                attrName = Conventions.getVariableNameForReturnType(attributeMethodToInvoke, resolvedType,
                        attrValue);
            }
            if (!implicitModel.containsAttribute(attrName)) {
                implicitModel.addAttribute(attrName, attrValue);
            }
        }
        Object[] args = resolveHandlerArguments(handlerMethodToInvoke, handler, webRequest, implicitModel);
        if (debug) {
            logger.debug("Invoking request handler method: " + handlerMethodToInvoke);
        }
        ReflectionUtils.makeAccessible(handlerMethodToInvoke);
        return handlerMethodToInvoke.invoke(handler, args);
    } catch (IllegalStateException ex) {
        // Internal assertion failed (e.g. invalid signature):
        // throw exception with full handler method context...
        throw new HandlerMethodInvocationException(handlerMethodToInvoke, ex);
    } catch (InvocationTargetException ex) {
        // User-defined @ModelAttribute/@InitBinder/@RequestMapping method threw an exception...
        ReflectionUtils.rethrowException(ex.getTargetException());
        return null;
    }
}