Spring IOC和DI

2023-12-24 18:05:46

什么是IOC & DI

IOC（Inversion of Control 控制反转）即“控制反转”，它是一种设计思想，是面向对象编程中的一种设计模式。其最常见的方式叫做DI（Dependency Injection 依赖注入），通过控制反转，将实例化对象的控制权，由手动的new变成了Spring框架通过反射机制实例化。

DI（Dependency Injection 依赖注入）即"依赖注入"，就是由容器动态的将某个依赖注入到组件中。需要使用的时候，依赖通过配置文件以及注解的方式注入到对象中。

DI 可以看作是 IOC 的一种实现方式，IOC 是一种思想，而 DI 是一种设计模式，是一种实现 IOC 的模式。

项目常用后端代码结构 如下图所示：

Spring IOC和DI
以查询User数据为例对比IOC的引入前后程序耦合性

引入IOC之前

代码实现

User模块实体类：User.java

package entity;

public class User {
    private Integer id;
    private String name;
    private Integer gender;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getGender() {
        return gender;
    }

    public void setGender(Integer gender) {
        this.gender = gender;
    }
}

Spring IOC和DI

User模块视图类：UserVo.java

package vo;

import entity.User;

public class UserVo {
    private Integer id;
    private String name;
    private Integer gender;
    private String genderName;

    // 省略getter&setter方法
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getGender() {
        return gender;
    }

    public void setGender(Integer gender) {
        this.gender = gender;
    }

    public String getGenderName() {
        return genderName;
    }

    public void setGenderName(String genderName) {
        this.genderName = genderName;
    }

    public UserVo() {
    }
    public UserVo(User user) {
        this.id = user.getId();
        this.name = user.getName();
        this.gender = user.getGender();
    }

    // 省略toString方法
    @Override
    public String toString() {
        return "UserVO{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", gender=" + gender +
                ", genderName='" + genderName + '\'' +
                '}';
    }

}

Spring IOC和DI
Spring IOC和DI

User模块Dao层：UserDao.java

package dao;

import entity.User;

public interface UserDao {
    User getEntity(Integer id);
}

Spring IOC和DI

User模块Dao层实现类：UserDaoImpl.java

package dao.impl;

import dao.UserDao;
import entity.User;

public class UserDaoImpl implements UserDao {
    public User getEntity(Integer id) {
        // 此处应该从数据库查询值 方便起见直接返回一个固定对象
        User user = new User();
        user.setId(1);
        user.setName("Anne");
        user.setGender(0);
        return user;
    }
}

Spring IOC和DI

User模块Service层：UserService.java

package services;

import vo.UserVo;

@Service
public interface UserService {
    UserVo getVo(Integer id);
}

Spring IOC和DI
User模块Service层实现类：UserServiceImpl.java

package services.impl;

import dao.UserDao;
import dao.impl.UserDaoImpl;
import entity.User;
import vo.UserVo;

public class UserServiceImpl implements UserService {
   private UserDao userDao;

    public UserVo getVo(Integer id) {
        // 手动实例化Dao
        userDao = new UserDaoImpl();
        // 执行Dao层方法
        User user = userDao.getEntity(id);
        // 省略业务逻辑处理。。。
        UserVo userVo = new UserVo(user);
       userVo.setGenderName(userVo.getGender() == 0 ? "female" : "male");
        return userVo;
    }
}

Spring IOC和DI

TIPS:

1.if…else
if (判别式) {
代码块1
} else {
代码块2
} 2.三目运算符
一般形式为:
表达式1?表达式2:表达式3;
如果表达式结果为真，会执行表达式2，若为假执行表达式3

User模块Controller层：UserController.java
Spring IOC和DI
User模块测试类：UserTest.java
Spring IOC和DI

测试结果

Spring IOC和DI
缺点分析
1.代码耦合性太强 不利于程序的测试；
2. 代码也不利于扩展。

解决方式：
对象的实例化由Spring框架加载实现，放到Spring容器中管理，避免了我们手动new对象，有需要用到对象实例依赖，直接向Spring容器要，让它注入即可。从而降低代码的耦合，提升扩展性。

引入IOC(XML)

代码实现

