private String[] getBeanNamesForType(ConfigurableListableBeanFactory beanFactory, String type) { try { return beanFactory.getBeanNamesForType(Class.forName(type), true, false); } catch (ClassNotFoundException | NoClassDefFoundError ex) { // Ignore } return NO_BEANS; }
@Override public String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) { assertBeanFactoryActive(); return getBeanFactory().getBeanNamesForType(type, includeNonSingletons, allowEagerInit); }
@Override public String[] getBeanNamesForType(@Nullable Class<?> type) { assertBeanFactoryActive(); return getBeanFactory().getBeanNamesForType(type); }
@Override public String[] getBeanNamesForType(ResolvableType type) { assertBeanFactoryActive(); return getBeanFactory().getBeanNamesForType(type); }
private <T> Optional<String> findComponent(Class<T> componentType, String componentQualifier) { return Stream.of(beanFactory.getBeanNamesForType(componentType)) .filter(bean -> isQualifierMatch(bean, beanFactory, componentQualifier)) .findFirst(); }
@Override public String[] getBeanNamesForType(@Nullable Class<?> type) { assertBeanFactoryActive(); return getBeanFactory().getBeanNamesForType(type); }
@Override public String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) { assertBeanFactoryActive(); return getBeanFactory().getBeanNamesForType(type, includeNonSingletons, allowEagerInit); }
@Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { String[] transactionManagers = beanFactory .getBeanNamesForType(TransactionManager.class, true, false); for (String transactionManager : transactionManagers) { addTransactionManagerDependencies(beanFactory, transactionManager); } }
private <T> List<T> findBeans(Class<T> clazz) { final String[] names = beanFactory.getBeanNamesForType(clazz); if (names.length == 0) { return ImmutableList.of(); } return Arrays.stream(names) .map(name -> beanFactory.getBean(name, clazz)) .collect(toImmutableList()); }
private void registerCorrelationDataProviders(Configurer configurer) { configurer.configureCorrelationDataProviders( c -> { String[] correlationDataProviderBeans = beanFactory.getBeanNamesForType(CorrelationDataProvider.class); return Arrays.stream(correlationDataProviderBeans) .map(n -> (CorrelationDataProvider) getBean(n, c)) .collect(Collectors.toList()); }); }
@Override public String[] getBeanNamesForType(ResolvableType type) { assertBeanFactoryActive(); return getBeanFactory().getBeanNamesForType(type); }
@Override public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { return (context.getBeanFactory().getBeanNamesForType(MetadataHolder.class, true, false).length == 0); }
private void registerConfigurerModules(Configurer configurer) { String[] configurerModules = beanFactory.getBeanNamesForType(ConfigurerModule.class); for (String configurerModuleBeanName : configurerModules) { ConfigurerModule configurerModule = beanFactory.getBean(configurerModuleBeanName, ConfigurerModule.class); configurerModule.configureModule(configurer); } }
ConfigurableListableBeanFactory beanFactory = this.beanFactory; Assert.state(this.beanFactory != null, "No ConfigurableListableBeanFactory set"); String[] beanNames = beanFactory.getBeanNamesForType(Object.class); for (String beanName : beanNames) { if (!ScopedProxyUtils.isScopedTarget(beanName)) {
/** * Retrieve all applicable Lifecycle beans: all singletons that have already been created, * as well as all SmartLifecycle beans (even if they are marked as lazy-init). * @return the Map of applicable beans, with bean names as keys and bean instances as values */ protected Map<String, Lifecycle> getLifecycleBeans() { ConfigurableListableBeanFactory beanFactory = getBeanFactory(); Map<String, Lifecycle> beans = new LinkedHashMap<>(); String[] beanNames = beanFactory.getBeanNamesForType(Lifecycle.class, false, false); for (String beanName : beanNames) { String beanNameToRegister = BeanFactoryUtils.transformedBeanName(beanName); boolean isFactoryBean = beanFactory.isFactoryBean(beanNameToRegister); String beanNameToCheck = (isFactoryBean ? BeanFactory.FACTORY_BEAN_PREFIX + beanName : beanName); if ((beanFactory.containsSingleton(beanNameToRegister) && (!isFactoryBean || matchesBeanType(Lifecycle.class, beanNameToCheck, beanFactory))) || matchesBeanType(SmartLifecycle.class, beanNameToCheck, beanFactory)) { Object bean = beanFactory.getBean(beanNameToCheck); if (bean != this && bean instanceof Lifecycle) { beans.put(beanNameToRegister, (Lifecycle) bean); } } } return beans; }
private ArmeriaReactiveWebServerFactory factory() { when(beanFactory.getBeanNamesForType((Class<?>) any())).thenReturn(names); return new ArmeriaReactiveWebServerFactory(beanFactory); }
public static void registerBeanPostProcessors( ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) { String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
private void registerModuleConfigurations(Configurer configurer) { String[] moduleConfigurations = beanFactory.getBeanNamesForType(ModuleConfiguration.class); for (String moduleConfiguration : moduleConfigurations) { configurer.registerModule(new LazyRetrievedModuleConfiguration( () -> beanFactory.getBean(moduleConfiguration, ModuleConfiguration.class), beanFactory.getType(moduleConfiguration) )); } }
@Before public void setUp() throws Exception { GenericApplicationContext ctx = new GenericApplicationContext(); new XmlBeanDefinitionReader(ctx).loadBeanDefinitions( new ClassPathResource("jeeNamespaceHandlerTests.xml", getClass())); ctx.refresh(); this.beanFactory = ctx.getBeanFactory(); this.beanFactory.getBeanNamesForType(ITestBean.class); }
/** * Finish the initialization of this context's bean factory, * initializing all remaining singleton beans. */ protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { // Initialize conversion service for this context. if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) { beanFactory.setConversionService( beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)); } // Register a default embedded value resolver if no bean post-processor // (such as a PropertyPlaceholderConfigurer bean) registered any before: // at this point, primarily for resolution in annotation attribute values. if (!beanFactory.hasEmbeddedValueResolver()) { beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal)); } // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early. String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false); for (String weaverAwareName : weaverAwareNames) { getBean(weaverAwareName); } // Stop using the temporary ClassLoader for type matching. beanFactory.setTempClassLoader(null); // Allow for caching all bean definition metadata, not expecting further changes. beanFactory.freezeConfiguration(); // Instantiate all remaining (non-lazy-init) singletons. beanFactory.preInstantiateSingletons(); }