SpringBoot介绍

SpringBoot核心特性

Spring boot是一个脚手架，构建于Spring框架(Framework)基础之上，基于快速构建理念，提供了自动配置功能，可实现其开箱即用特性（创建完一个基本的项目以后，可零配置或者少量配置即可运行我们的项目），其核心主要有如下几个方面：
▪起步依赖(Starter Dependency)-项目创建时底层帮你关联依赖。
▪自动配置(Auto Configuration)。
▪健康检查(Actator)-监控。

起步依赖

起步依赖本质是Mavenue项目对象模型（pom），定义了对其他库的传递依赖，依赖+依赖+。。。支持某项功能

<!--
        作用1: parent标签 集中定义了SpringBoot所有依赖jar包的版本信息.
             由官网解决了jar包冲突性问题.
        作用2: 本地仓库中没有该文件的jar包 parent表示的是一个聚合工程(定义).
    -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
<!--3.依赖工具API-->
<dependencies>
    <dependency>
        <groupId>com.jt</groupId>
        <artifactId>jt-common</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
</dependencies>

之前maven项目需要关系依赖的版本等等，现在只需关注springboot的版本，其他依赖springboot会帮我们进行管理。

自动配置-开箱即用

<dependencies>

        <!--
            手动依赖项 该依赖项被springBoot进行了高度的整合
            springBoot帮助大家动态的生成了配置项目,简化了配置的步骤
            该配置称之为自动化的配置信息
            spring-boot-starter springBoot自动化的启动项.
            开箱即用: 只需要导入jar包简单的配置即可实现对应的功能.
        -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

@EnableAutoConfiguration是实现自动配置的入口，该注解通过@Import注解导入了AutoConfigurationImportSelector.class，在该类中加载配置信息，然后删选出以EnableAutoConfiguration为key的数据，加载到IOC容器中，实现自动配置功能。

健康检查

Spring Boot 中actuator模块提供了健康检查，审计、指标收集，HTTP跟踪等功能，可以帮助我们更好的管理和跟踪springboot项目。
第一步：添加依赖

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

第二步：yml配置文件配置actuator选项

management.endpoints.web.exposure.include=*

第三步：重启服务器，访问webUI
http://localhost/actuator

SpringBoot的启动过程

项目的入口类使用了@SpringBootApplication注解描述，此注解内是：

• @SpringBootConfiguration：组合了 @Configuration 注解，实现配置文件的功能。在启动类里面标注了@Configuration,意味着它其实也是一个 IoC容器的配置类.
• @EnableAutoConfiguration：打开自动配置的功能，也可以关闭某个自动配置的选项，如关闭数据源自动配置功能： @SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })。springboot 应用把所有符合条件的@Configuration 配置都加载到当前 SpringBoot 创建并使用的 IoC 容器中。
• @ComponentScan：Spring组件扫描。默认会扫描当前 package 下的的所有加了@Component 、@Repository、@Service、@Controller的类到 IoC 容器中；

项目启动时发生的过程：

SpringBoot 项目在启动时，首先基于启动入口类上的注解描述，进行自动配置并扫描指定包以及子包中的类进行加载，然后检测类上是否有Spring框架中指定的注解描述（例如@Component,@Controller,@Service等）。假如有，则将类交给Spring框架中的BeanFactory工厂接口的实现类对象，此工厂对象会基于反射创建Bean的实例，假如此Bean指定了生命周期方法，还会调用生命周期方法。当实例创建以后，Spring框架还会基于类的作用域描述，将实例存储到不同作用域的容器中。以实现Bean对象的科学应用。

SpringBoot项目中对象的特性分析

第一步：创建springboot项目05-springboot-features

第二步：创建ObjectPool类

package com.cy.pj.common.pool;

import org.springframework.stereotype.Component;

@Component
public class ObjectPool {
    public ObjectPool(){
        System.out.println("objectpool()");
    }
}

第三步：创建测试类ObjectPoolTests

package com.cy.pj.pool;
import com.cy.pj.common.pool.ObjectPool;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
public class ObjectPoolTests {
        @Autowired
 private ObjectPool objectPool01;
        @Autowired
 private ObjectPool objectPool02;
        @Test
    void testObjectPool01(){
    //true  单例对象     
        System.out.println(objectPool01==objectPool02);
    }
}

