【框架：Spring】万字详解IOC控制反转（上：注入）

最新推荐文章于 2023-08-30 17:48:04 发布
最新推荐文章于 2023-08-30 17:48:04 发布
阅读量145 收藏
点赞数
分类专栏： # Spring 文章标签： spring maven java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45965358/article/details/120276530
版权

文章目录

1.入门

1.1简介

spring可以减轻项目模块之间的管理，类和类之间的管理。帮助开发人员创建对象，管理对象之间的关系。spring的核心技术是IOC和AOP。

1.2优点

  • 轻量
  • 针对接口编程，解耦合
  • AOP编程的支持
  • 方便集成各种框架

1.3 Spring的体系结构

在这里插入图片描述

2.IOC控制反转

2.1简介

在这里插入图片描述

2.2IOC的技术实现

在这里插入图片描述

2.3 创建第一个Spring

在这里插入图片描述

2.3.1创建maven项目

在这里插入图片描述

2.3.2 加入maven依赖包

<!--spring依赖-->
	<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>

 <!--单元测试-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

2.3.3创建类

在这里插入图片描述

接口

package com.sdnu.service;

public interface SomeService {
    void doSome();
}

实现类

package com.sdnu.service.impl;

import com.sdnu.service.SomeService;

public class SomeServiceImpl implements SomeService {
    @Override
    public void doSome() {
        System.out.println("执行了SomeServiceImpl的doSome方法");
    }
}

测试代码

    @Test
    public void test1(){
        SomeService service = new SomeServiceImpl();
        service.doSome();
    }

2.3.4 创建spring需要使用的配置信息

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

<?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="someService" class="com.sdnu.service.impl.SomeServiceImpl"></bean>
</beans>

2.3.5创建spring

    @Test
    public void test2(){
        //1.指定spring配置文件的名称
        String config = "beans.xml";
        //2.创建表示spring容器的对象，ApplicationContext
        //ApplicationContext就是表示spring容器，通过容器获取对象
        //ClassPathXmlApplicationContext表示从类路径加载spring的配置文件
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        //从容器中获取某个对象，你要调用对象的方法
        //getBean("配置文件的bean的id值")
        SomeService service = (SomeService) ac.getBean("someService");
        //使用spring创建好的对象
        service.doSome();
    }

2.3.6spring创建对象的时机

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

2.3.6 获取容器对象信息

我们在beans.xml中设置两个bean对象

<bean id="someService" class="com.sdnu.service.impl.SomeServiceImpl"></bean>
<bean id="someService2" class="com.sdnu.service.impl.SomeServiceImpl"></bean>

测试程序

    @Test
    public  void test3(){
        String config = "beans.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        int count = ac.getBeanDefinitionCount();
        System.out.println(count);
        String[] name = ac.getBeanDefinitionNames();
        for(String item : name) {
            System.out.println(item);
        }
    }

在这里插入图片描述

2.3.7创建非自定义对象

    @Test
    public void test4(){
        String config = "beans.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        Date myDate = (Date)ac.getBean("someService3");
        System.out.println("my Date is :" + myDate);
    }

在这里插入图片描述

2.4基于XML的DI

2.4.1注入分类

在这里插入图片描述
在这里插入图片描述
实现步骤：
在这里插入图片描述

2.4.2 set注入

在这里插入图片描述

（1）简单类型：
在这里插入图片描述
ApplicationContext.xml

    <bean id="myStudent" class="com.sdnu.ba01.Student">
        <property name="name" value="wangwu"/>
        <property name="age" value="21"/>
    </bean>

Student.java

package com.sdnu.ba01;

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

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

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

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

测试程序

    @Test
    public void test1(){
        String config = "ba01/ApplicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        Student student = (Student) ac.getBean("myStudent");
        System.out.println(student);
    }

在这里插入图片描述
（2）引用类型
在这里插入图片描述
School类在下面还会使用，就不重复写了。
School.java

