Example usage for org.springframework.core.type ClassMetadata getClassName

List of usage examples for org.springframework.core.type ClassMetadata getClassName

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.core.type.*
  5. ClassMetadata
  6. getClassName

Introduction

In this page you can find the example usage for org.springframework.core.type ClassMetadata getClassName.

Prototype

String getClassName();

Source Link

Document

Return the name of the underlying class.

Usage

From source file:org.syncope.core.rest.controller.TaskController.java

@PreAuthorize("hasRole('TASK_LIST')")
@RequestMapping(method = RequestMethod.GET, value = "/jobActionsClasses")
public ModelAndView getJobActionClasses() {
    CachingMetadataReaderFactory cachingMetadataReaderFactory = new CachingMetadataReaderFactory();

    Set<String> jobActionsClasses = new HashSet<String>();
    try {/*from   w  ww .  jav a 2  s .co  m*/
        for (Resource resource : resResolver.getResources("classpath*:**/*.class")) {

            ClassMetadata metadata = cachingMetadataReaderFactory.getMetadataReader(resource)
                    .getClassMetadata();
            if (ArrayUtils.contains(metadata.getInterfaceNames(), SyncJobActions.class.getName())) {

                try {
                    Class jobClass = Class.forName(metadata.getClassName());
                    if (!Modifier.isAbstract(jobClass.getModifiers())) {
                        jobActionsClasses.add(jobClass.getName());
                    }
                } catch (ClassNotFoundException e) {
                    LOG.error("Could not load class {}", metadata.getClassName(), e);
                }
            }
        }
    } catch (IOException e) {
        LOG.error("While searching for class implementing {}", SyncJobActions.class.getName(), e);
    }

    ModelAndView result = new ModelAndView();
    result.addObject(jobActionsClasses);
    return result;
}

From source file:org.syncope.core.rest.controller.ReportController.java

@PreAuthorize("hasRole('REPORT_LIST')")
@RequestMapping(method = RequestMethod.GET, value = "/reportletClasses")
public ModelAndView getReportletClasses() {
    CachingMetadataReaderFactory cachingMetadataReaderFactory = new CachingMetadataReaderFactory();

    Set<String> reportletClasses = new HashSet<String>();
    try {//  ww  w .  ja va2  s.  com
        for (Resource resource : resResolver.getResources("classpath*:**/*.class")) {

            ClassMetadata metadata = cachingMetadataReaderFactory.getMetadataReader(resource)
                    .getClassMetadata();
            if (ArrayUtils.contains(metadata.getInterfaceNames(), Reportlet.class.getName())
                    || AbstractReportlet.class.getName().equals(metadata.getSuperClassName())) {

                try {
                    Class jobClass = Class.forName(metadata.getClassName());
                    if (!Modifier.isAbstract(jobClass.getModifiers())) {

                        reportletClasses.add(jobClass.getName());
                    }
                } catch (ClassNotFoundException e) {
                    LOG.error("Could not load class {}", metadata.getClassName(), e);
                }
            }
        }
    } catch (IOException e) {
        LOG.error("While searching for class implementing {}", Reportlet.class.getName(), e);
    }

    ModelAndView result = new ModelAndView();
    result.addObject(reportletClasses);
    return result;
}

From source file:org.syncope.core.rest.controller.TaskController.java

@PreAuthorize("hasRole('TASK_LIST')")
@RequestMapping(method = RequestMethod.GET, value = "/jobClasses")
public ModelAndView getJobClasses() {
    CachingMetadataReaderFactory cachingMetadataReaderFactory = new CachingMetadataReaderFactory();

    Set<String> jobClasses = new HashSet<String>();
    try {/*from w  w w.j  a  va  2  s .  c  o  m*/
        for (Resource resource : resResolver.getResources("classpath*:**/*.class")) {

            ClassMetadata metadata = cachingMetadataReaderFactory.getMetadataReader(resource)
                    .getClassMetadata();
            if (ArrayUtils.contains(metadata.getInterfaceNames(), Job.class.getName())
                    || AbstractTaskJob.class.getName().equals(metadata.getSuperClassName())
                    || ArrayUtils.contains(metadata.getInterfaceNames(), StatefulJob.class.getName())) {

                try {
                    Class jobClass = Class.forName(metadata.getClassName());
                    if (!Modifier.isAbstract(jobClass.getModifiers()) && !metadata.hasEnclosingClass()
                            && !jobClass.equals(SyncJob.class) && !jobClass.equals(ReportJob.class)
                            && !jobClass.equals(NotificationJob.class)) {

                        jobClasses.add(jobClass.getName());
                    }
                } catch (ClassNotFoundException e) {
                    LOG.error("Could not load class {}", metadata.getClassName(), e);
                }
            }
        }
    } catch (IOException e) {
        LOG.error("While searching for class implementing {}", Job.class.getName(), e);
    }

    ModelAndView result = new ModelAndView();
    result.addObject(jobClasses);
    return result;
}

From source file:org.libreplan.web.common.entrypoints.RedirectorSynthetiser.java

