SpringBoot2核心技术-基础入门

依赖管理

SpringBoot有很多优点,其中依赖管理也是其特性之一。对于任何一个SpringBoot应用,都会初始化引入一个父项目做依赖管理。

 <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

spring-boot-dependencies几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制。也就是当引入该父工程下的默认依赖，不用写版本号。这是因为在spring-boot-dependencies下已经根据对应的springboot版本管理了相关常用依赖的版本

 <properties>
    <activemq.version>5.15.14</activemq.version>
    <antlr2.version>2.7.7</antlr2.version>
    <appengine-sdk.version>1.9.83</appengine-sdk.version>
    <artemis.version>2.12.0</artemis.version>
    <aspectj.version>1.9.6</aspectj.version>
    <assertj.version>3.16.1</assertj.version>
    <atomikos.version>4.0.6</atomikos.version>
    <awaitility.version>4.0.3</awaitility.version>
    <bitronix.version>2.1.4</bitronix.version>
    <build-helper-maven-plugin.version>3.1.0</build-helper-maven-plugin.version>
    <byte-buddy.version>1.10.18</byte-buddy.version>
    <caffeine.version>2.8.8</caffeine.version>
    <cassandra-driver.version>4.6.1</cassandra-driver.version>
    <classmate.version>1.5.1</classmate.version>
    <commons-codec.version>1.14</commons-codec.version>
    <commons-dbcp2.version>2.7.0</commons-dbcp2.version>
    <commons-lang3.version>3.10</commons-lang3.version>
    <commons-pool.version>1.6</commons-pool.version>
    <commons-pool2.version>2.8.1</commons-pool2.version>
    <couchbase-client.version>3.0.10</couchbase-client.version>
    <db2-jdbc.version>11.5.5.0</db2-jdbc.version>
    <dependency-management-plugin.version>1.0.10.RELEASE</dependency-management-plugin.version>
    <derby.version>10.14.2.0</derby.version>
    <dropwizard-metrics.version>4.1.16</dropwizard-metrics.version>
    <ehcache.version>2.10.6</ehcache.version>
    <ehcache3.version>3.8.1</ehcache3.version>
    <elasticsearch.version>7.6.2</elasticsearch.version>
    <embedded-mongo.version>2.2.0</embedded-mongo.version>
    <exec-maven-plugin.version>1.6.0</exec-maven-plugin.version>
    <flatten-maven-plugin.version>1.2.5</flatten-maven-plugin.version>
    <flyway.version>6.4.4</flyway.version>
    <freemarker.version>2.3.30</freemarker.version>
    <git-commit-id-plugin.version>3.0.1</git-commit-id-plugin.version>
    <glassfish-el.version>3.0.3</glassfish-el.version>
    <glassfish-jaxb.version>2.3.3</glassfish-jaxb.version>
    <groovy.version>2.5.14</groovy.version>
 	...
 	</properties>

如果引入非被管理的依赖,则需要指定版本号;当然我们也可以手动修改默认版本号

 	<!--修改默认mysql版本号-->
 	<properties>
        <mysql.version>5.1.43</mysql.version>
    </properties>

SpringBoot常用注解底层分析**

SpringBoot最明显的优点就是通过注解开发替换原来Spring中的配置文件，提高了程序的灵活性以及可维护性，现总结SpringBoot中常用的核心注解
底层@Configuration注解解析
SpringBoot中用Configuration注解修饰某个配置类,而这个类等价于原来Spring中的bean.xml文件，同时这个配置类也会一同注册到Spring容器中，组件id默认是类名的小写

/**
 * @Description
 * @Author Fangchenjiang
 * @Date 2021/10/5 12:23
 */
@Configuration(proxyBeanMethods=true) //告诉Spring此类为配置类,等价于配置文件
public class MyConfig {

    @Bean  //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user() {
        return new User("xf", 25);
    }


    @Bean
    public Pet pet() {

        return new Pet("anan");
    }
}

