org.springframework.context.annotation.ClassPathBeanDefinitionScanner

/**
 * Register a {@link org.springframework.beans.factory.config.BeanDefinition} for any
 * clreplacedes specified by {@link #register(Clreplaced...)} and scan any packages specified by
 * {@link #scan(String...)}.
 * <p>
 * For any values specified by {@link #setConfigLocation(String)} or
 * {@link #setConfigLocations(String[])}, attempt first to load each location as a
 * clreplaced, registering a {@code BeanDefinition} if clreplaced loading is successful, and if
 * clreplaced loading fails (i.e. a {@code ClreplacedNotFoundException} is raised), replacedume the
 * value is a package and attempt to scan it for annotated clreplacedes.
 * <p>
 * Enables the default set of annotation configuration post processors, such that
 * {@code @Autowired}, {@code @Required}, and replacedociated annotations can be used.
 * <p>
 * Configuration clreplaced bean definitions are registered with generated bean definition
 * names unless the {@code value} attribute is provided to the stereotype annotation.
 * @param beanFactory the bean factory to load bean definitions into
 * @see #register(Clreplaced...)
 * @see #scan(String...)
 * @see #setConfigLocation(String)
 * @see #setConfigLocations(String[])
 * @see AnnotatedBeanDefinitionReader
 * @see ClreplacedPathBeanDefinitionScanner
 */
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) {
    AnnotatedBeanDefinitionReader reader = getAnnotatedBeanDefinitionReader(beanFactory);
    ClreplacedPathBeanDefinitionScanner scanner = getClreplacedPathBeanDefinitionScanner(beanFactory);
    applyBeanNameGenerator(beanFactory, reader, scanner);
    applyScopeMetadataResolver(reader, scanner);
    loadBeanDefinitions(reader, scanner);
}

private void applyScopeMetadataResolver(AnnotatedBeanDefinitionReader reader, ClreplacedPathBeanDefinitionScanner scanner) {
    ScopeMetadataResolver scopeMetadataResolver = getScopeMetadataResolver();
    if (scopeMetadataResolver != null) {
        reader.setScopeMetadataResolver(scopeMetadataResolver);
        scanner.setScopeMetadataResolver(scopeMetadataResolver);
    }
}

private void loadBeanDefinitions(AnnotatedBeanDefinitionReader reader, ClreplacedPathBeanDefinitionScanner scanner) throws LinkageError {
    if (!this.annotatedClreplacedes.isEmpty()) {
        registerAnnotatedClreplacedes(reader);
    }
    if (!this.basePackages.isEmpty()) {
        scanBasePackages(scanner);
    }
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        registerConfigLocations(reader, scanner, configLocations);
    }
}

private void registerConfigLocations(AnnotatedBeanDefinitionReader reader, ClreplacedPathBeanDefinitionScanner scanner, String[] configLocations) throws LinkageError {
    for (String configLocation : configLocations) {
        try {
            register(reader, configLocation);
        } catch (ClreplacedNotFoundException ex) {
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Could not load clreplaced for config location [" + configLocation + "] - trying package scan. " + ex);
            }
            int count = scanner.scan(configLocation);
            if (this.logger.isInfoEnabled()) {
                logScanResult(configLocation, count);
            }
        }
    }
}

/**
 * Loads {@link BeanDefinition BeanDefinitions} from Annotation configuration (component) clreplacedes
 * as well as from other resource locations (e.g. XML).
 *
 * @param beanFactory {@link DefaultListableBeanFactory} to configure.
 * @throws BeansException if loading and configuring the {@link BeanDefinition BeanDefintions} for the target
 * {@link DefaultListableBeanFactory} fails.
 * @see org.springframework.beans.factory.support.DefaultListableBeanFactory
 * @see #newAnnotatedBeanDefinitionReader(BeanDefinitionRegistry)
 * @see #newClreplacedBeanDefinitionScanner(BeanDefinitionRegistry)
 * @see #getConfigLocations()
 */
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException {
    AnnotatedBeanDefinitionReader reader = configure(newAnnotatedBeanDefinitionReader(beanFactory));
    ClreplacedPathBeanDefinitionScanner scanner = configure(newClreplacedBeanDefinitionScanner(beanFactory));
    getBeanNameGenerator().ifPresent(beanNameGenerator -> {
        reader.setBeanNameGenerator(beanNameGenerator);
        scanner.setBeanNameGenerator(beanNameGenerator);
        beanFactory.registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);
    });
    getScopeMetadataResolver().ifPresent(scopeMetadataResolver -> {
        reader.setScopeMetadataResolver(scopeMetadataResolver);
        scanner.setScopeMetadataResolver(scopeMetadataResolver);
    });
    Arrays.stream(ArrayUtils.nullSafeArray(getConfigLocations(), String.clreplaced)).forEach(configLocation -> {
        try {
            Clreplaced<?> type = ClreplacedUtils.forName(configLocation, getClreplacedLoader());
            getLogger().trace("Registering [{}]", configLocation);
            reader.register(type);
        } catch (ClreplacedNotFoundException cause) {
            getLogger().trace(String.format("Could not load clreplaced for config location [%s] - trying package scan.", configLocation), cause);
            if (scanner.scan(configLocation) == 0) {
                getLogger().debug("No component clreplacedes found for specified clreplaced/package [{}]", configLocation);
            }
        }
    });
}

private ClreplacedPathBeanDefinitionScanner configure(ClreplacedPathBeanDefinitionScanner scanner) {
    Set<String> basePackages = this.basePackages;
    if (!basePackages.isEmpty()) {
        getLogger().debug("Scanning base packages: {}", basePackages);
        scanner.scan(StringUtils.toStringArray(basePackages));
    }
    return scanner;
}

/**
 * Register a {@link org.springframework.beans.factory.config.BeanDefinition} for any
 * clreplacedes specified by {@link #register(Clreplaced...)} and scan any packages specified by
 * {@link #scan(String...)}.
 * <p>
 * For any values specified by {@link #setConfigLocation(String)} or
 * {@link #setConfigLocations(String[])}, attempt first to load each location as a
 * clreplaced, registering a {@code BeanDefinition} if clreplaced loading is successful, and if
 * clreplaced loading fails (i.e. a {@code ClreplacedNotFoundException} is raised), replacedume the
 * value is a package and attempt to scan it for annotated clreplacedes.
 * <p>
 * Enables the default set of annotation configuration post processors, such that
 * {@code @Autowired}, {@code @Required}, and replacedociated annotations can be used.
 * <p>
 * Configuration clreplaced bean definitions are registered with generated bean definition
 * names unless the {@code value} attribute is provided to the stereotype annotation.
 *
 * @param beanFactory the bean factory to load bean definitions into
 * @see #register(Clreplaced...)
 * @see #scan(String...)
 * @see #setConfigLocation(String)
 * @see #setConfigLocations(String[])
 * @see AnnotatedBeanDefinitionReader
 * @see ClreplacedPathBeanDefinitionScanner
 */
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) {
    AnnotatedBeanDefinitionReader reader = getAnnotatedBeanDefinitionReader(beanFactory);
    ClreplacedPathBeanDefinitionScanner scanner = getClreplacedPathBeanDefinitionScanner(beanFactory);
    applyBeanNameGenerator(beanFactory, reader, scanner);
    applyScopeMetadataResolver(reader, scanner);
    loadBeanDefinitions(reader, scanner);
}

/**
 * 扫描注解Component的类，提取信息，组装成BeanDefinition
 *
 * @param scanPath
 */
private void scanPackage(String scanPath) {
    String[] basePackages = StrUtil.splitToArray(scanPath, ',');
    ClreplacedPathBeanDefinitionScanner scanner = new ClreplacedPathBeanDefinitionScanner(getRegistry());
    scanner.doScan(basePackages);
}

private void applyBeanNameGenerator(DefaultListableBeanFactory beanFactory, AnnotatedBeanDefinitionReader reader, ClreplacedPathBeanDefinitionScanner scanner) {
    BeanNameGenerator beanNameGenerator = getBeanNameGenerator();
    if (beanNameGenerator != null) {
        reader.setBeanNameGenerator(beanNameGenerator);
        scanner.setBeanNameGenerator(beanNameGenerator);
        beanFactory.registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);
    }
}

private void scanBasePackages(ClreplacedPathBeanDefinitionScanner scanner) {
    if (this.logger.isInfoEnabled()) {
        this.logger.info("Scanning base packages: [" + StringUtils.collectionToCommaDelimitedString(this.basePackages) + "]");
    }
    scanner.scan(StringUtils.toStringArray(this.basePackages));
}

@Test
public void clreplacedPathBeanDefinitionScanner_inheritsEnvironmentFromEnvironmentCapableBDR_scanProfileAnnotatedComponents() {
    GenericApplicationContext ctx = new GenericApplicationContext();
    ctx.setEnvironment(prodEnv);
    ClreplacedPathBeanDefinitionScanner scanner = new ClreplacedPathBeanDefinitionScanner(ctx);
    scanner.scan("org.springframework.core.env.scan2");
    ctx.refresh();
    replacedertThat(scanner.getEnvironment(), is((Environment) ctx.getEnvironment()));
    replacedertThat(ctx.containsBean(DEV_BEAN_NAME), is(false));
    replacedertThat(ctx.containsBean(PROD_BEAN_NAME), is(true));
}

@Test
public void clreplacedPathBeanDefinitionScanner_inheritsEnvironmentFromEnvironmentCapableBDR_scanProfileAnnotatedConfigClreplacedes() {
    // it's actually ConfigurationClreplacedPostProcessor's Environment that gets the job done here.
    GenericApplicationContext ctx = new GenericApplicationContext();
    ctx.setEnvironment(prodEnv);
    ClreplacedPathBeanDefinitionScanner scanner = new ClreplacedPathBeanDefinitionScanner(ctx);
    scanner.scan("org.springframework.core.env.scan1");
    ctx.refresh();
    replacedertThat(ctx.containsBean(DEV_BEAN_NAME), is(false));
    replacedertThat(ctx.containsBean(PROD_BEAN_NAME), is(true));
}

/**
 * Finds a {@link Set} of {@link BeanDefinitionHolder BeanDefinitionHolders} whose bean type annotated
 * {@link Service} Annotation.
 *
 * @param scanner       {@link ClreplacedPathBeanDefinitionScanner}
 * @param packageToScan pachage to scan
 * @param registry      {@link BeanDefinitionRegistry}
 * @return non-null
 * @since 2.5.8
 */
private Set<BeanDefinitionHolder> findServiceBeanDefinitionHolders(ClreplacedPathBeanDefinitionScanner scanner, String packageToScan, BeanDefinitionRegistry registry, BeanNameGenerator beanNameGenerator) {
    Set<BeanDefinition> beanDefinitions = scanner.findCandidateComponents(packageToScan);
    Set<BeanDefinitionHolder> beanDefinitionHolders = new LinkedHashSet<BeanDefinitionHolder>(beanDefinitions.size());
    for (BeanDefinition beanDefinition : beanDefinitions) {
        String beanName = beanNameGenerator.generateBeanName(beanDefinition, registry);
        BeanDefinitionHolder beanDefinitionHolder = new BeanDefinitionHolder(beanDefinition, beanName);
        beanDefinitionHolders.add(beanDefinitionHolder);
    }
    return beanDefinitionHolders;
}

@Test
void clreplacedPathBeanDefinitionScanner_inheritsEnvironmentFromEnvironmentCapableBDR_scanProfileAnnotatedComponents() {
    GenericApplicationContext ctx = new GenericApplicationContext();
    ctx.setEnvironment(prodEnv);
    ClreplacedPathBeanDefinitionScanner scanner = new ClreplacedPathBeanDefinitionScanner(ctx);
    scanner.scan("org.springframework.core.env.scan2");
    ctx.refresh();
    replacedertThat(scanner.getEnvironment()).isEqualTo(ctx.getEnvironment());
    replacedertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
    replacedertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
}

