package com.vayne.design;

/**
 * @author Volcanno
 */
public interface Subject {

    boolean registerObserver(Observer observer);

    boolean removeObserver(Observer observer);

    void notifyObserver();
}

package com.vayne.design;

/**
 * @author Volcanno
 */
public interface Observer {

    boolean update(String name,int age);

}

package com.vayne.design;

import java.util.ArrayList;
import java.util.List;

/**
 * @author Volcanno
 */
public class WeatherData implements Subject {

    private List<Observer> observers = new ArrayList<>();

    private String name;
    private int age;

    public void Do(String name, int age) {
        this.name = name;
        this.age = age;
        notifyObserver();
    }

    @Override
    public boolean registerObserver(Observer observer) {
        if (observer != null) {
            observers.add(observer);
            return true;
        }
        return false;
    }

    @Override
    public boolean removeObserver(Observer observer) {
        if (observer != null) {
            observers.remove(observer);
            return true;
        }
        return false;
    }

    @Override
    public void notifyObserver() {
        for (Observer observer : observers) {
            observer.update(this.name, this.age);
        }
    }
}

package com.vayne.design;

/**
 * @author Volcanno
 */
public class CenterOne implements Observer {

    private Subject subject;

    private String name;
    private int age;

    public CenterOne(Subject subject) {
        this.subject = subject;
        subject.registerObserver(this);
    }

    @Override
    public boolean update(String name, int age) {
        this.name = name;
        this.age = age;
        display();
        return true;
    }

    public void display() {
        System.out.println("name:");
        System.out.println(name);
        System.out.println("age");
        System.out.println(age);

    }
}

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

	if (logger.isInfoEnabled()) {
		logger.info("Refreshing " + this);
	}

	// Initialize any placeholder property sources in the context environment.
	//初始化一些属性,默认里面的实现是空的，留给子类使用，扩展点之一
	initPropertySources();

	// Validate that all properties marked as required are resolvable:
	// see ConfigurablePropertyResolver#setRequiredProperties
	//得到环境信息，默认的是StandardEnvironment。然后来验证一些必要的属性是否存在，如果不存在，那么此处就会
	//抛出异常
	//StandardEnvironment用的是委托模式，validateRequiredProperties的时候委托给了自己内部的属性解析器，也就是
	//propertyResolver。
	//propertyResolver在实例化的时候，会接收属性源，解析器的父类有一个私有集合对象用于储存key；
	//validate的时候，会通过解析器的getProperty取值然后验证是否存在；
	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<>();
}

package com.vayne.boot;

import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.env.SystemEnvironmentPropertySource;

import java.util.HashMap;
import java.util.Map;

/**
 * @author Volcanno
 */
public class Boot {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:application.xml");
        Map<String, Object> map = new HashMap<>();
        map.put("vay", "vayne");
        map.put("alis", "alison");
        SystemEnvironmentPropertySource seps = new SystemEnvironmentPropertySource("env", map);
        context.getEnvironment().getPropertySources().addFirst(seps);
        //这里会把vay和alis添加到AbstractPropertyResolver的一个list里面。然后validate的时候，会调用子类的getProperty
        context.getEnvironment().setRequiredProperties("vay");
        context.getEnvironment().setRequiredProperties("alis");
        context.refresh();
        Object object = context.getEnvironment().getProperty("alis");
        String string = String.valueOf(object);
        System.out.println("hello, " + string);
    }
}

@Override
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		// Prepare this context for refreshing.
           //进行一些准备工作，比如环境变量的操作等等
		prepareRefresh();

		// Tell the subclass to refresh the internal bean factory.
           //获取beanFactory
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// Prepare the bean factory for use in this context.
           //对beanFactory进行一些必要的设置
		prepareBeanFactory(beanFactory);

		try {
			// Allows post-processing of the bean factory in context subclasses.
               //beanFactory的后处理
			postProcessBeanFactory(beanFactory);

			// Invoke factory processors registered as beans in the context.
               //调用beanFactory的后处理器，扩展点之一
			invokeBeanFactoryPostProcessors(beanFactory);

			// Register bean processors that intercept bean creation.
               //注册bean处理器，扩展点之一
			registerBeanPostProcessors(beanFactory);

			// Initialize message source for this context.
               //实例化消息源，
			initMessageSource();

			// Initialize event multicaster for this context.
               //初始化广播器
			initApplicationEventMulticaster();

			// Initialize other special beans in specific context subclasses.
               //留出为子类提供的扩展点，扩展点之一
			onRefresh();

			// Check for listener beans and register them.
               //注册监听器
			registerListeners();

			// Instantiate all remaining (non-lazy-init) singletons.
               //实例化非懒加载的单例
			finishBeanFactoryInitialization(beanFactory);

			// Last step: publish corresponding event.
               //发布相关事件
			finishRefresh();
		}

		catch (BeansException ex) {
			if (logger.isWarnEnabled()) {
				logger.warn("Exception encountered during context initialization - " +
						"cancelling refresh attempt: " + ex);
			}

			// Destroy already created singletons to avoid dangling resources.
               //销毁bean
			destroyBeans();

			// Reset 'active' flag.
			cancelRefresh(ex);

			// Propagate exception to caller.
			throw ex;
		}

		finally {
			// Reset common introspection caches in Spring's core, since we
			// might not ever need metadata for singleton beans anymore...
			resetCommonCaches();
		}
	}
}