2 学习 IoC

已于 2022-08-11 09:37:22 修改
阅读量60 收藏
点赞数
分类专栏： Spring框架 文章标签： 学习 java spring
于 2022-08-10 15:39:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52077925/article/details/126242322
版权

1 什么是控制反转

在传统的程序开发中，需要调用对象时，通常由调用者来创建被调用者的示例，即对象是由调用者主动new出来的。
但在Spring框架中创建对象的工作不再由调用者来完成，而是交给IoC容器来创建，再推送给调用者，整个流程完成反转，所以是控制反转。

在这里插入图片描述

2 配置文件

  • 通过配置 bean 标签来完成对象的管理
    • id：对象名
    • class：对象的模板类（所有交给IoC容器来管理的类必须有无参构造函数，因为Spring底层是通过反射机制来创建对象的，而反射机制调用的是无参构造）
  • 对象的成员变量通过 property 标签赋值
    • name：成员变量名
    • vlaue：成员变量值（基本数据类型，String可以直接赋值；如果是其他引用，不能通过 value 赋值）
    • ref：将 IoC 中的另一个bean付给当前的成员变量（DI 依赖注入）
<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="student" class="com.southwind.entity.Student">
        <property name="age" value="22"></property>
        <property name="id" value="1"></property>
        <property name="name" value="张三"></property>
        <property name="addr" ref="address"></property>
    </bean>

    <bean id="address" class="com.southwind.entity.address">
        <property name="name" value="科技路"></property>
        <property name="id" value="1"></property>
    </bean>

</beans>

3 如何使用 IoC?

  1. 创建 Maven 工程，pom.xml 添加依赖
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.22</version>
        </dependency>
    </dependencies>
  1. 创建实体类 Student
package com.southwind.entity;

import lombok.Data;

@Data
public class Student {
    private long id;
    private String name;
    private int age;
}
  1. 传统的开发方式：手动 new Student
package com.southwind.test;

import com.southwind.entity.Student;

public class Test {
    public static void main(String args[]){
        Student student = new Student();
        student.setId(1L);
        student.setName("张三");
        student.setAge(22);
        System.out.println(student);
    }
}
  1. 通过 IoC容器 创建对象，在配置文件中添加需要管理的对象，XML 格式的配置文件，文件名可以自定义
  • 定义一个 spring.xml 配置文件（创建一个 XML Configuration File 文件)：
    在这里插入图片描述
<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="student" class="com.southwind.entity.Student">
        <property name="age" value="22"></property>
        <property name="id" value="1"></property>
        <property name="name" value="张三"></property>
    </bean>

</beans>
  • IoC的基本使用：
package com.southwind.test;

import com.southwind.entity.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String args[]){
        // 加载配置文件
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        Student student = (Student) applicationContext.getBean("student");
        System.out.println(student);
    }
}

4 IoC 底层原理

  • 读取配置文件，解析XML
  • 通过反射机制实例化配置文件中所配置所有的bean

4.1 IoC底层原理的简单演示

（1）根据加载配置文件的代码可知

// 加载配置文件
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
Student student = (Student) applicationContext.getBean("student");
System.out.println(student);

/*
	ApplicationContext是一个接口，有一个方法：getBean(String)
	ClassPathXmlApplicationContext是实现它的类

	调用反射机制，通过无参构造函数创建。
*/

（2）手动编写 ApplicationContext 和 ClassPathXmlApplicationContext

在这里插入图片描述
① ApplicationContext

package com.southwind.ioc;

public interface ApplicationContext {
    public Object getBean(String id);
}

② ClassPathXmlApplicationContext

package com.southwind.ioc;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Locale;
import java.util.Map;

public class ClassPathXmlApplicationContext implements ApplicationContext {
    private Map<String, Object> ioc = new HashMap<>();

