Java tutorial
/* * Copyright 2006-2014 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.springframework.batch.core.configuration.support; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.List; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.beans.BeansException; import org.springframework.beans.factory.BeanFactoryAware; import org.springframework.beans.factory.config.BeanFactoryPostProcessor; import org.springframework.beans.factory.config.BeanPostProcessor; import org.springframework.beans.factory.config.ConfigurableBeanFactory; import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.beans.factory.config.CustomEditorConfigurer; import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer; import org.springframework.beans.factory.support.AbstractBeanFactory; import org.springframework.beans.factory.support.DefaultListableBeanFactory; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.context.ConfigurableApplicationContext; import org.springframework.context.support.PropertySourcesPlaceholderConfigurer; import org.springframework.util.Assert; import org.springframework.util.ClassUtils; /** * {@link ApplicationContextFactory} implementation that takes a parent context and a path to the context to create. * When createApplicationContext method is called, the child {@link ApplicationContext} will be returned. The child * context is not re-created every time it is requested, it is lazily initialized and cached. Clients should ensure that * it is closed when it is no longer needed. If a path is not set, the parent will always be returned. * */ public abstract class AbstractApplicationContextFactory implements ApplicationContextFactory, ApplicationContextAware { private static final Log logger = LogFactory.getLog(AbstractApplicationContextFactory.class); private Object[] resources; private ConfigurableApplicationContext parent; private boolean copyConfiguration = true; private Collection<Class<? extends BeanFactoryPostProcessor>> beanFactoryPostProcessorClasses; private Collection<Class<?>> beanPostProcessorExcludeClasses; /** * Create a factory instance with the resource specified. The resources are Spring configuration files or java * packages containing configuration files. */ public AbstractApplicationContextFactory(Object... resource) { this.resources = resource; beanFactoryPostProcessorClasses = new ArrayList<Class<? extends BeanFactoryPostProcessor>>(); beanFactoryPostProcessorClasses.add(PropertyPlaceholderConfigurer.class); beanFactoryPostProcessorClasses.add(PropertySourcesPlaceholderConfigurer.class); beanFactoryPostProcessorClasses.add(CustomEditorConfigurer.class); beanPostProcessorExcludeClasses = new ArrayList<Class<?>>(); /* * Assume that a BeanPostProcessor that is BeanFactoryAware must be specific to the parent and remove it from * the child (e.g. an AutoProxyCreator will not work properly). Unfortunately there might still be a a * BeanPostProcessor with a dependency that itself is BeanFactoryAware, but we can't legislate for that here. */ beanPostProcessorExcludeClasses.add(BeanFactoryAware.class); } /** * Flag to indicate that configuration such as bean post processors and custom editors should be copied from the * parent context. Defaults to true. * * @param copyConfiguration the flag value to set */ public void setCopyConfiguration(boolean copyConfiguration) { this.copyConfiguration = copyConfiguration; } /** * Protected access for subclasses to the flag determining whether configuration should be copied from parent * context. * * @return the flag value */ protected final boolean isCopyConfiguration() { return copyConfiguration; } /** * Determines which bean factory post processors (like property placeholders) should be copied from the parent * context. Defaults to {@link PropertyPlaceholderConfigurer} and {@link CustomEditorConfigurer}. * * @param beanFactoryPostProcessorClasses array of post processor types to be copied */ public void setBeanFactoryPostProcessorClasses( Class<? extends BeanFactoryPostProcessor>[] beanFactoryPostProcessorClasses) { this.beanFactoryPostProcessorClasses = new ArrayList<Class<? extends BeanFactoryPostProcessor>>(); for (int i = 0; i < beanFactoryPostProcessorClasses.length; i++) { this.beanFactoryPostProcessorClasses.add(beanFactoryPostProcessorClasses[i]); } } /** * Determines by exclusion which bean post processors should be copied from the parent context. Defaults to * {@link BeanFactoryAware} (so any post processors that have a reference to the parent bean factory are not copied * into the child). Note that these classes do not themselves have to be {@link BeanPostProcessor} implementations * or sub-interfaces. * * @param beanPostProcessorExcludeClasses the classes to set */ public void setBeanPostProcessorExcludeClasses(Class<?>[] beanPostProcessorExcludeClasses) { this.beanPostProcessorExcludeClasses = new ArrayList<Class<?>>(); for (int i = 0; i < beanPostProcessorExcludeClasses.length; i++) { this.beanPostProcessorExcludeClasses.add(beanPostProcessorExcludeClasses[i]); } } /** * Protected access to the list of bean factory post processor classes that should be copied over to the context * from the parent. * * @return the classes for post processors that were nominated for copying */ protected final Collection<Class<? extends BeanFactoryPostProcessor>> getBeanFactoryPostProcessorClasses() { return beanFactoryPostProcessorClasses; } /** * Setter for the parent application context. * * @see org.springframework.context.ApplicationContextAware#setApplicationContext(org.springframework.context.ApplicationContext) */ @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { if (applicationContext == null) { return; } Assert.isInstanceOf(ConfigurableApplicationContext.class, applicationContext); parent = (ConfigurableApplicationContext) applicationContext; } /** * Creates an {@link ApplicationContext} from the provided path. * * @see ApplicationContextFactory#createApplicationContext() */ @Override public ConfigurableApplicationContext createApplicationContext() { if (resources == null || resources.length == 0) { return parent; } return createApplicationContext(parent, resources); } protected abstract ConfigurableApplicationContext createApplicationContext( ConfigurableApplicationContext parent, Object... resources); /** * Extension point for special subclasses that want to do more complex things with the context prior to refresh. The * default implementation does nothing. * * @param parent the parent for the new application context * @param context the new application context before it is refreshed, but after bean factory is initialized * * @see AbstractApplicationContextFactory#setBeanFactoryPostProcessorClasses(Class[]) */ protected void prepareContext(ConfigurableApplicationContext parent, ConfigurableApplicationContext context) { } /** * 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) */ 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); } } @Override public String toString() { return "ApplicationContextFactory [resources=" + Arrays.toString(resources) + "]"; } @Override public int hashCode() { return toString().hashCode(); } @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } return toString().equals(obj.toString()); } }