以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進來。

進入

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