Spring Boot 心智模型：IoC 与依赖注入

核心理念

Spring Boot 的设计哲学：通过 IoC 容器管理对象，通过依赖注入解耦组件，通过自动配置减少样板代码。

传统 Java 方式 vs Spring 方式

传统方式：紧耦合

public class OrderService {
    private OrderRepository orderRepository = new OrderRepositoryImpl();
    private EmailService emailService = new EmailServiceImpl();
    
    public void createOrder(Order order) {
        orderRepository.save(order);
        emailService.send(order.getUserEmail(), "Order created");
    }
}

问题：

• 依赖具体实现，无法替换
• 难以测试（无法 mock 依赖）
• 创建对象的责任在业务代码中

Spring 方式：依赖注入

@Service
public class OrderService {
    private final OrderRepository orderRepository;
    private final EmailService emailService;
    
    @Autowired
    public OrderService(OrderRepository orderRepository, EmailService emailService) {
        this.orderRepository = orderRepository;
        this.emailService = emailService;
    }
    
    public void createOrder(Order order) {
        orderRepository.save(order);
        emailService.send(order.getUserEmail(), "Order created");
    }
}

优势：

• 依赖接口，易于替换实现
• 易于测试（可以注入 mock 对象）
• 对象创建由容器管理

IoC 容器的三大职责

1. Bean 的创建与管理

@Component
public class UserService { }

@Service  // @Component 的特化
public class OrderService { }

@Repository  // @Component 的特化，用于数据访问
public class UserRepository { }

@Controller  // @Component 的特化，用于 Web 控制器
public class UserController { }

2. 依赖注入

// 构造器注入（推荐）
@Service
public class UserService {
    private final UserRepository userRepository;
    
    @Autowired  // 单构造器时可省略
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

// 字段注入（不推荐，但常见）
@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;
}

// Setter 注入（可选依赖时使用）
@Service
public class EmailService {
    private TemplateEngine templateEngine;
    
    @Autowired(required = false)
    public void setTemplateEngine(TemplateEngine templateEngine) {
        this.templateEngine = templateEngine;
    }
}

3. Bean 的生命周期管理

@Component
public class DatabaseConnection {
    
    @PostConstruct
    public void init() {
        // Bean 创建后执行
        System.out.println("连接数据库");
    }
    
    @PreDestroy
    public void cleanup() {
        // Bean 销毁前执行
        System.out.println("关闭数据库连接");
    }
}

自动配置的魔法

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@SpringBootApplication 等于：

@Configuration        // 声明配置类
@EnableAutoConfiguration  // 启用自动配置
@ComponentScan       // 扫描当前包及子包的 @Component

自动配置原理：

1. 检查 classpath 上的依赖（如 spring-boot-starter-web）
2. 根据条件判断是否需要配置（如 @ConditionalOnClass）
3. 自动创建所需的 Bean（如 DispatcherServlet、Jackson）

Bean 的作用域

@Service
@Scope("singleton")  // 默认，整个应用只有一个实例
public class UserService { }

@Service
@Scope("prototype")  // 每次请求都创建新实例
public class ReportGenerator { }

@Service
@Scope("request")  // Web 应用中，每个 HTTP 请求一个实例
public class RequestContext { }

与其他框架对比

特性	Spring Boot	Express.js	Django
IoC 容器	✅	❌	部分
依赖注入	✅	手动	部分
自动配置	✅	❌	部分
约定优于配置	✅	✅	✅

学习路径

1. 理解 IoC 和 DI 概念
2. 掌握 @Component、@Service、@Repository、@Controller
3. 学习依赖注入的三种方式
4. 理解 Bean 的生命周期
5. 掌握 @Configuration 和 @Bean

下一步：进入可运行实验创建第一个 Spring Boot 应用。