JAVA之IOC控制原理

1. IOC的基础知识背景：

IoC理论的背景：在采用面向对象方法设计的软件系统中，底层实现都是由N个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。这样对象和对象之间有着复杂的依赖关系，所以才有了控制反转这个理论。

2. 什么是IOC

IoC是Inversion of Control的缩写，翻译成“控制反转”，即控制不再有对象之间相互调用进行，而是有IOC容器进行，模块只需要做好自己就行。
如图：

3. 为什么要把这种方式叫做控制反转

对象之间互相依赖，调用时候控制权在我们手上，我们使用时候一个一个new，A—>B,B —>C,…（A调用B，B调用C，多起来了，你不就懵逼了么），如图：

小朋友，您是否有很多问号？？？

于是乎，如果软件系统引入了Ioc容器之后，对象之间失去了直接联系，IoC容器会主动创建一个对象B注入到对象A所需要的地方，获取对象由主动行为变成了被动行为，即把创建对象交给了IoC容器处理，控制权颠倒过来了，这就是控制反转的由来。

另外， IoC的别名：依赖注入（DI） : 即实现IOC的方法就是注入，由IoC容器在运行期间，动态地将某种依赖关系注入到对象之中。

4. IoC的原理

控制反转是spring框架的核心，也就是说，所有的组件都是被动的，所有的组件初始化和调用都由容器负责。组件处在一个容器当中，由容器负责管理。简单的来讲，就是由容器控制程序之间的关系，而非传统实现中，由程序代码直接操控，即在一个类中调用另外一个类。这也就是所谓“控制反转”的概念所在：控制权由应用代码中转到了外部容器，控制权的转移，即所谓反转。

5. Spring IoC中经常用到一个设计模式，即工厂模式

工厂模式是指：当应用程序中甲组件需要乙组件协助时，并不是在甲组件中直接实例化乙组件对象，而是通过乙组件的工厂获取，即该工厂可以生成某一类型组件的实例对象。在这种模式下，甲组件无需与乙组件以硬编码的方式耦合在一起，而只需与乙组件的工厂耦合，这样，解除了Bean之间的依赖关系。

大朋友，开始撸一下代码！

1. 创建一个接口

/**
 * 创建一个电子产品接口，包含两个方法，一个准备设备，一个链接设备
 */
public interface Electronic {
    public abstract void prepareDevice();
    public abstract void connectDevice();
}

2. 创建两个Bean，一个电脑类，一个鼠标类

public class Computer implements Electronic {
    @Override
    public void prepareDevice() {
        System.out.println("电脑准备好了");
    }

    @Override
    public void connectDevice() {
        System.out.println("电脑等待连接");
    }
}

public class Mouse implements Electronic {
    @Override
    public void prepareDevice() {
        System.out.println("鼠标准备好了");
    }

    @Override
    public void connectDevice() {
        System.out.println("鼠标连接电脑");
    }
}

3. 创建一个工厂

public class Factory {
    public Electronic getElectronic(String electronicName) throws Exception {
        if (electronicName.equals("computer")){
            return new Computer();
        }else if (electronicName.equals("mouse")){
            return new Mouse();
        }else {
            throw new IllegalArgumentException("让工厂生产的设备不存在，瞎鸡儿输入");
        }
    }
}

4. 测试方法

public class testFactory {
    public static void main(String[] args) throws Exception {
        // 先创建一个接口，默认为空
        Electronic electronic = null;
        // 进行工厂生产Computer, 注意转型
        electronic = (Electronic) new Factory().getElectronic("computer");
        // 对工厂的产品操作
        electronic.prepareDevice();
        electronic.connectDevice();

        // 进行工厂生产Mouse, 注意转型
        electronic = (Electronic) new Factory().getElectronic("mouse");
        // 对工厂的产品操作
        electronic.prepareDevice();
        electronic.connectDevice();
    }
}

结果如图：

6. 再回头看看我们spring中怎么使用

引用网上一个例子：https://www.cnblogs.com/jumpkin1122/p/11565282.html
1. 创建一个person类

public class Person {
    public void say(String str) {
        System.out.println(str);
    }
}

2. 配置xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="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-3.2.xsd">
            <bean id="person" class="com.test.spring.Person"></bean>
</beans>

3. 测试类进行测试

package com.test.spring;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class Person_Test {
    @Test
    /**
     * SpringIOC获取对象
     * <bean id="person" class="com.test.spring.person">
     */
    public void test01() {
        //创建Spring容器对象
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //通过我们配置文件中面配置的beanid来获取对象:id="person"
        // 这儿其实就是用到了工厂，通过context工厂，用getBean方法，传入参数，得到创建的对象，同时转型
        Person p = (Person)context.getBean("person");
        //调用对象的方法，并传人参数
        p.say("Hello SpringIOC");
        p.say("Spring控制反转");
    }
}

7.小朋友，你的问号应该没了吧！

经过以上方法对比，我相信会更好的理解springIOC中的原理，还有工厂模式的使用。各位看官，若有问题，恳请指正。