扫一扫下方二维码,关注本站官方公众号
获取永久解锁本站全部文章的验证码
还能不定期领现金红包

Go开发工程师:迎接上升风口,踏入蓝海行业!【完结】-Go语言中文社区

Go开发工程师:迎接上升风口,踏入蓝海行业!【完结】


### Go开发工程师:迎接上升风口,踏入蓝海行业!【完结】

download:网盘分享

springboot源码解析(转)

一.Spring Boot 的入口类

@SpringBootApplication

public class StartupApplication {


    public static void main(String[] args) {

        SpringApplication.run(StartupApplication.class, args);

    }

}


第一个参数 resourceLoader:资源加载器


第二个参数 primarySources:加载的主要资源类


@SuppressWarnings({ "unchecked", "rawtypes" })

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {

// 1、资源初始化资源加载器为 null,默许为空

this.resourceLoader = resourceLoader;

// 2、断言主要加载资源类不能为 null,否则报错

Assert.notNull(primarySources, "PrimarySources must not be null");

// 3、初始化主要加载资源类汇合并去重

this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));

// 4、推断当前 WEB 应用类型,一共有三种:

this.webApplicationType = WebApplicationType.deduceFromClasspath();

//5、设置应用上线文初始化器,从"META-INF/spring.factories"读取ApplicationContextInitializer类的实例称号汇合并去重,并停止set去重。(一共4个)

setInitializers((Collection) getSpringFactoriesInstances(

ApplicationContextInitializer.class));

// 6、设置监听器,从"META-INF/spring.factories"读取ApplicationListener类的实例称号汇合并去重,并停止set去重。(一共10个)

setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

// 7、推断主入口应用类,经过当前调用栈,获取Main办法所在类,并赋值给mainApplicationClass。

this.mainApplicationClass = deduceMainApplicationClass();

}


1.细致看看deduceFromClasspath办法的完成:


static WebApplicationType deduceFromClasspath() {

    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;

}       

public enum WebApplicationType {


    //非 WEB 项目

    NONE,


    //SERVLET WEB 项目

    SERVLET,


    //响应式 WEB 项目

    REACTIVE;

}


二.springboot启动类

public ConfigurableApplicationContext run(String... args) {

    // 1、创立并启动计时监控类

    StopWatch stopWatch = new StopWatch();

    stopWatch.start();

    // 2、初始化应用上下文和异常报告汇合

    ConfigurableApplicationContext context = null;

    Collection exceptionReporters = new ArrayList<>();

    // 3、设置系统属性 `java.awt.headless` 的值,默许值为:true,用于运转headless效劳器,停止简单的图像处置

    configureHeadlessProperty();

    // 4、创立一切 Spring 运转监听器并发布应用启动事情

    SpringApplicationRunListeners listeners = getRunListeners(args);

    listeners.starting();

    try {

        // 5、初始化默许应用参数类

        ApplicationArguments applicationArguments = new DefaultApplicationArguments(

                args);

        // 6、依据运转监听器和应用参数来准备 Spring 环境

        ConfigurableEnvironment environment = prepareEnvironment(listeners,

                applicationArguments);

        configureIgnoreBeanInfo(environment);

        // 7、创立 Banner 打印类

        Banner printedBanner = printBanner(environment);

        // 8、创立应用上下文

        context = createApplicationContext();

        // 9、准备异常报告器

        exceptionReporters = getSpringFactoriesInstances(

                SpringBootExceptionReporter.class,

                new Class[] { ConfigurableApplicationContext.class }, context);

        // 10、准备应用上下文

        prepareContext(context, environment, listeners, applicationArguments,

                printedBanner);

        // 11、刷新应用上下文

        refreshContext(context);

        // 12、应用上下文刷新后置处置

        afterRefresh(context, applicationArguments);

        // 13、中止计时监控类

        stopWatch.stop();

        // 14、输出日志记载执行主类名、时间信息

        if (this.logStartupInfo) {

            new StartupInfoLogger(this.mainApplicationClass)

                    .logStarted(getApplicationLog(), stopWatch);

        }

        // 15、发布应用上下文启动完成事情

        listeners.started(context);

        // 16、执行一切 Runner 运转器

        callRunners(context, applicationArguments);

    }

    catch (Throwable ex) {

        handleRunFailure(context, ex, exceptionReporters, listeners);

        throw new IllegalStateException(ex);

    }

    try {

        // 17、发布应用上下文就绪事情

        listeners.running(context);

    }

    catch (Throwable ex) {

        handleRunFailure(context, ex, exceptionReporters, null);

        throw new IllegalStateException(ex);

    }

    // 18、返回应用上下文

    return context;

}


三.启动详解

1、创立并启动计时监控类


StopWatch stopWatch = new StopWatch();

stopWatch.start();


来看下这个计时监控类 StopWatch 的相关源码:


作用:


首先记载了当前任务的称号,默许为空字符串,然后记载当前 Spring Boot 应用启动的开端时间

public void start() throws IllegalStateException {

    start("");

}


public void start(String taskName) throws IllegalStateException {

    if (this.currentTaskName != null) {

        throw new IllegalStateException("Can't start StopWatch: it's already running");

    }

    this.currentTaskName = taskName;

    this.startTimeMillis = System.currentTimeMillis();

}


2、初始化应用上下文和异常报告汇合


ConfigurableApplicationContext context = null;

Collection exceptionReporters = new

ArrayList<>();


3、设置系统属性 java.awt.headless 的值


configureHeadlessProperty();


4、创立一切 Spring 运转监听器并发布应用启动事情


SpringApplicationRunListeners listeners = getRunListeners(args);

listeners.starting();


来看下创立 Spring 运转监听器相关的源码:


private SpringApplicationRunListeners getRunListeners(String[] args) {

    Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };

    return new SpringApplicationRunListeners(logger, getSpringFactoriesInstances(

            SpringApplicationRunListener.class, types, this, args));

}


SpringApplicationRunListeners(Log log,

        Collection<? extends SpringApplicationRunListener> listeners) {

    this.log = log;

    this.listeners = new ArrayList<>(listeners);

}


5、初始化默许应用参数类


ApplicationArguments applicationArguments = newDefaultApplicationArguments(String[] args);


6.下面我们主要来看下准备环境的 prepareEnvironment 源码:


作用:


获取(或者创立)应用环境

配置应用环境

private ConfigurableEnvironment prepareEnvironment(

        SpringApplicationRunListeners listeners,

        ApplicationArguments applicationArguments) {

    // 6.1) 获取(或者创立)应用环境

    ConfigurableEnvironment environment = getOrCreateEnvironment();

    // 6.2) 配置应用环境

    configureEnvironment(environment, applicationArguments.getSourceArgs());

    listeners.environmentPrepared(environment);

    bindToSpringApplication(environment);

    if (this.webApplicationType == WebApplicationType.NONE) {

        environment = new EnvironmentConverter(getClassLoader())

                .convertToStandardEnvironmentIfNecessary(environment);

    }

    ConfigurationPropertySources.attach(environment);

    return environment;

}

//6.1) 获取(或者创立)应用环境

private ConfigurableEnvironment getOrCreateEnvironment() {

    if (this.environment != null) {

        return this.environment;

    }

    if (this.webApplicationType == WebApplicationType.SERVLET) {

        return new StandardServletEnvironment();

    }

    return new StandardEnvironment();

}

//这里分为规范 Servlet 环境和规范环境。

//6.2) 配置应用环境

protected void configureEnvironment(ConfigurableEnvironment environment,

        String[] args) {

    configurePropertySources(environment, args);

    configureProfiles(environment, args);

}


6.2)这里分为以下两步来配置应用环境。


配置 property sources

配置 Profiles

这里主要处置一切 property sources 配置和 profiles配置。


7、创立 Banner 打印类


Banner printedBanner = printBanner(environment);


8、创立应用上下文


context = createApplicationContext();


来看下 createApplicationContext() 办法的源码:

作用:


依据不同的应用类型初始化不同的上下文应用类。

protected ConfigurableApplicationContext createApplicationContext() {

    Class<?> contextClass = this.applicationContextClass;

    if (contextClass == null) {

        try {

            switch (this.webApplicationType) {

            case SERVLET:

                contextClass = Class.forName(DEFAULT_WEB_CONTEXT_CLASS);

                break;

            case REACTIVE:

                contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);

                break;

            default:

                contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);

            }

        }

        catch (ClassNotFoundException ex) {

            throw new IllegalStateException(

                    "Unable create a default ApplicationContext, "

                            + "please specify an ApplicationContextClass",

                    ex);

        }

    }

    return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);

}


