Example usage for org.springframework.beans.factory.config ConfigurableListableBeanFactory getBeanClassLoader

Introduction

In this page you can find the example usage for org.springframework.beans.factory.config ConfigurableListableBeanFactory getBeanClassLoader.

Prototype

@Nullable
ClassLoader getBeanClassLoader();

Source Link

Document

Return this factory's class loader for loading bean classes (only null if even the system ClassLoader isn't accessible).

Usage

From source file:org.springframework.batch.core.configuration.support.AbstractApplicationContextFactory.java

/**
 * Extension point for special subclasses that want to do more complex things with the bean factory prior to
 * refresh. The default implementation copies all configuration from the parent according to the
 * {@link #setCopyConfiguration(boolean) flag} set.
 *
 * @param parent the parent bean factory for the new context (will never be null)
 * @param beanFactory the new bean factory before bean definitions are loaded
 *
 * @see AbstractApplicationContextFactory#setCopyConfiguration(boolean)
 * @see DefaultListableBeanFactory#copyConfigurationFrom(ConfigurableBeanFactory)
 *//*from   w ww.j av  a 2  s  . com*/
protected void prepareBeanFactory(ConfigurableListableBeanFactory parent,
        ConfigurableListableBeanFactory beanFactory) {
    if (copyConfiguration && parent != null) {
        List<BeanPostProcessor> parentPostProcessors = new ArrayList<BeanPostProcessor>();
        List<BeanPostProcessor> childPostProcessors = new ArrayList<BeanPostProcessor>();

        childPostProcessors.addAll(beanFactory instanceof AbstractBeanFactory
                ? ((AbstractBeanFactory) beanFactory).getBeanPostProcessors()
                : new ArrayList<BeanPostProcessor>());
        parentPostProcessors.addAll(
                parent instanceof AbstractBeanFactory ? ((AbstractBeanFactory) parent).getBeanPostProcessors()
                        : new ArrayList<BeanPostProcessor>());

        try {
            Class<?> applicationContextAwareProcessorClass = ClassUtils.forName(
                    "org.springframework.context.support.ApplicationContextAwareProcessor",
                    parent.getBeanClassLoader());

            for (BeanPostProcessor beanPostProcessor : new ArrayList<BeanPostProcessor>(parentPostProcessors)) {
                if (applicationContextAwareProcessorClass.isAssignableFrom(beanPostProcessor.getClass())) {
                    logger.debug("Removing parent ApplicationContextAwareProcessor");
                    parentPostProcessors.remove(beanPostProcessor);
                }
            }
        } catch (ClassNotFoundException e) {
            throw new IllegalStateException(e);
        }

        List<BeanPostProcessor> aggregatedPostProcessors = new ArrayList<BeanPostProcessor>();
        aggregatedPostProcessors.addAll(childPostProcessors);
        aggregatedPostProcessors.addAll(parentPostProcessors);

        for (BeanPostProcessor beanPostProcessor : new ArrayList<BeanPostProcessor>(aggregatedPostProcessors)) {
            for (Class<?> cls : beanPostProcessorExcludeClasses) {
                if (cls.isAssignableFrom(beanPostProcessor.getClass())) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Removing bean post processor: " + beanPostProcessor + " of type " + cls);
                    }
                    aggregatedPostProcessors.remove(beanPostProcessor);
                }
            }
        }

        beanFactory.copyConfigurationFrom(parent);

        List<BeanPostProcessor> beanPostProcessors = beanFactory instanceof AbstractBeanFactory
                ? ((AbstractBeanFactory) beanFactory).getBeanPostProcessors()
                : new ArrayList<BeanPostProcessor>();

        beanPostProcessors.clear();
        beanPostProcessors.addAll(aggregatedPostProcessors);
    }
}

---

From source file:org.springframework.context.support.AbstractApplicationContext.java

/**
 * Configure the factory's standard context characteristics,
 * such as the context's ClassLoader and post-processors.
 * @param beanFactory the BeanFactory to configure
 *///from ww  w . j  a  va 2 s  .  c o  m
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // Tell the internal bean factory to use the context's class loader etc.
    beanFactory.setBeanClassLoader(getClassLoader());
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

    // Configure the bean factory with context callbacks.
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

    // BeanFactory interface not registered as resolvable type in a plain factory.
    // MessageSource registered (and found for autowiring) as a bean.
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);

    // Register early post-processor for detecting inner beans as ApplicationListeners.
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

    // Detect a LoadTimeWeaver and prepare for weaving, if found.
    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        // Set a temporary ClassLoader for type matching.
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }

    // Register default environment beans.
    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
    }
}

