Java Code Examples for java.lang.reflect.AccessibleObject#setAccessible()

/**
 * <p>
 * Appends the fields and values defined by the given object of the given Class.
 * </p>
 * 
 * <p>
 * If a cycle is detected as an object is &quot;toString()'ed&quot;, such an object is rendered as if
 * <code>Object.toString()</code> had been called and not implemented by the object.
 * </p>
 * 
 * @param clazz
 *            The class of object parameter
 */
protected void appendFieldsIn(Class<?> clazz) {
    if (clazz.isArray()) {
        this.reflectionAppendArray(this.getObject());
        return;
    }
    Field[] fields = clazz.getDeclaredFields();
    AccessibleObject.setAccessible(fields, true);
    for (Field field : fields) {
        String fieldName = field.getName();
        if (this.accept(field)) {
            try {
                // Warning: Field.get(Object) creates wrappers objects
                // for primitive types.
                Object fieldValue = this.getValue(field);
                this.append(fieldName, fieldValue);
            } catch (IllegalAccessException ex) {
                //this can't happen. Would get a Security exception
                // instead
                //throw a runtime exception in case the impossible
                // happens.
                throw new InternalError("Unexpected IllegalAccessException: " + ex.getMessage());
            }
        }
    }
}
 

/**
 * Enable sharing of the class-loader with 3rd party.
 *
 * @return the class-loader user be the helper.
 */
public ClassLoader getClassLoader() {
    // To follow the same behavior of Class.forName(...) I had to play
    // dirty (Supported by Sun, IBM & BEA JVMs)
    try {
        // Get a reference to this class' class-loader
        ClassLoader cl = this.getClass().getClassLoader();
        // Create a method instance representing the protected
        // getCallerClassLoader method of class ClassLoader
        Method mthd = ClassLoader.class.getDeclaredMethod(
                "getCallerClassLoader", new Class<?>[0]);
        // Make the method accessible.
        AccessibleObject.setAccessible(new AccessibleObject[] {mthd}, true);
        // Try to get the caller's class-loader
        return (ClassLoader)mthd.invoke(cl, new Object[0]);
    } catch (Throwable all) {
        // Use this class' class-loader
        return this.getClass().getClassLoader();
    }
}
 

public static AccessibleObject[] makeAccessible(final AccessibleObject[] aoa) {
    try {
        AccessibleObject.setAccessible(aoa, true);
        return aoa;
    } catch (Throwable outer) {
        // swallow for strict security managers, module systems, android or others,
        // but try one-by-one to get the allowed ones at least
        final List<AccessibleObject> ret = new ArrayList<>(aoa.length);
        for (final AccessibleObject ao : aoa) {
            boolean accessible = trySetAccessible(ao);
            if (accessible) {
                ret.add(ao);
            }
        }
        return ret.toArray((AccessibleObject[]) Array.newInstance(aoa.getClass().getComponentType(), 0));
    }
}
 

/**
 * Enable sharing of the class-loader with 3rd party.
 *
 * @return the class-loader user be the helper.
 */
public ClassLoader getClassLoader() {
    // To follow the same behavior of Class.forName(...) I had to play
    // dirty (Supported by Sun, IBM & BEA JVMs)
    try {
        // Get a reference to this class' class-loader
        ClassLoader cl = this.getClass().getClassLoader();
        // Create a method instance representing the protected
        // getCallerClassLoader method of class ClassLoader
        Method mthd = ClassLoader.class.getDeclaredMethod(
                "getCallerClassLoader", new Class[0]);
        // Make the method accessible.
        AccessibleObject.setAccessible(new AccessibleObject[] {mthd}, true);
        // Try to get the caller's class-loader
        return (ClassLoader)mthd.invoke(cl, new Object[0]);
    } catch (Exception all) {
        // Use this class' class-loader
        return this.getClass().getClassLoader();
    }
}
 

private static void blankField(Class<?> enumClass, String fieldName) throws NoSuchFieldException,
        IllegalAccessException {
    for (Field field : Class.class.getDeclaredFields()) {
        if (field.getName().contains(fieldName)) {
            AccessibleObject.setAccessible(new Field[]{field}, true);
            setFailSafeFieldValue(field, enumClass, null);
            break;
        }
    }
}
 

