spring之IoC知识梳理

最新推荐文章于 2026-01-09 15:15:24 发布
原创 最新推荐文章于 2026-01-09 15:15:24 发布 · 251 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #spring #ioc #bean

本文详细介绍了Spring框架中的IoC容器概念及其多种实现方式，包括无参构造、有参构造、依赖注入等，同时讲解了如何通过工厂方法创建对象、自动装载以及基于注解的配置。

文章目录

什么是 IoC

IoC 也叫控制反转

在传统的程序开发中，需要获取对象时，通常由开发者来手动创建实例化对象，但是在 Spring 框架中创建对象的工作不再由开发者完成，而是交给 IoC 容器来创建，我们直接获取即可，整个流程完成反转，因此是控制反转。

IOC的实现

创建实体类:

public class Student {
    private int id;
    private String name;
    }

在 pom.xml 中添加 Spring 依赖

创建配置文件，可以自定义文件名 spring.xml

无参构造方式

在 spring.xml 中配置 bean 标签，IoC 容器通过加载 bean 标签来创建对象。

<bean id="stu" class="com.sensen.springdemo.entity.Student"></bean>

调用 API 获取 IoC 创建的对象

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        Student stu = (Student) applicationContext.getBean("stu");
        System.out.println(stu);
        
        Student bean = applicationContext.getBean(Student.class);
        System.out.println(bean);

两种获取方式,上面的是根据id获取,后面的根据类名,返回结果都是属性值全为初始化值或null的对象.

如果想给对象赋值怎么办呢?
需要给实体类的每个属性加上set和get方法，spring通过对象的set方法和get方法来初始化对象。
之后修改bean配置即可:

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

再次运行即可得到有值的对象

有参构造方式

先给对象加上有参数的构造方法.

修改bean配置:

    <bean id="stu" class="com.sensen.springdemo.entity.Student">
        <constructor-arg name="id" value="3"></constructor-arg>
        <constructor-arg name="name" value="小明"></constructor-arg>
    </bean>

再次运行,也是得到有值的对象.

依赖注入（DI）

如果 IoC 容器管理多个对象，并且对象之间有级联关系，如何实现？

创建 Classes 类

public class Classes {
    private int id;
    private String name;
}

在 Student 类中添加 Classes 属性

    private int id;
    private String name;
    private Classes classes;

spring.xml 中配置 classes 对象，然后将该对象赋值给 stu 对象

<?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="stu" class="com.sensen.springdemo.entity.Student">
        <constructor-arg name="id" value="3"></constructor-arg>
        <constructor-arg name="name" value="小明"></constructor-arg>
        <constructor-arg name="classes" ref="classes"></constructor-arg>
    </bean>

    <bean id="classes" class="com.sensen.springdemo.entity.Classes">
        <property name="id" value="1"></property>
        <property name="name" value="Java班"></property>
    </bean>

</beans>

再次获取 Student 对象，结果如下图所示。
在这里插入图片描述
在 spring.xml 中，通过 ref 属性将其他 bean 赋给当前 bean 对象，这种方式叫做依赖注入（DI），是 Spring 非常重要的机制，DI 是将不同对象进行关联的一种方式，是 IoC 的具体实现方式，通常 DI 和 IoC 是紧密结合在一起的，因此一般说的 IoC 包括 DI。

Spring 中的 bean

bean 是根据 scope 来生成的，scope 常用的两种类型：

singleton，单例，表示通过 Spring 容器获取的该对象是唯一的；
prototype，原型，表示通过 Spring 容器获取的对象都是不同的；

默认是singleton的,如果需要改变配置,只需修改为prototype即可:

<bean id="stu" class="com.sensen.springdemo.entity.Student" scope="prototype">

Spring 的依赖

依赖是 bean 和 bean 之间的一种关联方式，配置依赖关系后，被依赖的 bean 一定先创建，再创建依赖的 bean.

例如如下配置:

<bean id="user" class="com.southwind.entity.User" depends-on="car">
   <property name="id" value="1"></property>
   <property name="name" value="张三"></property>
   <property name="age" value="23"></property>
</bean>
<bean id="car" class="com.southwind.entity.Car">
   <property name="id" value="1"></property>
   <property name="brand" value="宝马"></property>
</bean>

正常情况下,spring创建bean的顺序是由上到下,但是如果创建了依赖关系,则会先创建被依赖的对象.