使用SpringIOC首先需要导入Spring框架基础包并且添加Spring核心配置文件，将依赖交给Spring的beanFactory管理。
Spring IOC和DI
User模块测试类：UserTest.java

1、读取配置文件刷新Spring容器；
2、Controller由手动实例化改为从Spring容器拿取；
3、把ApplicationContext传到Controller层继续使用。

import controller.UserController;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import vo.UserVo;

public class UserTest {
    public static void main(String[] args) {
        // 手动实例化Controller
//        UserController userController = new UserController();
        // 执行Controller层方法
//        UserVo userVo = userController.getVo(1);
//        System.out.println(userVo);

        // 读取配置文件刷新Spring容器
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        // 从Spring容器拿Controller
        UserController userController = (UserController) context.getBean("userController");
        // 执行Controller层方法，因为之后还需要用到context对象，故下传
        UserVo userVo = userController.getVo(1, context);
        System.out.println(userVo);
    }
}

User模块Controller层：UserController.java

1、Service由手动实例化改为从Spring容器拿取；
2、把ApplicationContext传到Service层继续使用。
Spring IOC和DI

User模块Service层实现类：UserServiceImpl.java

Dao由手动实例化改为从Spring容器拿取
Spring IOC和DI

测试结果

Spring IOC和DI
缺点分析
因为每一个类的实例化都需要一个bean标签，一个大型工程有很多类，配置文件的内容未免过于臃肿，维护成本高。

解决方式
使用注解形式实现SpringIOC

XML改注解(IOC)

核心配置文件修改

context-component-scan标签启动包扫描功能，通过base-package属性指明需要被自动扫描实例化的类所在位置。

如下代码所示，我们在dao、services、controller下的类是需要扫描自动注入容器的

<?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:util="http://www.springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/util
        https://www.springframework.org/schema/util/spring-util.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
       ">

    <!-- bean definitions here -->
    <!-- 将指定类配置给Spring，让Spring创建其对象的实例 -->
<!--    <bean id="userDao" class="dao.impl.UserDaoImpl"/>-->
<!--    <bean id="userService" class="services.impl.UserServiceImpl"/>-->
<!--    <bean id="userController" class="controller.UserController"/>-->

    <context:component-scan base-package="dao"/>
    <context:component-scan base-package="services"/>
    <context:component-scan base-package="controller"/>


</beans>

运行项目发现context.getBean()代码报错
Spring IOC和DI
说明不是在base-package下的所有类都会自动注入到容器，而是要搭配注解使用。

常用注解介绍
@Component：一般用于通用组件类上使用的注解
@Service：一般用于业务逻辑层上使用的注解
@Controller：一般用于流程控制层上使用的注解
@Repository：一般用于数据持久层上使用的注解

其实我们在添加注解后，Spring会默认给每个bean设置id，值为类名首字母改为小写。
Spring IOC和DI
Spring IOC和DI

测试结果

Spring IOC和DI

引入DI

常用注解介绍
@Autowired注解自动按照类型注入。当使用注解注入属性时，set方法可以省略。它只能注入其他bean类型。当有多个类型匹配时，使用时要注入的对象变量名称作为bean的id，因为按照类型匹配，如果找不到匹配的实例也会抛出异常。

@Qualifier注解作用是在按照类型注入的基础之上，再按照Bean的id注入。所以如果是使用了@Autowire注解自动注入，但是容器中却有多个匹配的实例，可以搭配此注解，指定需要注入的实例id。简单来说，@Qualifier限定哪个bean应该被自动注入。

@Resource注解作用是指定依赖按照id注入，还是按照类型注入。当只使用注解但是不指定注入方式的时候，默认按照id注入，找不到再按照类型注入。

代码实现

User模块Controller层：UserController.java
Spring IOC和DI
User模块Dao层实现类：UserDaoImpl.java
Spring IOC和DI
User模块Service层实现类：UserServiceImpl.java
Spring IOC和DI
Spring IOC和DI

测试结果

Spring IOC和DI

表示

@Autowired注解已将UserService依赖自动注入UserController
@Qualifier注解已指定UserDao依赖的bean id，并使用@Autowired注解自动注入UserServiceImpl

上一篇：实验4：开源控制器实践——OpenDaylight


下一篇：PHP的依赖注入(DI) 和 控制反转(IoC)