Spring之IoC容器和依赖注入(2)

最新推荐文章于 2024-04-19 10:45:15 发布
最新推荐文章于 2024-04-19 10:45:15 发布
阅读量198 收藏
点赞数
分类专栏： 后端  文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36116242/article/details/113888603
版权

Spring之IoC容器和依赖注入(1)

4. IoC容器：创建容器三种方式

BeanFactory容器的类结构

方式一：类路径配置文件建容器

方式二：本地配置文件方式创建容器

方式三：注解的方式创建容器

代码

package com.it.test;

import com.it.service.CustomerService;
import com.it.service.impl.CustomerServiceImpl;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class TestCustomer {

    /**
     * 1.在类路径下读取配置文件，创建容器
     */
    @Test
    public void testCustomer() {
        //1.创建Spring容器，参数：指定spring的配置文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2.从容器中获取对象
        CustomerService customerService = (CustomerService) context.getBean("customerService");
        //3.调用对象的方法
        customerService.saveCustomer();
        //4.关闭容器
        context.close();
    }


    /**
     * 2. 从文件的绝对路径中获取配置文件，来创建容器
     */
    @Test
    public void testFileSystem() {
        //1.创建Spring容器，参数：指定spring的配置文件
        FileSystemXmlApplicationContext context = new FileSystemXmlApplicationContext("D:\\Spring\\src\\main\\resources\\applicationContext.xml");
        //2.从容器中获取对象
        CustomerService customerService = (CustomerService) context.getBean("customerService");
        //3.调用对象的方法
        customerService.saveCustomer();
        //4.关闭容器
        context.close();
    }
 
    /**
     * 3.读取注解的配置文件创建容器
     */
    @Test
    public void testAnnotationConfig() {
        //1.创建Spring容器，参数：类配置文件，通过注解去配置Spring
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(CustomerServiceImpl.class);
        System.out.println(context);
    }
}

5. bean标签的配置细节

bean标签的属性说明

属性说明
id容器中唯一的标识
name还可以有多个名字，使用逗号，空格，分号隔开都可以
class指定类全名，指定的是实现类，不是接口
scope指定bean在容器中作用范围 singleton：默认值，表示这个是单例对象，整个容器中只会创建一个对象 prototype：这是多例对象，每次获取一个新的对象 request：用于请求域 session：用于会话域 application: 用于上下文域 globalsession：用于全局的会话，用在分布式开发中
init-method创建对象时，执行的初始化的方法
destroy-method销毁对象时，执行的方法
lazy-init是否使用延迟加载，默认是不使用

6. bean的生命周期

bean的作用范围和生命周期的说明

scope取值作用范围生命周期
singleton 单例对象容器一创建就创建这个对象，只要容器不销毁就一直存在出生：容器创建就出生 活着：只要容器没有销毁就一直存在 死亡：容器关闭的时候
prototype 多例对象每次获取对象就创建一个新的对象，使用完毕会被GC回收出生：获取对象的时候 活着：使用过程中 死亡：由GC去回收

单例的延迟加载

  1. 未设置延迟加载，创建容器，不获取对象，也会实例化
  2. 使用lazy-init设置为true，在得到对象的时候才实例化

7. 依赖注入：构造函数

依赖注入介绍

       依赖注入(Dependency Injection，简称DI)。当某个Java对象(调用者)需要调用另一个Java对象(被调用者，即被依赖对象)时，以前调用者通常采用"new 被调用者"的代码方式来创建对象，这种方式会导致调用者与被调用者之间的耦合性增加，不利于后期项目的升级和维护

       使用Spring框架之后，对象的实例不再由调用者来创建，而是由Spring容器来创建，由容器控制程序之间的关系，而不是由调用者的程序代码直接控制。由容器负责将被依赖对象赋值给调用者的成员变量，相当于为调用者注入了它的依赖的实例，这就是Spring的依赖注入。

简单理解：依赖注入就是由Spring创建对象，并且给成员变量赋值。

构造方法注入

开发步骤

  1. 创建项目

  2. 编写类Customer

    1. 包含属性( int id; String name;boolean male;Date birthday;)

    2. 编写无参的构造方法

    3. 添加全参的构造方法

  3. 生成toString()方法，不用创建set和get方法

  4. 配置applicationContext.xml

    1. 使用bean的constructor-arg子元素

    2. 编号属性使用index指定值

    3. 名字属性使用name和type指定

    4. 性别使用name属性指定

    5. 日期使用ref引用另一个日期对象，日期使用bean在容器中声明为java.util.Date对象

  5. 在测试类中得到客户对象，输出客户对象