@Test
void clreplacedPathBeanDefinitionScanner_inheritsEnvironmentFromEnvironmentCapableBDR_scanProfileAnnotatedConfigClreplacedes() {
    // it's actually ConfigurationClreplacedPostProcessor's Environment that gets the job done here.
    GenericApplicationContext ctx = new GenericApplicationContext();
    ctx.setEnvironment(prodEnv);
    ClreplacedPathBeanDefinitionScanner scanner = new ClreplacedPathBeanDefinitionScanner(ctx);
    scanner.scan("org.springframework.core.env.scan1");
    ctx.refresh();
    replacedertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
    replacedertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
}

/**
 * Finds a {@link Set} of {@link BeanDefinitionHolder BeanDefinitionHolders} whose bean type annotated
 * {@link DubboService} Annotation.
 *
 * @param scanner       {@link ClreplacedPathBeanDefinitionScanner}
 * @param packageToScan pachage to scan
 * @param registry      {@link BeanDefinitionRegistry}
 * @return non-null
 * @since 2.5.8
 */
private Set<BeanDefinitionHolder> findServiceBeanDefinitionHolders(ClreplacedPathBeanDefinitionScanner scanner, String packageToScan, BeanDefinitionRegistry registry, BeanNameGenerator beanNameGenerator) {
    Set<BeanDefinition> beanDefinitions = scanner.findCandidateComponents(packageToScan);
    Set<BeanDefinitionHolder> beanDefinitionHolders = new LinkedHashSet<BeanDefinitionHolder>(beanDefinitions.size());
    for (BeanDefinition beanDefinition : beanDefinitions) {
        String beanName = beanNameGenerator.generateBeanName(beanDefinition, registry);
        BeanDefinitionHolder beanDefinitionHolder = new BeanDefinitionHolder(beanDefinition, beanName);
        beanDefinitionHolders.add(beanDefinitionHolder);
    }
    return beanDefinitionHolders;
}

/**
 * Register a {@link org.springframework.beans.factory.config.BeanDefinition} for
 * any clreplacedes specified by {@link #register(Clreplaced...)} and scan any packages
 * specified by {@link #scan(String...)}.
 * <p>For any values specified by {@link #setConfigLocation(String)} or
 * {@link #setConfigLocations(String[])}, attempt first to load each location as a
 * clreplaced, registering a {@code BeanDefinition} if clreplaced loading is successful,
 * and if clreplaced loading fails (i.e. a {@code ClreplacedNotFoundException} is raised),
 * replacedume the value is a package and attempt to scan it for annotated clreplacedes.
 * <p>Enables the default set of annotation configuration post processors, such that
 * {@code @Autowired}, {@code @Required}, and replacedociated annotations can be used.
 * <p>Configuration clreplaced bean definitions are registered with generated bean
 * definition names unless the {@code value} attribute is provided to the stereotype
 * annotation.
 * @param beanFactory the bean factory to load bean definitions into
 * @see #register(Clreplaced...)
 * @see #scan(String...)
 * @see #setConfigLocation(String)
 * @see #setConfigLocations(String[])
 * @see AnnotatedBeanDefinitionReader
 * @see ClreplacedPathBeanDefinitionScanner
 */
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) {
    AnnotatedBeanDefinitionReader reader = getAnnotatedBeanDefinitionReader(beanFactory);
    ClreplacedPathBeanDefinitionScanner scanner = getClreplacedPathBeanDefinitionScanner(beanFactory);
    BeanNameGenerator beanNameGenerator = getBeanNameGenerator();
    if (beanNameGenerator != null) {
        reader.setBeanNameGenerator(beanNameGenerator);
        scanner.setBeanNameGenerator(beanNameGenerator);
        beanFactory.registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);
    }
    ScopeMetadataResolver scopeMetadataResolver = getScopeMetadataResolver();
    if (scopeMetadataResolver != null) {
        reader.setScopeMetadataResolver(scopeMetadataResolver);
        scanner.setScopeMetadataResolver(scopeMetadataResolver);
    }
    if (!this.annotatedClreplacedes.isEmpty()) {
        if (logger.isInfoEnabled()) {
            logger.info("Registering annotated clreplacedes: [" + StringUtils.collectionToCommaDelimitedString(this.annotatedClreplacedes) + "]");
        }
        reader.register(this.annotatedClreplacedes.toArray(new Clreplaced<?>[this.annotatedClreplacedes.size()]));
    }
    if (!this.basePackages.isEmpty()) {
        if (logger.isInfoEnabled()) {
            logger.info("Scanning base packages: [" + StringUtils.collectionToCommaDelimitedString(this.basePackages) + "]");
        }
        scanner.scan(this.basePackages.toArray(new String[this.basePackages.size()]));
    }
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        for (String configLocation : configLocations) {
            try {
                Clreplaced<?> clazz = getClreplacedLoader().loadClreplaced(configLocation);
                if (logger.isInfoEnabled()) {
                    logger.info("Successfully resolved clreplaced for [" + configLocation + "]");
                }
                reader.register(clazz);
            } catch (ClreplacedNotFoundException ex) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Could not load clreplaced for config location [" + configLocation + "] - trying package scan. " + ex);
                }
                int count = scanner.scan(configLocation);
                if (logger.isInfoEnabled()) {
                    if (count == 0) {
                        logger.info("No annotated clreplacedes found for specified clreplaced/package [" + configLocation + "]");
                    } else {
                        logger.info("Found " + count + " annotated clreplacedes in package [" + configLocation + "]");
                    }
                }
            }
        }
    }
}

/**
 * 处理rpc扫描的包下的clreplaced类
 *
 * @param packages 包集合
 * @param registry 注册中心
 */
protected void processPackages(Set<String> packages, BeanDefinitionRegistry registry) {
    // 构造
    ClreplacedPathBeanDefinitionScanner scanner = new ClreplacedPathBeanDefinitionScanner(registry, false, environment, resourceLoader);
    registerAnnotationConfigProcessors(registry);
    scanner.addIncludeFilter(new AnnotationFilter());
    // 获取配置的rpc扫描包下的所有bean定义
    for (String basePackage : packages) {
        Set<BeanDefinition> definitions = scanner.findCandidateComponents(basePackage);
        if (!CollectionUtils.isEmpty(definitions)) {
            for (BeanDefinition definition : definitions) {
                processConsumerAnnotation(definition);
                processProviderAnnotation(definition, registry);
            }
        }
    }
}

/**
 * Finds a {@link Set} of {@link BeanDefinitionHolder BeanDefinitionHolders} whose bean type annotated
 * {@link Service} Annotation.找到一组beandefinitionholder，其bean类型注释了服务注释。
 *
 * @param scanner       {@link ClreplacedPathBeanDefinitionScanner}
 * @param packageToScan pachage to scan
 * @param registry      {@link BeanDefinitionRegistry}
 * @return non-null
 * @since 2.5.8
 */
private Set<BeanDefinitionHolder> findServiceBeanDefinitionHolders(ClreplacedPathBeanDefinitionScanner scanner, String packageToScan, BeanDefinitionRegistry registry, BeanNameGenerator beanNameGenerator) {
    Set<BeanDefinition> beanDefinitions = scanner.findCandidateComponents(packageToScan);
    Set<BeanDefinitionHolder> beanDefinitionHolders = new LinkedHashSet<BeanDefinitionHolder>(beanDefinitions.size());
    for (BeanDefinition beanDefinition : beanDefinitions) {
        String beanName = beanNameGenerator.generateBeanName(beanDefinition, registry);
        BeanDefinitionHolder beanDefinitionHolder = new BeanDefinitionHolder(beanDefinition, beanName);
        beanDefinitionHolders.add(beanDefinitionHolder);
    }
    return beanDefinitionHolders;
}

/**
 * Finds a {@link Set} of {@link BeanDefinitionHolder BeanDefinitionHolders} whose bean type annotated
 * {@link Service} Annotation.
 *
 * @param scanner       {@link ClreplacedPathBeanDefinitionScanner}
 * @param packageToScan package to scan
 * @param registry      {@link BeanDefinitionRegistry}
 * @return non-null
 * @since 2.5.8
 */
private Set<BeanDefinitionHolder> findServiceBeanDefinitionHolders(ClreplacedPathBeanDefinitionScanner scanner, String packageToScan, BeanDefinitionRegistry registry, BeanNameGenerator beanNameGenerator) {
    Set<BeanDefinition> beanDefinitions = scanner.findCandidateComponents(packageToScan);
    Set<BeanDefinitionHolder> beanDefinitionHolders = new LinkedHashSet<BeanDefinitionHolder>(beanDefinitions.size());
    for (BeanDefinition beanDefinition : beanDefinitions) {
        String beanName = beanNameGenerator.generateBeanName(beanDefinition, registry);
        BeanDefinitionHolder beanDefinitionHolder = new BeanDefinitionHolder(beanDefinition, beanName);
        beanDefinitionHolders.add(beanDefinitionHolder);
    }
    return beanDefinitionHolders;
}

/**
 * Finds a {@link Set} of {@link BeanDefinitionHolder BeanDefinitionHolders}
 *
 * @param scanner           {@link ClreplacedPathBeanDefinitionScanner}
 * @param packageToScan     package to scan
 * @param registry          {@link BeanDefinitionRegistry}
 * @param beanNameGenerator {@link BeanNameGenerator}
 * @return non-null
 */
public static Set<BeanDefinitionHolder> findBeanDefinitionHolders(ClreplacedPathBeanDefinitionScanner scanner, String packageToScan, BeanDefinitionRegistry registry, BeanNameGenerator beanNameGenerator) {
    Set<BeanDefinition> beanDefinitions = scanner.findCandidateComponents(packageToScan);
    Set<BeanDefinitionHolder> beanDefinitionHolders = new LinkedHashSet<BeanDefinitionHolder>(beanDefinitions.size());
    for (BeanDefinition beanDefinition : beanDefinitions) {
        String beanName = beanNameGenerator.generateBeanName(beanDefinition, registry);
        BeanDefinitionHolder beanDefinitionHolder = new BeanDefinitionHolder(beanDefinition, beanName);
        beanDefinitionHolders.add(beanDefinitionHolder);
    }
    return beanDefinitionHolders;
}

/**
 * {@link ServletWebServerApplicationContext} that accepts annotated clreplacedes as input - in
 * particular {@link org.springframework.context.annotation.Configuration @Configuration}
 * -annotated clreplacedes, but also plain {@link Component @Component} clreplacedes and JSR-330
 * compliant clreplacedes using {@code javax.inject} annotations. Allows for registering
 * clreplacedes one by one (specifying clreplaced names as config location) as well as for clreplacedpath
 * scanning (specifying base packages as config location).
 * <p>
 * Note: In case of multiple {@code @Configuration} clreplacedes, later {@code @Bean}
 * definitions will override ones defined in earlier loaded files. This can be leveraged
 * to deliberately override certain bean definitions via an extra Configuration clreplaced.
 *
 * @author Phillip Webb
 * @see #register(Clreplaced...)
 * @see #scan(String...)
 * @see ServletWebServerApplicationContext
 * @see AnnotationConfigWebApplicationContext
 */
