private boolean isInfrastructureBean(@Nullable String beanName) { if (beanName != null && this.beanFactory.containsBeanDefinition(beanName)) { BeanDefinition bd = this.beanFactory.getBeanDefinition(beanName); return (bd.getRole() == RootBeanDefinition.ROLE_INFRASTRUCTURE); } return false; } }
@Override protected boolean isEligibleAdvisorBean(String beanName) { return (this.beanFactory != null && this.beanFactory.containsBeanDefinition(beanName) && this.beanFactory.getBeanDefinition(beanName).getRole() == BeanDefinition.ROLE_INFRASTRUCTURE); }
@Override public boolean containsBeanDefinition(String beanName) { return getBeanFactory().containsBeanDefinition(beanName); }
/** * Determine whether the given bean should be proxied with its target * class rather than its interfaces. Checks the * {@link #PRESERVE_TARGET_CLASS_ATTRIBUTE "preserveTargetClass" attribute} * of the corresponding bean definition. * @param beanFactory the containing ConfigurableListableBeanFactory * @param beanName the name of the bean * @return whether the given bean should be proxied with its target class */ public static boolean shouldProxyTargetClass( ConfigurableListableBeanFactory beanFactory, @Nullable String beanName) { if (beanName != null && beanFactory.containsBeanDefinition(beanName)) { BeanDefinition bd = beanFactory.getBeanDefinition(beanName); return Boolean.TRUE.equals(bd.getAttribute(PRESERVE_TARGET_CLASS_ATTRIBUTE)); } return false; }
/** * Expose the given target class for the specified bean, if possible. * @param beanFactory the containing ConfigurableListableBeanFactory * @param beanName the name of the bean * @param targetClass the corresponding target class * @since 4.2.3 */ static void exposeTargetClass( ConfigurableListableBeanFactory beanFactory, @Nullable String beanName, Class<?> targetClass) { if (beanName != null && beanFactory.containsBeanDefinition(beanName)) { beanFactory.getMergedBeanDefinition(beanName).setAttribute(ORIGINAL_TARGET_CLASS_ATTRIBUTE, targetClass); } }
private boolean isInfrastructureBean(@Nullable String beanName) { if (beanName != null && this.beanFactory.containsBeanDefinition(beanName)) { BeanDefinition bd = this.beanFactory.getBeanDefinition(beanName); return (bd.getRole() == RootBeanDefinition.ROLE_INFRASTRUCTURE); } return false; } }
@Override public boolean containsBeanDefinition(String beanName) { return getBeanFactory().containsBeanDefinition(beanName); }
/** * Check whether the given bean definition is not subject to the annotation-based * required property check as performed by this post-processor. * <p>The default implementations check for the presence of the * {@link #SKIP_REQUIRED_CHECK_ATTRIBUTE} attribute in the bean definition, if any. * It also suggests skipping in case of a bean definition with a "factory-bean" * reference set, assuming that instance-based factories pre-populate the bean. * @param beanFactory the BeanFactory to check against * @param beanName the name of the bean to check against * @return {@code true} to skip the bean; {@code false} to process it */ protected boolean shouldSkip(@Nullable ConfigurableListableBeanFactory beanFactory, String beanName) { if (beanFactory == null || !beanFactory.containsBeanDefinition(beanName)) { return false; } BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName); if (beanDefinition.getFactoryBeanName() != null) { return true; } Object value = beanDefinition.getAttribute(SKIP_REQUIRED_CHECK_ATTRIBUTE); return (value != null && (Boolean.TRUE.equals(value) || Boolean.valueOf(value.toString()))); }
/** * Determine the original target class for the specified bean, if possible, * otherwise falling back to a regular {@code getType} lookup. * @param beanFactory the containing ConfigurableListableBeanFactory * @param beanName the name of the bean * @return the original target class as stored in the bean definition, if any * @since 4.2.3 * @see org.springframework.beans.factory.BeanFactory#getType(String) */ @Nullable public static Class<?> determineTargetClass( ConfigurableListableBeanFactory beanFactory, @Nullable String beanName) { if (beanName == null) { return null; } if (beanFactory.containsBeanDefinition(beanName)) { BeanDefinition bd = beanFactory.getMergedBeanDefinition(beanName); Class<?> targetClass = (Class<?>) bd.getAttribute(ORIGINAL_TARGET_CLASS_ATTRIBUTE); if (targetClass != null) { return targetClass; } } return beanFactory.getType(beanName); }
@Override public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { return !context.getBeanFactory().containsBeanDefinition("bean1"); } }
@Override public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { return context.getBeanFactory().containsBeanDefinition("bean1"); } }
@Nullable protected RootBeanDefinition getResolvedDecoratedDefinition(RootBeanDefinition rbd) { BeanDefinitionHolder decDef = rbd.getDecoratedDefinition(); if (decDef != null && this.beanFactory instanceof ConfigurableListableBeanFactory) { ConfigurableListableBeanFactory clbf = (ConfigurableListableBeanFactory) this.beanFactory; if (clbf.containsBeanDefinition(decDef.getBeanName())) { BeanDefinition dbd = clbf.getMergedBeanDefinition(decDef.getBeanName()); if (dbd instanceof RootBeanDefinition) { return (RootBeanDefinition) dbd; } } } return null; }
/** * Check whether the given bean definition is not subject to the annotation-based * required property check as performed by this post-processor. * <p>The default implementations check for the presence of the * {@link #SKIP_REQUIRED_CHECK_ATTRIBUTE} attribute in the bean definition, if any. * It also suggests skipping in case of a bean definition with a "factory-bean" * reference set, assuming that instance-based factories pre-populate the bean. * @param beanFactory the BeanFactory to check against * @param beanName the name of the bean to check against * @return {@code true} to skip the bean; {@code false} to process it */ protected boolean shouldSkip(@Nullable ConfigurableListableBeanFactory beanFactory, String beanName) { if (beanFactory == null || !beanFactory.containsBeanDefinition(beanName)) { return false; } BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName); if (beanDefinition.getFactoryBeanName() != null) { return true; } Object value = beanDefinition.getAttribute(SKIP_REQUIRED_CHECK_ATTRIBUTE); return (value != null && (Boolean.TRUE.equals(value) || Boolean.valueOf(value.toString()))); }
private Optional<ParameterResolver> findQualifiedBean(Map<String, ?> beansFound, ConfigurableListableBeanFactory clBeanFactory, Parameter[] parameters, int parameterIndex) { final Parameter parameter = parameters[parameterIndex]; // find @Qualifier matching candidate final Optional<Map<String, Object>> qualifier = AnnotationUtils.findAnnotationAttributes(parameter, Qualifier.class); if (qualifier.isPresent()) { for (Map.Entry<String, ?> bean : beansFound.entrySet()) { if (SpringUtils.isQualifierMatch(bean.getKey(), clBeanFactory, (String) qualifier.get().get("qualifier"))) { return Optional.of(new SpringBeanParameterResolver(clBeanFactory, bean.getKey())); } } } // find @Primary matching candidate for (Map.Entry<String, ?> bean : beansFound.entrySet()) { if (clBeanFactory.containsBeanDefinition(bean.getKey()) && clBeanFactory.getBeanDefinition(bean.getKey()).isPrimary()) { return Optional.of(new SpringBeanParameterResolver(clBeanFactory, bean.getKey())); } } return Optional.empty(); }
private boolean containsBeanDefinition( ConfigurableListableBeanFactory beanFactory, String name) { if (beanFactory.containsBeanDefinition(name)) { return true; } BeanFactory parent = beanFactory.getParentBeanFactory(); if (parent instanceof ConfigurableListableBeanFactory) { return containsBeanDefinition((ConfigurableListableBeanFactory) parent, name); } return false; }
private void registerEventHandlerRegistrar(String epConfigurationBeanName, String epConfigurerBeanName, BeanDefinitionRegistry registry) { List<RuntimeBeanReference> beans = new ManagedList<>(); beanFactory.getBeanNamesIterator().forEachRemaining(bean -> { if (!beanFactory.isFactoryBean(bean)) { Class<?> beanType = beanFactory.getType(bean); if (beanType != null && beanFactory.containsBeanDefinition(bean) && beanFactory.getBeanDefinition(bean).isSingleton()) { boolean hasHandler = StreamSupport.stream(methodsOf(beanType).spliterator(), false) .map(m -> findAnnotationAttributes(m, MessageHandler.class).orElse(null)) .filter(Objects::nonNull) .anyMatch(attr -> EventMessage.class .isAssignableFrom((Class) attr.get("messageType"))); if (hasHandler) { beans.add(new RuntimeBeanReference(bean)); } } } }); registry.registerBeanDefinition("eventHandlerRegistrar", genericBeanDefinition(EventHandlerRegistrar.class) .addConstructorArgReference(AXON_CONFIGURATION_BEAN) .addConstructorArgReference(epConfigurationBeanName) .addConstructorArgReference(epConfigurerBeanName) .addPropertyValue("eventHandlers", beans).getBeanDefinition()); }
@Nullable protected RootBeanDefinition getResolvedDecoratedDefinition(RootBeanDefinition rbd) { BeanDefinitionHolder decDef = rbd.getDecoratedDefinition(); if (decDef != null && this.beanFactory instanceof ConfigurableListableBeanFactory) { ConfigurableListableBeanFactory clbf = (ConfigurableListableBeanFactory) this.beanFactory; if (clbf.containsBeanDefinition(decDef.getBeanName())) { BeanDefinition dbd = clbf.getMergedBeanDefinition(decDef.getBeanName()); if (dbd instanceof RootBeanDefinition) { return (RootBeanDefinition) dbd; } } } return null; }
@Override public Object unregisterObject(String key) throws RegistrationException { Object object = applicationContext.getBean(key); if (applicationContext.getBeanFactory().containsBeanDefinition(key)) { ((BeanDefinitionRegistry) applicationContext.getBeanFactory()).removeBeanDefinition(key); } ((DefaultListableBeanFactory) applicationContext.getBeanFactory()).destroySingleton(key); return object; }
@Test public void testVanillaConfiguration() throws Exception { assertTrue(context.getBeanFactory().containsBeanDefinition("vanilla")); context.getBean("vanilla"); }
@Test public void testExpressionBasedConfiguration() throws Exception { assertTrue(context.getBeanFactory().containsBeanDefinition("expression")); Object target = context.getBean("expression"); assertNotNull(ReflectionTestUtils.getField(ReflectionTestUtils.getField(target, "handler"), "routingKeyGenerator")); }