IOC理论

最新推荐文章于 2024-05-07 14:13:00 发布
最新推荐文章于 2024-05-07 14:13:00 发布
阅读量138 收藏
点赞数
文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/axiyshsa/article/details/131139372
版权

IOC的原型

程序员不再管理对象的创建，更专注于业务的实现（会大大降低系统的耦合性）

一个好的程序秉承着高内聚低耦合的思想

IOC的本质（对象由Spring来创建、管理、装配）

IOC是一种设计思想，DI（依赖注入）只是实现IOC的一种方法
IOC是一种编程思想，由主动编程变为被动接收

IOC的实现方法

IOC是Spring框架的核心内容，有多种方式来实现：

  • 使用xml配置
  • 使用注解
  • 新版本的Spring也可以零配置实现IOC
    Spring容器在初始化时现读取配置文件，根据配置文件或元数据创建于组织对象存入容器中，程序使用时再从IOC容器中取出需要的对象

控制反转

控制（由Spring来创建）反转（程序本身不再创建对象，而是被动的接受对象）是一种描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IOC容器，其实现方法是依赖注入（DI）（依赖注入：利用set来实现注入）

Spring官网

https://docs.spring.io/spring-framework/reference/core/beans/basics.html

代码理解

User.java

package com.dao;

public class Users {
    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

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

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

    <!--使用Spring来创建对象，在Spring中这些都称为bean-->
    <bean id="users" class="com.dao.Users">
        <property name="str" value="Spring"/>
    </bean>

</beans>

test.java

import com.dao.Users;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.HashMap;

public class MyText {


    @Test
    public void mytext() {
//        获取Spring的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext ("applicationContext.xml");
        Users users = (Users) context.getBean ("users");
        System.out.println (users.toString ());

    }

}

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

IOC创建对象的方式

  1. 使用无参构造创建对象。默认
  2. 使用有参构造创建对象

2.1下标赋值

    <bean id="users" class="com.dao.Users">
        <!--<property name="str" value="Spring"/>-->
        <constructor-arg index="0" value="我是有参构造注入的下标赋值"/>
    </bean>

2.2类型赋值

    <!--使用Spring来创建对象，在Spring中这些都称为bean-->
    <bean id="users" class="com.dao.Users">
        <constructor-arg type="java.lang.String" value="我是类型注入"/>
    </bean>

2.3直接通过参数名

  <!--使用Spring来创建对象，在Spring中这些都称为bean-->
    <bean id="users" class="com.dao.Users">
        <constructor-arg name="str" value="直接通过参数名"/>
    </bean>

Spring配置

别名（alias，可以通过别名获取到该对象）

    <alias name="users" alias="users2"/>


    <!--id:Bean的唯一标识符，也就是相当于我们学的对象名 ，class：Bean对象所对应的全限定名：包名+类名  name:别名-->
    <bean id="users" class="com.dao.Users" name="users3">
        <constructor-arg name="str" value="直接通过参数名"/>
    </bean>

import

一般用于团队使用，将多个配置文件导入合并为一个

DI依赖注入

Set注入（重点）

  • 依赖注入:Set注入
    • 依赖：Bean对象的创建依赖于容器
    • 注入：Bean对象中的所有属性，由容器来注入

复杂类型

public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

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

实际对象

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobby;
    private Map<String, String> card;
    private String wife;
    private Properties info;
    }

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
		https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="address" class="com.pojo.Address">
        <property name="address" value="我是地址"/>
    </bean>
    <bean id="student" class="com.pojo.Student">
        <!--第一种，普通值（value）注入-->
        <property name="name" value="测试"/>
        <!--第二种，Bean注入-->
        <property name="address" ref="address"/>
        <!--数组注入-->
        <property name="books">
            <array>
                <value>我是数组1</value>
                <value>我是数组2</value>
                <value>我是数组3</value>
            </array>
        </property>
        <!--list注入-->
        <property name="hobby">
            <list>
                <value>我是list注入1</value>
                <value>我是list注入2</value>
                <value>我是list注入3</value>
            </list>
        </property>
        <!--map注入-->
        <property name="card">
            <map>
                <entry key="我是map1的key" value="我是map1"/>
                <entry key="我是map2的key" value="我是map2"/>
                <entry key="我是map3的key" value="我是map3"/>
            </map>
        </property>
        <!--空值注入-->
        <property name="wife">
            <null/>
        </property>
        <!--Properties注入-->
        <property name="info">
            <props>
                <prop key="我是Properties1的key">我是Properties1</prop>
                <prop key="我是Properties2的key">我是Properties2</prop>
                <prop key="我是Properties3的key">我是Properties3</prop>
            </props>
        </property>
    </bean>