public clreplaced AnnotationConfigServletWebServerApplicationContext extends ServletWebServerApplicationContext implements AnnotationConfigRegistry {

    private final AnnotatedBeanDefinitionReader reader;

    private final ClreplacedPathBeanDefinitionScanner scanner;

    private final Set<Clreplaced<?>> annotatedClreplacedes = new LinkedHashSet<>();

    private String[] basePackages;

    /**
     * Create a new {@link AnnotationConfigServletWebServerApplicationContext} that needs
     * to be populated through {@link #register} calls and then manually
     * {@linkplain #refresh refreshed}.
     */
    public AnnotationConfigServletWebServerApplicationContext() {
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClreplacedPathBeanDefinitionScanner(this);
    }

    /**
     * Create a new {@link AnnotationConfigServletWebServerApplicationContext} with the
     * given {@code DefaultListableBeanFactory}. The context needs to be populated through
     * {@link #register} calls and then manually {@linkplain #refresh refreshed}.
     * @param beanFactory the DefaultListableBeanFactory instance to use for this context
     */
    public AnnotationConfigServletWebServerApplicationContext(DefaultListableBeanFactory beanFactory) {
        super(beanFactory);
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClreplacedPathBeanDefinitionScanner(this);
    }

    /**
     * Create a new {@link AnnotationConfigServletWebServerApplicationContext}, deriving
     * bean definitions from the given annotated clreplacedes and automatically refreshing the
     * context.
     * @param annotatedClreplacedes one or more annotated clreplacedes, e.g. {@code @Configuration}
     * clreplacedes
     */
    public AnnotationConfigServletWebServerApplicationContext(Clreplaced<?>... annotatedClreplacedes) {
        this();
        register(annotatedClreplacedes);
        refresh();
    }

    /**
     * Create a new {@link AnnotationConfigServletWebServerApplicationContext}, scanning
     * for bean definitions in the given packages and automatically refreshing the
     * context.
     * @param basePackages the packages to check for annotated clreplacedes
     */
    public AnnotationConfigServletWebServerApplicationContext(String... basePackages) {
        this();
        scan(basePackages);
        refresh();
    }

    /**
     * {@inheritDoc}
     * <p>
     * Delegates given environment to underlying {@link AnnotatedBeanDefinitionReader} and
     * {@link ClreplacedPathBeanDefinitionScanner} members.
     */
    @Override
    public void setEnvironment(ConfigurableEnvironment environment) {
        super.setEnvironment(environment);
        this.reader.setEnvironment(environment);
        this.scanner.setEnvironment(environment);
    }

    /**
     * Provide a custom {@link BeanNameGenerator} for use with
     * {@link AnnotatedBeanDefinitionReader} and/or
     * {@link ClreplacedPathBeanDefinitionScanner}, if any.
     * <p>
     * Default is
     * {@link org.springframework.context.annotation.AnnotationBeanNameGenerator}.
     * <p>
     * Any call to this method must occur prior to calls to {@link #register(Clreplaced...)}
     * and/or {@link #scan(String...)}.
     * @param beanNameGenerator the bean name generator
     * @see AnnotatedBeanDefinitionReader#setBeanNameGenerator
     * @see ClreplacedPathBeanDefinitionScanner#setBeanNameGenerator
     */
    public void setBeanNameGenerator(BeanNameGenerator beanNameGenerator) {
        this.reader.setBeanNameGenerator(beanNameGenerator);
        this.scanner.setBeanNameGenerator(beanNameGenerator);
        this.getBeanFactory().registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);
    }

    /**
     * Set the {@link ScopeMetadataResolver} to use for detected bean clreplacedes.
     * <p>
     * The default is an {@link AnnotationScopeMetadataResolver}.
     * <p>
     * Any call to this method must occur prior to calls to {@link #register(Clreplaced...)}
     * and/or {@link #scan(String...)}.
     * @param scopeMetadataResolver the scope metadata resolver
     */
    public void setScopeMetadataResolver(ScopeMetadataResolver scopeMetadataResolver) {
        this.reader.setScopeMetadataResolver(scopeMetadataResolver);
        this.scanner.setScopeMetadataResolver(scopeMetadataResolver);
    }

    /**
     * Register one or more annotated clreplacedes to be processed. Note that
     * {@link #refresh()} must be called in order for the context to fully process the new
     * clreplaced.
     * <p>
     * Calls to {@code #register} are idempotent; adding the same annotated clreplaced more
     * than once has no additional effect.
     * @param annotatedClreplacedes one or more annotated clreplacedes, e.g. {@code @Configuration}
     * clreplacedes
     * @see #scan(String...)
     * @see #refresh()
     */
    @Override
    public final void register(Clreplaced<?>... annotatedClreplacedes) {
        replacedert.notEmpty(annotatedClreplacedes, "At least one annotated clreplaced must be specified");
        this.annotatedClreplacedes.addAll(Arrays.asList(annotatedClreplacedes));
    }

    /**
     * Perform a scan within the specified base packages. Note that {@link #refresh()}
     * must be called in order for the context to fully process the new clreplaced.
     * @param basePackages the packages to check for annotated clreplacedes
     * @see #register(Clreplaced...)
     * @see #refresh()
     */
    @Override
    public final void scan(String... basePackages) {
        replacedert.notEmpty(basePackages, "At least one base package must be specified");
        this.basePackages = basePackages;
    }

    @Override
    protected void prepareRefresh() {
        this.scanner.clearCache();
        super.prepareRefresh();
    }

    @Override
    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        super.postProcessBeanFactory(beanFactory);
        if (this.basePackages != null && this.basePackages.length > 0) {
            this.scanner.scan(this.basePackages);
        }
        if (!this.annotatedClreplacedes.isEmpty()) {
            this.reader.register(ClreplacedUtils.toClreplacedArray(this.annotatedClreplacedes));
        }
    }
}

/**
 * {@link ReactiveWebServerApplicationContext} that accepts annotated clreplacedes as input -
 * in particular
 * {@link org.springframework.context.annotation.Configuration @Configuration}-annotated
 * clreplacedes, but also plain {@link Component @Component} clreplacedes and JSR-330 compliant
 * clreplacedes using {@code javax.inject} annotations. Allows for registering clreplacedes one by
 * one (specifying clreplaced names as config location) as well as for clreplacedpath scanning
 * (specifying base packages as config location).
 * <p>
 * Note: In case of multiple {@code @Configuration} clreplacedes, later {@code @Bean}
 * definitions will override ones defined in earlier loaded files. This can be leveraged
 * to deliberately override certain bean definitions via an extra Configuration clreplaced.
 *
 * @author Phillip Webb
 * @since 2.0.0
 * @see #register(Clreplaced...)
 * @see #scan(String...)
 * @see ReactiveWebServerApplicationContext
 * @see AnnotationConfigApplicationContext
 */
public clreplaced AnnotationConfigReactiveWebServerApplicationContext extends ReactiveWebServerApplicationContext implements AnnotationConfigRegistry {

    private final AnnotatedBeanDefinitionReader reader;

    private final ClreplacedPathBeanDefinitionScanner scanner;

    private final Set<Clreplaced<?>> annotatedClreplacedes = new LinkedHashSet<>();

    private String[] basePackages;

    /**
     * Create a new {@link AnnotationConfigReactiveWebServerApplicationContext} that needs
     * to be populated through {@link #register} calls and then manually
     * {@linkplain #refresh refreshed}.
     */
    public AnnotationConfigReactiveWebServerApplicationContext() {
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClreplacedPathBeanDefinitionScanner(this);
    }

    /**
     * Create a new {@link AnnotationConfigReactiveWebServerApplicationContext} with the
     * given {@code DefaultListableBeanFactory}. The context needs to be populated through
     * {@link #register} calls and then manually {@linkplain #refresh refreshed}.
     * @param beanFactory the DefaultListableBeanFactory instance to use for this context
     */
    public AnnotationConfigReactiveWebServerApplicationContext(DefaultListableBeanFactory beanFactory) {
        super(beanFactory);
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClreplacedPathBeanDefinitionScanner(this);
    }

    /**
     * Create a new {@link AnnotationConfigReactiveWebServerApplicationContext}, deriving
     * bean definitions from the given annotated clreplacedes and automatically refreshing the
     * context.
     * @param annotatedClreplacedes one or more annotated clreplacedes, e.g. {@code @Configuration}
     * clreplacedes
     */
    public AnnotationConfigReactiveWebServerApplicationContext(Clreplaced<?>... annotatedClreplacedes) {
        this();
        register(annotatedClreplacedes);
        refresh();
    }

    /**
     * Create a new {@link AnnotationConfigReactiveWebServerApplicationContext}, scanning
     * for bean definitions in the given packages and automatically refreshing the
     * context.
     * @param basePackages the packages to check for annotated clreplacedes
     */
    public AnnotationConfigReactiveWebServerApplicationContext(String... basePackages) {
        this();
        scan(basePackages);
        refresh();
    }

    /**
     * {@inheritDoc}
     * <p>
     * Delegates given environment to underlying {@link AnnotatedBeanDefinitionReader} and
     * {@link ClreplacedPathBeanDefinitionScanner} members.
     */
    @Override
    public void setEnvironment(ConfigurableEnvironment environment) {
        super.setEnvironment(environment);
        this.reader.setEnvironment(environment);
        this.scanner.setEnvironment(environment);
    }

    /**
     * Provide a custom {@link BeanNameGenerator} for use with
     * {@link AnnotatedBeanDefinitionReader} and/or
     * {@link ClreplacedPathBeanDefinitionScanner}, if any.
     * <p>
     * Default is
     * {@link org.springframework.context.annotation.AnnotationBeanNameGenerator}.
     * <p>
     * Any call to this method must occur prior to calls to {@link #register(Clreplaced...)}
     * and/or {@link #scan(String...)}.
     * @param beanNameGenerator the bean name generator
     * @see AnnotatedBeanDefinitionReader#setBeanNameGenerator
     * @see ClreplacedPathBeanDefinitionScanner#setBeanNameGenerator
     */
    public void setBeanNameGenerator(BeanNameGenerator beanNameGenerator) {
        this.reader.setBeanNameGenerator(beanNameGenerator);
        this.scanner.setBeanNameGenerator(beanNameGenerator);
        this.getBeanFactory().registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);
    }

    /**
     * Set the {@link ScopeMetadataResolver} to use for detected bean clreplacedes.
     * <p>
     * The default is an {@link AnnotationScopeMetadataResolver}.
     * <p>
     * Any call to this method must occur prior to calls to {@link #register(Clreplaced...)}
     * and/or {@link #scan(String...)}.
     * @param scopeMetadataResolver the scope metadata resolver
     */
    public void setScopeMetadataResolver(ScopeMetadataResolver scopeMetadataResolver) {
        this.reader.setScopeMetadataResolver(scopeMetadataResolver);
        this.scanner.setScopeMetadataResolver(scopeMetadataResolver);
    }

    /**
     * Register one or more annotated clreplacedes to be processed. Note that
     * {@link #refresh()} must be called in order for the context to fully process the new
     * clreplaced.
     * <p>
     * Calls to {@code #register} are idempotent; adding the same annotated clreplaced more
     * than once has no additional effect.
     * @param annotatedClreplacedes one or more annotated clreplacedes, e.g. {@code @Configuration}
     * clreplacedes
     * @see #scan(String...)
     * @see #refresh()
     */
    @Override
    public final void register(Clreplaced<?>... annotatedClreplacedes) {
        replacedert.notEmpty(annotatedClreplacedes, "At least one annotated clreplaced must be specified");
        this.annotatedClreplacedes.addAll(Arrays.asList(annotatedClreplacedes));
    }

    /**
     * Perform a scan within the specified base packages. Note that {@link #refresh()}
     * must be called in order for the context to fully process the new clreplaced.
     * @param basePackages the packages to check for annotated clreplacedes
     * @see #register(Clreplaced...)
     * @see #refresh()
     */
    @Override
    public final void scan(String... basePackages) {
        replacedert.notEmpty(basePackages, "At least one base package must be specified");
        this.basePackages = basePackages;
    }

    @Override
    protected void prepareRefresh() {
        this.scanner.clearCache();
        super.prepareRefresh();
    }

    @Override
    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        super.postProcessBeanFactory(beanFactory);
        if (!ObjectUtils.isEmpty(this.basePackages)) {
            this.scanner.scan(this.basePackages);
        }
        if (!this.annotatedClreplacedes.isEmpty()) {
            this.reader.register(ClreplacedUtils.toClreplacedArray(this.annotatedClreplacedes));
        }
    }
}

