Example usage for org.springframework.util ClassUtils getAllInterfacesForClassAsSet

Introduction

In this page you can find the example usage for org.springframework.util ClassUtils getAllInterfacesForClassAsSet.

Prototype

public static Set<Class<?>> getAllInterfacesForClassAsSet(Class<?> clazz) 

Source Link

Document

Return all interfaces that the given class implements as a Set, including ones implemented by superclasses.

Usage

From source file:org.web4thejob.util.L10nUtil.java

public static List<L10nString> getLocalizableResources(final Class<?> localizable) {
    final List<L10nString> strings = new ArrayList<L10nString>();
    final Set<Class> classes = new HashSet<Class>();
    classes.add(localizable);/*  w ww  .  ja v  a  2s .  com*/
    classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(localizable));

    for (Class<?> clazz : classes) {
        ReflectionUtils.doWithFields(clazz, new ReflectionUtils.FieldCallback() {
            @Override
            public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
                strings.add((L10nString) field.get(null));
            }
        }, new ReflectionUtils.FieldFilter() {
            @Override
            public boolean matches(Field field) {
                return ReflectionUtils.isPublicStaticFinal(field) && L10nString.class.equals(field.getType());
            }
        });
    }

    //get localizable resources from extension modules
    for (Module module : ContextUtil.getModules()) {
        if (module instanceof LocalizableModule) {
            strings.addAll(((LocalizableModule) module).getLocalizableStrings(classes));
        }
    }

    // add commands,settings and global strings here...
    if (DesktopLayoutPanel.class.isAssignableFrom(localizable)) {
        for (CommandEnum commandEnum : CommandEnum.values()) {
            L10nString l10nString = new L10nString(CommandEnum.class, commandEnum.name(),
                    L10nUtil.getMessage(commandEnum.getClass(), commandEnum.name(), commandEnum.name()));
            strings.add(l10nString);
        }

        for (SettingEnum settingEnum : SettingEnum.values()) {
            L10nString l10nString = new L10nString(SettingEnum.class, settingEnum.name(),
                    L10nUtil.getMessage(settingEnum.getClass(), settingEnum.name(), settingEnum.name()));
            strings.add(l10nString);
        }

        for (Condition condition : Condition.getConditions()) {
            L10nString l10nString = new L10nString(Condition.class, condition.getKey(), condition.getKey());
            strings.add(l10nString);
        }
    }

    return strings;
}

---

From source file:org.web4thejob.util.CoreUtil.java

public static String describeClass(Class<?> clazz) {
    List<String> classes = new ArrayList<String>();
    classes.add(clazz.getCanonicalName());
    for (Class<?> cls : ClassUtils.getAllInterfacesForClassAsSet(clazz)) {
        classes.add(cls.getCanonicalName());
    }//w  w w.  ja v a 2s.com
    return StringUtils.collectionToDelimitedString(classes, ", ");
}

---

From source file:com.oembedler.moon.graphql.engine.dfs.GraphQLSchemaDfsTraversal.java

