Spring02：控制反转

本文为 SSM 框架系列之 Spring 第二部分：控制反转
其它内容的链接如下：
    1. HelloSpring
    2. 控制反转
    3. 依赖注入与装配机制
    4. 代理模式
    5. 面向切面编程
    6. 声明式事务

1 控制反转思想

接下来利用原来的 JavaEE 的三层架构来详细讲解 Spring 的控制反转思想。

1.1 原来的 Service 业务层逻辑

1.1.1 首先书写 Dao 层

1）确定接口

package sharm.dao;

public interface ApplicationDao {
    public void showName();
}

2）确定实现类

package sharm.dao;

public class ApplicationDaoQQImp implements ApplicationDao {

    @Override
    public void showName() {
        System.out.println("我是 QQ 大人，谁敢不从。");
    }
}

package sharm.dao;

public class ApplicationDaoTikTokImp implements ApplicationDao {

    @Override
    public void showName() {
        System.out.println("我是抖音大人，谁敢不从。");
    }
}

1.1.2 然后书写 Service 层

1）确定接口

package sharm.service;

public interface AppService {
    public void showName();
}

2）确定实现类

import sharm.dao.ApplicationDao;
import sharm.dao.ApplicationDaoQQImp;
import sharm.dao.ApplicationDaoTikTokImp;

public class AppServiceImp implements AppService {

    // 原来需要创建 Dao 对象
    ApplicationDao daoQQImp = new ApplicationDaoQQImp();
//    ApplicationDao daoTikTokImp= new ApplicationDaoTikTokImp();
    
    @Override
    public void showName() {
        daoQQImp.showName();
    }
}

1.1.3 测试

public class ServiceTest {
    @Test
    public void testService(){
        AppServiceImp appServiceImp = new AppServiceImp();
        appServiceImp.showName();
    }
}

这个时候，我们会发现，如果当用户想要输出另一个 Service 业务时，必须在 Service 层重新 new 一个对象，当业务数量多时，这并不轻松。

所以，出现了一个 IOC 思想，即控制反转思想：当用户更改需求时，程序员可以在不更改原有代码的前提下实现用户的需求。

1.2 控制反转思想

控制反转是一种设计思想，没有控制反转的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制。而控制反转则将对象的创建转移给第三方，使获得依赖对象的方式反转了。

控制反转是一种通过描述XML或注解，并通过第三方去生产或获取特定对象的方式。在 Spring 中实现控制反转的是 IOC 容器，其实现方法是依赖注入（DI）。

比如可以使用 setter 方法进行控制反转，如下：

在不改变 Dao 层代码的前提下，修改 Service 层代码：

package sharm.service;

import sharm.dao.ApplicationDao;
import sharm.dao.ApplicationDaoTikTokImp;

public class AppServiceImp implements AppService {
    ApplicationDao appDaoImp;
    // 不去实现它，而是利用 setter 方法实现
    public void setAppDaoImp(ApplicationDao appDaoImp) {
        this.appDaoImp = appDaoImp;
    }

    @Override
    public void showName() {
        appDaoImp.showName();
    }
}

测试：

public class ServiceTest {
    @Test
    public void testService(){
        AppServiceImp appServiceImp = new AppServiceImp();
        // 只需要在这部分修改业务
        appServiceImp.setAppDaoImp(new ApplicationDaoQQImp());

        appServiceImp.showName();
    }
}

这样就 OK 了，一切都是这么轻松自然。

 

---

2 Spring 的控制反转思想

在前面的代码中，加入 Spring 的配置文件：

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <!--bean 就是 java 对象 , 由 Spring 创建和管理。如果托管成功，原 pojo 类边会有一片叶子-->
    <!--id 指代的由 Spring 创建的对象名，class 为我们指定的 pojo 类-->
    <bean id="applicationDaoQQImp" class="sharm.dao.ApplicationDaoQQImp"/>
    <bean id="applicationDaoTikTokImp" class="sharm.dao.ApplicationDaoTikTokImp"/>
    <!--引用另一个 bean 用 ref 属性，同时该 bean 也已经被 Spring 托管了-->
    <bean id="appServiceImp" class="sharm.service.AppServiceImp">
        <property name="appDaoImp" ref="applicationDaoQQImp"/>
    </bean>
</beans>

测试代码为：

public class ServiceTest {
    @Test
    public void testService(){
        // 固定写法
        ApplicationContext context = new ClassPathXmlApplicationContext("sharm.pojo.spring.xml");
        // 得到对象，其中参数为对象名
        AppServiceImp appServiceImp = (AppServiceImp) context.getBean("appServiceImp");
        appServiceImp.showName();
    }
}

这个时候，用户都不需要面对程序，只需要修改 XML 配置文件即可。而配置文件是一个很灵活的东西，其当然可以直接让用户配置。

代码便是让世界上复杂的东西变得简单。

原来我们需要主动去创建一个对象，现在进行控制反转之后，通过给定某些名称，让 Spring 容器去主动的创建。