Java EE3-我独自整合（第二章：Spring IoC 入门案例）

一、先搞懂：Spring IoC 是什么？

IoC = Inversion of Control（控制反转） 一句话： 对象的创建、管理、赋值，不再由我们 new，交给 Spring 容器去做。

好处：

• 解耦（代码不硬耦合）
• 方便统一管理
• 方便测试、扩展

---

二、案例结构（标准三层）

我们做一个最经典的： UserService → UserDao 由 Spring 统一创建对象、自动注入。

结构：

src/
  com/
    demo/
      dao/
        UserDao.java
        UserDaoImpl.java
      service/
        UserService.java
        UserServiceImpl.java
      test/
        SpringTest.java
  applicationContext.xml  (Spring 核心配置文件)

---

三、步骤 1：导入 Spring 依赖（maven）

如果你是 Maven 项目，粘贴到 ​​pom.xml​​：

<dependencies>
    <!-- Spring 核心容器 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.24</version>
    </dependency>
</dependencies>

---

四、步骤 2：写 Dao 层

1. UserDao 接口

package com.demo.dao;

public interface UserDao {
    void add();
}

2. UserDaoImpl 实现类

package com.demo.dao;

public class UserDaoImpl implements UserDao {
    @Override
    public void add() {
        System.out.println("UserDao 执行 add() 方法……");
    }
}

---

五、步骤 3：写 Service 层

1. UserService 接口

package com.demo.service;

public interface UserService {
    void addUser();
}

2. UserServiceImpl 实现类

package com.demo.service;

import com.demo.dao.UserDao;

public class UserServiceImpl implements UserService {

    // 要注入的对象
    private UserDao userDao;

    // Spring 注入必须提供 set 方法！！
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void addUser() {
        System.out.println("UserService 执行 addUser()……");
        userDao.add(); // 调用 dao
    }
}

---

六、步骤 4：Spring 配置文件（最核心）

在 ​​src​​ 下创建 applicationContext.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">

    <!-- 1. 把 UserDao 交给 Spring 管理 -->
    <bean id="userDao" class="com.demo.dao.UserDaoImpl"/>

    <!-- 2. 把 UserService 交给 Spring 管理 -->
    <bean id="userService" class="com.demo.service.UserServiceImpl">
        <!-- 3. 依赖注入：给 userDao 赋值（DI） -->
        <property name="userDao" ref="userDao"/>
    </bean>

</beans>

关键说明

• ​​<bean>​​：把类交给 Spring 管理，Spring 自动 new 对象
• ​​id​​：对象名
• ​​class​​：类的全路径
• ​​<property>​​：DI 依赖注入，给属性赋值
• ​​name​​：类里的属性名
• ​​ref​​：要注入的 bean 的 id

---

七、步骤 5：测试类（运行）

package com.demo.test;

import com.demo.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    public static void main(String[] args) {
        // 1. 加载 Spring 配置文件，创建容器
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");

        // 2. 从 Spring 容器中获取对象
        UserService userService =
                (UserService) context.getBean("userService");

        // 3. 调用方法
        userService.addUser();
    }
}

---

八、运行结果

UserService 执行 addUser()……
UserDao 执行 add() 方法……

✅ 成功！ 我们 没有写一个 new，对象全部由 Spring 创建、注入。

---

九、这个案例的核心知识点（必须背会）

1. IoC 控制反转

对象的创建权，从程序员 反转 给了 Spring 容器。

2. DI 依赖注入

Spring 自动把 ​​UserDao​​ 对象赋值给 ​​UserService​​。 DI 是 IoC 的实现方式。

3. 必须条件

• 要注入的属性必须提供 set 方法
• 配置文件中 ​​<property>​​ 写法正确

4. 容器接口

​​ApplicationContext​​ 是 Spring 容器的核心接口，负责：

• 加载配置
• 创建对象
• 管理对象
• 注入对象

---

十、你可以独立完成的整合流程（独自默写版）

1. 建 Maven 项目，导入 spring-context
2. 写 Dao 接口 + 实现
3. 写 Service 接口 + 实现，提供 set 方法
4. 写 applicationContext.xml，配置 bean
5. 配置 property 注入依赖
6. 测试类获取容器，getBean，调用方法
7. 运行成功

---