java类org.springframework.beans.factory.config.ConfigurableListableBeanFactory的实例源码

/**
 * 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(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())));
}

protected JobDetail buildJobForBeanFactory(ConfigurableListableBeanFactory beanFactory, String jobBeanName) {
    try {
        BeanDefinition beanDefinition = beanFactory.getBeanDefinition(jobBeanName);
        Class beanClass = Class.forName(beanDefinition.getBeanClassName());

        JobDefinition jobDefinition = jobIntrospecter.getJobDefinitionForInstance(beanClass);

        JobDataMap jdm = new JobDataMap();

        jdm.put(Constants.JOB_CRONYX_MARKER, true);
        jdm.put(Constants.JOB_BEAN_NAME, jobBeanName);
        jdm.put(Constants.JOB_DEFINITION, jobDefinition);

        return JobBuilder.newJob()
                .withIdentity(jobDefinition.getKey().getName(), jobDefinition.getKey().getGroup())
                .withDescription(jobDefinition.getDescription())
                .ofType(jobClassSelector.select(jobDefinition))
                .usingJobData(jdm)
                .storeDurably()
                .requestRecovery(jobDefinition.isRecoverable())
                .build();

    }catch (Exception e) {
        logger.error("problem creating job detail, logging and going on. ", e);
        return null;
    }
}

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    String[] autoInitBeanNames = beanFactory.getBeanNamesForType(AbstractCacheAutoInit.class, false, false);
    if (autoInitBeanNames != null) {
        BeanDefinition bd = beanFactory.getBeanDefinition(JetCacheAutoConfiguration.GLOBAL_CACHE_CONFIG_NAME);
        String[] dependsOn = bd.getDependsOn();
        if (dependsOn == null) {
            dependsOn = new String[0];
        }
        int oldLen = dependsOn.length;
        dependsOn = Arrays.copyOf(dependsOn, dependsOn.length + autoInitBeanNames.length);
        System.arraycopy(autoInitBeanNames,0, dependsOn, oldLen, autoInitBeanNames.length);
        bd.setDependsOn(dependsOn);
    }
}

@Override
public void setBeanFactory(BeanFactory beanFactory) {
    Assert.isInstanceOf(ConfigurableListableBeanFactory.class, beanFactory);
    this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
}

private List<String> getPrimaryBeans(ConfigurableListableBeanFactory beanFactory,
                                     List<String> beanNames, boolean considerHierarchy) {
    List<String> primaryBeans = new ArrayList<String>();
    for (String beanName : beanNames) {
        BeanDefinition beanDefinition = findBeanDefinition(beanFactory, beanName, considerHierarchy);
        if (beanDefinition != null && beanDefinition.isPrimary()) {
            primaryBeans.add(beanName);
        }
    }
    return primaryBeans;
}

private BeanDefinition findBeanDefinition(ConfigurableListableBeanFactory beanFactory,
                                          String beanName, boolean considerHierarchy) {
    if (beanFactory.containsBeanDefinition(beanName)) {
        return beanFactory.getBeanDefinition(beanName);
    }
    if (considerHierarchy && beanFactory.getParentBeanFactory() instanceof ConfigurableListableBeanFactory) {
        return findBeanDefinition(((ConfigurableListableBeanFactory) beanFactory.getParentBeanFactory()), beanName, considerHierarchy);
    }
    return null;
}

private Class<?> getConfigurationClassFactoryBeanGeneric(ConfigurableListableBeanFactory beanFactory,
                                                         BeanDefinition definition, String name) throws Exception {
    Method method = getFactoryMethod(beanFactory, definition);
    Class<?> generic = ResolvableType.forMethodReturnType(method).as(FactoryBean.class).resolveGeneric();
    if ((generic == null || generic.equals(Object.class))
            && definition.hasAttribute(FACTORY_BEAN_OBJECT_TYPE)) {
        generic = getTypeFromAttribute(definition.getAttribute(FACTORY_BEAN_OBJECT_TYPE));
    }
    return generic;
}

private Method getFactoryMethod(ConfigurableListableBeanFactory beanFactory,
                                BeanDefinition definition) throws Exception {
    if (definition instanceof AnnotatedBeanDefinition) {
        MethodMetadata factoryMethodMetadata = ((AnnotatedBeanDefinition) definition).getFactoryMethodMetadata();
        if (factoryMethodMetadata instanceof StandardMethodMetadata) {
            return ((StandardMethodMetadata) factoryMethodMetadata).getIntrospectedMethod();
        }
    }
    BeanDefinition factoryDefinition = beanFactory.getBeanDefinition(definition.getFactoryBeanName());
    Class<?> factoryClass = ClassUtils.forName(factoryDefinition.getBeanClassName(), beanFactory.getBeanClassLoader());
    return getFactoryMethod(definition, factoryClass);
}

private Class<?> getDirectFactoryBeanGeneric(
        ConfigurableListableBeanFactory beanFactory, BeanDefinition definition,
        String name) throws ClassNotFoundException, LinkageError {
    Class<?> factoryBeanClass = ClassUtils.forName(definition.getBeanClassName(), beanFactory.getBeanClassLoader());
    Class<?> generic = ResolvableType.forClass(factoryBeanClass).as(FactoryBean.class).resolveGeneric();
    if ((generic == null || generic.equals(Object.class))
            && definition.hasAttribute(FACTORY_BEAN_OBJECT_TYPE)) {
        generic = getTypeFromAttribute(definition.getAttribute(FACTORY_BEAN_OBJECT_TYPE));
    }
    return generic;
}

/**
 * Check whether the named bean declares a qualifier of the given name.
 * @param qualifier the qualifier to match
 * @param beanName the name of the candidate bean
 * @param bf the {@code BeanFactory} from which to retrieve the named bean
 * @return {@code true} if either the bean definition (in the XML case)
 * or the bean's factory method (in the {@code @Bean} case) defines a matching
 * qualifier value (through {@code <qualifier>} or {@code @Qualifier})
 */
private static boolean isQualifierMatch(String qualifier, String beanName, ConfigurableListableBeanFactory bf) {
    if (bf.containsBean(beanName)) {
        try {
            BeanDefinition bd = bf.getMergedBeanDefinition(beanName);
            if (bd instanceof AbstractBeanDefinition) {
                AbstractBeanDefinition abd = (AbstractBeanDefinition) bd;
                AutowireCandidateQualifier candidate = abd.getQualifier(Qualifier.class.getName());
                if ((candidate != null && qualifier.equals(candidate.getAttribute(AutowireCandidateQualifier.VALUE_KEY))) ||
                        qualifier.equals(beanName) || ObjectUtils.containsElement(bf.getAliases(beanName), qualifier)) {
                    return true;
                }
            }
            if (bd instanceof RootBeanDefinition) {
                Method factoryMethod = ((RootBeanDefinition) bd).getResolvedFactoryMethod();
                if (factoryMethod != null) {
                    Qualifier targetAnnotation = factoryMethod.getAnnotation(Qualifier.class);
                    if (targetAnnotation != null && qualifier.equals(targetAnnotation.value())) {
                        return true;
                    }
                }
            }
        }
        catch (NoSuchBeanDefinitionException ex) {
            // Ignore - can't compare qualifiers for a manually registered singleton object
        }
    }
    return false;
}