[Spring框架]Spring实现IOC（控制反转）的方式

最新推荐文章于 2022-03-02 19:39:30 发布
最新推荐文章于 2022-03-02 19:39:30 发布
阅读量223 收藏
点赞数
分类专栏： Spring框架 文章标签： IOC的实现方式

Spring IOC的原理及详解


这里感谢 CSDN 的原博客： https://blog.csdn.net/zhaoraolin/article/details/78941062

1. IOC理论的背景

在平时的java应用开发中，我们要实现某一个功能或者说是完成某个业务逻辑时至少需要两个或以上的对象来协作完成，在没有使用Spring的时候，每个对象在需要使用它的合作对象时，自己均要使用像new object() 这样的语法来将合作对象创建出来，这个合作对象是由自己主动创建出来的，创建合作对象的主动权在自己手上，自己需要哪个合作对象，就主动去创建，创建合作对象的主动权和创建时机是由自己把控的，而这样就会使得对象间的耦合度高了，A对象需要使用合作对象B来共同完成一件事，A要使用B，那么A就对B产生了依赖，也就是A和B之间存在一种耦合关系，并且是紧密耦合在一起，而使用了Spring之后就不一样了，创建合作对象B的工作是由Spring来做的，Spring创建好B对象，然后存储到一个容器里面，当A对象需要使用B对象时，Spring就从存放对象的那个容器里面取出A要使用的那个B对象，然后交给A对象使用，至于Spring是如何创建那个对象，以及什么时候创建好对象的，A对象不需要关心这些细节问题(你是什么时候生的，怎么生出来的我可不关心，能帮我干活就行)，A得到Spring给我们的对象之后，两个人一起协作完成要完成的工作即可。

2. code

/** 
 * 一个伟大的程序员类 
 * */  
public class Programmer {  
  
    private String name;  
    private String sex;  
      
    public void coding(){  
        //要用到computer对象，调用computer的coding方法，  
        //在这里new computer对象，控制权在Programmer手里  
        Computer computer = new Computer();  
        computer.coding();  
    }  
}

public class Computer {  
      
    private String brand;  
    private String color;  
    private double size;  
      
    public void coding() {  
        System.out.println("Computer is coding!!!");  
    }  
}

上面，就是用传统方式创建依赖对象。接下来，看看Spring IOC是怎样反转控制权来创建对象的。

3. 三种方式：属性注入，构造器注入，自动装配。

3.1 属性注入（setter注入）

public class Programmer {  
  
    private String name;  
    private String sex;  
  
    // 在这里定义要依赖的computer属性，加上set方法  
    private Computer computer;  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public String getSex() {  
        return sex;  
    }  
  
    public void setSex(String sex) {  
        this.sex = sex;  
    }  
  
    public Computer getComputer() {  
        return computer;  
    }  
  
    /** 
     * 加上Setter方法 
     * */  
    public void setComputer(Computer computer) {  
        this.computer = computer;  
    }  
}  

public class Computer {  
      
    private String brand;  
    private String color;  
    private String size;  
      
    public void coding() {  
        System.out.println("Computer is coding!!!");  
    }  
  
    public String getBrand() {  
        return brand;  
    }  
  
    public void setBrand(String brand) {  
        this.brand = brand;  
    }  
  
    public String getColor() {  
        return color;  
    }  
  
    public void setColor(String color) {  
        this.color = color;  
    }  
  
    public String getSize() {  
        return size;  
    }  
  
    public void setSize(String size) {  
        this.size = size;  
    }    
}

看上面的代码，可以发现，Programmer类里面，有3个属性，name,sex,computer，并且都有对应的getter、setter方法；Computer类里面也有三个属性，分别是品牌、颜色、尺寸，也都有对应的getter、setter方法。这只是第一步，在类里面声明属性并且实现set方法。

接下来，要写一个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"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">  
      
  <bean id="programmer" class="com.spring.demo2.entity.Programmer">  
    <property name="name" value="小李"></property>  
    <property name="sex" value="男"></property>  
    <property name="computer" ref="computer"></property>  
  </bean>  
   
  <bean id="computer" class="com.spring.demo2.entity.Computer">  
    <property name="brand" value="hp"></property>  
    <property name="color" value="黑"></property>  
    <property name="size" value="14"></property>  
  </bean>  
