IoC（控制反转）的概述

1、Spring 号称是一个可以实现模块可插拔（轻量级）的 JavaEE 开发框架。那么它是如何实现程序的可插拔（轻量级）的呢？

答：实现程序的可插拔的核心理念就是控制反转（IoC：Inversion of Control），所谓的控制反转就是将代码的调用权（控制权）从调用放转移给被调用方（服务提供方）。

如图所示：

　　（1） 强耦合调用方式

　　将 A 调用 B 的对象修改为 C 类的对象，修改的是调用方的代码，所以我们认为代码的调用权在调用方。

　　（2） 基于 IoC（控制反转）的调用方式

　　将上图的需求，修改为使用 IoC 的调用代码方式。就是将代码的控制权从调用方修改为被调用方，意味着，代码的调用权转移给被调用方（我们也称为服务方），不用修改调用方的代码，只要修改配置文件就实现对象的切换。

　　如下图：将 A 类调用 B 类的对象修改为 C 类的对象，修改的是被调用方的配置文件的代码，所以代码的调用权转移到了被调用方。通过控制反转，我们可以实现增加模块或者移除模块统一由配置文件关联，所以增加或者移除模块配置 XML 配置文件即可。

　　我们将代码的调用权（控制权）从调用方转移给被调用方（服务提供方）的设计模式称为控制反转（IoC）。

　　根据上图可以得出，实现一个 IoC 的框架，必须要解决两个问题：

　　① 被调用方（服务方），在程序启动时就要根据配置文件类以及类与类的关系创建好对象，放在一个容器里面。

　　② 调用方使用一个接口或类的引用（不用使用 new），就可以创建获得对象。

　　我们将这种不用 new，而是根据接口或者类的引用就可以从被调用的容器里获得创建的对象的方式称为依赖注入。

　　所以   控制反转（IoC）= 依赖注入  +  面向接口的编程思想的实现

　　在这里，我们首先抓住一个重点：Spring 之所以可以实现可插拔程序，是实现了不用 new ，使用类或接口就可以获得对象。

2、基于 Spring 框架的 IoC 实现

　　（1）说明需求

　　　　CustomerClient 调用 CustomerService 的 save() 方法。将调用 CustomerServiceImpl 的对象实现的 save() 切换成调用 CustomerServiceImpl2 对象实现的 save().

　　　　注意：重点观察 CustomerClient，在切换过程中有没有修改该类的代码。

　　　　需求修改说明图：　 

　　如果将 CustomerClient 调用的 CustomerServiceImpl 的对象修改为 CustomerServiceImpl2 的对象，而不用修改 CustomerClient 的代码。那么说明代码的调用权从 CustomerClient 转移到了服务方。

　　（2）示例代码：

　　　　① CustomerService 接口代码：

package cn.mgy.service;

public interface CustomerService {
    /**
     * 保存方法
     */
    public void save();

}

　　　　② CustomerServiceImpl 子类：

package cn.mgy.service.impl;

import cn.mgy.service.CustomerService;

public class CustomerServiceImpl implements CustomerService{

    @Override
    public void save() {
        System.out.println("-保存客户-CustomerServiceImpl");
        
    }
}

　　　　③ CustomerServiceImpl2 子类：

package cn.mgy.service.impl;

import cn.mgy.service.CustomerService;

public class CustomerServiceImpl2 implements CustomerService{

    @Override
    public void save() {
        System.out.println("-保存客户-CustomerServiceImpl2");
        
    }
}

　　　　④  CustomerClient 类（调用方）：

package cn.mgy.client;

import cn.mgy.service.CustomerService;

public class CustomerClient {
    
    //1.声明一个父接口的引用
    private CustomerService customerService;

    //2.使用set方法注入对象，我们将通过方法注入的对象的方式称为依赖注入
    public void setCustomerService(CustomerService customerService) {
        this.customerService = customerService;
    }

    public void login(){
        //调用服务端的方法
        customerService.save();;
    }
}

　　　　⑤ 配置文件 applicationContext.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-4.2.xsd ">

<!-- <bean>标签：用于声明一个类,在启动Spring框架的时候根据该配置的类创建对象到容器里面 name -->
<!-- <bean name="customerServiceImpl" class="cn.mgy.service.impl.CustomerServiceImpl"></bean> -->
   <!-- 
   CustomerServiceImpl修改为CustomerServiceImpl2的配置
    -->
    <bean name="customerServiceImpl" class="cn.mgy.service.impl.CustomerServiceImpl2"></bean>

    <bean name="customerClient" class="cn.mgy.client.CustomerClient">
        <!-- 对应set方法关联的对象 customerService
                 name:关联对应的set方法，关联规则：xxx对应setXxx();如：customerService() 对应setCustomerService()
                 ref:指向容器中的对象
         -->
        <property name="customerService" ref="customerServiceImpl"></property>
    </bean>
</beans>

　　　　⑥ 测试代码：

package cn.mgy.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.mgy.client.CustomerClient;

public class ClientTest {
    

    @Test
    public void save(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        CustomerClient customerClient = context.getBean("customerClient", CustomerClient.class);
        //调用方法
        customerClient.login();
        
    }
}