Spring Boot 背景分析
JAVAEE应用体系中繁重的配置、低下的开发效率、高难度的三方集成，复杂的部署流程等等一直被开发人员所诟病。即使是使用Spring这样的轻量级的资源整合框架，在实现其相对比较多的资源整合时，依旧需要大量的手动依赖管理，复杂的XML配置(还经常没有提示)。还有就是现在的软件生态应用也已经形成一定的规模，系统架构正在从单体架构，分布式架构，跨越到微服务架构。随着整个架构体系的变化，企业对技术的要求也在变化，现在的企业更注重技术的开箱即用，更注重技术在生态圈中的深度融合，更注重轻量级的运维。由此由此spring boot诞生。
Spring Boot 要解决什么问题
Spring Boot是由Pivotal团队提供的全新的Java软件开发框架（很多人现在把它理解为一个脚手架），其设计目的是用来简化Spring项目的初始搭建以及开发过程。该框架使用了特定的注解方式来进行配置，从而使开发人员不再需要大量的xml配置。不再需要大量的手动依赖管理。Spring Boot基于快速构建理念，通过约定大于配置，开箱即用的方式，希望能够在蓬勃发展的快速应用开发领域成为其领导者。
Spring Boot 有哪些核心的关键特性
- 起步依赖(Starter Dependency)。
- 自动配置(Auto Configuration)。
- 健康检查(Actator)-监控。
- 嵌入式服务(Tomcat,Jetty)。
创建一个SpringBoot项目
创建Module
基于IDEA创建项目Module,模块名为04-springboot-start,组id和包名为com.cy,如图所示:
填写module信息,如图所示:
选择项目module版本,暂时不需要自己手动添加任何依赖,如图所示:
填写Module名称,完成module创建,如图所示
项目结构分析
项目Module创建好以后，其代码结构分析，如图所示：
SpringBoot 项目启动分析
启动入口
SpringBoot 工程中由SpringBootApplication注解描述的类为启动入口类，例如：
| package com.cy; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class Application {//Application.class public static void main(String[] args) {//Main Thread SpringApplication.run(Application.class, args); } }
|
启动过程概要分析
SpringBoot工程启动时其简易初始化过程，如图所示：
在启动过程中底层做了哪些事情，大致描述如下：
1)基于配置加载类(通过ClassLoader将指定位置的类读到内存->底层通过线程调用IO从磁盘读取到内存)。
2)对类进行分析(创建字节码对象-Class类型,通过反射获取器配置信息)。
3)对于指定配置(例如由spring特定注解描述)的对象存储其配置信息(借助BeanDefinition对象存储)。
4)基于BeanDefinition对象中class的配置构建类的实例(Bean对象),从进行bean对象的管理。
SpringBoot 快速入门分析
业务描述
在项目Module中定义一个类，类名为DefaultCache，然后将此类对象交给Spring创建并管理。最后通过单元测试对类的实例进行分析。
API设计分析
基于业务描述，进行API及关系设计，如图所示：
代码编写及运行
基于业务及API设计，进行代码编写，其过程如下：
第一步：定义DefaultCache类
| 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; public class DefaultCacheTests { /** * @Autowired 注解描述的属性由spring框架按照一定规则为其注入值（赋值） * 赋值过程是怎样的？ * 1)依赖查找？(请问查找规则是什么？) * 2)依赖注入？(需要借助什么技术?) */ @Autowired private DefaultCache defaultCache; @Test void testDefaultCache(){ System.out.println(defaultCache.toString()); //FAQ? defaultCache变量引用的对象是由谁创建的，存储到了哪里？bean pool } }
|
第三步：运行单元测试类进行应用分析
启动运行单元测试方法，检测其输出结果，基于结果分析：
1)SpringBoot项目中Bean对象的构建。
2)SpringBoot项目中Bean对象的获取。
运行过程中的BUG分析
- Bean类型找不到，如图所示：
空指针异常(NullPointerExcetpion-NPE),如图所示：
SpringBoot 项目中的对象特性分析
准备工作
第一步：创建项目Module，例如名字为05-springboot-features,如图所示：
第二步：添加业务类ObjectPool,代码如下：
| package com.cy.pj.common.pool; @Component public class ObjectPool{//假设此对象为一个对象池 public ObjectPool(){//假设运行项目启动类，此构造方法执行了，说明此类对象构建了。 Systemd.out.println("ObjectPool()") } }
|
思考：一般池对象有什么特点？
1)在JVM内存会开辟一块相对比较大的空间。
2)在这块空间中存储一些对象(思考基于什么存储结构进行存储-数组，链表，散列表)。
3)基于“享元模式”设计思想，实现内存中对象的可重用性。
第三步:定义单元测试,代码如下:
| 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(){ System.out.println(objectPool01==objectPool02); } }
|
对 @SpringBootApplication 注解的理解：
- 此注解描述的类为是SpringBoot的入口对象
- 我们通过这个入口来启动SpringBoot项目,这个入口有什么特点?
- 1)由SpringBootApplication注解描述（在SpringBoot项目中只有一个）
- 2)包一个main方法，在方法中完成SprinBboot项目的初始化
- FAQ:请问初始化时SpringBoot底层会做什么?
- 1)加载类（通过类加载器(ClassLoader)将指定位置的类读到内存-->底层通过 线程调用IO从磁盘读取数据）
- 2)对类进行分析(创建字节码对象,——Class类型,通过反射获取其配置信息)
- 3)对于指定配置(例如由Spring特定注解描述)的对象存储其配置信息(借助 BeanDefinition对象存储);
- 4)基于BeanDefinition对象中class的配置信息构建类的实例（Bean对象）,从而进行bean对象的管理
- 思考：浏览器中输入一个url（例如：http://www.baidu.com）然后回车,底层会做点什么?
- 1)将url发送给域名服务器(DNS),如果DNS解析域名获取IP地址（IP地址是网络当中计算机的唯一标识）
- 2)通过IP地址找到网络中的计算机服务器,再通过端口号定位到具体的web服务器 (例如tomcat)（端口号是计算机应用程序的唯一标识）
- 3)web服务器可以通过线程调用io读取到网络中的http协议中的数据,并对数据进行解析,然后封装到request对象
- 4)web服务器调用JAVAEE规范中的对象（Filter,Servlet）处理请求,请求处理结束再响应一个结果传递到客户端
思考：一般池对象有什么特点？
1)在JVM内存中会开辟一块相对比较大的空间。
2)在这块空间中存储一些对象（思考基于什么存储结构进行存储-数组，链表，散列表）。
3)基于“享元模式”设计思想，实现内存中对象的可重用性。
享元模式（Flyweight Pattern）主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。
延迟加载：
现在思考一个问题,对于ObjectPool这个类，假如项目启动以后，暂时不会用到这个池对象，是否有必要对其进行创建(默认是会创建的)？我们知道没必要，因为占用内存。那如何在启动时不创建此类对象呢？借助Spring框架提供的延迟加载特性进行实现。例如，我们可以在需要延迟加载的类上使用@Lazy注解进行描述，代码如下：
| package com.cy.pj.common.pool;
import org.springframework.context.annotation.Lazy; import org.springframework.stereotype.Component;
//-XX:+TraceClassLoading 可以通过JVM参数检测类有没有被加载了 @Lazy //描述的类的对象可以延迟其创建,何时需要何时创建,按需加载 @Component public class ObjectPool { public ObjectPool(){ System.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系统销毁。
对象生命周期方法
程序中的每个对象都有生命周期，对象创建，初始化，应用，销毁的这个过程称之为对象的生命周期。在对象创建以后要初始化，应用完成以后要销毁时执行的一些方法，我们可以称之为生命周期方法。但不见得每个对象都会定义生命周期方法。在实际项目中往往一些池对象通常会定义这样的一些生命周期方法(例如连接池)。那这样的方法在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作用域对象不执行此方法).
SpringBoot 项目中的依赖注入过程分析
在SpringBoot工程中，假如类与类之间存在着一定的依赖关系，Spring是如何进行依赖注入的呢，现在我们就通过一个案例做一个分析。
准备工作
第一步：创建一个项目module，如图所示：
第二步：启动运行项目，检测是否能成功启动
案例设计及分析
为了更好理解spring框架的底层注入机制，现在进行案例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，代码如下：
| 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;
@SpringBootTest public class CacheTests { @Autowired @Qualifier("softCache") private Cache cache;
@Test public void testCache() { System.out.println(cache); } }
|
其中，@Autowired由spring框架定义，用于描述类中属性或相关方法(例如构造方法)。Spring框架在项目运行时假如发现由他管理的Bean对象中有使用@Autowired注解描述的属性或方法，可以按照指定规则为属性赋值(DI)。其基本规则是：首先要检测容器中是否有与属性或方法参数类型相匹配的对象，假如有并且只有一个则直接注入。其次，假如检测到有多个，还会按照@Autowired描述的属性或方法参数名查找是否有名字匹配的对象，有则直接注入，没有则抛出异常。最后，假如我们有明确要求，必须要注入类型为指定类型，名字为指定名字的对象还可以使用@Qualifier注解对其属性或参数进行描述(此注解必须配合@Autowired注解使用)。
第五步：运行CacheTests检测输出结果，基于结果理解其注入规则。
编写及测试过程中的BUG分析
- 依赖注入异常，如图所示：
总结(Summary)
本小节为springboot技术入门章节，主要讲述了SpringBoot工程下，spring中bean对象的编写，特性以及依赖注入的规则，希望通过这一小节的讲解，同学们能够理解我们为什么要将对象交给spring管理，spring管理对象有什么优势，我们在springboot工程中应该如何配置这些对象。
扫一扫
633
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