9、准备异常报告器


exceptionReporters = getSpringFactoriesInstances(

SpringBootExceptionReporter.class,

new Class[] { ConfigurableApplicationContext.class }, context);


10、准备应用上下文


prepareContext(context, environment, listeners, applicationArguments,

printedBanner);


来看下 prepareContext() 办法的源码:


private void prepareContext(ConfigurableApplicationContext context,

        ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,

        ApplicationArguments applicationArguments, Banner printedBanner) {

    // 10.1)绑定环境到上下文

    context.setEnvironment(environment);


    // 10.2)配置上下文的 bean 生成器及资源加载器

    postProcessApplicationContext(context);


    // 10.3)为上下文应用一切初始化器

    applyInitializers(context);


    // 10.4)触发一切 SpringApplicationRunListener 监听器的 contextPrepared 事情办法

    listeners.contextPrepared(context);


    // 10.5)记载启动日志

    if (this.logStartupInfo) {

        logStartupInfo(context.getParent() == null);

        logStartupProfileInfo(context);

    }


    // 10.6)注册两个特殊的单例bean

    context.getBeanFactory().registerSingleton("springApplicationArguments",

            applicationArguments);

    if (printedBanner != null) {

        context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);

    }


    // 10.7)加载一切资源

    Set sources = getAllSources();

    Assert.notEmpty(sources, "Sources must not be empty");

    load(context, sources.toArray(new Object[0]));


    // 10.8)触发一切 SpringApplicationRunListener 监听器的 contextLoaded 事情办法

    listeners.contextLoaded(context);

}


11、刷新应用上下文

refreshContext(context);

这个主要是刷新 Spring 的应用上下文,源码如下,不细致阐明。


private void refreshContext(ConfigurableApplicationContext context) {

    refresh(context);

    if (this.registerShutdownHook) {

        try {

            context.registerShutdownHook();

        }

        catch (AccessControlException ex) {

            // Not allowed in some environments.

        }

    }

}


12、应用上下文刷新后置处置

afterRefresh(context, applicationArguments);

看了下这个办法的源码是空的,目前能够做一些自定义的后置处置操作。


protected void afterRefresh(ConfigurableApplicationContext context,

        ApplicationArguments args) {

}

1

2

3

13、中止计时监控类


stopWatch.stop();

public void stop() throws IllegalStateException {

    if (this.currentTaskName == null) {

        throw new IllegalStateException("Can't stop StopWatch: it's not running");

    }

    long lastTime = System.currentTimeMillis() - this.startTimeMillis;

    this.totalTimeMillis += lastTime;

    this.lastTaskInfo = new TaskInfo(this.currentTaskName, lastTime);

    if (this.keepTaskList) {

        this.taskList.add(this.lastTaskInfo);

    }

    ++this.taskCount;

    this.currentTaskName = null;

}


计时监听器中止,并统计一些任务执行信息。


14、输出日志记载执行主类名、时间信息


if (this.logStartupInfo) {

    new StartupInfoLogger(this.mainApplicationClass)

            .logStarted(getApplicationLog(), stopWatch);

}

1

2

3

4

15、发布应用上下文启动完成事情


listeners.started(context);


触发一切 SpringApplicationRunListener 监听器的 started 事情办法。


16、执行一切 Runner 运转器


callRunners(context, applicationArguments);


private void callRunners(ApplicationContext context, ApplicationArguments args) {

    List runners = new ArrayList<>();

    runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());

    runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());

    AnnotationAwareOrderComparator.sort(runners);

    for (Object runner : new LinkedHashSet<>(runners)) {

        if (runner instanceof ApplicationRunner) {

            callRunner((ApplicationRunner) runner, args);

        }

        if (runner instanceof CommandLineRunner) {

            callRunner((CommandLineRunner) runner, args);

        }

    }

}


执行一切 ApplicationRunner 和 CommandLineRunner 这两种运转器,不细致展开了。


17、发布应用上下文就绪事情


listeners.running(context);


触发一切 SpringApplicationRunListener 监听器的 running 事情办法。




版权声明1:本文来源,感谢博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
站方申明:本站部分内容来自社区用户分享,若涉及侵权,请联系站方删除。
  • 发表于 2021-08-25 00:21
  • 阅读 ( 1050 )
  • 分类:Go

0 条评论

请先 登录 后评论

官方社群