0


为什么要用springboot进行开发呢?

文章目录

前言

学习了一段时间springboot,一般都可以在项目中使用springboot开发了。因为springboot的东西并不多,或者说,springboot根本就没有新东西。

好了,现在问一句,**

我们为什么要用springboot?

**

我听过的回答:

A:Spring Boot 最主要是不用 XML 配置,可以用 Java 来配置 bean,省去了许多配置文件
我又问:Spring 本身就可以用 Java 配置代替 XML 配置,和 Spring Boot 有什么关系呢?
A:。。。

B:Spring Boot 我们用来做 Spring Cloud 微服务。
我又问:微服务和 Spring Boot 有什么关系?不用 Spring Boot 行不行?
B:。。。

C:Spring Boot 可以打 jar 包部署,内部集成了Tomcat
这个确实是 Spring Boot 的特色,但是我还是觉得没有答到关键点上。
然后我继续问,如果不考虑打 jar 包部署呢?
C:。。。

显然,这些答案都没有回答到点子上。以我的理解,springboot是什么?它只是对spring Framework做了二次封装。以便简化开发,让程序员将更多的精力和时间放到业务上去。规避了繁琐的配置操作。而且还减少了遭遇bug的数量。说直白一点:**

自动配置

**。

1、那么Springboot是怎么实现自动配置的

1.1 启动类

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

还是要从springboot的启动类说起。就这个类而言,最神秘的还是Annotation定义(@SpringBootApplication)和类定义(SpringApplication.run)。

1.2 @SpringBootApplication

这个注解之前没见过,可以说它是springboot自己的新注解,我们点进去看下。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters ={
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class)})
public @interface SpringBootApplication {...      
}

可以看到,这是一个组合注解
虽然定义使用了多个Annotation进行了原信息标注,但实际上重要的只有三个Annotation

  • @Configuration(@SpringBootConfiguration点开查看发现里面还是应用了@Configuration)
  • @EnableAutoConfiguration
  • @ComponentScan

1.3 @Configuration

这里的@Configuration对我们来说不陌生,它就是JavaConfig形式的Spring Ioc容器的配置类使用的那个@Configuration,SpringBoot社区推荐使用基于JavaConfig的配置形式,所以,这里的启动类标注了@Configuration之后,本身其实也是一个IoC容器的配置类。

1.4 @ComponentScan

@ComponentScan这个注解在Spring中很重要,它对应XML配置中的元素,@ComponentScan的功能其实就是自动扫描并加载符合条件的组件(比如@Component和@Repository等)或者bean定义,最终将这些bean定义加载到IoC容器中。

我们可以通过basePackages等属性来细粒度的定制@ComponentScan自动扫描的范围,如果不指定,则默认Spring框架实现会从声明@ComponentScan所在类的package进行扫描。

注:所以SpringBoot的启动类最好是放在root package下,因为默认不指定basePackages。

1.5 @EnableAutoConfiguration

这厮才是springboot的核心!
大家是否还熟悉Spring框架提供的各种名字为@Enable开头的Annotation定义?比如@EnableScheduling、@EnableCaching、@EnableMBeanExport等,@EnableAutoConfiguration的理念和做事方式其实一脉相承,简单概括一下就是,借助@Import的支持,收集和注册特定场景相关的bean定义。

而@EnableAutoConfiguration也是借助@Import的帮助,将所有符合自动配置条件的bean定义加载到IoC容器,仅此而已!

@EnableAutoConfiguration作为一个复合Annotation,点进去,信息如下:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {...
}

