GrepCode: org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory (.java) - Class

Maven-Central
/
org.springframework / spring-beans
/
2.5.6

3.1.1.RELEASE
3.0.6.RELEASE
3.0.5.RELEASE
3.0.4.RELEASE
3.0.3.RELEASE
3.0.2.RELEASE
3.0.1.RELEASE
3.0.0.RELEASE
2.5.6
2.5.6.SEC03
2.5.6.SEC02
2.5.5
2.5.4
2.5.3
2.5.2
2.5.1
1.2.1
/
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory
Find Usages
Diff
Raw
Download
HTML Widget
Stack Overflow Questions
1
   /*
2
    * Copyright 2002-2008 the original author or authors.
3
    *
4
    * Licensed under the Apache License, Version 2.0 (the "License");
5
    * you may not use this file except in compliance with the License.
6
    * You may obtain a copy of the License at
7
    *
8
    *      http://www.apache.org/licenses/LICENSE-2.0
9
    *
10
   * Unless required by applicable law or agreed to in writing, software
11
   * distributed under the License is distributed on an "AS IS" BASIS,
12
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
   * See the License for the specific language governing permissions and
14
   * limitations under the License.
15
   */
16
  
17
  package org.springframework.beans.factory.support;
18
  
19
  import java.beans.PropertyDescriptor;
20
  import java.lang.reflect.Constructor;
21
  import java.lang.reflect.InvocationTargetException;
22
  import java.lang.reflect.Method;
23
  import java.lang.reflect.Modifier;
24
  import java.security.AccessControlContext;
25
  import java.security.AccessController;
26
  import java.security.PrivilegedAction;
27
  import java.util.ArrayList;
28
  import java.util.Arrays;
29
  import java.util.HashMap;
30
  import java.util.HashSet;
31
  import java.util.Iterator;
32
  import java.util.LinkedHashSet;
33
  import java.util.LinkedList;
34
  import java.util.List;
35
  import java.util.Map;
36
  import java.util.Set;
37
  import java.util.TreeSet;
38
  
39
  import org.springframework.beans.BeanUtils;
40
  import org.springframework.beans.BeanWrapper;
41
  import org.springframework.beans.BeanWrapperImpl;
42
  import org.springframework.beans.BeansException;
43
  import org.springframework.beans.MutablePropertyValues;
44
  import org.springframework.beans.PropertyAccessorUtils;
45
  import org.springframework.beans.PropertyValue;
46
  import org.springframework.beans.PropertyValues;
47
  import org.springframework.beans.TypeConverter;
48
  import org.springframework.beans.factory.BeanClassLoaderAware;
49
  import org.springframework.beans.factory.BeanCreationException;
50
  import org.springframework.beans.factory.BeanCurrentlyInCreationException;
51
  import org.springframework.beans.factory.BeanDefinitionStoreException;
52
  import org.springframework.beans.factory.BeanFactory;
53
  import org.springframework.beans.factory.BeanFactoryAware;
54
  import org.springframework.beans.factory.BeanNameAware;
55
  import org.springframework.beans.factory.FactoryBean;
56
  import org.springframework.beans.factory.InitializingBean;
57
  import org.springframework.beans.factory.ObjectFactory;
58
  import org.springframework.beans.factory.UnsatisfiedDependencyException;
59
  import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
60
  import org.springframework.beans.factory.config.BeanDefinition;
61
  import org.springframework.beans.factory.config.BeanPostProcessor;
62
  import org.springframework.beans.factory.config.ConfigurableBeanFactory;
63
  import org.springframework.beans.factory.config.DependencyDescriptor;
64
  import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
65
  import org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor;
66
  import org.springframework.beans.factory.config.TypedStringValue;
67
  import org.springframework.core.CollectionFactory;
68
  import org.springframework.core.MethodParameter;
69
  import org.springframework.core.PriorityOrdered;
70
  import org.springframework.util.ClassUtils;
71
  import org.springframework.util.ObjectUtils;
72
  import org.springframework.util.ReflectionUtils;
73
  import org.springframework.util.StringUtils;

 Abstract bean factory superclass that implements default bean creation,
 with the full capabilities specified by the RootBeanDefinition class.
 Implements the org.springframework.beans.factory.config.AutowireCapableBeanFactory
 interface in addition to AbstractBeanFactory's createBean(java.lang.Class) method.

 Provides bean creation (with constructor resolution), property population,
 wiring (including autowiring), and initialization. Handles runtime bean
 references, resolves managed collections, calls initialization methods, etc.
 Supports autowiring constructors, properties by name, and properties by type.

 
The main template method to be implemented by subclasses is
 org.springframework.beans.factory.config.AutowireCapableBeanFactory.resolveDependency(org.springframework.beans.factory.config.DependencyDescriptor,java.lang.String,java.util.Set,org.springframework.beans.TypeConverter),
 used for autowiring by type. In case of a factory which is capable of searching
 its bean definitions, matching beans will typically be implemented through such
 a search. For other factory styles, simplified matching algorithms can be implemented.

 
Note that this class does not assume or implement bean definition
 registry capabilities. See DefaultListableBeanFactory for an implementation
 of the org.springframework.beans.factory.ListableBeanFactory and
 BeanDefinitionRegistry interfaces, which represent the API and SPI
 view of such a factory, respectively.

 
 Author(s):Rod JohnsonJuergen HoellerRob HarropMark Fisher Since:13.02.2004 See also:RootBeanDefinitionDefaultListableBeanFactoryBeanDefinitionRegistry
106
 
107
 public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
