org.junit.vintage
junit-vintage-engine
org.springframework.boot
spring-boot-maven-plugin
package com.cy;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class StartApplication {//Application.class
public static void main(String[] args) {//Main Thread
SpringApplication.run(StartApplication .class, args);
}
}
找到SpringBoot 工程中由@SpringBootApplication注解描述的类为然后启动运行,其启动过程如下:
在启动过程中底层做了哪些事情,大致描述如下:
第一:基于配置加载类(通过ClassLoader将指定位置的类通过线程调用IO从磁盘读取到内存)。
第二:对类进行分析(创建字节码对象-Class类型,通过反射获取器配置信息)。
第三:对于指定配置(例如由spring特定注解描述)的对象存储其配置信息(借助BeanDefinition对象存储)。
第四:基于BeanDefinition对象中class的配置构建类的实例(Bean对象),并进行bean对象的管理(可能会存储到bean池)。
===========================================================================
在项目Module中定义一个类,类名为DefaultCache,然后将此类对象交给Spring创建并管理。最后通过单元测试对类的实例进行分析。
基于业务描述,进行API及关系设计,如图所示:
在这张图中描述了一个DefaultCache和DefaultCacheTests单元测试类,这个两个类都交给了spring管理,并且DefaultCacheTests类依赖于DefaultCache类型,由spring框架基于@Autowired对属性描述,进行执行的注入(将DefaultCache类型对象,注入给DefaultCache类型)。
在Spring框架规范中,所有由spring管理的对象都称之为Bean对象,我们现在基于如上业务及API设计图,进行Bean类型代码的编写及测试,其过程如下:
第一步:定义DefaultCache类,并交给spring管理。
package com.cy.pj.common.cache;
import org.springframework.stereotype.Component;
/**
- @Component 注解描述的类,表示此类交给Spring框架管理。
*/
@Component
public class DefaultCache {
}
第二步:定义DefaultCacheTests单元测试类
package com.cy.pj.common.cache;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
@SpringBootTest
public class DefaultCacheTests {
/**
- @Autowired 注解描述的属性由spring框架按照一定规则为其注入值。
*/ @Autowired
private DefaultCache defaultCache;
@Test
void testDefaultCache(){
System.out.println(defaultCache.toString());
//FAQ? defaultCache变量引用的对象是由谁创建的,存储 到了哪里?bean pool
}
}
第三步:运行单元测试类进行应用分析
启动运行单元测试方法,检测其输出结果,基于结果分析:
1)SpringBoot项目中Bean对象的构建(例如DefaultCache类型的对象是如何构建、何时构建的)。
2)SpringBoot项目中Bean对象的获取(例如DefaultCacheTests类中是符合获取DefaultCache类型对象的,基于IOC。)
说明:这个案例中描述了Spring IOC设计思想,项目中将对象交给Spring管理(我们饭来张口,衣来伸手,Spring框架实现对象控制),由spring完成对象的依赖查找和依赖注入的过程(这个种设计最重要的设计是让初学者规避对象管理的风险,对象由专业人士进行控制)。
- 测试过程中Bean类型找不到,如图所示:
- 空指针异常(NullPointerExcetpion-NPE),如图所示:
- 运行单元测试类,启动类找不到,如图所示:
- 运行单元测试类,启动类有多个,如图所示:
- 运行单元测试,提示NoSuchBeanDefinition异常,如图所示:
- 单元测试类中的方法添加了参数,如图所示:
===============================================================================
第一步:添加业务类ObjectPool,代码如下:
package com.cy.pj.common.pool;
@Component
public class ObjectPool{//假设此对象为一个对象池
public ObjectPool(){//假设运行项目启动类,此构造方法执行了,说明此类对象构建了。
Systemd.out.println(“ObjectPool()”)
}
}
第二步:定义单元测试,代码如下:
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;
@Test
void testObjectPool01(){
System.out.println(objectPool01);//true
}
}
现在思考一个问题,对于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;
@Scope(“singleton”)
@Lazy
@Component
public class ObjectPool{//假设此对象为一个对象池
public ObjectPool(){//假设运行项目启动类,此构造方法执行了,说明此类对象构建了。
Systemd.out.println(“ObjectPool()”)
}
}
其中,在上面的代码中,我们使用了@Scope注解对类进行描述,用于指定类的实例作用域。不写@Scope默认就是单例(singleton)作用域,这个作用域会配合延迟加载(@Lazy)特性使用,表示此类的实例在需要时可以创建一份并且将其存储到spring的容器中(Bean池),需要的时候从池中取,以实现对象的可重用。假如一些对象应用次数非常少,可以考虑不放入池中,进而使用@Scope(“prototype”)作用域对类进行描述,让此类的对象何时需要何时创建,用完以后,当此对象不可达了,则可以直接被GC系统销毁。基于代码进行测试分析,例如:
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 testObjectScope(){
System.out.println(objectPool01==objectPool02);//true 表示单例作用域,false表示prototype作用域
}
}
程序中的每个对象都有生命周期,对象创建,初始化,应用,销毁的这个过程称之为对象的生命周期。在对象创建以后要初始化,应用完成以后要销毁时执行的一些方法,我们可以称之为生命周期方法。但不见得每个对象都会定义生命周期方法。在实际项目中往往一些池对象通常会定义这样的一些生命周期方法(例如连接池)。那这样的方法在spring工程中如何进行标识呢?通常要借助@PostConstruct和@PreDestroy注解对特定方法进行描述,例如:
package com.cy.pj.common.pool;
@Scope(“singleton”)
@Lazy
@Component
public class ObjectPool{//假设此对象为一个对象池
public ObjectPool(){
Systemd.out.println(“ObjectPool()”)
}
@PostConstruct
public void init(){
System.out.println(“init()”);
}
@PreDestroy
public void destory(){
System.out.println(“destory()”);
}
}
其中:
1)@PostConstruct 注解描述的方法为生命周期初始化方法,在对象构建以后执行.
2)@PreDestroy 注解描述的方法为生命周期销毁方法,此方法所在的对象,假如存储到了spring容器,那这个对象在从spring容器移除之前会先执行这个生命周期销毁方法(prototype作用域对象不执行此方法).
=============================================================================
为了更好理解sping框架的底层注入机制,现在进行案例API设计,理解API的依赖注入过程,如图所示:
在这个案例中单元测试类CacheTests中定义一个Cache接口类型的属性,然后由Spring框架完成对cache类型属性值的注入。
第一步:定义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,代码如下:
为了更好理解sping框架的底层注入机制,现在进行案例API设计,理解API的依赖注入过程,如图所示:
在这个案例中单元测试类CacheTests中定义一个Cache接口类型的属性,然后由Spring框架完成对cache类型属性值的注入。
第一步:定义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,代码如下: