Spring教程-优快云博客

Spring 实战（第 4 版）
初识 - Spring
学习Spring框架这一篇就够了
 Spring 创建和使用
 Spring 更简单的读取和存储对象
 Bean 作用域和生命周期
 Spring 从入门到精通 (一) 入门篇
 Spring 从入门到精通 (十八) AOP注解式开发
 Spring专栏
 Spring纯注解开发模式简直就是Spring中的Spring
Spring AOP 详解
 手写迷你Spring框架
 Spring从面向对象再到面向切面
 Spring面试题（2020最新版）
Spring框架教程（非常详细）
学习记录一记录Spring框架学习和力扣打卡
 学习记录二
 学习记录七
 Spring系列学习汇总
 java数据结构和c语言数据结构区别，移动架构师成长路线
 Spring和SpringBoot学习

在这里插入图片描述

什么是 IoC?

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

IoC => Inversion of Control 翻译成中⽂是 “控制反转” 的意思，也就是说 Spring 是⼀个“控制反转”的容器,是 Spring 的核心,贯穿始终.这个 IOC ，对于 Spring框架来说，就是由 Spring 来负责控制对象的生命周期和对象间的关系.把所有类放在 Spring容器里,所有类的创建和销毁都由Spring来控制,而不再由引用他的对象来控制,这就是控制反转.

在传统的代码中对象创建顺序是：Car -> Framework -> Bottom -> Tire
改进之后解耦的代码的对象创建顺序是：Tire -> Bottom -> Framework -> Car

在这里插入图片描述
在我们改进之后的控制权发⽣的反转，不再是上级对象创建并控制下级对象了，⽽是下级对象把注⼊将当前对象中，下级的控制权不再由上级类控制了，这样即使下级类发⽣任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IoC 的实现思想

什么是 DI?

DI 是 Dependency Injection 的缩写，翻译成中⽂是“依赖注⼊”的意思
所谓依赖注⼊，就是由 IoC 容器在运⾏期间，动态地将某种依赖关系注⼊到对象之中。所以，依赖注⼊（DI）和控制反转（IoC）是从不同的⻆度的描述的同⼀件事情，就是指通过引⼊ IoC 容器，利⽤依赖关系注⼊的⽅式，实现对象之间的解耦。
IoC 是“⽬标”也是⼀种思想，⽽⽬标和思想只是⼀种指导原则，最终还是要有可⾏的落地⽅案，⽽ DI 就属于具体的实现。

创建 Spring 项目

前面所学习的 Spring 就是⼀个包含了众多⼯具⽅法的 IoC 容器。
就具备两个最核心的功能：
将对象(Bean)存储到容器（Spring）中；
从容器(Spring)中将对象(Bean)取出来。

总体三步:
1: 创建⼀个普通 Maven 项⽬。
2: 添加 Spring 框架⽀持（spring-context、spring-beans）。
3: 添加启动类
在这里插入图片描述

User.java

package beans;

public class User {
    public void sayHi(String name){
        System.out.println("hello :  "+name);
    }
}

在这里插入图片描述

App.java

import beans.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) {
        // 方法一: 通过 ApplicationContext 来获取 Spring 的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        //根据上下文对象提供的方法获取到 Bean
        User user1 = (User) context.getBean("user");

        user1.sayHi("Spring1");

        // 方法二: 通过  BeanFactory 来获取 Spring 的上下文对象
        BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));

        //通过类型获取
        User user2 = beanFactory.getBean(User.class);

        user2.sayHi("Spring2");

        // 方法三: 通过 id+类型 来获取
        User user3 = context.getBean("user",User.class);

        user3.sayHi("Spring3");



    }
}

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">

    <beans>
        <bean id = "user" class="beans.User"></bean>
    </beans>
</beans>

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>spring1</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <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>


</project>

在这里插入图片描述

如何理解 Spring?

Spring 是包含了多个⼯具⽅法的 IoC 容器，说的是对象的创建和销毁的权利都交给 Spring 来管理了，它本身⼜具备了存储对象和获取对象的能⼒。也就是 Spring 最核心的功能就是:就是学如何将对象(Bean)存⼊到 Spring (容器)中，再从 Spring(容器) 中获取对象(Bean)的过程

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

IoC 和 DI 有什么区别?

IoC, Inversion of Control, 译为控制反转. 使用控制反转的思路 ,可以实现依赖类之间的解耦,让我们不必在去关心依赖类的具体实现, 以及生命周期, 我们只需要在使用他的时候, 把他注入进来就行.
DI, Denpendency Injection, 译为依赖注入. 是一种 Ioc 具体实现手段, 指的是在 IoC 容器运行的期间, 动态将某种依赖关系注入到对象中.
区别: IoC 是一种思想, DI 是一种实现(乐观锁(思想) CAS(实现手段))就像是说:我今天要去吃一段好的犒劳自己一下(思想) 跟我今天要去吃一顿海底捞犒劳一下自己(实现手段)