Spring IOC(一)

1. Spring IOC入门

1.1 什么是Spring IoC

IoC（Inversion of Control），即控制反转，是一种设计原则。简单来说，IoC就是将程序的某种传统控制流程反转了。

在Spring框架中，控制反转体现在对象的创建和管理上。

在不使用Spring框架的情况下，程序中需要使用某个类的对象时，需要手动创建该对象，如下所示。

基于Spring框架，开发者可以将类交给Spring框架管理，由Spring框架负责创建类的对象，并在开发者需要时提供给开发者。

1.2 Spring IoC容器概述

Spring的IoC容器（IoC Container）是Spring框架的核心组件之一，负责管理对象的生命周期和依赖关系。它实现了IoC的概念，通过将对象的创建、依赖注入和销毁等任务从应用程序代码中转移到容器中，以实现更松耦合、可维护和可测试的应用程序。

在Spring中，由IoC容器创建、组装和管理的对象被称为Bean。

1.3 第一个IoC示例

本案例创建Maven项目，并在项目中引入Spring框架的依赖：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>6.0.11</version>
</dependency>

首先，创建com.obj.spring包，在包下新建ContextConfig类：

package com.obj.spring
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
/**
 * Spring框架的配置类
 * 通过注解实现配置
 */
@Configuration
@ComponentScan("com.obj.spring")
public class ContextConfig {
}

接下来，声明com.obj.entity包，并在该包下创建Computer类。

package com.obj.entity;
import org.springframework.stereotype.Component;
@Component // 将当前类对象交给Spring框架管理
public class Computer {
    @Override
    public String toString() {
        return "Computer{}";
    }
}

然后，在com.obj包下创建案例的主类，命名为Application：

import com.obj.entity.Computer;
import com.obj.spring.ContextConfig;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class Application {
    public static void main(String[] args) {
        // 初始化Spring IoC容器对象
        ApplicationContext context =
                new AnnotationConfigApplicationContext(ContextConfig.class);
        // 通过Spring IoC容器对象获取Bean对象
        Computer computer = context.getBean(Computer.class);
        // 输出Bean对象信息
        System.out.println(computer);
    }
}

1.4 IoC示例运行原理解析

ContextConfig是一个Spring框架的配置类，功能类似于xml配置文件，作用是为Spring框架提供用户自定义的配置。

在早期的Spring框架中，配置是通过xml文件的方式提供的，内容较为繁琐。自2.5版本开始，Spring提供了基于注解进行配置的功能，可以更好的利用Java语言特性，避免了大量的XML配置代码。

@Configuration：用于标记当前类是一个Spring框架的配置类
@ComponentScan("cn.highedu")：用于通知Spring框架自动扫描和加载指定包下的所有组件并注册到Spring IoC容器中

Computer是一个交给Spring管理的类。

@Component：用于将类标识为一个受Spring管理的组件

ApplicationContext是Spring容器中最重要的核心接口之一，它扮演着Spring容器的角色，提供了一种对Spring Bean进行集中式管理的机制。

getBean方法用于从IoC容器中获取一个符合条件的Bean对象。

AnnotationConfigApplicationContext是ApplicationContext接口的一个重要实现，它可以通过读取基于Java类的配置以及指定的Component classes来构建Spring IoC容器。它在启动时将会扫描指定的包中所有用@Component、@Service、@Repository等注解修饰的类，将这些类实例化并且交由Spring容器进行管理。

1.5 IoC实现解耦示例

本案例通过一个简单的耦合场景，演示Spring IoC为项目带来的好处。

定义一个接口A和它的实现类B，然后定义20个类，分别命名为X1到X20。在X1到X20中都有一个名为method的方法，在方法中创建了B类的实例，并调用了run方法。

此时，X1到X20与接口及其他实现类B存在依赖关系，即存在耦合。如下图所示：

此时，有一个程序扩展需求：新建A接口的实现类C，将程序中所有的B类的对象都替换为C类的对象。为实现这一需求，需要逐个修改X1到X20类中的代码，程序的可扩展性和可维护性较差。

如果项目中应用了Spring IoC，则可以极大的简化这一工作。

首先，在com.obj.entity包下声明接口A。

public interface A {
    void run();
}

然后，在com.obj.entity包下声明类B，类B实现接口A，并重写run方法：

