/**
 * Prepare this context for refreshing, setting its startup date and
 * active flag as well as performing any initialization of property sources.
 */
protected void prepareRefresh() {
    // Switch to active.
    this.startupDate = System.currentTimeMillis();
    this.closed.set(false);
    this.active.set(true);

    if (logger.isDebugEnabled()) {
        if (logger.isTraceEnabled()) {
            logger.trace("Refreshing " + this);
        }
        else {
            logger.debug("Refreshing " + getDisplayName());
        }
    }

    // Initialize any placeholder property sources in the context environment.
    initPropertySources();

    // Validate that all properties marked as required are resolvable:
    // see ConfigurablePropertyResolver#setRequiredProperties
    getEnvironment().validateRequiredProperties();

    // Store pre-refresh ApplicationListeners...
    if (this.earlyApplicationListeners == null) {
        this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
    }
    else {
        // Reset local application listeners to pre-refresh state.
        this.applicationListeners.clear();
        this.applicationListeners.addAll(this.earlyApplicationListeners);
    }

    // Allow for the collection of early ApplicationEvents,
    // to be published once the multicaster is available...
    this.earlyApplicationEvents = new LinkedHashSet<>();
}

protected final void refreshBeanFactory() throws BeansException {
    if (hasBeanFactory()) { //如果存在beanfactory， 则关闭
        destroyBeans();
        closeBeanFactory();
    }
    try {
        //为上下文生命周期的下个阶段初始化一个新的beanfactory
        DefaultListableBeanFactory beanFactory = createBeanFactory();
        //指定ID
        beanFactory.setSerializationId(getId());
        //设置是否允许被覆盖，是否允许循环引用
        customizeBeanFactory(beanFactory);
        //从Xml、Annotation、Groovy中读取Bean信息并注册。
        loadBeanDefinitions(beanFactory);
        //set the refrences to this.beanFactory.
        synchronized (this.beanFactoryMonitor) {
            this.beanFactory = beanFactory;
        }
    }
    catch (IOException ex) {
        throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    }
}

/**
 * Configure the factory's standard context characteristics,
 * such as the context's ClassLoader and post-processors.
 * @param beanFactory the BeanFactory to configure
 */
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // Tell the internal bean factory to use the context's class loader etc.
    beanFactory.setBeanClassLoader(getClassLoader());
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

    // Configure the bean factory with context callbacks.
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

    // BeanFactory interface not registered as resolvable type in a plain factory.
    // MessageSource registered (and found for autowiring) as a bean.
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);

    // Register early post-processor for detecting inner beans as ApplicationListeners.
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

    // Detect a LoadTimeWeaver and prepare for weaving, if found.
    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        // Set a temporary ClassLoader for type matching.
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }

    // Register default environment beans.
    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
    }
}

public class XURLConnection extends URLConnection{

  private final UrlResource resource;

  protected XURLConnection(URL url){
   super(url);
   this.resource = new ClassPathResource(url.getPath());
  }

  public InputStream getInputStream() throws IOException{
    return resource.getInputStream();
  }
}

public class Handler extends URLStreamHandler{
   protected URLConnection openConnection(URL u) throws IOException{
       return new XURLConnection(u);
   }
}

URL url = new URL("x:///META-INF/default.properties");
InputStream is = url.openStream();
System.out.println(StreamUtils.copyString(is, Charset.forName("UTF-8")));

DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
AnnotatedBeanDefinitionReader reader = new AnnotatedBeanDefinitionReader(beanFactory);
reader.register(Main.class);

