public Object getBean(String name, Class requiredType, final Object[] args) throws BeansException {
       final String beanName = transformedBeanName(name);
       Object bean = null;

       // Eagerly check singleton cache for manually registered singletons.
       Object sharedInstance = getSingleton(beanName);
       if (sharedInstance != null) {
           if (isSingletonCurrentlyInCreation(beanName)) {
               if (logger.isDebugEnabled()) {
                   logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
                           "' that is not fully initialized yet - a consequence of a circular reference");
               }
           }
           else {
               if (logger.isDebugEnabled()) {
                   logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
               }
           }
           if (containsBeanDefinition(beanName)) {
               RootBeanDefinition mergedBeanDefinition = getMergedBeanDefinition(beanName, false);
               bean = getObjectForBeanInstance(sharedInstance, name, mergedBeanDefinition);
           }
           else {
               bean = getObjectForBeanInstance(sharedInstance, name, null);
           }
       }

       else {
           // Fail if we're already creating this singleton instance:
           // We're assumably within a circular reference.
           if (isSingletonCurrentlyInCreation(beanName)) {
               throw new BeanCurrentlyInCreationException(beanName);
           }

           // Check if bean definition exists in this factory.
           BeanFactory parentBeanFactory = getParentBeanFactory();
           if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
               // Not found -> check parent.
               String nameToLookup = originalBeanName(name);
               if (parentBeanFactory instanceof AbstractBeanFactory) {
                   // Delegation to parent with args only possible for AbstractBeanFactory.
                   return ((AbstractBeanFactory) parentBeanFactory).getBean(nameToLookup, requiredType, args);
               }
               else if (args == null) {
                   // No args -> delegate to standard getBean method.
                   return parentBeanFactory.getBean(nameToLookup, requiredType);
               }
               else {
                   throw new NoSuchBeanDefinitionException(beanName,
                           "Cannot delegate to parent BeanFactory because it does not supported passed-in arguments");
               }
           }

           this.alreadyCreated.add(beanName);

           final RootBeanDefinition mergedBeanDefinition = getMergedBeanDefinition(beanName, false);
           checkMergedBeanDefinition(mergedBeanDefinition, beanName, args);

           // Create bean instance.
           if (mergedBeanDefinition.isSingleton()) {
               sharedInstance = getSingleton(beanName, new ObjectFactory() {
                   public Object getObject() throws BeansException {
                       try {
                           return createBean(beanName, mergedBeanDefinition, 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);
                           throw ex;
                       }
                   }
               });
               bean = getObjectForBeanInstance(sharedInstance, name, mergedBeanDefinition);
           }

           else if (mergedBeanDefinition.isPrototype()) {
               // It's a prototype -> create a new instance.
               Object prototypeInstance = null;
               try {
                   beforePrototypeCreation(beanName);
                   prototypeInstance = createBean(beanName, mergedBeanDefinition, args);
               }
               finally {
                   afterPrototypeCreation(beanName);
               }
               bean = getObjectForBeanInstance(prototypeInstance, name, mergedBeanDefinition);
           }

           else {
               String scopeName = mergedBeanDefinition.getScope();
               final Scope scope = (Scope) this.scopes.get(scopeName);
               if (scope == null) {
                   throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
               }
               try {
                   Object scopedInstance = scope.get(beanName, new ObjectFactory() {
                       public Object getObject() throws BeansException {
                           beforePrototypeCreation(beanName);
                           try {
                               Object bean = createBean(beanName, mergedBeanDefinition, args);
                               if (requiresDestruction(bean, mergedBeanDefinition)) {
                                   scope.registerDestructionCallback(beanName,
                                           new DisposableBeanAdapter(bean, beanName, mergedBeanDefinition, getBeanPostProcessors()));
                               }
                               return bean;
                           }
                           finally {
                               afterPrototypeCreation(beanName);
                           }
                       }
                   });
                   bean = getObjectForBeanInstance(scopedInstance, name, mergedBeanDefinition);
               }
               catch (IllegalStateException ex) {
                   throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active", ex);
               }
           }
       }

       // Check if required type matches the type of the actual bean instance.
       if (requiredType != null && !requiredType.isAssignableFrom(bean.getClass())) {
           throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
       }
       return bean;
   }

