IOC理论

最新推荐文章于 2024-05-07 14:13:00 发布
最新推荐文章于 2024-05-07 14:13:00 发布
阅读量115 收藏
点赞数
文章标签： 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的方式实现。

要早睡早起啦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring的IOC的思想
LWQ0825的博客
01-10 425
在福建出差，顺手学了一下IOC的思想，就来总结一下IOC的理论上的一个演变以及其所起到的作用。 1、IOC出现之前的模式 我们就简单的做一个dao service 以及客户端的调用演示。 最开始我们的需求就是一个获取用户数据，使用的是默认的获取。 dao的接口：UserDao public interface UserDao { public void getUser(); } dao的实现类：UserDaoImpl public class UserDaoImpl implements .
spring ioc aop基础理论实践笔记
09-24
1，spring是一个开源的免费的框架（容器）。 2，spring是一个轻量级的，非入侵式的框架。 ​ 非入侵式：就是项目引入了这个框架之后，...总结：spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架。
Ioc思想
weixin_33835103的博客
07-17 63
DIP: Dependency Inversion Principle 依赖倒转原则 高层次组件不应该依赖于低层次组件，二者均应该依赖于接口。抽象不应该依赖于细节，细节应该依赖于抽象。 IOC：Inversion Of Control 控制反转 核心：底层模块是通过基于依赖倒置原则的类型的构造函数注入的。 伪代码： public class FinanceInfoService {...
10000字讲解IoC 思想以及五大注解
最新发布
Shine0115的博客
05-07 996
什么是 Spring 呢？我们经常听到的都是说 Spring 是一个框架，让我们的开发变得更加简单了，但是这个概念相对来说，太抽象化了，具体点来讲：Spring是包含了很多工具方法的IoC容器什么是容器？容器是用来容纳某种物品的装置。在生活中，水杯就是一个容器，它用容纳水，垃圾桶也是一个容器，它用来装垃圾。在我们学习过的数据结C构中，像 List，Map，Statck等，也都是一个容器，用来存储数据。还有 Tomcat，它就是一个 Web 容器，在上面可以部署很多的Web服务。什么是 IoC？IoC：inv
IOC思想
zhaomengxia123的博客
08-05 1423
IOC:控制反转 IOC是Spring的核心，贯穿始终 对于Spring框架来说，就是由spring IOC容器来负责控制对象的生命周期和对象间的关系 1.在传统开发模式下，我们是采用直接new一个对象的方式来创建对象，也就是所依赖的对象由自己控制 但是这种可以交给IOC容器来控制对象 2.控制的是对象 3.有了IOC之后，所依赖的对象直接由Ioc容器创建后注入到被注入的对象中，依赖的...
ioc 思想
metjoyful的博客
12-04 913
IoC理论的背景 我们都知道，在采用面向对象方法设计的软件系统中，它的底层实现都是由Ñ个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。 就类似于机械式手表的后盖，就会看到与上面类似的情形，各个齿轮分别带动时针，分针和秒针顺时针旋转，从而在表盘上产生正确的时间。图1中描述的就是这样的一个齿轮组，它拥有多个独立的齿轮，这些齿轮相互啮合在一起，协同工作，共同完成某项任务。我们可以看...
IOC框架详解
11-26
为了解决这一问题，Michael Mattson在1996年提出了IOC理论，该理论的核心是将对象的控制权从对象自身转移给一个第三方容器，即IOC容器。 控制反转（IOC）的概念可以这样理解：原本对象A需要依赖对象B，A会自行创建...
IOC之深入理解SpringIoC
02-24
谁控制谁控制什么为何是反转哪些方面反转了在回答这四个问题之前，我们先看IOC的定义：所谓IOC，就是由SpringIOC容器来负责对象的生命周期和对象之间的关系上面这句话是整个IoC理论的核心。如何来理解这句话？我们...
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的组件。 程序的耦合： 耦合：程序间的依赖关系 包括: 类之间的依赖 方法之间的依赖 解耦： 降低程序间的依赖关系 实际开发中： 应该做到：编译期
【spring】Ioc思想
恩会的博客
01-17 247
ApplicationContext 的三个常用实现类 ClassPathXmlApplicationContext 加载类路径下的配置文件（最常用） FileSystemXmlApplicationContext 加载磁盘路径下的配置文件（必须有访问权限） AnnotationConfigApplicati...
IOC（控制反转）思想
weixin_44976835的博客
12-22 374
首先搭建一个环境，创建Maven项目： 导入Spring Spring Maven地址： <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId&
IoC 思想和实现
a141210104的专栏
11-05 443
IoC 是什么，为什么需要IoC，用简单例子自己实现IoC思想彻底理解什么是IoC以及IoC的优点
浅谈IOC编程思想
阿生
08-03 355
IOC 是的缩写表示控制反转在整个系统中IOC就相当于哆啦A梦的口袋，任何对象可以通过这个口袋中拿到。有了IOC容器之后再看c对象的依赖，它虽然还是依赖于a和b但是情况却不一样了fill:#333;color:#333;color:#333;fill:none;}IOC容器abc如图所示，此时的情况相当于cc的依赖交由IOC容器进行管理，在程序运行时IOC容器主动的将a和b进行注入到c中。这时候c由主动创建a和b两个依赖的行为被反转为被动接受IOC容器注入a和b依赖思考一下？......
第二节 IOC容器概念(Spring 第一章)
无
05-11 313
**第二节 IOC容器概念** 1、普通容器 ①生活中的普通容器 ②程序中的普通容器 2、复杂容器 ①生活中的复杂容器 ②程序中的复杂容器 [1]Servlet生命周期 [2]Filter生命周期 3、IOC思想 ①获取资源的传统方式 ②反转控制方式获取资源 ③DI 4、 IOC容器在Spring中的实现 ①BeanFactory ②ApplicationContext ③ApplicationContext的主要实现类
Spring IOC思想
Giraffe_it的博客
12-08 260
1. 什么是 IOC      控制反转(IoC=Inversion of Control)，控制反转(或依赖注入) ，用白话来讲，就是由容器控制程序之间的（依赖）关系，而非传统实现中，由程序代码直接操控。这也就是所谓“控制反转”的概念所在：(依赖)控制权由应用代码中转到了外部容器，控制权的转移，是所谓反转。    IOC还有一个另外的名字：“依赖注入 (DI=Dependency Inject...
Spring(一)---IOC思想
BenJi的博客
02-09 233
引言 当下最火的框架,莫不是Spring全家桶了,而Spring框架在业务层有两个非常重要的思想,IOC和AOP. 这边,我先记录下我对Spring框架IOC的一些理解. 简单介绍 老规矩,看一下百度百科. 其实说明白了 ,就是通过配置,将以前手动new对象的实例化过程,交给Spring 框架.当项目启动的时候,Spring框架中的,管理所有Bean的Spring容器会启动,帮我们自动...
Spring3教程：IoC、DI与AOP详解
每一章都结合实例和理论，使读者能够逐步掌握Spring框架的核心功能，并能有效地将其应用于实际项目中。此外，由于作者在ITEye网站上提供资源，读者可以在这个交流社区中获取更多的解答和支持，便于持续学习和交流。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值