例如上面这种配置后,就会先创建 car,再创建 user.

Spring 读取外部资源

创建实体类TestConfig,，并加上setget方法：

public class TestConfig {
    private String url;
    private String user;
    private String root;

    @Override
    public String toString() {
        return "TestConfig{" +
                "url='" + url + '\'' +
                ", user='" + user + '\'' +
                ", root='" + root + '\'' +
                '}';
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    public String getRoot() {
        return root;
    }

    public void setRoot(String root) {
        this.root = root;
    }
}

在spring.xml的相同目录下，创建jdbc.properties

url = com.testConfig.com
user = root
pwd = root

之后在spring.xml中如下配置：

 <!-- 导入外部的资源文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
    <!-- 创建对象 -->
    <bean id="testConfig" class="com.sensen.springdemo.entity.TestConfig">
        <property name="url" value="${user}"></property>
        <property name="user" value="${pwd}"></property>
        <property name="root" value="${url}"></property>
    </bean>

之后运行

        ApplicationContext applicationContext1 = new ClassPathXmlApplicationContext("spring.xml");
        TestConfig testConfig = (TestConfig) applicationContext.getBean("testConfig");
        System.out.println(testConfig);

即可看到配置已经生效了.

IoC 通过工厂方法创建对象

IoC 是典型的工厂模式，把IOC看成一个大工厂，这个大工厂里面要生成的对象都是在XML文件中定义的，然后利用java的反射编程，根据xml给出的类名动态的生成相应的对象。

下面我们就来学习如何使用工厂模式来创建 bean。

静态工厂

先创建个Car类：

public class Car {
    private int num;
    private String brand;
    public Car(int num, String brand) {
        super();
        this.num = num;
        this.brand = brand;
    }

    @Override
    public String toString() {
        return "Car{" +
                "num=" + num +
                ", brand='" + brand + '\'' +
                '}';
    }
}

再来个静态工厂类：

public class StaticCarFactory {
    private static Map<Integer, Car> cars;
    static{
        cars = new HashMap<Integer,Car>();
        cars.put(1, new Car(1,"奥迪"));
        cars.put(2, new Car(2,"奥拓"));
    }
    public static Car getCar(int num){
        return cars.get(num);
    }
}

之后是xml的配置：

    <!--    在 spring.xml 中配置静态工厂-->
    <!--    factory-method 指向静态方法；-->
    <!--    constructor-arg 的 value 属性为调用静态方法所传的参数。-->
    <bean id="car1" class="com.sensen.springdemo.factory.StaticCarFactory" factory-method="getCar">
        <constructor-arg value="1"></constructor-arg>
    </bean>

最后在test中演示：

 		 //静态工厂
        Car car = (Car) applicationContext.getBean("car1");
        System.out.println(car);

即可看到奥迪车了。

实例工厂

还是上面的Car类，来个实例工厂：

public class InstanceCarFactory {
    private Map<Integer, Car> cars;
    public InstanceCarFactory() {
        cars = new HashMap<Integer,Car>();
        cars.put(1, new Car(1,"奥迪"));
        cars.put(2, new Car(2,"奥拓"));
    }
    public Car getCar(int num){
        return cars.get(num);
    }
}

xml的配置：

    <!-- 配置实例工厂对象 -->
    <bean id="carFactory" class="com.sensen.springdemo.factory.InstanceCarFactory"></bean>
    <!-- 通过实例工厂对象创建 car 对象 -->
    <bean id="car2" factory-bean="carFactory" factory-method="getCar">
        <constructor-arg value="2"></constructor-arg>
    </bean>

演示：

        //实例工厂
        Car car2 = (Car) applicationContext.getBean("car2");
        System.out.println(car2);

IoC 自动装载（autowire）

Spring 还提供了另外一种更加简便的方式：自动装载，不需要手动配置 property，IoC 容器会自动选择 bean 完成依赖注入。

自动装载有两种方式：

byName，通过属性名自动装载。

创建实体类，类中成员变量有Car对象：

public class Person {
    private int id;
    private String name;
    private Car car;

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

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }
}

在xml中配置：

 <!--    自动装载-->
    <bean id="person" class="com.sensen.springdemo.entity.Person" autowire="byName">
        <property name="id" value="1"></property>
        <property name="name" value="张三"></property>
    </bean>
    <bean id="car" factory-bean="carFactory" factory-method="getCar">
        <constructor-arg value="2"></constructor-arg>
    </bean>

