Spring IOC（控制反转）详解
一、什么是 IOC
IOC（Inversion of Control，控制反转）是一种设计思想，不是什么技术实现。它指的是将对象的创建、管理和依赖关系的控制权从程序代码本身转移到外部容器（Spring 容器）。
传统方式 vs IOC
传统方式（程序控制）：
publicclassUserService{privateUserDaouserDao=newUserDao();// 自己创建依赖对象publicvoidaddUser(){userDao.save();}}IOC 方式（容器控制）：
publicclassUserService{@AutowiredprivateUserDaouserDao;// 容器注入依赖对象publicvoidaddUser(){userDao.save();}}二、IOC 的核心概念
1. 控制反转
- 控制：指对象创建、依赖管理的控制权
- 反转：从程序代码反转到外部容器
2. 依赖注入（DI，Dependency Injection）
DI 是 IOC 的实现方式，指容器在创建对象时，自动将依赖对象注入到目标对象中。
3. IOC 容器
Spring 提供的容器实现，负责管理 Bean 的生命周期和依赖关系。
三、Spring IOC 容器
1. 两个核心接口
// BeanFactory：基础容器，提供基本的 IOC 功能publicinterfaceBeanFactory{ObjectgetBean(Stringname);<T>TgetBean(Class<T>requiredType);booleancontainsBean(Stringname);// ...}// ApplicationContext：高级容器，扩展了更多功能publicinterfaceApplicationContextextendsBeanFactory{// 国际化支持StringgetMessage(Stringcode,Object[]args,Localelocale);// 资源加载ResourcegetResource(Stringlocation);// 事件发布voidpublishEvent(ApplicationEventevent);// ...}2. 常见的实现类
// 1. ClassPathXmlApplicationContext：从类路径加载配置ApplicationContextcontext=newClassPathXmlApplicationContext("applicationContext.xml");// 2. FileSystemXmlApplicationContext：从文件系统加载配置ApplicationContextcontext=newFileSystemXmlApplicationContext("D:/config/applicationContext.xml");// 3. AnnotationConfigApplicationContext：基于注解的配置ApplicationContextcontext=newAnnotationConfigApplicationContext(AppConfig.class);// 4. WebApplicationContext：Web 应用专用// 在 Spring Boot 中自动创建四、Bean 的定义方式
1. XML 配置方式
<?xml version="1.0" encoding="UTF-8"?><beansxmlns="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"><!-- 定义 Bean --><beanid="userService"class="com.example.UserService"><!-- 构造器注入 --><constructor-argref="userDao"/><!-- 属性注入 --><propertyname="name"value="张三"/></bean><beanid="userDao"class="com.example.UserDao"/></beans>2. 注解方式（推荐）
// 1. @Component：通用组件@ComponentpublicclassUserService{@AutowiredprivateUserDaouserDao;}// 2. @Service：服务层@ServicepublicclassUserService{@AutowiredprivateUserDaouserDao;}// 3. @Repository：数据访问层@RepositorypublicclassUserDao{publicvoidsave(){// ...}}// 4. @Controller：控制层@ControllerpublicclassUserController{@AutowiredprivateUserServiceuserService;}// 5. @Configuration：配置类@Configuration@ComponentScan("com.example")publicclassAppConfig{@BeanpublicUserServiceuserService(){returnnewUserService(userDao());}@BeanpublicUserDaouserDao(){returnnewUserDao();}}五、依赖注入的方式
1. 构造器注入（推荐）
@ServicepublicclassUserService{privatefinalUserDaouserDao;// Spring 4.3+ 单个构造器可省略 @Autowired@AutowiredpublicUserService(UserDaouserDao){this.userDao=userDao;}}优点：
- 保证依赖不可变（final）
- 保证对象初始化完成
- 更容易测试
2. Setter 注入
@ServicepublicclassUserService{privateUserDaouserDao;@AutowiredpublicvoidsetUserDao(UserDaouserDao){this.userDao=userDao;}}优点：
- 灵活，可以在运行时修改
- 适合可选依赖
3. 字段注入
@ServicepublicclassUserService{@AutowiredprivateUserDaouserDao;}缺点：
- 不能使用 final
- 容易导致空指针
- 不利于测试
4. 方法注入
@ServicepublicclassUserService{privateUserDaouserDao;@Autowiredpublicvoidinit(UserDaouserDao){this.userDao=userDao;}}六、Bean 的作用域
// 1. singleton（默认）：单例，整个容器只有一个实例@Scope("singleton")publicclassUserService{}// 2. prototype：原型，每次获取都创建新实例@Scope("prototype")publicclassUserService{}// 3. request：Web 应用，每个请求一个实例@Scope(value=WebApplicationContext.SCOPE_REQUEST,proxyMode=ScopedProxyMode.TARGET_CLASS)publicclassUserService{}// 4. session：Web 应用，每个会话一个实例@Scope(value=WebApplicationContext.SCOPE_SESSION,proxyMode=ScopedProxyMode.TARGET_CLASS)publicclassUserService{}// 5. application：Web 应用，ServletContext 生命周期@Scope(value=WebApplicationContext.SCOPE_APPLICATION,proxyMode=ScopedProxyMode.TARGET_CLASS)publicclassUserService{}七、Bean 的生命周期
@ComponentpublicclassUserServiceimplementsBeanNameAware,BeanFactoryAware,ApplicationContextAware,InitializingBean,DisposableBean{// 1. 实例化（构造器）publicUserService(){System.out.println("1. 实例化");}// 2. 设置属性@AutowiredprivateUserDaouserDao;// 3. BeanNameAware@OverridepublicvoidsetBeanName(Stringname){System.out.println("3. BeanNameAware.setBeanName: "+name);}// 4. BeanFactoryAware@OverridepublicvoidsetBeanFactory(BeanFactorybeanFactory){System.out.println("4. BeanFactoryAware.setBeanFactory");}// 5. ApplicationContextAware@OverridepublicvoidsetApplicationContext(ApplicationContextapplicationContext){System.out.println("5. ApplicationContextAware.setApplicationContext");}// 6. BeanPostProcessor - 前置处理@PostConstructpublicvoidpostConstruct(){System.out.println("6. @PostConstruct");}// 7. InitializingBean@OverridepublicvoidafterPropertiesSet(){System.out.println("7. InitializingBean.afterPropertiesSet");}// 8. 自定义初始化方法@Bean(initMethod="init")publicvoidinit(){System.out.println("8. 自定义初始化方法");}// Bean 可以使用了// 9. PreDestroy@PreDestroypublicvoidpreDestroy(){System.out.println("9. @PreDestroy");}// 10. DisposableBean@Overridepublicvoiddestroy(){System.out.println("10. DisposableBean.destroy");}// 11. 自定义销毁方法@Bean(destroyMethod="cleanup")publicvoidcleanup(){System.out.println("11. 自定义销毁方法");}}八、IOC 容器启动流程
// 1. 创建容器ApplicationContextcontext=newAnnotationConfigApplicationContext(AppConfig.class);// 内部流程：// 1.1 扫描配置类，解析 Bean 定义// 1.2 注册 Bean 定义到 BeanDefinitionRegistry// 1.3 实例化单例 Bean（非懒加载）// 1.4 执行依赖注入// 1.5 执行初始化回调// 1.6 容器启动完成九、自动装配（@Autowired）
1. 按类型装配
@AutowiredprivateUserDaouserDao;// 按类型查找2. 按名称装配
@Autowired@Qualifier("userDaoImpl")// 指定 Bean 名称privateUserDaouserDao;3. 可选依赖
@Autowired(required=false)// 不存在也不报错privateUserDaouserDao;4. 集合注入
@AutowiredprivateList<UserDao>userDaoList;// 注入所有 UserDao 类型@AutowiredprivateMap<String,UserDao>userDaoMap;// Bean名称 -> Bean实例十、条件化注册 Bean
// 1. @Conditional@ConfigurationpublicclassAppConfig{@Bean@Conditional(WindowsCondition.class)// 满足条件才注册publicUserServicewindowsService(){returnnewWindowsService();}@Bean@Conditional(LinuxCondition.class)publicUserServicelinuxService(){returnnewLinuxService();}}// 2. 常用条件注解@ConditionalOnClass(DataSource.class)// 类路径存在@ConditionalOnMissingBean(DataSource.class)// 容器中不存在@ConditionalOnProperty(name="app.enabled",havingValue="true")// 配置属性@ConditionalOnExpression("${app.enabled:true}")// SpEL 表达式十一、IOC 的优势
1. 解耦
// 不再需要手动创建和管理对象// 对象之间的关系由容器维护2. 便于测试
// 可以轻松注入 Mock 对象@TestpublicvoidtestUserService(){UserDaomockDao=mock(UserDao.class);UserServiceservice=newUserService(mockDao);// 测试...}3. 配置化管理
// 通过配置文件或注解管理对象// 便于维护和修改4. AOP 支持
// IOC 容器管理对象，便于实现 AOP@Aspect@ComponentpublicclassLoggingAspect{@Before("execution(* com.example.*.*(..))")publicvoidlogBefore(){// ...}}十二、总结
Spring IOC 的核心价值：
- 控制反转：将对象创建和依赖管理的控制权交给容器
- 依赖注入：容器自动将依赖注入到目标对象
- 松耦合：对象之间通过接口依赖，降低耦合度
- 易测试：便于单元测试和集成测试
- 易维护：集中管理对象，便于配置和修改
最佳实践：
- 优先使用构造器注入
- 使用注解配置（@Component、@Service 等）
- 合理使用 Bean 的作用域
- 理解 Bean 的生命周期，合理使用初始化和销毁回调
- 避免循环依赖，必要时使用 @Lazy
Spring IOC 是 Spring 框架的基石，理解它对于掌握 Spring 至关重要！
)