/**
 * Initialize the given bean instance, applying factory callbacks
 * as well as init methods and bean post processors.
 * <p>Called from {@link #createBean} for traditionally defined beans,
 * and from {@link #initializeBean} for existing bean instances.
 * @param beanName the bean name in the factory (for debugging purposes)
 * @param bean the new bean instance we may need to initialize
 * @param mbd the bean definition that the bean was created with
 * (can also be {@code null}, if given an existing bean instance)
 * @return the initialized bean instance (potentially wrapped)
 * @see BeanNameAware
 * @see BeanClassLoaderAware
 * @see BeanFactoryAware
 * @see #applyBeanPostProcessorsBeforeInitialization
 * @see #invokeInitMethods
 * @see #applyBeanPostProcessorsAfterInitialization
 */
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
  if (System.getSecurityManager() != null) {
    AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
      invokeAwareMethods(beanName, bean);
      return null;
    }, getAccessControlContext());
  }
  else {
    invokeAwareMethods(beanName, bean);
  }

  Object wrappedBean = bean;
  if (mbd == null || !mbd.isSynthetic()) {
    wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
  }

  try {
    invokeInitMethods(beanName, wrappedBean, mbd);
  }
  catch (Throwable ex) {
    throw new BeanCreationException(
        (mbd != null ? mbd.getResourceDescription() : null),
        beanName, "Invocation of init method failed", ex);
  }
  if (mbd == null || !mbd.isSynthetic()) {
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
  }

  return wrappedBean;
}

/**
 * 通过 {@link org.springframework.beans.factory.ObjectProvider} 进行依赖查找
 */
public class ObjectProviderDemo {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        applicationContext.register(ObjectProviderDemo.class);
        applicationContext.refresh();
        lookupByObjectProvider(applicationContext);
        applicationContext.close();
    }

    @Bean
    public String helloWorld() {
        return "Hello World";
    }
    private static void lookupByObjectProvider(AnnotationConfigApplicationContext applicationContext) {
        ObjectProvider<String> objectProvider = applicationContext.getBeanProvider(String.class);
        System.out.println(objectProvider.getObject());
    }
}

public class HierarchicalDependencyLookupDemo {


    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();

        ConfigurableListableBeanFactory beanFactory = applicationContext.getBeanFactory();

        HierarchicalBeanFactory parentBeanFactory = createParentBeanFactory();

        beanFactory.setParentBeanFactory(parentBeanFactory);

        displayContainsLocalBean(beanFactory, "user"); //false
        displayContainsLocalBean(parentBeanFactory, "user"); //true
        
        displayContainsBean(beanFactory, "user"); //true
        displayContainsBean(parentBeanFactory,"user");//true

        applicationContext.refresh();
        applicationContext.close();
    }


    private static void displayContainsBean(HierarchicalBeanFactory beanFactory, String beanName) {
        System.out.printf("当前 BeanFactory [%s] 是否包含  bean[name:%s]  %s\n", beanFactory, beanName, containsBean(beanFactory,beanName));

    }

    private static boolean containsBean(HierarchicalBeanFactory beanFactory, String beanName) {
        BeanFactory parentBeanFactory = beanFactory.getParentBeanFactory();
        if (parentBeanFactory instanceof HierarchicalBeanFactory) {
            HierarchicalBeanFactory parentHierarchicalBeanFactory = HierarchicalBeanFactory.class.cast(parentBeanFactory);
            if (containsBean(parentHierarchicalBeanFactory, beanName)) {
                return true;
            }
        }
        return beanFactory.containsLocalBean(beanName);
    }

    private static void displayContainsLocalBean(HierarchicalBeanFactory parentBeanFactory, String user) {
        System.out.printf("当前 BeanFactory [%s] 是否包含 Local bean[name:%s]  %s\n", parentBeanFactory, user, parentBeanFactory.containsLocalBean(user));
    }

    private static HierarchicalBeanFactory createParentBeanFactory() {
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
        String location = "classpath:applicationContext-lookup.xml";
        reader.loadBeanDefinitions(location);
        return beanFactory;
    }
}

/**
 * 通过 {@link org.springframework.beans.factory.ObjectProvider} 进行依赖查找
 */
public class ObjectProviderDemo {


    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        applicationContext.register(ObjectProviderDemo.class);
        applicationContext.refresh();

