Spring的开发要点总结

文章目录

【JavaEE】Spring的开发要点总结（1）

[1. DI 和 DL](#1. DI 和 DL)

[1.1 DI 依赖注入](#1.1 DI 依赖注入)

[1.2 DL 依赖查询](#1.2 DL 依赖查询)

[1.3 DI 与 DL的区别](#1.3 DI 与 DL的区别)

[1.4 IoC 与 DI/DL 的区别](#1.4 IoC 与 DI/DL 的区别)

[2. Spring项目的创建](#2. Spring项目的创建)

[2.1 创建Maven项目](#2.1 创建Maven项目)

[2.2 设置国内源](#2.2 设置国内源)

[2.2.1 勾选](#2.2.1 勾选)

[2.2.2 删除本地jar包](#2.2.2 删除本地jar包)

[2.2.3 reload](#2.2.3 reload)

[2.3 添加依赖](#2.3 添加依赖)

[2.4 创建启动类](#2.4 创建启动类)

[3. 将Bean对象存储到Spring(IoC容器)中](#3. 将Bean对象存储到Spring(IoC容器)中)

[3.1 创建一个Bean对象](#3.1 创建一个Bean对象)

[3.2 将Bean对象存储到Spring中](#3.2 将Bean对象存储到Spring中)

[3.2.1 配置文件](#3.2.1 配置文件)

[3.2.2 包含一个bean标签](#3.2.2 包含一个bean标签)

[3.3 获取Bean对象并使用](#3.3 获取Bean对象并使用)

[3.3.1 获取Spring的上下文对象](#3.3.1 获取Spring的上下文对象)

[3.3.2 通过Spring的上下文对象，获取一个指定的Bean对象](#3.3.2 通过Spring的上下文对象，获取一个指定的Bean对象)

[3.3.3 使用Bean对象](#3.3.3 使用Bean对象)

[3.3.4 验证懒加载-两种获取Bean对象的方法的区别](#3.3.4 验证懒加载-两种获取Bean对象的方法的区别)

【JavaEE】Spring的开发要点总结（1）

Spring的初步了解博客：【JavaEE】JavaEE进阶：框架的学习 - Spring的初步认识_s:103的博客-CSDN博客

就不带大家回顾了~

从框架获取的对象称为获取【Bean对象】！

Java是咖啡，Bean就是"咖啡豆"，也就是"对象"

Spring项目开发就是开业，放咖啡豆到罐子里 ，后续从罐子里拿咖啡豆 ，结合豆子用咖啡机做咖啡 ，咖啡给用户喝，的过程~

1. DI 和 DL

1.1 DI 依赖注入

在Spring项目中，DI通常指的是Dependency Injection（依赖注入）。Spring框架是一个使用DI作为核心思想的开源框架，它通过依赖注入的方式管理和注入对象之间的依赖关系。

指的是，在程序运行期间动态地将"依赖对象"获取到的过程

以Framework构造方法为例，需要一个依赖对象"bottom"，那么就在运行的时候，动态地在框架内部去查询到对应地Bean对象，然后赋值给bottom

这就是依赖的注入~

后面真正进入Spring代码的学习的时候，会有更好的理解！

1.2 DL 依赖查询

在Spring项目中，DL通常指的是Dependency Lookup（依赖查找）。Dependency Lookup 是一种在运行时通过容器来查找和获取依赖对象的方式。

DL与DI不同的最大一点就是，DL显式的去从框架内部获取Bean对象，然后自己去赋值给对应的对象：

后面真正进入Spring代码的学习的时候，会有更好的理解！

1.3 DI 与 DL的区别

静态与动态 ：

DI 是在对象创建时将依赖注入到对象中

而DL 是在运行时通过容器查找和获取依赖对象。

控制权 ：

DI 将控制权交给容器，在对象创建时由容器负责注入依赖对象

而 DL 则由代码显式调用容器的方法来获取依赖对象，控制权更多地在代码手中。

依赖关系的表达 ：

DI 的依赖关系通过构造函数、Setter方法或注解等方式在类的定义中表达

而 DL 则需要在代码中显式地调用容器的方法来获取依赖对象。

灵活性 ：

DI 可以更方便地进行单元测试和模拟依赖对象，因为依赖对象可以通过构造函数或 Setter 方法注入

而 DL 则需要运行时访问容器，不太适合在测试环境中进行模拟。

松耦合与紧耦合 ：

DI 通过将依赖对象注入到类中实现了松耦合，对象不需要关心如何获取依赖

而 DL 则需要显式地调用容器方法来获取依赖，导致对象与容器之间紧密耦合。

后面真正进入Spring代码的学习的时候，会有更好的理解！

1.4 IoC 与 DI/DL 的区别

IoC是"目标"的一种思想，而IoC就是只是"指导原则"，"Spring的基本思想"

DI/DL则是"落实的方案"，就属于"Spring特点的具体实现"

IoC是控制权的反转，"向框架要对象"，那么Bean对象是怎么给我们的，就是DI/DL

接下来就要创建Spring项目了，（配置国内源哦，在上一篇文章中有提到~）

2. Spring项目的创建

2.1 创建Maven项目

Spring项目的基础就是Maven项目：

然后输入创建目录，确认：

2.2 设置国内源

2.2.1 勾选

以后的设置一并改了

2.2.2 删除本地jar包

之前留下的jar包很有可能，是你没有设置国内源，导致一些jar包不完整，导致后续无法重新向中央仓库下载这些jar包~

delete删除即可：

2.2.3 reload

耐心等待~

这个时间就差不多~

2.3 添加依赖

xml 复制代码

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.3.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.2.3.RELEASE</version>
    </dependency>
</dependencies>

建议把这些常用的依赖放在git上的代码片段上，方便获取

这里版本号后面是release也没问题~
因为国内源里确实存在~

添加的框架有 spring-context：spring 上下文，还有 spring-beans：管理对象的模块

2.4 创建启动类

项目的运行的就是main方法~

很多知识要到后面才能理解哦，一步步来！

3. 将Bean对象存储到Spring(IoC容器)中

3.1 创建一个Bean对象

一个Bean对象，无非就是java中的一个普通的类的一个实例罢了~

3.2 将Bean对象存储到Spring中

3.2.1 配置文件

这个时候就需要一个配置文件：

xml 复制代码

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

直接复制过去即可

resources就是放一些配置文件的~
取名规则：写实，直观，表达文件内容含义

爆红的话，reload一下~

3.2.2 包含一个bean标签

id
- 将对象存储到IoC容器中的名字

class
- 要存储到IoC中的Bean的完整路径

创建一个包

把UserService拖进去

默认是不分组的，去掉这个√，就分组了

而bean标签的class属性，就是类的路径~

包名.类名

两个对象~

这一步虽然看似我们将这个类的对象放进Spring中，但是只起到"声明"的作用~

因为IoC容器加载对象，如果是懒汉模式，即是非必要不加载，所以这一步就是声明，对象在容器中的"名字"和"位置"

所以代码在运行的过程中加载才会通过这个配置文件，将Bean放进容器中~

3.3 获取Bean对象并使用

获取和使用都在启动类的main方法中~

3.3.1 获取Spring的上下文对象

没有题词很正常，打出来就行了，然后导包

法1：ApplicationContext

用单词全称的好处就是，打错字会有提醒~

法2：BeanFactory

两种方式都能获取，区别在后面讲解~

上下文对象：

上下文（Context）在一般语境下指的是某个事件、问题或情况发生的背景和环境。它是指在特定的时间、地点或条件下所处的整体情况、状态或背景。
上下文对象是指在特定环境中包含了相关信息和状态的对象。它提供了在该环境中执行操作所需的上下文信息。

在这里的话，就是蕴含了容器存储的Bean对象的信息~

不好理解上下文对象，那你就理解成，IoC容器管理器~

3.3.2 通过Spring的上下文对象，获取一个指定的Bean对象

这里填的就是Bean对象的名字，也就是在配置文件中的id~

但是这个方法返回的结果是Object类型，需要强制类型转化：

或者，用类对象作为参数：

返回这个类的一个Bean对象

但是运行时错误：

字面意思就是，不唯一Bean定义异常

确实如此，有两个UserService的Bean对象

最好的一种方法就是，传两个参数，一个id，一个类对象：

3.3.3 使用Bean对象

java 复制代码

public static void main(String[] args) {
    //1. 得到Spring的上下文对象
    ApplicationContext applicationContext =
        new ClassPathXmlApplicationContext("spring-config.xml");
    //2. 得到Bean
//  UserService userService = (UserService) applicationContext.getBean("user");
    UserService userService = applicationContext.getBean("user", UserService.class);

    //3. 使用Bean
    userService.sayHi();
}

3.3.4 验证懒加载-两种获取Bean对象的方法的区别

我们在UserService的构造方法上添上一笔

注释一些代码：

运行：

对于ApplicationContext，是一种全加载的方式

对于BeanFactory，则是一种懒加载的方式

所以我们在回答问题的时候要这样：

相同点：都是容器的管理对象，都能获取Bean对象

区别：

ApplicationContext是BeanFactory的一个子类（子孙之一）

因此，ApplicationContext拥有更多的功能

国际化支持

资源访问支持

事件传播支持

...

加载机制不同

BeanFactory，比较老，在之前资源匮乏，所以要珍惜资源，所以懒加载可以节省资源

启动快，后期的获取慢

ApplicationContext，则是现在资源不成问题，配置文件全部一起加载也无妨~

启动慢，后期的获取快

而以上IoC机制的实现，就是DL，依赖查找的方式，就是通过给定的配置文件，在配置文件中的beans里查找Bean对象的声明，找到对象并返回~

文章到此结束！谢谢观看

可以叫我小马，我可能写的不好或者有错误，但是一起加油鸭🦆！

本文代码链接：SpringDemo1 · 游离态/马拉圈2023年7月 - 码云 - 开源中国 (gitee.com)

可见，这样子做，获得一个对象太麻烦了，下一篇文章教你简单的存储和获取Bean对象，并且结合DI~