---

From source file:org.springframework.context.support.AbstractApplicationContext.java

/**
 * Instantiate and invoke all registered BeanFactoryPostProcessor beans,
 * respecting explicit order if given./*from   ww w. j  a v  a2 s.  c  om*/
 * <p>Must be called before singleton instantiation.
 */
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory,
            getBeanFactoryPostProcessors());

    // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
    // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
    if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
}

---

From source file:org.springframework.flex.config.HibernateSerializationConfigPostProcessor.java

@SuppressWarnings("unchecked")
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    if (isHibernateDetected(beanFactory.getBeanClassLoader())) {

        //Make sure there is a MessageBrokerFactoryBean present
        BeanDefinition messageBrokerBeanDef = findMessageBrokerFactoryBeanDefinition(beanFactory);
        Assert.notNull(//  w  w w  . jav  a  2  s  .  c o  m
                "Could not find an appropriate bean definition for MessageBrokerBeanDefinitionFactoryBean.");

        MutablePropertyValues brokerProps = messageBrokerBeanDef.getPropertyValues();
        ManagedSet<RuntimeBeanReference> configProcessors;
        if (brokerProps.getPropertyValue(CONFIG_PROCESSORS_PROPERTY) != null) {
            configProcessors = (ManagedSet<RuntimeBeanReference>) brokerProps
                    .getPropertyValue(CONFIG_PROCESSORS_PROPERTY).getValue();
        } else {
            configProcessors = new ManagedSet<RuntimeBeanReference>();
        }

        //Abort if HibernateConfigProcessor is already present
        if (isAmfConversionServiceProcessorConfigured(beanFactory, configProcessors)) {
            return;
        }

        if (!ClassUtils.isAssignableValue(BeanDefinitionRegistry.class, beanFactory)) {
            if (log.isWarnEnabled()) {
                log.warn(
                        "Hibernate AMF serialization support could not be auto-configured because the current BeanFactory does not implement "
                                + "BeanDefinitionRegistry.  In order for this support to be enabled, you must manually configure an instance of "
                                + HIBERNATE_CONFIG_PROCESSOR_CLASS);
            }
        }

        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;

        //Add the appropriate HibernateConfigProcessor bean definition
        BeanDefinitionBuilder processorBuilder;
        if (isJpaDetected(beanFactory.getBeanClassLoader())) {
            processorBuilder = BeanDefinitionBuilder.rootBeanDefinition(JPA_HIBERNATE_CONFIG_PROCESSOR_CLASS);
        } else {
            processorBuilder = BeanDefinitionBuilder.rootBeanDefinition(HIBERNATE_CONFIG_PROCESSOR_CLASS);
        }

        String processorId = BeanDefinitionReaderUtils
                .registerWithGeneratedName(processorBuilder.getBeanDefinition(), registry);

        configProcessors.add(new RuntimeBeanReference(processorId));
    }
}

---

From source file:org.springframework.flex.config.HibernateSerializationConfigPostProcessor.java

private boolean isAmfConversionServiceProcessorConfigured(ConfigurableListableBeanFactory beanFactory,
        ManagedSet<RuntimeBeanReference> configProcessors) {

    for (RuntimeBeanReference configProcessor : configProcessors) {
        BeanDefinition bd = beanFactory.getMergedBeanDefinition(configProcessor.getBeanName());
        if (bd instanceof AbstractBeanDefinition) {
            AbstractBeanDefinition abd = (AbstractBeanDefinition) bd;
            if (!abd.hasBeanClass()) {
                try {
                    abd.resolveBeanClass(beanFactory.getBeanClassLoader());
                } catch (ClassNotFoundException ex) {
                    throw new CannotLoadBeanClassException(abd.getResourceDescription(),
                            configProcessor.getBeanName(), abd.getBeanClassName(), ex);
                }//from w  w w  .jav  a  2  s  .  co  m
            }
            if (AbstractAmfConversionServiceConfigProcessor.class.isAssignableFrom(abd.getBeanClass())) {
                return true;
            }
        }
    }
    return false;
}

---

• «
• 1
• 2
• »