Spring IoC 总结 - 技术栈

1.Spring IoC是什么？

Spring IoC（Inverse of Control 控制反转）是 Spring 框架的一个关键概念，它是 Spring 实现依赖注入（DI）的核心机制之一。IoC 是一种设计模式，用于解耦组件之间的依赖关系，提高代码的灵活性、可维护性和可测试性。

在传统的编程模式中，对象的创建和管理通常由程序员自己负责 。但是在大型应用中，对象之间的依赖关系会变得复杂，手动管理这些依赖关系将会变得非常困难。这时候，IoC 就变得非常有用。 SpringIoC也称依赖注入，指对象被动地接收依赖类而不用自己主动去找，对象不是从容器中查找它依赖的类，而是在容器实例化对象时主动将它依赖的类注入给它。

在 Spring IoC 中，对象之间的依赖关系由容器管理。容器负责创建对象、装配对象之间的依赖关系，并且管理它们的生命周期。开发者只需要描述对象之间的依赖关系，然后交给容器来实现。

Spring IoC 主要通过以下两种方式实现依赖注入：

构造函数注入（Constructor Injection）：通过构造函数来注入依赖对象。在配置文件中声明 bean 的时候，可以指定构造函数的参数，Spring 容器会负责将相应的依赖对象传递给构造函数。
属性注入（Setter Injection）：通过 setter 方法来注入依赖对象。在配置文件中声明 bean 的时候，可以使用 <property> 标签来设置对象的属性，Spring 容器会负责调用相应的 setter 方法，并将依赖对象传递进去。

Spring IoC 的工作流程大致如下：

配置：开发者通过 XML 配置文件、**Java 注解（常用）**或者 Java 代码来描述对象之间的依赖关系。
实例化：Spring 容器根据配置信息，实例化并管理 bean 对象。
注入：Spring 容器根据配置信息，将依赖对象注入到相应的 bean 中。
使用：开发者可以通过从容器中获取 bean，并调用其方法来使用它。
销毁：Spring 容器负责管理 bean 的生命周期，包括初始化和销毁。

使用 Spring IoC 可以带来很多好处，比如降低组件之间的耦合度、提高代码的可维护性和可测试性、提高开发效率等。

2.Spring IoC 容器的初始化过程？

Spring IoC 容器的初始化过程涉及到几个关键步骤，包括读取配置、实例化并初始化 beans，以及处理依赖注入。这个过程大致可以分为以下几个阶段：

1. 启动 Spring IoC 容器

对于基于 XML 的配置，通常会通过创建 ClassPathXmlApplicationContext 或 FileSystemXmlApplicationContext 的实例来启动 Spring IoC 容器。
对于基于注解的配置，通常会使用 AnnotationConfigApplicationContext 类。

2. 读取配置信息

容器启动后，**会根据提供的配置信息（XML 文件、Java 配置类或注解）来加载并解析，**确定需要管理的 beans 及其依赖关系。

3. 实例化 Beans

根据配置信息，容器会实例化 beans。这一步主要是创建对象的实例，但还未填充属性或完成依赖注入。

4. 依赖注入

在 beans 实例化之后，Spring IoC 容器将会根据配置信息（通过构造器注入、设置器注入或字段注入）将依赖的 beans 注入到相应的对象中。

5. 初始化

依赖注入完成后，如果 bean 实现了 InitializingBean 接口或通过配置指定了 init 方法，Spring 容器将调用这些方法来完成初始化。这是自定义初始化逻辑的地方。

6. BeanPostProcessor

Spring IoC 容器允许 BeanPostProcessor 的实现类在任何 bean 的初始化方法调用前后进行额外的处理。这可以用于需要对 bean 进行某些处理的高级配置。

7. 完成初始化

此时，所有的 beans 都已经被成功创建、依赖注入并初始化。容器现在准备好了，可以使用。

8. 使用 Beans

应用程序可以通过容器获取 beans，并调用它们的方法来执行业务逻辑。

9. 销毁

当应用程序结束时，或者 Spring 容器被显式关闭时，容器会销毁单例 beans。如果 beans 实现了 DisposableBean 接口或通过配置指定了 destroy 方法，Spring 容器将调用这些方法来完成清理工作。

这个过程显示了 Spring IoC 容器如何管理 beans 的整个生命周期，从创建、初始化到销毁，确保了应用组件的高度解耦和灵活管理。

3.Spring IoC依赖注入常用注解及其区别？

Spring自动装配(Autowired)原理，不是自动配置！！！及@Autowired与@Resource的区别-CSDN博客

4.如何通过注解创建Bean？

在 Spring 中，通过注解创建和配置 Bean 是一种简洁且广泛使用的方法，它减少了 XML 配置的需要。下面是使用注解创建 Bean 的基本步骤：

1. 开启注解支持

首先，确保你的 Spring 配置开启了注解支持。如果你正在使用基于 Java 的配置，可以通过在配置类上添加 @Configuration 注解，并使用 @ComponentScan 注解来指定 Spring 应该扫描哪些包来查找带有注解的类。

java 复制代码

@Configuration 
@ComponentScan(basePackages = "com.example.project") 
public class AppConfig { 
}