这是springboot2.0的配置,如果你用的版本是1.5或以下的,是这样:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(EnableAutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {...
}

当然,EnableAutoConfigurationImportSelector这个类也是继承了AutoConfigurationImportSelector类的,这个没关系,无所谓啦!

1.6 两个重要注解

  • @AutoConfigurationPackage:自动配置包
  • @Import: 导入自动配置的组件

1.7 AutoConfigurationPackage注解

你一步一步点进去,一直点到Registrar类中:

/**
     * {@link ImportBeanDefinitionRegistrar} to store the base package from the importing
     * configuration.
     */
    static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {

        @Override
        public void registerBeanDefinitions(AnnotationMetadata metadata,
                BeanDefinitionRegistry registry){
            register(registry, new PackageImport(metadata).getPackageName());}

        @Override
        public Set<Object> determineImports(AnnotationMetadata metadata){return Collections.singleton(new PackageImport(metadata));}

它其实是注册了一个Bean的定义。
new PackageImport(metadata).getPackageName(),它其实返回了当前主程序类的 同级以及子级 的包组件。

1.8 Import(AutoConfigurationImportSelector.class)注解

在这里插入图片描述
可以从图中看出

AutoConfigurationImportSelector 继承了 DeferredImportSelector 继承了 ImportSelector

ImportSelector有一个方法为:

selectImports

@Override
    public String[] selectImports(AnnotationMetadata annotationMetadata){if(!isEnabled(annotationMetadata)){return NO_IMPORTS;}
        AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
                .loadMetadata(this.beanClassLoader);
        AnnotationAttributes attributes = getAttributes(annotationMetadata);
        List<String> configurations = getCandidateConfigurations(annotationMetadata,
                attributes);
        configurations = removeDuplicates(configurations);
        Set<String> exclusions = getExclusions(annotationMetadata, attributes);
        checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        configurations = filter(configurations, autoConfigurationMetadata);
        fireAutoConfigurationImportEvents(configurations, exclusions);return StringUtils.toStringArray(configurations);}

它其实是去加载

public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories

";外部文件。这个外部文件,有很多自动配置的类。如下:
在这里插入图片描述
其中,最关键的要属@Import(EnableAutoConfigurationImportSelector.class),借助EnableAutoConfigurationImportSelector,@EnableAutoConfiguration可以帮助SpringBoot应用将所有符合条件的@Configuration配置都加载到当前SpringBoot创建并使用的IoC容器。

1.9自动配置幕后英雄:SpringFactoriesLoader详解

public abstract class SpringFactoriesLoader {
    //...
    public static <T> List<T> loadFactories(Class<T> factoryClass, ClassLoader classLoader){...
    }

    public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader){....}}

配合@EnableAutoConfiguration使用的话,它更多是提供一种配置查找的功能支持,即根据@EnableAutoConfiguration的完整类名org.springframework.boot.autoconfigure.EnableAutoConfiguration作为查找的Key,获取对应的一组@Configuration类
在这里插入图片描述
上图就是从SpringBoot的autoconfigure依赖包中的META-INF/spring.factories配置文件中摘录的一段内容,可以很好地说明问题。

所以,@EnableAutoConfiguration自动配置的魔法骑士就变成了:从classpath中搜寻所有的META-INF/spring.factories配置文件,并将其中org.springframework.boot.autoconfigure.EnableutoConfiguration对应的配置项通过反射(Java Refletion)实例化为对应的标注了@Configuration的JavaConfig形式的IoC容器配置类,然后汇总为一个并加载到IoC容器。

1.10 深入探索SpringApplication执行流程

SpringApplication的run方法的实现是我们本次旅程的主要线路,该方法的主要流程大体可以归纳如下:

1) 如果我们使用的是SpringApplication的静态run方法,那么,这个方法里面首先要创建一个SpringApplication对象实例,然后调用这个创建好的SpringApplication的实例方法。在SpringApplication实例初始化的时候,它会提前做几件事情:

public static ConfigurableApplicationContext run(Object[] sources, String[] args){return new SpringApplication(sources).run(args);}
  • 根据classpath里面是否存在某个特征(org.springframework.web.context.ConfigurableWebApplicationContext)来决定是否应该创建一个为Web应用使用的ApplicationContext类型。
  • 使用SpringFactoriesLoader在应用的classpath中查找并加载所有可用的ApplicationContextInitializer。
  • 使用SpringFactoriesLoader在应用的classpath中查找并加载所有可用的ApplicationListener。
  • 推断并设置main方法的定义类
