Spring源码解析

@SpringBootApplication
public class ApplicationMain {
    public static void main(String[] args) {
        SpringApplication.run(ApplicationMain.class, args);
    }
}

public static void main(String[] args) {
    SpringApplication.run(Application.class,args);
}
 
/**
 * Static helper that can be used to run a {@link SpringApplication} from the
 * specified source using default settings.
 * @param primarySource the primary source to load
 * @param args the application arguments (usually passed from a Java main method)
 * @return the running {@link ApplicationContext}
 */
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
    return run(new Class<?>[] { primarySource }, args);
}
 
/**
 * Static helper that can be used to run a {@link SpringApplication} from the
 * specified sources using default settings and user supplied arguments.
 * @param primarySources the primary sources to load
 * @param args the application arguments (usually passed from a Java main method)
 * @return the running {@link ApplicationContext}
 */
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
    //1、先实例化SpringApplication对象
	//2、再执行run()方法
    return new SpringApplication(primarySources).run(args);
}

public SpringApplication(Class<?>... primarySources) {
    this(null, primarySources);
}

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    //获取类加载器，但是这里传进来的是null，所以现在还没有实例化Bean的类加载器
    this.resourceLoader = resourceLoader;
    //断言判空校验
    Assert.notNull(primarySources, "PrimarySources must not be null");
    //将Application.class(你自己创建的main方法的类加载到主资源集合中)
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    //1、加载容器，这里就相当于一个筛选器，加载不同的Bean需要不同的容器
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    //2、这里就开始使用IOC了，加载META-INF/spring.factories中的初始化器
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    //3、加载META-INF/spring.factories中的监听器
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    //4、加载主类
    this.mainApplicationClass = deduceMainApplicationClass();
}

private static final String[] SERVLET_INDICATOR_CLASSES = { "javax.servlet.Servlet",
        "org.springframework.web.context.ConfigurableWebApplicationContext" };
// 默认servlet处理器
private static final String WEBMVC_INDICATOR_CLASS = "org.springframework.web.servlet.DispatcherServlet";

// reactive处理器
private static final String WEBFLUX_INDICATOR_CLASS = "org.springframework.web.reactive.DispatcherHandler";

private static final String JERSEY_INDICATOR_CLASS = "org.glassfish.jersey.servlet.ServletContainer";

static WebApplicationType deduceFromClasspath() {
   // 如果不存在reactive处理器，并且存在servlet，则返回reactive
   if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
         && !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
      return WebApplicationType.REACTIVE;
   }
   for (String className : SERVLET_INDICATOR_CLASSES) {
      if (!ClassUtils.isPresent(className, null)) {
         return WebApplicationType.NONE;
      }
   }
   return WebApplicationType.SERVLET;
}

// 获取spring工厂实例
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
   return getSpringFactoriesInstances(type, new Class<?>[] {});
}
// 获取spring工厂实例
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
    // 获取加载器
    ClassLoader classLoader = getClassLoader();
    // Use names and ensure unique to protect against duplicates
    // 使用名称并确保其唯一性，以防止重复
    // 从"META-INF/spring.factories"加载指定类型的类全路径
    Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    // 创建spring工厂实例
    List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
    // 排序
    AnnotationAwareOrderComparator.sort(instances);
    return instances;
}
@SuppressWarnings("unchecked")
private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes,
        ClassLoader classLoader, Object[] args, Set<String> names) {
    List<T> instances = new ArrayList<>(names.size());
    for (String name : names) {
        try {
            // 获取对象class类型
            Class<?> instanceClass = ClassUtils.forName(name, classLoader);
            Assert.isAssignable(type, instanceClass);
            // 获取构造方法
            Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
            // 初始化对象
            T instance = (T) BeanUtils.instantiateClass(constructor, args);
            instances.add(instance);
        }
        catch (Throwable ex) {
            throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, ex);
        }
    }
    return instances;
}

this.mainApplicationClass = deduceMainApplicationClass();

private Class<?> deduceMainApplicationClass() {
    try {
		//获取栈堆的信息
        StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
        for (StackTraceElement stackTraceElement : stackTrace) {
			//循环找出main方法
            if ("main".equals(stackTraceElement.getMethodName())) {
				//加载main方法的类
                return Class.forName(stackTraceElement.getClassName());
            }
        }
    }
    catch (ClassNotFoundException ex) {
        // Swallow and continue
    }
    return null;
}

