Spring一IOC、DI

最新推荐文章于 2024-07-30 19:40:03 发布
最新推荐文章于 2024-07-30 19:40:03 发布
阅读量114 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44807446/article/details/102633528
版权

1、Spring

1.1、简介

  • 2002，首次推出了Spring框架的雏形：interface21框架！
  • Spring框架即以interface21框架为基础,经过重新设计,并不断丰富其内涵,于*2004年3月24日,*发布了1.0正式版。
  • Rod Johnson ，Spring Framework创始人，悉尼大学的音乐学博士
  • spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架！

现有的技术栈

  1. SSH ： Struct2 + Spring + Hibernate！
  2. SSM ： SpringMvc + Spring + Mybatis！

Spring的获取：
官网：https://spring.io/projects/spring-framework#overview

官方下载地址： http://repo.spring.io/release/org/springframework/spring

GitHub：https://github.com/spring-projects/spring-framework

需要导入的jar包

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>

1.2、优点

  • Spring是一个开源的免费的框架（容器）！
  • Spring是一个轻量级的、非入侵式的框架！
  • 控制反转（IOC） ， 面向切面编程（AOP）！
  • 支持事务的处理，对框架整合的支持！

Spring就是一个轻量级的控制反转（IOC） 和面向切面编程（AOP）的框架！

弊端：发展了太久之后，违背了原来的理念！配置十分繁琐，人称：“ 配置地狱！”

1.3、组成

在这里插入图片描述

1.4、拓展

在Spring的官网有这个介绍：现代化的Java开发！说白就是基于Spring的开发！
在这里插入图片描述

  • Spring Boot
    • 一个快速开发的脚手架。
    • 基于SpringBoot可以快速的开发单个微服务。
    • 约定大于配置！
  • Spring Cloud
    • SpringCloud 是基于SpringBoot实现的。

2.IOC的本质

中文的意思为控制反转，也可以将他理解为一个容器。

  • 是一种的设计的思想，就是将原本在程序中创建对象的控制权，交由Spring框架进行管理。
  • 正常控制：new一个对象
  • 反控:如果要使用某个对象，是需要只需要从Spring容器获取需要使用的对象，不用关心对象的创建的过程，也就是将创建对象的控制权交给Spring框架。

3.HelloSpring

  1. 导入Spring相关jar包
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.1.10.RELEASE</version>
</dependency>
  1. 编写相关代码
    2.1编写一个Hello实体类
package com.jiao;

public class Hello {
    private String name;

    public String getName() {
        return name;
    }

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

    public void show(){
        System.out.println("Hello:"+name);
    }
}

2.2 写编写我们的spring文件 , 这里我们命名为beans.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就是java对象，由Spring创建和管理-->
  <bean id="hello" class="com.jiao.Hello">
      <property name="name" value="张阿娇"/>
  </bean>

</beans>

2.3 我们可以去进行测试了 .

import com.jiao.Hello;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    @Test
    public void Test(){
        //解析beans.xml文件，生成管理相应的Bean对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //getBean:参数即为Spring配置文件中bean的id
        Hello hello = (Hello) context.getBean("hello");
        hello.show();
    }
}

4、IOC创建对象的方式

  1. 使用无参构造创建对象，默认！
  2. 假设我们要使用有参构造创建对象。

在beans.xml文件中

无参构造创建对象
    方式1：下标赋值
    <bean id="user" class="com.jiao.pojo.User">
        <constructor-arg index="0" value="张阿娇"></constructor-arg>
    </bean>

    方式2：直接通过参数名来赋值
    <bean id="user" class="com.jiao.pojo.User">
        <constructor-arg name="name" value="南胖子"/>
    </bean>


    方式3：通过类型创建，不建议使用
    <bean id="user" class="com.jiao.pojo.User">
        <constructor-arg type="java.lang.String" value="加油啊"/>
    </bean>

5、Spring配置

5.1、别名

<bean id="UserTwo" class="com.jiao.pojo.UserTwo">
        <constructor-arg index="0" value="张可爱"/>
    </bean>
    别名：如果添加了别名，我们也可以使用别名获取到这个对象
    <alias name="UserTwo" alias="user"/>
	
	name也是别名，而且name可以同时取多个别名
    <bean id="UserTwo" class="com.jiao.pojo.UserTwo" name="u1,u2,u3">
        <constructor-arg type="java.lang.String" value="南狗"/>
    </bean>

5.2、import

这个import，一般用于团队开发使用，他可以将多个配置文件，导入合并为一个。假设，现在项目中有多个人开发，这三个人复制不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的applicationContext.xml！

<import resource="beans.xml"/>
    <import resource="beans1.xml"/>

6、依赖注入

6.1、构造器注入

6.2、Set方式注入 【重点】

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

1.Address类

package com.jiao.pojo;

public class Address {
    private String Address;

2.Student类

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String,String> cards;
    private Set<String> games;
    private String wife;
    private Properties info;

3.beans.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.jiao.pojo.Address">
        <property name="address" value="陕西西安"/>
    </bean>