public GraphQLType createGraphQLObjectTypeRecursively(DfsContext dfsContext, final Class<?> implClass) {

    ResolvableTypeAccessor resolvableTypeAccessor = ResolvableTypeAccessor.forClass(implClass);
    String objectName = resolvableTypeAccessor.getName();
    String objectDescription = resolvableTypeAccessor.getDescription();

    GraphQLType graphQLObjectType = objectTypeResolverMap.get(implClass);
    if (!objectTypeNameReferenceMap.containsKey(implClass)) {

        objectTypeNameReferenceMap.put(implClass, objectName);
        objectNameTypeReferenceMap.put(objectName, implClass);

        final List<GraphQLFieldDefinition> graphQLFieldDefinitions = new ArrayList<>();

        if (implClass.isEnum()) {
            graphQLObjectType = buildGraphQLEnumType(dfsContext, resolvableTypeAccessor);
        } else {/*w  ww .java  2  s. c  o m*/

            ReflectionUtils.getAllFields(implClass).forEach(field -> {
                GraphQLFieldDefinition definition = getFieldDefinition(dfsContext, implClass, field);
                if (definition != null)
                    graphQLFieldDefinitions.add(definition);
            });

            ReflectionUtils.getAllMethods(implClass).forEach(method -> {
                GraphQLFieldDefinition definition = getMethodDefinition(dfsContext, implClass, method);
                if (definition != null)
                    graphQLFieldDefinitions.add(definition);
            });

            List<GraphQLType> graphQLInterfaceTypes = Lists.newArrayList();
            if (implClass.isInterface()) {
                if (resolvableTypeAccessor.isGraphQLUnion()) {
                    List<GraphQLType> possibleTypes = new ArrayList<>();
                    for (Class<?> possibleType : resolvableTypeAccessor.getGraphQLUnionPossibleTypes()) {
                        possibleTypes.add(createGraphQLObjectTypeRecursively(dfsContext, possibleType));
                    }

                    graphQLObjectType = GraphQLUnionType.newUnionType().name(resolvableTypeAccessor.getName())
                            .possibleTypes(possibleTypes.toArray(new GraphQLObjectType[possibleTypes.size()]))
                            .typeResolver(new CompleteObjectTreeTypeResolver(objectTypeResolverMap))
                            .description(resolvableTypeAccessor.getDescription()).build();
                    graphQLUnionTypeMap.add((GraphQLUnionType) graphQLObjectType);
                } else {
                    graphQLObjectType = newInterface().name(objectName).description(objectDescription)
                            .fields(graphQLFieldDefinitions)
                            .typeResolver(new CompleteObjectTreeTypeResolver(objectTypeResolverMap)).build();
                }
            } else {
                ClassUtils.getAllInterfacesForClassAsSet(implClass).forEach(aClass -> {
                    if (isAcceptableInterface(dfsContext, aClass)) {
                        GraphQLType graphQLType = createGraphQLObjectTypeRecursively(dfsContext, aClass);
                        graphQLInterfaceTypes.add(graphQLType);
                    }
                });

                graphQLObjectType = newObject().name(objectName).description(objectDescription)
                        .fields(graphQLFieldDefinitions)
                        .withInterfaces(resolveInterfaceReferences(dfsContext, graphQLInterfaceTypes)).build();
            }
        }

        objectTypeResolverMap.put(implClass, graphQLObjectType);
    } else {
        // reference
        //if (!implClass.isInterface())
        graphQLObjectType = new GraphQLTypeReference(objectName);
    }
    return graphQLObjectType;
}

---

From source file:org.springframework.aop.framework.CglibAopProxy.java

/**
 * Checks to see whether the supplied {@code Class} has already been validated and
 * validates it if not./*from   w w  w.  j  a v  a 2 s .c  om*/
 */
private void validateClassIfNecessary(Class<?> proxySuperClass, @Nullable ClassLoader proxyClassLoader) {
    if (logger.isWarnEnabled()) {
        synchronized (validatedClasses) {
            if (!validatedClasses.containsKey(proxySuperClass)) {
                doValidateClass(proxySuperClass, proxyClassLoader,
                        ClassUtils.getAllInterfacesForClassAsSet(proxySuperClass));
                validatedClasses.put(proxySuperClass, Boolean.TRUE);
            }
        }
    }
}

---

From source file:org.springframework.aop.support.AopUtils.java

/**
 * Can the given pointcut apply at all on the given class?
 * This is an important test as it can be used to optimize
 * out a pointcut for a class./*from  ww  w.  j  a va  2 s  .com*/
 * @param pc pc static or dynamic pointcut to check
 * @param targetClass class we're testing
 * @return whether the pointcut can apply on any method
 */
public static boolean canApply(Pointcut pc, Class targetClass) {
    if (!pc.getClassFilter().matches(targetClass)) {
        return false;
    }

    Set classes = ClassUtils.getAllInterfacesForClassAsSet(targetClass);
    classes.add(targetClass);
    for (Iterator it = classes.iterator(); it.hasNext();) {
        Class clazz = (Class) it.next();
        Method[] methods = clazz.getMethods();
        for (int j = 0; j < methods.length; j++) {
            if (pc.getMethodMatcher().matches(methods[j], targetClass)) {
                return true;
            }
        }
    }

    return false;
}

---