108
 		implements AutowireCapableBeanFactory {
109
 
110
 	private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();

	
Whether to automatically try to resolve circular references between beans
112
 
113
 	private boolean allowCircularReferences = true;

	
 Whether to resort to injecting a raw bean instance in case of circular reference,
 even if the injected bean eventually got wrapped.
 
118
 
119
 	private boolean allowRawInjectionDespiteWrapping = false;

	
 Dependency types to ignore on dependency check and autowire, as Set of
 Class objects: for example, String. Default is none.
 
124
 
125
 	private final Set ignoredDependencyTypes = new HashSet();

	
 Dependency interfaces to ignore on dependency check and autowire, as Set of
 Class objects. By default, only the BeanFactory interface is ignored.
 
130
 
131
 	private final Set ignoredDependencyInterfaces = new HashSet();

	
Cache of unfinished FactoryBean instances: FactoryBean name --> BeanWrapper
133
 
134
 	private final Map factoryBeanInstanceCache = CollectionFactory.createConcurrentMapIfPossible(16);

	
Cache of filtered PropertyDescriptors: bean Class -> PropertyDescriptor array
136
 
137
 	private final Map filteredPropertyDescriptorsCache = new HashMap();


	
 Create a new AbstractAutowireCapableBeanFactory.
 
142
 
143
 	public AbstractAutowireCapableBeanFactory() {
144
 		super();
145
 		ignoreDependencyInterface(BeanNameAware.class);
146
 		ignoreDependencyInterface(BeanFactoryAware.class);
147
 		ignoreDependencyInterface(BeanClassLoaderAware.class);
148
 	}

	
 Create a new AbstractAutowireCapableBeanFactory with the given parent.
 
 Parameters:parentBeanFactory parent bean factory, or null if none
153
 
154
 	public AbstractAutowireCapableBeanFactory(BeanFactory parentBeanFactory) {
155
 		this();
156
 		setParentBeanFactory(parentBeanFactory);
157
 	}


	
 Set the instantiation strategy to use for creating bean instances.
 Default is CglibSubclassingInstantiationStrategy.
 
 See also:CglibSubclassingInstantiationStrategy
164
 
165
 	public void setInstantiationStrategy(InstantiationStrategy instantiationStrategy) {
166
 		this.instantiationStrategy = instantiationStrategy;
167
 	}

	
 Return the instantiation strategy to use for creating bean instances.
 
171
 
172
 	protected InstantiationStrategy getInstantiationStrategy() {
173
 		return this.instantiationStrategy;
174
 	}

	
 Set whether to allow circular references between beans - and automatically
 try to resolve them.
 Note that circular reference resolution means that one of the involved beans
 will receive a reference to another bean that is not fully initialized yet.
 This can lead to subtle and not-so-subtle side effects on initialization;
 it does work fine for many scenarios, though.
 
Default is "true". Turn this off to throw an exception when encountering
 a circular reference, disallowing them completely.
 
NOTE: It is generally recommended to not rely on circular references
 between your beans. Refactor your application logic to have the two beans
 involved delegate to a third bean that encapsulates their common logic.
 
188
 
189
 	public void setAllowCircularReferences(boolean allowCircularReferences) {
190
 		this.allowCircularReferences = allowCircularReferences;
191
 	}

	
 Set whether to allow the raw injection of a bean instance into some other
 bean's property, despite the injected bean eventually getting wrapped
 (for example, through AOP auto-proxying).
 This will only be used as a last resort in case of a circular reference
 that cannot be resolved otherwise: essentially, preferring a raw instance
 getting injected over a failure of the entire bean wiring process.
 
Default is "false", as of Spring 2.0. Turn this on to allow for non-wrapped
 raw beans injected into some of your references, which was Spring 1.2's
 (arguably unclean) default behavior.
 
NOTE: It is generally recommended to not rely on circular references
 between your beans, in particular with auto-proxying involved.
 
 See also:setAllowCircularReferences(boolean)
206
 
207
 	public void setAllowRawInjectionDespiteWrapping(boolean allowRawInjectionDespiteWrapping) {
208
 		this.allowRawInjectionDespiteWrapping = allowRawInjectionDespiteWrapping;
209
 	}

	
 Ignore the given dependency type for autowiring:
 for example, String. Default is none.
 
214
 
215
 	public void ignoreDependencyType(Class type) {
216
 		this.ignoredDependencyTypes.add(type);
217
 	}

	
 Ignore the given dependency interface for autowiring.
 This will typically be used by application contexts to register
 dependencies that are resolved in other ways, like BeanFactory through
 BeanFactoryAware or ApplicationContext through ApplicationContextAware.
 
By default, only the BeanFactoryAware interface is ignored.
 For further types to ignore, invoke this method for each type.
 
 See also:org.springframework.beans.factory.BeanFactoryAwareorg.springframework.context.ApplicationContextAware
228
 
229
 	public void ignoreDependencyInterface(Class ifc) {
230
 		this.ignoredDependencyInterfaces.add(ifc);
231
 	}
232
 
233
 
234
 	public void copyConfigurationFrom(ConfigurableBeanFactory otherFactory) {
235
 		super.copyConfigurationFrom(otherFactory);
236
 		if (otherFactory instanceof AbstractAutowireCapableBeanFactory) {
237
 			AbstractAutowireCapableBeanFactory otherAutowireFactory =
238
 					(AbstractAutowireCapableBeanFactory) otherFactory;
239
 			this.instantiationStrategy = otherAutowireFactory.instantiationStrategy;
240
 			this.allowCircularReferences = otherAutowireFactory.allowCircularReferences;
241
 			this.ignoredDependencyTypes.addAll(otherAutowireFactory.ignoredDependencyTypes);
242
 			this.ignoredDependencyInterfaces.addAll(otherAutowireFactory.ignoredDependencyInterfaces);
243
 		}
244
 	}
245
 
246
 
247
 	//-------------------------------------------------------------------------
248
 	// Typical methods for creating and populating external bean instances
249
 	//-------------------------------------------------------------------------
250
 
251
 	public Object createBean(Class beanClass) throws BeansException {
252
 		// Use prototype bean definition, to avoid registering bean as dependent bean.
253
 		RootBeanDefinition bd = new RootBeanDefinition(beanClass);
254
 		bd.setScope(SCOPE_PROTOTYPE);
255
 		return createBean(beanClass.getName(), bd, null);
256
 	}
257
 
258
 	public void autowireBean(Object existingBean) {
259
 		// Use non-singleton bean definition, to avoid registering bean as dependent bean.
260
 		RootBeanDefinition bd = new RootBeanDefinition(ClassUtils.getUserClass(existingBean));
261
 		bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
262
 		BeanWrapper bw = new BeanWrapperImpl(existingBean);
263
 		initBeanWrapper(bw);
264
 		populateBean(bd.getBeanClass().getName(), bd, bw);
265
 	}
266
 
267
 	public Object configureBean(Object existingBean, String beanName) throws BeansException {
268
 		markBeanAsCreated(beanName);
269
 		BeanDefinition mbd = getMergedBeanDefinition(beanName);
270
 		RootBeanDefinition bd = null;
271
 		if (mbd instanceof RootBeanDefinition) {
272
 			RootBeanDefinition rbd = (RootBeanDefinition) mbd;
273
 			if (SCOPE_PROTOTYPE.equals(rbd.getScope())) {
274
 				bd = rbd;
275
 			}
276
 		}
277
 		if (bd == null) {
278
 			bd = new RootBeanDefinition(mbd);
279
 			bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
280
 		}
281
 		BeanWrapper bw = new BeanWrapperImpl(existingBean);
282
 		initBeanWrapper(bw);
283
 		populateBean(beanName, bd, bw);
284
 		return initializeBean(beanName, existingBean, bd);
285
 	}
286
 
287
 	public Object resolveDependency(DependencyDescriptor descriptor, String beanName) throws BeansException {
288
 		return resolveDependency(descriptor, beanName, null, null);
289
 	}
290
 
291
 
292
 	//-------------------------------------------------------------------------
293
 	// Specialized methods for fine-grained control over the bean lifecycle
294
 	//-------------------------------------------------------------------------
295
 
296
 	public Object createBean(Class beanClass, int autowireMode, boolean dependencyCheck) throws BeansException {
297
 		// Use non-singleton bean definition, to avoid registering bean as dependent bean.
298
 		RootBeanDefinition bd = new RootBeanDefinition(beanClass, autowireMode, dependencyCheck);
299
 		bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
300
 		return createBean(beanClass.getName(), bd, null);
301
 	}
302
 
303
 	public Object autowire(Class beanClass, int autowireMode, boolean dependencyCheck) throws BeansException {
304
 		// Use non-singleton bean definition, to avoid registering bean as dependent bean.
305
 		RootBeanDefinition bd = new RootBeanDefinition(beanClass, autowireMode, dependencyCheck);
306
 		bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
307
 		if (bd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR) {
308
 			return autowireConstructor(beanClass.getName(), bd, null, null).getWrappedInstance();
309
 		}
310
 		else {
311
 			Object bean = getInstantiationStrategy().instantiate(bd, null, this);
312
 			populateBean(beanClass.getName(), bd, new BeanWrapperImpl(bean));
313
 			return bean;
314
 		}
315
 	}
316
 
317
 	public void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
318
 			throws BeansException {
319
 
320
 		if (autowireMode == AUTOWIRE_CONSTRUCTOR) {
321
 			throw new IllegalArgumentException("AUTOWIRE_CONSTRUCTOR not supported for existing bean instance");
322
 		}
323
 		// Use non-singleton bean definition, to avoid registering bean as dependent bean.
324
 		RootBeanDefinition bd =
325
 				new RootBeanDefinition(ClassUtils.getUserClass(existingBean), autowireMode, dependencyCheck);
326
 		bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
327
 		BeanWrapper bw = new BeanWrapperImpl(existingBean);
328
 		initBeanWrapper(bw);
329
 		populateBean(bd.getBeanClass().getName(), bd, bw);
330
 	}
331
 
332
 	public void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException {
333
 		markBeanAsCreated(beanName);
334
 		BeanDefinition bd = getMergedBeanDefinition(beanName);
335
 		BeanWrapper bw = new BeanWrapperImpl(existingBean);
336
 		initBeanWrapper(bw);
337
 		applyPropertyValues(beanName, bd, bw, bd.getPropertyValues());
338
 	}
339
 
340
 	public Object initializeBean(Object existingBean, String beanName) {
341
 		return initializeBean(beanName, existingBean, null);
342
 	}
343
 
344
 	public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
345
 			throws BeansException {
346
 
347
 		Object result = existingBean;
348
 		for (Iterator it = getBeanPostProcessors().iterator(); it.hasNext();) {
349
 			BeanPostProcessor beanProcessor = (BeanPostProcessor) it.next();
350
 			result = beanProcessor.postProcessBeforeInitialization(result, beanName);
351
 		}
352
 		return result;
353
 	}
354
 
355
 	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
356
 			throws BeansException {
357
 
358
 		Object result = existingBean;
359
 		for (Iterator it = getBeanPostProcessors().iterator(); it.hasNext();) {
360
 			BeanPostProcessor beanProcessor = (BeanPostProcessor) it.next();
361
 			result = beanProcessor.postProcessAfterInitialization(result, beanName);
362
 		}
363
 		return result;
364
 	}
365
 
366
 
367
 	//---------------------------------------------------------------------
368
 	// Implementation of relevant AbstractBeanFactory template methods
369
 	//---------------------------------------------------------------------
370
 
	
 Central method of this class: creates a bean instance,
 populates the bean instance, applies post-processors, etc.
 
 See also:doCreateBean(java.lang.String,org.springframework.beans.factory.support.RootBeanDefinition,java.lang.Object[])
375
 
376
 	protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
377
 			throws BeanCreationException {
378
 
379
 		AccessControlContext acc = AccessController.getContext();
380
 		return AccessController.doPrivileged(new PrivilegedAction() {
381
 			public Object run() {
382
 				if (logger.isDebugEnabled()) {
383
 					logger.debug("Creating instance of bean '" + beanName + "'");
384
 				}
385
 				// Make sure bean class is actually resolved at this point.
386
 				resolveBeanClass(mbd, beanName);
387
 
388
 				// Prepare method overrides.
389
 				try {
390
 					mbd.prepareMethodOverrides();
391
 				}
392
 				catch (BeanDefinitionValidationException ex) {
393
 					throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
394
 							beanName, "Validation of method overrides failed", ex);
395
 				}
396
 
397
 				try {
398
 					// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
399
 					Object bean = resolveBeforeInstantiation(beanName, mbd);
400
 					if (bean != null) {
401
 						return bean;
402
 					}
403
 				}
404
 				catch (Throwable ex) {
405
 					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
406
 							"BeanPostProcessor before instantiation of bean failed", ex);
407
 				}
408
 
409
 				Object beanInstance = doCreateBean(beanName, mbd, args);
410
 				if (logger.isDebugEnabled()) {
411
 					logger.debug("Finished creating instance of bean '" + beanName + "'");
412
 				}
413
 				return beanInstance;
414
 			}
415
 		}, acc);