package com.sdnu.ba02;

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

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

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

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

ApplicationContext.xml

    <bean id="mySchool2" class="com.sdnu.ba02.School">
        <property name="name" value="深圳大学"/>
        <property name="address" value="深圳市"/>
    </bean>
    <bean id="myStudent2" class="com.sdnu.ba02.Student">
        <property name="name" value="张三"/>
        <property name="age" value="21"/>
        <property name="school" ref="mySchool2"/>
    </bean>

Student.java

package com.sdnu.ba02;

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

    public void setSchool(School school) {
        this.school = school;
    }

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

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

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

测试程序

    @Test
    public void test2(){
        String config = "ba01/ApplicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        Student student = (Student) ac.getBean("myStudent2");
        System.out.println(student);
    }

2.4.2构造注入

在这里插入图片描述

  • name

ApplicationContext.xml

    <bean id="mySchool3" class="com.sdnu.ba03.School">
        <property name="name" value="深圳大学"/>
        <property name="address" value="深圳市"/>
    </bean>
    <bean id="myStudent3" class="com.sdnu.ba03.Student">
        <constructor-arg name="name" value="张三"/>
        <constructor-arg name="age" value="21"/>
        <constructor-arg name="school" ref="mySchool3"/>
    </bean>

Student.java

package com.sdnu.ba03;

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

    public Student(String name, Integer age, School school) {
        this.name = name;
        this.age = age;
        this.school = school;
    }

}

测试程序

    @Test
    public void test3(){
        String config = "ba01/ApplicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        Student student = (Student) ac.getBean("myStudent3");
        System.out.println(student);
    }
  • index
    <!--index-->
    <bean id="myStudent3Index" class="com.sdnu.ba03.Student">
        <constructor-arg index = "0" value="张三"/>
        <constructor-arg index = "1" value="21"/>
        <constructor-arg index="2" ref="mySchool3"/>
    </bean>
  • 省略
    <!--省略-->
    <bean id="myStudent3Omit" class="com.sdnu.ba03.Student">
        <constructor-arg  value="张三"/>
        <constructor-arg  value="21"/>
        <constructor-arg ref="mySchool3"/>
    </bean>

2.4.3创建文件对象

ApplicationContext.xml

    <!--创建文件对象-->
    <bean id="myfile" class="java.io.File">
        <constructor-arg name="parent" value="D:\test\spring"/>
        <constructor-arg name="child" value="happy.txt"/>
    </bean>

测试程序

    @Test
    public void test3File(){
        String config = "ba01/ApplicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        File file = (File) ac.getBean("myfile");
        System.out.println(file);
    }

2.4.4引用类型自动注入

在这里插入图片描述
在这里插入图片描述
(1)byName

在这里插入图片描述

ApplicationContext.xml


    <!--注意id与Student.java中的Student类的school属性相同-->
    <bean id="school" class="com.sdnu.ba04.School">
        <property name="name" value="深圳大学"/>
        <property name="address" value="深圳市"/>
    </bean>
    <bean id="myStudent" class="com.sdnu.ba04.Student" autowire="byName">
        <property name="name" value="张三"/>
        <property name="age" value="21"/>
        <!--
        <property name="school" ref="mySchool"/>
        -->
    </bean>

在这里插入图片描述
(2)byType

ApplicationContext.xml

   <bean id="school" class="com.sdnu.ba05.School">
        <property name="name" value="深圳大学"/>
        <property name="address" value="深圳市"/>
    </bean>
    <bean id="myStudent" class="com.sdnu.ba05.Student" autowire="byType">
        <property name="name" value="张三"/>
        <property name="age" value="21"/>
        <!--
        <property name="school" ref="mySchool"/>
        -->
    </bean>

在这里插入图片描述

作者：Beyong　　　　
出处：Beyong博客
github地址：https://github.com/beyong2019