/**
 * <p>
 * Appends the fields and values defined by the given object of the given <code>Class</code>.
 * </p>
 *
 * @param object
 *            the object to append details of
 * @param clazz
 *            the class to append details of
 * @param builder
 *            the builder to append to
 * @param useTransients
 *            whether to use transient fields
 * @param excludeFields
 *            Collection of String field names to exclude from use in calculation of hash code
 */
private static void reflectionAppend(Object object, Class<?> clazz, HashCodeBuilder builder, boolean useTransients,
        String[] excludeFields) {
    if (isRegistered(object)) {
        return;
    }
    try {
        register(object);
        Field[] fields = clazz.getDeclaredFields();
        AccessibleObject.setAccessible(fields, true);
        for (Field field : fields) {
            if (!ArrayUtils.contains(excludeFields, field.getName())
                && (field.getName().indexOf('$') == -1)
                && (useTransients || !Modifier.isTransient(field.getModifiers()))
                && (!Modifier.isStatic(field.getModifiers()))) {
                try {
                    Object fieldValue = field.get(object);
                    builder.append(fieldValue);
                } catch (IllegalAccessException e) {
                    // this can't happen. Would get a Security exception instead
                    // throw a runtime exception in case the impossible happens.
                    throw new InternalError("Unexpected IllegalAccessException");
                }
            }
        }
    } finally {
        unregister(object);
    }
}
 

/**
 * Set accessible
 * @param ao The object
 */
static void setAccessible(final AccessibleObject ao)
{
   if (System.getSecurityManager() == null)
      ao.setAccessible(true);

   AccessController.doPrivileged(new PrivilegedAction<Object>()
   {
      public Object run()
      {
         ao.setAccessible(true);
         return null;
      }
   });
}
 

/**
 * <p>
 * Appends the fields and values defined by the given object of the given <code>Class</code>.
 * </p>
 * 
 * @param object
 *            the object to append details of
 * @param clazz
 *            the class to append details of
 * @param builder
 *            the builder to append to
 * @param useTransients
 *            whether to use transient fields
 * @param excludeFields
 *            Collection of String field names to exclude from use in calculation of hash code
 */
private static void reflectionAppend(Object object, Class<?> clazz, HashCodeBuilder builder, boolean useTransients,
        String[] excludeFields) {
    if (isRegistered(object)) {
        return;
    }
    try {
        register(object);
        Field[] fields = clazz.getDeclaredFields();
        AccessibleObject.setAccessible(fields, true);
        for (Field field : fields) {
            if (!ArrayUtils.contains(excludeFields, field.getName())
                && (field.getName().indexOf('$') == -1)
                && (useTransients || !Modifier.isTransient(field.getModifiers()))
                && (!Modifier.isStatic(field.getModifiers()))) {
                try {
                    Object fieldValue = field.get(object);
                    builder.append(fieldValue);
                } catch (IllegalAccessException e) {
                    // this can't happen. Would get a Security exception instead
                    // throw a runtime exception in case the impossible happens.
                    throw new InternalError("Unexpected IllegalAccessException");
                }
            }
        }
    } finally {
        unregister(object);
    }
}
 

/**
 * <p>Appends to <code>builder</code> the comparison of <code>lhs</code>
 * to <code>rhs</code> using the fields defined in <code>clazz</code>.</p>
 * 
 * @param lhs  left-hand object
 * @param rhs  right-hand object
 * @param clazz  <code>Class</code> that defines fields to be compared
 * @param builder  <code>CompareToBuilder</code> to append to
 * @param useTransients  whether to compare transient fields
 * @param excludeFields  fields to exclude
 */
private static void reflectionAppend(
    Object lhs,
    Object rhs,
    Class<?> clazz,
    CompareToBuilder builder,
    boolean useTransients,
    String[] excludeFields) {
    
    Field[] fields = clazz.getDeclaredFields();
    AccessibleObject.setAccessible(fields, true);
    for (int i = 0; i < fields.length && builder.comparison == 0; i++) {
        Field f = fields[i];
        if (!ArrayUtils.contains(excludeFields, f.getName())
            && (f.getName().indexOf('$') == -1)
            && (useTransients || !Modifier.isTransient(f.getModifiers()))
            && (!Modifier.isStatic(f.getModifiers()))) {
            try {
                builder.append(f.get(lhs), f.get(rhs));
            } catch (IllegalAccessException e) {
                // This can't happen. Would get a Security exception instead.
                // Throw a runtime exception in case the impossible happens.
                throw new InternalError("Unexpected IllegalAccessException");
            }
        }
    }
}
 