import org.springframework.stereotype.Component;
@Component
public class B implements A{
    @Override
    public void run() {
        System.out.println("Run by B");
    }
}

在Application类中添加通过A接口类型获取Bean对象并测试的代码。

public class Application {
    public static void main(String[] args) {
        // 初始化Spring IoC容器对象
        ApplicationContext context =
                new AnnotationConfigApplicationContext(ContextConfig.class);
        A a = context.getBean(A.class);
        a.run();
    }
}

此时，控制台输出“Run by B”。

接下来，在cn.highedu.entity包下创建类C，同样实现A接口。

import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;
@Component
@Primary // 优先使用该类对象
public class C implements A{
    @Override
    public void run() {
        System.out.println("Run by C");
    }
}

再次运行Application类中的main方法，控制台输出“Run by C”，表示此时A接口的实现类已经改为使用类C。在这个切换的过程中，开发者并不需要对Application类中的代码进行修改，提高了程序的可扩展性。

1.6 Spring IoC的好处

Spring IoC为项目带来许多好处：

1、松耦合性： IoC降低了对象之间的紧密耦合度。对象不再直接创建和管理它们的依赖，而是通过容器来完成。这使得各个组件能够更独立地变化，降低了变更的风险。

2、可维护性：由于对象的创建和管理由容器负责，代码的结构更清晰，逻辑更集中。这使得代码更易于理解、扩展和维护，尤其在大型项目中尤为重要。

3、灵活性：通过配置文件或者注解，你可以在不修改代码的情况下改变对象的行为。这意味着你可以更容易地应对变化的需求，而不需要大规模的代码修改。

4、重用性（Reusability）：通过依赖注入，对象可以被更广泛地重用。你可以通过将相同的组件配置到不同的环境中，实现代码的重用。

总的来说，Spring IoC通过将控制权从应用程序代码中转移到容器中，带来了更好的可维护性、灵活性和重用性，有助于构建高质量、可扩展和易于维护的应用程序。

2. Spring DI入门

2.1 什么是DI

在统一建模语言 (UML) 中，依赖（Dependency）是一种关系，表明一个元素或一组元素需要其他模型元素来进行规范或实现。

DI是Dependency Injection的缩写，即依赖注入，是一项使一个对象接收到它所依赖的其他对象的技术。DI 的实现通常需要使用注解或 XML 配置文件来声明依赖关系：

2.2 Spring中的DI

Spring框架提供了一种基于注解的、声明式的依赖注入方式，称为 Spring DI。

DI是Spring框架实现控制反转（IoC）的一种方式，被反转的是一个对象获取其依赖对象的流程。

传统流程：一个对象主动创建自己依赖项的对象
反转后的流程：一个对象声明自己需要某个依赖项对象，由框架将依赖项对象注入到该对象中

在 Spring 框架中，依赖注入通常通过注解或 XML 配置文件实现。

1、注解方式

Spring框架支持使用@Autowired、@Resources等注解来实现依赖注入。

@Autowired注解可以注入一个具体的类、接口、或者抽象类，一般用于注入当前对象依赖的其他对象
@Resources注解与@Autowired注解功能相似，但是执行机制上略有不同，推荐使用@Autowired注解

2、XML配置文件方式（了解）

Spring 框架也支持使用 XML 配置文件来实现依赖注入。通过 XML 配置文件，可以更清晰地定义依赖关系，同时也支持更多的配置选项。例如，可以使用以下 XML 配置文件来实现依赖注入:

<bean id="B"  class="com.example.demo.B">    
</bean>  
<bean class="com.example.demo.A">  
        <property name="b"  ref="B" />  
</bean>

2.3 依赖注入示例

在com.obj.entity包下声明Student类，该类包含一个Computer类型的属性。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Student {

    // 通过Spring框架获取Computer对象
    @Autowired
    private Computer computer;

    public void use(){
        System.out.println("使用电脑："+computer);
    }
}

在Application类的main方法中获取Student类的Bean，查看是否自动注入了Computer对象。

public class Application {
    public static void main(String[] args) {
        // 初始化Spring IoC容器对象
        ApplicationContext context =
                new AnnotationConfigApplicationContext(ContextConfig.class);
        Student student = context.getBean(Student.class);
        student.use();
    }
}