private ApplicationContext createContext(ScopedProxyMode scopedProxyMode) {
    GenericWebApplicationContext context = new GenericWebApplicationContext();
    ClreplacedPathBeanDefinitionScanner scanner = new ClreplacedPathBeanDefinitionScanner(context);
    scanner.setIncludeAnnotationConfig(false);
    scanner.setBeanNameGenerator((definition, registry) -> definition.getScope());
    scanner.setScopedProxyMode(scopedProxyMode);
    // Scan twice in order to find errors in the bean definition compatibility check.
    scanner.scan(getClreplaced().getPackage().getName());
    scanner.scan(getClreplaced().getPackage().getName());
    context.refresh();
    return context;
}

private ApplicationContext createContext(final ScopedProxyMode scopedProxyMode) {
    GenericWebApplicationContext context = new GenericWebApplicationContext();
    ClreplacedPathBeanDefinitionScanner scanner = new ClreplacedPathBeanDefinitionScanner(context);
    scanner.setIncludeAnnotationConfig(false);
    scanner.setScopeMetadataResolver(new ScopeMetadataResolver() {

        @Override
        public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) {
            ScopeMetadata metadata = new ScopeMetadata();
            if (definition instanceof AnnotatedBeanDefinition) {
                AnnotatedBeanDefinition annDef = (AnnotatedBeanDefinition) definition;
                for (String type : annDef.getMetadata().getAnnotationTypes()) {
                    if (type.equals(javax.inject.Singleton.clreplaced.getName())) {
                        metadata.setScopeName(BeanDefinition.SCOPE_SINGLETON);
                        break;
                    } else if (annDef.getMetadata().getMetaAnnotationTypes(type).contains(javax.inject.Scope.clreplaced.getName())) {
                        metadata.setScopeName(type.substring(type.length() - 13, type.length() - 6).toLowerCase());
                        metadata.setScopedProxyMode(scopedProxyMode);
                        break;
                    } else if (type.startsWith("javax.inject")) {
                        metadata.setScopeName(BeanDefinition.SCOPE_PROTOTYPE);
                    }
                }
            }
            return metadata;
        }
    });
    // Scan twice in order to find errors in the bean definition compatibility check.
    scanner.scan(getClreplaced().getPackage().getName());
    scanner.scan(getClreplaced().getPackage().getName());
    context.registerAlias("clreplacedPathBeanDefinitionScannerJsr330ScopeIntegrationTests.SessionScopedTestBean", "session");
    context.refresh();
    return context;
}

/**
 * Register a {@link org.springframework.beans.factory.config.BeanDefinition} for
 * any clreplacedes specified by {@link #register(Clreplaced...)} and scan any packages
 * specified by {@link #scan(String...)}.
 * <p>For any values specified by {@link #setConfigLocation(String)} or
 * {@link #setConfigLocations(String[])}, attempt first to load each location as a
 * clreplaced, registering a {@code BeanDefinition} if clreplaced loading is successful,
 * and if clreplaced loading fails (i.e. a {@code ClreplacedNotFoundException} is raised),
 * replacedume the value is a package and attempt to scan it for annotated clreplacedes.
 * <p>Enables the default set of annotation configuration post processors, such that
 * {@code @Autowired}, {@code @Required}, and replacedociated annotations can be used.
 * <p>Configuration clreplaced bean definitions are registered with generated bean
 * definition names unless the {@code value} attribute is provided to the stereotype
 * annotation.
 * @param beanFactory the bean factory to load bean definitions into
 * @see #register(Clreplaced...)
 * @see #scan(String...)
 * @see #setConfigLocation(String)
 * @see #setConfigLocations(String[])
 * @see AnnotatedBeanDefinitionReader
 * @see ClreplacedPathBeanDefinitionScanner
 */
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) {
    AnnotatedBeanDefinitionReader reader = getAnnotatedBeanDefinitionReader(beanFactory);
    ClreplacedPathBeanDefinitionScanner scanner = getClreplacedPathBeanDefinitionScanner(beanFactory);
    BeanNameGenerator beanNameGenerator = getBeanNameGenerator();
    if (beanNameGenerator != null) {
        reader.setBeanNameGenerator(beanNameGenerator);
        scanner.setBeanNameGenerator(beanNameGenerator);
        beanFactory.registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);
    }
    ScopeMetadataResolver scopeMetadataResolver = getScopeMetadataResolver();
    if (scopeMetadataResolver != null) {
        reader.setScopeMetadataResolver(scopeMetadataResolver);
        scanner.setScopeMetadataResolver(scopeMetadataResolver);
    }
    if (!this.annotatedClreplacedes.isEmpty()) {
        if (logger.isDebugEnabled()) {
            logger.debug("Registering annotated clreplacedes: [" + StringUtils.collectionToCommaDelimitedString(this.annotatedClreplacedes) + "]");
        }
        reader.register(ClreplacedUtils.toClreplacedArray(this.annotatedClreplacedes));
    }
    if (!this.basePackages.isEmpty()) {
        if (logger.isDebugEnabled()) {
            logger.debug("Scanning base packages: [" + StringUtils.collectionToCommaDelimitedString(this.basePackages) + "]");
        }
        scanner.scan(StringUtils.toStringArray(this.basePackages));
    }
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        for (String configLocation : configLocations) {
            try {
                Clreplaced<?> clazz = ClreplacedUtils.forName(configLocation, getClreplacedLoader());
                if (logger.isTraceEnabled()) {
                    logger.trace("Registering [" + configLocation + "]");
                }
                reader.register(clazz);
            } catch (ClreplacedNotFoundException ex) {
                if (logger.isTraceEnabled()) {
                    logger.trace("Could not load clreplaced for config location [" + configLocation + "] - trying package scan. " + ex);
                }
                int count = scanner.scan(configLocation);
                if (count == 0 && logger.isDebugEnabled()) {
                    logger.debug("No annotated clreplacedes found for specified clreplaced/package [" + configLocation + "]");
                }
            }
        }
    }
}

/**
 * Register a {@link org.springframework.beans.factory.config.BeanDefinition} for
 * any clreplacedes specified by {@link #register(Clreplaced...)} and scan any packages
 * specified by {@link #scan(String...)}.
 * <p>For any values specified by {@link #setConfigLocation(String)} or
 * {@link #setConfigLocations(String[])}, attempt first to load each location as a
 * clreplaced, registering a {@code BeanDefinition} if clreplaced loading is successful,
 * and if clreplaced loading fails (i.e. a {@code ClreplacedNotFoundException} is raised),
 * replacedume the value is a package and attempt to scan it for component clreplacedes.
 * <p>Enables the default set of annotation configuration post processors, such that
 * {@code @Autowired}, {@code @Required}, and replacedociated annotations can be used.
 * <p>Configuration clreplaced bean definitions are registered with generated bean
 * definition names unless the {@code value} attribute is provided to the stereotype
 * annotation.
 * @param beanFactory the bean factory to load bean definitions into
 * @see #register(Clreplaced...)
 * @see #scan(String...)
 * @see #setConfigLocation(String)
 * @see #setConfigLocations(String[])
 * @see AnnotatedBeanDefinitionReader
 * @see ClreplacedPathBeanDefinitionScanner
 */
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) {
    AnnotatedBeanDefinitionReader reader = getAnnotatedBeanDefinitionReader(beanFactory);
    ClreplacedPathBeanDefinitionScanner scanner = getClreplacedPathBeanDefinitionScanner(beanFactory);
    BeanNameGenerator beanNameGenerator = getBeanNameGenerator();
    if (beanNameGenerator != null) {
        reader.setBeanNameGenerator(beanNameGenerator);
        scanner.setBeanNameGenerator(beanNameGenerator);
        beanFactory.registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);
    }
    ScopeMetadataResolver scopeMetadataResolver = getScopeMetadataResolver();
    if (scopeMetadataResolver != null) {
        reader.setScopeMetadataResolver(scopeMetadataResolver);
        scanner.setScopeMetadataResolver(scopeMetadataResolver);
    }
    if (!this.componentClreplacedes.isEmpty()) {
        if (logger.isDebugEnabled()) {
            logger.debug("Registering component clreplacedes: [" + StringUtils.collectionToCommaDelimitedString(this.componentClreplacedes) + "]");
        }
        reader.register(ClreplacedUtils.toClreplacedArray(this.componentClreplacedes));
    }
    if (!this.basePackages.isEmpty()) {
        if (logger.isDebugEnabled()) {
            logger.debug("Scanning base packages: [" + StringUtils.collectionToCommaDelimitedString(this.basePackages) + "]");
        }
        scanner.scan(StringUtils.toStringArray(this.basePackages));
    }
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        for (String configLocation : configLocations) {
            try {
                Clreplaced<?> clazz = ClreplacedUtils.forName(configLocation, getClreplacedLoader());
                if (logger.isTraceEnabled()) {
                    logger.trace("Registering [" + configLocation + "]");
                }
                reader.register(clazz);
            } catch (ClreplacedNotFoundException ex) {
                if (logger.isTraceEnabled()) {
                    logger.trace("Could not load clreplaced for config location [" + configLocation + "] - trying package scan. " + ex);
                }
                int count = scanner.scan(configLocation);
                if (count == 0 && logger.isDebugEnabled()) {
                    logger.debug("No component clreplacedes found for specified clreplaced/package [" + configLocation + "]");
                }
            }
        }
    }
}

private ApplicationContext createContext(ScopedProxyMode scopedProxyMode) {
    GenericWebApplicationContext context = new GenericWebApplicationContext();
    ClreplacedPathBeanDefinitionScanner scanner = new ClreplacedPathBeanDefinitionScanner(context);
    scanner.setIncludeAnnotationConfig(false);
    scanner.setBeanNameGenerator(new BeanNameGenerator() {

        @Override
        public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
            return definition.getScope();
        }
    });
    scanner.setScopedProxyMode(scopedProxyMode);
    // Scan twice in order to find errors in the bean definition compatibility check.
    scanner.scan(getClreplaced().getPackage().getName());
    scanner.scan(getClreplaced().getPackage().getName());
    context.refresh();
    return context;
}

public synchronized static void create(ApplicationContext applicationContext) {
    DoradoServerBuilder builder = Dorado.serverConfig;
    if (builder == null) {
        throw new IllegalStateException("Please init DoradoServer first!");
    }
    if (!(applicationContext instanceof DoradoApplicationContext) && (applicationContext instanceof BeanDefinitionRegistry)) {
        ClreplacedPathBeanDefinitionScanner scanner = new ClreplacedPathBeanDefinitionScanner((BeanDefinitionRegistry) applicationContext);
        scanner.resetFilters(false);
        scanner.addIncludeFilter(new AnnotationTypeFilter(Controller.clreplaced));
        scanner.scan(builder.scanPackages());
    }
    instance = new SpringContainer(applicationContext);
    Dorado.springInitialized = true;
}

/**
 * {@link ServletWebServerApplicationContext} that accepts annotated clreplacedes as input - in
 * particular {@link org.springframework.context.annotation.Configuration @Configuration}
 * -annotated clreplacedes, but also plain {@link Component @Component} clreplacedes and JSR-330
 * compliant clreplacedes using {@code javax.inject} annotations. Allows for registering
 * clreplacedes one by one (specifying clreplaced names as config location) as well as for clreplacedpath
 * scanning (specifying base packages as config location).
 * <p>
 * Note: In case of multiple {@code @Configuration} clreplacedes, later {@code @Bean}
 * definitions will override ones defined in earlier loaded files. This can be leveraged
 * to deliberately override certain bean definitions via an extra Configuration clreplaced.
 *
 * @author Phillip Webb
 * @see #register(Clreplaced...)
 * @see #scan(String...)
 * @see ServletWebServerApplicationContext
 * @see AnnotationConfigWebApplicationContext
 */
