03-IDEA创建SpringBoot项目并进行入门分析

最新推荐文章于 2024-09-19 14:27:57 发布

暖暖0

最新推荐文章于 2024-09-19 14:27:57 发布

阅读量168

点赞数 1

分类专栏： Java

本文链接：https://blog.csdn.net/weixin_50554271/article/details/110478491

版权

Java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

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;

//spring框架是一个资源整合框架,是个用来快速解决spring工程的脚手架
/*在springboot工程中只能有一个类是启动类,这个类需要
    1) 使用@SpringBootApplication注解进行描述
    2)此类中会有一个main方法,在main方法中初始化springboot默认配置
   FAQ? 请问此类启动时会做什么?
    1)通过线程(Thread)调用IO从磁盘查找对应的类并将其读到内存(类加载)--Class Loading
    2)对读到内存中类进行分析,哪些是交给spring管理的,由spring管理的这些类哪些是配置类
    3)对spring管理的类,底层要进行解析,将这些类的信息封装到指定对象(Map<String,BeanDefinition(->配置信息)>)
    4)spring连框架可以基于Bean的配置,借助工厂构建对象,借助Map存储对象(实例-Bean对象),管理对象
    5)我们需要对象时,可以直接从spring容器(IOC)中去取
    Bean的作用域,Bean的延迟加载,Bean的生命周期
    ...*/

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        // main方法运行在什么线程(main线程-主线程)

        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;
import org.springframework.boot.test.context.SpringBootTest;

/**使用 @SpringBootTest 注解描述的类
    为springboot工程中的单元测试类*/
@SpringBootTest
public class DefaultCacheTests {
/**
 * @Autowired 注解描述的属性由spring框架按照一定规则为其注入值（赋值DI）
 * 赋值过程是怎样的？
 *  1)依赖查找？(请问查找规则是什么？)
 *  2)依赖注入？(需要借助什么技术?)
 */
@Autowired  //没有写@Autowired 输出的值就是null
private DefaultCache defaultCache;      //加入没有这样的bean会报NoSuchBeanDefinitionException
@Test
public void testDefaultCache(){
    System.out.println(defaultCache.toString());   //com.cy.pj.common.cache.DefaultCache@5ab9b447
    //FAQ? defaultCache变量引用的对象是由谁创建的，存储到了哪里？    bean pool
    /**
     当输出的defaultCache属性的值未null,可能原因是什么?
        1)属性赋值(自己没有赋值,也没有让spring赋值)
        2)属性在的类没有使用@SpringBootTest注解描述
        3)@Test类引入错误(
     */
}
}

第三步：运行单元测试类进行应用分析
启动运行单元测试方法，检测其输出结果，基于结果分析：
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.common.test;

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;

import javax.annotation.PostConstruct;

@SpringBootTest
public class ObjectPoolTests {

    @Autowired
    private ObjectPool objectPool01;

    @Autowired
    private ObjectPool objectPool02;

    @Test
    void testObjectPool(){
        /*  @Scope("singleton") 此注解用于设置bean对象的作用域,默认为singleton(单例),相同名字的bean实例在内存只能有一份*/
     //   System.out.println(objectPool01==objectPool02);     //true
        System.out.println("objectPool()");
        Integer a1=100; //自动封箱  Integer a41=Integer.
        Integer a2=100; //a1=a2  ?  true --> 从池中取(池中有从池中取,没有就new一个)
        Integer a3=100;
        Integer a4=100; //false
    }

    //生命周期方法演示:(并不是每个类中都要写这样的方法 --  一般在池对象的设计中都会有这样的方法)
    @PostConstruct
    /*  属于对象的生命周期初始化方法 ,此方法会在构造方法之后执行
        当类的设计是一个池对象的时候,就要写  */
    public void init(){
        System.out.println("init()");
    }

    @PostConstruct
    /*  属于对象的生命周期初始化方法 ,此方法会在对象销毁之前执行
        当类的设计是一个池对象的时候,就要写  */
    public void destroy(){  //spring负责创建,不负责销毁
        System.out.println("destroy()");
    }

}

延迟加载

现在思考一个问题,对于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作用域对象不执行此方法).

package com.cy.pj.common.pool;


