01-SpringBoot技术快速入门_设置工作区springboot

SpringBoot 简介

背景分析

在传统JAVAEE应用体系中创建一个项目,需要手动添加大量的依赖,还要考虑版本的兼容性,还有繁重的配置、负载的项目部署,会高度影响开发效率,即使是使用Spring进行资源整合,也存在同样的这些问题。还有就是现在的软件生态应用也已经形成一定的规模,整个软件架构体系在变化，企业对技术的要求也在变化，现在的企业更注重技术的开箱即用，更注重技术在生态圈中的深度融合，更注重轻量级的运维。由此由此spring boot诞生。

解决什么问题

Spring Boot是一个全新的Java软件开发框架（很多人现在把它理解为一个脚手架），其设计目的是用来简化Spring项目的初始搭建以及开发过程,并为后面的Spring Cloud 微服务实践提供更加便利条件。该框架使用了特定的注解方式来进行配置，从而使开发人员不再需要大量的xml配置。不再需要大量的手动依赖管理。Spring Boot基于快速构建理念，通过约定大于配置，开箱即用的方式，希望能够在蓬勃发展的快速应用开发领域成为其领导者。

有哪些核心特性

SpringBoot 框架诞生后，之所以能得到软件开发行业的高度认可，自然离不开它提供给我们的一些关键特性，例如：

• 起步依赖(Starter Dependency)-创建项目时，会默认添加基础依赖，简化我们自己查找依赖的过程。
• 自动配置(Auto Configuration)-创建项目时，springboot工程添加的默认依赖中提供了很多默认的配置，简化了我们对资源的配置过程。
• 健康检查(Actator)-监控-springboot工程运行时，我们可以打开actuator特性，基于此特性监控spring中的bean，连接池，jvm内存等
• 嵌入式服务(Tomcat,Jetty)-springboot工程支持内嵌的web服务，可以将tomcat或jetty这样的服务直接嵌套到web依赖中，简化部署过程

SpringBoot 项目创建及运行

准备工作

第一步：在磁盘指定目录中(不要有中文)创建一个文件夹（作为我们的一个工作区），例如javastack.
第二步：使用idea打开 (file/open)你的javastack目录(也可以将这个目录理解为空项目)。
第三步：配置maven环境，编码方式等。

第四步：确定工程结构(可以练习一下项目的创建)，例如：

javastack   
├── 01-java      //这里写java练习        
├── 02-spring
│       └── spr-boot
│          └── spr-ioc // 这里讲ioc的知识
│          └── spr-aop //这里讲aop的知识
│          └── spr-mvc //这里学mvc相关的知识    
│       └── spr-cloud //这里可以写微服务相关    
│── └── pom.xml
1
2
3
4
5
6
7
8
9

项目pom文件初始化

第一步： 修改spr-boot项目下pom.xml文件内容，例如：

 <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>02-spring</artifactId>
        <groupId>com.cy</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <modelVersion>4.0.0</modelVersion>

    <artifactId>spr-boot</artifactId>
    <packaging>pom</packaging>

    <modules>
        <module>spr-ioc</module>
        <module>spr-aop</module>
        <module>spr-mvc</module>
    </modules>
    <!--基于dependencyManagement元素，定义一些公共依赖的版本,注意只定义依赖版本-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.3.2.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!--定义当前工程以及子工程所需要的一些依赖-->
    <dependencies>
        <!--junit单元测试依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope><!--test表示当前的单元测试只能放在test目录-->
            <exclusions><!--exclusions用于排除一些不需要的依赖-->
                <exclusion><!--这里排除的junit4这个版本的测试引擎-->
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <!--配置一下当前项目的插件-->
    <build>
        <plugins>
            <!--定义当前工程的统一编译环境-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

第二步：修改spr-ioc的配置文件，例如：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>spr-boot</artifactId>
        <groupId>com.spring</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spr-ioc</artifactId>
  
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
    </dependencies>

</project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

创建项目启动类