</beans>

解读一下这个xml文件：
1.声明一个bean，可以理解为实例化了一个对象。那这里实例化了两个对象（programmer和computer），各个属性都已经赋值上去。

2.id为programmer的bean，其实就是Programmer类；通过给property赋值，Spring就会通过Programmer类的各个属性的set方法，逐一给Programmer的属性赋值。

3.在programmer里面，有一个属性是computer的，可以看到它属性值是 ref=“computer”，这就说明computer这个属性是个引用，这里ref后面的值其实就是指向另一个bean的id值，所以这里引用的是id为computer的bean。

以上，就是属性注入了。关键的是在类里面声明属性，写set方法，然后在xml里面配置bean和property的值。

3.2. 构造器注入

构造器注入，顾名思义，就是在构造器里面注入依赖对象。那是怎么实现的呢？其实跟属性注入差不多，定义一个有参构造器，然后配置xml文件就行了。看代码：

import com.spring.demo02.entity.Computer;  
  
public class Programmer {  
      
    private Computer computer;  
      
    public Programmer(Computer computer){  
        this.computer = computer;  
    }  
} 

public class Computer {  
  
    private String brand;  
    private String color;  
    private String size;  
  
    public Computer(String brand, String color, String size) {  
        this.brand = brand;  
        this.color = color;  
        this.size = size;  
    }  
}

上面两个类都有一个有参的构造器，接下来，在xml里面配置这两个bean，然后再配置构造器的参数值就可以了

<?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-3.0.xsd">  
      
  <bean id="programmer" class="com.spring.demo3.entity.Programmer">  
    <constructor-arg ref="computer"></constructor-arg>  
  </bean>  
    
  <!-- 构造器里面没有name字段，只有value，是根据构造器的方法参数顺序来定义的 -->  
  <bean id="computer" class="com.spring.demo3.entity.Computer">  
    <constructor-arg value="联想"></constructor-arg>  
    <constructor-arg value="红色"></constructor-arg>  
    <constructor-arg value="15.6寸"></constructor-arg>  
  </bean>  
    
</beans>

3.3. 自动装配


import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Component;  
  
@Component  
public class Programmer {  
      
    @Autowired  
    Computer computer;  
  
} 

import org.springframework.stereotype.Component;  
  
@Component  
public class Computer {  
    private String brand;  
    private String color;  
    private String size;
 
    public String getBrand() {  
        return brand;  
    }  
  
    public void setBrand(String brand) {  
        this.brand = brand;  
    }  
  
    public String getColor() {  
        return color;  
    }  
  
    public void setColor(String color) {  
        this.color = color;  
    }  
  
    public String getSize() {  
        return size;  
    }  
  
    public void setSize(String size) {  
        this.size = size;  
    }  
}


<?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/context   
    http://www.springframework.org/schema/context/spring-context-3.0.xsd   
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">  
      
    <context:component-scan base-pakage="com.spring.demo04">  
    
</beans>

关键点：在类前面加注解：@Component，在需要注入的类里面加注解：@Autowired，这样xml里面的自动扫描就会扫描到这些加了注解的类和属性，在实例化bean的时候，Spring容器会把加了@Component的类实例化；在实际运行时，会给加了@Autowired的属性注入对应的实例。

Spring中的自动装配有哪些限制？

  1. 如果使用了构造器注入或者setter注入，那么将覆盖自动装配的依赖关系。
  2. 基本数据类型的值、字符串字面量、类字面量无法使用自动装配来注入。
  3. 优先考虑使用显式的装配来进行更精确的依赖注入而不是使用自动装配。

和自动装配相关的注解有哪些？

  1. @Required：该依赖关系必须装配（手动或自动装配），否则将抛出BeanInitializationException异常。
  2. @Autowired：自动装配，默认按类型进行自动装配。
  3. @Qualifier：如果按类型自动装配时有不止一个匹配的类型，那么可以使用该注解指定名字来消除歧义。
  • 注释的作用