test类：

        Person person = (Person) applicationContext.getBean("person");
        System.out.println(person);

可以看到结果：
Person{id=1, name=‘张三’, car=Car{num=2, brand=‘奥拓’}}

byType，通过属性对应的数据类型自动装载。

其他的不变，把xml修改为：

    <!--    自动装载-->
    <bean id="person" class="com.sensen.springdemo.entity.Person" autowire="byType">
        <property name="id" value="1"></property>
        <property name="name" value="张三"></property>
    </bean>
    <bean id="car" factory-bean="carFactory" factory-method="getCar">
        <constructor-arg value="2"></constructor-arg>
    </bean>

注意的是需要把其他的Car类配置删除，不然spring无法识别你需要装载哪个Car。

Spring IoC 基于注解

新建一个项目，创建及格包：
controller，service，dao，entity。

在entity中新建user类：

package com.sensen.springboot.entity;

/**
 * @ClassName User
 * @Author linsen
 * @Date 2020/11/26 11:12
 **/
public class User {
    private int id;
    private String name;
    public User(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }

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

在dao中新建接口和实现类，模拟数据：

public interface  UserDAO {
    public User getUserById(int id);
}

public class UserDAOImpl implements UserDAO{

    private static Map<Integer,User> users;

    static{
        users = new HashMap<Integer,User>();
        users.put(1, new User(1, "张三"));
        users.put(2, new User(2, "李四"));
        users.put(3, new User(3, "王五"));
    }

    @Override
    public User getUserById(int id) {
        // TODO Auto-generated method stub
        return users.get(id);
    }

}

在service中新建接口和实现类:

public interface UserService {
    public User getUserById(int id);
}


public class UserServiceImpl implements UserService{
    
    private UserDAO userDAO;

    @Override
    public User getUserById(int id) {
        // TODO Auto-generated method stub
        return userDAO.getUserById(id);
    }

    public UserDAO getUserDAO() {
        return userDAO;
    }

    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }
}

最后在controller中新建类：

public class UserController {

    private UserService userService;

    public UserService getUserService() {
        return userService;
    }

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public User getUserById(int id){
        return userService.getUserById(id);
    }
}

之后是spring.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:component-scan base-package="com.sensen.springboot"></context:component-scan>-->
    <!-- 配置UserController -->
    <bean id="userController" class="com.sensen.springboot.controller.UserController">
        <property name="userService" ref="userService"></property>
    </bean>
    <!-- 配置UserService -->
    <bean id="userService" class="com.sensen.springboot.service.UserServiceImpl">
        <property name="userDAO" ref="userDAO"></property>
    </bean>
    <!-- 配置UserDAO -->
    <bean id="userDAO" class="com.sensen.springboot.dao.UserDAOImpl"></bean>
</beans>

新建main类：

public class ApplicationTest {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        UserController userController =(UserController)applicationContext.getBean("userController");
        System.out.println(userController.getUserById(1));
    }
}

即可输出结果：
User{id=1, name=‘张三’}

下面把项目改造成用注解实现，首先删除xml中所有配置，加上一句：
<context:component-scan base-package=“com.sensen.springboot”></context:component-scan>
这句话代表项目改用注解配置。

之后在各个类上加注解

@Controller
public class UserController {