public static void forceAccess(AccessibleObject object) {
    if (object == null || object.isAccessible()) {
        return;
    }
    try {
        object.setAccessible(true);
    } catch (SecurityException e) {
        throw ExceptionUtil.toRuntimeException(e);
    }
}
 

/**
 * XXX Default access superclass workaround
 *
 * When a public class has a default access superclass with public members,
 * these members are accessible. Calling them from compiled code works fine.
 * Unfortunately, on some JVMs, using reflection to invoke these members
 * seems to (wrongly) prevent access even when the modifier is public.
 * Calling setAccessible(true) solves the problem but will only work from
 * sufficiently privileged code. Better workarounds would be gratefully
 * accepted.
 * @param o the AccessibleObject to set as accessible
 */
static void setAccessibleWorkaround(AccessibleObject o) {
    if (o == null || o.isAccessible()) {
        return;
    }
    Member m = (Member) o;
    if (Modifier.isPublic(m.getModifiers())
            && isPackageAccess(m.getDeclaringClass().getModifiers())) {
        try {
            o.setAccessible(true);
        } catch (SecurityException e) { // NOPMD
            // ignore in favor of subsequent IllegalAccessException
        }
    }
}
 

/**
 * <p>Appends the fields and values defined by the given object of the
 * given Class.</p>
 * 
 * @param lhs  the left hand object
 * @param rhs  the right hand object
 * @param clazz  the class to append details of
 * @param builder  the builder to append to
 * @param useTransients  whether to test transient fields
 * @param excludeFields  array of field names to exclude from testing
 */
private static void reflectionAppend(
    Object lhs,
    Object rhs,
    Class clazz,
    EqualsBuilder builder,
    boolean useTransients,
    String[] excludeFields) {
    Field[] fields = clazz.getDeclaredFields();
    List excludedFieldList = excludeFields != null ? Arrays.asList(excludeFields) : Collections.EMPTY_LIST;
    AccessibleObject.setAccessible(fields, true);
    for (int i = 0; i < fields.length && builder.isEquals; i++) {
        Field f = fields[i];
        if (!excludedFieldList.contains(f.getName())
            && (f.getName().indexOf('$') == -1)
            && (useTransients || !Modifier.isTransient(f.getModifiers()))
            && (!Modifier.isStatic(f.getModifiers()))) {
            try {
                builder.append(f.get(lhs), f.get(rhs));
            } catch (IllegalAccessException e) {
                //this can't happen. Would get a Security exception instead
                //throw a runtime exception in case the impossible happens.
                throw new InternalError("Unexpected IllegalAccessException");
            }
        }
    }
}
 

@Override
public Object setup(Map context, Object target, Member member, String propertyName) {
    Object result = null;

    if (isAccessible(context, target, member, propertyName)) {
        AccessibleObject accessible = (AccessibleObject) member;

        if (!accessible.isAccessible()) {
            result = Boolean.TRUE;
            accessible.setAccessible(true);
        }
    }
    return result;
}
 

/**
 * <p>
 * Appends the fields and values defined by the given object of the given <code>Class</code>.
 * </p>
 * 
 * @param object
 *            the object to append details of
 * @param clazz
 *            the class to append details of
 * @param builder
 *            the builder to append to
 * @param useTransients
 *            whether to use transient fields
 * @param excludeFields
 *            Collection of String field names to exclude from use in calculation of hash code
 */
private static void reflectionAppend(Object object, Class clazz, HashCodeBuilder builder, boolean useTransients,
        String[] excludeFields) {
    if (isRegistered(object)) {
        return;
    }
    try {
        register(object);
        Field[] fields = clazz.getDeclaredFields();
        AccessibleObject.setAccessible(fields, true);
        for (int i = 0; i < fields.length; i++) {
            Field field = fields[i];
            if (!ArrayUtils.contains(excludeFields, field.getName())
                && (field.getName().indexOf('$') == -1)
                && (useTransients || !Modifier.isTransient(field.getModifiers()))
                && (!Modifier.isStatic(field.getModifiers()))) {
                try {
                    Object fieldValue = field.get(object);
                    builder.append(fieldValue);
                } catch (IllegalAccessException e) {
                    // this can't happen. Would get a Security exception instead
                    // throw a runtime exception in case the impossible happens.
                    throw new InternalError("Unexpected IllegalAccessException");
                }
            }
        }
    } finally {
        unregister(object);
    }
}
 

