Spring 框架学习（一）——IOC思想原型及实质

文章目录

Spring 框架学习（一）——IOC思想原型及实质
一、我们以前写业务代码的方式
二、用户更改需求，代码如何改动
三、IOC 思想原型
四、控制反转
五、IOC实质

Spring 框架学习（一）——IOC思想原型及实质

一、我们以前写业务代码的方式

1.UserDao 数据访问接口

package com.kuang.dao;

import java.util.List;
public interface UserDao {
    void selectAll();
}

2.UserDaoImpl Dao层实现类

package com.kuang.dao;

public class UserDaoImpl implements UserDao{
    public void selectAll() {
        System.out.println("获取了用户的数据!");
    }
}

3.UserService 业务接口

package com.kuang.service;

public interface UserService {
    void getUser();
}

4.UserServiceImpl 业务实现类

package com.kuang.service;
import com.kuang.dao.UserDao;
import com.kuang.dao.UserDaoImpl;

public class UserServiceImpl implements UserService {
    // 以前这个new Dao层实体类的代码都写到方法里面，也可以写到外面避免多次创建实例
    // 这里用到了 组合的方式
    
    private UserDao userDao = new UserDaoImpl();

    // 用户实际调用的是业务层，而不是Dao层
    // 业务层就做一个事情，调Dao层进行使用功能

    public void getUser() {
          userDao.selectAll();
    }

}

5.测试类用户使用业务功能

package com.kuang.test;
import com.kuang.service.UserService;
import com.kuang.service.UserServiceImpl;

public class Test {

 @org.junit.Test
    public void test(){
     UserService userService = new UserServiceImpl();
     userService.getUser();
    }
}

接口与具体实现类的分开有效的实现了解耦合，但是还不够方便。

举几个例子，来说明Sring为什么要使用IOC来实现控制反转，以及什么是控制反转

二、用户更改需求，代码如何改动

如果用户增加了一个使用Mysql获取用户数据的需求，在上述的方式下我们会怎么改呢？

1.创建一个其他的类实现UserDao接口，重写方法的具体代码

package com.kuang.dao;

public class UserDaoMySQLImpl implements UserDao{
    public void selectAll() {
        System.out.println("MySQL获取用户数据!");
    }
}

2.在UserServiceImpl 业务层具体实现的方法里面修改代码，使得UserDao的实现类更改成上面写的这个新的类

package com.kuang.service;
import com.kuang.dao.UserDao;
import com.kuang.dao.UserDaoMySQLImpl;

public class UserServiceImpl implements UserService {
    // 将接口实现的类 修改了
    private UserDao userDao = new UserDaoMySQLImpl();
    
    public void getUser() {
          userDao.selectAll();
    }
}

3.测试具体业务功能。

以上面这个例子可以说明一个问题：

上面的例子中，每次用户更改需求，我们都要在原代码的基础上进行修改，比如用户想要Orcale获取数据就要修改成new Orcale，想要SqlServer 获取用户数据，就要修改成 new SqlServer。

这个例子中修改的代码还不是很多，如果真实的项目中，代码量成千上万行，有几十个类，用户的需求增加或者更改，那么就需要在很多地方修改代码，非常麻烦，开发的效率很低

上述的方式写代码，适应不了用户的需求变更，用户需求变了，要立马修改原代码，非常不好。

所以就有了另外一种写代码的具体方式

三、IOC 思想原型

在业务具体实现类这里，变更写代码的方式

package com.kuang.service;
import com.kuang.dao.UserDao;

public class UserServiceImpl implements UserService {
    // 对属性不做具体的new，交给set接口来设置，控制权直接翻转
    private UserDao userDao;

    // 使用set的方式实现了值的动态注入
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void getUser() {
          userDao.selectAll();
    }
}

之前的方式是程序控制创建对象（通过new的方式定死了具体的实现对象）

现在是用户在使用不同需求时，通过set注入自己需要的对象即可实现需求。

package com.kuang.test;
import com.kuang.dao.UserDaoMySQLImpl;
import com.kuang.service.UserService;
import com.kuang.service.UserServiceImpl;

public class Test {

 @org.junit.Test
    public void test(){
     UserService userService = new UserServiceImpl();

     // 加了这一行代码，用户实现set注入自己的需要具体对象，不需要修改源代码中的任意一行
     ((UserServiceImpl)userService).setUserDao(new UserDaoMySQLImpl());
     
     userService.getUser();
    }
}

在之前的业务中，用户的需求可能会影响到我们之前写的代码，我们需要根据用户的需求去修改原代码。如果程序的代码量非常大，修改一次的成本非常大。

使用set接口实现，已经发生了革命性的变化（控制反转）

四、控制反转

之前程序是主动创建对象的，控制权在程序员手上，所以用户的每一个需求都会让我们改代码。

（程序员用过new来写死一个创建的对象）

使用set接口，程序不在具有主动性了，而是变成了被动的接收对象。

（使用set接口，原有的程序不用改变，用户只需要在使用的时候set一个需要的对象即可）

当用户的需求再次增加，我们只需要扩展一个类来实现之前的接口，写具体的业务代码，用户在使用的时候set注入扩展的类即可。使得程序扩展更加方便，大大降低了系统的耦合性，也使得程序员可以更加专注的写业务代码，不需要管理对象的创建了。

以上就是IOC思想的原型，Spring的IOC底层使用了大量的set方法实现各种对象注入，来解决以上的问题。

五、IOC实质

控制反转IOC（Inversion of Control）是一种设计思想，DI（依赖注入）是实现IOC的一种具体方式。

上面的例子就是说明了程序中获得依赖对象的方式反转了。之前面向对象编程中，对象的创建与对象之间的依赖关系完全的硬编码在程序中，对象的创建由程序员自己控制，控制反转后将对象的创建交给第三方容器来做。

早些年，各个对象之间都是耦合的，一层调一层，理想的是中间加一个中间件使得各个对象耦合降低，IOC就是降低各个对象耦合度的中间容器。

Spring 框架学习（一）——IOC思想原型及实质

文章目录