@SuppressWarnings({"unchecked", "rawtypes"})
    private void initialize(Object[] sources){if(sources != null && sources.length >0){
            this.sources.addAll(Arrays.asList(sources));}
        this.webEnvironment = deduceWebEnvironment();
        setInitializers((Collection) getSpringFactoriesInstances(
                ApplicationContextInitializer.class));
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = deduceMainApplicationClass();}

2) SpringApplication实例初始化完成并且完成设置后,就开始执行run方法的逻辑了,方法执行伊始,首先遍历执行所有通过SpringFactoriesLoader可以查找到并加载的SpringApplicationRunListener。调用它们的started()方法,告诉这些SpringApplicationRunListener,“嘿,SpringBoot应用要开始执行咯!”。

public ConfigurableApplicationContext run(String... args){
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        FailureAnalyzers analyzers = null;
        configureHeadlessProperty();
        SpringApplicationRunListeners listeners = getRunListeners(args);
        listeners.starting();
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                    args);
            ConfigurableEnvironment environment = prepareEnvironment(listeners,
                    applicationArguments);
            Banner printedBanner = printBanner(environment);
            context = createApplicationContext();
            analyzers = new FailureAnalyzers(context);
            prepareContext(context, environment, listeners, applicationArguments,
                    printedBanner);
       // 核心点:会打印springboot的启动标志,直到server.port端口启动
            refreshContext(context);
            afterRefresh(context, applicationArguments);
            listeners.finished(context, null);
            stopWatch.stop();if(this.logStartupInfo){
                new StartupInfoLogger(this.mainApplicationClass)
                        .logStarted(getApplicationLog(), stopWatch);}return context;}
        catch (Throwable ex){
            handleRunFailure(context, listeners, analyzers, ex);
            throw new IllegalStateException(ex);}}

3) 创建并配置当前Spring Boot应用将要使用的Environment(包括配置要使用的PropertySource以及Profile)。

private ConfigurableEnvironment prepareEnvironment(
            SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments){
        // Create and configure the environment
        ConfigurableEnvironment environment = getOrCreateEnvironment();
        configureEnvironment(environment, applicationArguments.getSourceArgs());
        listeners.environmentPrepared(environment);if(!this.webEnvironment){
            environment = new EnvironmentConverter(getClassLoader())
                    .convertToStandardEnvironmentIfNecessary(environment);}return environment;}

4) 遍历调用所有SpringApplicationRunListener的environmentPrepared()的方法,告诉他们:“当前SpringBoot应用使用的Environment准备好了咯!”。

public void environmentPrepared(ConfigurableEnvironment environment){for(SpringApplicationRunListener listener : this.listeners){
            listener.environmentPrepared(environment);}}

5) 如果SpringApplication的showBanner属性被设置为true,则打印banner。

private Banner printBanner(ConfigurableEnvironment environment){if(this.bannerMode == Banner.Mode.OFF){return null;}
        ResourceLoader resourceLoader = this.resourceLoader != null ? this.resourceLoader
                : new DefaultResourceLoader(getClassLoader());
        SpringApplicationBannerPrinter bannerPrinter = new SpringApplicationBannerPrinter(
                resourceLoader, this.banner);if(this.bannerMode == Mode.LOG){return bannerPrinter.print(environment, this.mainApplicationClass, logger);}return bannerPrinter.print(environment, this.mainApplicationClass, System.out);}

6) 根据用户是否明确设置了applicationContextClass类型以及初始化阶段的推断结果,决定该为当前SpringBoot应用创建什么类型的ApplicationContext并创建完成,然后根据条件决定是否添加ShutdownHook,决定是否使用自定义的BeanNameGenerator,决定是否使用自定义的ResourceLoader,当然,最重要的,将之前准备好的Environment设置给创建好的ApplicationContext使用。