416
 	}

	
 Actually create the specified bean. Pre-creation processing has already happened
 at this point, e.g. checking postProcessBeforeInstantiation callbacks.
 Differentiates between default bean instantiation, use of a
 factory method, and autowiring a constructor.
 
 Parameters:beanName the name of the beanmbd the merged bean definition for the beanargs arguments to use if creating a prototype using explicit arguments to a
 static factory method. This parameter must be null except in this case. Returns:a new instance of the bean Throws:org.springframework.beans.factory.BeanCreationException if the bean could not be created See also:instantiateBean(java.lang.String,org.springframework.beans.factory.support.RootBeanDefinition)instantiateUsingFactoryMethod(java.lang.String,org.springframework.beans.factory.support.RootBeanDefinition,java.lang.Object[])autowireConstructor(java.lang.String,org.springframework.beans.factory.support.RootBeanDefinition,java.lang.reflect.Constructor[],java.lang.Object[])
432
 
433
 	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
434
 		// Instantiate the bean.
435
 		BeanWrapper instanceWrapper = null;
436
 		if (mbd.isSingleton()) {
437
 			instanceWrapper = (BeanWrapper) this.factoryBeanInstanceCache.remove(beanName);
438
 		}
439
 		if (instanceWrapper == null) {
440
 			instanceWrapper = createBeanInstance(beanName, mbd, args);
441
 		}
442
 		final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
443
 		Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
444
 
445
 		// Allow post-processors to modify the merged bean definition.
446
 		synchronized (mbd.postProcessingLock) {
447
 			if (!mbd.postProcessed) {
448
 				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
449
 				mbd.postProcessed = true;
450
 			}
451
 		}
452
 
453
 		// Eagerly cache singletons to be able to resolve circular references
454
 		// even when triggered by lifecycle interfaces like BeanFactoryAware.
455
 		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
456
 				isSingletonCurrentlyInCreation(beanName));
457
 		if (earlySingletonExposure) {
458
 			if (logger.isDebugEnabled()) {
459
 				logger.debug("Eagerly caching bean '" + beanName +
460
 						"' to allow for resolving potential circular references");
461
 			}
462
 			addSingletonFactory(beanName, new ObjectFactory() {
463
 				public Object getObject() throws BeansException {
464
 					return getEarlyBeanReference(beanName, mbd, bean);
465
 				}
466
 			});
467
 		}
468
 
469
 		// Initialize the bean instance.
470
 		Object exposedObject = bean;
471
 		try {
472
 			populateBean(beanName, mbd, instanceWrapper);
473
 			exposedObject = initializeBean(beanName, exposedObject, mbd);
474
 		}
475
 		catch (Throwable ex) {
476
 			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
477
 				throw (BeanCreationException) ex;
478
 			}
479
 			else {
480
 				throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
481
 			}
482
 		}
483
 
484
 		if (earlySingletonExposure) {
485
 			Object earlySingletonReference = getSingleton(beanName, false);
486
 			if (earlySingletonReference != null) {
487
 				if (exposedObject == bean) {
488
 					exposedObject = earlySingletonReference;
489
 				}
490
 				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
491
 					String[] dependentBeans = getDependentBeans(beanName);
492
 					Set actualDependentBeans = new LinkedHashSet(dependentBeans.length);
493
 					for (int i = 0; i < dependentBeans.length; i++) {
494
 						String dependentBean = dependentBeans[i];
495
 						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
496
 							actualDependentBeans.add(dependentBean);
497
 						}
498
 					}
499
 					if (!actualDependentBeans.isEmpty()) {
500
 						throw new BeanCurrentlyInCreationException(beanName,
501
 								"Bean with name '" + beanName + "' has been injected into other beans [" +
502
 								StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
503
 								"] in its raw version as part of a circular reference, but has eventually been " +
504
 								"wrapped. This means that said other beans do not use the final version of the " +
505
 								"bean. This is often the result of over-eager type matching - consider using " +
506
 								"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
507
 					}
508
 				}
509
 			}