private void addIfSuitable(List<Class<?>> accumulatedResult, CachingMetadataReaderFactory metadataReaderFactory,
        Resource resource) {/* w w w . ja  va  2  s  . c o m*/
    try {
        if (resource.isReadable()) {
            MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(resource);
            AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
            ClassMetadata classMetadata = metadataReader.getClassMetadata();

            if (classMetadata.isInterface()
                    && annotationMetadata.getAnnotationTypes().contains(EntryPoints.class.getName())) {

                Class<?> klass = Class.forName(classMetadata.getClassName());
                if (klass.isInterface()) {
                    accumulatedResult.add(klass);
                }
            }
        }
    } catch (Exception e) {
        LOG.warn("exception processing " + resource, e);
    }
}

From source file:org.springframework.core.type.filter.AbstractTypeHierarchyTraversingFilter.java

@Override
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
        throws IOException {

    // This method optimizes avoiding unnecessary creation of ClassReaders
    // as well as visiting over those readers.
    if (matchSelf(metadataReader)) {
        return true;
    }/*from  w  ww  . j  a  va2 s.c  om*/
    ClassMetadata metadata = metadataReader.getClassMetadata();
    if (matchClassName(metadata.getClassName())) {
        return true;
    }

    if (this.considerInherited) {
        String superClassName = metadata.getSuperClassName();
        if (superClassName != null) {
            // Optimization to avoid creating ClassReader for super class.
            Boolean superClassMatch = matchSuperClass(superClassName);
            if (superClassMatch != null) {
                if (superClassMatch.booleanValue()) {
                    return true;
                }
            } else {
                // Need to read super class to determine a match...
                try {
                    if (match(metadata.getSuperClassName(), metadataReaderFactory)) {
                        return true;
                    }
                } catch (IOException ex) {
                    logger.debug("Could not read super class [" + metadata.getSuperClassName()
                            + "] of type-filtered class [" + metadata.getClassName() + "]");
                }
            }
        }
    }

    if (this.considerInterfaces) {
        for (String ifc : metadata.getInterfaceNames()) {
            // Optimization to avoid creating ClassReader for super class
            Boolean interfaceMatch = matchInterface(ifc);
            if (interfaceMatch != null) {
                if (interfaceMatch.booleanValue()) {
                    return true;
                }
            } else {
                // Need to read interface to determine a match...
                try {
                    if (match(ifc, metadataReaderFactory)) {
                        return true;
                    }
                } catch (IOException ex) {
                    logger.debug("Could not read interface [" + ifc + "] for type-filtered class ["
                            + metadata.getClassName() + "]");
                }
            }
        }
    }

    return false;
}

From source file:ru.kwanza.dbtool.orm.impl.mapping.SpringEntityMappingRegistryImpl.java

private void scanPackage(String basePackage) {
    try {//w  ww  .  j  av a  2s. c o  m
        final String packageSearchPath = createPackageSearchPath(basePackage);
        final Resource[] resources = resourcePatternResolver.getResources(packageSearchPath);
        for (Resource resource : resources) {
            if (log.isTraceEnabled()) {
                log.trace("Scanning " + resource);
            }
            if (resource.isReadable()) {
                try {
                    final MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(resource);
                    final ClassMetadata classMetadata = metadataReader.getClassMetadata();
                    final String className = classMetadata.getClassName();
                    if (!classMetadata.isAbstract()
                            && !Enum.class.getName().equals(classMetadata.getSuperClassName())) {
                        log.trace(className);
                        final ClassLoader classLoader = resourcePatternResolver.getClassLoader();
                        Class<?> entityClass = classLoader.loadClass(className);
                        if (entityClass.isAnnotationPresent(Entity.class)
                                || entityClass.isAnnotationPresent(AbstractEntity.class)) {
                            delegate.registerEntityClass(entityClass);
                        }
                    }
                } catch (Throwable e) {
                    throw new RuntimeException("Error while registering entity mapping: " + resource, e);
                }
            } else {
                if (log.isTraceEnabled()) {
                    log.trace("Ignored because not readable: " + resource);
                }
            }
        }
    } catch (IOException e) {
        throw new RuntimeException("I/O failure during classpath scanning", e);
    }
}

From source file:xc.mst.service.impl.test.TestTypeFilter.java

@SuppressWarnings("unchecked")
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
        throws IOException {
    try {/*w ww  . j  a v  a2  s. com*/
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        String className = classMetadata.getClassName();
        Class c = getClassLoader().loadClass(className);
        LOG.debug("checking class: " + c);
        if (BaseMetadataServiceTest.class.isAssignableFrom(c) && !BaseMetadataServiceTest.class.equals(c)) {
            String filter = System.getenv("service.test");
            LOG.debug("filter: " + filter);
            LOG.debug("c.getName(): " + c.getName());
            if (StringUtils.isEmpty(filter) || c.getName().toUpperCase().contains(filter.toUpperCase())) {
                testClasses.add(c);
                LOG.debug("adding class to test suite: " + c);
            }
        }
    } catch (Throwable t) {
        LOG.debug("", t);
    }
    return false;
}