    public ClassPathXmlApplicationContext(String path){
        try{
            SAXReader reader = new SAXReader();
            Document document = reader.read("src/main/resources/"+path);
            Element root = document.getRootElement();
            Iterator<Element> iterator = root.elementIterator();
            while (iterator.hasNext()){
                Element element = iterator.next();
                String id = element.attributeValue("id");
                String className = element.attributeValue("class");
                // 通过反射机制创建对象
                Class clazz = Class.forName(className);
                // 获取无参构造函数
                Constructor constructor = clazz.getConstructor();
                Object object = constructor.newInstance();
                // 给目标对象赋值
                Iterator<Element> beanIter = element.elementIterator();
                while(beanIter.hasNext()){
                    Element property = beanIter.next();
                    String name = property.attributeValue("name");
                    String valueStr = property.attributeValue("value");
                    String ref = property.attributeValue("ref");
                    if(ref == null){
                        String methodName = "set"+name.substring(0,1).toUpperCase()+name.substring(1,name.length());
                        Field field = clazz.getDeclaredField(name);
                        Method method = clazz.getDeclaredMethod(methodName,field.getType());
                        // 根据成员变量的数据类型将 value 进行转换
                        Object value = null;
                        if(field.getType().getName() == "long"){
                            value = Long.parseLong(valueStr);
                        }
                        if(field.getType().getName() == "java.lang.String"){
                            value = valueStr;
                        }
                        if(field.getType().getName() == "int"){
                            value = Integer.parseInt(valueStr);
                        }
                        method.invoke(object, value);
                    }
                }
                ioc.put(id,object);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    @Override
    public Object getBean(String id) {
        return ioc.get(id);
    }
}

③ 运行结果

Student(id=1, name=张三, age=22, addr=null)

// addr的赋值也是类似，以后再补充

5 获取IoC容器创建的对象

5.1 通过 id 获取对象

Student student = (Student) applicationContext.getBean("student");

5.2 通过 运行时类 获取对象

Student student = (Student) applicationContext.getBean(Student.class);

这种方式存在一个问题，配置文件中一个数据类型的对象只能由一个实例，否则会抛出异常，因为没有唯一的bean。

6 创建对象的方式

6.1 无参构造

在实体类中创建对应的有参构造函数。
@NoArgsConstructor 无参构造

	<bean id="student" class="com.southwind.entity.Student">
        <property name="age" value="22"></property>
        <property name="id" value="1"></property>
        <property name="name" value="张三"></property>
        <property name="addr" ref="address"></property>
    </bean>
    
    <bean id="address" class="com.southwind.entity.address">
        <property name="name" value="科技路"></property>
        <property name="id" value="1"></property>
    </bean>

6.2 有参构造

在实体类中创建对应的有参构造函数。
@AllArgsConstructor 有参构造

 <!-- 写法一 -->
 	<bean id="student2" class="com.southwind.entity.Student">
        <constructor-arg name="id" value="3"></constructor-arg>
        <constructor-arg name="name" value="小米"></constructor-arg>
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="addr" ref="address2"></constructor-arg>
    </bean>

    <bean id="address2" class="com.southwind.entity.address">
        <constructor-arg name="id" value="2"></constructor-arg>
        <constructor-arg name="name" value="可新路"></constructor-arg>
    </bean>

<!-- 写法二 -->
<!-- name 省略,但要按顺序 -->
 	<bean id="student2" class="com.southwind.entity.Student">
        <constructor-arg value="3"></constructor-arg>
        <constructor-arg value="小米"></constructor-arg>
        <constructor-arg value="18"></constructor-arg>
        <constructor-arg ref="address2"></constructor-arg>
    </bean>

    <bean id="address2" class="com.southwind.entity.address">
        <constructor-arg value="2"></constructor-arg>
        <constructor-arg value="可新路"></constructor-arg>
    </bean>

<!-- 写法三 -->
<!-- index代替name -->
 	<bean id="student2" class="com.southwind.entity.Student">
        <constructor-arg index="0" value="3"></constructor-arg>
        <constructor-arg index="1" value="小米"></constructor-arg>
        <constructor-arg index="2" value="18"></constructor-arg>
        <constructor-arg index="3" ref="address2"></constructor-arg>
    </bean>

    <bean id="address2" class="com.southwind.entity.address">
        <constructor-arg index="0" value="2"></constructor-arg>
        <constructor-arg index="1" value="可新路"></constructor-arg>
    </bean>

注解：
（1）@AllArgsConstructor 有参构造
（2）@NoArgsConstructor 无参构造

给你一杯BUG
关注
专栏目录
IOC学习
qq_35091353的博客
09-14 168
一、什么是 IOC IoC：控制反转（Inversion of Control）容器，这不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。 （1）控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理 （2）使用 IOC 目的：为了耦合度降低 IoC一些解释： 　　●谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有..
Spring Ioc学习心得
Monkeydesigner的博客
01-18 597
Spring Ioc基础介绍，以及代码实现
IOC的理解学习
爱学习的大雄的博客
06-29 1485
在学习Spring 的过程中我们经常会接触到IOC（控制反转），大家也知道IOC是Sping 的重要核心之一，那么如何理解它呢，它又是产生什么作用呢？以下是我经过查阅资料后的总结理解，供大家参考。假设我们设计一辆汽车：先设计轮子，然后根据轮子大小设计底盘，接着根据底盘设计车身，最后根据车身设计好整个汽车。这里就出现了一个“依赖”关系：汽车依赖车身，车身依赖底盘，底盘依赖轮子。这样的设计看起来没问题，但是可维护性却很低。假设设计完工之后，上司却突然说根据市场需求的变动，要我们把车子的轮子设计都改大一码。这下我
学习springIOC
weixin_45621552的博客
07-02 1258
Spring 是目前主流的 Java 开发框架，是 Java 世界最为成功的框架。其目的是用于简化企业级应用程序开发的难度和周期，任何 Java 应用都可以从 Spring 中受益。Spring 框架还是一个超级粘合平台，除了自己提供功能外，还提供粘合其他技术和框架的能力。什么是框架？框架是一个半成品，提供了基本的运行功能，但具体业务实现需要我们去编写。
C# IoC控制反转学习笔记
MarcoPro的博客
03-03 1997
IoC-Invertion of Control，即控制反转，是一种程序设计思想。：就是有联系，表示一个类依赖于另一个类。：设计模式六大原则之一，是一种软件架构设计原则。：一种软件设计原则，上层对下层的依赖（即底层模块的获得）交给第三方。：实现IoC的一种方式、手段。：依赖注入的框架，用来映射依赖，管理对象的创建和生存周期。
学习SpringIOC
weixin_52579117的博客
05-20 173
IOC概念和原理 Inversion of Control，翻译过来是反转控制。而反转控制又是什么呢？控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理。而我们使用IOC就是为了耦合度降低。 Spring 提供了 IOC 容器的两种实现方式： （1）BeanFactory 这是 IOC 容器的基本实现，是 Spring 内部使用的接口。面向 Spring 本身，不提供给开发人员使用。 （2）ApplicationContext BeanFactory 接口的子接口，提供更多更强
尚硅谷Spring学习笔记第2节IOC
weixin_57341232的博客
08-07 957
IOC——1、IOC容器——2、基于XML管理bean——3、基于注解管理bean
Spring IOC学习笔记
dadaxiongdebaobao的博客
08-19 962
java 反射机制是IOC的底层实现，IOC是spring容器的内核，AOP，声明式事务管理都是在此基础上发展的。 IOC：某一接口具体实现类的选择控制权从调用类中移除，转交第三方决定，DI是依赖注入，是和IOC一样的： DI：让调用类对某一接口实现类的依赖关系由第三方注入，以移除调用类对某一接口实现的依赖。 Eg：在演员，剧本，角色中 ，本来演员是直接依赖角色和剧本的，用IOC之后
Spring学习(2) Spring的IOC底层实现
梦想也许遥不可及，但重要的是追梦的过程，用博客记录自己的成长，记录自己一步一步向上攀登的印记
06-29 1198
在创建Bean之前，首先需要创建IOC容器，Spring提供了IOC容器的两种实现方式:bean对象是由Spring IOC容器管理的bean 是一个被实例化，组装，并通过 Spring IoC 容器所管理的对象。这些 bean 是由用容器提供的配置元数据创建的，例如，在 XML 的表单中的 定义。bean的常见属性 如果一个类中，有一个属性不是基本类型，包装类，String类，而是自定义的类型，那么我们就不可以使用value标签或value属性来为它赋值，而要使用ref来进行引用 级联属性更改数值会影
java 框架 SSM 学习 核心容器IoC
lyn_stark的博客
03-20 555
首次使用博客记录学习提示：以下是本篇文章正文内容，下面案例可供参考BeanFactory 是IoC容器的顶层接口，初始化BeanFactory对象时，加载的bean延迟加载ApplicationContext 接口是Spring容器的核心接口，初始化时bean立即加载ApplicationContext接口提供基础的bean相关的方法，通过其他的接口扩展其功能ApplicationContext接口常用初始化类。
《撸代码 学习 IOC注入技术1 》—— 布局注入 与 控件注入
01-03
《撸代码 学习 IOC注入技术1 》—— 布局注入 与 控件注入 1.概念再理解2.布局注入3.控件注入 好的，下面就是见证奇迹的时刻啦： 成功啦！我成功啦，啊哈哈哈哈~ 完成了布局注入，那我们下面继续控件注入吧~ ...
C#实现的IOC和AOP框架，供学习
07-22
这个名为“GreeFramOfficial”的压缩包文件，很可能是提供了一个基于C#实现的IOC和AOP框架，供开发者学习和使用。 IOC（Inversion of Control）的核心思想是将对象的创建和管理交给一个容器来处理，而不是由对象...
手写IOC项目，学习理解Spring IOC原理
09-21
而剖析一个类或用反射解决具体的问题就是使用相关应用程序接口(1)`java.lang.Class`(2)`java.lang.reflect`，所以，Class对象是反射的根源。 IOC和DI是Spring里面最核心的东西，，资源中会写出这两个模块。资源内容...
学习春天ioc容器
02-12
总的来说，学习Spring IoC容器对于Java开发者来说至关重要，它能够帮助你构建松散耦合、易于测试和维护的应用。掌握IoC容器的使用，不仅能够提高开发效率，还能让你更好地理解和利用Spring框架提供的其他高级功能。...
spring入门学习-2、IOC、DI知识.pdf
02-17
### Spring入门学习：IOC与DI详解 #### 一、什么是IOC？ **IOC**，全称为 **Inversion of Control**（控制反转），它并不是一项具体的技术，而是一种设计思想。在传统的Java开发过程中，当我们需要使用某个组件时...
H.264学习笔记
zfenggo的博客
09-26 807
H.264凭借其出色的压缩效率、灵活的编码方式以及高质量的视频表现，成为了现代视频技术的核心标准之一。它不仅减少了存储需求，还提高了流媒体和实时视频传输的可行性。对于从高清到超高清视频，H.264的编码能力仍然广泛适用。H.264的帧结构设计（I帧、P帧和B帧）极大地提高了视频编码的压缩效率。I帧保存完整的图像信息，P帧通过参考之前的帧减少冗余数据，而B帧则通过双向参考提供进一步的压缩优势。这种帧间的协同工作大幅降低了带宽需求和存储成本，同时保持了视频的高质量。NALU头。
2024-2025华为ICT大赛报名｜赛前辅导｜学习资料
qq2859066538的博客
09-25 309
华为ICT大赛是华为公司打造的面向全球高校的年度ICT赛事，大赛以“联接、荣耀、未来”为主题，协同政府、高等教育机构、培训机构和行业企业，促进高校ICT人才培养、成长和就业，助力ICT人才生态繁荣。华为ICT大赛2023-2024实践赛涵盖网络、云、计算（第九届华为ICT大赛更名为基础软件）和昇腾AI四个赛道。为有效帮助参赛者把握命题思路、突破重点内容、检验学习效果、提高实战经验，更充分地备战大赛，华为首次推出华为ICT大赛2023-2024实践赛真题实战系列课程，为您铺就通往大赛的成功之路。
从0学习React（3）
qq_54432917的博客
09-29 535
在第一篇文章中，我们对index.tsx文件的每一行代码都做了简单的分析。通过第一篇文章的总结，我也大致知道了index.tsx里的很多语法。而第二篇文章，我对index.tsx文件的框架做了一个大致的分析，通过第二篇文章，我对index.tsx有了进一步的认识。按理来讲，第三篇文章我还是解析index.tsx文件，但是我发现，对于前两篇文章，其实我对语法的细节有很多不明白的点。因此这篇文章，我就把React的一些最基础的知识给梳理一下，帮助我更好的理解index.tsx的代码。
【DirectX sdk 学习使用】
最新发布
qq_41610493的博客
10-01 184
设置包含目录：打开你的项目属性，导航到VC++目录，然后在包含目录中添加DirectX SDK的Include文件夹路径。设置库目录：同样在VC++目录中，在库目录中添加DirectX SDK的Lib文件夹路径。运行安装程序：下载完成后，找到下载的安装程序（通常是一个.exe文件），双击运行。选择安装路径：选择你希望安装DirectX SDK的路径，或者使用默认路径。如果你有任何问题或需要进一步的指导，请随时告诉我。接受许可协议：在安装向导中，阅读并接受许可协议。完成安装：点击“安装”按钮，等待安装完成。
Struts2详解：优雅的Web框架与IOC、AOP的结合
"Struts2学习教程 - Struts2_PPT1" Struts是一个流行的Java Web框架，它基于Model-View-Controller (MVC)架构模式，为开发人员提供了一种更加优雅的方式来实现控制器功能。Struts2不仅提供了控制器，还包含一系列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值