</beans>

MyTest.java（测试类）

import com.pojo.Student;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {

    @Test
    public void cs() {

        ApplicationContext context = new ClassPathXmlApplicationContext ("beans.xml");
        Student student = (Student) context.getBean ("student");
        System.out.println (student.toString ());

    }
}

官网参考这里是引用

构造器注入

其他注入

p注入（快捷的set注入）

  • 导入p命名空间
   xmlns:p="http://www.springframework.org/schema/p"
  • 实现
    userBeans.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
		https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--p命名空间注入，可以直接注入属性的值：相当于property-->

    <bean id="user" class="com.pojo.User" p:name="我是p命名注入" p:age="20"/>

</beans>

测试


    @Test
    public void cs2() {
        ApplicationContext context = new ClassPathXmlApplicationContext ("userBwans.xml");
        User user = (User) context.getBean ("user");
        System.out.println (user.toString ());
    }

c注入（快捷的构造器注入）

导入c命名空间

	xmlns:c="http://www.springframework.org/schema/c"

实现
userBeas.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:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
		https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--p命名空间注入，可以直接注入属性的值：相当于property-->
    <bean id="user" class="com.pojo.User" c:name="我是c注入" c:age="20"/>

</beans>

cs.java


    @Test
    public void cs2() {
        ApplicationContext context = new ClassPathXmlApplicationContext ("userBwans.xml");
        User user = (User) context.getBean ("user");
        System.out.println (user.toString ());
    }