import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
/**
    创建一个对象池类型,然后将此类型的对象交给spring管理
    @Component 注解描述的对象可以嫁给spring去管理,表示这个对象是一个一般组件
    系统底层会通过反射技术创建Bean实例,并未Bean起一个名字

    反射?
        是Java中一种高级特性,这组特性会借助一组API,获取运行时类及其的成员,并进行操作
    反射的最大优势?
        不能预知未来,但可以驾驭未来

    Java中应用反射技术的七点是什么?获取Class对象(字节码对象)
*/

@Component  //此注解描述的对象可以交给spring去管理,例如创建bean实例,给bean起一个默认名字等
@Scope("prototype")    //prototype 为多实例作用域,每次从spring框架请求类的实例都会创建新的 ,这个对象不会存到spring容器中,不会存入bean池中,因为应用次数少,随用随建
//@Scope("singleton")  //此注解用于设置bean对象的作用域,默认为singleton(单例),相同名字的bean实例在内存只能有一份 ,多于@lazy使用,存入bean池中(因为可以重用)
@Lazy   //描述对象类型时,表示延迟对象的创建,何时需要何时创建(即对象的延迟加载),尤其是一些大对象(即占用资源比较多的对象),短时间不会用到的,我们可以采用这样策略.
//@Component ("objPool")   描述bean的同时,给bean起名字
public class ObjectPool {   //默认bean对象的名字为类名,然后首字母小写,例如objectPool
    public ObjectPool(){
        System.out.println("ObjectPool()");
    }
}
//此类的配置在背加载到内存是,会将类的配置信息存储到Map<Spring,BeanDefinition>容器中
//早期创建类的实例:new ObjectPool()
//spring中为什么用反射创建对象,而不是直接new,对象类型的方式呢?

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	//默认bean的名字为softCache
public class SoftCache implements Cache{

}

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

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

}

PS: 定义 CacheService

package com.cy.pj.common.service;


import com.cy.pj.common.cache.Cache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service
public class CacheService {
    //1,  has a    --> 最常用的方式
    @Autowired
    @Qualifier("softCache")
    private Cache cache;
    //当类中有多个构造函数,但是构造函数又没有使用@Autowired注解描述,则优先调用无参构造函数
    //public CacheService(){}

    //2, 通过构造函数实现值得注入  --只能调用一次
  /*  @Autowired //可以描述构造方法 , @Autowired注解可以省略(只有这一个构造函数时,否则优先调用无参构造)
    *//*@Qualifier要写在构造方法中
        可以描述参数,属性,方法*//*
    public CacheService(@Qualifier("softCache") Cache cache){
        this.cache=cache;
    }*/

    //3, 通过set方法为属性赋值  -->可以反复调用
  /*  @Autowired
    public CacheService(@Qualifier("softCache") Cache cache){
        this.cache=cache;
    }
*/
    public Cache getCache(){
        return cache;
    }

}

第四步：定义CacheTests单元测试类，代码如下：

package com.cy.pj.common.cache;

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

@SpringBootTest
public class CacheTests {

    /** ?思考:当使用@Autowired注解描述属性时,spring底层按什么规则为属性赋值?(DI)
         规则如下:
            1)首先基于属性类型从spring容器中查询其对象,加入只有一个 则直接注入
            2)假如属性类型对应的对象有多个,则基于属性名进行查找,假如有名字相同的则直接注入,没有则注入失败
        ?假如我们希望为属性注入指定名字的bean对象,该如何实现
            借助 @Qualifier注解描述属性并指定要注入的bean的名字(这个注解必须配合@Autowired注解进行赋值使用)
        ?底层通过什么方式为属性赋值(DI)
            反射技术
        */
    @Autowired
    @Qualifier("softCache") //DL(Dependency lookup) --DI(Dependency Injection)
    private Cache cache;  //引入包下的类alt+enter

    @Test
    public void testCache(){
        System.out.println(cache);
    }
}

PS: 定义CacheServiceTests单元测试类

package com.cy.pj.common.service;

import com.cy.pj.common.cache.Cache;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class CacheServiceTests {

    @Autowired
    private CacheService cacheService;

    @Test
    public void testCacheService(){
        System.out.println(cacheService.getCache());
    }


}

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

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

编写及测试过程中的BUG分析
依赖注入异常，如图所示：
在这里插入图片描述

总结(Summary)

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