Spring之理解IOC（控制反转）

已于 2022-06-29 16:43:22 修改
阅读量445 收藏 1
点赞数
文章标签： spring java 后端
于 2022-06-29 15:35:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42338744/article/details/125514896
版权

文章目录

一、IOC是什么？

控制反转IOC（Inversion of Control）是一个概念，是一种思想。由Spring容器进行对象的创建和依赖注入。程序员在使用时直接取出使用即可。
正转：由程序员进行对象的创建和依赖注入称为正转。程序员说了算。

Student stu = new Student(); =====>程序员创建对象
stu.setName("小明");         =====>程序员进行赋值
stu.setAge(22);

反转：由Spring容器创建对象和依赖注入称为反转，将控制权从程序员手中夺走，交给Spring容器，称为反转。

<bean id="stu" class="com.bjpowernode.pojo.Student"> ==>Spring容器创建对象
	<property name="name" value="小明">           ==>Spring容器依赖注入值
	<property name="age" value="22">
</bean>

测试：
学生实体类：

public class Student {
    private String name;
    private int age;

    public Student() {
        System.out.println("创建学生对象");
    }

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

由程序员创建对象：

    @Test
    public void testStudent1(){
        Student stu = new Student();
    }

运行结果：
在这里插入图片描述

applicationContext.xml

    <bean id="stu" class="com.bjpowernode.pojo.Student"></bean>

由Spring容器创建对象：

 @Test
    public void testStudent2(){
        //由Spring容器进行对象创建
        //如果想从Spring容器中取出对象，则要先创建容器对象并启动才可以取对象
       ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
       //取对象
       Student stu = (Student) ac.getBean("stu");
    }

运行结果同上。

二、基于XML的IOC

2.1 创建对象

    <bean id="stu" class="com.bjpowernode.pojo.Student"></bean>

2.2 给创建的对象赋值

2.2.1 使用setter注入

注入分为简单类型注入和引用类型注入

2.2.1.1 简单类型注入使用value属性

同上。

2.1.1.2 引用类型注入使用ref属性

注意：使用setter注入必须提供无参的构造方法，必须提供setXXX()方法
引用类型注入代码（给学生添加一个学校属性，表明这个学生是哪个学校的）：
School实体类：

public class School {
    private String name;
    private String address;

    //为了给成员变量注入值，必须提供无参构造方法和setXXX()方法


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

    public void setAddress(String address) {
        this.address = address;
    }

    public School(){
        System.out.println("学校的无参构造方法被调用。。。");
    }

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

applicationContext.xml文件，创建学校对象：

    <bean id="school" class="com.bjpowernode.pojo.School">
        <property name="name" value="西西大学"></property>
        <property name="address" value="西西区"></property>
    </bean>

Student实体类（加入学校属性以及set方法）：

public class Student {
    private String name;
    private int age;
    private School school;

    public void setSchool(School school) {
        this.school = school;
    }
    public Student() {
        System.out.println("创建学生对象");
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", school=" + school +
                '}';
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    public void setAge(int age) {
        this.age = age;
    }
}

applicationContext.xml文件，创建学生对象，对于学校属性使用ref注入：

<bean id="stu" class="com.bjpowernode.pojo.Student">
        <property name="name" value="小明"></property>
        <property name="age" value="22"></property>
        <property name="school" ref="school"></property>
</bean>

测试：

    @Test
    public void testStudent2(){
        //由Spring容器进行对象创建
        //如果想从Spring容器中取出对象，则要先创建容器对象并启动才可以取对象
       ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        //取对象 
       Student stu =(Student) ac.getBean("stu");
       System.out.println(stu);
    }

运行结果：
在这里插入图片描述

2.2.2 使用构造方法注入

Student stu = new Student(“小明”,22);

2.2.2.1 使用构造方法的参数名称进行注入值

学校实体类（没有无参构造方法、没有set方法）：

public class School {
    private String name;
    private String address;