public Object getBean(String name, Class requiredType, final Object[] args) throws BeansException {
       final String beanName = transformedBeanName(name);
       Object bean = null;

       // Eagerly check singleton cache for manually registered singletons.
       Object sharedInstance = getSingleton(beanName);
     

protected String transformedBeanName(String name) {
       String beanName = BeanFactoryUtils.transformedBeanName(name);
       // Handle aliasing.
       Synchronized (this.aliasMap) {
           String canonicalName = (String) this.aliasMap.get(beanName);
           return (canonicalName != null ? canonicalName : beanName);
       }
   }

//DefaultSingletonBeanRegistry class

public Object getSingleton(String beanName) {
       Synchronized (this.singletonCache) {
           return this.singletonCache.get(beanName);
       }
   }

/**
    * Return a RootBeanDefinition, even by traversing parent if the parameter is a
    * child definition. Can ask the parent bean factory if not found in this instance.
    * @param name the name of the bean to retrieve the merged definition for
    * @param includingAncestors whether to ask the parent bean factory if not found
    * in this instance
    * @return a (potentially merged) RootBeanDefinition for the given bean
    * @throws NoSuchBeanDefinitionException if there is no bean with the given name
    * @throws BeanDefinitionStoreException in case of an invalid bean definition
    */
   protected RootBeanDefinition getMergedBeanDefinition(String name, boolean includingAncestors)
       throws BeansException {

       String beanName = transformedBeanName(name);

       // Efficiently check whether bean definition exists in this factory.
       if (includingAncestors && !containsBeanDefinition(beanName) &&
               getParentBeanFactory() instanceof AbstractBeanFactory) {
           return ((AbstractBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(beanName, true);
       }

       // Resolve merged bean definition locally.
       return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
   }

/**
    * Get the object for the given bean instance, either the bean
    * instance itself or its created object in case of a FactoryBean.
    * @param beanInstance the shared bean instance
    * @param name name that may include factory dereference prefix
    * @param mbd the merged bean definition
    * @return the object to expose for the bean
    */
protected Object getObjectForBeanInstance(Object beanInstance, String name, RootBeanDefinition mbd) throws BeansException {

       String beanName = transformedBeanName(name);

       // Don't let calling code try to dereference the
       // bean factory if the bean isn't a factory.
       if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
           throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
       }

       boolean shared = (mbd == null || mbd.isSingleton());
       Object object = beanInstance;

       // Now we have the bean instance, which may be a normal bean or a FactoryBean.
       // If it's a FactoryBean, we use it to create a bean instance, unless the
       // caller actually wants a reference to the factory.
       if (beanInstance instanceof FactoryBean) {
           if (!BeanFactoryUtils.isFactoryDereference(name)) {
               // Return bean instance from factory.
               FactoryBean factory = (FactoryBean) beanInstance;
               if (logger.isDebugEnabled()) {
                   logger.debug("Bean with name '" + beanName + "' is a factory bean");
               }
               // Cache object obtained from FactoryBean if it is a singleton.
               if (shared && factory.isSingleton()) {
                   Synchronized (this.factoryBeanObjectCache) {
                       object = this.factoryBeanObjectCache.get(beanName);
                       if (object == null) {
                           object = getObjectFromFactoryBean(factory, beanName, mbd);
                           this.factoryBeanObjectCache.put(beanName, object);
                       }
                   }
               }
               else {
                   object = getObjectFromFactoryBean(factory, beanName, mbd);
               }
           }
           else {
                // The user wants the factory itself.
               if (logger.isDebugEnabled()) {
                   logger.debug("Calling code asked for FactoryBean instance for name '" + beanName + "'");
               }
           }
       }

       return object;
   }