思维导图：

1，什么是IOC？

1. 控制反转；

IOC（Inversion of Control），控制反转；是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度；

2. 常见方式；

其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），也是轻量级Spring框架的核心。

2，IOC实例讲解；

1，耦合实例：

我们定义一个Cat类：

package com.java.service;

public class Cat {
    public void test(){
        System.out.println("Cat-测试人员");
    }
}

接着来个Work类（调用Cat类）：

package com.java.service;

public class Work {
    public void dotest(){
        Cat cat=new Cat();
        //Cat做测试
        cat.test();
    }
}

测试类：

package com.java.test;

import com.java.service.Work;

public class WorkTest {
    public static void main(String[] args) {
        Work work=new Work();
        work.dotest();
    }
}

运行结果：

这是一个简单的类调用方法，但是这个Work和人Cat是完全耦合在一起的； 如果说我还有另外一个Dog也要参加测试，那么只能在Work里面进行再次修改代码; 这样代码的耦合度很高。

另外建一个Dog类：

package com.java.service;

public class Dog {
    public void test(){
        System.out.println("Dog-测试人员");
    }
}

当要Dog做测试时，只能在Work里面继续修改代码：

package com.java.service;

public class Work {
    public void dotest(){
        /*Cat cat=new Cat();
        //Cat做测试
        cat.test();*/
        Dog dog=new Dog();
        //Dog做测试
        dog.test();
    }
}

测试类代码不变：

package com.java.test;

import com.java.service.Work;

public class WorkTest {
    public static void main(String[] args) {
        Work work=new Work();
        work.dotest();
    }
}

运行结果：

分析一下，这样修改会改变很多代码，执行效率不高； 我们怎么样能修改一下这种实现的方式，让代码效率更高呢？

2，用接口实现，提高效率；

我们先来定义一个接口：

package com.java.service;

public interface Tester {
    public void test();
}

并让所有参与测试的人员继承这个接口：

package com.java.service;

public class Dog implements Tester{
    public void test(){
        System.out.println("Dog-测试人员");
    }
}

package com.java.service;

public class Cat implements Tester{
    public void test(){
        System.out.println("Cat-测试人员");
    }
}

然后我们在Work类里面定义一个对象Tester;

具体谁来测试我们在主函数里面设置；

package com.java.service;

public class Work {
    private Tester tester;

    public void setTester(Tester tester) {
        this.tester = tester;
    }

    public void dotest(){
        /*Cat cat=new Cat();
        //Cat做测试
        cat.test();*/
        /*Dog dog=new Dog();
        //Dog做测试
        dog.test();*/
        tester.test();
    }
}

主函数（可以设置谁来进行测试，比方说Cat）：

package com.java.test;

import com.java.service.Cat;
import com.java.service.Work;

public class WorkTest {
    public static void main(String[] args) {
        /*Work work=new Work();
        work.dotest();*/

        Work work=new Work();
        //将Cat设置为测试人员
        work.setTester(new Cat());
        work.dotest();
    }
}

运行结果：

这样就实现了控制反转！ 控制权在我们自己传入的对象里面，也就是在自己手里

但好像还是有点麻烦，于是乎，我们就来看看Spring中有什么更简单的方式吧~

3，Spring如何管理Bean；

那么，Spring是如何管理Bean的呢？

我们先在beans.xml配置文件里面写几个bean；

<?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.xsd">

    <!--通过id来标识类
    <bean id="helloWorld" class="com.java.test.HelloWorld"></bean>-->
    <bean id="cat" class="com.java.service.Cat"></bean>

    <bean id="dog" class="com.java.service.Dog"></bean>

    <bean id="work" class="com.java.service.Work">
        <!--这里的name对应的是Work类对应的tester，ref是指让谁去测试-->
        <property name="tester" ref="cat"></property>
    </bean>
</beans>

测试类：

注意这里的bean里面的id就是bean.xml配置文件的work；

package com.java.test;

import com.java.service.Work;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        //加载beans.xml文件，调用Spring接口
        ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml");
        //通过id获取bean，返回一个对象
        Work work=(Work)ac.getBean("work");
        //调用方法
        work.dotest();
    }
}

运行结果:

如果想换成Dog测试，那么直接修改bean.xml里面的ref值就可以了， 简单方便！ 你们看，用Spring来管理Bean，极大地降低了面向对象中代码的耦合度！