SpringBoot

1. SpringBoot 项目快速搭建

创建一个 maven 工程（jar）
导入SpringBoot 相关的依赖

	<parent>
	    <groupId>org.springframework.boot</groupId>
	    <artifactId>spring-boot-starter-parent</artifactId>
	    <version>2.1.12.RELEASE</version>
	</parent>
	<dependencies>
	    <dependency>
	        <groupId>org.springframework.boot</groupId>
	        <artifactId>spring-boot-starter-web</artifactId>
	    </dependency>
	</dependencies>

编写一个主程序，启动 SpringBoot 应用

package com.wangzhao;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author wangzhao
 * @date 2020/6/29 17:43
 */

// @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用
@SpringBootApplication
public class HelloWorldMainApplication {

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

}

编写 Controller 层

package com.wangzhao.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author wangzhao
 * @date 2020/6/29 17:47
 */
@RestController
public class HelloController {

    @RequestMapping("/hello")
    public String sayHello() {
        return "Hello World!";
    }
    
}

运行主程序测试

6. 项目整体结构

如上，便成功启动了一个SpringBoot的项目，可以看到，相比于Spring而言，SpringBoot使用非常简单，快速，并且我们几乎没有进行任何配置文件的填写。

2. HelloWorld 探究

2.1 pom.xml

2.1.1 父项目

Hello World其所依赖的父项目为：spring-boot-starter-parent

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.9.RELEASE</version>
  </parent>

我们可以看一下spring-boot-starter-parent做了哪些事情

	<properties>
	    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
	    <java.version>1.8</java.version>
	    <resource.delimiter>@</resource.delimiter>
	    <maven.compiler.source>${java.version}</maven.compiler.source>
	    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	    <maven.compiler.target>${java.version}</maven.compiler.target>
    </properties>

使用 UTF-8 格式编码
定义了 Java 编译版本为 1.8 。

除此之外，spring-boot-starter-parent其所依赖的父项目为spring-boot-dependencies：

	<parent>
	    <groupId>org.springframework.boot</groupId>
	    <artifactId>spring-boot-dependencies</artifactId>
	    <version>2.1.12.RELEASE</version>
	    <relativePath>../../spring-boot-dependencies</relativePath>
   </parent>

	<properties>
	    <activemq.version>5.15.11</activemq.version>
	    <antlr2.version>2.7.7</antlr2.version>
	    <appengine-sdk.version>1.9.77</appengine-sdk.version>
	    <artemis.version>2.6.4</artemis.version>
	    <aspectj.version>1.9.5</aspectj.version>
	    <assertj.version>3.11.1</assertj.version>
	    <atomikos.version>4.0.6</atomikos.version>
	    <bitronix.version>2.1.4</bitronix.version>
	    ......
    </properties>
    
    <dependencyManagement>
	    <dependencies>
	      <dependency>
	        <groupId>org.springframework.boot</groupId>
	        <artifactId>spring-boot</artifactId>
	        <version>2.1.12.RELEASE</version>
	      </dependency>
	      <dependency>
	        <groupId>org.springframework.boot</groupId>
	        <artifactId>spring-boot-test</artifactId>
	        <version>2.1.12.RELEASE</version>
	      </dependency>
	      ......
	   </dependencies>
	</dependencyManagement>

其相当于SpringBoot的版本仲裁中心；

他提供了jar包的版本管理，以及Spring框架和其他第三方组件jar包的依赖管理。

2.1.2 导入的依赖

回到我们项目的pom文件中，导入了该依赖。

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

让我们进入到spring-boot-starter-web的pom文件中，可以看到导入的都是web相关的模块，并且还内置了一个tomcat。

<dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
      <version>2.1.12.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-json</artifactId>
      <version>2.1.12.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <version>2.1.12.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.hibernate.validator</groupId>
      <artifactId>hibernate-validator</artifactId>
      <version>6.0.18.Final</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.1.13.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.1.13.RELEASE</version>
      <scope>compile</scope>
    </dependency>
  </dependencies>

spring-boot-starter：spring-boot场景启动器，其帮我们导入了相关场景模块正常运行所依赖的组件；

Spring Boot将所有的功能场景都抽取出来，做成一个个的starter（启动器），只需要在项目里面引入这些starter相关场景的所有依赖都会导入进来。要用什么功能，就导入什么场景的启动器。

2.2 主启动类

// @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用
@SpringBootApplication
public class HelloWorldMainApplication {

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

}

@SpringBootApplication：SpringBoot应用标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot就应该运行这个类的main()方法启动SpringBoot应用。

2.2.1 @SpringBootApplication

进入到@SpringBootApplication内，观察其做了哪些工作：

