【Spring】之基础概念和使用

🏀🏀🏀来都来了，不妨点个关注！
🎧🎧🎧博客主页：欢迎各位大佬!

文章目录

1. Spring的概述
- 1.1 什么是容器？
- 1.2 什么是IoC？
- 1.3 什么是DI？
- 1.4 理解Spring IoC
2. Spring的创建和使用
- 2.1 前置准备
- 2.2 存储Bean对象
- - 2.2.1创建Bean对象
  - 2.2.2 将Bean注入到Spring
- 2.3 获取并使用Bean对象
- - 2.3.1 创建一个Spring上下文对象
  - - 2.3.1.1 ApplicationContext和BeanFactory有什么区别
  - 2.3.2 获取Bean对象
  - 2.3.3 使用Bean对象

1. Spring的概述

我们常说的Spring是指Spring Framework(Spring 框架)，它是一个开源的框架，它有着广泛的应用场景，它可以让Java企业级开发更加简单。
用一句话总结就是：Spring是一个包含了众多工具方法的IoC容器。

1.1 什么是容器？

通俗来说，容器就是用来存放东西的，就比如我们的杯子平常就是用来装水的，这里的杯子就是一个容器。回想我们之前学过哪些容器呢？

List/Map ->数据存储容器
Tomcat ->Web容器

而我们说的Spring则是对象存储的容器，它里面则是存储的对象。

1.2 什么是IoC？

上面，我们提到Spring是一个IoC容器，这里的IoC是指Inversion Of Control，翻译过来就是 “控制反转” 的意思。也就是说Spring是一个“控制反转”的容器，那这里的控制是指的对谁的控制呢？
正如我们上面提到过Spring是存储对象的容器，其“控制反转”指的就是对对象的控制权的反转。
即对象的生命周期，不由程序员（或当前代码片段）控制，而是由Spring（Spring容器/IoC容器）控制——控制反转

1.3 什么是DI？

提到IOC我们就不得不提到DI（Denpendcy Injection）——依赖注入。
依赖注⼊，就是由 IoC 容器在运⾏期间，动态地将某种依赖关系注⼊到对象之中。依赖注⼊（DI）和控制反转（IoC）是从不同的⻆度的描述的同⼀件事情，就是指通过引⼊ IoC 容器，利⽤依赖关系注⼊的⽅式，实现对象之间的解耦。
IOC是一种设计思想，而DI是一种具体的实现方式。
就比如今天小丁学习很累，想去吃顿好的犒劳下自己，那吃顿好的这个想法这就是设计思想，而具体是去吃烤肉还是火锅这个行为则是具体的实现方式。

1.4 理解Spring IoC

在文章最开始我们就说了：Spring是一个IoC容器。那么如何理解这句话呢？
既然Spring是一个IoC（控制反转）容器，那么重点还在“容器”上，是一个容器就应该具体以下特点：

将对象存储到容器中
把对象从容器中取出来
这也就是说，学Spring的核心功能就包括了，学如何将对象存入到Spring中，再从Spring中取出对象的过程。

将对象存放到容器中的好处：将对象存储在 IoC 容器相当于将以后可能⽤的所有⼯具制作好都放到仓库中，需要的时候直接取就⾏了，⽤完再把它放回到仓库。⽽ new 对象的⽅式相当于，每次需要⼯具了，才现做，⽤完就扔掉了也不会保存，下次再⽤的时候还得重新做，这就是 IoC 容器和普通程序开发的区别。

2. Spring的创建和使用

通过上述的说明，我们知道学习Spring就是要学如何将对象存入到Spring中，再从Spring中取出对象的过程，那么接下来我们就来创建一个Spring项目进行对象的存入和取出操作。Spring项目的创建分为以下几步：

创建一个maven项目
添加Spring相关依赖
添加一个启动类
这里我们不做过多赘述。

2.1 前置准备

当我们创建好一个maven项目后，在pom.xml中导入以下依赖就变成了一个Spring项目：

<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>

在这里插入图片描述
然后在resources下新建一个xml文件，命名可以自定义，但建议取名要有意义，这里我们新建一个spring的配置文件，里面放一些配置，不用记忆，配置如下：

<?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">
    <content:component-scan base-package="com.java.demo"></content:component-scan>

