Idea工具中创建 SpringBoot工程及入门分析

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对象的管理(可能会存储到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;
@SpringBootTest
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),如图所示：

启动类找不到,如图所示:

启动类有多个,如图所示:

NoSuchBeanDefinition异常,如图所示:

单元测试类中的方法添加了参数,如图所示:

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);
    }
}

延迟加载

现在思考一个问题,对于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系统销毁。

对象生命周期方法

程序中的每个对象都有生命周期，对象创建，初始化，应用，销毁的这个过程称之为对象的生命周期。在对象创建以后要初始化，应用完成以后要销毁时执行的一些方法，我们可以称之为生命周期方法。但不见得每个对象都会定义生命周期方法。在实际项目中往往一些池对象通常会定义这样的一些生命周期方法(例如连接池)。那这样的方法在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工程中应该如何配置这些对象。

springboot

阅读 20.3k更新于 2020-11-27

赞222收藏69

本作品系原创，采用《署名-非商业性使用-禁止演绎 4.0 国际》许可协议

[

springboot 最佳实践

](https://segmentfault.com/blog...

SpringBoot技术的势、道、术分析与实践。

已关注

19 条评论

得票时间

[](https://segmentfault.com/a/11...

Mario_redamancy：

@Autowired注解描述的属性由spring框架按照一定规则为其注入值(赋值),赋值过程是怎样的？

@Autowired的赋值过程:
默认优先按照类型去容器中找对应的组件,getBean(Xxx.class),找到就赋值
如果找到多个相同类型的组件,再将属性的名称作为组件的id去容器中查找getBean("xxx")

什么是依赖？
在A类中需要用到B类中的方法，通过直接new的方式创建B类对象，就产生了依赖关系，A依赖B
依赖查找的规则？
1) 依赖拖拽？
依赖拖拽的方式是通过读取配置文件(.propertis,.xml等)获取bean信息存入Map中，然后查找需要的依赖对象进行创建（就是第二阶段张慎政老师教的通过配置标签的形式进行对象管理）
2) 上下文查找？
上下文查找不太理解，查了一些资料，上下文查找是与当前环境有关，是动态获取bean对象的方式
依赖注入？
Spring会自动识别依赖关系,由IOC容器在运行期间,动态的将某种依赖关系注入到对象之中
defaultCache变量引用由谁创建,存储到了那里?

defaultCache变量引用的对象是由BeanFactory创建并存储到bean pool中,其中@Component代表这个类交给Spring进行管理,默认是单例模式,所以会存储再bean池中

我们为什么要把对象交给Spring管理?
1) Spring管理Bean对象可以实现对象对资源的使用
2) 通过IoC容器降低对象之间的耦合关系
一般池对象有什么特点？

1)在JVM内存会开辟一块相对比较大的空间。

使用空间换取时间(频繁的创建和销毁对象会占用大量资源,所以池化思想就是希望减少频繁创建对象所带来的开销)

2)在这块空间中存储一些对象(思考基于什么存储结构进行存储-数组，链表，散列表)。

Map + ArrayList

3)基于“享元模式”设计思想，实现内存中对象的可重用性。

 通过尽量共享实例来避免 new 出实例

@PreDestroy 注解描述的方法为生命周期销毁方法,此方法所在的对象,假如存储到了spring容器,那这个对象在从spring容器移除之前会先执行这个生命周期销毁方法(prototype作用域对象不执行此方法)
!! 没看到这句话的时候,我和几个同学激战了将近一个小时,(为什么多例不执行销毁方法,单例执行的销毁方法又是什么条件销毁的(池子没了?程序结束?))
最后结论就是因为程序结束了,要释放资源,所以容器没了,导致存在bean池中的对象执行销毁方法(单例)

天津中心 08 班

Idea工具中创建 SpringBoot工程及入门分析

SpringBoot 项目创建

创建Module

项目结构分析

SpringBoot 项目启动分析

启动入口

启动过程概要分析

SpringBoot 快速入门分析

业务描述

API设计分析

代码编写及运行

运行过程中的BUG分析

SpringBoot 项目中的对象特性分析

准备工作

延迟加载

对象作用域分析

对象生命周期方法

SpringBoot 项目中的依赖注入过程分析

准备工作

案例设计及分析

代码编写及测试分析

编写及测试过程中的BUG分析

总结(Summary)

springboot 最佳实践

你可能感兴趣的:(Idea工具中创建 SpringBoot工程及入门分析)