public clreplaced AnnotationConfigServletWebServerApplicationContext extends ServletWebServerApplicationContext implements AnnotationConfigRegistry {

    private final AnnotatedBeanDefinitionReader reader;

    private final ClreplacedPathBeanDefinitionScanner scanner;

    private final Set<Clreplaced<?>> annotatedClreplacedes = new LinkedHashSet<>();

    private String[] basePackages;

    /**
     * Create a new {@link AnnotationConfigServletWebServerApplicationContext} that needs
     * to be populated through {@link #register} calls and then manually
     * {@linkplain #refresh refreshed}.
     */
    public AnnotationConfigServletWebServerApplicationContext() {
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClreplacedPathBeanDefinitionScanner(this);
    }

    /**
     * Create a new {@link AnnotationConfigServletWebServerApplicationContext} with the
     * given {@code DefaultListableBeanFactory}. The context needs to be populated through
     * {@link #register} calls and then manually {@linkplain #refresh refreshed}.
     *
     * @param beanFactory the DefaultListableBeanFactory instance to use for this context
     */
    public AnnotationConfigServletWebServerApplicationContext(DefaultListableBeanFactory beanFactory) {
        super(beanFactory);
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClreplacedPathBeanDefinitionScanner(this);
    }

    /**
     * Create a new {@link AnnotationConfigServletWebServerApplicationContext}, deriving
     * bean definitions from the given annotated clreplacedes and automatically refreshing the
     * context.
     *
     * @param annotatedClreplacedes one or more annotated clreplacedes, e.g. {@code @Configuration}
     *                         clreplacedes
     */
    public AnnotationConfigServletWebServerApplicationContext(Clreplaced<?>... annotatedClreplacedes) {
        this();
        register(annotatedClreplacedes);
        refresh();
    }

    /**
     * Create a new {@link AnnotationConfigServletWebServerApplicationContext}, scanning
     * for bean definitions in the given packages and automatically refreshing the
     * context.
     *
     * @param basePackages the packages to check for annotated clreplacedes
     */
    public AnnotationConfigServletWebServerApplicationContext(String... basePackages) {
        this();
        scan(basePackages);
        refresh();
    }

    /**
     * {@inheritDoc}
     * <p>
     * Delegates given environment to underlying {@link AnnotatedBeanDefinitionReader} and
     * {@link ClreplacedPathBeanDefinitionScanner} members.
     */
    @Override
    public void setEnvironment(ConfigurableEnvironment environment) {
        super.setEnvironment(environment);
        this.reader.setEnvironment(environment);
        this.scanner.setEnvironment(environment);
    }

    /**
     * Provide a custom {@link BeanNameGenerator} for use with
     * {@link AnnotatedBeanDefinitionReader} and/or
     * {@link ClreplacedPathBeanDefinitionScanner}, if any.
     * <p>
     * Default is
     * {@link org.springframework.context.annotation.AnnotationBeanNameGenerator}.
     * <p>
     * Any call to this method must occur prior to calls to {@link #register(Clreplaced...)}
     * and/or {@link #scan(String...)}.
     *
     * @param beanNameGenerator the bean name generator
     * @see AnnotatedBeanDefinitionReader#setBeanNameGenerator
     * @see ClreplacedPathBeanDefinitionScanner#setBeanNameGenerator
     */
    public void setBeanNameGenerator(BeanNameGenerator beanNameGenerator) {
        this.reader.setBeanNameGenerator(beanNameGenerator);
        this.scanner.setBeanNameGenerator(beanNameGenerator);
        this.getBeanFactory().registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);
    }

    /**
     * Set the {@link ScopeMetadataResolver} to use for detected bean clreplacedes.
     * <p>
     * The default is an {@link AnnotationScopeMetadataResolver}.
     * <p>
     * Any call to this method must occur prior to calls to {@link #register(Clreplaced...)}
     * and/or {@link #scan(String...)}.
     *
     * @param scopeMetadataResolver the scope metadata resolver
     */
    public void setScopeMetadataResolver(ScopeMetadataResolver scopeMetadataResolver) {
        this.reader.setScopeMetadataResolver(scopeMetadataResolver);
        this.scanner.setScopeMetadataResolver(scopeMetadataResolver);
    }

    /**
     * Register one or more annotated clreplacedes to be processed. Note that
     * {@link #refresh()} must be called in order for the context to fully process the new
     * clreplaced.
     * <p>
     * Calls to {@code #register} are idempotent; adding the same annotated clreplaced more
     * than once has no additional effect.
     *
     * @param annotatedClreplacedes one or more annotated clreplacedes, e.g. {@code @Configuration}
     *                         clreplacedes
     * @see #scan(String...)
     * @see #refresh()
     */
    @Override
    public final void register(Clreplaced<?>... annotatedClreplacedes) {
        replacedert.notEmpty(annotatedClreplacedes, "At least one annotated clreplaced must be specified");
        this.annotatedClreplacedes.addAll(Arrays.asList(annotatedClreplacedes));
    }

    /**
     * Perform a scan within the specified base packages. Note that {@link #refresh()}
     * must be called in order for the context to fully process the new clreplaced.
     *
     * @param basePackages the packages to check for annotated clreplacedes
     * @see #register(Clreplaced...)
     * @see #refresh()
     */
    @Override
    public final void scan(String... basePackages) {
        replacedert.notEmpty(basePackages, "At least one base package must be specified");
        this.basePackages = basePackages;
    }

    @Override
    protected void prepareRefresh() {
        this.scanner.clearCache();
        super.prepareRefresh();
    }

    @Override
    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        super.postProcessBeanFactory(beanFactory);
        if (this.basePackages != null && this.basePackages.length > 0) {
            this.scanner.scan(this.basePackages);
        }
        if (!this.annotatedClreplacedes.isEmpty()) {
            this.reader.register(ClreplacedUtils.toClreplacedArray(this.annotatedClreplacedes));
        }
    }
}

/**
 * {@link ReactiveWebServerApplicationContext} that accepts annotated clreplacedes as input -
 * in particular
 * {@link org.springframework.context.annotation.Configuration @Configuration}-annotated
 * clreplacedes, but also plain {@link Component @Component} clreplacedes and JSR-330 compliant
 * clreplacedes using {@code javax.inject} annotations. Allows for registering clreplacedes one by
 * one (specifying clreplaced names as config location) as well as for clreplacedpath scanning
 * (specifying base packages as config location).
 * <p>
 * Note: In case of multiple {@code @Configuration} clreplacedes, later {@code @Bean}
 * definitions will override ones defined in earlier loaded files. This can be leveraged
 * to deliberately override certain bean definitions via an extra Configuration clreplaced.
 *
 * @author Phillip Webb
 * @see #register(Clreplaced...)
 * @see #scan(String...)
 * @see ReactiveWebServerApplicationContext
 * @see AnnotationConfigApplicationContext
 * @since 2.0.0
 */
public clreplaced AnnotationConfigReactiveWebServerApplicationContext extends ReactiveWebServerApplicationContext implements AnnotationConfigRegistry {

    private final AnnotatedBeanDefinitionReader reader;

    private final ClreplacedPathBeanDefinitionScanner scanner;

    private final Set<Clreplaced<?>> annotatedClreplacedes = new LinkedHashSet<>();

    private String[] basePackages;

    /**
     * Create a new {@link AnnotationConfigReactiveWebServerApplicationContext} that needs
     * to be populated through {@link #register} calls and then manually
     * {@linkplain #refresh refreshed}.
     */
    public AnnotationConfigReactiveWebServerApplicationContext() {
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClreplacedPathBeanDefinitionScanner(this);
    }

    /**
     * Create a new {@link AnnotationConfigReactiveWebServerApplicationContext} with the
     * given {@code DefaultListableBeanFactory}. The context needs to be populated through
     * {@link #register} calls and then manually {@linkplain #refresh refreshed}.
     *
     * @param beanFactory the DefaultListableBeanFactory instance to use for this context
     */
    public AnnotationConfigReactiveWebServerApplicationContext(DefaultListableBeanFactory beanFactory) {
        super(beanFactory);
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClreplacedPathBeanDefinitionScanner(this);
    }

    /**
     * Create a new {@link AnnotationConfigReactiveWebServerApplicationContext}, deriving
     * bean definitions from the given annotated clreplacedes and automatically refreshing the
     * context.
     *
     * @param annotatedClreplacedes one or more annotated clreplacedes, e.g. {@code @Configuration}
     *                         clreplacedes
     */
    public AnnotationConfigReactiveWebServerApplicationContext(Clreplaced<?>... annotatedClreplacedes) {
        this();
        register(annotatedClreplacedes);
        refresh();
    }

    /**
     * Create a new {@link AnnotationConfigReactiveWebServerApplicationContext}, scanning
     * for bean definitions in the given packages and automatically refreshing the
     * context.
     *
     * @param basePackages the packages to check for annotated clreplacedes
     */
    public AnnotationConfigReactiveWebServerApplicationContext(String... basePackages) {
        this();
        scan(basePackages);
        refresh();
    }

    /**
     * {@inheritDoc}
     * <p>
     * Delegates given environment to underlying {@link AnnotatedBeanDefinitionReader} and
     * {@link ClreplacedPathBeanDefinitionScanner} members.
     */
    @Override
    public void setEnvironment(ConfigurableEnvironment environment) {
        super.setEnvironment(environment);
        this.reader.setEnvironment(environment);
        this.scanner.setEnvironment(environment);
    }

    /**
     * Provide a custom {@link BeanNameGenerator} for use with
     * {@link AnnotatedBeanDefinitionReader} and/or
     * {@link ClreplacedPathBeanDefinitionScanner}, if any.
     * <p>
     * Default is
     * {@link org.springframework.context.annotation.AnnotationBeanNameGenerator}.
     * <p>
     * Any call to this method must occur prior to calls to {@link #register(Clreplaced...)}
     * and/or {@link #scan(String...)}.
     *
     * @param beanNameGenerator the bean name generator
     * @see AnnotatedBeanDefinitionReader#setBeanNameGenerator
     * @see ClreplacedPathBeanDefinitionScanner#setBeanNameGenerator
     */
    public void setBeanNameGenerator(BeanNameGenerator beanNameGenerator) {
        this.reader.setBeanNameGenerator(beanNameGenerator);
        this.scanner.setBeanNameGenerator(beanNameGenerator);
        this.getBeanFactory().registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);
    }

    /**
     * Set the {@link ScopeMetadataResolver} to use for detected bean clreplacedes.
     * <p>
     * The default is an {@link AnnotationScopeMetadataResolver}.
     * <p>
     * Any call to this method must occur prior to calls to {@link #register(Clreplaced...)}
     * and/or {@link #scan(String...)}.
     *
     * @param scopeMetadataResolver the scope metadata resolver
     */
    public void setScopeMetadataResolver(ScopeMetadataResolver scopeMetadataResolver) {
        this.reader.setScopeMetadataResolver(scopeMetadataResolver);
        this.scanner.setScopeMetadataResolver(scopeMetadataResolver);
    }

    /**
     * Register one or more annotated clreplacedes to be processed. Note that
     * {@link #refresh()} must be called in order for the context to fully process the new
     * clreplaced.
     * <p>
     * Calls to {@code #register} are idempotent; adding the same annotated clreplaced more
     * than once has no additional effect.
     *
     * @param annotatedClreplacedes one or more annotated clreplacedes, e.g. {@code @Configuration}
     *                         clreplacedes
     * @see #scan(String...)
     * @see #refresh()
     */
    @Override
    public final void register(Clreplaced<?>... annotatedClreplacedes) {
        replacedert.notEmpty(annotatedClreplacedes, "At least one annotated clreplaced must be specified");
        this.annotatedClreplacedes.addAll(Arrays.asList(annotatedClreplacedes));
    }

    /**
     * Perform a scan within the specified base packages. Note that {@link #refresh()}
     * must be called in order for the context to fully process the new clreplaced.
     *
     * @param basePackages the packages to check for annotated clreplacedes
     * @see #register(Clreplaced...)
     * @see #refresh()
     */
    @Override
    public final void scan(String... basePackages) {
        replacedert.notEmpty(basePackages, "At least one base package must be specified");
        this.basePackages = basePackages;
    }

    @Override
    protected void prepareRefresh() {
        this.scanner.clearCache();
        super.prepareRefresh();
    }

    @Override
    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        super.postProcessBeanFactory(beanFactory);
        if (!ObjectUtils.isEmpty(this.basePackages)) {
            this.scanner.scan(this.basePackages);
        }
        if (!this.annotatedClreplacedes.isEmpty()) {
            this.reader.register(ClreplacedUtils.toClreplacedArray(this.annotatedClreplacedes));
        }
    }
}

