Spring教程

Spring 实战（第 4 版）
初识 - Spring
学习Spring框架这一篇就够了
Spring 创建和使用
Spring 更简单的读取和存储对象
Bean 作用域和生命周期
Spring 从入门到精通 (一) 入门篇
Spring 从入门到精通 (十八) AOP注解式开发
Spring专栏
Spring纯注解开发模式简直就是Spring中的Spring
Spring AOP 详解
手写迷你Spring框架
Spring从面向对象再到面向切面
Spring面试题（2020最新版）
Spring框架教程（非常详细）

什么是 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);
    }
}

1
2
3
4
5
6
7
8

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");



    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

spring-config.xml

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


1
2
3
4
5
6
7
8
9
10
11
12

pom.xml

<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.0modelVersion>

    <groupId>org.examplegroupId>
    <artifactId>spring1artifactId>
    <version>1.0-SNAPSHOTversion>

    <properties>
        <maven.compiler.source>8maven.compiler.source>
        <maven.compiler.target>8maven.compiler.target>
    properties>
    <dependencies>

        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.2.3.RELEASEversion>
        dependency>

        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-beansartifactId>
            <version>5.2.3.RELEASEversion>
        dependency>
    dependencies>


project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

如何理解 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(实现手段))就像是说:我今天要去吃一段好的犒劳自己一下(思想) 跟 我今天要去吃一顿海底捞犒劳一下自己(实现手段)