03-基于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对象的管理。

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

延迟加载

如今思考一个问题,对于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工程中应该如何配置这些对象。