Spring框架基础：IoC与DI

概述

Spring是Java企业级开发的主流框架，它通过IoC（控制反转）和DI（依赖注入）实现了代码的松耦合。Spring容器管理对象的生命周期和依赖关系。

1. Spring容器

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

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

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        UserService userService = context.getBean(UserService.class);
        userService.register("admin");
    }
}

2. Bean的定义

import org.springframework.stereotype.Service;
import org.springframework.stereotype.Repository;

@Service
public class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void register(String username) {
        User user = new User(username);
        userRepository.save(user);
        System.out.println("注册用户: " + username);
    }
}

@Repository
public class UserRepository {
    private final Map<String, User> store = new HashMap<>();

    public void save(User user) {
        store.put(user.getUsername(), user);
    }

    public User findByUsername(String username) {
        return store.get(username);
    }
}

3. 依赖注入方式

@Service
public class OrderService {
    private final UserRepository userRepository;
    private final ProductService productService;

    // 构造器注入（推荐）
    public OrderService(UserRepository userRepository, ProductService productService) {
        this.userRepository = userRepository;
        this.productService = productService;
    }
}

@Service
public class PaymentService {
    private NotificationService notificationService;

    // Setter注入
    @Autowired
    public void setNotificationService(NotificationService notificationService) {
        this.notificationService = notificationService;
    }
}

4. Bean作用域

@Service
@Scope("singleton")
public class SingletonService {
}

@Service
@Scope("prototype")
public class PrototypeService {
}

@Component
@Scope("request")
public class RequestScopedService {
}

5. Bean生命周期

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class LifecycleBean {
    @PostConstruct
    public void init() {
        System.out.println("Bean初始化完成");
    }

    @PreDestroy
    public void cleanup() {
        System.out.println("Bean销毁前");
    }
}

最佳实践

1. 使用构造器注入：保证依赖不可变
2. 面向接口编程：提高可测试性
3. 合理使用作用域：根据需要选择singleton或prototype
4. 使用@Component系列注解：简化Bean定义
5. 避免循环依赖：设计时注意依赖关系

总结

Spring框架通过IoC和DI实现了代码的松耦合，掌握Spring的核心概念和使用方式，是开发企业级Java应用的基础。合理使用Spring的功能，可以提高代码的可维护性和可测试性。