【Spring】学习笔记02 —— IOC 控制反转

最新推荐文章于 2024-07-18 15:34:18 发布

小谷围最靓的仔

最新推荐文章于 2024-07-18 15:34:18 发布

阅读量185

点赞数

分类专栏： Spring 文章标签： spring

本文链接：https://blog.csdn.net/qq_41338341/article/details/116261225

版权

Spring 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

本文深入探讨了IoC（控制反转）的概念，通过实例展示了传统业务实现方式的问题，解释了如何通过依赖注入（DI）来降低耦合性。介绍了Spring框架中的IOC核心，包括XML配置和注解实现，以及对象创建的不同方式。最后，文章通过代码演示了Spring如何通过配置文件管理对象，实现对象的创建、管理和装配。

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

1. IOC 雏形

原始的业务实现方式

我们原来的业务实现步骤是这样的：

UserDao 接口
UserDaoImpl 实现类
UserService 业务接口
UserService 实现类

我们先用原来的方式编写一个简单的例子，如下：

1、编写一个 UserDao 接口。

public interface UserDao {
    public void getUser();
}

2、编写 UserDao 的实现类

public class UserDaoImpl implements UserDao{

    @Override
    public void getUser() {
        System.out.println("默认获取用户数据");
    }
}

3、编写 UserService 业务接口

public interface UserService {
    public void getUser();
}

4、编写 UserService 业务实现类

public class UserServiceImpl implements UserService{

    private UserDao userDao = new UserDaoImpl();

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

5、测试

public class MyTest {
    public static void main(String[] args) {

        // 用户实际调用的是业务层，不需要接触 dao 层
        UserService userService = new UserServiceImpl();
        userService.getUser();
    }
}

测试结果：

默认获取用户数据

以上就是我们原来编写业务代码的方式，很典型的基于 MVC 模型的开发方式。

原始方式存在的问题

假设现在新增需求，我们需要增加一个新的 UserDao 接口的实现类，代码如下：

public class UserDaoMysqlImpl implements UserDao {

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

我们要使用这个新增的 UserDao 实现类，就得去修改 UserService 实现类中相应的代码：

public class UserServiceImpl implements UserService{

    private UserDao userDao = new UserDaoMysqlImpl();

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

好了，现在我们又要加需求，又添加一个 UserDao 的实现类，代码如下：

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

然后又得去修改 UserService 实现类中相应的代码。

很显然，这种设计的耦合性太高了。用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改源代码，如果程序的代码量十分庞大，那修改一次的成本代价十分昂贵。

解决方法

我们可以在需要用到 UserDao 的地方（也就是例子中的 UserService 实现类），不去实例化它，而是只声明，利用 set() 来实例化。修改如下：

public class UserServiceImpl implements UserService{

    private UserDao userDao;

    // 利用 set() 实现
    public void setUserDao(UserDao userDao){
        this.userDao = userDao;
    }

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

测试代码修改如下：

public class MyTest {
    public static void main(String[] args) {
        // 用户实际调用的是业务层，不需要接触 dao 层
        UserServiceImpl userService = new UserServiceImpl();

        userService.setUserDao(new UserDaoImpl());
        userService.getUser();

        // 加了新需求
        userService.setUserDao(new UserDaoMysqlImpl());
        userService.getUser();
    }
}

不晓得大家发现区别没，使用 set() 方法后，程序发生了根本性的变化！

以前，是程序主动创建对象，控制权在程序员手上。
现在，使用 set() 注入之后，程序不再具有主动性，而是变成了被动的接受对象，控制权在调用者手上。

这种思想，从本质上解决了问题，我们程序员不用再去管理对象的创建了，更多地关注业务的逻辑实现，系统的耦合性大大地降低，这就是 IOC 的原型！！！

2. IOC 本质

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

控制：传统 Java SE 程序设计，我们直接在程序内部通过 new 进行创建对象，是程序主动去创建依赖对象；IOC 程序中，是专门由一个容器来创建这些对象，即由容器来控制对象的创建；
反转：程序本身不创建对象 , 而变成被动的接收对象。

依赖注入 : 就是利用 set() 方法来进行注入的。

IOC 是 Spring 框架的核心内容，可以通过 XML 配置或者注解来实现 IOC，新版本的 Spring 也可以零配置实现 IOC（自动装配）。

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

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

Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从 IOC 容器中取出需要的对象。
在这里插入图片描述

3. 通过代码来理解 IOC 的作用

1、先创建一个空白的 Maven 项目，pom.xml 中添加如下依赖：

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>

2、在 java 目录下新建 pojo 包，编写 Hello.java 实体类。

public class Hello {

    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Hello{ str = " + str + " }";
    }
}

3、在 resources 目录下新建配置文件 applicationContext.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <!--使用 Spring 来创建对象，在 Spring 中一个 bean 是一个实例对象-->
    <!--
        id ===> 实例对象名
        class ===> 类所在的路径，是哪一个类的实例对象
        property 标签用来设置属性
        name ===> 成员变量名
        value ===> 变量的值
    -->
    <bean id="hello" class="pojo.Hello">
        <property name="str" value="我想吃冰淇淋"/>
    </bean>
</beans>

4、编写测试代码

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

public class MyTest {
    public static void main(String[] args) {
        // 获取 Spring 的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 我们的对象现在都在 Spring 中的管理了，我们要使用，直接去里面取出来就行
        Hello hello = (Hello)context.getBean("hello");
        System.out.println(hello.toString());
    }
}

输出结果：

Hello{ str = 我想吃冰淇淋 }

修改文章开头提到的原始方式的例子

新增一个 applicationContext.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--使用 Spring 来创建对象，在 Spring 中一个 bean 是一个实例对象-->
    <!--
        id ===> 实例对象名
        class ===> 类所在的路径，是哪一个类的实例对象
        property 标签用来设置属性
        name ===> 成员变量名
        value ===> 变量的值
    -->
    <bean id="mysqlImpl" class="dao.UserDaoMysqlImpl"/>
    <bean id="oracleImpl" class="dao.UserDaoOracleImpl"/>
    
