以XmlBeanFactory為例，最簡單的取bean方式是：

BeanFactory factory = new XmlBeanFactory(new FileSystemResource("D:\\workspace\\JavaApplication2\\src\\javaapplication2\\spring\\beans.xml"));
            Car obj = (Car)factory.getBean("car");

 Bean的配置檔案內容也很簡單：

    <bean id="vehicle"   abstract="true">
        <property name="wheel" value="Four wheeler"/>        
    </bean>
    <bean id="car" class="javaapplication2.spring.Car" parent="vehicle">
        <property name="dicky" value="Flat dicky"/>    
    </bean>

先看起始點，載入先走AbstractBeanFactory

	public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
	}

doGetBean方法中：

// Create bean instance.
if (mbd.isSingleton()) {
         //傳入一個內聯類ObjectFactory並實現了getObject方法。
         sharedInstance = getSingleton(beanName, new ObjectFactory() {
	public Object getObject() throws BeansException {
	try {
	    return createBean(beanName, mbd, args);
	}
	catch (BeansException ex) {
	// Explicitly remove instance from singleton cache: It might have been put there
	// eagerly by the creation process, to allow for circular reference resolution.
	// Also remove any beans that received a temporary reference to the bean.
	destroySingleton(beanName); //有異常則銷燬bean
			throw ex;
	}
}
});
	bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
        //此處開始例項化bean
 

}

通過new ObjectFactory()的回撥方法，回調當前類繼承的createBean方法，該方法在父類AbstractAutowireCapableBeanFactory中：

AbstractAutowireCapableBeanFactory->

protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
			throws BeanCreationException {

		// Make sure bean class is actually resolved at this point.
		resolveBeanClass(mbd, beanName);  //載入該bean的class，並放置到mbd裡面,bean的生成不在這裡。

		// Prepare method overrides.
		try {
			mbd.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}

		try {
			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
			Object bean = resolveBeforeInstantiation(beanName, mbd);  //嘗試獲取一個proxy，普通bean這裡一般是空的返回
			
			if (bean != null) {
				return bean;
			}
		}
		catch (Throwable ex) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"BeanPostProcessor before instantiation of bean failed", ex);
		}

		Object beanInstance = doCreateBean(beanName, mbd, args);  //開始create bean的例項，mbd中包括了需要的class
		if (logger.isDebugEnabled()) {
			logger.debug("Finished creating instance of bean '" + beanName + "'");
		}
		return beanInstance;
	}
 

進入AbstractBeanFactory中的protected Class resolveBeanClass方法：

try {
	if (mbd.hasBeanClass()) {
		return mbd.getBeanClass();
	}
	if (System.getSecurityManager() != null) {
		return AccessController.doPrivileged(new PrivilegedExceptionAction<Class>() {
			public Class run() throws Exception {
				return doResolveBeanClass(mbd, typesToMatch);
			}
		}, getAccessControlContext());
	}
	else {
		return doResolveBeanClass(mbd, typesToMatch);   <---還要繼續進去看生成方法。
	}
}

轉入doResolveBeanClass：

private Class doResolveBeanClass(RootBeanDefinition mbd, Class... typesToMatch) throws ClassNotFoundException {
	if (!ObjectUtils.isEmpty(typesToMatch)) {
		ClassLoader tempClassLoader = getTempClassLoader();
		if (tempClassLoader != null) {
			if (tempClassLoader instanceof DecoratingClassLoader) {
				DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader;
			for (Class<?> typeToMatch : typesToMatch) {
				dcl.excludeClass(typeToMatch.getName())
			}
		}
		String className = mbd.getBeanClassName();
		return (className != null ? ClassUtils.forName(className, tempClassLoader) : null); //通過自己的ClassUtils的forName方法來例項化class
		}
	}
	return mbd.resolveBeanClass(getBeanClassLoader());  <----這裡傳入了bean的classloader，下面繼續看這裡
}

AbstractBeanDefinition->resolveBeanClass

public Class resolveBeanClass(ClassLoader classLoader) throws ClassNotFoundException {
		String className = getBeanClassName();
		if (className == null) {
			return null;
		}
		Class resolvedClass = ClassUtils.forName(className, classLoader);//classloader傳入後，仍然是用forName方法載入class
		this.beanClass = resolvedClass;
		return resolvedClass;
	}

再來看forName做了些什麼

ClassUtils ->

ClassLoader classLoaderToUse = classLoader;
if (classLoaderToUse == null) {
	classLoaderToUse = getDefaultClassLoader();
}
try {
	return classLoaderToUse.loadClass(name); //也比較簡單，直接呼叫loadClass方法載入
}

最終將class load進來。

Bean例項化過程：

AbstractAutowireCapableBeanFactory->createBeanInstance

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) 
	// Need to determine the constructor...
	//提取建構函式，如果沒有就是空
	Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
	if (ctors != null ||mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
			return autowireConstructor(beanName, mbd, ctors, args);
	}

	// No special handling: simply use no-arg constructor.
	return instantiateBean(beanName, mbd); //這裡例項化

進入

AbstractAutowireCapableBeanFactory->instantiateBean

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd)
...這裡省略沒用的		
	else {
		beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);//下面看這裡的例項化
	}		
			
	BeanWrapper bw = new BeanWrapperImpl(beanInstance);   //返回一個包裝類物件
	initBeanWrapper(bw);
	return bw;

SimpleInstantiationStrategy->instantiate

public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner)
	synchronized (beanDefinition.constructorArgumentLock) {
			constructorToUse = (Constructor<?>) beanDefinition.resolvedConstructorOrFactoryMethod;
		...
	}
	return BeanUtils.instantiateClass(constructorToUse);	 //BeanUtils來初始化例項 ，給出了例項化需要的建構函式

再來看BeanUtils的例項化方法，比較簡單，直接用反射的建構函式來newInstance。

BeanUtils->

public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
	try {
		ReflectionUtils.makeAccessible(ctor);
		return ctor.newInstance(args);
	}

AbstractAutowireCapableBeanFactory->

Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) 

	// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			populateBean(beanName, mbd, instanceWrapper);
			if (exposedObject != null) {
				exposedObject = initializeBean(beanName, exposedObject, mbd);
			}
		}
	return exposedObject;		//返回給AbstractBeanFactory