代码

Customer

package com.it.entity;

import java.util.Date;

/**
 * 客户对象
 */
public class Customer {

    private int id;
    private String name;
    private boolean male;
    private Date birthday;

    public Customer() {
    }

    public Customer(int id, String name, boolean male, Date birthday) {
        this.id = id;
        this.name = name;
        this.male = male;
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", male=" + male +
                ", birthday=" + birthday +
                '}';
    }
}

applicationContext.xml

<!--
1. 使用构造方法注入
子元素：constructor-arg 构造方法注入
    index：每几个位置，从0开始
    name：指定形参的名字
    type：指定参数的类型
    value：简单类型的值：8种基本类型+String类型
    ref：赋值引用类型，指定对象的id
 -->
<bean class="com.it.entity.Customer" id="customer">
    <constructor-arg name="id" value="100"/>
    <constructor-arg name="name" value="白骨精"/>
    <constructor-arg name="male" value="true"/>
    <constructor-arg name="birthday" ref="birthday" type="java.util.Date"/>
</bean>

<!-- 引用类型：现在的时间 -->
<bean class="java.util.Date" id="birthday"/>
constructor-arg标签的属性描述
index构造方法参数的位置
name参数名
type指定参数的类型
value赋值简单类型=基本类型+String类型
ref赋值引用类型

 

8. 依赖注入：set方法

就是通过类中的set方法，给成员变量赋值

步骤

  1. 给Customer添加set注入

  2. 配置applicationContext.xml，通过property元素给所有的属性赋值

  3. 运行测试类，输出customer对象

代码

1、Customer

package com.it.entity;

import java.util.Date;

/**
 * 客户对象
 */
public class Customer {

    private int id;
    private String name;
    private boolean male;
    private Date birthday;

    public Customer() {
    }

    public Customer(int id, String name, boolean male, Date birthday) {
        this.id = id;
        this.name = name;
        this.male = male;
        this.birthday = birthday;
    }

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

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

    public void setMale(boolean male) {
        this.male = male;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", male=" + male +
                ", birthday=" + birthday +
                '}';
    }
}

2、applicationContext.xml

<!-- 2.使用set方法注入 -->
<bean class="com.it.entity.Customer" id="customer">
    <!-- 属性名：为id value为200 -->
    <property name="id" value="200"/>
    <property name="name" value="猪八戒"/>
    <property name="male" value="true"/>
    <property name="birthday" ref="birthday"/>
</bean>

<!-- 引用类型：现在的时间 -->
<bean class="java.util.Date" id="birthday"/>

9、依赖注入：p命名空间

概述

注：先要在xml中导入p命名空间，本质仍然是调用类中的set方法实现注入功能。

步骤

  1. 配置applicationContext.xml

    1. 导入p命名空间(xmlns:p="http://www.springframework.org/schema/p")

    2. 通过"p:属性名"或者"p:属性名-ref"注入属性

  2. 测试类，从容器中得到客户对象输出

代码

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"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
  
    <!-- 使用p命名空间注入，本质上还是set注入
      1. 导入p命名空间
      2. 简单类型的格式：p:属性名="值"
         引用类型的格式：p:属性名-ref="id"
       -->
    <bean class="com.it.entity.Customer" id="customer" p:id="300" p:name="孙悟空" p:male="false" p:birthday-ref="birthday"/>

    <!-- 引用类型：现在的时间 -->
    <bean class="java.util.Date" id="birthday"/>
</beans>

10. 集合属性的注入

创建实体类

package com.it.entity;

import java.util.*;

public class Person {

    //字符串数组
    private String[] array;
    //字符串类型的List集合
    private List<String> list;
    //字符串类型的Set集合
    private Set<String> set;
    //字符串的键和值Map集合
    private Map<String, String> map;
    //Properties属性集合
    private Properties prop;

    public String[] getArray() {
        return array;
    }

    public void setArray(String[] array) {
        this.array = array;
    }