延迟加载

对于ObjectPool这个类，假如项目启动以后，暂时不会用到这个池对象，是否有必要对其进行创建(默认是会创建的)？我们知道没必要，因为占用内存。那如何在启动时不创建此类对象呢？借助Spring框架提供的延迟加载特性进行实现。例如，我们可以在需要延迟加载的类上使用@Lazy注解进行描述，代码如下：

package com.cy.pj.common.pool;
@Lazy
@Component
public class ObjectPool{//假设此对象为一个对象池
    public ObjectPool(){//假设运行项目启动类，此构造方法执行了，说明此类对象构建了。
      Systemd.out.println("ObjectPool()")
    }
}

此时，我们再去运行运行启动类，检测ObjectPool对象是否创建了，假如没有创建，说明延迟加载生效了。此时，我们总结一下，什么对象适合使用延迟加载特性呢？大对象，稀少用(项目启动以后，暂时用不到)的对象。
注意：延迟加载并不是延迟对类进行加载，而是在启动时，暂时不创建类的实例。假如想看一下内存中的类是否被加载了，可以通过JVM参数进行检测，参数为-XX:+TraceClassLoading。

对象作用域分析

在实际的项目中内存中的对象有一些可能要反复应用很多次，有一些可能用完以后再也不用了或者说应用次数很少了。对于经常要重复使用的对象我可考虑存储到池中(例如交给spring框架进行管理)，应用次数很少的对象那就没必要放到池中了，用完以后让它自己销毁就可以了。在Spring项目工程中为了对这样的对象进行设计和管理，提供了作用域特性的支持，具体应用：

package com.cy.pj.common.pool;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
@Scope("prototype")//prototype表示多例作用域，此类实例与Lazy无关，
//@Scope//注解用于定义对象作用域，默认为单例作用域（一个JVM内存中名字相同的Bean只能有一个 -key相同的作用域只能有一个）
//@Lazy//描述的类的对象可以延迟其创建 -XX:+TraceClassLoading，可以通过jvm参数，检测类是否加载
@Component
public class ObjectPool {
    public ObjectPool(){
        System.out.println("objectpool()");
    }

其中，在上面的代码中，我们使用了@Scope注解对类进行描述，用于指定类的实例作用域。不写@Scope默认就是单例(singleton)作用域，这个作用域会配合延迟加载(@Lazy)特性使用，表示此类的实例在需要时可以创建一份并且将其存储到spring的容器中(Bean池),需要的时候从池中取，以实现对象的可重用。假如一些对象应用次数非常少，可以考虑不放入池中，进而使用@Scope("prototype")作用域对类进行描述,让此类的对象何时需要何时创建，用完以后，当此对象不可达了，则可以直接被GC系统销毁。

对象生命周期方法

程序中的每个对象都有生命周期，对象创建，初始化，应用，销毁的这个过程称之为对象的生命周期。在对象创建以后要初始化，应用完成以后要销毁时执行的一些方法，我们可以称之为生命周期方法。但不见得每个对象都会定义生命周期方法。在实际项目中往往一些池对象通常会定义这样的一些生命周期方法(例如连接池)。那这样的方法在spring工程中如何进行标识呢？通常要借助@PostConstruct和@PreDestroy注解对特定方法进行描述，例如：

package com.cy.pj.common.pool;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
@Scope("prototype")//prototype表示多例作用域，此类实例与Lazy无关，
//@Scope//注解用于定义对象作用域，默认为单例作用域（一个JVM内存中名字相同的Bean只能有一个 -key相同的作用域只能有一个）
//@Lazy//描述的类的对象可以延迟其创建 -XX:+TraceClassLoading，可以通过jvm参数，检测类是否加载
@Component
public class ObjectPool {
    public ObjectPool(){
        System.out.println("objectpool()");
    }
    @PostConstruct
 public void init(){
        System.out.println("init()");
    }
    @PreDestroy
 public void destroy(){
        System.out.println("destory()");
    }
}

其中:
1)@PostConstruct 注解描述的方法为生命周期初始化方法,在对象构建以后执行.
2)@PreDestroy 注解描述的方法为生命周期销毁方法,此方法所在的对象,假如存储到了spring容器,那这个对象在从spring容器移除之前会先执行这个生命周期销毁方法(prototype作用域对象不执行此方法).