憨憨呆呆的IT之旅

class B {
  public void doSomeThing() {}
}

class A {
  public doSomeThing() {
    B b = new B();
    b.doSomeThing();
  }
}

interface IB {
  void doSomeThing();
}

class B1 implements IB {}
class B2 implements IB {}
class B3 implements IB {}

class BFactory {
  public static IB newB(int type) {
    if (type == 1) {
      return new B1();
    } else if (type == 2) {
      return new B2();
    } else {
      return new B3();
    }
  }
}

class A {
  public doSomeThing() {
    IB b = BFactory.newB(1);
    b.doSomeThing();
  }
}

class B {
  public void doSomeThing() {}
}

class A {
  @Autowired
  private B b;
  
  public doSomeThing() {
    b.doSomeThing();
  }
}

@Controller
public class EmployeeController {
  @Autowired
  private EmployeeDao employeeDao;
  
  public String index() {
    return "Hello from Spring!";
  }
}

@SpringBootApplication
@ComponentScan(basePackages = "com.company.app")
public class MySpringBootApp {
  public static void main(String[] args) {
    ApplicationContext context = SpringApplication.run(MySpringBootApp.class, args);
  }
}

// 新建一个工厂
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();

// 新建一个 bean definition
GenericBeanDefinition beanDefinition = (GenericBeanDefinition) BeanDefinitionBuilder
  .genericBeanDefinition(SomeService.class)
  .setAutowireMode(GenericBeanDefinition.AUTOWIRE_BY_TYPE)
  .getBeanDefinition();

// 注册到工厂
factory.registerBeanDefinition("someService", beanDefinition);

// 自己定义一个 bean post processor. 作用是在 bean 初始化之后, 判断这个 bean 如果实现了 ApplicationContextAware 接口, 就把 context 注册进去..(先不要管 context 哪来的...例子嘛)
factory.addBeanPostProcessor(new BeanPostProcessor() {
  @Override
  public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    return bean;
  }

  @Override
  public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    if (bean instanceof ApplicationContextAware) {
      GenericApplicationContext context = new GenericApplicationContext(factory);
      ((ApplicationContextAware) bean).setApplicationContext(context);
    }
    return bean;
  }
});

// 再注册一个 bean post processor: AutowiredAnnotationBeanPostProcessor. 作用是搜索这个 bean 中的 @Autowired 注解, 生成注入依赖的信息.
AutowiredAnnotationBeanPostProcessor autowiredAnnotationBeanPostProcessor = new AutowiredAnnotationBeanPostProcessor();
autowiredAnnotationBeanPostProcessor.setBeanFactory(factory);
factory.addBeanPostProcessor(autowiredAnnotationBeanPostProcessor);

// getBean() 时, 初始化
SomeService SomeService = factory.getBean("someService",SomeService.class);
SomeService.doSomething();

public class StaticListableBeanFactory implements ListableBeanFactory {
  private final Map<String, Object> beans;

  public StaticListableBeanFactory() {
    this.beans = new LinkedHashMap();
  }

  public StaticListableBeanFactory(Map<String, Object> beans) {
    Assert.notNull(beans, "Beans Map must not be null");
    this.beans = beans;
  }

  public void addBean(String name, Object bean) {
    this.beans.put(name, bean);
  }

  public Object getBean(String name) throws BeansException {
    String beanName = BeanFactoryUtils.transformedBeanName(name);
    Object bean = this.beans.get(beanName);
    if (bean == null) {
      throw new NoSuchBeanDefinitionException(beanName, "Defined beans are [" + StringUtils.collectionToCommaDelimitedString(this.beans.keySet()) + "]");
    } else if (BeanFactoryUtils.isFactoryDereference(name) && !(bean instanceof FactoryBean)) {
      throw new BeanIsNotAFactoryException(beanName, bean.getClass());
    } else if (bean instanceof FactoryBean && !BeanFactoryUtils.isFactoryDereference(name)) {
      try {
        Object exposedObject = ((FactoryBean)bean).getObject();
        if (exposedObject == null) {
          throw new BeanCreationException(beanName, "FactoryBean exposed null object");
        } else {
          return exposedObject;
        }
      } catch (Exception var5) {
        throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", var5);
      }
    } else {
      return bean;
    }
  }
  