510
 		}
511
 
512
 		// Register bean as disposable.
513
 		registerDisposableBeanIfNecessary(beanName, bean, mbd);
514
 
515
 		return exposedObject;
516
 	}
517
 
518
 	protected Class predictBeanType(String beanName, RootBeanDefinition mbd, Class[] typesToMatch) {
519
 		Class beanClass = null;
520
 		if (mbd.getFactoryMethodName() != null) {
521
 			beanClass = getTypeForFactoryMethod(beanName, mbd, typesToMatch);
522
 		}
523
 		else {
524
 			beanClass = resolveBeanClass(mbd, beanName, typesToMatch);
525
 		}
526
 		// Apply SmartInstantiationAwareBeanPostProcessors to predict the
527
 		// eventual type after a before-instantiation shortcut.
528
 		if (beanClass != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
529
 			for (Iterator it = getBeanPostProcessors().iterator(); it.hasNext(); ) {
530
 				BeanPostProcessor bp = (BeanPostProcessor) it.next();
531
 				if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
532
 					SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
533
 					Class processedType = ibp.predictBeanType(beanClass, beanName);
534
 					if (processedType != null) {
535
 						return processedType;
536
 					}
537
 				}
538
 			}
539
 		}
540
 		return beanClass;
541
 	}

	
 Determine the bean type for the given bean definition which is based on
 a factory method. Only called if there is no singleton instance registered
 for the target bean already.
 This implementation determines the type matching createBean(java.lang.Class)'s
 different creation strategies. As far as possible, we'll perform static
 type checking to avoid creation of the target bean.
 
 Parameters:beanName the name of the bean (for error handling purposes)mbd the merged bean definition for the beantypesToMatch the types to match in case of internal type matching purposes
 (also signals that the returned Class will never be exposed to application code) Returns:the type for the bean if determinable, or null else See also:createBean(java.lang.Class)
556
 
557
 	protected Class getTypeForFactoryMethod(String beanName, RootBeanDefinition mbd, Class[] typesToMatch) {
558
 		Class factoryClass = null;
559
 		boolean isStatic = true;
560
 
561
 		String factoryBeanName = mbd.getFactoryBeanName();
562
 		if (factoryBeanName != null) {
563
 			if (factoryBeanName.equals(beanName)) {
564
 				throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
565
 						"factory-bean reference points back to the same bean definition");
566
 			}
567
 			// Check declared factory method return type on factory class.
568
 			factoryClass = getType(factoryBeanName);
569
 			isStatic = false;
570
 		}
571
 		else {
572
 			// Check declared factory method return type on bean class.
573
 			factoryClass = resolveBeanClass(mbd, beanName, typesToMatch);
574
 		}
575
 
576
 		if (factoryClass == null) {
577
 			return null;
578
 		}
579
 
580
 		// If all factory methods have the same return type, return that type.
581
 		// Can't clearly figure out exact method due to type converting / autowiring!
582
 		int minNrOfArgs = mbd.getConstructorArgumentValues().getArgumentCount();
583
 		Method[] candidates = ReflectionUtils.getAllDeclaredMethods(factoryClass);
584
 		Set returnTypes = new HashSet(1);
585
 		for (int i = 0; i < candidates.length; i++) {
586
 			Method factoryMethod = candidates[i];
587
 			if (Modifier.isStatic(factoryMethod.getModifiers()) == isStatic &&
588
 					factoryMethod.getName().equals(mbd.getFactoryMethodName()) &&
589
 					factoryMethod.getParameterTypes().length >= minNrOfArgs) {
590
 				returnTypes.add(factoryMethod.getReturnType());
591
 			}
592
 		}
593
 
594
 		if (returnTypes.size() == 1) {
595
 			// Clear return type found: all factory methods return same type.
596
 			return (Class) returnTypes.iterator().next();
597
 		}
598
 		else {
599
 			// Ambiguous return types found: return null to indicate "not determinable".
600
 			return null;
601
 		}
602
 	}

	
 This implementation checks the FactoryBean's getObjectType method
 on a plain instance of the FactoryBean, without bean properties applied yet.
 If this doesn't return a type yet, a full creation of the FactoryBean is
 used as fallback (through delegation to the superclass's implementation).
 The shortcut check for a FactoryBean is only applied in case of a singleton
 FactoryBean. If the FactoryBean instance itself is not kept as singleton,
 it will be fully created to check the type of its exposed object.
 
612
 
613
 	protected Class getTypeForFactoryBean(String beanName, RootBeanDefinition mbd) {
614
 		FactoryBean fb = (mbd.isSingleton() ?
615
 				getSingletonFactoryBeanForTypeCheck(beanName, mbd) :
616
 				getNonSingletonFactoryBeanForTypeCheck(beanName, mbd));
617
 
618
 		if (fb != null) {
619
 			// Try to obtain the FactoryBean's object type from this early stage of the instance.
620
 			Class objectType = getTypeForFactoryBean(fb);
621
 			if (objectType != null) {
622
 				return objectType;
623
 			}
624
 		}
625
 
626
 		// No type found - fall back to full creation of the FactoryBean instance.
627
 		return super.getTypeForFactoryBean(beanName, mbd);
628
 	}

	
 Obtain a reference for early access to the specified bean,
 typically for the purpose of resolving a circular reference.
 
 Parameters:beanName the name of the bean (for error handling purposes)mbd the merged bean definition for the beanbean the raw bean instance Returns:the object to expose as bean reference
637
 
638
 	protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
639
 		Object exposedObject = bean;
640
 		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
641
 			for (Iterator it = getBeanPostProcessors().iterator(); it.hasNext(); ) {
642
 				BeanPostProcessor bp = (BeanPostProcessor) it.next();
643
 				if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
644
 					SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
645
 					exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
646
 				}
647
 			}
648
 		}
649
 		return exposedObject;
650
 	}
651
 
652
 
653
 	//---------------------------------------------------------------------
654
 	// Implementation methods
655
 	//---------------------------------------------------------------------
656
 
	
 Obtain a "shortcut" singleton FactoryBean instance to use for a
 getObjectType() call, without full initialization
 of the FactoryBean.
 
 Parameters:beanName the name of the beanmbd the bean definition for the bean Returns:the FactoryBean instance, or null to indicate
 that we couldn't obtain a shortcut FactoryBean instance
665
 
666
 	private FactoryBean getSingletonFactoryBeanForTypeCheck(String beanName, RootBeanDefinition mbd) {
667
 		synchronized (getSingletonMutex()) {
668
 			BeanWrapper bw = (BeanWrapper) this.factoryBeanInstanceCache.get(beanName);
669
 			if (bw != null) {
670
 				return (FactoryBean) bw.getWrappedInstance();
671
 			}
672
 			if (isSingletonCurrentlyInCreation(beanName)) {
673
 				return null;
674
 			}
675
 			Object instance = null;
676
 			try {
677
 				// Mark this bean as currently in creation, even if just partially.
678
 				beforeSingletonCreation(beanName);
679
 				// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
680
 				instance = resolveBeforeInstantiation(beanName, mbd);
681
 				if (instance == null) {
682
 					bw = createBeanInstance(beanName, mbd, null);
683
 					instance = bw.getWrappedInstance();
684
 				}
685
 			}
686
 			finally {
687
 				// Finished partial creation of this bean.
688
 				afterSingletonCreation(beanName);
689
 			}
690
 			FactoryBean fb = getFactoryBean(beanName, instance);
691
 			if (bw != null) {
692
 				this.factoryBeanInstanceCache.put(beanName, bw);
693
 			}
694
 			return fb;
695
 		}
696
 	}

	
 Obtain a "shortcut" non-singleton FactoryBean instance to use for a
 getObjectType() call, without full initialization
 of the FactoryBean.
 
 Parameters:beanName the name of the beanmbd the bean definition for the bean Returns:the FactoryBean instance, or null to indicate
 that we couldn't obtain a shortcut FactoryBean instance