@Test
public void testClreplacedPathBeanDefinitionScanner() {
    ClreplacedPathBeanDefinitionScanner scanner = new ClreplacedPathBeanDefinitionScanner(beanDefinitionRegistry);
    scanner.scan("spring.study.componentprovider.bean");
}

public static Set<String> getMessageType() {
    BeanDefinitionRegistry bdr = new SimpleBeanDefinitionRegistry();
    ClreplacedPathBeanDefinitionScanner s = new ClreplacedPathBeanDefinitionScanner(bdr, false);
    s.addIncludeFilter(new replacedignableTypeFilter(Message.clreplaced));
    s.scan("net.consensys");
    String[] beans = bdr.getBeanDefinitionNames();
    return Arrays.stream(beans).map(n -> bdr.getBeanDefinition(n).getBeanClreplacedName()).collect(Collectors.toSet());
}

private Set<BeanDefinitionHolder> findServiceBeanDefinitionHolders(ClreplacedPathBeanDefinitionScanner scanner, String packageToScan, BeanDefinitionRegistry registry, BeanNameGenerator beanNameGenerator) {
    Set<BeanDefinition> beanDefinitions = scanner.findCandidateComponents(packageToScan);
    Set<BeanDefinitionHolder> beanDefinitionHolders = new LinkedHashSet<BeanDefinitionHolder>(beanDefinitions.size());
    for (BeanDefinition beanDefinition : beanDefinitions) {
        String beanName = beanNameGenerator.generateBeanName(beanDefinition, registry);
        BeanDefinitionHolder beanDefinitionHolder = new BeanDefinitionHolder(beanDefinition, beanName);
        beanDefinitionHolders.add(beanDefinitionHolder);
    }
    return beanDefinitionHolders;
}

private void registerServiceBeans(Set<String> packagesToScan, BeanDefinitionRegistry registry) {
    ClreplacedPathBeanDefinitionScanner scanner = new ClreplacedPathBeanDefinitionScanner(registry, true, this.environment, this.resourceLoader);
    BeanNameGenerator beanNameGenerator = resolveBeanNameGenerator(registry);
    scanner.setBeanNameGenerator(beanNameGenerator);
    scanner.addIncludeFilter(new AnnotationTypeFilter(Service.clreplaced));
    for (String packageToScan : packagesToScan) {
        // Registers @Service Bean first
        scanner.scan(packageToScan);
        // Finds all BeanDefinitionHolders of @Service whether @ComponentScan scans or not.
        Set<BeanDefinitionHolder> beanDefinitionHolders = findServiceBeanDefinitionHolders(scanner, packageToScan, registry, beanNameGenerator);
        if (!CollectionUtils.isEmpty(beanDefinitionHolders)) {
            for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
                registerServiceBean(beanDefinitionHolder, registry);
            }
        }
    }
}

@Override
public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
    String declaringClreplaced = metadata.getClreplaced().getName();
    ClreplacedPathBeanDefinitionScanner scanner = new ClreplacedPathBeanDefinitionScanner(registry, false, this.environment, this.resourceLoader);
    scanner.addIncludeFilter(new AnnotationTypeFilter(Command.clreplaced));
    scanner.addIncludeFilter(new AnnotationTypeFilter(Event.clreplaced));
    AnnotationAttributes enodeScan = attributesFor(metadata, EnableEnode.clreplaced.getName());
    Set<String> basePackages = new LinkedHashSet<>();
    String[] basePackagesArray = enodeScan.getStringArray("basePackages");
    String[] scanBasePackagesArray = enodeScan.getStringArray("scanBasePackages");
    for (String pkg : basePackagesArray) {
        String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg), ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
        Collections.addAll(basePackages, tokenized);
    }
    for (String pkg : scanBasePackagesArray) {
        String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg), ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
        Collections.addAll(basePackages, tokenized);
    }
    for (Clreplaced<?> clazz : enodeScan.getClreplacedArray("basePackageClreplacedes")) {
        basePackages.add(ClreplacedUtils.getPackageName(clazz));
    }
    if (basePackages.isEmpty()) {
        basePackages.add(ClreplacedUtils.getPackageName(metadata.getClreplacedName()));
    }
    scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {

        @Override
        protected boolean matchClreplacedName(String clreplacedName) {
            return declaringClreplaced.equals(clreplacedName);
        }
    });
    String[] scanPackages = StringUtils.toStringArray(basePackages);
    ObjectContainer.BASE_PACKAGES = scanPackages;
    scanner.scan(scanPackages);
}

/**
 * Scan base packages for register {@link Component @Component}s
 *
 * @param registry     {@link BeanDefinitionRegistry}
 * @param basePackages base packages
 * @return the count of registered components.
 */
public static int scanBasePackages(BeanDefinitionRegistry registry, String... basePackages) {
    int count = 0;
    if (!ObjectUtils.isEmpty(basePackages)) {
        boolean debugEnabled = logger.isDebugEnabled();
        if (debugEnabled) {
            logger.debug(registry.getClreplaced().getSimpleName() + " will scan base packages " + Arrays.asList(basePackages) + ".");
        }
        List<String> registeredBeanNames = Arrays.asList(registry.getBeanDefinitionNames());
        ClreplacedPathBeanDefinitionScanner clreplacedPathBeanDefinitionScanner = new ClreplacedPathBeanDefinitionScanner(registry);
        count = clreplacedPathBeanDefinitionScanner.scan(basePackages);
        List<String> scannedBeanNames = new ArrayList<String>(count);
        scannedBeanNames.addAll(Arrays.asList(registry.getBeanDefinitionNames()));
        scannedBeanNames.removeAll(registeredBeanNames);
        if (debugEnabled) {
            logger.debug("The Scanned Components[ count : " + count + "] under base packages " + Arrays.asList(basePackages) + " : ");
        }
        for (String scannedBeanName : scannedBeanNames) {
            BeanDefinition scannedBeanDefinition = registry.getBeanDefinition(scannedBeanName);
            if (debugEnabled) {
                logger.debug("Component [ name : " + scannedBeanName + " , clreplaced : " + scannedBeanDefinition.getBeanClreplacedName() + " ]");
            }
        }
    }
    return count;
}

/**
 * Loads bean definitions from underlying sources, including XML and JavaConfig. Acts as a
 * simple facade over {@link AnnotatedBeanDefinitionReader},
 * {@link XmlBeanDefinitionReader} and {@link ClreplacedPathBeanDefinitionScanner}. See
 * {@link SpringApplication} for the types of sources that are supported.
 *
 * @author Phillip Webb
 * @see #setBeanNameGenerator(BeanNameGenerator)
 */
clreplaced BeanDefinitionLoader {

    private final Object[] sources;

    private final AnnotatedBeanDefinitionReader annotatedReader;

    private final XmlBeanDefinitionReader xmlReader;

    private BeanDefinitionReader groovyReader;

    private final ClreplacedPathBeanDefinitionScanner scanner;

    private ResourceLoader resourceLoader;

    /**
     * Create a new {@link BeanDefinitionLoader} that will load beans into the specified
     * {@link BeanDefinitionRegistry}.
     * @param registry the bean definition registry that will contain the loaded beans
     * @param sources the bean sources
     */
    BeanDefinitionLoader(BeanDefinitionRegistry registry, Object... sources) {
        replacedert.notNull(registry, "Registry must not be null");
        replacedert.notEmpty(sources, "Sources must not be empty");
        this.sources = sources;
        this.annotatedReader = new AnnotatedBeanDefinitionReader(registry);
        this.xmlReader = new XmlBeanDefinitionReader(registry);
        if (isGroovyPresent()) {
            this.groovyReader = new GroovyBeanDefinitionReader(registry);
        }
        this.scanner = new ClreplacedPathBeanDefinitionScanner(registry);
        this.scanner.addExcludeFilter(new ClreplacedExcludeFilter(sources));
    }

    /**
     * Set the bean name generator to be used by the underlying readers and scanner.
     * @param beanNameGenerator the bean name generator
     */
    public void setBeanNameGenerator(BeanNameGenerator beanNameGenerator) {
        this.annotatedReader.setBeanNameGenerator(beanNameGenerator);
        this.xmlReader.setBeanNameGenerator(beanNameGenerator);
        this.scanner.setBeanNameGenerator(beanNameGenerator);
    }

    /**
     * Set the resource loader to be used by the underlying readers and scanner.
     * @param resourceLoader the resource loader
     */
    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
        this.xmlReader.setResourceLoader(resourceLoader);
        this.scanner.setResourceLoader(resourceLoader);
    }

    /**
     * Set the environment to be used by the underlying readers and scanner.
     * @param environment the environment
     */
    public void setEnvironment(ConfigurableEnvironment environment) {
        this.annotatedReader.setEnvironment(environment);
        this.xmlReader.setEnvironment(environment);
        this.scanner.setEnvironment(environment);
    }

    /**
     * Load the sources into the reader.
     * @return the number of loaded beans
     */
    public int load() {
        int count = 0;
        for (Object source : this.sources) {
            count += load(source);
        }
        return count;
    }

    private int load(Object source) {
        replacedert.notNull(source, "Source must not be null");
        if (source instanceof Clreplaced<?>) {
            return load((Clreplaced<?>) source);
        }
        if (source instanceof Resource) {
            return load((Resource) source);
        }
        if (source instanceof Package) {
            return load((Package) source);
        }
        if (source instanceof CharSequence) {
            return load((CharSequence) source);
        }
        throw new IllegalArgumentException("Invalid source type " + source.getClreplaced());
    }

    private int load(Clreplaced<?> source) {
        if (isGroovyPresent() && GroovyBeanDefinitionSource.clreplaced.isreplacedignableFrom(source)) {
            // Any GroovyLoaders added in beans{} DSL can contribute beans here
            GroovyBeanDefinitionSource loader = BeanUtils.instantiateClreplaced(source, GroovyBeanDefinitionSource.clreplaced);
            load(loader);
        }
        if (isComponent(source)) {
            this.annotatedReader.register(source);
            return 1;
        }
        return 0;
    }

    private int load(GroovyBeanDefinitionSource source) {
        int before = this.xmlReader.getRegistry().getBeanDefinitionCount();
        ((GroovyBeanDefinitionReader) this.groovyReader).beans(source.getBeans());
        int after = this.xmlReader.getRegistry().getBeanDefinitionCount();
        return after - before;
    }

    private int load(Resource source) {
        if (source.getFilename().endsWith(".groovy")) {
            if (this.groovyReader == null) {
                throw new BeanDefinitionStoreException("Cannot load Groovy beans without Groovy on clreplacedpath");
            }
            return this.groovyReader.loadBeanDefinitions(source);
        }
        return this.xmlReader.loadBeanDefinitions(source);
    }

    private int load(Package source) {
        return this.scanner.scan(source.getName());
    }

    private int load(CharSequence source) {
        String resolvedSource = this.xmlReader.getEnvironment().resolvePlaceholders(source.toString());
        // Attempt as a Clreplaced
        try {
            return load(ClreplacedUtils.forName(resolvedSource, null));
        } catch (IllegalArgumentException | ClreplacedNotFoundException ex) {
        // swallow exception and continue
        }
        // Attempt as resources
        Resource[] resources = findResources(resolvedSource);
        int loadCount = 0;
        boolean atLeastOneResourceExists = false;
        for (Resource resource : resources) {
            if (isLoadCandidate(resource)) {
                atLeastOneResourceExists = true;
                loadCount += load(resource);
            }
        }
        if (atLeastOneResourceExists) {
            return loadCount;
        }
        // Attempt as package
        Package packageResource = findPackage(resolvedSource);
        if (packageResource != null) {
            return load(packageResource);
        }
        throw new IllegalArgumentException("Invalid source '" + resolvedSource + "'");
    }

    private boolean isGroovyPresent() {
        return ClreplacedUtils.isPresent("groovy.lang.MetaClreplaced", null);
    }

    private Resource[] findResources(String source) {
        ResourceLoader loader = (this.resourceLoader != null) ? this.resourceLoader : new PathMatchingResourcePatternResolver();
        try {
            if (loader instanceof ResourcePatternResolver) {
                return ((ResourcePatternResolver) loader).getResources(source);
            }
            return new Resource[] { loader.getResource(source) };
        } catch (IOException ex) {
            throw new IllegalStateException("Error reading source '" + source + "'");
        }
    }

    private boolean isLoadCandidate(Resource resource) {
        if (resource == null || !resource.exists()) {
            return false;
        }
        if (resource instanceof ClreplacedPathResource) {
            // A simple package without a '.' may accidentally get loaded as an XML
            // doreplacedent if we're not careful. The result of getInputStream() will be
            // a file list of the package content. We double check here that it's not
            // actually a package.
            String path = ((ClreplacedPathResource) resource).getPath();
            if (path.indexOf('.') == -1) {
                try {
                    return Package.getPackage(path) == null;
                } catch (Exception ex) {
                // Ignore
                }
            }
        }
        return true;
    }

    private Package findPackage(CharSequence source) {
        Package pkg = Package.getPackage(source.toString());
        if (pkg != null) {
            return pkg;
        }
        try {
            // Attempt to find a clreplaced in this package
            ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(getClreplaced().getClreplacedLoader());
            Resource[] resources = resolver.getResources(ClreplacedUtils.convertClreplacedNameToResourcePath(source.toString()) + "/*.clreplaced");
            for (Resource resource : resources) {
                String clreplacedName = StringUtils.stripFilenameExtension(resource.getFilename());
                load(Clreplaced.forName(source.toString() + "." + clreplacedName));
                break;
            }
        } catch (Exception ex) {
        // swallow exception and continue
        }
        return Package.getPackage(source.toString());
    }

    private boolean isComponent(Clreplaced<?> type) {
        // This has to be a bit of a guess. The only way to be sure that this type is
        // eligible is to make a bean definition out of it and try to instantiate it.
        if (AnnotationUtils.findAnnotation(type, Component.clreplaced) != null) {
            return true;
        }
        // Nested anonymous clreplacedes are not eligible for registration, nor are groovy
        // closures
        if (type.getName().matches(".*\\$_.*closure.*") || type.isAnonymousClreplaced() || type.getConstructors() == null || type.getConstructors().length == 0) {
            return false;
        }
        return true;
    }

    /**
     * Simple {@link TypeFilter} used to ensure that specified {@link Clreplaced} sources are
     * not accidentally re-added during scanning.
     */
    private static clreplaced ClreplacedExcludeFilter extends AbstractTypeHierarchyTraversingFilter {

        private final Set<String> clreplacedNames = new HashSet<>();

        ClreplacedExcludeFilter(Object... sources) {
            super(false, false);
            for (Object source : sources) {
                if (source instanceof Clreplaced<?>) {
                    this.clreplacedNames.add(((Clreplaced<?>) source).getName());
                }
            }
        }

        @Override
        protected boolean matchClreplacedName(String clreplacedName) {
            return this.clreplacedNames.contains(clreplacedName);
        }
    }

    /**
     * Source for Bean definitions defined in Groovy.
     */
    @FunctionalInterface
    protected interface GroovyBeanDefinitionSource {

        Closure<?> getBeans();
    }
}