        lookupByObjectProvider(applicationContext);
        lookupIfAvailable(applicationContext);
        lookupByStream(applicationContext);
        applicationContext.close();
    }

    private static void lookupByStream(AnnotationConfigApplicationContext applicationContext) {
        ObjectProvider<String> objectProvider = applicationContext.getBeanProvider(String.class);
//        Iterator<String> iterator = objectProvider.iterator();
//        while(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
        objectProvider.stream().forEach(System.out::println);
    }

    private static void lookupIfAvailable(AnnotationConfigApplicationContext applicationContext) {
        ObjectProvider<User> userObjectProvider = applicationContext.getBeanProvider(User.class);
        User user = userObjectProvider.getIfAvailable(User::new);
        System.out.println(user);

    }

    @Bean
    @Primary
    public String helloWorld() {
        return "Hello World";
    }

    @Bean
    public String message(){
        return "message";
    }

    private static void lookupByObjectProvider(AnnotationConfigApplicationContext applicationContext) {
        ObjectProvider<String> objectProvider = applicationContext.getBeanProvider(String.class);
        System.out.println(objectProvider.getObject());
    }
}

import com.github.springframework.models.User;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TypeSafetyDependencyLookupDemo {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        applicationContext.register(TypeSafetyDependencyLookupDemo.class);
        applicationContext.refresh();

        displayBeanFactoryGetBean(applicationContext);
        displayObjectFactoryGetObject(applicationContext);
        displayObjectProviderIfAvailable(applicationContext);

        displayListableBeanFactoryGetBeansOfType(applicationContext);

        displayObjectProviderStreamOps(applicationContext);
        applicationContext.close();
    }

    public static void displayObjectProviderStreamOps(AnnotationConfigApplicationContext beanFactory){
        ObjectProvider<User> userObjectFactory = beanFactory.getBeanProvider(User.class);
        printException("displayObjectProviderStreamOps", ()->userObjectFactory.forEach(System.out::println));
    }

    public static void displayListableBeanFactoryGetBeansOfType(ListableBeanFactory beanFactory){
        printException("displayListableBeanFactoryGetBeansOfType", ()->beanFactory.getBeansOfType(User.class));
    }

    public static void displayObjectProviderIfAvailable(BeanFactory beanFactory){
        ObjectProvider<User> userObjectFactory = beanFactory.getBeanProvider(User.class);
        printException("displayObjectProviderIfAvailable", ()->userObjectFactory.getIfAvailable());
    }

    public static void displayObjectFactoryGetObject(BeanFactory beanFactory){
        ObjectProvider<User> userObjectFactory = beanFactory.getBeanProvider(User.class);
        printException("displayObjectFactoryGetObject", ()->userObjectFactory.getObject());
    }

    public static void displayBeanFactoryGetBean(BeanFactory beanFactory){
        printException("displayBeanFactoryGetBean",()->beanFactory.getBean(User.class));
    }

    public static void printException(String source, Runnable run){
        System.out.println("Source From : " + source);
        System.out.println("======================================");
        try{
            run.run();
        }catch (BeansException e){
            e.printStackTrace();
        }
    }
}

        //bean definition builder.
BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(User.class);

beanDefinitionBuilder.addPropertyValue("id",1L);
beanDefinitionBuilder.addPropertyValue("name","lisi");

BeanDefinition beanDefinition = beanDefinitionBuilder.getBeanDefinition();

GenericBeanDefinition genericBeanDefinition = new GenericBeanDefinition();
genericBeanDefinition.setBeanClass(User.class);

MutablePropertyValues propertyValues = new MutablePropertyValues();
//        propertyValues.addPropertyValue("id",2L);
//        propertyValues.addPropertyValue("name","zhaowu");

propertyValues.add("id",2L)
        .add("name","zhaowu");
genericBeanDefinition.setPropertyValues(propertyValues);

/**
 * Generate a bean name for the given bean definition, unique within the
 * given bean factory.
 * @param definition the bean definition to generate a bean name for
 * @param registry the bean factory that the definition is going to be
 * registered with (to check for existing bean names)
 * @param isInnerBean whether the given bean definition will be registered
 * as inner bean or as top-level bean (allowing for special name generation
 * for inner beans versus top-level beans)
 * @return the generated bean name
 * @throws BeanDefinitionStoreException if no unique name can be generated
 * for the given bean definition
 */