徐俊生
关注
专栏目录
Spring——Spring核心（IoC）控制反转详细说明
Java_zhujia的博客
11-15 537
控制反转IoC(Inversion of Control） 是一个概念，是一种思想。指将传统上由程序代码直接操控的对象调用权交给容器，通过容器来实现对象的装配和管理。控制反转就是对对象控制权的转移，从程序代码本身反转到了外部容器。通过容器实现对象的创建，属性赋值， 依赖的管理。IoC 是一个概念，是一种思想，其实现方式多种多样。当前比较流行的实现方式是依赖注入。应用广泛。
Spring实现控制反转（IOC）的三种方式（零）——理解IOC
格局、视野、认知
10-12 1304
学过Spring的应该都知道Spring的IOC和AOP，然而我刚接触Spring不久，学习了IOC，发现掌握的不是很好，停留在概念上，今天就以例子来总结一下Spring的IOC。也希望各位大大能够指点迷津。 IOC：也就是控制反转（创建对象实例的控制权反转），说的是一个类A要调用另一个类B，本来应该在类A里面创建B的实例的，控制权在A手里。现在用了Spring了，有了IOC，控制权就不在A手里
IOC控制反转原理spring
ZJH
03-02 1409
IOC概念 定义：控制反转，把对象的创建和调用（传统方式是通过new之后直接使用对象），交给Spring进行管理（依靠对象工厂通过注入的方式获取对象） 降低耦合度 底层原理：xml解析、工厂模式、反射 补：工厂模式和单例模式区别 单例模式（懒汉式，饿汉式）都只能创建一个指定类的唯一对象 工厂模式（一个接口，多态性的体现）可以创建该接口的工厂下的所有类的唯一对象 工厂模式和单例模式的区别 IOC接口——实现IOC容器 IOC容器可以有多个，new几个就有几个IOC容器，一个容器绑定一个xml文件，一个xm
(二) Spring核心之控制反转（IoC）
lyj_010的博客
09-20 279
基本概念 技术描述 实现方法
Spring实现控制反转（IOC）的三种方式（三）——自动装配
格局、视野、认知
10-12 2097
续：Spring实现控制反转（IOC）的三种方式（零）——理解IOC Spring实现控制反转（IOC）的三种方式（一）——属性注入 Spring实现控制反转（IOC）的三种方式（二）——构造器注入 前面简单的说了Spring IOC注入实例的两种方式，下面也是从菜鸟角度来说说自动装配的方式。 package com.spring.demo04.entity; impor
Spring框架的控制反转（IOC）如何简单理解
qq_42777577的博客
11-17 482
控制反转（IOC）的一个spring框架很重要的特点，那到底什么是控制反转，控制反转有什么用呢？ 什么是控制反转呢？ （百度百科）控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency ...
Spring框架控制反转IOC和依赖注入DI详解
01-20
本文介绍了Spring框架中的控制反转IOC和依赖注入DI，欢迎阅读，共同学习，一起进步。 Spring框架基础参考：深入学习Spring基础 文章目录一.入门程序和IOC简介二.IOC-控制反转三.DI-依赖注入四. IOC和DI五.Spring...
Spring框架IoC控制反转.pdf
最新发布
09-20
【Spring框架IoC控制反转】 一、Spring框架是什么 Spring框架是Java开发中的一款轻量级框架，诞生于2003年，旨在简化企业级应用的开发复杂性。Spring的核心理念包括控制反转（IoC）和面向切面编程（AOP）。作为一...
Java仿Spring框架IOC控制反转利用反射简单实现(源码)
12-11
Java中的控制反转（IOC，Inversion of Control）和Spring框架是现代企业级应用开发的核心概念。IOC使得应用程序的组件之间解耦，提高了代码的可测试性和可维护性。本篇文章将详细探讨如何通过反射机制来实现一个简单...
Java spring webmvc如何实现控制反转
08-18
"Java Spring WebMVC 实现控制反转" 控制反转（Inversion of Control，IoC）是软件设计中的一种原则，指的是在软件设计中，将控制权从对象中抽象出来，交给第三方来管理。Java Spring WebMVC 中的控制反转主要通过...
Spring 框架学习—控制反转（IOC）
weixin_34150830的博客
10-28 946
Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架，主要用于降低模块之间耦合度的框架，实际上Spring除了能够通过IoC降低模块之间的耦合度外还提供了其它功能。1、IoC的基础知识以及原理： ...
Spring之控制反转：IOC
GeXueliu的博客
12-03 192
IOC：控制反转，把对象交给框架创建 基于xml的IOC spring默认使用无参构造创建对象，但当有参构造覆盖了无参构造时，需注入有参构造的参数 //存在无参构造，创建对象 <bean id="acountDao" class="cn.itcast.dao.impl.AccountDaoImpl"> </bean> //无参构造不存在，只有有参构造创建对象 &lt...
Spring 面试题
thatkrisyang
03-08 585
Java面试中的Spring方面问题 https://www.cnblogs.com/threetop/p/9474016.html 1、一般问题 1.1. 不同版本的 Spring Framework 有哪些主要功能？ VersionFeatureSpring 2.5发布于 2007 年。这是第一个支持注解的版本。Spring 3.0发布于 2009 年。它完全利用了 Java5 中的改进，...
Spring实现IOC（控制反转）的三种方式
旧城以西的博客
12-31 1万+
IOC：也就是控制反转（创建对象实例的控制权反转），说的是一个类A要调用另一个类B，本来应该在类A里面创建B的实例的，控制权在A手里。现在用了Spring了，有了IOC，控制权就不在A手里了，而是交到Spring的IOC容器了，A要用到B，那Spring就把B分给A了。 下面通过具体的例子来说明： package com.spring.demo.entity; /** * 一个伟
Spring框架中IoC(控制反转)的原理
热门推荐
茕夜
05-26 4万+
一.IoC的基础知识以及原理： 1.IoC理论的背景：在采用面向对象方法设计的软件系统中，底层实现都是由N个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。即软件系统中对象之间的耦合，对象A和对象B之间有关联，对象B又和对象C有依赖关系，这样对象和对象之间有着复杂的依赖关系，所以才有了控制反转这个理论。 2.什么是控制反转(IoC)： (1).IoC是Inver
Spring实现控制反转（IOC）的三种方式（一）——属性注入
格局、视野、认知
10-12 1770
续上一篇：Spring实现控制反转（IOC）的三种方式（零）——理解IOC 这篇文章，来理解一下Spring IOC的属性注入（set注入）方法。还是用上一篇的程序员写代码的例子。 package com.spring.demo02.entity; public class Programmer { private String name; private String sex
spring IOC(控制反转)和DI(依赖注入)以及三种依赖注入方式的比较
慕言小鹏
02-07 1667
1.Spring中IOC的优点是什么？IOC 或 依赖注入把应用的代码量降到最低。它使应用容易测试，单元测试不再需要单例和JNDI查找机制。最小的代价和最小的侵入性使松散耦合得以实现。IOC容器支持加载服务时的饿汉式初始化和懒加载2.什么是Spring的依赖注入？依赖注入，是IOC的一个方面，是个通常的概念，它有多种解释。这概念是说你不用创建对象，而只需要描述它如何被创建。你不用在代码里直接组装你...
ioc容器的实现方法有哪些_弄清楚Spring的Ioc(控制反转)和DI(依赖注入)
weixin_39938312的博客
11-24 216
弄清楚Spring的Ioc(控制反转)和DI(依赖注入)开头先理解清楚Ioc(控制反转)和DI(依赖注入)，这个是看本文的重点Ioc目的是解耦耦合关系不仅会出现在对象与对象之间，也会出现在软件系统的各模块之间，以及软件系统和硬件系统之间。如何降低系统之间、模块之间和对象之间的耦合度，是软件工程永远追求的目标之一。为了解决对象之间的耦合度过高的问题，软件专家Michael Mattson提出了IOC...
Spring IOC（控制反转）的三种依赖注入方式
qq_35504206的博客
07-06 2720
1）、什么是依赖注入（DI）和控制反转（IOC）依赖注入和控制反转是对同一件事情的不同描述，从某个方面来讲，就是他们描述的角度不同。依赖注入是从应用程序的角度在描述，应用程序依赖容器创建并注入它所需要的外部资源；控制反转是从容器的角度在描述，描述完整点：容器控制应用程序，由容器反向的向应用程序注入应用程序所需要的外部资源。当某个角色（一个java实例，调用者）需要另外一个角色（另外一个java实例...
Spring框架深度解析：IOC控制反转与核心组件
4. **Spring API**：Spring框架提供了大量的API，包括IoC（Inversion of Control，控制反转）容器，使得开发者可以将对象的创建、初始化和销毁工作交由Spring管理。例如，通过`ClassPathXmlApplicationContext`启动...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值