</beans>

在上面我们也提到了学Spring的核心功能包括了，学如何将对象存入到Spring中，再从Spring中取出对象的过程。接下来我们就对如何将对象存入到Spring以及如何从Spring中将对象取出作讲解。（在Spring框架中，我们将存储在Spring容器中的对象称为“Bean”）。

2.2 存储Bean对象

存储Bean对象分为两步：

创建一个Bean对象，所谓的Bean其实就是Java的一个普通类。
将Bean注入到Spring容器。

2.2.1创建Bean对象

public class User {
    public void sayHi() {
        System.out.println("Hi,User~");
    }
}

2.2.2 将Bean注入到Spring

在前置准备中，我们已经配置好了spring-config.xml这个文件，我们只需按照以下格式将Bean写入文件即可。

<bean id="user" class="com.java.demo.User"></bean>

此处的id就是我们之后通过Spring容器拿到这个Bean对象的名称，而class则是这个Bean所在目录的路径。

2.3 获取并使用Bean对象

获取并使用Bean对象分为以下三步：

获取Spring上下文对象
通过Spring上下文获取指定Bean对象
使用Bean对象

2.3.1 创建一个Spring上下文对象

下面的讲解中我们均以获取User对象为例，User定义如下：

package com.java.demo;

import com.java.demo.model.ArticleInfo;
import org.springframework.context.annotation.Bean;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;

@Service
public class User {

    public User() {
        System.out.println("User Init");
    }
    public void sayHi() {
        System.out.println("Hi,User~");
    }
}

  //1.得到上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");

在这里插入图片描述
另一种创建Spring上下文对象的方式：通过BeanFactory获取

BeanFactory context2 = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));

2.3.1.1 ApplicationContext和BeanFactory有什么区别

首先，从功能上来看，ApplicationContext是BeanFactory的子接口，因此它继承了BeanFactory的所有功能。但除此之外，ApplicationContext还扩展了更多的功能，如支持国际化、资源文件访问等，这使得它提供了更完整的框架功能。

其次，从加载和创建Bean的方式来看**，BeanFactory采用的是延时加载的方式**，也就是说，在容器启动时并不会立即创建所有的Bean，而是在需要使用某个Bean的时候，才会对其进行加载和实例化。这种方式的好处是在应用启动的时候占用资源较少，对于资源要求较高的应用可能更具优势。而ApplicationContext则是在容器启动的时候，一次性创建所有的Bean，这样在系统启动的时候就能尽早地发现配置问题，并且在运行时速度相对BeanFactory会更快。

最后，从创建方式来看，BeanFactory通常是以编程的方式创建的，而ApplicationContext则是以声明的方式创建的，通常是自动注册的。

综上所述，ApplicationContext和BeanFactory在功能、加载和创建Bean的方式以及创建方式上都有所不同。在实际应用中，可以根据具体需求选择使用哪一个。如果需要更丰富的框架功能和更快的运行速度，那么ApplicationContext可能是一个更好的选择；而如果资源要求较高，或者希望更精细地控制Bean的加载和创建过程，那么BeanFactory可能更适合。

2.3.2 获取Bean对象

根据名称获取Bean对象

User user = (User)context.getBean("user");

在这里插入图片描述
另外两种获取Bean对象的方法：

根据类型获取Bean

User user = (User)context.getBean(User.class);

可能的问题：当同一个类型注入Spring中多个的情况，使用类型获取Bean就会发生报错：
在这里插入图片描述

在这里插入图片描述
解决方法：使用名称获取Bean或者使用名称+类型获取Bean。

根据名称+类型获取Bean

User user = (User)context.getBean("user",User.class);

2.3.3 使用Bean对象

     user.sayHi();

在这里插入图片描述
整体的获取Bean对象代码如下：


import com.java.demo.User;
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 App {
    public static void main(String[] args) {
        //1.得到上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
//        BeanFactory context2 = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
        //2.得到bean对象
        // 通过名称获取
          User user = (User) context.getBean("user");
        //通过类型获取
//            User user = context.getBean(User.class);
        //通过名称+类型获取
//        User user = context.getBean("user", User.class);

        //3.使用bean对象
         user.sayHi();
    }
}