SpringBoot启动过程中底层做了哪些？
- 基于配置加载类，将类（启动类所包含的：JVM基础类库优先，spring内部类库...可通过栈追踪 -XX:TraceClassLoading 对JVM参数分析）读到内存。
- 对具有注解、配置文件特定配置的对象进行存储配置信息（借助BeanDefinition存储)
- 基于BeanDefinition对象中的class的配置构建类的实例Bean对象，并进行Bean对象管理（有些可能存储到bean池中）。
业务描述
在项目Module中定义一个类，类名为DefaultCache，然后将此类对象交给Spring创建并管理。最后通过单元测试对类的实例进行分析。
API设计分析
基于业务描述，进行API及关系设计，如图所示：
基于业务及API设计，进行代码编写，其过程如下：
1：
package com.cy.pj.common.cache;
import org.springframework.stereotype.Component;
@Component
//用来描述由spring管理的一般（common）组件
public class DefaultCache {
}
2：
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
//此注解描述的类为springboot工程中的单元测试类
public class DefaultCacheTests {
//has a
@Autowired
//此注解用于告诉spring请按指定规则为此属性赋值
private DefaultCache defaultCache;
@Test
public void testDefaultCache(){
System.out.println("测试：");System.out.println(defaultCache.toString());
}
}
SpringBoot 项目中的对象特性分析
1：
package com.cy.pj.common.pool;
import org.springframework.stereotype.Component;
@Component
public class ObjectPool {
public ObjectPool(){
//通常利用构造方法来检测该类有没有创建System.out.println("ObjectPool类创建了！");
}
}
2：
package com.cy.pj.common.pool;
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 testObjectPool(){
System.out.println("测试：");System.out.println(objectPool01==objectPool02);
/**
- 若为true，则表明为同一对象，即没有创建新对象
- 说明了BeanPool中有且只有一个对象ObjectPool
*/
延迟加载
现在思考一个问题,对于ObjectPool这个类，假如项目启动以后，暂时不会用到这个池对象，是否有必要对其进行创建(默认是会创建的)？我们知道没必要，因为占用内存。那如何在启动时不创建此类对象呢？借助Spring框架提供的延迟加载特性进行实现。例如，我们可以在需要延迟加载的类上使用@Lazy注解进行描述，代码如下：
package com.cy.pj.common.pool;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
@Lazy
@Component
public class ObjectPool {
public ObjectPool(){
//通常利用构造方法来检测该类有没有创建System.out.println("ObjectPool类创建了！");
}
}
对象作用域分析
在实际的项目中内存中的对象有一些可能要反复应用很多次，有一些可能用完以后再也不用了或者说应用次数很少了。对于经常要重复使用的对象我可考虑存储到池中(例如交给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("singleton")
@Lazy
@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("singleton")
@Lazy
@Component
public class ObjectPool {
public ObjectPool(){
//通常利用构造方法来检测该类有没有创建System.out.println("ObjectPool类创建了！");
}
@PostConstruct//该注解描述的方法为生命周期初始化方法，在构建方法前执行
public void init(){
System.out.println("init()");}
@PreDestroy/**
- 该注解描述的方法为生命周期销毁方法，此方法所在的对象
- 若存储到spring容器中，则在销毁容器前，先执行该方法
- prototype作用域对象不执行该方法
*/
public void destroy(){
System.out.println("destroy()");}
}
SpringBoot 项目中的依赖注入过程分析
在SpringBoot工程中，假如类与类之间存在着一定的依赖关系，Spring是如何进行依赖注入的呢，现在我们就通过一个案例做一个分析。
案例设计及分析
为了更好理解spring框架的底层注入机制，现在进行案例API设计，如图所示：
代码编写及测试分析
第一步：定义Cache接口，代码如下：
package com.cy.pj.common.cache;
public interface Cache {
}
第二步：定义Cache接口实现类SoftCache，代码如下：
package com.cy.pj.common.cache;
@Component
public class SoftCache implements Cache{
}第三步：定义Cache接口实现类WeakCache，代码如下：
package com.cy.pj.common.cache;
@Component
public class WeakCache implements Cache{
}第四步：定义CacheTests单元测试类，代码如下：
package com.cy.pj.common.cache;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
public class CacheTests {
@Autowired
//@Qualifier("")
/**
* 此处必须指定实现类的类型
* 即实现Cache有两个类，SoftCache和WeakCache
* 但不指定类型时，底层不知道找哪一个，就会报错
* 可以通过@Qualifier("softCache")来指定类型
* 也可通过 Cache softCache让其比较参数自行查找
* 该参数是底层创建并 命名的，默认类名（首字母小写）
*/
private Cache softCache;
@Test
void testCache(){
System.out.println("测试：");
System.out.println(softCache);
}
}其中，@Autowired由spring框架定义，用于描述类中属性或相关方法(例如构造方法)。Spring框架在项目运行时假如发现由他管理的Bean对象中有使用@Autowired注解描述的属性或方法，可以按照指定规则为属性赋值(DI)。其基本规则是：首先要检测容器中是否有与属性或方法参数类型相匹配的对象，假如有并且只有一个则直接注入。其次，假如检测到有多个，还会按照@Autowired描述的属性或方法参数名查找是否有名字匹配的对象，有则直接注入，没有则抛出异常。最后，假如我们有明确要求，必须要注入类型为指定类型，名字为指定名字的对象还可以使用@Qualifier注解对其属性或参数进行描述(此注解必须配合@Autowired注解使用)。
第五步：运行CacheTests检测输出结果，基于结果理解其注入规则。