    <bean id="student" class="com.jiao.pojo.Student">
        <!--第一种，普通值注入，value-->
        <property name="name" value="张可爱"/>
        <!--第二种,Bean注入，ref-->
        <property name="address" ref="address"/>
        <!--数组-->
        <property name="books">
            <array>
                <value>西游记</value>
                <value>三国演义</value>
                <value>红楼梦</value>
                <value>水浒传</value>
            </array>
        </property>
        <!--List-->
        <property name="hobbys">
            <list>
                <value>吃</value>
                <value>喝</value>
                <value>玩</value>
                <value>乐</value>
            </list>
        </property>
        <!--Map-->
        <property name="cards">
            <map>
                <entry key="身份证" value="610424"/>
                <entry key="银行卡" value="0077"/>
            </map>
        </property>
        <!--Set-->
        <property name="games">
            <set>
                <value>AOA</value>
                <value>BOB</value>
                <value>COC</value>
            </set>
        </property>
        <!--null-->
        <property name="wife">
            <null/>
        </property>
        <!--Properties-->
        <property name="info">
            <props>
                <prop key="学号">20150615140</prop>
                <prop key="性别">女</prop>
            </props>
        </property>
    </bean>
    
</beans>

4.测试类

@Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student);
    }

6.3、拓展方式注入（p和c注入）

我们可以使用 p命令空间和c命令空间进行注入。

p命名空间注入，可以直接注入属性的值：property
    <bean id="user" class="com.jiao.pojo.User" p:name="张可爱" p:age="11"/>

    c命名空间注入，通过构造器注入：construct-args
    <bean id="user" class="com.jiao.pojo.User" c:name="南胖子" c:age="20"/>

注意点：p命名和c命名空间不能直接使用，需要导入xml约束！

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

6.4、bean的作用域

在这里插入图片描述

  1. 单例模式：Spring默认机制
    <bean id="user" class="com.jiao.pojo.User" c:name="张三" c:age="11" scope="singleton"/>
  1. 原型模式：每次从容器中get的时候，都会产生一个新对象
    <bean id="user" class="com.jiao.pojo.User" c:name="李四" c:age="23" scope="prototype"/>
