java.lang.reflect.AccessibleObject#isAccessible ( )源码实例Demo

@Override
protected boolean tryToMakeAccessible(Object accessibleObject)
{
    if (!(accessibleObject instanceof AccessibleObject)) {
        return false;
    }
    AccessibleObject accessible = (AccessibleObject)accessibleObject;
    if (accessible.isAccessible()) {
        return true;
    }
    try {
        accessible.setAccessible(true);
    } catch (Exception ex) { }

    return accessible.isAccessible();
}
 

/**
 * XXX Default access superclass workaround.
 *
 * When a {@code public} class has a default access superclass with {@code 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 {@code public}.
 * Calling {@code 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
 * @return a boolean indicating whether the accessibility of the object was set to true.
 */
static boolean setAccessibleWorkaround(final AccessibleObject o) {
    if (o == null || o.isAccessible()) {
        return false;
    }
    final Member m = (Member) o;
    if (!o.isAccessible() && Modifier.isPublic(m.getModifiers()) && isPackageAccess(m.getDeclaringClass().getModifiers())) {
        try {
            o.setAccessible(true);
            return true;
        } catch (final SecurityException e) { // NOPMD
            // ignore in favor of subsequent IllegalAccessException
        }
    }
    return false;
}
 

@Override
protected boolean tryToMakeAccessible(Object accessibleObject)
{
    if (!(accessibleObject instanceof AccessibleObject)) {
        return false;
    }
    AccessibleObject accessible = (AccessibleObject)accessibleObject;
    if (accessible.isAccessible()) {
        return true;
    }
    try {
        accessible.setAccessible(true);
    } catch (Exception ex) { }

    return accessible.isAccessible();
}
 

private static Object readValue(final AnnotatedMember member, final Object object) {
    if (object == null) {
        return null;
    }
    final Object res;
    final AccessibleObject accessor = (AccessibleObject) member.getMember();
    // case: private field
    if (!accessor.isAccessible()) {
        accessor.setAccessible(true);
        try {
            res = member.getValue(object);
        } finally {
            accessor.setAccessible(false);
        }
    } else {
        // public access (most likely getter)
        res = member.getValue(object);
    }
    return res;
}
 

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.FALSE;
            accessible.setAccessible(true);
        }
    }
    return result;
}
 

@SuppressWarnings("rawtypes")
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.FALSE;
			accessible.setAccessible(true);
		}
	}
	return result;
}
 

/**
 * XXX Default access superclass workaround
 * <p>
 * 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
        }
    }
}
 

/**
 * 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(final AccessibleObject o) {
    if (o == null || o.isAccessible()) {
        return;
    }
    final Member m = (Member) o;
    if (Modifier.isPublic(m.getModifiers())
            && isPackageAccess(m.getDeclaringClass().getModifiers())) {
        try {
            o.setAccessible(true);
        } catch (final SecurityException e) { // NOPMD
            // ignore in favor of subsequent IllegalAccessException
        }
    }
}
 

/**
 * XXX Default access superclass workaround
 * <p>
 * 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
        }
    }
}
 

public static void ensureAccessibility(AccessibleObject accessibleObject) {
	if ( accessibleObject.isAccessible() ) {
		return;
	}

	accessibleObject.setAccessible( true );
}
 

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

static boolean setAccessibleWorkaround(final AccessibleObject o) {
    if (o == null || o.isAccessible()) {
        return false;
    }
    final Member m = (Member) o;
    if (!o.isAccessible() && Modifier.isPublic(m.getModifiers()) && isPackageAccess(m.getDeclaringClass().getModifiers())) {
        try {
            o.setAccessible(true);
            return true;
        } catch (final SecurityException e) { // NOPMD
            // ignore in favor of subsequent IllegalAccessException
        }
    }
    return false;
}
 

/**
 * 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) to prevent access even when the modifer 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(final AccessibleObject o) {
    if (o == null || o.isAccessible()) {
        return;
    }
    Member m = (Member) o;
    if (Modifier.isPublic(m.getModifiers()) && MemberUtils.isPackageAccess(m.getDeclaringClass().getModifiers())) {
        try {
            o.setAccessible(true);
        } catch (SecurityException e) {
            // ignore in favor of subsequent IllegalAccessException
        }
    }
}
 

/**
 * Makes sure that the AccessibleObject is accessible before the function
 * gets invoked and resets the accessibility after invocation.
 *
 * @param ao
 *            the accessible object
 * @param fn
 *            the function to invoke
 * @return the return value of the passed function
 */
static <T> T run(AccessibleObject ao, Supplier<T> fn) {
	boolean origAccessibility = true;
	try {
		origAccessibility = ao.isAccessible();
		if (!origAccessibility) {
			ao.setAccessible(true);
		}
		return fn.get();
	} finally {
		if (!origAccessibility) {
			ao.setAccessible(origAccessibility);
		}
	}
}
 

/**
 * 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) to prevent access even when the modifer 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) {
            // ignore in favor of subsequent IllegalAccessException
        }
    }
}
 

public static void makeAccessible(final AccessibleObject obj) {
  if (obj != null && !obj.isAccessible()) {
    AccessController.doPrivileged(new PrivilegedAction() {
      public Object run() {
        obj.setAccessible(true);
        return null;
      }
    });
  }
}
 

@SuppressWarnings("deprecation")
private boolean isAccessible(AccessibleObject accessibleObject) {
    return accessibleObject.isAccessible();
}
 

/**
 * changes the accessibleObject accessibility and returns true if accessibility was changed
 */
public void enableAccess(AccessibleObject accessibleObject) {
    wasAccessible = accessibleObject.isAccessible();
    accessibleObject.setAccessible(true);
}
 

private static void setAccessible(AccessibleObject accessible) {
	if (!accessible.isAccessible()) {
		AccessController.doPrivileged(new SetAccessibleAction(accessible));
	}
}
 

public static void setAccessible(final AccessibleObject obj, final boolean accessible) {
   if (obj.isAccessible() == accessible)
      return;

   AccessController.doPrivileged(new SetAccessibleAction(obj, accessible));
}