java八股文IOC - 技术栈

IOC

简介:IOC称为控制反转,将依赖对象注入当前对象,当前对象没有对依赖对象的控制,实现代码之间的解耦,控制反转不是一种技术，而是一种设计思想。

传统开发：你（程序员）手动创建对象、管理对象之间的依赖关系（比如在 A 类里 new B() 来调用 B 的方法），控制权在你手里。

IOC 思想：把创建对象、管理依赖的控制权 "反转" 出去，交给一个统一的 "容器"（比如 Spring IOC 容器）来管理。你只需要告诉容器 "需要什么"，容器会主动把对象（Bean）给你，无需手动 new。

IOC的实现

1.构造器注入

java 复制代码

//创建一个水杯类
class Cup{
    public void holdCup(){
        System.out.println("水杯装水");
    }
}
//人喝水,构造器注入
class Person{
    private Cup cup;
    //构造器注入依赖
    public Person(Cup cup){
        this.cup=cup;
    }
    public void drinkWater(){
        cup.holdCup();
        System.out.println("人喝水");
    }
}
//IOC容器,将创建Peeson对象需要的依赖注入
class IocContainer{
    public static Cup getCup(){
        return new Cup() ;
    }
    public static Person getPerson(){
        return new Person(getCup());
    }
}
public class IOC {
    public static void main(String[] args) {
        // 直接从容器拿对象，无需关心创建和依赖
        Person person=IocContainer.getPerson();
        person.drinkWater();

        //没有Ioc容器原本需要创建对象和依赖注入
        Cup cup=new Cup();
        Person person1=new Person(cup);
        person1.drinkWater();
    }
}

2.Setter 方法注入

java 复制代码

class Person {
    private Cup cup;
    
    // Setter方法注入
    public void setCup(Cup cup) {
        this.cup = cup;
    }
    
    public void drinkWater() {
        cup.holdWater();
        System.out.println("喝水");
    }
}

// 容器中注入方式
class IocContainer {
    public static Person getPerson() {
        Person person = new Person();
        person.setCup(getCup()); // Setter注入
        return person;
    }
    
    public static Cup getCup() {
        return new Cup();
    }
}

3.注解注入(spring中常用)

Spring 框架中通过@Component（标记 Bean）、@Autowired（自动注入）实现IOC：

java 复制代码

package com.example.demo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.stereotype.Component;

@Component
//创建一个水杯类
class Cup{
    public void holdCup(){
        System.out.println("水杯装水");
    }
}
@Component
//人喝水,构造器注入
class Person{
    @Autowired
    private Cup cup;
    //构造器注入依赖
    public void drinkWater(){
        cup.holdCup();
        System.out.println("人喝水");
    }
}
//IOC容器,将创建Peeson对象需要的依赖注入

public class IOC {
    public static void main(String[] args) {
        ApplicationContext context=new AnnotationConfigApplicationContext("com.example.demo");
        Person person= context.getBean(Person.class);
        person.drinkWater();
    }
}

总结

IOC 的核心优势：

1.降低耦合：类不再依赖具体的实现类，而是依赖容器注入的对象，修改实现类无需改动业务代码。

2.便于测试：可以轻松注入模拟对象（Mock），方便单元测试。

3.提高复用性：对象由容器统一管理，可重复使用。

4.简化配置：Spring 容器统一管理对象的生命周期和依赖，无需手动维护。

IOC 核心：将对象的创建、依赖管理从代码转移到外部容器，实现 "控制反转"。

实现方式：依赖注入（DI），包括构造器注入、Setter 注入、注解注入（Spring 主流）。

核心价值：降低代码耦合度，提高代码可维护性和可测试性，是 Spring 框架的基础。