/** * Gets an accessible <code>Field</code> by name breaking scope if requested. * Superclasses/interfaces 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. <code>False</code> will only match public fields. * @return the Field object * @throws IllegalArgumentException if the class or field name is null */ public static Field getField(final 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"); } // Sun Java 1.3 has a bugged implementation of getField hence we write the // code ourselves // getField() will return the Field object with the declaring class // set correctly to the class that declares the field. Thus requesting the // field on a subclass will return the field from the superclass. // // priority order for lookup: // searchclass private/protected/package/public // superclass protected/package/public // private/different package blocks access to further superclasses // implementedinterface public // check up the superclass hierarchy for (Class<?> acls = cls; acls != null; acls = acls.getSuperclass()) { try { Field field = acls.getDeclaredField(fieldName); // getDeclaredField checks for non-public scopes as well // and it returns accurate results if (!Modifier.isPublic(field.getModifiers())) { if (forceAccess) { field.setAccessible(true); } else { continue; } } return field; } catch (NoSuchFieldException ex) { // NOPMD // ignore } } // check the public interface case. This must be manually searched for // incase there is a public supersuperclass field hidden by a private/package // superclass field. Field match = null; for (Class<?> class1 : ClassUtils.getAllInterfaces(cls)) { try { Field test = ((Class<?>) class1).getField(fieldName); if (match != null) { throw new IllegalArgumentException( "Reference to field " + fieldName + " is ambiguous relative to " + cls + "; a matching field exists on two or more implemented interfaces."); } match = test; } catch (NoSuchFieldException ex) { // NOPMD // ignore } } return match; }
/** * Gets a <code>List</code> of all interfaces implemented by the given class and its superclasses. * * <p>The order is determined by looking through each interface in turn as declared in the source * file and following its hierarchy up. Then each superclass is considered in the same way. Later * duplicates are ignored, so the order is maintained. * * @param cls the class to look up, may be <code>null</code> * @return the <code>List</code> of interfaces in order, <code>null</code> if null input */ public static List<Class<?>> getAllInterfaces(Class<?> cls) { if (cls == null) { return null; } LinkedHashSet<Class<?>> interfacesFound = new LinkedHashSet<Class<?>>(); getAllInterfaces(cls, interfacesFound); return new ArrayList<Class<?>>(interfacesFound); }
@Override public <F> F createCompositeFilter(ClassLoader loader, Object... filters) { Set<Class<?>> interfaces = new HashSet<Class<?>>(); for (Object filter : filters) { interfaces.addAll(ClassUtils.getAllInterfaces(filter.getClass())); } return (F) Proxy.newProxyInstance( loader, interfaces.toArray(CLASS_ARRAY), new CompositeFilter(this, filters)); }
/** * Get the interfaces for the specified class. * * @param cls the class to look up, may be <code>null</code> * @param interfacesFound the <code>Set</code> of interfaces for the class */ private static void getAllInterfaces(Class<?> cls, HashSet<Class<?>> interfacesFound) { while (cls != null) { Class<?>[] interfaces = cls.getInterfaces(); for (Class<?> i : interfaces) { if (interfacesFound.add(i)) { getAllInterfaces(i, interfacesFound); } } cls = cls.getSuperclass(); } }
protected final String getShortClassName(Class<?> paramAnonymousClass) { Iterator localIterator = ClassUtils.getAllInterfaces(paramAnonymousClass).iterator(); do { if (!localIterator.hasNext()) { break; } paramAnonymousClass = (Class) localIterator.next(); } while (!Annotation.class.isAssignableFrom(paramAnonymousClass)); for (; ; ) { if (paramAnonymousClass == null) {} for (paramAnonymousClass = ""; ; paramAnonymousClass = paramAnonymousClass.getName()) { return new StringBuilder(paramAnonymousClass).insert(0, '@').toString(); } paramAnonymousClass = null; } }
@Override public boolean needToProxy(Class<?> clazz) { return ClassUtils.getAllInterfaces(clazz).contains(Session.class); }