DuDuDu.
关注
SpringIOC DI循环依赖实例详解
08-24
SpringIOC 是一个基于依赖注入（Dependency Injection，简称 DI）的容器，用于管理 Bean 的生命周期。 DI 循环依赖是指在 Bean 初始化过程中出现的循环依赖问题，即一个 Bean 依赖于另一个 Bean，而后者又依赖于前者...
springIOC和DI
05-08
什么是spring，spring核心，spring优点，spring体系结构， 入门案例，DI基础，核心API，文档内附代码
Spring IOC 和 DI详解
m0_61876562的博客
04-22 1229
IOC 是Spring的核心思想。其实IOC在前面 Spring MVC 部分我们就已经用到了。代码部分，我们在类上添加@RestController 和 @Controller 注解, 就是把这个对象交给Spring管理Spring 框架启动时就会加载该类。把对象交给Spring管理, 就是IoC思想。IOC: Inversion of Control (控制反转), 也就是说 Spring 是一个"控制反转"的容器.什么是控制反转呢?也就是控制权反转。什么的控制权发生了反转?
SpringIOC/DI详解
qq_63688997的博客
07-19 1195
SpringIOC/DI详细讲述，概念，包含内容实例化bean常用注解实现方式等等。
Spring——IoC和DI
浪漫不死的博客
03-02 3602
目录一、初识Spring为什么要使用Spring什么是SpringSpring框架的核心由哪些模块组成二、Core Container（核心容器）IoC（控制反转）什么是 IoCIoC 的作用IoC 的优点IoC 的缺点DI（依赖注入）什么是DI依赖注入的基本原则依赖注入的优势不同类型的依赖注入实现方式构造器依赖注入和 Setter方法注入的区别顶级接口BeanFactory 和 ApplicationContext 的区别BeanFactory和ApplicationContext的关系详解Applica
spring中IoC和DI浅析
ldcaws的专栏
08-16 1062
IoC和DI都是spring框架中的重要概念，通常也是成对出现的，下面对IoC和DI及其关系进行简单分析。
spring IOC和DI 理解
zhang2383906154的博客
11-15 2862
IOC(控制反转)和DI（依赖注入）是spring中的重要组成部分，下面是个人的一些理解，不代表官方。 1、IOC是什么？ IOC:全名是Inversion of Controller 中文解释是控制反转，不是什么技术，是一种设计思想。在java开发中IOC意味着你设计好的对象交给容器控制，而不是传统的在你对象内部直接控制。如何理解好IOC那？理解IOC的关键是要明确：“谁控制谁”、“控制什么”、为何是反转（有反转就应该有正转）哪些方面反转了，我们来分析一下： 1）谁控制谁，控制什么：传统的java
Spring IoC & DI（笔记）
LHY537200的博客
07-30 880
什么是容器？生活中的水杯,垃圾桶,冰箱等等这些都是容器，我们接触的容器有哪些?List/Map->数据存储容器Tomcat-> Web 容器。什么是IoC？IoC是Spring的核⼼思想，其实IoC我们在前⾯已经使⽤了,我们在前⾯讲到,在类上⾯添加@RestController和@Controller 注解。就是把这个对象交给Spring管理,Spring框架启动时就会加载该类.把对象交给Spring管理,就是IoC思想.
Spring IOC&DI
zhuge_long的专栏
05-31 1099
Resource注解与@Autowired注解的作用是一样的，都是用来为bean对象注入值的，唯一的区别是@Resource注解要根据实例化的bean名称为bean对象注入值。@Resource(name = “userDaoImpl2”)//name属性设置注入对象的属性名，如果属性名和name注入的名称一致的，name可以不赋值。Spring5.0开始，倡导以注解方式完成对象的管理，如果对象无法使用注解，就将对象交给spring的配置统一管理，而不再推荐使用xml配置的方式！
Spring--IoC与DI
qq_33807380的博客
03-21 1094
IoC（Inversion of Control，控制反转）是Spring框架的核心部分，是一个设计模式，它允许将对象的创建和依赖关系的管理从应用程序代码中分离出来，交给外部容器处理。这种模式的核心思想是“控制”的反转，即由传统的由对象自己创建依赖转变为由外部容器在运行时注入依赖。IoC容器是Spring框架中实现IoC概念的核心组件，主要负责实例化、配置和组装应用程序中的对象，并管理它们的生命周期。
Spring详解—— IOC 和 DI 区别
说故事的五公子
06-25 1635
我们只要提到Spring这个词，有简单了解过Spring的人基本上都会脱口而出IoC、DI和AOP这几个概念。但是对于初学者来说，一下子搞懂IoC和DI的概念还是挺麻烦的。比如之前我自己刚刚学习Spring的时候，只知道IoC能够帮我们创建对象，不再需要我们自己去创建了，并且那时IoC和DI傻傻分不清，对AOP的概念就更加不用说了。所以这次一定要好好理解。IoC（Inversion of Control）的意思是“控制反转”，它是Spring最核心的点，并且贯穿始终。IoC并不是一门技术，而是一种设计思想。
深入浅出讲解Spring IOC和DI的区别
小电玩
10-21 828
很多人都会把ioc和di说成同一个东西，其实IOC和DI虽然在概念上可以笼统地视为同一事物，但其本质上存在区别。IOC（Inverse of Control，控制反转）从容器的角度描述，而DI（Dependency Injection，依赖注入）则从应用程序的角度描述。换言之，IOC是依赖倒置原则的设计思想，而DI则是该原则的具体实现方式。因此，我们希望能够更加严谨地区分这两个概念，以更好地理解和应用它们。
Spring IOC和DI实现原理及实例解析
08-19
Spring IOC和DI实现原理及实例解析 Spring IOC（Inversion ...Spring IOC和DI的实现原理及实例解析是Spring框架的基础，它提供了一种灵活和可扩展的方式来管理对象之间的依赖关系，提高了应用程序的可维护性和灵活性。
spring核心IOC以及DI
01-21
【Spring核心IOC以及DI】是Spring框架中的关键概念，它们是Spring实现控制反转（Inversion of Control，简称IOC）和依赖注入（Dependency Injection，简称DI）的基石。这两个概念是Spring框架的核心，使得应用程序的...
南京工业大学在辽宁2020-2024各专业最低录取分数及位次表.pdf
10-04
那些年，与你同分同位次的同学都去了哪里？全国各大学在辽宁2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
下单系统的Spnigboot和微信小程序实现（全栈微信小程式下单）.zip
10-04
下单系统的Spnigboot和微信小程序实现（全栈微信小程式下单）
基于Java开发的智能文件管家设计源码
最新发布
10-04
该项目是一款基于Java的智能文件管家设计源码，涵盖102个文件，包括29个Java源文件、27个类文件、19个XML配置文件、10个YAML文件、8个列表文件、4个属性文件、4个JAR包文件以及1个Git忽略文件。该系统旨在提供高效便捷的文件管理解决方案。
基于YoloV8的简单目标检测和跟踪，使用KMNET进行鼠标移动（处理多目标移动抖动，处理鼠标平滑移动）.zip
10-04
基于YoloV8的简单目标检测和跟踪，使用KMNET进行鼠标移动（处理多目标移动抖动，处理鼠标平滑移动）
Spring IOC与DI深度解析
"本文详细探讨了Spring框架中的IoC（Inversion of Control，控制反转）概念，以及依赖注入（Dependency Injection，DI）的工作原理，并通过XML配置文件的方式展示了如何在Spring中实现IOC。" Spring框架的核心特性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值