706
 
707
 	private FactoryBean getNonSingletonFactoryBeanForTypeCheck(String beanName, RootBeanDefinition mbd) {
708
 		if (isPrototypeCurrentlyInCreation(beanName)) {
709
 			return null;
710
 		}
711
 		Object instance = null;
712
 		try {
713
 			// Mark this bean as currently in creation, even if just partially.
714
 			beforePrototypeCreation(beanName);
715
 			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
716
 			instance = resolveBeforeInstantiation(beanName, mbd);
717
 			if (instance == null) {
718
 				BeanWrapper bw = createBeanInstance(beanName, mbd, null);
719
 				instance = bw.getWrappedInstance();
720
 			}
721
 		}
722
 		finally {
723
 			// Finished partial creation of this bean.
724
 			afterPrototypeCreation(beanName);
725
 		}
726
 		return getFactoryBean(beanName, instance);
727
 	}

	
 Apply MergedBeanDefinitionPostProcessors to the specified bean definition,
 invoking their postProcessMergedBeanDefinition methods.
 
 Parameters:mbd the merged bean definition for the beanbeanType the actual type of the managed bean instancebeanName the name of the bean Throws:org.springframework.beans.BeansException if any post-processing failed See also:MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition(org.springframework.beans.factory.support.RootBeanDefinition,java.lang.Class,java.lang.String)
737
 
738
 	protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class beanType, String beanName)
739
 			throws BeansException {
740
 
741
 		for (Iterator it = getBeanPostProcessors().iterator(); it.hasNext();) {
742
 			BeanPostProcessor beanProcessor = (BeanPostProcessor) it.next();
743
 			if (beanProcessor instanceof MergedBeanDefinitionPostProcessor) {
744
 				MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) beanProcessor;
745
 				bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
746
 			}
747
 		}
748
 	}

	
 Apply before-instantiation post-processors, resolving whether there is a
 before-instantiation shortcut for the specified bean.
 
 Parameters:beanName the name of the beanmbd the bean definition for the bean Returns:the shortcut-determined bean instance, or null if none
756
 
757
 	protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
758
 		Object bean = null;
759
 		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
760
 			// Make sure bean class is actually resolved at this point.
761
 			if (mbd.hasBeanClass() && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
762
 				bean = applyBeanPostProcessorsBeforeInstantiation(mbd.getBeanClass(), beanName);
763
 				if (bean != null) {
764
 					bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
765
 				}
766
 			}
767
 			mbd.beforeInstantiationResolved = Boolean.valueOf(bean != null);
768
 		}
769
 		return bean;
770
 	}

	
 Apply InstantiationAwareBeanPostProcessors to the specified bean definition
 (by class and name), invoking their postProcessBeforeInstantiation methods.
 Any returned object will be used as the bean instead of actually instantiating
 the target bean. A null return value from the post-processor will
 result in the target bean being instantiated.
 
 Parameters:beanClass the class of the bean to be instantiatedbeanName the name of the bean Returns:the bean object to use instead of a default instance of the target bean, or null Throws:org.springframework.beans.BeansException if any post-processing failed See also:org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(java.lang.Class,java.lang.String)
783
 
784
 	protected Object applyBeanPostProcessorsBeforeInstantiation(Class beanClass, String beanName)
785
 			throws BeansException {
786
 
787
 		for (Iterator it = getBeanPostProcessors().iterator(); it.hasNext();) {
788
 			BeanPostProcessor beanProcessor = (BeanPostProcessor) it.next();
789
 			if (beanProcessor instanceof InstantiationAwareBeanPostProcessor) {
790
 				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) beanProcessor;
791
 				Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
792
 				if (result != null) {
793
 					return result;
794
 				}
795
 			}
796
 		}
797
 		return null;
798
 	}

	
 Create a new instance for the specified bean, using an appropriate instantiation strategy:
 factory method, constructor autowiring, or simple instantiation.
 
 Parameters:beanName the name of the beanmbd the bean definition for the beanargs arguments to use if creating a prototype using explicit arguments to a
 static factory method. It is invalid to use a non-null args value in any other case. Returns:BeanWrapper for the new instance See also:instantiateUsingFactoryMethod(java.lang.String,org.springframework.beans.factory.support.RootBeanDefinition,java.lang.Object[])autowireConstructor(java.lang.String,org.springframework.beans.factory.support.RootBeanDefinition,java.lang.reflect.Constructor[],java.lang.Object[])instantiateBean(java.lang.String,org.springframework.beans.factory.support.RootBeanDefinition)
811
 
812
 	protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
813
 		// Make sure bean class is actually resolved at this point.
814
 		Class beanClass = resolveBeanClass(mbd, beanName);
815
 
816
 		if (mbd.getFactoryMethodName() != null)  {
817
 			return instantiateUsingFactoryMethod(beanName, mbd, args);
818
 		}
819
 
820
 		// Shortcut when re-creating the same bean...
821
 		if (mbd.resolvedConstructorOrFactoryMethod != null) {
822
 			if (mbd.constructorArgumentsResolved) {
823
 				return autowireConstructor(beanName, mbd, null, args);
824
 			}
825
 			else {
826
 				return instantiateBean(beanName, mbd);
827
 			}
828
 		}
829
 
830
 		// Need to determine the constructor...
831
 		Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
832
 		if (ctors != null ||
833
 				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
834
 				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
835
 			return autowireConstructor(beanName, mbd, ctors, args);
836
 		}
837
 
838
 		// No special handling: simply use no-arg constructor.
839
 		return instantiateBean(beanName, mbd);
840
 	}

	
 Determine candidate constructors to use for the given bean, checking all registered
 SmartInstantiationAwareBeanPostProcessors.
 
 Parameters:beanClass the raw class of the beanbeanName the name of the bean Returns:the candidate constructors, or null if none specified Throws:org.springframework.beans.BeansException in case of errors See also:org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors(java.lang.Class,java.lang.String)
850
 
851
 	protected Constructor[] determineConstructorsFromBeanPostProcessors(Class beanClass, String beanName)
852
 			throws BeansException {
853
 
854
 		if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
855
 			for (Iterator it = getBeanPostProcessors().iterator(); it.hasNext();) {
856
 				BeanPostProcessor beanProcessor = (BeanPostProcessor) it.next();
857
 				if (beanProcessor instanceof SmartInstantiationAwareBeanPostProcessor) {
858
 					SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) beanProcessor;
859
 					Constructor[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
860
 					if (ctors != null) {
861
 						return ctors;
862
 					}
863
 				}
864
 			}
865
 		}
866
 		return null;
867
 	}

	
 Instantiate the given bean using its default constructor.
 
 Parameters:beanName the name of the beanmbd the bean definition for the bean Returns:BeanWrapper for the new instance