/**
 * Ensure that ContextLoaderListener and GenericWebApplicationContext interact nicely.
 */
@Test
public void genericWAC() {
    GenericWebApplicationContext ctx = new GenericWebApplicationContext();
    ContextLoaderListener cll = new ContextLoaderListener(ctx);
    ClreplacedPathBeanDefinitionScanner scanner = new ClreplacedPathBeanDefinitionScanner(ctx);
    scanner.scan("bogus.pkg");
    cll.contextInitialized(new ServletContextEvent(new MockServletContext()));
}

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
    DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    Environment environment = beanFactory.getBean(Environment.clreplaced);
    String[] componentScanAnnotatedBeanNames = beanFactory.getBeanNamesForAnnotation(ComponentScan.clreplaced);
    Set<String> basePackages = new LinkedHashSet<>();
    for (String beanName : componentScanAnnotatedBeanNames) {
        AnnotatedBeanDefinition definition = (AnnotatedBeanDefinition) beanFactory.getBeanDefinition(beanName);
        BeanDefinition mergedBeanDefinition = beanFactory.getMergedBeanDefinition(beanName);
        Map<String, Object> attributes = definition.getMetadata().getAnnotationAttributes(ComponentScan.clreplaced.getName());
        String[] basePackagesArray = (String[]) attributes.get("basePackages");
        for (String pkg : basePackagesArray) {
            String[] tokenized = StringUtils.tokenizeToStringArray(environment.resolvePlaceholders(pkg), ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
            Collections.addAll(basePackages, tokenized);
        }
        for (Clreplaced<?> clazz : (Clreplaced<?>[]) attributes.get("basePackageClreplacedes")) {
            basePackages.add(ClreplacedUtils.getPackageName(clazz));
        }
        if (basePackages.isEmpty()) {
            basePackages.add(ClreplacedUtils.getPackageName(mergedBeanDefinition.getBeanClreplacedName()));
        }
    }
    ClreplacedPathBeanDefinitionScanner scanner = new ClreplacedPathBeanDefinitionScanner(beanFactory, false);
    scanner.addIncludeFilter(new AnnotationTypeFilter(Generated.clreplaced));
    scanner.scan(basePackages.toArray(new String[0]));
}

/**
 * Loads bean definitions from underlying sources, including XML and JavaConfig. Acts as a
 * simple facade over {@link AnnotatedBeanDefinitionReader},
 * {@link XmlBeanDefinitionReader} and {@link ClreplacedPathBeanDefinitionScanner}. See
 * {@link SpringApplication} for the types of sources that are supported.
 *
 * @author Phillip Webb
 * @see #setBeanNameGenerator(BeanNameGenerator)
 */
clreplaced BeanDefinitionLoader {

    private final Object[] sources;

    private final AnnotatedBeanDefinitionReader annotatedReader;

    private final XmlBeanDefinitionReader xmlReader;

    private BeanDefinitionReader groovyReader;

    private final ClreplacedPathBeanDefinitionScanner scanner;

    private ResourceLoader resourceLoader;

    /**
     * Create a new {@link BeanDefinitionLoader} that will load beans into the specified
     * {@link BeanDefinitionRegistry}.
     *
     * @param registry the bean definition registry that will contain the loaded beans
     * @param sources  the bean sources
     */
    BeanDefinitionLoader(BeanDefinitionRegistry registry, Object... sources) {
        replacedert.notNull(registry, "Registry must not be null");
        replacedert.notEmpty(sources, "Sources must not be empty");
        this.sources = sources;
        // 注解形式的Bean定义读取器 比如：@Configuration @Bean @Component @Controller @Service等等
        this.annotatedReader = new AnnotatedBeanDefinitionReader(registry);
        // XML形式的Bean定义读取器
        this.xmlReader = new XmlBeanDefinitionReader(registry);
        if (isGroovyPresent()) {
            this.groovyReader = new GroovyBeanDefinitionReader(registry);
        }
        // 类路径扫描器
        this.scanner = new ClreplacedPathBeanDefinitionScanner(registry);
        // 扫描器添加排除过滤器
        this.scanner.addExcludeFilter(new ClreplacedExcludeFilter(sources));
    }

    /**
     * Set the bean name generator to be used by the underlying readers and scanner.
     *
     * @param beanNameGenerator the bean name generator
     */
    public void setBeanNameGenerator(BeanNameGenerator beanNameGenerator) {
        this.annotatedReader.setBeanNameGenerator(beanNameGenerator);
        this.xmlReader.setBeanNameGenerator(beanNameGenerator);
        this.scanner.setBeanNameGenerator(beanNameGenerator);
    }

    /**
     * Set the resource loader to be used by the underlying readers and scanner.
     *
     * @param resourceLoader the resource loader
     */
    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
        this.xmlReader.setResourceLoader(resourceLoader);
        this.scanner.setResourceLoader(resourceLoader);
    }

    /**
     * Set the environment to be used by the underlying readers and scanner.
     *
     * @param environment the environment
     */
    public void setEnvironment(ConfigurableEnvironment environment) {
        this.annotatedReader.setEnvironment(environment);
        this.xmlReader.setEnvironment(environment);
        this.scanner.setEnvironment(environment);
    }

    /**
     * Load the sources into the reader.
     *
     * @return the number of loaded beans
     */
    public int load() {
        int count = 0;
        for (Object source : this.sources) {
            count += load(source);
        }
        return count;
    }

    private int load(Object source) {
        replacedert.notNull(source, "Source must not be null");
        // 从Clreplaced加载
        if (source instanceof Clreplaced<?>) {
            return load((Clreplaced<?>) source);
        }
        // 从Resource加载
        if (source instanceof Resource) {
            return load((Resource) source);
        }
        // 从Package加载
        if (source instanceof Package) {
            return load((Package) source);
        }
        // 从 CharSequence 加载 ？？？
        if (source instanceof CharSequence) {
            return load((CharSequence) source);
        }
        throw new IllegalArgumentException("Invalid source type " + source.getClreplaced());
    }

    private int load(Clreplaced<?> source) {
        if (isGroovyPresent() && GroovyBeanDefinitionSource.clreplaced.isreplacedignableFrom(source)) {
            // Any GroovyLoaders added in beans{} DSL can contribute beans here
            GroovyBeanDefinitionSource loader = BeanUtils.instantiateClreplaced(source, GroovyBeanDefinitionSource.clreplaced);
            load(loader);
        }
        if (isComponent(source)) {
            // 将 启动类的 BeanDefinition注册进 beanDefinitionMap
            this.annotatedReader.register(source);
            return 1;
        }
        return 0;
    }

    private int load(GroovyBeanDefinitionSource source) {
        int before = this.xmlReader.getRegistry().getBeanDefinitionCount();
        ((GroovyBeanDefinitionReader) this.groovyReader).beans(source.getBeans());
        int after = this.xmlReader.getRegistry().getBeanDefinitionCount();
        return after - before;
    }

    private int load(Resource source) {
        if (source.getFilename().endsWith(".groovy")) {
            if (this.groovyReader == null) {
                throw new BeanDefinitionStoreException("Cannot load Groovy beans without Groovy on clreplacedpath");
            }
            return this.groovyReader.loadBeanDefinitions(source);
        }
        return this.xmlReader.loadBeanDefinitions(source);
    }

    private int load(Package source) {
        return this.scanner.scan(source.getName());
    }

    private int load(CharSequence source) {
        String resolvedSource = this.xmlReader.getEnvironment().resolvePlaceholders(source.toString());
        // Attempt as a Clreplaced
        try {
            return load(ClreplacedUtils.forName(resolvedSource, null));
        } catch (IllegalArgumentException | ClreplacedNotFoundException ex) {
        // swallow exception and continue
        }
        // Attempt as resources
        Resource[] resources = findResources(resolvedSource);
        int loadCount = 0;
        boolean atLeastOneResourceExists = false;
        for (Resource resource : resources) {
            if (isLoadCandidate(resource)) {
                atLeastOneResourceExists = true;
                loadCount += load(resource);
            }
        }
        if (atLeastOneResourceExists) {
            return loadCount;
        }
        // Attempt as package
        Package packageResource = findPackage(resolvedSource);
        if (packageResource != null) {
            return load(packageResource);
        }
        throw new IllegalArgumentException("Invalid source '" + resolvedSource + "'");
    }

    private boolean isGroovyPresent() {
        return ClreplacedUtils.isPresent("groovy.lang.MetaClreplaced", null);
    }

    private Resource[] findResources(String source) {
        ResourceLoader loader = (this.resourceLoader != null) ? this.resourceLoader : new PathMatchingResourcePatternResolver();
        try {
            if (loader instanceof ResourcePatternResolver) {
                return ((ResourcePatternResolver) loader).getResources(source);
            }
            return new Resource[] { loader.getResource(source) };
        } catch (IOException ex) {
            throw new IllegalStateException("Error reading source '" + source + "'");
        }
    }

    private boolean isLoadCandidate(Resource resource) {
        if (resource == null || !resource.exists()) {
            return false;
        }
        if (resource instanceof ClreplacedPathResource) {
            // A simple package without a '.' may accidentally get loaded as an XML
            // doreplacedent if we're not careful. The result of getInputStream() will be
            // a file list of the package content. We double check here that it's not
            // actually a package.
            String path = ((ClreplacedPathResource) resource).getPath();
            if (path.indexOf('.') == -1) {
                try {
                    return Package.getPackage(path) == null;
                } catch (Exception ex) {
                // Ignore
                }
            }
        }
        return true;
    }

    private Package findPackage(CharSequence source) {
        Package pkg = Package.getPackage(source.toString());
        if (pkg != null) {
            return pkg;
        }
        try {
            // Attempt to find a clreplaced in this package
            ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(getClreplaced().getClreplacedLoader());
            Resource[] resources = resolver.getResources(ClreplacedUtils.convertClreplacedNameToResourcePath(source.toString()) + "/*.clreplaced");
            for (Resource resource : resources) {
                String clreplacedName = StringUtils.stripFilenameExtension(resource.getFilename());
                load(Clreplaced.forName(source.toString() + "." + clreplacedName));
                break;
            }
        } catch (Exception ex) {
        // swallow exception and continue
        }
        return Package.getPackage(source.toString());
    }

    private boolean isComponent(Clreplaced<?> type) {
        // This has to be a bit of a guess. The only way to be sure that this type is
        // eligible is to make a bean definition out of it and try to instantiate it.
        if (AnnotationUtils.findAnnotation(type, Component.clreplaced) != null) {
            return true;
        }
        // Nested anonymous clreplacedes are not eligible for registration, nor are groovy
        // closures
        if (type.getName().matches(".*\\$_.*closure.*") || type.isAnonymousClreplaced() || type.getConstructors() == null || type.getConstructors().length == 0) {
            return false;
        }
        return true;
    }

    /**
     * Simple {@link TypeFilter} used to ensure that specified {@link Clreplaced} sources are
     * not accidentally re-added during scanning.
     */
    private static clreplaced ClreplacedExcludeFilter extends AbstractTypeHierarchyTraversingFilter {

        private final Set<String> clreplacedNames = new HashSet<>();

        ClreplacedExcludeFilter(Object... sources) {
            super(false, false);
            for (Object source : sources) {
                if (source instanceof Clreplaced<?>) {
                    this.clreplacedNames.add(((Clreplaced<?>) source).getName());
                }
            }
        }

        @Override
        protected boolean matchClreplacedName(String clreplacedName) {
            return this.clreplacedNames.contains(clreplacedName);
        }
    }

    /**
     * Source for Bean definitions defined in Groovy.
     */
    @FunctionalInterface
    protected interface GroovyBeanDefinitionSource {

        Closure<?> getBeans();
    }
}