public static String generateBeanName(
        BeanDefinition definition, BeanDefinitionRegistry registry, boolean isInnerBean)
        throws BeanDefinitionStoreException {

    String generatedBeanName = definition.getBeanClassName();
    if (generatedBeanName == null) {
        if (definition.getParentName() != null) {
            generatedBeanName = definition.getParentName() + "$child";
        }
        else if (definition.getFactoryBeanName() != null) {
            generatedBeanName = definition.getFactoryBeanName() + "$created";
        }
    }
    if (!StringUtils.hasText(generatedBeanName)) {
        throw new BeanDefinitionStoreException("Unnamed bean definition specifies neither " +
                "'class' nor 'parent' nor 'factory-bean' - can't generate bean name");
    }

    String id = generatedBeanName;
    if (isInnerBean) {
        // Inner bean: generate identity hashcode suffix.
        id = generatedBeanName + GENERATED_BEAN_NAME_SEPARATOR + ObjectUtils.getIdentityHexString(definition);
    }
    else {
        // Top-level bean: use plain class name with unique suffix if necessary.
        return uniqueBeanName(generatedBeanName, registry);
    }
    return id;
}

/**
 * Turn the given bean name into a unique bean name for the given bean factory,
 * appending a unique counter as suffix if necessary.
 * @param beanName the original bean name
 * @param registry the bean factory that the definition is going to be
 * registered with (to check for existing bean names)
 * @return the unique bean name to use
 * @since 5.1
 */
public static String uniqueBeanName(String beanName, BeanDefinitionRegistry registry) {
    String id = beanName;
    int counter = -1;

    // Increase counter until the id is unique.
    while (counter == -1 || registry.containsBeanDefinition(id)) {
        counter++;
        id = beanName + GENERATED_BEAN_NAME_SEPARATOR + counter;
    }
    return id;
}

@Override
public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
    if (definition instanceof AnnotatedBeanDefinition) {
        String beanName = determineBeanNameFromAnnotation((AnnotatedBeanDefinition) definition);
        if (StringUtils.hasText(beanName)) {
            // Explicit bean name found.
            return beanName;
        }
    }
    // Fallback: generate a unique default bean name.
    return buildDefaultBeanName(definition, registry);
}

/**
 * Derive a default bean name from the given bean definition.
 * <p>The default implementation simply builds a decapitalized version
 * of the short class name: e.g. "mypackage.MyJdbcDao" -> "myJdbcDao".
 * <p>Note that inner classes will thus have names of the form
 * "outerClassName.InnerClassName", which because of the period in the
 * name may be an issue if you are autowiring by name.
 * @param definition the bean definition to build a bean name for
 * @return the default bean name (never {@code null})
 */
protected String buildDefaultBeanName(BeanDefinition definition) {
    String beanClassName = definition.getBeanClassName();
    Assert.state(beanClassName != null, "No bean class name set");
    String shortClassName = ClassUtils.getShortName(beanClassName);
    return Introspector.decapitalize(shortClassName);
}

public class AnnotationBeanDefinitionDemo {


    public static void main(String[] args) {

        //create factory bean
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();

        //register config class.
        applicationContext.register(Config.class);

        //refresh
        applicationContext.refresh();

        //getUser
        System.out.println(applicationContext.getBean(User.class));
    }



    static class Config{
        @Bean
        public User user(){
            User user = new User();
            user.setId(1L);
            user.setName("Ann: zhangsan");
            return user;
        }
    }
}

public class AnnotationBeanDefinitionDemo {
    public static void main(String[] args) {
        //create factory bean
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();

        //register config class.
        applicationContext.register(Config.class);

        //refresh
        applicationContext.refresh();

        //
        System.out.println(applicationContext.getBean(Config.class));
    }
    @Component
    static class Config{
        @Bean
        public User user(){
            User user = new User();
            user.setId(1L);
            user.setName("Ann: zhangsan");
            return user;
        }
    }
}