874
 
875
 	protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
876
 		try {
877
 			Object beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
878
 			BeanWrapper bw = new BeanWrapperImpl(beanInstance);
879
 			initBeanWrapper(bw);
880
 			return bw;
881
 		}
882
 		catch (Throwable ex) {
883
 			throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
884
 		}
885
 	}

	
 Instantiate the bean using a named factory method. The method may be static, if the
 mbd parameter specifies a class, rather than a factoryBean, or an instance variable
 on a factory object itself configured using Dependency Injection.
 
 Parameters:beanName the name of the beanmbd the bean definition for the beanexplicitArgs argument values passed in programmatically via the getBean method,
 or null if none (-> use constructor argument values from bean definition) Returns:BeanWrapper for the new instance See also:AbstractBeanFactory.getBean(java.lang.String,java.lang.Object[])
897
 
898
 	protected BeanWrapper instantiateUsingFactoryMethod(
899
 			String beanName, RootBeanDefinition mbd, Object[] explicitArgs) {
900
 
901
 		ConstructorResolver constructorResolver =
902
 				new ConstructorResolver(this, this, getInstantiationStrategy(), getCustomTypeConverter());
903
 		return constructorResolver.instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
904
 	}

	
 "autowire constructor" (with constructor arguments by type) behavior.
 Also applied if explicit constructor argument values are specified,
 matching all remaining arguments with beans from the bean factory.
 This corresponds to constructor injection: In this mode, a Spring
 bean factory is able to host components that expect constructor-based
 dependency resolution.
 
 Parameters:beanName the name of the beanmbd the bean definition for the beanctors the chosen candidate constructorsexplicitArgs argument values passed in programmatically via the getBean method,
 or null if none (-> use constructor argument values from bean definition) Returns:BeanWrapper for the new instance
919
 
920
 	protected BeanWrapper autowireConstructor(
921
 			String beanName, RootBeanDefinition mbd, Constructor[] ctors, Object[] explicitArgs) {
922
 
923
 		ConstructorResolver constructorResolver =
924
 				new ConstructorResolver(this, this, getInstantiationStrategy(), getCustomTypeConverter());
925
 		return constructorResolver.autowireConstructor(beanName, mbd, ctors, explicitArgs);
926
 	}

	
 Populate the bean instance in the given BeanWrapper with the property values
 from the bean definition.
 
 Parameters:beanName the name of the beanmbd the bean definition for the beanbw BeanWrapper with bean instance
934
 
935
 	protected void populateBean(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw) {
936
 		PropertyValues pvs = mbd.getPropertyValues();
937
 
938
 		if (bw == null) {
939
 			if (!pvs.isEmpty()) {
940
 				throw new BeanCreationException(
941
 						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
942
 			}
943
 			else {
944
 				// Skip property population phase for null instance.
945
 				return;
946
 			}
947
 		}
948
 
949
 		// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
950
 		// state of the bean before properties are set. This can be used, for example,
951
 		// to support styles of field injection.
952
 		boolean continueWithPropertyPopulation = true;
953
 
954
 		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
955
 			for (Iterator it = getBeanPostProcessors().iterator(); it.hasNext();) {
956
 				BeanPostProcessor beanProcessor = (BeanPostProcessor) it.next();
957
 				if (beanProcessor instanceof InstantiationAwareBeanPostProcessor) {
958
 					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) beanProcessor;
959
 					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
960
 						continueWithPropertyPopulation = false;
961
 						break;
962
 					}
963
 				}
964
 			}
965
 		}
966
 
967
 		if (!continueWithPropertyPopulation) {
968
 			return;
969
 		}
970
 
971
 		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
972
 				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
973
 			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
974
 
975
 			// Add property values based on autowire by name if applicable.
976
 			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
977
 				autowireByName(beanName, mbd, bw, newPvs);
978
 			}
979
 
980
 			// Add property values based on autowire by type if applicable.
981
 			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
982
 				autowireByType(beanName, mbd, bw, newPvs);
983
 			}
984
 
985
 			pvs = newPvs;
986
 		}
987
 
988
 		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
989
 		boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
990
 
991
 		if (hasInstAwareBpps || needsDepCheck) {
992
 			PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw);
993
 			if (hasInstAwareBpps) {
994
 				for (Iterator it = getBeanPostProcessors().iterator(); it.hasNext(); ) {
995
 					BeanPostProcessor beanProcessor = (BeanPostProcessor) it.next();
996
 					if (beanProcessor instanceof InstantiationAwareBeanPostProcessor) {
997
 						InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) beanProcessor;
998
 						pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
999
 						if (pvs == null) {
1000
							return;
1001
						}
1002
					}
1003
				}
1004
			}
1005
			if (needsDepCheck) {
1006
				checkDependencies(beanName, mbd, filteredPds, pvs);
1007
			}
1008
		}
1009
1010
		applyPropertyValues(beanName, mbd, bw, pvs);
1011
	}

	
 Fill in any missing property values with references to
 other beans in this factory if autowire is set to "byName".
 
 Parameters:beanName the name of the bean we're wiring up.
 Useful for debugging messages; not used functionally.mbd bean definition to update through autowiringbw BeanWrapper from which we can obtain information about the beanpvs the PropertyValues to register wired objects with
1021
1022
	protected void autowireByName(
1023
			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
1024
1025
		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
1026
		for (int i = 0; i < propertyNames.length; i++) {
1027
			String propertyName = propertyNames[i];
1028
			if (containsBean(propertyName)) {
1029
				Object bean = getBean(propertyName);
1030
				pvs.addPropertyValue(propertyName, bean);
1031
				registerDependentBean(propertyName, beanName);
1032
				if (logger.isDebugEnabled()) {
1033
					logger.debug("Added autowiring by name from bean name '" + beanName +
1034
						"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
1035
				}
1036
			}
1037
			else {
1038
				if (logger.isTraceEnabled()) {
1039
					logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
1040
							"' by name: no matching bean found");
1041
				}
1042
			}
1043
		}
1044
	}

	
 Abstract method defining "autowire by type" (bean properties by type) behavior.
 This is like PicoContainer default, in which there must be exactly one bean
 of the property type in the bean factory. This makes bean factories simple to
 configure for small namespaces, but doesn't work as well as standard Spring
 behavior for bigger applications.
 
 Parameters:beanName the name of the bean to autowire by typembd the merged bean definition to update through autowiringbw BeanWrapper from which we can obtain information about the beanpvs the PropertyValues to register wired objects with
1056
1057
	protected void autowireByType(
1058
			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
1059
1060
		TypeConverter converter = getCustomTypeConverter();
1061
		if (converter == null) {
1062
			converter = bw;
1063
		}
1064
1065
		Set autowiredBeanNames = new LinkedHashSet(4);
1066
		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
1067
		for (int i = 0; i < propertyNames.length; i++) {
1068
			String propertyName = propertyNames[i];
1069
			try {
1070
				PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
1071
				MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
1072
				// Do not allow eager init for type matching in case of a prioritized post-processor.
1073
				boolean eager = !PriorityOrdered.class.isAssignableFrom(bw.getWrappedClass());
1074
				DependencyDescriptor desc = new DependencyDescriptor(methodParam, false, eager);
1075
1076
				Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
1077
				if (autowiredArgument != null) {
1078
					pvs.addPropertyValue(propertyName, autowiredArgument);
1079
				}
1080
				for (Iterator it = autowiredBeanNames.iterator(); it.hasNext();) {
1081
					String autowiredBeanName = (String) it.next();
1082
					registerDependentBean(autowiredBeanName, beanName);
1083
					if (logger.isDebugEnabled()) {
1084
						logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" +
1085
								propertyName + "' to bean named '" + autowiredBeanName + "'");
1086
					}
1087
				}
1088
				autowiredBeanNames.clear();
1089
			}
1090
			catch (BeansException ex) {
1091
				throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
1092
			}
1093
		}
