Java ClassPathScanningCandidateComponentProvider.setResourceLoader方法代码示例

import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider; //导入方法依赖的package包/类
private Set<Class<?>> getInitialEntitySet(BeanFactory beanFactory)
		throws ClassNotFoundException {
	Set<Class<?>> entitySet = new HashSet<Class<?>>();
	ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(
			false);
	scanner.setEnvironment(this.environment);
	scanner.setResourceLoader(this.resourceLoader);
	scanner.addIncludeFilter(new AnnotationTypeFilter(Document.class));
	scanner.addIncludeFilter(new AnnotationTypeFilter(Persistent.class));
	for (String basePackage : getMappingBasePackages(beanFactory)) {
		if (StringUtils.hasText(basePackage)) {
			for (BeanDefinition candidate : scanner
					.findCandidateComponents(basePackage)) {
				entitySet.add(ClassUtils.forName(candidate.getBeanClassName(),
						this.classLoader));
			}
		}
	}
	return entitySet;
}
 

import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider; //导入方法依赖的package包/类
public Stream<BeanDefinition> scanBeanDefinitions(Class<? extends Annotation> annoClass, String...extraPackagesToScans){
	ClassPathScanningCandidateComponentProvider scanner = createAnnotationScanner(classLoader, annoClass);
	if(resourceLoader!=null){
		scanner.setResourceLoader(resourceLoader);
	}
	/*Set<String> basePackages = getBasePackages();
	for (String basePackage : basePackages) {
		Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(basePackage);
		for (BeanDefinition candidateComponent : candidateComponents) {
			consumer.accept(candidateComponent);
		}
	}*/
	Set<String> basePackages = getBasePackages();
	if(!LangUtils.isEmpty(extraPackagesToScans)){
		basePackages.addAll(Arrays.asList(extraPackagesToScans));
	}
	return basePackages.stream()
						.flatMap(pack->scanner.findCandidateComponents(pack).stream());
}
 

import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider; //导入方法依赖的package包/类
public static Set<Class<?>> scanTypes(String basePackage, Class<?> targetType) throws ClassNotFoundException {
    ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false);
    if (resourceLoader!=null) {
        scanner.setResourceLoader(resourceLoader);
    }

    AssignableTypeFilter filter = new AssignableTypeFilter(targetType);
    scanner.addIncludeFilter(filter);
    Set<BeanDefinition> beanSet = scanner.findCandidateComponents(basePackage);

    Set<Class<?>> classSet = new HashSet<Class<?>>();
    for (BeanDefinition beanDef : beanSet) {
        // log.debug("found candidate bean = {}", beanDef.getBeanClassName());

        Class<?> clazz;

        clazz = Class.forName(beanDef.getBeanClassName(), true, Thread.currentThread().getContextClassLoader());
        classSet.add(clazz);
    }

    return classSet;
}
 

import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider; //导入方法依赖的package包/类
public void registerSoapClients(AnnotationMetadata metadata,
                                 BeanDefinitionRegistry registry) {
    ClassPathScanningCandidateComponentProvider scanner = getScanner();
    scanner.setResourceLoader(this.resourceLoader);

    AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
            SoapClient.class);
    scanner.addIncludeFilter(annotationTypeFilter);

    Set<String> basePackages = getBasePackages(metadata);

    for (String basePackage : basePackages) {
        Set<BeanDefinition> candidateComponents = scanner
                .findCandidateComponents(basePackage);

        for (BeanDefinition candidateComponent : candidateComponents) {
            if (candidateComponent instanceof AnnotatedBeanDefinition) {
                // verify annotated class is an interface
                AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
                AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                Assert.isTrue(annotationMetadata.isInterface(),
                        "@SoapClient can only be specified on an interface");

                Map<String, Object> attributes = annotationMetadata
                        .getAnnotationAttributes(
                                SoapClient.class.getCanonicalName());
                registerSoapClient(registry, annotationMetadata, attributes);
            }
        }
    }
}
 