7) ApplicationContext创建好之后,SpringApplication会再次借助Spring-FactoriesLoader,查找并加载classpath中所有可用的ApplicationContext-Initializer,然后遍历调用这些ApplicationContextInitializer的initialize(applicationContext)方法来对已经创建好的ApplicationContext进行进一步的处理。

@SuppressWarnings({"rawtypes", "unchecked"})
    protected void applyInitializers(ConfigurableApplicationContext context){for(ApplicationContextInitializer initializer : getInitializers()){
            Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(
                    initializer.getClass(), ApplicationContextInitializer.class);
            Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
            initializer.initialize(context);}}

8) 遍历调用所有SpringApplicationRunListener的contextPrepared()方法。

private void prepareContext(ConfigurableApplicationContext context,
            ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments, Banner printedBanner){
        context.setEnvironment(environment);
        postProcessApplicationContext(context);
        applyInitializers(context);
        listeners.contextPrepared(context);if(this.logStartupInfo){
            logStartupInfo(context.getParent()== null);
            logStartupProfileInfo(context);}

        // Add boot specific singleton beans
        context.getBeanFactory().registerSingleton("springApplicationArguments",
                applicationArguments);if(printedBanner != null){
            context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);}

        // Load the sources
        Set<Object> sources = getSources();
        Assert.notEmpty(sources, "Sources must not be empty");
        load(context, sources.toArray(new Object[sources.size()]));
        listeners.contextLoaded(context);}

9) 最核心的一步,将之前通过@EnableAutoConfiguration获取的所有配置以及其他形式的IoC容器配置加载到已经准备完毕的ApplicationContext。

private void prepareAnalyzer(ConfigurableApplicationContext context,
FailureAnalyzer analyzer){if(analyzer instanceof BeanFactoryAware){((BeanFactoryAware) analyzer).setBeanFactory(context.getBeanFactory());}}

10) 遍历调用所有SpringApplicationRunListener的contextLoaded()方法。

public void contextLoaded(ConfigurableApplicationContext context){for(SpringApplicationRunListener listener : this.listeners){
            listener.contextLoaded(context);}}

11) 调用ApplicationContext的refresh()方法,完成IoC容器可用的最后一道工序。

private void refreshContext(ConfigurableApplicationContext context){
        refresh(context);if(this.registerShutdownHook){
            try {
                context.registerShutdownHook();}
            catch (AccessControlException ex){
                // Not allowed in some environments.
            }}}

12) 查找当前ApplicationContext中是否注册有CommandLineRunner,如果有,则遍历执行它们。

private void callRunners(ApplicationContext context, ApplicationArguments args){
        List<Object> runners = new ArrayList<Object>();
        runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
        runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
        AnnotationAwareOrderComparator.sort(runners);for(Object runner : new LinkedHashSet<Object>(runners)){if(runner instanceof ApplicationRunner){
                callRunner((ApplicationRunner) runner, args);}if(runner instanceof CommandLineRunner){
                callRunner((CommandLineRunner) runner, args);}}}

13) 正常情况下,遍历执行SpringApplicationRunListener的finished()方法、(如果整个过程出现异常,则依然调用所有SpringApplicationRunListener的finished()方法,只不过这种情况下会将异常信息一并传入处理)
去除事件通知点后,整个流程如下:

public void finished(ConfigurableApplicationContext context, Throwable exception){for(SpringApplicationRunListener listener : this.listeners){
            callFinishedListener(listener, context, exception);}}

在这里插入图片描述

总结

到此,SpringBoot的核心组件完成了基本的解析,综合来看,大部分都是Spring框架背后的一些概念和实践方式,SpringBoot只是在这些概念和实践上对特定的场景事先进行了固化和升华,而也恰恰是这些固化让我们开发基于Sping框架的应用更加方便高效。

标签: spring boot java spring

本文转载自: https://blog.csdn.net/ManuMAX/article/details/128999126
版权归原作者 胖天才小朱(怀玉) 所有, 如有侵权,请联系我们删除。

“为什么要用springboot进行开发呢?”的评论:

还没有评论