static void beanDefinitionRegistry(BeanDefinitionRegistry registry, String name) {
    BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(User.class);
    beanDefinitionBuilder.addPropertyValue("id", 1L)
            .addPropertyValue("name", "Reg: zhangsan");
    if (StringUtils.hasText(name)) {
        registry.registerBeanDefinition(name, beanDefinitionBuilder.getBeanDefinition());
    } else {
        BeanDefinitionReaderUtils.registerWithGeneratedName(beanDefinitionBuilder.getBeanDefinition(),registry);
    }
}

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
applicationContext.register(Config.class);
beanDefinitionRegistry(applicationContext,"REG:ZhangSan:Name");
beanDefinitionRegistry(applicationContext,null);
applicationContext.refresh();
System.out.println(applicationContext.getBeansOfType(Config.class));
System.out.println(applicationContext.getBeansOfType(User.class));
System.out.println(applicationContext.getBeansOfType(AnnotationApplicationContextDemo.class));

public class User2 {

    private Long id;

    private String name;
    
    public static User2 getInstance(){
        return new User2();
    }
}

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/META-INF/bean-creation-context.xml");

User2 user = applicationContext.getBean("user-by-static-method", User2.class);

public interface UserFactory {
    default User2 createuser() {
        return new User2();
    }
}

public class DefaultUserFactory implements UserFactory {
}

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/META-INF/bean-creation-context.xml");
User2 user3 = applicationContext.getBean("user-by-instance-method", User2.class);

public class UserFactoryBean implements FactoryBean<User2> {

    @Override
    public User2 getObject() throws Exception {
        return User2.getInstance();
    }

    @Override
    public Class<?> getObjectType() {
        return User2.class;
    }
}

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/META-INF/bean-creation-context.xml");
User2 user2 = applicationContext.getBean("user-by-factory-method", User2.class);

public static void demoServiceLoader() {
    ServiceLoader<UserFactory> serviceLoader = ServiceLoader.load(UserFactory.class, Thread.currentThread().getContextClassLoader());
    displayServiceLoad(serviceLoader);
}

public static void displayServiceLoad(ServiceLoader<UserFactory> serviceLoader) {
    Iterator<UserFactory> iterator = serviceLoader.iterator();
    while (iterator.hasNext()) {
        UserFactory userFactory = iterator.next();
        System.out.println(userFactory.createuser());
    }
}

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/META-INF/sp-bean-creation-context.xml");
ServiceLoader<UserFactory> serviceLoader = applicationContext.getBean("userFactoryServiceLoader", ServiceLoader.class);
displayServiceLoad(serviceLoader);

AutowireCapableBeanFactory beanFactory = applicationContext.getAutowireCapableBeanFactory();
UserFactory userFactory = beanFactory.createBean(DefaultUserFactory.class);
System.out.println(userFactory.createuser());

public class DefaultUserFactory implements UserFactory, InitializingBean {

    public DefaultUserFactory() {
        System.out.println("DefaultUserFactory Constructor Called.");
    }

    @PostConstruct
    public void init(){
        System.out.println("DefaultUserFactory PostConstructor Called.");
    }

    public void initUserFactory(){
        System.out.println("DefaultUserFactory initUserFactory Called.");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("DefaultUserFactory afterPropertiesSet called.");
    }
}

@Configuration
public class BeanInitializationDemo {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        applicationContext.register(BeanInitializationDemo.class);
        applicationContext.refresh();
        UserFactory userFactory = applicationContext.getBean(UserFactory.class)
        System.out.println(userFactory.createuser());
        applicationContext.close();
    }

    @Bean(initMethod = "initUserFactory")
    public DefaultUserFactory userFactory(){
        return new DefaultUserFactory();
    }
}

UserFactory userFactory = new DefaultUserFactory();
ConfiguableListableBeanFactory factory = applicationContext.getBeanFactory();
factory.registerSingleton("userFactory", userFactory);

UserFactory userFactory = applicationContext.getBean("UserFactory",UserFactory.class);