java IOC控制反转和依赖注入的理解，通俗易懂

朱雀 2021-05-03 09:40 525阅读 0赞

**什么是IOC？**

> IOC是 Inversion of Control的缩写，即控制反转
> 
> 。

**什么是控制反转？**

> 所谓控制反转就是把目标对象的控制权限由程序代码本身转移到外部容器控制；就是在传统的程序中我们是由设计类来操控目标对象的权利，而现在我们把这个权利转到外部容器，通过外部容器来实现对象的实列化和管理，这就是控制反转

**什么是依赖注入？**

> 依赖注入是控制反转实现的主要方式，依赖注入就是将目标对象的实例变量注入到调用该目标对象的对象中去

>   
>

**传统的编程方式：**

**    结构图：**

> 代码如下：
> 
> 目标对象1（ Floudy ）

````
public class SystemIoc {

private Aigent aigent = new Floudy();
    public void save(Object obj) {
        aigent.save(obj);
    }

}
````

> 
> 目标对象2（ Usb ）

````
public class Usb  implements Aigent{
    private Integer size;
    public void save(Object obj) {
        System.out.println("使用U盘存储  "+obj+"  数据！");
    }
}
````

> 接口（ Aigent ）

````
public interface Aigent {

void save(Object obj);

}
````

> 设计类（SystemIoc）

````
public class SystemIoc {

private Aigent aigent = new Floudy();
    public void save(Object obj) {
        aigent.save(obj);
    }
}
````

> 测试类（Test）

````
public class Test {
    
    public static void main(String[] args) {
        SystemIoc systemIoc = new SystemIoc();
        systemIoc.save("音乐");
    }
}
````

> **IOC的编程方式：**

> > 代码如下：
> > 
> > 目标对象1（ Floudy ）
> >

````
public class SystemIoc {
    
    private Aigent aigent = new Floudy();
    public void save(Object obj) {
        aigent.save(obj);
    }
}
````

> > 
> > 目标对象2（ Usb ）
> >

````
public class Usb  implements Aigent{

private Integer size;
    public void save(Object obj) {
        System.out.println("使用U盘存储  "+obj+"  数据！");
    }
}
````

> > 
> > 接口（ Aigent ）
> >

````
public interface Aigent {
    void save(Object obj);
}
````

> > 
> > 设计类（SystemIoc）

````
public class SystemIoc {

//只负责调用方法，失去控制权限,控制权限将由IOC容器实现，即xml配置文件，需要通过依赖注入来实现对象的注入
    private Aigent aigent;

public void save(Object obj) {
        aigent.save(obj);
    }
    public Aigent getAigent() {
        return aigent;
    }
    public void setAigent(Aigent aigent) {
        this.aigent = aigent;
    }
}
````

**依赖注入实现控制反转：**

applicationContext.xml配置文件（完成对象实列化）：

````
<beans>
    <bean id="cloud" class="com.svse.bean.Cloud">
        <property name="size" value="100"></property>
    </bean>
    <bean id="floppy" class="com.svse.bean.Floppy">
        <property name="size" value="100"></property>
    </bean>
    <bean id="usb" class="com.svse.bean.Usb">
        <property name="size" value="100"></property>
    </bean>
    <bean id="saveSystem" class="com.svse.bean.SaveSystem">
        <property name="saveGgent">
            <ref bean="floppy"/>
        </property>
    </bean>
</beans>
````

Test(测试类)：

````

public class Test {
    public static void main(String[] args) {
      //读取spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext(“applicationContext.xml”);
        SaveSystem saveSystem=(SaveSystem) context.getBean(“saveSystem”);
        saveSystem.save(“音乐”);
    }
}
````

**总结：**

> 控制反转和依赖注入可以理解为同一件事，因为他们都是把创建对象实列的控制权限交给容器来操作。控制反转是从代码操作对象角度来看，将操作对象的控制权交给了容器，而依赖注入是把需要的对象或属性注入到代码中去