import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider; //导入方法依赖的package包/类
/**
 * Scan for entities with the specified annotations.
 * @param annotationTypes the annotation types used on the entities
 * @return a set of entity classes
 * @throws ClassNotFoundException if an entity class cannot be loaded
 */
@SafeVarargs
public final Set<Class<?>> scan(Class<? extends Annotation>... annotationTypes)
		throws ClassNotFoundException {
	List<String> packages = getPackages();
	if (packages.isEmpty()) {
		return Collections.<Class<?>>emptySet();
	}
	Set<Class<?>> entitySet = new HashSet<Class<?>>();
	ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(
			false);
	scanner.setEnvironment(this.context.getEnvironment());
	scanner.setResourceLoader(this.context);
	for (Class<? extends Annotation> annotationType : annotationTypes) {
		scanner.addIncludeFilter(new AnnotationTypeFilter(annotationType));
	}
	for (String basePackage : packages) {
		if (StringUtils.hasText(basePackage)) {
			for (BeanDefinition candidate : scanner
					.findCandidateComponents(basePackage)) {
				entitySet.add(ClassUtils.forName(candidate.getBeanClassName(),
						this.context.getClassLoader()));
			}
		}
	}
	return entitySet;
}
 

import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider; //导入方法依赖的package包/类
/**
 * Scan a package to find classes that have the given annotation.
 * 
 * @param packageRoot The package to scan.
 * @param anno Annotation that should be on the class that we are interested in.
 * @return A set of classes that have the annotation.
 */
public static Set<Class<?>> scan(String packageRoot, Class<? extends Annotation> anno) {
    ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false);
    if (resourceLoader!=null) {
        scanner.setResourceLoader(resourceLoader);
    }

    AnnotationTypeFilter filter = new AnnotationTypeFilter(anno);
    scanner.addIncludeFilter(filter);
    Set<BeanDefinition> beanSet = scanner.findCandidateComponents(packageRoot);

    Set<Class<?>> classSet = new HashSet<Class<?>>();
    for (BeanDefinition beanDef : beanSet) {
        LOGGER.debug("found candidate bean = " + beanDef.getBeanClassName());

        Class<?> clazz;
        try {
            clazz = Class.forName(beanDef.getBeanClassName(), true, Thread.currentThread().getContextClassLoader());
            if (clazz.isAnnotationPresent(anno)) {
                LOGGER.debug("found annotated class, " + clazz.getName());
                classSet.add(clazz);
            }
        } catch (ClassNotFoundException e) {
            LOGGER.error("exception while scanning classpath for annotated classes", e);
        }
    }

    return classSet;
}
 

import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider; //导入方法依赖的package包/类
@Override
public Collection<BundleBean> refreshBundles(List<URL> urlList) throws BundleParsingException {

    final ClassPathScanningCandidateComponentProvider scanner =
            new ClassPathScanningCandidateComponentProvider(false);
    final URL[] urlArray = urlList.toArray(new URL[urlList.size()]);
    final URLClassLoader childLoader = AccessController.doPrivileged(new PrivilegedAction<URLClassLoader>() {
        @Override
        public URLClassLoader run() {
            return new URLClassLoader(urlArray, scanner.getResourceLoader().getClassLoader());
        }
    });

    PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(childLoader);
    scanner.setResourceLoader(resolver);
    scanner.setMetadataReaderFactory(new SimpleMetadataReaderFactory());
    scanner.addIncludeFilter(new AnnotationTypeFilter(org.dynamise.shared.annotation.Service.class));

    List<BundleBean> list = ConfigUtils.parsePathItems(this.propertyBean.getBundlePackages()).get().stream()
            .map(pkg -> scanner.findCandidateComponents(pkg))
            .flatMap(Collection::stream)
            .map(beanDef -> createBundleBean(childLoader, findSourceFile(beanDef), beanDef.getBeanClassName()))
            .collect(toList());

    list = shrinkDuplicates(list, list, new ArrayList<>(list.size()));
    list = shrinkDuplicates(list, this.bundleMap.values(), new ArrayList<>(list.size()));


    if (list.isEmpty()) {
        throw new BundleParsingException("No suitable bundles found");
    }

    list.stream().forEach(bundle -> this.bundleMap.values().stream().filter(current -> current.equals(bundle))
            .findFirst().ifPresent(current -> this.bundleMap.remove(current.getId())));

    list.stream().forEach(bundle -> this.bundleMap.put(bundle.getId(), bundle));

    return list;
}
 