package org.springframework.boot.autoconfigure;


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

	// 根据class来排除特定的类，使其不能加入spring容器，传入参数value类型是class类型。
	@AliasFor(annotation = EnableAutoConfiguration.class)
	Class<?>[] exclude() default {};

	// 根据classname 来排除特定的类，使其不能加入spring容器，传入参数value类型是class的全类名字符串数组。
	@AliasFor(annotation = EnableAutoConfiguration.class)
	String[] excludeName() default {};

	// 指定扫描包，参数是包名的字符串数组。
	@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
	String[] scanBasePackages() default {};

	// 扫描特定的包，参数类似是Class类型数组。
	@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
	Class<?>[] scanBasePackageClasses() default {};

}

可以看到@SpringBootApplication是一个复合注解，包括@SpringBootConfiguration，@EnableAutoConfiguration和@ComponentScan。

@SpringBootConfiguration：SpringBoot的配置类，标注在某个类上，表示这是一个SpringBoot的配置类。

package org.springframework.boot;

// 配置类的作用等同于配置文件，配置类也是容器中的一个对象
@Configuration
public @interface SpringBootConfiguration {
}

@EnableAutoConfiguration：开启自动配置功能，以前由我们需要配置的东西，现在由SpringBoot帮我们自动配置，这个注解就是Springboot能实现自动配置的关键。
@ComponentScan：这个注解是组件扫描这个是我们最熟悉的注解，即使没有使用过注解也经常在Spring的配置文件中使用过<context:component-scan base-package="com.xxx.xxx"/>, 组件扫描就是扫描指定的包下的类，并加载符合条件的组件。

3. @EnableAutoConfiguration

package org.springframework.boot.autoconfigure;

// 自动配置包
@AutoConfigurationPackage

// Spring的底层注解@Import，给容器中导入一个组件；
// 导入的组件是AutoConfigurationPackages.Registrar.class 
@Import(AutoConfigurationImportSelector.class)

// 告诉SpringBoot开启自动配置功能，这样自动配置才能生效。
public @interface EnableAutoConfiguration {

	String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

	// 返回不会被导入到 Spring 容器中的类
	Class<?>[] exclude() default {};

	// 返回不会被导入到 Spring 容器中的类名
	String[] excludeName() default {};

}

Spring 中有很多以Enable开头的注解，其作用就是借助@Import来收集并注册特定场景相关的Bean，并加载到IOC容器。@EnableAutoConfiguration就是借助@Import来收集所有符合自动配置条件的bean定义，并加载到IoC容器。

@EnableAutoConfiguration就是借助@Import来收集所有符合自动配置条件的Bean定义，并加载到IOC容器。

3.1 @AutoConfigurationPackage

@AutoConfigurationPackage：自动配置包，它也是一个组合注解，其中最重要的注解是@Import(AutoConfigurationPackages.Registrar.class)，它是Spring框架的底层注解，它的作用就是给容器中导入某个组件类，例如@Import(AutoConfigurationPackages.Registrar.class)，它就是将Registrar这个组件类导入到容器中，可查看Registrar类中registerBeanDefinitions方法，这个方法就是导入组件类的具体实现。

package org.springframework.boot.autoconfigure;

@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {

}

@Override
public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
	// 将注解标注的元信息传入，获取到相应的包名
	register(registry, new PackageImport(metadata).getPackageName());
}

可以看到AnnotationMetadata（注解标注注的元信息中包含了使用了哪些注解，相应的注解作用在哪个类上）

我们对new PackageImport(metadata).getPackageName()进行检索，看看其结果是什么？

因此可以得知使用@AutoConfigurationPackage注解就是将主程序类所在包及所有子包下的组件到扫描到Spring容器中。

3.1.1 AutoConfigurationImportSelector

@Import({AutoConfigurationImportSelector.class})：将AutoConfigurationImportSelector这个类导入到Spring容器中，AutoConfigurationImportSelector可以帮助Springboot应用将所有符合条件的@Configuration配置都加载到当前SpringBoot创建并使用的IOC容器(ApplicationContext)中。

AutoConfigurationImportSelector 是 ImportSelector 接口的实现类，而 ImportSelector 接口中的selectImports方法将返回的全限定类名对应的类交给 Spring 容器管理。

其不光实现了ImportSelector接口，还实现了很多其它的Aware接口，分别表示在某个时机会被回调。

public interface ImportSelector {
	String[] selectImports(AnnotationMetadata importingClassMetadata);
}