    <bean id="userServiceImpl" class="service.UserServiceImpl">
        <!--
            ref: 引用 Spring 容器中创建的对象
            value: 具体的值，基本数据类型
        -->
        <property name="userDao" ref="mysqlImpl"/>
    </bean>
</beans>

测试代码修改如下：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.UserServiceImpl;

public class MyTest {
    public static void main(String[] args) {
        // 获取 Spring 容器
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 容器在手，天下我有！
       UserServiceImpl service = (UserServiceImpl)context.getBean("userServiceImpl");

       service.getUser();
    }
}

至此，我们不用再在程序中改动，要实现不同的操作，只需要在 xml 配置文件中进行修改。所谓的 IOC，一句话概括，就是对象由 Spring 来创建、管理和装配！

4. IOC 创建对象的方式

1、Spring 容器默认使用无参构造器创建对象，配置文件写法如下：

<bean id=" " class=" ">
	...
</bean>

2、如果想要使用有参构造器，xml 文件有如下几种写法：

方式一：根据 index 参数下标设置，如

<bean id="exampleBean" class="examples.ExampleBean">
    <constructor-arg index="0" value="7500000"/>
    <constructor-arg index="1" value="42"/>
</bean>

方式二：根据参数名字配置

<bean id="exampleBean" class="examples.ExampleBean">
    <constructor-arg name="years" value="7500000"/>
    <constructor-arg name="ultimateAnswer" value="42"/>
</bean>

方式三：根据参数类型配置

<bean id="exampleBean" class="examples.ExampleBean">
    <constructor-arg type="int" value="7500000"/>
    <constructor-arg type="java.lang.String" value="42"/>
</bean>

方式四：根据参数列表顺序配置

<bean id="beanOne" class="x.y.ThingOne">
	<constructor-arg value="10"/>
    <constructor-arg value="20"/>
</bean>

结论：在配置文件被加载的时候，其中管理的对象都已经初始化了！ 可以把容器看作是一个婚介所，在你要结婚之前，里面已经有了各种各样的对象，不管是不是你喜欢的对象，里面都有，而且对象唯一，并不是到你需要使用的时候才创建对象。

5. Spring配置文件的一些字段说明

alias：用来设置别名，为 bean 设置别名，可以设置多个别名

<bean id="user" class="pojo.User">
	<property name="name" value="张三"/>
</bean>

<!-- 在获取Bean的时候可以使用别名获取 -->
<alias name="user" alias="user2"/>

Bean 的配置

bean就是java对象，由Spring创建和管理。

id：bean的唯一标识符，如果没有配置id，name就是默认标识符，如果不配置 id 和 name，可以根据 applicationContext.getBean(.class) 获取对象。
class：bean 对象所对应的全限定名：包名 + 类型。
name：如果配置id，又配置了name，那么name是别名，可以同时取多个别名，多个别名之间可以使用空格、逗号, 或者分号; 隔开
scope：设置作用域

<bean id="hello" name="hello2 h2,h3;h4" class="com.kuang.pojo.Hello">
   <property name="name" value="Spring"/>
</bean>

import

一般用于团队的合作开发使用，它可以将多个配置文件导入合并成为一个 xml 文件，使用的时候，直接使用总的 xml 配置文件就可以了。语法如下：

<import resource="{path}/applicationContext1.xml"/>
<import resource="{path}/applicationContext2.xml"/>
<import resource="{path}/applicationContext3.xml"/>

根据 import 导入的顺序，同名的bean，下面的会覆盖上边的。

小谷围最靓的仔

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【Spring】学习笔记02 —— IOC 控制反转

1. IOC 雏形原始的业务实现方式我们原来的业务实现步骤是这样的：UserDao 接口UserDaoImpl 实现类UserService 业务接口UserService 实现类我们先用原来的方式编写一个简单的例子，如下：1、编写一个 UserDao 接口。public interface UserDao { public void getUser();}2、编写 UserDao 的实现类public class UserDaoImpl implements Us
复制链接

扫一扫

专栏目录