  ...
}

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

	/** Cache of singleton objects: bean name to bean instance. */
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

	/** Cache of singleton factories: bean name to ObjectFactory. */
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

	/** Cache of early singleton objects: bean name to bean instance. */
	private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

	/** Set of registered singletons, containing the bean names in registration order. */
	private final Set<String> registeredSingletons = new LinkedHashSet<>(256);

	/** Names of beans that are currently in creation. */
	private final Set<String> singletonsCurrentlyInCreation =
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));

	/** Names of beans currently excluded from in creation checks. */
	private final Set<String> inCreationCheckExclusions =
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));

	/** List of suppressed Exceptions, available for associating related causes. */
	@Nullable
	private Set<Exception> suppressedExceptions;

	/** Flag that indicates whether we're currently within destroySingletons. */
	private boolean singletonsCurrentlyInDestruction = false;

	/** Disposable bean instances: bean name to disposable instance. */
	private final Map<String, Object> disposableBeans = new LinkedHashMap<>();

	/** Map between containing bean names: bean name to Set of bean names that the bean contains. */
	private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<>(16);

	/** Map between dependent bean names: bean name to Set of dependent bean names. */
	private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);

	/** Map between depending bean names: bean name to Set of bean names for the bean's dependencies. */
	private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);
  
  ...
}

// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory 
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

		// Instantiate the bean.
		...
		instanceWrapper = createBeanInstance(beanName, mbd, args); // line 555
		...
		// inject dependencies for bean properties 
		populateBean(beanName, mbd, instanceWrapper); // line 592
		exposedObject = initializeBean(beanName, exposedObject, mbd);
		...
		
		return exposedObject;
}

// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory line 759
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
    if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
      throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
    } else {
      Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
      if (instanceSupplier != null) {
        return this.obtainFromSupplier(instanceSupplier, beanName);
      } else if (mbd.getFactoryMethodName() != null) {
        return this.instantiateUsingFactoryMethod(beanName, mbd, args);
      } else {
        boolean resolved = false;
        boolean autowireNecessary = false;
        if (args == null) {
          synchronized(mbd.constructorArgumentLock) {
            if (mbd.resolvedConstructorOrFactoryMethod != null) {
              resolved = true;
              autowireNecessary = mbd.constructorArgumentsResolved;
            }
          }
        }

        if (resolved) {
          return autowireNecessary ? this.autowireConstructor(beanName, mbd, (Constructor[])null, (Object[])null) : this.instantiateBean(beanName, mbd);
        } else {
          Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
          if (ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)) {
            ctors = mbd.getPreferredConstructors();
            return ctors != null ? this.autowireConstructor(beanName, mbd, ctors, (Object[])null) : this.instantiateBean(beanName, mbd);
          } else {
            return this.autowireConstructor(beanName, mbd, ctors, args);
          }
        }
      }
    }
  }

// org.springframework.beans.BeanUtils  line 49
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
    Assert.notNull(ctor, "Constructor must not be null");

    try {
      ReflectionUtils.makeAccessible(ctor);
      return KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass()) ? BeanUtils.KotlinDelegate.instantiateClass(ctor, args) : ctor.newInstance(args);
    } catch (InstantiationException var3) {
      throw new BeanInstantiationException(ctor, "Is it an abstract class?", var3);
    } catch (IllegalAccessException var4) {
      throw new BeanInstantiationException(ctor, "Is the constructor accessible?", var4);
    } catch (IllegalArgumentException var5) {
      throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", var5);
    } catch (InvocationTargetException var6) {
      throw new BeanInstantiationException(ctor, "Constructor threw exception", var6.getTargetException());
    }
  }

/**
	 * Actually performs context closing: publishes a ContextClosedEvent and
	 * destroys the singletons in the bean factory of this application context.
	 * <p>Called by both {@code close()} and a JVM shutdown hook, if any.
	 * @see org.springframework.context.event.ContextClosedEvent
	 * @see #destroyBeans()
	 * @see #close()
	 * @see #registerShutdownHook()
	 */
	protected void doClose() {
			// Publish shutdown event.
			publishEvent(new ContextClosedEvent(this));
			
			// Stop all Lifecycle beans, to avoid delays during individual destruction.
			this.lifecycleProcessor.onClose();
				
			// Destroy all cached singletons in the context's BeanFactory.
			destroyBeans();

			// Close the state of this context itself.
			closeBeanFactory();

			// Let subclasses do some final clean-up if they wish...
			onClose();
		}
	}