Configuration注解中的属性proxyBeanMethods，proxyBeanMethods：代理bean的方法

•  Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用多少次返回的组件都是单实例的】
  

•  Lite(proxyBeanMethods = false)【每个@Bean方法被调用多少次返回的组件都是新创建的】
  

•  组件依赖必须使用Full模式默认。其他默认是否Lite模式
  

proxyBeanMethods默认为true
底层@Import注解解析
导入指定组件并注册到Spring容器,并将组件类的全类名作为组件的id

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Import {

	/**
	 * {@link Configuration @Configuration}, {@link ImportSelector},
	 * {@link ImportBeanDefinitionRegistrar}, or regular component classes to import.
	 */
	Class<?>[] value();
}

@Conditional
条件装配：满足Conditional指定的条件，则进行组件注入

ImportResource
将资源文件中的组件导入并注册到容器中,比如项目中有某个spring的bean.xml文件,通过ImportResource注解以文件形式注册到容器中,十分方便

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="testUser" class="com.example.demo.bean.User"></bean>
</beans>

/**
 * @Description
 * @Author Fangchenjiang
 * @Date 2021/10/5 12:23
 */
@ImportResource(locations = "classpath:bean.xml")
@Configuration //告诉Spring此类为配置类,等价于配置文件
public class MyConfig {
        
}

@ConfigurationProperties
配置信息与组件属性绑定

/**
 * @Description
 * @Author Fangchenjiang
 * @Date 2021/10/7 2:04
 */
@Component
@ConfigurationProperties(prefix = "mycar")
public class Car {
    private String brand;
    private Integer price;

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public Integer getPrice() {
        return price;
    }

    public void setPrice(Integer price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                '}';
    }
}

application.properties

# 应用名称
spring.application.name=demo
# 应用服务 WEB 访问端口
server.port=8080

mycar.brand=BMW
mycar.price=10000

自动配置原理

SpringBoot程序启动，底层事先为我们注册了很多组件到Spring容器中，具体过程如下：
在主启动类的@SpringBootApplication 中，有开启自动配置的注解@EnableAutoConfiguration，该注解通过@Import({AutoConfigurationImportSelector.class})，而自动配置的入口在AutoConfigurationImportSelector中，我们关注核心代码即可：

 //选择导入的组件
 public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        } else {
            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = 
            //获取自动配置入口
            this.getAutoConfigurationEntry(annotationMetadata);
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }
    }
	
	//自动配置实现
	protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        } else {
            AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
            //加载自动配置项
            List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
            //去除重复的配置
            configurations = this.removeDuplicates(configurations);
            Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
            this.checkExcludedClasses(configurations, exclusions);
            configurations.removeAll(exclusions);
            configurations = this.getConfigurationClassFilter().filter(configurations);
            this.fireAutoConfigurationImportEvents(configurations, exclusions);
            return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
        }
    }
	
	
	//通过SpringFactoriesLoader(实际加载配置类的执行者)加载
	 protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        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类中
    public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        String factoryTypeName = factoryType.getName();
        return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, 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 {
            	//获取META-INF/spring.factories下的自动配置相关的类路径
                Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                LinkedMultiValueMap result = new LinkedMultiValueMap();

                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[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        int var10 = var9.length;

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

                cache.put(classLoader, result);
                return result;
            } catch (IOException var13) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
            }
        }
    }

简单总结就是:通过AutoConfigurationImportSelector获取自动装配入口，然后通过SpringFactoriesLoader扫描autoconfigure包下的META-INF/spring.factories中#Auto Configure路径下的类，并通过反射实例化成一个个的配置类并注入到Spring容器中，从而实现了自动装配，虽然127个场景的所有自动配置启动的时候默认全部加载。xxxxAutoConfiguration，但实际具体到配置类时，仍然需要按照条件装配规则（@Conditional），最终会按需配置。