1094
	}


	
 Return an array of non-simple bean properties that are unsatisfied.
 These are probably unsatisfied references to other beans in the
 factory. Does not include simple properties like primitives or Strings.
 
 Parameters:mbd the merged bean definition the bean was created withbw the BeanWrapper the bean was created with Returns:an array of bean property names See also:org.springframework.beans.BeanUtils.isSimpleProperty(java.lang.Class)
1105
1106
	protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
1107
		Set result = new TreeSet();
1108
		PropertyValues pvs = mbd.getPropertyValues();
1109
		PropertyDescriptor[] pds = bw.getPropertyDescriptors();
1110
		for (int i = 0; i < pds.length; i++) {
1111
			if (pds[i].getWriteMethod() != null && !isExcludedFromDependencyCheck(pds[i]) &&
1112
					!pvs.contains(pds[i].getName()) && !BeanUtils.isSimpleProperty(pds[i].getPropertyType())) {
1113
				result.add(pds[i].getName());
1114
			}
1115
		}
1116
		return StringUtils.toStringArray(result);
1117
	}

	
 Extract a filtered set of PropertyDescriptors from the given BeanWrapper,
 excluding ignored dependency types or properties defined on ignored
 dependency interfaces.
 
 Parameters:bw the BeanWrapper the bean was created with Returns:the filtered PropertyDescriptors See also:isExcludedFromDependencyCheck(java.beans.PropertyDescriptor)
1126
1127
	protected PropertyDescriptor[] filterPropertyDescriptorsForDependencyCheck(BeanWrapper bw) {
1128
		synchronized (this.filteredPropertyDescriptorsCache) {
1129
			PropertyDescriptor[] filtered = (PropertyDescriptor[])
1130
					this.filteredPropertyDescriptorsCache.get(bw.getWrappedClass());
1131
			if (filtered == null) {
1132
				List pds = new LinkedList(Arrays.asList(bw.getPropertyDescriptors()));
1133
				for (Iterator it = pds.iterator(); it.hasNext();) {
1134
					PropertyDescriptor pd = (PropertyDescriptor) it.next();
1135
					if (isExcludedFromDependencyCheck(pd)) {
1136
						it.remove();
1137
					}
1138
				}
1139
				filtered = (PropertyDescriptor[]) pds.toArray(new PropertyDescriptor[pds.size()]);
1140
				this.filteredPropertyDescriptorsCache.put(bw.getWrappedClass(), filtered);
1141
			}
1142
			return filtered;
1143
		}
1144
	}

	
 Determine whether the given bean property is excluded from dependency checks.
 This implementation excludes properties defined by CGLIB and
 properties whose type matches an ignored dependency type or which
 are defined by an ignored dependency interface.
 
 Parameters:pd the PropertyDescriptor of the bean property Returns:whether the bean property is excluded See also:ignoreDependencyType(java.lang.Class)ignoreDependencyInterface(java.lang.Class)
1155
1156
	protected boolean isExcludedFromDependencyCheck(PropertyDescriptor pd) {
1157
		return (AutowireUtils.isExcludedFromDependencyCheck(pd) ||
1158
				this.ignoredDependencyTypes.contains(pd.getPropertyType()) ||
1159
				AutowireUtils.isSetterDefinedInInterface(pd, this.ignoredDependencyInterfaces));
1160
	}

	
 Perform a dependency check that all properties exposed have been set,
 if desired. Dependency checks can be objects (collaborating beans),
 simple (primitives and String), or all (both).
 
 Parameters:beanName the name of the beanmbd the merged bean definition the bean was created withpds the relevant property descriptors for the target beanpvs the property values to be applied to the bean See also:isExcludedFromDependencyCheck(java.beans.PropertyDescriptor)
1171
1172
	protected void checkDependencies(
1173
			String beanName, AbstractBeanDefinition mbd, PropertyDescriptor[] pds, PropertyValues pvs)
1174
			throws UnsatisfiedDependencyException {
1175
1176
		int dependencyCheck = mbd.getDependencyCheck();
1177
		for (int i = 0; i < pds.length; i++) {
1178
			if (pds[i].getWriteMethod() != null && !pvs.contains(pds[i].getName())) {
1179
				boolean isSimple = BeanUtils.isSimpleProperty(pds[i].getPropertyType());
1180
				boolean unsatisfied = (dependencyCheck == RootBeanDefinition.DEPENDENCY_CHECK_ALL) ||
1181
					(isSimple && dependencyCheck == RootBeanDefinition.DEPENDENCY_CHECK_SIMPLE) ||
1182
					(!isSimple && dependencyCheck == RootBeanDefinition.DEPENDENCY_CHECK_OBJECTS);
1183
				if (unsatisfied) {
1184
					throw new UnsatisfiedDependencyException(
1185
							mbd.getResourceDescription(), beanName, pds[i].getName(),
1186
							"Set this property value or disable dependency checking for this bean.");
1187
				}
1188
			}
1189
		}
1190
	}

	
 Apply the given property values, resolving any runtime references
 to other beans in this bean factory. Must use deep copy, so we
 don't permanently modify this property.
 
 Parameters:beanName the bean name passed for better exception informationmbd the merged bean definitionbw the BeanWrapper wrapping the target objectpvs the new property values
1200
1201
	protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
1202
		if (pvs == null || pvs.isEmpty()) {
1203
			return;
1204
		}
1205
1206
		MutablePropertyValues mpvs = null;
1207
		List original = null;
1208
1209
		if (pvs instanceof MutablePropertyValues) {
1210
			mpvs = (MutablePropertyValues) pvs;
1211
			if (mpvs.isConverted()) {
1212
				// Shortcut: use the pre-converted values as-is.
1213
				try {
1214
					bw.setPropertyValues(mpvs);
1215
					return;
1216
				}
1217
				catch (BeansException ex) {
1218
					throw new BeanCreationException(
1219
							mbd.getResourceDescription(), beanName, "Error setting property values", ex);
1220
				}
1221
			}
1222
			original = mpvs.getPropertyValueList();
1223
		}
1224
		else {
1225
			original = Arrays.asList(pvs.getPropertyValues());
1226
		}
1227
1228
		TypeConverter converter = getCustomTypeConverter();
1229
		if (converter == null) {
1230
			converter = bw;
1231
		}
1232
		BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
1233
1234
		// Create a deep copy, resolving any references for values.
1235
		List deepCopy = new ArrayList(original.size());
1236
		boolean resolveNecessary = false;
