Spring中的IOC-CSDN博客

本文链接：https://blog.csdn.net/qq_34794716/article/details/120230910

本文介绍了Spring框架中的IoC（控制反转）理论，包括UserDao接口的实现，UserServices中依赖注入的两种方式，以及如何通过配置文件和代码示例来演示IoC的核心概念。通过实例说明IoC如何降低系统耦合，提高开发效率。

摘要由CSDN通过智能技术生成

Spring . IOC

1.1 IOC理论推导

1.UserDao接口

public interface UserDao {
    void getUser();
}

2.UserDaoImpl接口实现类

public class UserDaoImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("用户获取数据...");
    }
}

public class UserDaoMysqlImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("Mysql");
    }
}

3.UserServices业务接口

public interface UserServices {
    void getUser();
}

4.UserServicesImpl业务接口实现类

程序猿掌握主动权，程序主动创建对象（需要根据用户的需求修改底层代码，十分麻烦！！）

public class UserServicesImpl implements UserServices{
    //根据需要使用的业务创建对象
    private UserDao userDao = new UserDaoImpl();

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

将控制权交给用户，根据用户需求，程序被动的创建对象（使用set结构实现）

public class UserServicesImpl implements UserServices{

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

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

使用set方法的好处就是程序猿不再需要去管理对象的创建，全部交给用户端的需求，被动创建。
系统的耦合性大大的降低，程序猿可以更加卖力与业务动能的开发（真是头秃呀~）。
这种思想是IOC的原型。

1.2 IOC的本质

用结构图理解下：

控制反转(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IOC的一种方法。没有IOC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬解码在程序中，对象的创建由程序控制，控制反转后对象的创建移交于第三方，即获得依赖对象的方式反转了。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式把二者合二为一。Bean的定义信息直接以注解的形式定义在实现类中，实现零配置的目的。

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

1.3 HelloSpring

1.pojo的Hello类

package pojo;

public class Hello {
    private String name;

    public String getName() {
        return name;
    }
   //依赖注入使用set的实现方式
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "name='" + name + '\'' +
                '}';
    }
}

2.配置文件beans.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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--使用Spring来创建对象，在Spring中对象称为bean
    类型 对象名 = new 类型()；
    id = 对象名；
    class = new的类型
    property：给对象中的属性赋值
    -->
        
        <bean id="hello" class="pojo.Hello">
            <property name="name" value="spring"/>
        </bean>
</beans>

3.测试文件TestMain

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import pojo.Hello;

public class TestMain {
    public static void main(String[] args) {
        //获取ApplicationContext，获取Spring容器
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //从Spring容器获取对象(容器在手，天下我有！！)
        Hello hello = context.getBean("hello", Hello.class);
        System.out.println(hello.getName());
    }
}

上面这整个过程就叫做控制反转(还有点蒙圈中o(╥﹏╥)o......)