/* 61: */ /* 62: */ public static Field getDeclaredField( Class cls, String fieldName, boolean forceAccess) /* 63: */ { /* 64:164 */ if (cls == null) { /* 65:165 */ throw new IllegalArgumentException("The class must not be null"); /* 66: */ } /* 67:167 */ if (fieldName == null) { /* 68:168 */ throw new IllegalArgumentException("The field name must not be null"); /* 69: */ } /* 70: */ try /* 71: */ { /* 72:172 */ Field field = cls.getDeclaredField(fieldName); /* 73:173 */ if (!MemberUtils.isAccessible(field)) { /* 74:174 */ if (forceAccess) { /* 75:175 */ field.setAccessible(true); /* 76: */ } else { /* 77:177 */ return null; /* 78: */ } /* 79: */ } /* 80:180 */ return field; /* 81: */ } /* 82: */ catch (NoSuchFieldException e) { } /* 83:183 */ return null; /* 84: */ }
/** * Return an accessible method (that is, one that can be invoked via reflection) that implements * the specified Method. If no such method can be found, return <code>null</code>. * * @param method The method that we wish to call * @return The accessible method */ public static Method getAccessibleMethod(Method method) { if (!MemberUtils.isAccessible(method)) { return null; } // If the declaring class is public, we are done Class cls = method.getDeclaringClass(); if (Modifier.isPublic(cls.getModifiers())) { return method; } String methodName = method.getName(); Class[] parameterTypes = method.getParameterTypes(); // Check the implemented interfaces and subinterfaces method = getAccessibleMethodFromInterfaceNest(cls, methodName, parameterTypes); // Check the superclass chain if (method == null) { method = getAccessibleMethodFromSuperclass(cls, methodName, parameterTypes); } return method; }
/** * Gets an accessible <code>Field</code> by name breaking scope if requested. Only the specified * class will be considered. * * @param cls the class to reflect, must not be null * @param fieldName the field name to obtain * @param forceAccess whether to break scope restrictions using the <code>setAccessible</code> * method. False will only match public fields. * @return the Field object * @throws IllegalArgumentException if the class or field name is null */ public static Field getDeclaredField(Class cls, String fieldName, boolean forceAccess) { if (cls == null) { throw new IllegalArgumentException("The class must not be null"); } if (fieldName == null) { throw new IllegalArgumentException("The field name must not be null"); } try { // only consider the specified class by using getDeclaredField() Field field = cls.getDeclaredField(fieldName); if (!MemberUtils.isAccessible(field)) { if (forceAccess) { field.setAccessible(true); } else { return null; } } return field; } catch (NoSuchFieldException e) { } return null; }
/** * Returns accessible version of the given constructor. * * @param ctor prototype constructor object. * @return <code>null</code> if accessible constructor can not be found. * @see java.lang.SecurityManager */ public static Constructor getAccessibleConstructor(Constructor ctor) { return MemberUtils.isAccessible(ctor) && Modifier.isPublic(ctor.getDeclaringClass().getModifiers()) ? ctor : null; }