Sping-IOC理论推导

2、IOC理论推导

2.1 IOC原型

• 使用原来的方式实现
• 第一步 ：编写UseDAO接口

package dao;

public interface UseDao {
    void getUser();
}

• 第二步 ：编写UseDao的实现类

//实现类 一
package dao;

public class UserDaoImpl implements UseDao{
    @Override
    public void getUser() {
        System.out.println("获取默认用户");
    }
}
//实现类二
package dao;

public class UserDaoMysql implements UseDao{
    @Override
    public void getUser() {
        System.out.println("获取mysql用户");
    }
}

• 第三步 ：编写UserService 接口

package service;

public interface UserService {
    void   getUser();
}

• 第四步 ：编写UserService的实现类

package service;

import dao.UseDao;
import dao.UserDaoImpl;
import dao.UserDaoMysql;

public class UserServiceImpl implements UserService{
    /*业务层调用数据层*/
    private UseDao useDao = new UserDaoMysql();

    @Override
    public void getUser() {
        useDao.getUser();
    }
}

• 第五步 ：测试

package dao;

import org.junit.Test;
import service.UserServiceImpl;

public class MyTest {
    @Test
    public void test(){
         UserServiceImpl userService = new UserServiceImpl();
         userService.getUser();
    }
}

• 第六步 ：发现弊端
  • 如果要开发一个新的业务 就需要 新建一个实现UserDao接口的实现类 并在UserService接口实现类下修改对应的实现（第四步中 第十行代码）耦合度过高每次修改需要修改大量的代码牵一发而动全身
• 第七步 ：解决方案
  • 可以在UserService接口实现类下预留一个接口[比较第四步]

package service.impl;

import dao.UserDao;
import dao.impl.UserDaoImpl;
import dao.impl.UserMysqlImpl;
import service.UserService;

public class UserServiceImpl implements UserService {

     private UserDao userDao ;
    /*使用预留的接口 利用set进行注入*/
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void getUser() {
        userDao.getUser();
    }
}

• 第八步 ：再次测试

package dao;

import dao.impl.UserMysqlImpl;
import org.junit.Test;
import service.impl.UserServiceImpl;

public class UserTest {
    @Test
    public void test(){
        /*用户实际调用的是业务逻辑层*/
         UserServiceImpl service = new UserServiceImpl();
         /*降低耦合*/
         service.setUserDao(new UserMysqlImpl());
         service.getUser();
    }
}

2.2 IOC本质

• 控制反转IOC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法。
  • 控制反转个人认为就是将控制权让出去由本来的自动创建对象到现在的被动接受对象（减少了硬编码 提高了灵活性）[参考2.1 中的第四步与第七步]
  • 控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。