如果你还在使用 XML 配置，可以通过 <context:component-scan> 标签来启用注解扫描：

XML 复制代码

<context:component-scan base-package="com.example.project" />

2. 使用注解声明 Bean

在类上使用 Spring 提供的注解来声明一个 Bean。最常用的注解有：

@Component：通用的组件注解，可以用在任何类上。
@Service：用于标注服务层的组件。
@Repository：用于标注数据访问层的组件，它可以让数据访问异常具有一定的转换逻辑。（现常用@Mapper注解）
@Controller：用于标注控制层的组件（如 Spring MVC 的控制器）。

这些注解自动将类标记为 Spring 管理的组件，意味着 Spring 会为这些类创建 Bean。

java 复制代码

@Service 
public class MyService { // class body }

3. 自动装配依赖

可以使用 @Autowired 注解在需要依赖注入的地方，Spring 会自动寻找匹配的组件并注入。@Autowired 可以用在构造器、字段和方法上。

java 复制代码

@Service 
public class MyService { 
    private final MyRepository myRepository; 
    @Autowired 
    public MyService(MyRepository myRepository) { 
        this.myRepository = myRepository; 
    } 
}

4. 进阶配置

@Qualifier 注解可以用来解决自动装配时同一类型有多个实例的冲突。
@Bean 注解可以用在方法上，用于显式声明一个 Bean，这在 @Configuration 类中特别有用。

java 复制代码

@Configuration 
public class AppConfig { 
    @Bean 
    public MyBean myBean() {
     return new MyBean(); 
    } 
}

5. 运行 Spring 应用

最后，通过创建 AnnotationConfigApplicationContext 的实例，加载包含 @Configuration 注解的配置类，Spring 容器就会启动并创建注解声明的 Bean。

java 复制代码

public class Application { 
    public static void main(String[] args) { 
        ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class); 
        MyService myService = ctx.getBean(MyService.class); // 使用 myService 
    } 
}

通过遵循上述步骤，你可以利用注解轻松地在 Spring 中创建和配置 Bean。

5.SpringIoC解决了哪些问题，好处是什么？

Spring IoC（控制反转）容器解决了多个与应用程序开发相关的核心问题，主要集中在对象的创建、管理和解耦上。它带来了如下好处：

1. 降低耦合度

传统的应用程序开发中，对象的创建通常由开发者通过直接实例化来完成，这导致了高度耦合的代码。Spring IoC 容器通过依赖注入（DI），让对象的创建和生命周期管理交由容器控制，从而实现了对象间的低耦合。开发者只需要关注业务逻辑，而对象之间的依赖关系可以通过配置来完成。

2. 提高代码的可维护性

由于降低了耦合度，应用组件之间的依赖关系变得更加清晰，这自然提高了代码的可读性和可维护性。当需要替换或修改某个组件时，由于依赖关系是通过配置进行管理的，因此更改变得简单且影响范围可控。

3. 提高代码的可测试性

在传统的开发模式中，单元测试可能会受到紧密耦合代码的影响，变得复杂且难以维护。Spring IoC 使得依赖注入变得简单，开发者可以轻松地为测试用例注入 mock 对象，从而提高测试的覆盖度和质量。

4. 简化资源管理

Spring IoC 容器提供了一种简化的方式来管理资源，比如数据库连接和文件资源。通过资源和服务的自动装配，开发者无需手动编码来查找依赖项，简化了资源的使用和释放。

5. 统一的生命周期管理

**Spring IoC 容器管理着所有 bean 的生命周期，可以在对象的创建、使用和销毁阶段插入自定义的逻辑。**比如，可以自动调用初始化和销毁回调方法，这对于需要进行特定生命周期管理的资源来说非常有用。

6. 灵活的配置管理

Spring IoC 容器支持多种配置方式，包括 XML 配置、注解和 Java 配置。这提供了极大的灵活性，允许开发者根据项目的具体需求和偏好选择最合适的配置方式。

7. 促进良好的编程实践

通过鼓励接口编程和组件化开发，Spring IoC 促进了良好的编程实践。这使得代码更加模块化，提高了复用性和可测试性。

总结: Spring IoC 提供了一种强大的机制来管理对象的创建、配置和管理，解决了传统开发模式中的耦合度高、可维护性和可测试性差等问题。通过使用 Spring IoC，开发者可以更专注于业务逻辑的实现，同时享受到高质量代码的好处。

6.虽然IoC也被称为依赖注入，但注意区别？

IoC vs DI： IoC 是一个更广泛的概念，它描述了一个目标（减少代码耦合），而 DI 描述了实现这个目标的一种方法（通过外部注入依赖来减少耦合）。
联系： DI 是实现 IoC 的手段之一。通过将对象的创建和依赖关系的管理交给外部容器（如 Spring IoC 容器），实现了控制的反转，对象不再自行控制依赖对象的创建和生命周期。

简而言之，IoC 是一个宽泛的编程思想，主张通过反转控制来减少代码之间的耦合；DI 是实现 IoC 思想的一种具体做法，通过外部注入的方式来管理对象之间的依赖关系，从而使得代码更加灵活和模块化。