Spring-IOC 学习笔记

IOC 核心概念

IOC（Inversion of Control，控制反转）是 Spring 框架的核心思想之一，其核心逻辑是将对象创建的权利从程序员手动通过代码（如 new 关键字）创建，转移到 Spring 容器中，由容器根据配置信息统一管理对象的创建、初始化、依赖注入及生命周期，以此降低代码间的耦合度，提升项目的可维护性与扩展性。

IOC（控制反转）的核心是将对象创建与管理权利移交 Spring 容器，其主流实现方式分为基于 XML 配置文件和基于注解两种，二者在配置形式、操作流程和适用场景上存在显著差异，以下分别展开介绍：

一、基于 XML 配置文件的方式

该方式通过编写 XML 格式的配置文件，明确告知 Spring 容器需管理的 Bean 信息，是 Spring 早期最经典的 IOC 实现形式，文档中即采用此方式完成 IOC 操作。

二、基于注解的方式

该方式通过在 Java 类或方法上添加特定注解（如 @Component、@Service 等），替代 XML 配置文件告知 Spring 容器管理 Bean，是目前主流的 IOC 实现方式，配置更简洁、开发效率更高。

IOC 实现方式（配置文件方式）

1. 项目初始化：创建 Maven 项目

• 项目类型选择：通过开发工具的 “New Project” 功能，选择基于 Maven Archetype 的项目构建方式，指定 Archetype 为 org.apache.maven.archetypes:maven-archetype-webapp（Web 应用骨架），用于搭建基础项目结构。

2.依赖配置：导入 Spring 上下文容器依赖

• 在项目的 pom.xml 文件中，通过 <dependency> 标签配置 Spring 上下文容器依赖，以确保项目能够使用 Spring 容器的核心功能。

<!--spring上下文 容器-->  
<dependency>  
  <groupId>org.springframework</groupId>  
  <artifactId>spring-context</artifactId>  
  <version>5.3.25</version>  
</dependency>

3. 配置文件编写：创建 Spring 核心配置文件

• 配置文件创建：在项目 src/main/resources 目录下，创建名为 applicationContext.xml 的 XML 配置文件，该文件是 Spring 容器的核心配置入口，用于定义 Bean 信息。
• Bean 定义规范：在 applicationContext.xml 中，通过 <bean> 标签定义需要由容器管理的对象。其中，id 属性设置为 stu（作为 Bean 在容器中的唯一标识，确保对象获取时的唯一性），class 属性设置为 com.cykj.Student（指定 Bean 对应的全类名，即包名 + 类名，告诉容器需要创建的对象类型）。

4. 容器调用：通过代码获取容器中的 Bean 对象

• 容器初始化：在 Lesson01 类的 main 方法中，通过 ClassPathXmlApplicationContext 类（Spring 提供的基于类路径读取 XML 配置文件的容器实现类），传入 applicationContext.xml 配置文件路径，完成 Spring 容器的初始化，此时容器会根据配置文件中的 Bean 定义自动创建 Student 对象。

• Bean 对象获取的三种规范方式：
  1. 基于 Bean 的 id 获取：调用容器的 getBean("stu") 方法，传入配置文件中 Bean 的 id 值，返回 Object 类型对象，需手动强制转换为 Student 类型，实现对容器中指定 Bean 的获取。
  2. 基于 Bean 的 id + 目标类型获取：调用容器的 getBean("stu", Student.class) 方法，同时传入 Bean 的 id 和目标类的 Class 对象，直接返回指定类型的 Bean 对象，无需手动类型转换，减少类型转换异常风险。
  3. 基于目标类型获取：调用容器的 getBean(Student.class) 方法，仅传入目标类的 Class 对象，直接返回该类型的 Bean 对象（该方式要求容器中该类型的 Bean 唯一，否则会抛出 NoUniqueBeanDefinitionException 异常）。

/**  
 * @className: Lesson01  
 * @author: ahatc  
 * @date: 2025/11/15 11:55  
 * @version: 1.0  
 * @description: 通过配置文件的方式（IOC）  
 */  
  
