H5W3
当前位置:H5W3 > java > 正文

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

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

亮亮发布于 今天 12:38

SpringBoot 项目创建

创建Module

基于IDEA创建项目Module,模块名为04-springboot-start,组id和包名为com.cy,如图所示:
【Java】Idea工具中创建 SpringBoot工程及入门分析
填写module信息,如图所示:
【Java】Idea工具中创建 SpringBoot工程及入门分析
选择项目module版本,暂时不需要自己手动添加任何依赖,如图所示:
【Java】Idea工具中创建 SpringBoot工程及入门分析
填写Module名称,完成module创建,如图所示
【Java】Idea工具中创建 SpringBoot工程及入门分析

项目结构分析

项目Module创建好以后,其代码结构分析,如图所示:

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

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工程启动时其简易初始化过程,如图所示:

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

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

SpringBoot 快速入门分析

业务描述

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

API设计分析

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

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

代码编写及运行

基于业务及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类型找不到,如图所示:

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

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

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

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

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

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

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

  • NoSuchBeanDefinition异常,如图所示:

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

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

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

SpringBoot 项目中的对象特性分析

准备工作

第一步:创建项目Module,例如名字为05-springboot-features,如图所示:
【Java】Idea工具中创建 SpringBoot工程及入门分析

第二步:添加业务类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,如图所示:
【Java】Idea工具中创建 SpringBoot工程及入门分析
第二步:启动运行项目,检测是否能成功启动

案例设计及分析

为了更好理解spring框架的底层注入机制,现在进行案例API设计,如图所示:

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

在这个案例中单元测试类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分析

  • 依赖注入异常,如图所示:

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

总结(Summary)

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

springboot

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

举报

赞222收藏69

分享

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


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

[

springboot 最佳实践

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

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

已关注

19 条评论

得票时间

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

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

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

Mario_redamancy

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

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

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

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

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

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

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

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

Map + ArrayList

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

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

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

天津中心 08 班

javaspringideaspringboot
阅读 39发布于 今天 12:38
本作品系原创,采用《署名-非商业性使用-禁止演绎 4.0 国际》许可协议
avatar

亮亮
1 声望
1 粉丝

0 条评论
得票时间

avatar

亮亮
1 声望
1 粉丝

宣传栏

SpringBoot 项目创建

创建Module

基于IDEA创建项目Module,模块名为04-springboot-start,组id和包名为com.cy,如图所示:
【Java】Idea工具中创建 SpringBoot工程及入门分析
填写module信息,如图所示:
【Java】Idea工具中创建 SpringBoot工程及入门分析
选择项目module版本,暂时不需要自己手动添加任何依赖,如图所示:
【Java】Idea工具中创建 SpringBoot工程及入门分析
填写Module名称,完成module创建,如图所示
【Java】Idea工具中创建 SpringBoot工程及入门分析

项目结构分析

项目Module创建好以后,其代码结构分析,如图所示:

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

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工程启动时其简易初始化过程,如图所示:

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

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

SpringBoot 快速入门分析

业务描述

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

API设计分析

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

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

代码编写及运行

基于业务及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类型找不到,如图所示:

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

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

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

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

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

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

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

  • NoSuchBeanDefinition异常,如图所示:

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

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

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

SpringBoot 项目中的对象特性分析

准备工作

第一步:创建项目Module,例如名字为05-springboot-features,如图所示:
【Java】Idea工具中创建 SpringBoot工程及入门分析

第二步:添加业务类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,如图所示:
【Java】Idea工具中创建 SpringBoot工程及入门分析
第二步:启动运行项目,检测是否能成功启动

案例设计及分析

为了更好理解spring框架的底层注入机制,现在进行案例API设计,如图所示:

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

在这个案例中单元测试类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分析

  • 依赖注入异常,如图所示:

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

总结(Summary)

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

springboot

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

举报

赞222收藏69

分享

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


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

[

springboot 最佳实践

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

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

已关注

19 条评论

得票时间

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

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

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

Mario_redamancy

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

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

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

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

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

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

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

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

Map + ArrayList

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

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

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

天津中心 08 班

本文地址:H5W3 » 【Java】Idea工具中创建 SpringBoot工程及入门分析

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址