@Override
protected ClreplacedPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) {
    ClreplacedPathBeanDefinitionScanner scanner = super.configureScanner(parserContext, element);
    getAnnotationClreplacedes(parserContext, element, scanner.getResourceLoader().getClreplacedLoader()).forEach((clazz) -> scanner.addIncludeFilter(new AnnotationTypeFilter(clazz)));
    return scanner;
}

@Override
public List<String> getProtocols() {
    BeanDefinitionRegistry bdr = new SimpleBeanDefinitionRegistry();
    ClreplacedPathBeanDefinitionScanner s = new ClreplacedPathBeanDefinitionScanner(bdr, false);
    TypeFilter tf = new replacedignableTypeFilter(Protocol.clreplaced);
    s.addIncludeFilter(tf);
    s.setIncludeAnnotationConfig(false);
    s.scan("net.consensys");
    String[] beans = bdr.getBeanDefinitionNames();
    return Arrays.stream(beans).map(n -> bdr.getBeanDefinition(n).getBeanClreplacedName()).collect(Collectors.toList());
}

@Override
public void registerBeanDefinitions(@NonNull AnnotationMetadata importingClreplacedMetadata, @NonNull BeanDefinitionRegistry registry) {
    ClreplacedPathBeanDefinitionScanner scanner = new ClreplacedPathBeanDefinitionScanner(registry);
    scanner.addIncludeFilter(new replacedignableTypeFilter(DevValidator.clreplaced));
    scanner.scan(GlobalConst.PACKAGE);
}

private void loadContext() {
    if (context == null) {
        // Create a parent context containing all beans provided to plugins
        // More on that below in the article...
        GenericApplicationContext parentContext = new GenericApplicationContext();
        parentContext.refresh();
        // Create the annotation-based context
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.setParent(parentContext);
        // Scan for clreplacedes annotated with @<PluginAnnotaionType>,
        // do not include standard Spring annotations in scan
        ClreplacedPathBeanDefinitionScanner scanner = new ClreplacedPathBeanDefinitionScanner(context, false);
        scanner.addIncludeFilter(new AnnotationTypeFilter(pluginAnnotationType));
        scanner.scan(pluginBasePackage);
        context.refresh();
        this.context = context;
    }
}

@Override
public void registerBeanDefinitions(AnnotationMetadata importMetadata, BeanDefinitionRegistry registry) {
    ClreplacedPathBeanDefinitionScanner scanner = new ClreplacedPathBeanDefinitionScanner(registry, false);
    scanner.addIncludeFilter(new AnnotationTypeFilter(Generated.clreplaced));
    scanner.scan(ClreplacedUtils.getPackageName(importMetadata.getClreplacedName()));
}

@Override
public void registerBeanDefinitions(AnnotationMetadata importingClreplacedMetadata, BeanDefinitionRegistry registry) {
    Map<String, Object> attributes = importingClreplacedMetadata.getAnnotationAttributes(EnableLimiter.clreplaced.getCanonicalName());
    // 如果开启限流，则扫描组件、初始化对应的限流器和切面
    ClreplacedPathBeanDefinitionScanner scanConfigure = new ClreplacedPathBeanDefinitionScanner(registry, true);
    if ((Boolean) attributes.get(LimiterConstants.ENABLE_GROUP)) {
        enableGroup.set(true);
    }
    if ((Boolean) attributes.get(LimiterConstants.CONNECT_CONSOLE)) {
        connectConsole.set(true);
    }
    scanConfigure.scan(LimiterConstants.SCAPATH);
}

@Override
public void registerBeanDefinitions(AnnotationMetadata importingClreplacedMetadata, BeanDefinitionRegistry registry) {
    System.out.println("MapperAutoRegistryConfiguration#registerBeanDefinitions");
    AnnotationAttributes attributes = AnnotationAttributes.fromMap(importingClreplacedMetadata.getAnnotationAttributes(MapperScan.clreplaced.getName()));
    this.basePackages = attributes.getStringArray("basePackages");
    ClreplacedPathBeanDefinitionScanner scanner = new ClreplacedPathBeanDefinitionScanner(registry, false, environment, resourceLoader);
    scanner.addIncludeFilter(new AnnotationTypeFilter(Mapper.clreplaced));
    scanner.scan(basePackages);
}

@Override
public void registerBeanDefinitions(AnnotationMetadata importingClreplacedMetadata, BeanDefinitionRegistry registry) {
    AnnotationAttributes annotationAttributes = AnnotationAttributes.fromMap(importingClreplacedMetadata.getAnnotationAttributes(GRpcServerScan.clreplaced.getCanonicalName()));
    if (annotationAttributes == null) {
        log.warn("GrpcScan was not found.Please check your configuration.");
        return;
    }
    ClreplacedPathBeanDefinitionScanner clreplacedPathGrpcApiScanner = new ClreplacedPathBeanDefinitionScanner(registry, false);
    clreplacedPathGrpcApiScanner.setResourceLoader(this.resourceLoader);
    clreplacedPathGrpcApiScanner.addIncludeFilter(new AnnotationTypeFilter(GRpcApi.clreplaced));
    List<String> basePackages = AutoConfigurationPackages.get(this.beanFactory);
    for (String pkg : annotationAttributes.getStringArray("basePackages")) {
        if (StringUtils.hasText(pkg)) {
            basePackages.add(pkg);
        }
    }
    clreplacedPathGrpcApiScanner.scan(StringUtils.toStringArray(basePackages));
}

@Override
public void registerBeanDefinitions(AnnotationMetadata importingClreplacedMetadata, BeanDefinitionRegistry registry) {
    Map<String, Object> attributes = importingClreplacedMetadata.getAnnotationAttributes(EnableBloomFilter.clreplaced.getCanonicalName());
    transaction = (Boolean) attributes.get("transaction");
    String[] scanPaths = (String[]) attributes.get(BloomFilterConstants.SCAPATH);
    // 扫描并存储注解上的信息
    if (!scanPaths[0].trim().equals("")) {
        bloomFilterFieldMap = new HashMap();
        ClreplacedPathScanningCandidateComponentProvider scanner = new ClreplacedPathScanningCandidateComponentProvider(false);
        scanner.addIncludeFilter(new AnnotationTypeFilter(BloomFilterPrefix.clreplaced));
        for (String basePath : scanPaths) {
            for (BeanDefinition e : scanner.findCandidateComponents(basePath)) {
                Clreplaced<?> clazz = null;
                try {
                    clazz = Clreplaced.forName(e.getBeanClreplacedName());
                } catch (ClreplacedNotFoundException e1) {
                    e1.printStackTrace();
                }
                if (clazz.isAnnotationPresent(BloomFilterPrefix.clreplaced)) {
                    final Map<String, BloomFilterProperty> map = new HashMap();
                    final String prefix = clazz.getAnnotation(BloomFilterPrefix.clreplaced).prefix();
                    // 查看clazz是否有对应的注解，并生成键名和对应的注解
                    ReflectionUtils.doWithFields(clazz, field -> {
                        field.setAccessible(Boolean.TRUE);
                        if (field.isAnnotationPresent(BloomFilterProperty.clreplaced)) {
                            String key = field.getName();
                            String keyName = CommonUtil.getKeyName(prefix, key);
                            map.put(keyName, field.getAnnotation(BloomFilterProperty.clreplaced));
                        }
                    });
                    bloomFilterFieldMap.put(prefix, map);
                }
            }
        }
        bloomFilterFieldMap = Collections.unmodifiableMap(bloomFilterFieldMap);
    } else {
        System.err.println("=============redisbloomfilter not support work with lambda cause not set the scan path(also require jdk1.8+)=============");
    }
    // 指定扫描自己写的符合默认扫描注解的组件
    ClreplacedPathBeanDefinitionScanner scanConfigure = new ClreplacedPathBeanDefinitionScanner(registry, true);
    scanConfigure.scan(BloomFilterConstants.PATH);
}

See More Examples