1237
		for (Iterator it = original.iterator(); it.hasNext();) {
1238
			PropertyValue pv = (PropertyValue) it.next();
1239
			if (pv.isConverted()) {
1240
				deepCopy.add(pv);
1241
			}
1242
			else {
1243
				String propertyName = pv.getName();
1244
				Object originalValue = pv.getValue();
1245
				Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
1246
				Object convertedValue = resolvedValue;
1247
				boolean convertible = bw.isWritableProperty(propertyName) &&
1248
						!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
1249
				if (convertible) {
1250
					convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
1251
				}
1252
				// Possibly store converted value in merged bean definition,
1253
				// in order to avoid re-conversion for every created bean instance.
1254
				if (resolvedValue == originalValue) {
1255
					if (convertible) {
1256
						pv.setConvertedValue(convertedValue);
1257
					}
1258
					deepCopy.add(pv);
1259
				}
1260
				else if (originalValue instanceof TypedStringValue && convertible) {
1261
					pv.setConvertedValue(convertedValue);
1262
					deepCopy.add(pv);
1263
				}
1264
				else {
1265
					resolveNecessary = true;
1266
					deepCopy.add(new PropertyValue(pv, convertedValue));
1267
				}
1268
			}
1269
		}
1270
		if (mpvs != null && !resolveNecessary) {
1271
			mpvs.setConverted();
1272
		}
1273
1274
		// Set our (possibly massaged) deep copy.
1275
		try {
1276
			bw.setPropertyValues(new MutablePropertyValues(deepCopy));
1277
		}
1278
		catch (BeansException ex) {
1279
			throw new BeanCreationException(
1280
					mbd.getResourceDescription(), beanName, "Error setting property values", ex);
1281
		}
1282
	}

	
 Convert the given value for the specified target property.
 
1286
1287
	private Object convertForProperty(Object value, String propertyName, BeanWrapper bw, TypeConverter converter) {
1288
		if (converter instanceof BeanWrapperImpl) {
1289
			return ((BeanWrapperImpl) converter).convertForProperty(value, propertyName);
1290
		}
1291
		else {
1292
			PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
1293
			MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
1294
			return converter.convertIfNecessary(value, pd.getPropertyType(), methodParam);
1295
		}
1296
	}


	
 Initialize the given bean instance, applying factory callbacks
 as well as init methods and bean post processors.
 Called from createBean(java.lang.Class) for traditionally defined beans,
 and from initializeBean(java.lang.Object,java.lang.String) for existing bean instances.
 
 Parameters:beanName the bean name in the factory (for debugging purposes)bean the new bean instance we may need to initializembd the bean definition that the bean was created with
 (can also be null, if given an existing bean instance) Returns:the initialized bean instance (potentially wrapped) See also:org.springframework.beans.factory.BeanNameAwareorg.springframework.beans.factory.BeanClassLoaderAwareorg.springframework.beans.factory.BeanFactoryAwareapplyBeanPostProcessorsBeforeInitialization(java.lang.Object,java.lang.String)invokeInitMethods(java.lang.String,java.lang.Object,org.springframework.beans.factory.support.RootBeanDefinition)applyBeanPostProcessorsAfterInitialization(java.lang.Object,java.lang.String)
1315
1316
	protected Object initializeBean(String beanName, Object bean, RootBeanDefinition mbd) {
1317
		if (bean instanceof BeanNameAware) {
1318
			((BeanNameAware) bean).setBeanName(beanName);
1319
		}
1320
1321
		if (bean instanceof BeanClassLoaderAware) {
1322
			((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
1323
		}
1324
1325
		if (bean instanceof BeanFactoryAware) {
1326
			((BeanFactoryAware) bean).setBeanFactory(this);
1327
		}
1328
1329
		Object wrappedBean = bean;
1330
		if (mbd == null || !mbd.isSynthetic()) {
1331
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
1332
		}
1333
1334
		try {
1335
			invokeInitMethods(beanName, wrappedBean, mbd);
1336
		}
1337
		catch (Throwable ex) {
1338
			throw new BeanCreationException(
1339
					(mbd != null ? mbd.getResourceDescription() : null),
1340
					beanName, "Invocation of init method failed", ex);
1341
		}
1342
1343
		if (mbd == null || !mbd.isSynthetic()) {
1344
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
1345
		}
1346
		return wrappedBean;
1347
	}

	
 Give a bean a chance to react now all its properties are set,
 and a chance to know about its owning bean factory (this object).
 This means checking whether the bean implements InitializingBean or defines
 a custom init method, and invoking the necessary callback(s) if it does.
 
 Parameters:beanName the bean name in the factory (for debugging purposes)bean the new bean instance we may need to initializembd the merged bean definition that the bean was created with
 (can also be null, if given an existing bean instance) Throws:java.lang.Throwable if thrown by init methods or by the invocation process See also:invokeCustomInitMethod(java.lang.String,java.lang.Object,java.lang.String,boolean)
1360
1361
	protected void invokeInitMethods(String beanName, Object bean, RootBeanDefinition mbd)
1362
			throws Throwable {
1363
1364
		boolean isInitializingBean = (bean instanceof InitializingBean);
1365
		if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
1366
			if (logger.isDebugEnabled()) {
1367
				logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
1368
			}
1369
			((InitializingBean) bean).afterPropertiesSet();
1370
		}
1371
1372
		String initMethodName = (mbd != null ? mbd.getInitMethodName() : null);
1373
		if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
1374
				!mbd.isExternallyManagedInitMethod(initMethodName)) {
1375
			invokeCustomInitMethod(beanName, bean, initMethodName, mbd.isEnforceInitMethod());
1376
		}
1377
	}

	
 Invoke the specified custom init method on the given bean.
 Called by invokeInitMethods.
 Can be overridden in subclasses for custom resolution of init
 methods with arguments.
 
 Parameters:beanName the bean name in the factory (for debugging purposes)bean the new bean instance we may need to initializeinitMethodName the name of the custom init methodenforceInitMethod indicates whether the defined init method needs to exist See also:invokeInitMethods(java.lang.String,java.lang.Object,org.springframework.beans.factory.support.RootBeanDefinition)
1389
1390
	protected void invokeCustomInitMethod(
1391
			String beanName, Object bean, String initMethodName, boolean enforceInitMethod) throws Throwable {
1392
1393
		Method initMethod = BeanUtils.findMethod(bean.getClass(), initMethodName, null);
1394
		if (initMethod == null) {
1395
			if (enforceInitMethod) {
1396
				throw new NoSuchMethodException("Couldn't find an init method named '" + initMethodName +
1397
						"' on bean with name '" + beanName + "'");
1398
			}
1399
			else {
1400
				if (logger.isDebugEnabled()) {
1401
					logger.debug("No default init method named '" + initMethodName +
1402
							"' found on bean with name '" + beanName + "'");
1403
				}
1404
				// Ignore non-existent default lifecycle methods.
1405
				return;
1406
			}
1407
		}
1408
1409
		if (logger.isDebugEnabled()) {
1410
			logger.debug("Invoking init method  '" + initMethodName + "' on bean with name '" + beanName + "'");
1411
		}
1412
		ReflectionUtils.makeAccessible(initMethod);
1413
		try {
1414
			initMethod.invoke(bean, (Object[]) null);
1415
		}
1416
		catch (InvocationTargetException ex) {
1417
			throw ex.getTargetException();
1418
		}
1419
	}


	
 Applies the postProcessAfterInitialization callback of all
 registered BeanPostProcessors, giving them a chance to post-process the
 object obtained from FactoryBeans (for example, to auto-proxy them).
 
 See also:applyBeanPostProcessorsAfterInitialization(java.lang.Object,java.lang.String)
1427
1428
	protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
1429
		return applyBeanPostProcessorsAfterInitialization(object, beanName);
1430
	}

	
 Overridden to clear FactoryBean instance cache as well.
 
1434
1435
	protected void removeSingleton(String beanName) {
1436
		super.removeSingleton(beanName);
1437
		this.factoryBeanInstanceCache.remove(beanName);
1438
	}
1439
1440
}