    @Autowired
    private UserService userService;
..........................................
@Service
public class UserServiceImpl implements UserService{
	@Autowired
    private UserDAO userDAO;
...........................................
@Repository
public class UserDAOImpl implements UserDAO{

即可完成和上面一样的效果。类中属性的自动装载默认是通过 byType 的方式实现的。

当然也可以用byName的方式去完成：

将service的注解改成
@Service(“myUserService”)

之后再controller中自动装载service类时改成
@Autowired()
@Qualifier(“myUserService”)
private UserService userService;

效果相同，只是换成了byName的方式去装载。
@Qualifier() 中的值必须与 @Service() 中的值一致，才能完成自动装载。

源代码

两种方式配置ioc的代码

https://gitee.com/linsen97/spring-demo
https://gitee.com/linsen97/spring-demo2

简单的实现spring的ioc功能
https://gitee.com/linsen97/spring-ioc-impl

Spring高频面试基础问题与知识点整理
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
04-07 174万+
高频Spring相关基本面试题和知识点整理
Spring系列第3篇:基于XML的IOC环境搭建和入门
qq_29445811的博客
11-17 261
文章目录一、bean xml配置文件格式二、使用步骤1.引入库2.读入数据总结 一、bean xml配置文件格式 Bean概念 由spring容器管理的对象统称为Bean对象。Bean就是普通的java对象，和我们自己new的对象其实是一样的，只是这些对象是由spring去创建和管理的，我们需要在配置文件中告诉spring容器需要创建哪些bean对象，所以需要先在配置文件中定义好需要创建的bean对象，这些配置统称为bean定义配置元数据信息，spring容器通过读取这些bean配置元数据信息来构建和组装我
Spring IOC示例代码
ChesterChai的博客
07-13 867
在本文中不会对概念性的东西进行讲解，比如什么是IOC，因此不适合初学者。目的在于对学过Spring IOC的读者能快速复习相关的内容。更多细节建议参考其他资料。 使用Maven来管理项目，并在pom.xml文件中引入Spring <dependencies> <dependency> <groupId>org.springframewor...
Spring框架IOC的源码阅读[上]
QG_zhang的博客
01-31 510
写在前面的话,之前对Spring也仅仅会用的程度,偶然朋友提到过想实现Spring的IOC和AOP功能,看了git上面tiny-spring的实现,前辈的思路很清晰,于是便有了基于当前Spring最新版本Spring-5.1.4.RELEASE源码阅读和仿写的想法。 首先我们看看使用官方框架IOC如何使用 // 1.读取配置 ApplicationContext applicationCont...
手写代码实现spring的ioc功能
贾红平
06-18 8735
本篇文章和大家一起交流一下有关spring的ioc知识,并自己通过代码实现一个简单版的spring的IOC功能。首先看一下IOC基础知识的分享:一、分享Iteye的开涛对Ioc的精彩讲解　　首先要分享的是Iteye的开涛这位技术牛人对Spring框架的IOC的理解，写得非常通俗易懂，以下内容全部来自原文，原文地址：http://jinnianshilongnian.iteye.com/blog/1...
（一）Spring 之IOC入门简单例子
热门推荐
ZJE
01-20 1万+
1. IOC 和 DI 是什么 2.导入Spring 的jar 包 3.实现IOC简单例子的步骤 （一）IOC 和 DI是什么 IOC即控制反转，意思是对象的创建不通过 手动 new，而是把对象的创建权交给Spring来完成。 DI 即依赖注入，意思是 Spring主动创建被调用类的对象，然后把这个对象注入到我们自己的类中，使我们能使用它 （二）导入jar 包 下载s
Spring-IOC知识点整理
drug1910951117的博客
07-22 233
Spring是什么 Spring是分层的JavaSE/EE应用 full-stack轻量级开源框架 Spring体系结构 底层是核心容器 Beans Core Context SpringEL表达式 中间层技术 AOP Aspects 应用层技术 数据访问与数据集成 Web集成 Web实现 基于Test测试 IOC IOC（Inversion Of Control）控制反转，Spring反向控制应用程序所需要使用的外部资源 IOC入门案例 导入maven坐标 <d
SpringIoC知识点梳理
weixin_42426099的博客
03-08 257
Spring IoC（Spring Inversion of Control）：控制反转，一种编程思想。我理解就是把管理对象的权力，由直接通过程序变为通过Spring容器，如此统一的来管理对象和对象间的关系 DI（Dependency Injection）：依赖注入，Spring通过DI，实现了IoC 文章目录1.通过Spring来创建对象2.获取Spring创建的对象3.Bean的作用域4.B...
Spring IOC知识点一网打尽！
BASK2311的博客
01-12 275
在《精通Spring4.x 企业应用开发实战》中对IOC的定义是这样的：IoC(Inversion of Control)控制反转，包含了两个方面：一、控制。二、反转当前对象对内部成员的控制权。反转指的是：这种控制权不由当前对象管理了，由其他(类,第三方容器)来管理。IOC不够开门见山，于是Martin Fowler提出了DI(dependency injection)来替代IoC，即让调用类对某一接口实现类的依赖关系由第三方(容器或协作类)注入，以移除调用类对某一接口实现类的依赖。
Spring IoC知识点整理
墨客人生的博客
06-28 678
1、IOC     1.1、IOC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入）？         依赖注入是控制反转的一种方式。控制反转是一种可以帮助我们解耦各业务对象间依赖关系的对象绑定方式。IOC容器主要的作用有：业务对象的构建管理和业务对象间的依赖绑定。     1.2、依赖注入的三种方式？         构造方
SpringIOC(最新整理).pdf
06-16
本文档为Spring开发者提供了配置bean的全面指导，无论是XML方式还是注解方式，都涉及到了Spring IoC中实现依赖注入和bean生命周期管理的核心知识。开发者应能够根据具体情况选择最合适的配置方式，以提高开发效率并...
精选资源
Spring IOC和AOP代码与笔记整理
12-07
Spring框架是Java开发中不可或缺的一部分，它以IoC（Inversion of Control，控制反转）和AOP（Aspect Oriented Programming，面向切面编程）为核心，极大地简化了企业级应用的开发工作。本篇将深入探讨Spring的这两...
Spring之IOC(DI)附面试题准备
梁同学Coding博客
11-05 578
写在前面：艾瑞巴蒂~好久没更新了。中途发生比较多的事情，等后面文章里慢慢会介绍哈。嘿嘿，登上公众号后台发现最近还多了几位朋友关注我的公众号。感谢。一定抽空多写几篇文章哈!把最好的一面展现给...
Java 并发编程：JUC 包中原子操作类的原理和用法
m0_69632475的博客
01-09 300
通过上一部分的分析，我们应该基本理解了 CAS 的无锁思想，并对“魔法类” Unsafe 有了更全面的了解。这也是我们分析原子包的前提。接下来，让我们一步步分析 CAS 在 Java 中的应用。JDK5 之后，JUC 包提供了包，该包下提供了大量基于 CAS 的原子操作类。如果在未来你不希望对程序代码加锁，但又想避免线程安全问题，那么可以使用该包下提供的类。Atomic 包提供的操作类主要可以分为以下四种类型：基本类型原子操作类引用类型原子操作类数组类型原子操作类属性更新原子操作类。
面向微服务事件驱动与异步消息可靠处理的互联网系统高可用设计与多语言工程实践分享
2501_94180531的博客
01-05 515
事件驱动解耦服务，提高吞吐可靠投递与幂等消费保证消息一致性监控、重试与顺序控制是稳定性的关键微服务事件驱动与异步消息可靠处理，使系统在高并发和复杂业务场景下保持稳定与可控。通过在多语言系统中统一幂等语义、结合可靠投递、顺序控制和监控策略，互联网系统能够在异步流程中实现高可用和长期可维护性。这篇关于事件驱动与异步消息可靠处理的工程实践分享，希望为你在微服务高可用设计中提供可落地、长期有效的参考思路。
Java 25 switch - 表达式多条件判断
最新发布
java界的小学生
01-09 89
Java 25 switch - 表达式多条件判断 记录模式‌：支持复杂对象的模式匹配。
windows下的守护进程|nssm
slongzhang的博客
01-06 1180
NSSM（Non-Sucking Service Manager）是Windows系统中将普通程序封装为系统服务的工具。使用步骤包括：下载解压NSSM，以管理员身份运行CMD/PowerShell；通过图形界面或命令行安装服务，配置可执行文件路径、参数等；使用start/stop/restart命令管理服务；支持通过edit命令修改配置或remove删除服务；建议配置日志功能方便排查问题。核心功能是实现进程守护，确保程序异常退出后自动重启。
Web开发者进阶AI：Agent技能设计模式之迭代分析与上下文聚合实战
沛哥儿的专栏
01-09 624
迭代有界：必须设置maxDepth（如同Web分页的maxPage） 上下文隔离：按会话ID分区存储（Redis key前缀隔离） 技能自治：每个Skill保持无状态（如同RESTful原则）
SpringBoot3 + GraalVM安装和初次打包
风不知从何处起的小屋
01-08 597
本文介绍了使用GraalVM将Spring Boot项目打包为原生可执行文件的完整流程。
springioc知识点
02-22
嗯，用户让我介绍一下Spring IoC的知识点，我需要先回忆一下自己学过的相关内容。首先，IoC，也就是控制反转，是Spring框架的核心之一。那什么是控制反转呢？应该是指将对象的创建和依赖关系的管理从应用程序代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值