打开spr-ioc项目然后，添加启动类，例如：

package com.spring;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class BootIOCApplication {//Application.class
  public static void main(String[] args) {//Main Thread
    SpringApplication.run(BootIOCApplication.class, args);
  }
}
1
2
3
4
5
6
7
8
9

启动并运行项目

找到SpringBoot 工程中由@SpringBootApplication注解描述的类为然后启动运行，其启动过程如下：

在启动过程中底层做了哪些事情，大致描述如下：
第一：基于配置加载类(通过ClassLoader将指定位置的类通过线程调用IO从磁盘读取到内存)。
第二：对类进行分析(创建字节码对象-Class类型,通过反射获取器配置信息)。
第三：对于指定配置(例如由spring特定注解描述)的对象存储其配置信息(借助BeanDefinition对象存储)。
第四：基于BeanDefinition对象中class的配置构建类的实例(Bean对象),并进行bean对象的管理(可能会存储到bean池)。

SpringBoot 快速入门实践

业务描述

在项目spr-ioc的项目中定义一个类，类名为DefaultCache，然后将此类对象交给Spring创建并管理。最后通过单元测试对类的实例进行分析。

API设计分析

基于业务描述，进行API及关系设计，如图所示：

在这张图中描述了一个DefaultCache和DefaultCacheTests单元测试类，这个两个类都交给了spring管理，并且DefaultCacheTests类依赖于DefaultCache类型，由spring框架基于@Autowired对属性描述，进行执行的注入(将DefaultCache类型对象，注入给DefaultCache类型）。

Bean对象定义及获取

在Spring框架规范中，所有由spring管理的对象都称之为Bean对象，我们现在基于如上业务及API设计图，进行Bean类型代码的编写及测试，其过程如下：

第一步：定义DefaultCache类，并交给spring管理。

package com.cy.pj.common.cache;
import org.springframework.stereotype.Component;
/**
 * @Component 注解描述的类，表示此类交给Spring框架管理。
 */
@Component
public class DefaultCache {

}
1
2
3
4
5
6
7
8
9

第二步：定义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
2
3
4
5
6
7
8
9
10
11
12
13
14
15

第三步：运行单元测试类进行应用分析

启动运行单元测试方法，检测其输出结果，基于结果分析：
1)SpringBoot项目中Bean对象的构建（例如DefaultCache类型的对象是如何构建、何时构建的）。
2)SpringBoot项目中Bean对象的获取（例如DefaultCacheTests类中是符合获取DefaultCache类型对象的，基于IOC。）

说明：这个案例中描述了Spring IOC设计思想，项目中将对象交给Spring管理（我们饭来张口，衣来伸手，Spring框架实现对象控制），由spring完成对象的依赖查找(DL)和依赖注入(DI)的过程（这个种设计最重要的是让初学者规避对象管理的风险，对象由专业人士进行控制）。

测试过程中的BUG分析

• 测试过程中Bean类型找不到，如图所示：
  

• 空指针异常(NullPointerExcetpion-NPE),如图所示：
  

• 运行单元测试类，启动类找不到,如图所示:
  

• 运行单元测试类，启动类有多个,如图所示:
  

• 运行单元测试，提示NoSuchBeanDefinition异常,如图所示:

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

@Import注解应用

应用说明：
此注解一般用于将某个类引入到启动类或者是启动类所在包或子包的配置上类，用于将这个类做为spring管理的一个对象，经常应用于第三方框架资源的导入(第三资源不是我们写的，可能不在我们启动类的包体系下)。

案例演示：

第一步：定义一个类（这个类没在启动类所在包或子包中），例如：

package com.example;

public class LogCache {
    public LogCache(){
        System.out.println("LogCache()");
    }
}
1
2
3
4
5
6
7

第二步：在项目启动类上添加@Import(LogCache.class)注解。
第三步：创建单元测试类，检测是否可以拿到LogCache对象。

package com.spring.cache;

import com.example.LogCache;
import com.example.SimpleCache;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Import;

