【JavaEE进阶之Spring】一分钟让你学会什么是Spring以及如何使用创建Spring
前言：
今天我们正式进入到JavaEE进阶的学习中了，在JavaEE进阶的学习中，我们最主要的就是学习Spring框架。那我们从今天就要逐渐从最基础的Spring开始，教会大家什么是Spring以及如何使用。
⭐个人主页：书生♡
gitee主页♂：奋斗的小白
博客领域：java编程,前端，算法，强训题目
写作风格：超前知识点，干货，思路讲解，面试题目
支持博主：点赞、收藏⭐、留言
目录
- 1.Spring框架
-
- 1.1 Spring是什么
- 1.2 Ioc容器
- 2. 理解Spring Ioc
- 3.理解DI
- 4.创建Spring
-
- 4.1 创建Maven项目
- 4.2.添加Spring框架的支持
- 4.3 添加启动项
- 5.存储Bean对象
-
- 5.1 创建Bean对象
- 5.2 将bean对象注入到Spring中
- 6.获取并使⽤ Bean 对象
-
- 6.1 获取 Spring 上下⽂对象
- 6.2 获取 Bean 对象
-
- 6.2.1 根据Bean名称（标识）来得到Bean对象
- 6.2.2 根据Bean类型，来得到Bean对象（容易出错）
- 6.2.3 根据Bean名称（标识）+类型 来得到Bean对象
- 6.3 使⽤ Bean 对象
- 7.存储和使用Bean的总结
- 8. 面试题之【ApplicationContext VS BeanFactory】
1.Spring框架
1.1 Spring是什么
我们要学习Spring，那么就要先知道什么是Spring？Spring什么用？
什么是Spring？
定义：我们通常说的Spring其实就是 Spring Framework，也就是Spring框架，可以让程序开发更加简单。
用一句话概括就是：Spring就是一个包含众多工具方法的Ioc容器。
1.2 Ioc容器
我们在知道Spring是Ioc容器，那么什么是Ioc容器？Ioc是什么？容器又是什么呢？
首先容器：就是一个用来存储某一个/一些物品的装置。
例如：我们之前数据结构学过的List/Map就是一个容器，在JavaEE初阶学过的Tomcat也是一个容器。
List / map —》是一个数据存储容器
Tomcat —》 是一个Web容器
既然Spring是Ioc容器 ，那么什么是Ioc呢？
IoC = Inversion of Control 翻译成中⽂是“控制反转”的意思，也就是说 Spring 是⼀个“控制反转”的容 器
Ioc是“控制反转”，那么他控制的是什么？反转的又是什么呢？
其实Ioc控制反转的是，对象的生命周期
原本：比如要在A中使用B，传统代码是在A中new B，B的生命周期是由程序员控制的
经过控制反转以后：从Spring拿B对象就行，因为这个时候B对象是由Spring管理的。对生命周期的托管
我们假如设计一个汽车的制造流程:
传统的就是汽车-》车身-》底盘-》轮胎，每一个都是有依赖的。
public static void main(String[] args) {
Car car = new Car(20);
car.run();
}
static class Car {
private Framework framework;
public Car(int size) {
framework = new Framework(size);
}
public void run() {
// 依赖⻋身
framework.init();
}
}
static class Framework {
private Bottom bottom;
public Framework(int size) {
bottom = new Bottom(size);
}
public void init() {
// 依赖底盘
bottom.init();
}
}
通过部分代码可以看出来，当我们在最底层修改代码的时候，整个代码链都需要进行修改。这样就很麻烦，那么我们怎么解决呢？并且这样的耦合读很高
现在我们是通过，在每一个类中，创建下一个类，因此我们修改一个其他的就都要修改了，那么我们可以将原来由⾃⼰创建的下级类，改为传递的⽅式（也就是注⼊的⽅式），这样的话我们就不需要修改很多了。
通过Ioc控制反转的具体的代码实现：
public class App {
public static void main(String[] args) {
Tire tire=new Tire(10,"red");
Bottom bottom=new Bottom(tire);
Framework framework=new Framework(bottom);
Car car=new Car(framework);
car.init();
}
}
public class Car {
private Framework framework;
public Car(Framework framework) {
this.framework = framework;
}
public void init()
{
System.out.println("执行Car！！！");
framework.init();
}
}
public class Framework {
private Bottom bottom;
public Framework(Bottom bottom) {
this.bottom = bottom;
}
public void init()
{
System.out.println("执行Framework！！！");
bottom.init();
}
}
public class Bottom {
private Tire tire;
public Bottom(Tire tire) {
this.tire = tire;
}
public void init()
{
System.out.println("执行Bottom！！！");
tire.init();
}
}
public class Tire {
private int size = 20;
private String color;
public Tire(int size, String color) {
this.size = size;
this.color = color;
}
public void init() {
System.out.println("轮胎——size：" + size +
" | color：" + color);
}
}
我们来看一下这两个的对比：
在传统的代码中对象创建顺序是：Car -> Framework -> Bottom -> Tire
改进之后解耦的代码的对象创建顺序是：Tire -> Bottom -> Framework -> Car
传统代码是 Car 控制并创建了Framework，依次往下，⽽改进之后的控制权发⽣的反转，不再是上级对象创建并控制下级对象了，⽽是下级对象注⼊到当前对象中，下级的控制权不再由上级类控制了，这样即使下级类发⽣任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IoC 的实现思想。
Ioc其实就是一个设计的思想，目的就是为了解耦
2. 理解Spring Ioc
我们知道Spring最核心的总结是：Spring是一个包含众多工具方法的Ioc容器。
既然 Spring是一个Ioc（控制反转）容器，那么他就有最基础的两个功能
● 将对象存储到容器中
● 将对象从容器中取出
这个就意味着：我们学习Spring最核心的功能就是学如何将对象存储到Spring，以及怎么讲对象从Spring中取出来。
普通程序：是通过new 对象得方式，想当于每一次使用的时候，才会实现，用完就丢掉了，下次用在实现
Ioc容器：是将对象放到Spring中，使用的时候，直接从容器中取出来就可以了，用完再放回到容器中。
Spring 是⼀个 IoC 容器，说的是对象的创建和销毁的权利都交给 Spring 来管理了，它本身⼜具备了存
储对象和获取对象的能⼒。
3.理解DI
在这里我们不得不提及，另一个根Ioc有关系的词，那就是DI，什么是DI呢?
DI 是 Dependency Injection 的缩写，翻译成中⽂是“依赖注⼊”的意思。
DI：所谓依赖注⼊，就是在程序运⾏期间，动态地将某种依赖关系注⼊到对象之中。（具体的技术）
广义上来讲：
DI和Ioc就是一个东西 是从不同的⻆度的描述的同⼀件事情，就是指通过引⼊ IoC容器，利⽤依赖关系注⼊的⽅式，实现对象之间的解耦
Ioc：是一种设计思想
DI：是一个具体的实现
4.创建Spring
我们在Servlet中就是创建一个Maven项目去实现的，在我们的Spring中也是一样的，也是通过Maven去实现的。
我们创建一个Spring分为三步：
1.创建一个普通的Maven项目
2.添加Spring框架的支持（spring-context、spring-beans）
3.添加启动类
有很多人不理解bean是什么？其实就是我们Java的对象，就叫做bean
那么我们就往下看每一个步骤是什么样子的。
4.1 创建Maven项目
这个就是我们创建好的Maven项目
4.2.添加Spring框架的支持
我们需要在 Maven的pom.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>
这段代码大家不要背，大家只需要知道需要添加这个，大家可以把这个代码保存在你的本地，等你需要的时候，直接拿来复制一个就可以了。
我们添加的依赖有：
spring-context：spring 上下⽂
spring-beans：管理对象的模块。
4.3 添加启动项
在左边的Java下，创建一个类就是我们启动项
到这里我们的Spring就创建成功了。
5.存储Bean对象
前面给大家说过，Bean其实就是Java对象，只不过我们在这里叫做Bean对象
存储Bean对象分为两个步骤：
1.创建一个Bean对象
2.将创建好的bean对象，注入到Spring中
5.1 创建Bean对象
既然Bean其实就是Java对象
那我们只需要创建一个类就可以了，这样一个bean对象就创建好了
public class User {
public String Hello()
{
return "hello Bean!!!";
}
}
5.2 将bean对象注入到Spring中
我们需要，在创建好的项⽬中添加 Spring 配置⽂件 spring-config.xml，将此⽂件放到 resources 的根⽬录下
在spring-config.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"
xmlns:content="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
</beans>
接下来，再将 User 对象注册到 Spring 中就可以
我们使用Bean标签来注入到Spring中，id这个名字我们可以随便起，但是class这个名字一定要是我们的包名+类名不可以改变。（没有包的话可以不写）
到这里我们存储Bean对象就好了
6.获取并使⽤ Bean 对象
我们既然已经将对象存入到容器中，那么就需要将对象从容器中取出来。
获取并使⽤ Bean 对象，分为以下 3 步：
- 获取 Spring 上下⽂对象
- 获取⼀个指定的 Bean 对象。
- 使⽤ Bean 对象。
什么是Spring上下文呢？
Spring上下文（ApplicationContext）是Spring Framework的核心部分之一，它是一个容器，用于管理应用程序中的所有bean对象。提供了一些基本的功能，如依赖注入（Dependency Injection）。
ApplicationContext可以加载多个配置文件，它会自动扫描所有配置文件中的bean，并将它们加入到容器中，以便在应用程序中使用。在Spring应用程序中，通常会创建一个或多个ApplicationContext对象，每个对象都代表着一个独立的应用程序上下文。
为什么要获取Spring上下文呢？
因为对象都交给 Spring 管理了，所以获取对象要从 Spring 中获取，那么就得先得到Spring 的上下⽂
6.1 获取 Spring 上下⽂对象
我们一般使用ApplicationContext来获取一个Spring上下文对象
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
public static void main(String[] args) {
//1.获取 Spring 上下⽂对象
ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
}
}
除了ApplicationContext，在以前还会使用BeanFactory，但是这个现在已经过时了
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
public class Test {
public static void main(String[] args) {
//1.获取 Spring 上下⽂对象
//ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("springconfig.xml"));
}
}
6.2 获取 Bean 对象
我们通过getBean来获取Bean
我们也有三种方法去获取Bean对象：
1.根据Bean名称（标识）来得到Bean对象
2.根据Bean类型，来得到Bean对象（容易出错）
3.根据Bean名称（标识）+类型 来得到Bean对象
6.2.1 根据Bean名称（标识）来得到Bean对象
这种需要进行强制转型
public class Test {
public static void main(String[] args) {
//1.获取 Spring 上下⽂对象
ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
//2.获取Bean对象
User user=(User) context.getBean("user");
}
}
6.2.2 根据Bean类型，来得到Bean对象（容易出错）
第二种方式就是通过 Bean类型来获取
public class Test {
public static void main(String[] args) {
//1.获取 Spring 上下⽂对象
ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
//2.获取Bean对象
User user= context.getBean(User.class);
}
}
但是这种方式，容易出错。当我们当有⼀个类型被重复注册到 spring-config.xml 中时，在使用这种方法获取就会出现问题。
因为是同一个类型的，不知道拿的是哪一个，就会出错。
6.2.3 根据Bean名称（标识）+类型 来得到Bean对象
最后一种方式，也是现在最常用的一个方式了，就是通过标识+类型去获取Bean对象
public class Test {
public static void main(String[] args) {
//1.获取 Spring 上下⽂对象
ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
//2.获取Bean对象
User user= context.getBean("user",User.class);
}
}
6.3 使⽤ Bean 对象
我们直接调⽤相应的⽅法就可以使用了
public class Test {
public static void main(String[] args) {
//1.获取 Spring 上下⽂对象
ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
//2.获取Bean对象
User user= context.getBean("user",User.class);
//3.使用Bean对象
System.out.println(user.Hello());
}
}
7.存储和使用Bean的总结
一.创建Maven项目
1.创建一个普通的Maven项目
2.添加Spring框架的支持（spring-context、spring-beans）
3.添加启动类
二. 存对象
1.创建一个Bean对象
2.将创建好的bean对象，注入到Spring中
三. 取对象
- 得到 Spring 上下⽂，并读取到 Spring 的配置⽂件。
- 获取某⼀个 Bean 对象。
- 使⽤ Bean 对象。
8. 面试题之【ApplicationContext VS BeanFactory】
ApplicationContext 和BeanFactory的功能是一样的，但是ApplicationContext 是 BeanFactory的子类。
相同点：
1.都可以得到Spring的上下文对象
2.都是Spring的顶级接口
不同点：
1.ApplicationContext 是 BeanFactory的子类，其中 BeanFactory 提供了基础的访问容器的能⼒，⽽ ApplicationContext属于 BeanFactory 的⼦类，它除了继承了 BeanFactory 的所有功能之外，它还拥有独特的特性，还添加了对国际化⽀持、资源访问⽀持等⽅⾯。
2.ApplicationContext 是⼀次性加载并初始化所有的 Bean 对象，所以以后访问的时候就会很快，BeanFactory 是需要那个才去加载Bean对象，比较慢，因此ApplicationContext 更加轻量