    //使用带参构造方法注入值
    public School(String name, String address) {
        this.name = name;
        this.address = address;
    }

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

创建学校对象，并注入值：

    <bean id="school" class="com.bjpowernode.pojo.School">
       <constructor-arg name="name" value="西西大学"></constructor-arg>
        <constructor-arg name="address" value="西西区"></constructor-arg>
    </bean>
2.2.2.2 使用构造方法参数的下标注入值
 <bean id="school" class="com.bjpowernode.pojo.School">
       <constructor-arg index="0" value="西西大学"></constructor-arg>
        <constructor-arg index="1" value="西西区"></constructor-arg>
    </bean>
2.2.2.3 使用默认的构造方法的参数的顺序注入值
    <bean id="school" class="com.bjpowernode.pojo.School">
       <constructor-arg  value="西西大学"></constructor-arg>
        <constructor-arg value="西西区"></constructor-arg>
    </bean>

三、基于注解的IOC

也成为DI（Dependency Injection），它是IOC具体实现的技术。
基于注解的IOC，必须要在Spring的核心配置文件中添加包扫描。
当前实体类所在的包名：

<context:component-scan base-package="com.bjpowernode.pojo"></context:component-scan>

3.1 创建对象的注解

@Component：可以创建任意的对象

@Component
public class Student {
    private String name;
    private int age;

    public Student() {
        System.out.println("学生的无参构造方法调用了。。。");
    }

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

测试类：

@Test
    public void testStudent1(){
       ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    }

运行结果：
在这里插入图片描述

@Controller：专门用来创建控制器的对象，这种对象可以接受用户的请求，可以返回处理结果给客户端
@Service：专门用来创建业务逻辑层的对象，负责向下访问数据访问层，处理完毕后的结果返回给界面层
@Repository：专门用来创建数据访问层的对象，负责数据库中的增删改查所有操作

3.2 依赖注入的注解

3.2.1 值类型的注入：

@Value：用来给简单类型注入值

@Component("stu")
public class Student {
    @Value("小红")
    private String name;
    @Value("22")
    private int age;

    public Student() {
        System.out.println("学生的无参构造方法调用了。。。");
    }

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

测试：

    @Test
    public void testStudent1(){
       ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
       Student stu = (Student) ac.getBean("stu");
       System.out.println(stu);
    }

运行结果：
在这里插入图片描述

3.2.1 引用类型的注入：

@Autowired：使用类型注入值，从整个Bean工厂中搜索同源类型的对象进行注入。
什么是同源类型：

