IOC的理论推导

导入依赖

<dependencies>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>4.0.9.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.2.0.RELEASE</version>
    </dependency>

</dependencies>

在我们之前的代码中，我们需要根据用户的需求去修改代码，如果程序十分庞大，修改起来会比较麻烦，修改一次的成本就十分昂贵

1.userDao接口

package com.yms.dao;

/**
 * @Author 杨明书
 * @PackageName: com.yms.dao
 * @ClassName: UserDao
 * @Description:
 * @Date: 2021/12/29 10:09
 */
public interface UserDao {
    void getUser();

}

2.userDaoImpl实现类

package com.yms.dao.impl;

import com.yms.dao.UserDao;

/**
 * @Author 杨明书
 * @PackageName: com.yms.dao.impl
 * @ClassName: UserDaoImpl
 * @Description:
 * @Date: 2021/12/29 10:10
 */
public class UserDaoImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("默认获取用户的数据");
    }
}

3.userService业务接口

package com.yms.service;

/**
 * @Author 杨明书
 * @PackageName: com.yms.service
 * @ClassName: UserService
 * @Description:
 * @Date: 2021/12/29 10:12
 */
public interface UserService {

    void  getUser();
}

4.userServiceImpl业务实现类

package com.yms.service.impl;

import com.yms.dao.UserDao;
import com.yms.dao.impl.UserDaoImpl;
import com.yms.service.UserService;

/**
 * @Author 杨明书
 * @PackageName: com.yms.service.impl
 * @ClassName: UserServiceImpl
 * @Description:
 * @Date: 2021/12/29 10:13
 */
public class UserServiceImpl implements UserService {
    /**
     * 程序控制对象，存在的弊端，使用一次就要去换取一次对象，代码冗余
     */
//    private  UserDao userDao=new UserDaoImpl();
    /**
     * 解决方案，使用set注入，是的每个用户拿到的数据都是一样的
     *
     */
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void getUser() {
        System.out.println("这是一个service实现类");
        userDao.getUser();

    }
}

5.测试类

import com.yms.dao.impl.UserDaoImpl;
import com.yms.dao.impl.UserDaoMysql;
import com.yms.dao.impl.UserDaoOracle;
import com.yms.service.UserService;
import com.yms.service.impl.UserServiceImpl;

/**
 * @Author 杨明书
 * @PackageName: PACKAGE_NAME
 * @ClassName: MyTest
 * @Description:
 * @Date: 2021/12/29 10:16
 */
public class MyTest {
    public static void main(String[] args) {
//        UserService userService = new UserServiceImpl();
//        userService.getUser();
//        UserDaoMysql mysql = new UserDaoMysql();
//        mysql.getUser();
//        UserDaoOracle userDaoOracle = new UserDaoOracle();
//        userDaoOracle.getUser();

        UserServiceImpl userService = new UserServiceImpl();
        userService.setUserDao(new UserDaoMysql());
        userService.getUser();


//        UserServiceImpl userService = new UserServiceImpl();
//        userService.getUser();


    }
}

我们使用set注入后，已经发生了革命性的变化

   /**
     * 程序控制对象，存在的弊端，使用一次就要去换取一次对象，代码冗余
     */
//    private  UserDao userDao=new UserDaoImpl();
    /**
     * 解决方案，使用set注入，是的每个用户拿到的数据都是一样的
     *
     */
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

总结：之前，程序是主动创建对象，控制权是在程序员手上

我们使用set注入后，程序不在拥有主动权，而是编程了被动的接受对象

这种思想称之为：控制反转IOC ，程序员不在去关注对象的创建，程序员可以专注于业务的实现！大大降低了耦合性，这就是ioc的原型。

控制反转是一种通过描述（xml或者注解） ，并通过第三方的生产活可获取特定的对象的方式，在spring中实现控制反转的是ioc容器，其实实现的方式就是依赖注入。