@SpringBootTest
public class LogCacheTests {
    @Autowired
    private LogCache logCache;

    @Test
    void testLogCache(){
        System.out.println(logCache);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

@Configuration&@Bean注解应用

问题描述：假如现在有一个类，但是这个类没在启动类所在包或子包中，我们如何将这个类的对象交给spring管理？
解决方案：可以在启动类所在包或子包中定义一个配置类(@Configuration注解描述配置类)，然后在配置类中定义方法，在方法内部构建对象并返回，而且这个方法要使用@Bean注解描述。
案例演示：
第一步：定义一个SimpleCache对象(不再启动类所在的包体系中)，例如

package com.example;

import org.springframework.stereotype.Component;


public class SimpleCache {
    public SimpleCache(){
        System.out.println("SimpleCache()");
    }
}
1
2
3
4
5
6
7
8
9
10

第二步：定义个配置类(这个配置类要写在启动类所在包或子包中)，例如：

package com.spring.config;

import com.example.SimpleCache;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

/**
 * @Configuration 注解描述类，
 * 表示是spring中的一个配置类。
 */
@Configuration
public class CacheConfig {//注意这个类的位置，以及类上的注解
    /**
     * @Bean 注解描述的方法一般会写在@Configuration注解描述的类中，
     * 用于自己创建对象，并把对象交给spring管理，spring会默认为
     * 这个bean起个名字(默认是方法名)，
     * @return
     */
     @Bean//没有为bean起名字，默认为方法名
    //@Bean("myCache")//这里是自定义bean的名字
    public SimpleCache simpleCache(){
         System.out.println("CacheConfig.simpleCache()");
         return new SimpleCache();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

第三步：编写单元测试类(测试类也要写到test目录中与启动类包体系相同的包中)，检测是否可以拿到SimpleCache对象

package com.spring.cache;

import com.example.SimpleCache;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class SimpleCacheTests {
    @Autowired
    private SimpleCache simpleCache;

    @Test
    void testSimpleCache(){
        System.out.println(simpleCache);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

思考：@Configuration&@Component注解有什么不同？
第一：@Configuration是一个特殊的@Component注解。
第二：@Configuration注解一般用于描述配置类（例如ConfigConfig对象），@Component用于描述一般组件（例如一个Cache对象）。
第三：@Configuration注解描述的配置中，假如使用@Bean注解描述了方法，无论此方法被调用多少次，这个方法只执行一次。
第四：假如实用@Component注解描述配置类，@Bean注解描述的方法，每次被调用，都会执行。

SpringBoot中Bean对象特性分析

Bean对象设计

第一步：添加业务类ObjectPool,代码如下：

package com.cy.pj.common.pool;
@Component
public class ObjectPool{//假设此对象为一个对象池
    public ObjectPool(){//假设运行项目启动类，此构造方法执行了，说明此类对象构建了。
      Systemd.out.println("ObjectPool()")
    }
}
1
2
3
4
5
6
7

第二步:定义单元测试,代码如下:

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
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Bean对象延迟加载

现在思考一个问题,对于ObjectPool这个类，假如项目启动以后，暂时不会用到这个池对象，是否有必要对其进行创建(默认是会创建的)？我们知道没必要，因为占用内存。那如何在启动时不创建此类对象呢？借助Spring框架提供的延迟加载特性进行实现。例如，我们可以在需要延迟加载的类上使用@Lazy注解进行描述，代码如下：

package com.cy.pj.common.pool;
@Lazy
@Component
public class ObjectPool{//假设此对象为一个对象池
    public ObjectPool(){//假设运行项目启动类，此构造方法执行了，说明此类对象构建了。
      Systemd.out.println("ObjectPool()")
    }
}
1
2
3
4
5
6
7
8

此时，我们再去运行运行启动类，检测ObjectPool对象是否创建了，假如没有创建，说明延迟加载生效了。此时，我们总结一下，什么对象适合使用延迟加载特性呢？大对象，稀少用(项目启动以后，暂时用不到)的对象。
注意：延迟加载并不是延迟对类进行加载，而是在启动时，暂时不创建类的实例。假如想看一下内存中的类是否被加载了，可以通过JVM参数进行检测，参数为-XX:+TraceClassLoading。

Bean对象作用域分析

在实际的项目中内存中的对象有一些可能要反复应用很多次，有一些可能用完以后再也不用了或者说应用次数很少了。对于经常要重复使用的对象我可考虑存储到池中(例如交给spring框架进行管理)，应用次数很少的对象那就没必要放到池中了，用完以后让它自己销毁就可以了。在Spring项目工程中为了对这样的对象进行设计和管理，提供了作用域特性的支持，具体应用：

package com.cy.pj.common.pool;
@Scope("singleton")
@Lazy
@Component
public class ObjectPool{//假设此对象为一个对象池
    public ObjectPool(){//假设运行项目启动类，此构造方法执行了，说明此类对象构建了。
      Systemd.out.println("ObjectPool()")
    }
}
1
2
3
4
5
6
7
8
9

其中，在上面的代码中，我们使用了@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作用域
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

对象生命周期方法

程序中的每个对象都有生命周期，对象创建，初始化，应用，销毁的这个过程称之为对象的生命周期。在对象创建以后要初始化，应用完成以后要销毁时执行的一些方法，我们可以称之为生命周期方法。但不见得每个对象都会定义生命周期方法。在实际项目中往往一些池对象通常会定义这样的一些生命周期方法(例如连接池)。那这样的方法在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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

其中:
1)@PostConstruct 注解描述的方法为生命周期初始化方法,在对象构建以后执行.
2)@PreDestroy 注解描述的方法为生命周期销毁方法,此方法所在的对象,假如存储到了spring容器,那这个对象在从spring容器移除之前会先执行这个生命周期销毁方法(prototype作用域对象不执行此方法).

SpringBoot 工程依赖注入分析

案例设计

为了更好理解sping框架的底层注入机制，现在进行案例API设计，理解API的依赖注入过程，如图所示：

在这个案例中单元测试类CacheTests中定义一个Cache接口类型的属性，然后由Spring框架完成对cache类型属性值的注入。

代码编写及测试分析

第一步：定义Cache接口，代码如下：

package com.cy.pj.common.cache;
public interface Cache {
 
}
1
2
3
4

第二步：定义Cache接口实现类SoftCache，代码如下：

package com.cy.pj.common.cache;
 
@Component
public class SoftCache implements Cache{

}
1
2
3
4
5
6

第三步：定义Cache接口实现类WeakCache，代码如下：

package com.cy.pj.common.cache;
 
@Component
public class WeakCache implements Cache{

}
1
2
3
4
5
6

第四步：定义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);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

其中，@Autowired由spring框架定义，用于描述类中属性或相关方法(例如构造方法)。Spring框架在项目运行时假如发现由他管理的Bean对象中有使用@Autowired注解描述的属性或方法，可以按照指定规则为属性赋值(DI)。其基本规则是：首先要检测容器中是否有与属性或方法参数类型相匹配的对象，假如有并且只有一个则直接注入。其次，假如检测到有多个，还会按照@Autowired描述的属性或方法参数名查找是否有名字匹配的对象，有则直接注入，没有则抛出异常。最后，假如我们有明确要求，必须要注入类型为指定类型，名字为指定名字的对象还可以使用@Qualifier注解对其属性或参数进行描述(此注解必须配合@Autowired注解使用)。

第五步：运行CacheTests检测输出结果，基于结果理解其注入规则。

测试过程中的BUG分析

• 依赖注入异常，如图所示：

总结(Summary)

本小节为springboot技术入门章节，主要讲述了SpringBoot工程下，spring中bean对象的编写，特性以及依赖注入的规则，希望通过这一小节的讲解，同学们能够理解我们为什么要将对象交给spring管理，spring管理对象有什么优势，我们在springboot工程中应该如何配置这些对象。