Bean scopes(Bean 作用域）

官方解释导航
在这里插入图片描述

重点掌握
在这里插入图片描述

  • 单例模式（Spring模式机制）
`<bean id="user" class="com.pojo.User" c:name="我是c注入" c:age="20" scope="singleton"/>
  • 原型模式（每次从容器中get时都会产生新的对象）
<bean id="user" class="com.pojo.User" c:name="我是c注入" c:age="20" scope="prototype"/>
  • 其余的request、session、application，只能在Web开放中使用

Bean的自动装配

  • 自动装配是Spring满足Bean依赖的一种方式
  • Spring会在上下文中自动寻找，并自动给Bean装配属性

在Sprin中又三种自动装配的方式：

  1. 在xml中显示的配置
  2. 在Java中显示的配置
  3. 隐式的自动装配

测试代码搭建
Dog.java

package com.pojo;

public class Dog {

    public void shut() {
        System.out.println ("汪汪汪~");
    }
}

Cat.java

package com.pojo;

public class Cat {

    public void shut() {
        System.out.println ("喵喵喵~");
    }
}

People.java

package com.pojo;

public class People {

    private String name;
    private Dog dog;
    private Cat cat;

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", dog=" + dog +
                ", cat=" + cat +
                '}';
    }

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

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }
}

myTest.java

import com.pojo.People;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {


    @Test
    public void test1() {
        ApplicationContext context = new ClassPathXmlApplicationContext ("beans.xml");
        People people = context.getBean ("people", People.class);
        people.getCat ().shut ();
        people.getDog ().shut ();
    }
}
  • byName自动装配
<?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
		https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="dog" class="com.pojo.Dog"/>
    <bean id="cat" class="com.pojo.Cat"/>
    <!--byName:会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid-->
    <bean id="people" class="com.pojo.People" autowire="byName">
        <property name="dog" ref="dog"/>
        <property name="cat" ref="cat"/>
        <property name="name" value="测试"/>
    </bean>

</beans>
  • byType自动装配
<?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
		https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="dog" class="com.pojo.Dog"/>
    <bean id="cat" class="com.pojo.Cat"/>
    <!--byType:会自动在容器上下文中查找，和自己对象属性类型相同的beanid-->
    <bean id="people" class="com.pojo.People" autowire="byType">
        <property name="dog" ref="dog"/>
        <property name="cat" ref="cat"/>
        <property name="name" value="测试"/>
    </bean>

</beans>

在这里插入图片描述

小结：
byname的时候，需要保证所有的bean的id是唯一，并且这个bean需要和自动注入的属性的Set方法的值是一致的
bytype的时候，需要保证所有的bean的class是唯一的，并且这个bean需要和自动注入的属性的类型一致！

注解实现自动装配

使用注解的要求

  1. 导入约束
xmlns:context="http://www.springframework.org/schema/context"
  1. 配置注解支持
<?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
		https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context
		https://www.springframework.org/schema/context/spring-context.xsd">

	<context:annotation-config/>

</beans>

@Autowired

直接在属性上使用即可，也可以在Set方式上使用！
使用Autowired我们可以不用编写Set方法了，前提自动装配的属性在IOC（Spring）容器中存在，且符合名字byname

科普：
@Nullable：字段标记了这个注解，说明这个字段可以为null
@Autowired （required=false）:说明这个对象可以为空，否则则不允许为空
public @interface Autowired {
boolean required() default true;
}
测试代码：
public class People {
private String name;
@Autowired(required = false)
private Dog dog;
@Autowired
private Cat cat;
}
如果 @Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，我们可以通过 @Qualifier(value = "XXX"取配置@Autowired的使用，指定一个唯一的bean对象注入

Resource注解（功能跟Autowired差不多）

    @Resource(name = "cat")
    private Cat cat;

小结：
@Resource和 @Autowired的区别
都是用来自动装配的，都可以放在属性字段上
@Autowired通过byType的方式实现，而且必须要求这个对象存在（常用）
@Resource默认通过byname的方式实现，如果找不到名字，则通过byType实现，如果两个都找不到的情况下，就报错（常用）
执行顺序不同：@Resource默认通过byname实现， @Autowired通过byType的方式实现。

要早睡早起啦
关注
spring ioc aop基础理论实践笔记
09-24
1，spring是一个开源的免费的框架（容器）。 2，spring是一个轻量级的，非入侵式的框架。 ​ 非入侵式：就是项目引入了这个框架之后，...总结：spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架。
IOC思想
zhaomengxia123的博客
08-05 1482
IOC:控制反转 IOC是Spring的核心，贯穿始终 对于Spring框架来说，就是由spring IOC容器来负责控制对象的生命周期和对象间的关系 1.在传统开发模式下，我们是采用直接new一个对象的方式来创建对象，也就是所依赖的对象由自己控制 但是这种可以交给IOC容器来控制对象 2.控制的是对象 3.有了IOC之后，所依赖的对象直接由Ioc容器创建后注入到被注入的对象中，依赖的...
2-1、IOC思想以及实现
weixin_48312484的博客
07-28 242
IOC容器就是IOC思想在Spring的一个罗德实现，IOC容器中管理的组件叫做bean，创建bean之前要先创建IOC容器。在程序组件中需要获取资源时，传统方式我们需要主动的从容器中去获取资源，这种模式要求开发人员了解特定资源在具体容器中的获取的方法。反转控制思想与传统获取资源方式相反，改为由容器主动提供资源，开发人员只要做好接受准备即可，无需了解资源获取的具体方法。例想要吃饭，传统方式买菜——>洗菜——>切菜——>炒菜——>吃饭。例想要吃饭，IOC方式点外卖——>拿外卖——>吃饭。...
10000字讲解IoC 思想以及五大注解
最新发布
Shine0115的博客
05-07 1057
什么是 Spring 呢？我们经常听到的都是说 Spring 是一个框架，让我们的开发变得更加简单了，但是这个概念相对来说，太抽象化了，具体点来讲：Spring是包含了很多工具方法的IoC容器什么是容器？容器是用来容纳某种物品的装置。在生活中，水杯就是一个容器，它用容纳水，垃圾桶也是一个容器，它用来装垃圾。在我们学习过的数据结C构中，像 List，Map，Statck等，也都是一个容器，用来存储数据。还有 Tomcat，它就是一个 Web 容器，在上面可以部署很多的Web服务。什么是 IoC？IoC：inv
IoC 思想和实现
a141210104的专栏
11-05 463
IoC 是什么，为什么需要IoC，用简单例子自己实现IoC思想彻底理解什么是IoC以及IoC的优点
ioc 思想
metjoyful的博客
12-04 933
IoC理论的背景 我们都知道，在采用面向对象方法设计的软件系统中，它的底层实现都是由Ñ个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。 就类似于机械式手表的后盖，就会看到与上面类似的情形，各个齿轮分别带动时针，分针和秒针顺时针旋转，从而在表盘上产生正确的时间。图1中描述的就是这样的一个齿轮组，它拥有多个独立的齿轮，这些齿轮相互啮合在一起，协同工作，共同完成某项任务。我们可以看...
IOC框架详解
11-26
为了解决这一问题，Michael Mattson在1996年提出了IOC理论，该理论的核心是将对象的控制权从对象自身转移给一个第三方容器，即IOC容器。 控制反转（IOC）的概念可以这样理解：原本对象A需要依赖对象B，A会自行创建...
Spring的IOC原理
03-21
**一、IoC理论背景** 在面向对象的软件设计中，对象间的耦合是不可避免的，它们通过相互合作实现业务逻辑。这种耦合就像机械手表中的齿轮，彼此啮合共同完成任务。随着软件系统规模的扩大，对象间的依赖关系变得...
【框架源码篇 01】Spring源码-手写IOC
10-21
在本系列的第一篇【框架源码篇 01】中，我们将深入探讨Spring框架的核心组件——控制反转（Inversion of Control，简称IOC）。IOC是一种设计模式，它将对象的...记得阅读和研究这些代码，实践是检验理论的最好方式。
实践彻底理解IOC思想
01-21
Spring IOC（控制反转） IOC英文是Inversion of Control中文理解为控制反转，是Spring框架的一种设计思想。表示创建或者控制对象的权利由应用程序转换到Spring容器，如下将通过new关键字准确获取UserServiceImpl、UserMapperImpl类的权利交给BeanFactory，所谓的容器是指程序运行之后，装有多个实例化Bean的组件。 程序的耦合： 耦合：程序间的依赖关系 包括: 类之间的依赖 方法之间的依赖 解耦： 降低程序间的依赖关系 实际开发中： 应该做到：编译期
SpringIOC机制详解
互联网底层民工的博客
06-30 7392
所谓Bean的作用域其实就是指Spring给我们创建出的对象的存活范围，在配置文件中通过bean的scope属性指定取值范围说明singleton默认值，单例的prototype多例的requestWEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 request 域中sessionWEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 session 域中。
IOC和AOP思想
m0_52255127的博客
08-09 430
IOC和AOP思想
8、IOC容器思想
qq_63486066的博客
10-19 205
8、IOC—IOC容器思想 1、IOC容器思想 IOC：Inversion of Control，翻译过来是反转控制。 ①获取资源的传统方式 在应用程序中的组件需要获取资源时，传统的方式是组件主动的从容器中获取所需要的资源，在这样的模式下开发人员往往需要知道在具体容器中特定资源的获取方式，增加了学习成本，同时降低了开发效率。 ②反转控制方式获取资源 反转控制的思想完全颠覆了应用程序组件获取资源的传统方式：反转了资源的获取方向——改由容器主动的将资源推送给需要的组件，开发人员不需要知道容器是如何创建资源对象的
IOC核心概念
buith9879的博客
06-11 435
Ioc（Inversion of Contorl）控制反转---->一种编程思想为了降低程序的耦合性，我们由主动new一个对象转换为由外部提供对象。此过程中对象创建控制权由程序转移到外部，这种思想叫做控制反转。Spring技术对这种思想进行了实现。Spring提供了一个容器，称之为“Ioc容器”充当Ioc思想中的外部。Ioc容器负责对象的创建、初始化等一系列操作，被创建或者管理的容器在Ioc容器中成为bean。DI（dependency Injection）依赖注入。
第二节 IOC容器概念(Spring 第一章)
无
05-11 346
**第二节 IOC容器概念** 1、普通容器 ①生活中的普通容器 ②程序中的普通容器 2、复杂容器 ①生活中的复杂容器 ②程序中的复杂容器 [1]Servlet生命周期 [2]Filter生命周期 3、IOC思想 ①获取资源的传统方式 ②反转控制方式获取资源 ③DI 4、 IOC容器在Spring中的实现 ①BeanFactory ②ApplicationContext ③ApplicationContext的主要实现类
从零开始学习Spring5架构（二）——IOC基础
FFFPAG的博客
10-01 160
IOC的本质 控制反转IOC(Inversion of Control)，是一种设计思想，**DI(依赖注入)**是实现IOC的一种方法，也有人认为DI只是IOC的另一种说法。 没有IOC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，所谓控制反转就是：获得依赖对象的方式反转了，即原先的程序对象由类来主动创建，而IOC则是接收一个类的实例对象。 IOC是Spring框架的核心内容，使用多种方式完美的实现了I
对IOC的理解
weixin_51697044的博客
04-15 2212
一、对IOC和DI的基本认识 1、理解IOC(控制反转) IOC是Inversion of control的缩写,翻译为控制反转。要理解控制反转，就需要从控制入手。 (1)谁控制了谁，控制了什么
Spring5框架详解：IOC理论与实践
IOC理论 控制反转（IOC）是Spring的重要特性，它通过配置文件（如`beans.xml`）或注解来定义对象及其依赖关系。下面是一个简单的例子： ```xml xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值