SpringBoot-原理-01

运行原理基本探究

1. pom.xml

其中他引入了一个父项目，所以可以使用父项目中的依赖，主要是管理项目的资源过滤及插件

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

进入其中之后还能发现一个父依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.5.4</version>
  </parent>

第二个才是真正管理SpringBoot应用中所有依赖版本的地方，SpringBoot的版本控制中心
以后导入包是不需要写版本的，如果导入的包在依赖中没有的话就需要手动配置版本

2. 启动器spring-boot-start

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

spring-boot-start-xxx是spring-boot的场景启动器
spring-boot-starter-web帮我们导入了web模块正常运行的所依赖的组件

SpringBoot将所有的功能场景都抽取了出来，做成了一个个的starter，只需要在项目中引入这些starter即可，所有相关的依赖都会导入进来，我们要用什么功能直接导入场景启动器即可就是spring-boot-start-xxx，未来也可以自定义starter

3. 主启动类

1. 默认主启动类

package com.sli.helloworld;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
//来标注一个主程序的类，说明这是一个SpringBoot的应用
@SpringBootApplication
public class HelloworldApplication {

    public static void main(String[] args) {
		//直接启动服务
        SpringApplication.run(HelloworldApplication.class, args);
    }

}

2. 分析注解具体干了什么

SpringBootApplication

作用：标注在某个类上面，说明这个类是SpringBoot的主配置类，SpringBoot就应该运行这个类的main方法来启动SpringBoot应用

进入这个注解：可以看到上面还有其他的注解！

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
...
}

ComponentScan

这个注解在Spring中很重要，它对应XML配置中的元素
作用：自动扫描并加载符合条件的组件或者bean，将这个bean定义加载到IOC容器中

SpringBootConfiguration

作用：springbootconfiguration是springboot项目的配置注解,这也是一个组合注解,这个注解可以用java的代码的形式实现spring中xml配置文件的效果,并会将当前的类内声明成一个或多个以@Bean注解标记的对象纳入到spring容器中,并且对象名就是方法名.从源码得知,SpringBootConfiguration注解上使用了Configuration注解,因此它可被configuration注解替换,那么什么是Configuration?
详情见:http://www.51gjie.com/javaweb/1045.html

Configuration

指示一个类声明一个或者多个@Bean方法,并且可以由Spring容器处理,以便在运行时这些bean生成BeanDefiniton和服务请求,简单看@Configuration的内部实现,可以看到@component注解,意味着也将会注册为bean,其内部也可以依赖注入(一般的Bean能用的东西,他也能用)例如@Autowired @Inject @Scope等.他也可以理解为一个xml内容的java版本

点进去这个注解查看

@Configuration
@Indexed
public @interface SpringBootConfiguration {
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

继续点进去Configuration，

@Component
public @interface Configuration {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";

    boolean proxyBeanMethods() default true;
}

这里的@Configuation，说明这是一个配置类，配置类就是对应的Spring的xml配置文件；
里面的@Component，说明启动类本身也是Spring中的一个组件而已，负责启动应用！
返回SpringBootApplication注解中查看

EnableAutoConfiguration

@EnableAutoConfiguration开启自动配置功能
以前我们需要自己配置的东西，现在SpringBoot就可以帮助我们自动装配；
@EnableAutoConfiguration告诉SpringBoot开启自动配置功能，这样自动配置就能生效；
作用:从classpath中搜索所有的META-INF/spring.factiories配置文件,将其中org.springframework.boot.autoconfigure.EnableAutoConfiguration key对应的配置项加载到spring容器
只有spring.boot.enableautoconfiguration为true（默认为true）的时候，才启用自动配置
点击进去

@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}

@AutoConfigrationPackage:自动配置包

@Import({Registrar.class})
public @interface AutoConfigurationPackage {
    String[] basePackages() default {};

    Class<?>[] basePackageClasses() default {};
}

@import:Spring底层注解@inport，给容器导入一个组件
Registrar.class作用：将主启动类的所在包及包下的所有子包里面的所有组件扫描到Spring容器；
返回上一步
@Import（{AutoConfigurationImportSelector.class}）：给容器导入组件
AutoConfigurationImportSelectior:自动配置导入选择器，那么他会导入哪些组件选择器?去查看这个类的源码

这个类中有个一个方法

//获取候选的位置
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
		//这里的getSpringFactoriesLoaderFactoryClass()方法
		//返回的就是我们最开始看的启动器自动导入配置文件的注解类：EnableAutoConfiguration
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
        Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
        return configurations;
    }

这个方法调用了SpringFactoriesLoader类的静态方法！进入SpringFactoriesLoader类loadFactoryName（）方法

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        ClassLoader classLoaderToUse = classLoader;
        if (classLoader == null) {
            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
        }

        String factoryTypeName = factoryType.getName();
		//这里调用了loadspringFactories方法
        return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
    }

接着看loadSpringFactories方法

private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
		//获取classloder，返回可以看到这里就是EnableAutoConfigration标注本身
        Map<String, List<String>> result = (Map)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            HashMap result = new HashMap();
            try {
				//去获取一个资源“META-INF/spring.factories”
                Enumeration urls = classLoader.getResources("META-INF/spring.factories");
				//将找到的资源遍历，封装为一个Properties
                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();

                    while(var6.hasNext()) {
                        Entry<?, ?> entry = (Entry)var6.next();
                        String factoryTypeName = ((String)entry.getKey()).trim();
                        String[] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        String[] var10 = factoryImplementationNames;
                        int var11 = factoryImplementationNames.length;

                        for(int var12 = 0; var12 < var11; ++var12) {
                            String factoryImplementationName = var10[var12];
                            ((List)result.computeIfAbsent(factoryTypeName, (key) -> {
                                return new ArrayList();
                            })).add(factoryImplementationName.trim());
                        }
                    }
                }

                result.replaceAll((factoryType, implementations) -> {
                    return (List)implementations.stream().distinct().collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
                });
                cache.put(classLoader, result);
                return result;
            } catch (IOException var14) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var14);
            }
        }
    }

发现多次出现的文件：spring.factores，全局搜索

打开spring.faction，看到很多自动配置的文件，这就是自动配置的根源

这一个个都是JavaConfig配置类，而且都注入了一些Bean
所以，自动装配真正实现是从classpath中搜索所有的META-INF/spring.factories配置的文件，并将其中对应的org.springframework.boot.autoconfigure。包下的配置项，通过反射实例化并为其标注了@Configration的JavaConfig形式的IOC容器配置类，然后将这些都汇总成为一个实例并加载到IOC容器中

结论

SpringBoot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值
将这些值作为自动配置类导入容器，自动配置类就生效，帮我们进行自动配置工作；
整个J2EE的整体解决方案和自动配置都在springboot-autoconfigure的jar包中；
它会给容器中导入非常多的自动配置类（xxxAutoConfiguration）, 就是给容器中导入这个场景需要的所有组件，并配置好这些组件；
有了自动配置类，免去了我们手动编写配置注入功能组件等的工作；

点击查看代码

posted @ 2021-09-23 12:42 1_f 阅读(17) 评论(0) 收藏举报

刷新页面返回顶部

1_f