我们可以知道，所有的aware都优先于selectImports方法执行，也就是说selectImports方法最后执行，那么在它执行的时候所有需要的资源都已经获取到了（AutoConfigurationImportSelector的四个成员变量）

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
		ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {

	private ConfigurableListableBeanFactory beanFactory;

	private Environment environment;

	private ClassLoader beanClassLoader;

	private ResourceLoader resourceLoader;

	@Override
	public String[] selectImports(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return NO_IMPORTS;
		}
		// 获得自动配置元信息，需要传入beanClassLoader这个类加载器
		AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
				.loadMetadata(this.beanClassLoader);
		AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata,
				annotationMetadata);
		return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
	}

深入研究 loadMetadata 方法

	// 文件中为需要加载的配置类的类路径
	protected static final String PATH = "META-INF/" + "spring-autoconfigure-metadata.properties";

	public static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader) {
		return loadMetadata(classLoader, PATH);
	}

	static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader, String path) {
		try {

            // 读取spring-boot-autoconfigure-2.1.12.RELEASE.jar包中
            // spring-autoconfigure-metadata.properties的信息生成urls枚举对象
			Enumeration<URL> urls = (classLoader != null) ? classLoader.getResources(path)
					: ClassLoader.getSystemResources(path);
			Properties properties = new Properties();

            //解析urls枚举对象中的信息封装成properties对象并加载
			while (urls.hasMoreElements()) {
				properties.putAll(PropertiesLoaderUtils
						.loadProperties(new UrlResource(urls.nextElement())));
			}

            //根据封装好的properties对象生成AutoConfigurationMetadata对象返回
			return loadMetadata(properties);
		}
		catch (IOException ex) {
			throw new IllegalArgumentException(
					"Unable to load @ConditionalOnClass location [" + path + "]", ex);
		}
	}

深入研究 getAutoConfigurationEntry 方法

	protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
			AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return EMPTY_ENTRY;
		}
		// 将注解元信息封装成注解属性对象
		AnnotationAttributes attributes = getAttributes(annotationMetadata);
		// 获取到配置类的全路径字符串集合
		List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
		// 删除重复项
		configurations = removeDuplicates(configurations);
		// 应用 exclusion 属性
		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
		checkExcludedClasses(configurations, exclusions);
		configurations.removeAll(exclusions);
		
		// 应用过滤器 AutoConfigurationImportFilter，
        // 对于 spring boot autoconfigure，定义了一个需要被应用的过滤器 ：
        // org.springframework.boot.autoconfigure.condition.OnClassCondition，
        // 此过滤器检查候选配置类上的注解@ConditionalOnClass，如果要求的类在classpath
        // 中不存在，则这个候选配置类会被排除掉
		configurations = filter(configurations, autoConfigurationMetadata);
		
		// 现在已经找到所有需要被应用的候选配置类
        // 广播事件 AutoConfigurationImportEvent 
		fireAutoConfigurationImportEvents(configurations, exclusions);
		return new AutoConfigurationEntry(configurations, exclusions);
	}

深入 getCandidateConfigurations 方法

这个方法中有一个重要方法loadFactoryNames，这个方法是让SpringFactoryLoader去加载一些组件的名字。

	protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
	 // 这个方法需要传入两个参数getSpringFactoriesLoaderFactoryClass()和getBeanClassLoader()
     // getSpringFactoriesLoaderFactoryClass()这个方法返回的是EnableAutoConfiguration.class
     // getBeanClassLoader()这个方法返回的是beanClassLoader（类加载器）
		List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
				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;
	}

继续点开loadFactory方法

	public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
        
        //获取出入的键
        String factoryClassName = factoryClass.getName();
        return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
    }

    private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
        MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            try {
              
                //如果类加载器不为null，则加载类路径下spring.factories文件，将其中设置的配置类的全路径信息封装 为Enumeration类对象
                Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                LinkedMultiValueMap result = new LinkedMultiValueMap();

                //循环Enumeration类对象，根据相应的节点信息生成Properties对象，通过传入的键获取值，在将值切割为一个个小的字符串转化为Array，方法result集合中
                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 factoryClassName = ((String)entry.getKey()).trim();
                        String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        int var10 = var9.length;

                        for(int var11 = 0; var11 < var10; ++var11) {
                            String factoryName = var9[var11];
                            result.add(factoryClassName, factoryName.trim());
                        }
                    }
                }

                cache.put(classLoader, result);
                return result;
       }
   }
}

3.2 自动配置原理

SpringBoot启动的时候加载主配置类，开启了自动配置功能 @EnableAutoConfiguration
@EnableAutoConfiguration 作用：

利用 EnableAutoConfigurationImportSelector 给容器中导入一些组件
可以查看 selectImports() 方法的内容：

List<String> configurations = this.getCandidateConfigurations(annotationMetadata,attributes);