import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider; //导入方法依赖的package包/类
@PostConstruct
public void postConstruct() {
	ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(
			false);
	scanner.setEnvironment(this.environment);
	scanner.setResourceLoader(this.resourceLoader);
	scanner.addIncludeFilter(new AnnotationTypeFilter(WicketHomePage.class));
	scanner.addIncludeFilter(new AnnotationTypeFilter(WicketSignInPage.class));
    scanner.addIncludeFilter(new AnnotationTypeFilter(WicketAccessDeniedPage.class));
    scanner.addIncludeFilter(new AnnotationTypeFilter(WicketExpiredPage.class));
    scanner.addIncludeFilter(new AnnotationTypeFilter(WicketInternalErrorPage.class));
    for (String basePackage : getMappingBasePackages(beanFactory)) {
		if (StringUtils.hasText(basePackage)) {
			pageCandidates().getBasePackages().add(basePackage);
			Set<BeanDefinition> beanDefinitions = scanner.findCandidateComponents(basePackage);
			for (BeanDefinition beanDefinition : beanDefinitions) {
				Class<?> beanClass;
				try {
					beanClass = ClassUtils.forName(beanDefinition.getBeanClassName(), classLoader);
				} catch (ClassNotFoundException e) {
					throw new IllegalStateException(e);
				}
				if(beanClass.isAnnotationPresent(WicketHomePage.class)){
					pageCandidates().getHomePageCandidates().add(new WicketClassCandidate<Page>((Class<Page>) beanClass));
				}
				if(beanClass.isAnnotationPresent(WicketSignInPage.class)){
					pageCandidates().getSignInPageCandidates().add(new WicketClassCandidate<WebPage>((Class<WebPage>) beanClass));
				}
				if(beanClass.isAnnotationPresent(WicketAccessDeniedPage.class)){
					pageCandidates().getAccessDeniedPageCandidates().add(new WicketClassCandidate<Page>((Class<Page>) beanClass));
				}
				if(beanClass.isAnnotationPresent(WicketExpiredPage.class)){
					pageCandidates().getExpiredPageCandidates().add(new WicketClassCandidate<Page>((Class<Page>) beanClass));
				}
				if(beanClass.isAnnotationPresent(WicketInternalErrorPage.class)){
					pageCandidates().getInternalErrorPageCandidates().add(new WicketClassCandidate<Page>((Class<Page>) beanClass));
				}
			}
			
		}
    }
}
 

import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider; //导入方法依赖的package包/类
private Set<BeanDefinition> findCandidateComponents(ModulesConfig modulesConfig, ParserContext parser, Class<? extends Annotation> annotationType){
	ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false);
	scanner.addIncludeFilter(new AnnotationTypeFilter(annotationType));
	scanner.setResourceLoader(parser.getReaderContext().getResourceLoader());
	return scanner.findCandidateComponents(modulesConfig.getBasePackage());
}
 

import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider; //导入方法依赖的package包/类
/**
 * Utility method to scan the given package and handler for the annotation
 * of the given class. Its uses the Spring annotation detector
 *
 * @param clas
 *            the clas
 * @param basePackage
 *            the base package
 * @param handler
 *            the handler
 */
public static void scan(final Class<? extends Annotation> clas, final String[] basePackage, final AnnotationHandler handler) {
	final ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false);
	scanner.setResourceLoader(new PathMatchingResourcePatternResolver(Thread.currentThread().getContextClassLoader()));
	scanner.addIncludeFilter(new AnnotationTypeFilter(clas));
	for (final String pck : basePackage) {
		for (final BeanDefinition bd : scanner.findCandidateComponents(pck)) {
			handler.handleAnnotationFound(bd.getBeanClassName());
		}
	}
}