  • 被注入的类型与注入的类型是完全相同的类型
  • 被注入的类型（父）与注入的类型（子）是父子类
    在有父子类的情况下，使用按类型注入，就意味着有多个可注入的对象，此时按照名称进行二次筛选，选中与被注入对象相同名称的对象进行注入。
  • 被注入的类型（接口）与注入的类型（实现类）是接口和实现的类型
    学校实体类：
@Component//交给spring去创建对象
public class School {//此时school对象的名称就是school
    @Value("西西西大学")
    private String name;
    @Value("西西西区")
    private String address;
    public School() {
        System.out.println("school的无参构造方法调用了。。。");
    }
    @Override
    public String toString() {
        return "School{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

学生实体类：

@Component("stu")//交给spring去创建对象
public class Student {
    @Value("小红")
    private String name;
    @Value("22")
    private int age;
    //引用类型按类型注入
    @Autowired
    private School school;
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", school=" + school +
                '}';
    }
}

XML文件中的包扫描记得添加
测试类同3.2.1中的测试
运行结果：
在这里插入图片描述

@Qualifier：使用名称注入值，从整个Bean工厂中搜索相同名称的对象进行注入
学生实体类 （多添加一个@Qualifier）：

@Component("stu")
public class Student {
    @Value("小红")
    private String name;
    @Value("22")
    private int age;
    //引用类型按类型注入
    @Autowired
    private School school;
    @Override
    @Qualifier("school")
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", school=" + school +
                '}';
    }
}

其余都一样。

Bwy_1004
关注
Spring 框架学习—控制反转（IOC）
weixin_34150830的博客
10-28 939
Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架，主要用于降低模块之间耦合度的框架，实际上Spring除了能够通过IoC降低模块之间的耦合度外还提供了其它功能。1、IoC的基础知识以及原理： ...
Spring IOC 控制反转
10-24
接下来，我们通过一个简单的示例代码来进一步理解Spring IOC控制反转的实现过程： ```java // 定义一个DAO层接口 public interface UserDao { void save(); } // DAO层接口的实现类 public class UserDaoImpl ...
谈谈Spring Ioc的理解
10-20 315
原文：http://blog.csdn.net/qq_22654611/article/details/52606960 学了几天Ioc了，但是对它的理解还是模模糊糊，看了这篇博客感觉对Ioc有了更深的理解一 一、分享Iteye的开涛对Ioc的精彩讲解 　　首先要分享的是Iteye的开涛这位技术牛人对Spring框架的IOC的理解，写得非常通俗易懂，以下内容全部来自原文，原文地址：...
Spring控制反转(IoC)的理解
张凡的专栏
12-06 448
原文及讨论：http://bbs.bccn.net/thread-82938-1-1.htmlSpring框架的核心就是控制反转(Inversion of Control)和依赖注入(Dependency Injection)，通过这两方面来实现松耦合。    使用IoC，对象是被动的接受依赖类，而不是自己主动的去找。容器在实例化的时候主动将它的依赖类注入给它。可以这样理解：控制反转将类的
对Spring IOC控制反转的详细理解
qq_53999369的博客
06-10 906
Spring中对IOC控制反转的理解，关于生成的对象的生成、生命周期、线程安全和循环依赖问题。
Spring学习之Spring的IOC原理了解（Spring控制反转原理了解）
qq_39746820的博客
04-26 383
控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。
Spring深入理解控制反转-IOC
最新发布
10-01
基于annotation注解方式理解SpringIOC控制反转
Spring框架IoC控制反转.pdf
09-20
【Spring框架IoC控制反转】 一、Spring框架是什么 Spring框架是Java开发中的一款轻量级框架，诞生于2003年，旨在简化企业级应用的开发复杂性。Spring的核心理念包括控制反转（IoC）和面向切面编程（AOP）。作为一...
helloIoc.zip spring ioc控制反转简单测试代码
01-13
Spring框架的核心特性之一就是依赖注入（Dependency Injection，简称DI），它通过控制反转（Inversion of Control，简称IOC）实现。这个"helloIoc.zip"压缩包包含的是一组用于演示Spring IOC基本概念和使用的测试...
理解Spring中的IoC控制反转与依赖注入
"Spring中使用Ioc控制反转" 在Spring框架中，IoC（Inversion of Control）控制反转是一种设计原则，它改变了传统程序中的控制流程，将对象的创建和管理权交给了外部容器，即Spring IoC容器。这一概念的核心在于解耦...
Spring——Spring核心（IoC）控制反转详细说明
weixin_44606952的博客
09-01 1510
1. 控制反转描述 2. 创建Spring程序 2.1 创建Maven项目+配置文件 2.2 创建实体类 2.3 配置Spring的xml文件，使用Spring 容器创建对象 2.4 测试类 3. 注入的分类 3.1 set注入 3.1.1 简单类型的注入 3.1.2 引用类型的注入 3.2 构造方法的注入 3.2.1 使用构造方法参数名称注入 3.2.2 使用构造方法的参数索引下标注入 3.2.3 使用默认顺序注入 3.4 注解注入 3.4.1 注解类型 3.4.2 注解类型的使用...
【Spring】理解Ioc控制反转
愿万事胜意
05-16 268
IoC 全称为Inversion of Control，翻译为 “控制反转”，它还有一个别名为 DI（Dependency Injection）,即依赖注入。依赖注入这个词让人望而生畏，现在已经演变成一项复杂的编程技巧或设计模式理念。但事实证明，依赖注入并不像它听上去那么复杂。在项 目中应用DI，你会发现你的代码会变得异常简单并且更容易理解和测试。本篇文章将主要介绍Ioc的概念和作用，以及Ioc是如何解决程序的耦合性问题的。 程序的耦合 耦合指的就是就是对象之间的依赖性。耦合具有两面性：一方面，紧密耦.
Spring IOC（控制反转）的理解
m0_38114797的博客
04-29 224
本文大部分来自：https://www.cnblogs.com/Mr-Rocker/p/7721824.html 学习过Spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念，对于初学Spring的人来说，总觉得IoC 、DI这两个概念是模糊不清的，是很难理解的，今天和大家分享网上的一些技术大牛们对Spring框架的IOC的理解以及谈谈我对Spring I...
对于Spring的IOC控制反转的理解
m0_57713282的博客
05-20 251
一：IOC:全名是InverseObject Control，意为反转对象控制，所谓控制指的是对象的创建控制权，也就是说，把创建对象的控制权反转，对象交给spring去创建（原来的创建控制权在我们手里，我们需要的时候就直接通过new关键字创建对象），这样做的好处是降低了类与类之间的耦合性 二：降低耦合性的体现之一是面向接口编程，如Service类中直接注入Dao接口成员变量，通过Dao接口调用接口方法，Dao接口实现类由容器Spring容器创建，那么Service就不用依赖于Dao接口的具体实现了。Da.
详解Spring Ioc（控制反转）
qq_41934990的博客
07-05 358
Spring Ioc 控制反转是一个比较抽象的概念，可以举例来说明。 生活中，人们要用到一种东西，人们的基本想法就是找到东西，比如想喝果汁，在没有饮品店的日子里，最直接的做法就是，买果汁机，水果，准备开水。这时我们“主动”创造的过程，也就是一杯果汁需要主动去创造。 而现在果汁店遍地都是，想喝果汁，第一想法就是打开手机，搜索果汁店，根据自己喜欢的口味下单，等待外卖小哥来送果汁，注意：这里我们没有“主动”创造果汁，是由饮品店创造的，而不是我们，但是也达到了要求是不是。 通过上面的简单的例子，我们从中可以看
Spring中的IOC（控制反转）
m0_71013414的博客
06-15 494
DI（依赖注入）是一种实现IOC的一种方法，也有人认为DI只是IOC的另一种说法，没有IOC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序员自己控制，控制反转后，将对象的创建转移给了第三方，个人认为所谓的控制反转就是，获取依赖对象的方式反转了。采用XML方式配置Bean的时候，Bean的定义信息和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。@Component有几个衍生注解。
Spring核心之IoC控制反转详细解释----从入门到精通
一个小小白的成长之路的博客
04-19 616
1、IoC概念 Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。 IoC 是指在程序开发中，实例的创建不再由调用者管理，而是由 Spring 容器创建。Spring 容器会负责控制程序之间的关系，而不是由程序代码直接控制，因此，控制权由程序代码转移到了 Spring 容器中，控制权发生了反转，这就是 Spring 的 IoC 思想。（简单的说，我们之前创建对象或者实例，都是通过构造方法new一个出来，或者通过反射、克隆，序列化，动态代理等创建，而我们学习
Spring之IOC
猎户星座
06-11 186
什么叫控制反转 为什么叫做控制反转呢。 在传统的模式下，我想要使用另外一个非静态对象的时候会怎么做呢，答案就是 new 一个实例出来。 举个例子，假设有一个 Logger 类，用来输出日志的。定义如下： public class Logger { public void log(String text){ System.out.println("log:" + text); } } 那现在我要调用这个 log 方法，会怎么做呢。 Logger logger =
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值