上面代码的作用是获取候选的配置

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    
   List<String> configurations = SpringFactoriesLoader.loadFactoryNames();
    
   // 扫描所有 jar 包类路径下  META-INF/spring.factories
   // 把扫描到的这些文件的内容包装成 properties 对象
   // 从properties中获取到 EnableAutoConfiguration.class类（类名对应的值），把他们添加到容器中

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
......

每一个这样的 xxxAutoConfiguration类都是容器中的一个组件，都加入到容器之中。用它们来做自动配置。

每一个自动配置类进行自动配置功能
以 HttpEncodingAutoConfiguration（Http编码自动配置）为例解释自动配置原理

// 表示这是一个配置类，和以前编写的配置文件一样，也可以给容器中添加组件
@Configuration

// 启动指定类的ConfigurationProperties功能；将配置文件中对应的值和HttpEncodingProperties绑定起来；
@EnableConfigurationProperties({HttpEncodingProperties.class}) 

// Spring底层@Conditional注解，根据不同的条件，如果满足指定的条件，整个配置类里面的配置就会生效。
// 判断当前应用是否是web应用，如果是，当前配置类生效。并把HttpEncodingProperties加入到 ioc 容器中
@ConditionalOnWebApplication

// 判断当前项目有没有这个CharacterEncodingFilter ： SpringMVC中进行乱码解决的过滤器
@ConditionalOnClass({CharacterEncodingFilter.class})

// 判断配置文件中是否存在某个配置 spring.http.encoding.enabled 如果不存在，判断也是成立的
// matchIfMissing = true 表示即使我们配置文件中不配置spring.http.encoding.enabled=true，也是默认生效的
@ConditionalOnProperty(
    prefix = "spring.http.encoding",
    value = {"enabled"},
    matchIfMissing = true
)
public class HttpEncodingAutoConfiguration {
    
    // 它已经和SpringBoot配置文件中的值进行映射了
    private final HttpEncodingProperties properties;
    
    // 只有一个有参构造器的情况下，参数的值就会从容器中拿
    public HttpEncodingAutoConfiguration(HttpEncodingProperties properties) {
        this.properties = properties;
    }
    
    @Bean	//给容器中添加一个组件，这个组件中的某些值需要从properties中获取
    @ConditionalOnMissingBean({CharacterEncodingFilter.class})	//判断容器中没有这个组件
    public CharacterEncodingFilter characterEncodingFilter() {
        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
        filter.setEncoding(this.properties.getCharset().name());
        filter.setForceRequestEncoding(this.properties.shouldForce(Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
        return filter;
    }

根据当前不同的条件判断，决定这个配置类是否生效。

一旦这个配置类生效，这个配置类就会给容器中添加各种组件；这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是和配置文件绑定的。

# 我们能配置的属性都是来源于这个功能的properties类
spring.http.encoding.enabled=true
spring.http.encoding.charset=utf-8
spring.http.encoding.force=true

所有在配置文件中能配置的属性都是在 xxxProperties 类中封装着，配置文件能配置什么就可以参照某个功能对应的这个属性类。

// 从配置文件中获取指定的值和bean的属性进行绑定
@ConfigurationProperties(prefix = "spring.http.encoding")
public class HttpEncodingProperties {
    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

3.3 精髓

SpringBoot 启动会加载大量的自动配置类
我们看我们需要实现的功能有没有SpringBoot默认写好的自动配置类
我们再来看这个自动配置类中到底配置了哪些组件；（只要我们有我们要用的组件，我们就不需要再来配置了）
给容器中自动配置类添加组件的时候，会从properties类中获取某些属性，我们就可以在配置文件中指定这些属性的值。

xxxAutoConfiguration：自动配置类，用于给容器中添加组件从而代替之前我们手动完成大量繁琐的配置。

xxxProperties : 封装了对应自动配置类的默认属性值，如果我们需要自定义属性值，只需要根据xxxProperties寻找相关属性在配置文件设值即可。

SpringBoot 自动配置源码分析

SpringBoot

1. SpringBoot 项目快速搭建

2. HelloWorld 探究

2.1 pom.xml

2.1.1 父项目

2.1.2 导入的依赖

2.2 主启动类

2.2.1 @SpringBootApplication

3. @EnableAutoConfiguration

3.1 @AutoConfigurationPackage

3.1.1 AutoConfigurationImportSelector

深入研究 loadMetadata 方法

深入研究 getAutoConfigurationEntry 方法

深入 getCandidateConfigurations 方法

3.2 自动配置原理

3.3 精髓

SpringBoot 自動配置源碼分析

Docker 核心技術與基本原理

MySQL之表

03-J.U.C之AQS

Java SE 不得不注意的地方

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結