/**
 * <p>Appends to <code>builder</code> the comparison of <code>lhs</code>
 * to <code>rhs</code> using the fields defined in <code>clazz</code>.</p>
 * 
 * @param lhs  left-hand object
 * @param rhs  right-hand object
 * @param clazz  <code>Class</code> that defines fields to be compared
 * @param builder  <code>CompareToBuilder</code> to append to
 * @param useTransients  whether to compare transient fields
 * @param excludeFields  fields to exclude
 */
private static void reflectionAppend(
    Object lhs,
    Object rhs,
    Class<?> clazz,
    CompareToBuilder builder,
    boolean useTransients,
    String[] excludeFields) {
    
    Field[] fields = clazz.getDeclaredFields();
    AccessibleObject.setAccessible(fields, true);
    for (int i = 0; i < fields.length && builder.comparison == 0; i++) {
        Field f = fields[i];
        if (!ArrayUtils.contains(excludeFields, f.getName())
            && (f.getName().indexOf('$') == -1)
            && (useTransients || !Modifier.isTransient(f.getModifiers()))
            && (!Modifier.isStatic(f.getModifiers()))) {
            try {
                builder.append(f.get(lhs), f.get(rhs));
            } catch (IllegalAccessException e) {
                // This can't happen. Would get a Security exception instead.
                // Throw a runtime exception in case the impossible happens.
                throw new InternalError("Unexpected IllegalAccessException");
            }
        }
    }
}
 

private @Nullable
Invokable<C> findInvokable(final Class<?>... param_types) {
    if (mClass == ANY_TYPE)        // AnyType as a internal indicator for class not found.
        return mHasFallback ? new FallbackInvokable<C>(mFallbackReturnValue) : null;

    final int modifiers;
    Invokable<C> invokable;
    final AccessibleObject accessible;
    final Class<?>[] ex_types;
    try {
        if (mName != null) {
            final Method candidate = mClass.getDeclaredMethod(mName, param_types);
            Method method = candidate;
            ex_types = candidate.getExceptionTypes();
            modifiers = method.getModifiers();
            if (Modifier.isStatic(mModifiers) != Modifier.isStatic(candidate.getModifiers())) {
                fail(new AssertionException(candidate + (Modifier.isStatic(mModifiers) ? " is not static" : "is static")).setHackedMethod(method));
                method = null;
            }
            if (mReturnType != null && mReturnType != ANY_TYPE && !candidate.getReturnType().equals(mReturnType)) {
                fail(new AssertionException("Return type mismatch: " + candidate));
                method = null;
            }
            if (method != null) {
                invokable = new InvokableMethod<>(method);
                accessible = method;
            } else {
                invokable = null;
                accessible = null;
            }
        } else {
            final Constructor<C> ctor = mClass.getDeclaredConstructor(param_types);
            modifiers = ctor.getModifiers();
            invokable = new InvokableConstructor<>(ctor);
            accessible = ctor;
            ex_types = ctor.getExceptionTypes();
        }
    } catch (final NoSuchMethodException e) {
        fail(new AssertionException(e).setHackedClass(mClass).setHackedMethodName(mName).setParamTypes(param_types));
        return mHasFallback ? new FallbackInvokable<C>(mFallbackReturnValue) : null;
    }

    if (mModifiers > 0 && (modifiers & mModifiers) != mModifiers)
        fail(new AssertionException(invokable + " does not match modifiers: " + mModifiers).setHackedMethodName(mName));

    if (mThrowTypes == null && ex_types.length > 0 || mThrowTypes != null && ex_types.length == 0) {
        fail(new AssertionException("Checked exception(s) not match: " + invokable));
        if (ex_types.length > 0)
            invokable = null;        // No need to fall-back if expected checked exceptions are absent.
    } else if (mThrowTypes != null) {
        Arrays.sort(ex_types, CLASS_COMPARATOR);
        if (!Arrays.equals(ex_types, mThrowTypes)) {    // TODO: Check derived relation of exceptions
            fail(new AssertionException("Checked exception(s) not match: " + invokable));
            invokable = null;
        }
    }

    if (invokable == null) {
        if (!mHasFallback) return null;
        return new FallbackInvokable<>(mFallbackReturnValue);
    }

    if (!accessible.isAccessible()) accessible.setAccessible(true);
    return invokable;
}
 

public static void makeAccessible(AccessibleObject instance, boolean accessible) {
  Objects.requireNonNull(instance);
  instance.setAccessible(accessible);
}
 