public class Lesson01 {  
    public static void main(String[] args) {  
        //通过 这个去获取一个配置文件读取到的类  
        ClassPathXmlApplicationContext classPathXmlApplicationContext  
                = new ClassPathXmlApplicationContext("applicationContext.xml");  
  
        //第一种获取方式：通过id获取  
        //bean的名字与配置文件中的 id 一致  
        Object stu1 = (Student) classPathXmlApplicationContext.getBean("stu");  
        System.out.println(stu1);  
  
        //第二种获取方式：通过id+类名  
        Student stu2 = classPathXmlApplicationContext.getBean("stu",Student.class);  
        System.out.println(stu2);  
  
        //第三种获取方式：通过类名获取  
        Student stu3 = classPathXmlApplicationContext.getBean(Student.class);  
        System.out.println(stu3);  
  
  
    }}

IOC 实现方式（注解方式）【更优】

1. 第一步第二步同上创建Maven 工程与导入依赖

一、核心配置与依赖

1. Maven 依赖（pom.xml 关键部分）

   引入 Spring 核心上下文和 Lombok 依赖，前者用于 IOC 容器功能，后者简化实体类代码：

   <dependencies>
       <!-- Spring IOC核心依赖 -->
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-context</artifactId>
           <version>5.3.25</version>
       </dependency>
       <!-- Lombok：自动生成get/set等方法 -->
       <dependency>
           <groupId>org.projectlombok</groupId>
           <artifactId>lombok</artifactId>
           <version>1.18.30</version>
       </dependency>
   </dependencies>
   

2. Spring 配置文件（applicationContext.xml）

   核心配置包扫描和外部配置文件加载，前者让 Spring 自动识别注解类，后者读取外部属性：

   <!-- 扫描指定包下带注解的类，注册为Bean -->
   <context:component-scan base-package="com.cykj"/>
   
   <!-- 加载外部配置文件（如数据库信息） -->
   <context:property-placeholder location="classpath:db.properties"/>
   

二、实体类与注解使用

1. Student 类

   使用@Component标识为 Spring 管理的 Bean，通过@Value注入外部配置值，@Autowired自动注入依赖：

   @Data  // Lombok注解：简化get/set/toString
   @Component  // 注册为Bean，默认id为"student"
   public class Student {
       @Value("${jdbc.url}")  // 从db.properties读取值
       private String name;
       
       @Autowired  // 自动注入Course类型的Bean
       private Course course;
   }
   

2. Course 类

   同样用@Component注册为 Bean，与 Student 形成依赖关系：

   @Data
   @Component  // 注册为Bean，默认id为"course"
   public class Course {
       private Student courseName;  // 关联Student
   }
   

三、测试代码（获取容器中的 Bean）

通过 Spring 上下文加载配置文件，从 IOC 容器中获取 Bean 并使用：

public class Lesson01 {
    public static void main(String[] args) {
        // 初始化IOC容器
        ClassPathXmlApplicationContext context = 
            new ClassPathXmlApplicationContext("applicationContext.xml");
        // 获取id为"student"的Bean
        Student student = (Student) context.getBean("student");
        System.out.println(student);  // 打印对象信息
    }
}

四、核心注解作用

• @Component：将类标记为 Spring Bean，由 IOC 容器管理，默认 Bean id 为类名首字母小写。
• @Autowired：自动按类型匹配并注入依赖的 Bean，无需手动创建对象。
• @Value：注入基本类型或字符串值，支持通过${key}读取外部配置文件（如 db.properties）中的值。
• @Data（Lombok）：自动生成 getter、setter、toString 等方法，减少重复代码。

五、关键流程

1. 启动程序时，Spring 加载配置文件，通过component-scan扫描com.cykj包下的注解类。
2. 识别@Component注解，将 Student 和 Course 实例化为 Bean 存入 IOC 容器。
3. 通过@Autowired完成 Student 与 Course 的依赖注入，@Value注入配置文件中的属性值。
4. 从容器中获取 Bean 并使用，实现对象的创建和依赖管理完全由 Spring 控制。

对实现方式进行封装

静态 ClassPathXmlApplicationContext 工具类 返回 getBean(“student”) 结果