    public List<String> getList() {
        return list;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public Set<String> getSet() {
        return set;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public Map<String, String> getMap() {
        return map;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public Properties getProp() {
        return prop;
    }

    public void setProp(Properties prop) {
        this.prop = prop;
    }

    @Override
    public String toString() {
        return "Person{" +
                "array=" + Arrays.toString(array) +
                ", list=" + list +
                ", set=" + set +
                ", map=" + map +
                ", prop=" + prop +
                '}';
    }
}

配置applicationContext.xml

  1. 标签使用说明：

    1. 单列集合：使用标签 array/list/set

    2. 双列集合：使用标签 map/prop

    3. 只要数据结构相同，标签可以互用

  2. 使用set注入，给所有的属性使用相应的标签赋值

    1. 数组：array，每个元素是value或ref

    2. List集合：list，每个元素是value或ref

    3. set集合：set，每个元素是value或ref

    4. map集合：map，其中每个元素是entry，entry再指定key和value

    5. prop集合：props，其中每个元素是prop，包含key属性，没有value属性，标签体的内容是值

<!--  注入属性集合：所有的单列集合可以通用，只是语义上区别 -->
<bean class="com.itheima.entity.Person" id="person">
    <!--数组类型-->
    <property name="array">
        <array>
            <value>孙悟空</value>
            <value>猪八戒</value>
            <value>白骨精</value>
        </array>
    </property>

    <!-- list类型 -->
    <property name="list">
        <list>
            <value>张飞</value>
            <value>关羽</value>
            <value>刘备</value>
        </list>
    </property>

    <!-- set类型 -->
    <property name="set">
        <set>
            <value>贾宝玉</value>
            <value>林黛玉</value>
            <value>薛宝钗</value>
        </set>
    </property>

    <!-- map集合，所有的双引集合也是可以通用的 -->
    <property name="map">
        <map>
            <entry key="cn" value="中国"/>
            <entry key="usa" value="美国"/>
            <entry key="jp" value="日本"/>
        </map>
    </property>

    <!-- property集合 -->
    <property name="prop">
        <props>
            <prop key="gz">广州</prop>
            <prop key="sh">上海</prop>
            <prop key="bj">北京</prop>
        </props>
    </property>
</bean>

11. @Component注解

关于IoC配置说明

注解配置和 xml 配置要实现的目的是一样的，都是要降低程序间的耦合。只是配置的形式不一样。关于实际的开发中到底使用 xml 还是注解，每家公司有不同的习惯。

注意：SpringIoC容器中XML配置与注解可以混合使用。即：如果Dao用注解创建的对象；service用xml创建的对象一样可以注入DAO。

步骤

  1. 创建项目：添加依赖spring-context

  2. 创建实体类，使用@Component注解。

  3. 在applicationContext.xml 配置中开启注解扫描的基包

  4. 在测试类中得到Account类并且输出

Account实体类

package com.it.entity;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

/**
 * 被扫描到以后，由Spring创建这个对象放到容器中去，默认是类名首字母小写做为名字
 * 也可以指定value属性，就是它的名字
    @Component:用于普通的类
    @Service：用于业务层的类
    @Repository：用于持久层
    @Controller：用于控制器
    注：以上四个注解的功能一样，只是语义上区别
 */
@Component
public class Account {

    private Integer id;
    private String name;
    private Double money;

    public Account() {
    }

    public Account(Integer id, String name, Double money) {
        this.id = id;
        this.name = name;
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

applicationContext.xml

  1. 使用context命名空间

  2. 配置扫描哪个基包

<?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
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 扫描哪个包下所有的类，指定基包的名字，使用context命名空间 -->
    <context:component-scan base-package="com.it"/>
</beans>

测试类

package com.it.test;

import com.it.entity.Account;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestAccount {

    @Test
    public void testAccount() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //从容器中获取对象
        Account account = (Account) context.getBean("account");
        System.out.println(account);
    }
}

12. @Autowired注解

@Autowired介绍

  • 位置: 用于成员变量和成员方法上

  • 作用: 将属性注入相应的值

    • 按类型匹配的方式从容器中去查找对应的值注入

    • 如果有多个匹配的类型，按名字匹配的方式注入

    • 如果找不到匹配的名字，就会抛出异常

@Autowired的属性required

作用：默认为true，这个属性是否必须，如果为false，则在容器中找不到这个属性匹配的类型，也不抛出异常，属性值为空

@Autowired修饰属性

@Autowired修饰方法

 

代码

package com.it.entity;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component("user")
public class User1 {

    private String username;

    /**
     * 在默认的情况下：@Autowired的值必须要注入，否则抛出异常
     * 属性：required 默认是true，设置为false表示这个属性不是必须注入的
     */
    @Autowired(required = false)
    private void inputUsername(String username) {
        this.username = username;
    }

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

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"
       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
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 扫描哪个包下所有的类，指定基包的名字，使用context命名空间 -->
    <context:component-scan base-package="com.it"/>

    <!-- 有一个字符串类型要注入 -->
    <bean class="java.lang.String" id="man">
        <!-- 相当于 new String("Boy") -->
        <constructor-arg value="Boy"/>
    </bean>

 
</beans>

13. @Qualifier注解

作用

  • 必须与@Autowired配置使用，不能单独使用

  • 位置: 放在成员变量或成员方法上

  • 作用: 按名字匹配的方式注入

  • 属性: value指定要注入的名字名

14. @Value注解

作用

用于一些简单类型的注入，也可以注入日期类型

以后主要用于从Java属性文件中读取键，将值注入到成员变量

 

上帝123
关注
专栏目录
Spring--IOC和依赖注入
qq_45688655的博客
01-11 445
学习Spring
Spring的IOC和依赖注入
qq_43910194的博客
09-26 730
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、IOC，依赖注入是什么？二、IOC容器三、依赖注入类型总结 前言 spring IOC的基本介绍，spring IOC容器以及依赖注入 一、IOC，依赖注入是什么？ IOC控制反转（Inversion of Control，IOC）是spring框架的核心，用来减少计算机程序的耦合问题 没有IOC：某一个对象（调用者）需要调用一个Java对象（被调用者）时，在传统模式下需要进行new被调用者来创建对象，但是用这样的方法会
Spring的IOC和依赖注入（day003）
XXL_SanSui的博客
08-31 173
先说说什么是耦合关系 上面的齿轮之间的啮合关系，与软件系统中对象之间的耦合关系非常相似。对象之间的耦合关系是无法避免的，也是必要的，这是协同工作的基础。 控制反转（IOC） 如何降低系统之间、模块之间和对象之间的耦合度，是软件工程永远追求的目标之一，所以为了优化这个问题，软件专家Michael Mattson提出了IOC概念，用来实现对象之间的“解耦”，现在这个理论被运用得很广泛，很多J2EE项目均采用了IOC框架产品Spring。 概念 IOC是Inversion of Control的缩写—>控制
JAVA：理解 Spring IOC 与依赖注入
最新发布
木头
04-19 585
JAVA：理解 Spring IOC 与依赖注入
Spring 学习笔记1 —— IOC容器 I （IOC容器、DI依赖注入）
2401_83915812的博客
04-17 897
1 Spring IoC容器和Bean简介1.1 了解IOC。
浅谈Spring IoC容器的依赖注入原理
08-27
Spring IoC容器的依赖注入原理是Spring框架的核心机制之一，负责将服务对象（Bean）实例化并将其提供给客户端使用。依赖注入原理可以分为两个阶段：IoC容器初始化和Bean实例化。 在IoC容器初始化阶段，主要完成的...
编程语言+JAVAspring+IoC容器+依赖注入
03-01
编程语言+JAVAspring+IoC容器+依赖注入**：这是一...它介绍了JAVAspring的IoC容器的概念、原理和作用，以及如何使用JAVAspring的IoC容器来实现依赖注入，包括设值注入和构造注入的方式，以及一些配置文件和注解的用法。
详解Spring IOC 容器启动流程分析
08-25
Spring IOC 容器是 Java 企业级应用程序的核心组件之一，它提供了一个统一的依赖注入机制，使得应用程序的组件之间能够松耦合。Spring IOC 容器的启动流程是整个 Spring 框架的核心所在，本文将从 ...
Spring.Net IOC依赖注入原理流程解析
08-18
Spring.Net IOC依赖注入原理流程解析 本文将详细介绍Spring.Net IOC依赖注入原理流程解析，通过示例代码介绍了非常详细，对大家的学习或者工作具有一定的参考学习价值。 一、什么是IOC？ IOC（Inversion of ...
Spring实现一个简单的SpringIOC容器
08-30
通过以上步骤，我们可以构建一个基础的Spring IOC容器，实现对象的创建、依赖注入和作用域管理。虽然这个简单的实现可能没有Spring框架那样全面和高效，但它可以帮助我们理解Spring IOC容器的工作原理，为进一步学习...
Spring笔记整理3（多种类型注入）
weixin_42260782的博客
09-12 217
多种类型注入 CollectionBean与CarBean，省略setget以及toString方法 public class CollectionBean { private Object [] arr;//数组类型注入 private List list; //list/set类型注入 private Map map;//map类型注入 private Properties prop;//properties类型注入 } public class Car { private String
spring中IOC（依赖注入）详解
六年鹿苑的博客
05-31 515
Spring 的 Bean 的属性注入: 【构造方法的方式注入属性】 <bean id="car" class="cn.itcast.spring.demo4.Car"> <constructor-arg name="name" value="保时捷"/> <constructor-arg name="price" value="1000000"/&g...
spring学习：IOC和依赖注入的基本概念
点缀星辰
12-26 542
简介     很早以前接触过spring，听说过关于这个框架最多的就是关于依赖注入和它带来的各种好处。那么spring框架的这些概念到底是什么意思呢？它对于我们实际中的开发有什么帮助呢？在这里，我们以一个初学者的视角一步步来理解和体会其中的作用。   从OO设计原则说起     当我们使用一些面向对象的语言来设计以及实现应用的时候，经常会强调一些基本的设计原则。其中最基本的一条就是面向...
详解spring的IOC控制反转和DI依赖注入
qq_38122518的博客
06-05 6758
　学习过Spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念，对于初学Spring的人来说，总觉得IoC 、DI这两个概念是模糊不清的，是很难理解的，今天和大家分享网上的一些技术大牛们对Spring框架的IOC的理解以及谈谈我对Spring Ioc的理解。一、分享Iteye的开涛对Ioc的精彩讲解　　首先要分享的是Iteye的开涛这位技术牛人对Spring...
ioc与依赖注入
weixin_71307869的博客
06-22 1439
IOC就是一个Spring特有的，用来装类对象的，就是我们用Spring框架时，不需要new对象了，不过我们需要让我们的Spring知道我们写了哪些配置和需要用什么，所以这时我们就要引用Spring的注解或者在配置xml文件上配置我们的类配置，就是在我们自己写的类上加上@Component、@Controller、@Service、@Repository等等这些让我们的Spring知道我们等下要调用有哪些类，让它先准备准备，等下我们需要用了，就getBean或者通过@Autowrite、@Resource来
对SpringIOC和依赖注入的理解
sky
05-21 170
IOC——控制反转 将管理对象的权利由程序员手中提交到SpringIOC容器手中 SpringIOC容器负责管理程序员提前注册好的类对象， 当Spring启动后，程序员注册的类对象将由IOC容器提供给程序员， 不需要程序员自己new 只需要你提供一个类名（id），SpringIOC容器会自动帮你查找并返回给你 你不需要担心该对象如何创建与生命周期，只需要获取接收就OK 如果SpringIOC容器提供了错误的对象，程序员的代码自然会抛出异常 DI——依赖注入 首先你可以将依赖理解为“需要”，注入理解为“提供
Spring中依赖注入与容器
可小辉的博客
04-08 716
依赖注入、IoC/DI Spring 框架（核心）IoC 容器 IoC：控制反转 DI：依赖注入 什么是依赖?一个组件（对象）的运行需要用到另一个组件（对象），称这种关系为依赖关系 举例：鱼依赖水，生命依赖空气、阳光、水、食物 组件依赖的资源（其他组件）由所在环境（上下文、容器）传递进去 依赖注入的几种形式 - 接口注入 - 构造器注入 - 属性（setter）注入 ...
如何理解Spring的控制反转IOC和依赖注入DI思想
FFFLLLLLL的博客
07-04 1591
首先我们要知道Java应用程序的每个逻辑业务的完成需要多个类的相互合作。例如有一个Student对象需要使用Course对象，通常需要在Student对象中new一个Course对象，然后再调用Course对象的相关属性或者方法，但是也可以看出对象之间的耦合度高了。Spring的IOC的想法就是由Spring容器来控制以来对象的创建和销毁，例如当Student对象需要使用Cousrse时候，Stu
什么是依赖注入
自由人生
03-27 5554
只讲原理，不讲过程。 大多数面向对象编程语言，在调用一个类的时候，先要实例化这个类，生成一个对象。 如果你在写一个类，过程中要调用到很多其它类，甚至这里的其它类，也要“依赖”于更多其它的类，那么可以想象，你要进行多少次实例化。 这就是“依赖”的意思。 依赖注入，全称是“依赖注入到容器”， 容器（IOC容器）是一个设计模式，它也是个对象，你把某个类（不管有多少依赖关系）放入这个容器中，可以“
理解Spring IoC容器的依赖注入机制
Spring IoC容器的依赖注入原理是通过容器管理Bean的生命周期，控制Bean之间的依赖关系，使得应用代码更加解耦和灵活。在容器创建Bean时，它会自动处理Bean的依赖，减少手动管理对象的复杂性，提高了开发效率和代码的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值