public static <T extends Enum<?>> T addEnum(Class<T> enumType, String enumName, Class<?>[] additionalTypes, Object[] additionalValues) {

        // 0. Sanity checks
        if (!Enum.class.isAssignableFrom(enumType)) {
            throw new RuntimeException("class " + enumType + " is not an instance of Enum");
        }
        // 1. Lookup "$VALUES" holder in enum class and get previous enum instances
        Field valuesField = null;
        Field[] fields = enumType.getDeclaredFields();
        for (Field field : fields) {
            if (field.getName().contains("$VALUES")) {
                valuesField = field;
                break;
            }
        }
        AccessibleObject.setAccessible(new Field[]{valuesField}, true);

        try {

            // 2. Copy it
            T[] previousValues = (T[]) valuesField.get(enumType);
            List values = new ArrayList(Arrays.asList(previousValues));

            // 3. build new enum
            T newValue = (T) makeEnum(enumType, // The target enum class
                    enumName, // THE NEW ENUM INSTANCE TO BE DYNAMICALLY ADDED
                    values.size(),
                    additionalTypes, // can be used to pass values to the enum constuctor
                    additionalValues); // can be used to pass values to the enum constuctor

            // 4. add new value
            values.add(newValue);

            // 5. Set new values field
            setFailsafeFieldValue(valuesField, null,
                    values.toArray((T[]) Array.newInstance(enumType, 0)));

            // 6. Clean enum cache
            cleanEnumCache(enumType);
            return newValue;
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e.getMessage(), e);
        }
    }
 

/**
 * <p>
 * Appends the fields and values defined by the given object of the given Class.
 * </p>
 * 
 * <p>
 * If a cycle is detected as an object is &quot;toString()'ed&quot;, such an object is rendered as if
 * <code>Object.toString()</code> had been called and not implemented by the object.
 * </p>
 * 
 * @param clazz
 *            The class of object parameter
 */
protected void appendFieldsIn(Class clazz) {
    if (isRegistered(this.getObject())) {
        // The object has already been appended, therefore we have an
        // object cycle.
        // Append a simple Object.toString style string. The field name is
        // already appended at this point.
        this.appendAsObjectToString(this.getObject());
        return;
    }
    try {
        this.registerObject();
        if (clazz.isArray()) {
            this.reflectionAppendArray(this.getObject());
            return;
        }
        Field[] fields = clazz.getDeclaredFields();
        AccessibleObject.setAccessible(fields, true);
        for (int i = 0; i < fields.length; i++) {
            Field field = fields[i];
            String fieldName = field.getName();
            if (this.accept(field)) {
                try {
                    // Warning: Field.get(Object) creates wrappers objects
                    // for primitive types.
                    Object fieldValue = this.getValue(field);
                    if (isRegistered(fieldValue) && !field.getType().isPrimitive()) {
                        // A known field value has already been appended,
                        // therefore we have an object cycle,
                        // append a simple Object.toString style string.
                        this.getStyle().appendFieldStart(this.getStringBuffer(), fieldName);
                        this.appendAsObjectToString(fieldValue);
                        this.getStyle().appendFieldEnd(this.getStringBuffer(), fieldName);
                        // The recursion out of
                        // builder.append(fieldName, fieldValue);
                        // below will append the field
                        // end marker.
                    } else {
                        try {
                            this.registerObject();
                            this.append(fieldName, fieldValue);
                        } finally {
                            this.unregisterObject();
                        }
                    }
                } catch (IllegalAccessException ex) {
                    // this can't happen. Would get a Security exception
                    // instead
                    // throw a runtime exception in case the impossible
                    // happens.
                    throw new InternalError("Unexpected IllegalAccessException: " + ex.getMessage());
                }
            }
        }
    } finally {
        this.unregisterObject();
    }
}
 

/**
 * 获取类的所有实例<code>Method</code>，不包括<code>java.lang.Object</code>的 <code>Method</code>
 * <p>
 * 如果<code>clazz</code>为<code>null</code>，返回<code>null</code>
 * 
 * @param clazz 要获取的类
 * @param accessible 是否允许访问
 * @return <code>Method</code>数组
 */
public static Method[] getAllInstanceMethods(Class<?> clazz, boolean accessible) {
    Method[] methods = getAllInstanceMethods(clazz);
    if (ArrayUtil.isNotEmpty(methods)) {
        AccessibleObject.setAccessible(methods, accessible);
    }

    return methods;
}