本博客中未标明转载的文章归作者Beyong有，欢迎转载，但未经作者同意必须保留此段声明，且在文章明显位置给出原文连接，否则保留追究法律责任的权利。

Listener-1379
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring框架控制反转IOC和依赖注入DI详解
01-20
本文介绍了Spring框架中的控制反转IOC和依赖注入DI，欢迎阅读，共同学习，一起进步。 Spring框架基础参考：深入学习Spring基础 文章目录一.入门程序和IOC简介二.IOC-控制反转三.DI-依赖注入四. IOC和DI五.Spring...
IOC(概念和原理)
热门推荐
weixin_44223212的博客
10-28 1万+
1.什么是IOC （1）控制反转，把对象的创建和对象之间的调用过程，交给Spring管理 （2）使用IOC的目的：降低耦合度 （3）做入门案例就是IOC实现 2.IOC底层原理 （1）xml解析、工厂模式、反射 3.画图解析 4.IOC(接口) 1.IOC思想基于IOC容器完成，IOC容器底层就是对象工厂 2.Spring提供IOC容器实现两种方式：（两个接口） （1）BeanFactory:IOC容器基本实现，是Spring内部的使用接口，不提供开发人员使用 *加载配置文件时候不会创建对象，在使用或
IOC概念和原理
weixin_52875557的博客
10-03 7050
1.什么是IOC IOC即为控制反转，把对象的创建和对象之间的调用过程，交给Spring管理。不需要像se阶段一样new对象。 使用IOC的目的：为了降低耦合度。所谓耦合度就是某模块（类）与其它模块（类）之间的关联、感知和依赖的程度，是衡量代码独立性的一个指标，也是软件工程设计及编码质量评价的一个标准。 2.IOC的底层原理 假如有以上俩个类，传统创建对象我们需要在UesrService类中调用uesrDao中add方法需要先在UesrService中new uesrDao的对象，再调.
IOC和AOP
zzs1126的博客
04-03 1183
IOC，即控制反转，把对象的创建、初始化、销毁交给 Spring 来管理，而不是由开发者控制，实现控制反转。IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂（BeanFactory 接口）。IOC的原理是基于xml解析、工厂设计模式、反射实现的。使用IOC可以降低代码的耦合度。1.2 Spring 提供 IOC 容器实现两种方式（1）BeanFactory：IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用。
IOC原理
soputasmile的笔记
03-24 1408
转自：http://blog.csdn.net/u012561176/article/details/45974315IOC的基础知识以及原理1、IOC理论背景在采用面向对象方法设计的软件系统中，底层实现都是由N个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。即软件系统中对象之间的耦合，对象A和对象B之间有关联，对象B又和对象C有依赖关系，这样对象和对象之间有着复杂的依赖关系，所以才
史上最全讲解:IOC
lynn_123456的博客
02-06 512
什么是IOC 通俗易懂的理解IOC 由于引进了中间位置的“第三方”，也就是IOC容器，使得A、B、C、D这4个对象没有了耦合关系，齿轮之间的传动全部依靠“第三方”了，全部对象的控制权全部上缴给“第三方”IOC容器，所以，IOC容器成了整个系统的关键核心，它起到了一种类似“粘合剂”的作用，把系统中的所有对象粘合在一起发挥作用，如果没有这个“粘合剂”，对象与对象之间会彼此失去联系，这就是有人把IO...
Spring框架IoC控制反转.pdf
最新发布
09-20
【Spring框架IoC控制反转】 一、Spring框架是什么 Spring框架是Java开发中的一款轻量级框架，诞生于2003年，旨在简化企业级应用的开发复杂性。Spring的核心理念包括控制反转（IoC）和面向切面编程（AOP）。作为一...
实例讲解Java的Spring框架中的控制反转和依赖注入
09-02
在Java的Spring框架中，控制反转（IoC，Inversion of Control）和依赖注入（DI，Dependency Injection）是核心设计理念，它们旨在降低组件之间的耦合度，提高代码的可测试性和可维护性。Spring框架通过IoC容器来管理...
Spring为IOC容器注入Bean的五种方式详解
08-25
Spring 框架中，IOC（Inverse of Control，控制反转）容器是核心组件之一，用于管理 Bean 的生命周期。在 Spring 中，IOC 容器可以通过五种方式来注入 Bean，本文将对这五种方式进行详细的介绍。 一、@Import 导入...
helloIoc.zip spring ioc控制反转简单测试代码
01-13
Spring框架的核心特性之一就是依赖注入（Dependency Injection，简称DI），它通过控制反转（Inversion of Control，简称IOC）实现。这个"helloIoc.zip"压缩包包含的是一组用于演示Spring IOC基本概念和使用的测试...
IOC详解
weixin_47586838的博客
09-13 637
IOC的含义： Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。 在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。 其实IoC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。 DI—Depende...
IOC概述及其实现原理
逍遥Sean的博客
07-05 7774
IoC即Inversion of Control，反应过来就是控制反转。啥是控制反转啊？控制反转指的就是将对象的创建权反转给（交给）了Spring，其作用是实现了程序的解耦合。也可这样解释：获取对象的方式变了，对象创建的控制权不是"使用者"，而是"框架"或者"容器"。用更通俗的话来说，IoC就是指对象的创建，并不是在代码中用new操作new出来的，而是通过Spring进行配置创建的。
Spring系列--IOC详解
qq_42194397的博客
11-25 2342
IOC笔记总结
Spring——IOC底层原理
qq_50233116的博客
11-02 4014
IOC底层原理、IOC接口（BeanFanctory）、IOC操作Bean管理（基于XML）相关介绍
IOC概念及原理
大太阳
02-28 1646
1、什么是IOC？ 控制反转：把对象创建和对象之间的调用过程，交给Spring进行管理。 使用IOC的目的：降低耦合度。 Spring入门案例是IOC的实现 2、IOC底层原理 XML解析 工厂模式 反射 3、图解IOC原理 IOC过程 （1）XML配置文件，配置创建的对象 <bean id="userDao" class="com.wxm.UserDao"></bean> （2）有UserService类和UserDao类，创建工厂类 class UserFactory
spring-IOC原理详解
谈少华的博客
04-15 5270
Spring容器高层视图 Spring 启动时读取应用程序提供的Bean配置信息，并在Spring容器中生成一份相应的Bean配置注册表，然后根据这张注册表实例化Bean，装配好Bean之间的依赖关系，为上层应用提供准备就绪的运行环境。 Bean缓存池：HashMap实现 IOC容器介绍 Spring 通过一个配置文件描述 Bean 及 Bean 之间的依赖关系，利用 Java 语言的...
ioc简述（快速了解ioc及使用）
X2822889732的博客
08-30 1326
ioc简述（快速了解ioc及使用）
ioc和aop的原理面试
m0_74134550的博客
02-20 642
1、ioc原理：在传统的实现中，由程序内部代码来控制组件之间的关系。2、aop原理：AOP将业务逻辑组件和切面类都加入到容器中，负责在业务逻辑运行的时候将日志进行打印，切面类负责动态感知MathC运行到哪里然后执行。IoC容器就是一个对象制造工厂，需要什么，它会给提供，直接使用即可，而不用考虑所用的东西是如何制成的，也不用考虑最后是怎么被销毁的，这一切全部由IOC容器包办。创建代理对象过程中，会先创建一个代理工厂，获取到所有的增强器（通知方法），将这些增强器和目标类注入代理工厂，再用代理工厂创建对象。
Spring框架入门：IOC控制反转与依赖注入解析
Spring的核心技术主要包括IOC（Inversion of Control，控制反转）和AOP（Aspect-Oriented Programming，面向切面编程）。其中，IOC又被称为DI（Dependency Injection，依赖注入），它改变了传统程序中对象的创建和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值