public ConfigurableApplicationContext run(String... args) {
	StopWatch stopWatch = new StopWatch();
	// 计时器启动，我们总能看到项目启动时间多少，就是它统计出来的
	stopWatch.start();
	ConfigurableApplicationContext context = null;
	Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();

	// 1、设置系统headless为true
    configureHeadlessProperty();
	// 2、加载SpringApplicationListener和上面初始化加载可不一样啊，上面的是ApplicationListener
    SpringApplicationRunListeners listeners = getRunListeners(args);
    // 系统启动前-的监听，这个可以实现ApplicationListener<ApplicationStartingEvent>来自定义监听器
    listeners.starting();
    try {
    	// 初始化参数对象，args就是main方法里的参数
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        // 准备环境变量和各种默认的转换器和格式器，意思就是把电脑中的环境变量加载进来
        // 还有我们常用的那些日期格式，字符格式转换的类加载进来，所以说这一步做的还挺多
        ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
    	// spring.beaninfo.ignore 的配置用来决定是否跳过 BeanInfo 类的扫描，如果设置为 true,则跳过。
        configureIgnoreBeanInfo(environment);
		// 3、这个就是系统启动时出现的“SPRINGBOOT”图形，这个可以看下源码
        Banner printedBanner = printBanner(environment);
    	// 创建AnnotationConfigReactiveWebServerApplicationContext，这块儿有些复杂，先不说
        context = createApplicationContext();
		// 4、异常报告类加载
        exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
					new Class[] { ConfigurableApplicationContext.class }, context);
		// 5、准备上下文
        prepareContext(context, environment, listeners, applicationArguments, printedBanner);
		// 6、刷新上下文
        refreshContext(context);
    	// 刷新后的操作
        afterRefresh(context, applicationArguments);
    	// 结束计时
        stopWatch.stop();
    	// 打印启动时间
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
        }
		// 7、系统上下文刷新完成后的监听器
        listeners.started(context);
		// 8、执行自定义run方法
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, listeners);
        throw new IllegalStateException(ex);
    }

	try {
		//系统启动完成运行时的监听器
		listeners.running(context);
	}
	catch (Throwable ex) {
		handleRunFailure(context, ex, exceptionReporters, null);
		throw new IllegalStateException(ex);
	}
	return context;
}

private static final String SYSTEM_PROPERTY_JAVA_AWT_HEADLESS = "java.awt.headless";
 
private void configureHeadlessProperty() {
	System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, System.getProperty(
			SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString(this.headless)));
}

private SpringApplicationRunListeners getRunListeners(String[] args) {
	Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
	return new SpringApplicationRunListeners(logger, getSpringFactoriesInstances(
		SpringApplicationRunListener.class, types, this, args));
}

private Banner printBanner(ConfigurableEnvironment environment) {
	......
	if (this.bannerMode == Mode.LOG) {
		//这里就是加载Banner的方法
		return bannerPrinter.print(environment, this.mainApplicationClass, logger);
	}
	return bannerPrinter.print(environment, this.mainApplicationClass, System.out);
}

public Banner print(Environment environment, Class<?> sourceClass, Log logger) {

	//获取Banner
	Banner banner = getBanner(environment);
	......
	return new PrintedBanner(banner, sourceClass);
}

private Banner getBanner(Environment environment) {
	Banners banners = new Banners();

	//1、可以放图片Banner哦！！
	banners.addIfNotNull(getImageBanner(environment));
	//2、文字的Banner
	banners.addIfNotNull(getTextBanner(environment));
	......
}

static final String BANNER_IMAGE_LOCATION_PROPERTY = "spring.banner.image.location";
static final String[] IMAGE_EXTENSION = { "gif", "jpg", "png" };
 
private Banner getImageBanner(Environment environment) {
	String location = environment.getProperty(BANNER_IMAGE_LOCATION_PROPERTY);
	......
    for (String ext : IMAGE_EXTENSION) {
		Resource resource = this.resourceLoader.getResource("banner." + ext);
		if (resource.exists()) {
			return new ImageBanner(resource);
		}
	}
}

static final String BANNER_LOCATION_PROPERTY = "spring.banner.location";
static final String DEFAULT_BANNER_LOCATION = "banner.txt";	
 
private Banner getTextBanner(Environment environment) {
	String location = environment.getProperty(BANNER_LOCATION_PROPERTY,
			DEFAULT_BANNER_LOCATION);
    ......
}

private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
	context.setEnvironment(environment);
	postProcessApplicationContext(context);
	applyInitializers(context);
	listeners.contextPrepared(context);
	......
}

import org.springframework.boot.context.event.ApplicationStartedEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class MyApplicationStartedListener implements ApplicationListener<ApplicationStartedEvent> {

@Override
public void onApplicationEvent(ApplicationStartedEvent event) {
    // 在应用程序启动后执行一些逻辑
    System.out.println("Application is started. Do something here...");
}

}

context.getBeansOfType(ApplicationRunner.class)

context.getBeansOfType(CommandLineRunner.class)

@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

        // Prepare this context for refreshing.
        // 准备此上下文以进行刷新
        prepareRefresh();

        // Tell the subclass to refresh the internal bean factory.
        // 告诉子类刷新内部bean工厂
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // Prepare the bean factory for use in this context.
        // 准备bean工厂以在当前上下文使用
        prepareBeanFactory(beanFactory);

        try {
            // Allows post-processing of the bean factory in context subclasses.
            // 允许在上下文子类中对bean工厂进行后处理
            postProcessBeanFactory(beanFactory);

            StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
            // Invoke factory processors registered as beans in the context.
            // 调用在上下文中注册为bean的工厂处理器
            invokeBeanFactoryPostProcessors(beanFactory);

            // Register bean processors that intercept bean creation.
            // 注册拦截bean创建的bean处理器
            registerBeanPostProcessors(beanFactory);
            beanPostProcess.end();

            // Initialize message source for this context.
            // 为此上下文初始化消息源
            initMessageSource();

            // Initialize event multicaster for this context.
            // 为此上下文初始化事件传播
            initApplicationEventMulticaster();

            // Initialize other special beans in specific context subclasses.
            // 在特定上下文子类中初始化其他特殊bean
            onRefresh();

            // Check for listener beans and register them.
            // 检查监听器bean并注册它们
            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.
            // 销毁已创建的单例以避免悬挂资源
            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...
            // 重置Spring核心中的常见自省缓存，因为我们可能再也不需要单例bean的元数据了。。。
            resetCommonCaches();
            contextRefresh.end();
        }
    }
}