Spring 控制反转(IoC)

最新推荐文章于 2024-07-18 15:34:18 发布
最新推荐文章于 2024-07-18 15:34:18 发布
阅读量168 收藏
点赞数
分类专栏： Spring学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kdisaaa/article/details/108380485
版权

Spring笔记二：

控制反转(IoC)：

1、什么是IoC？

IoC，Inversion of Control（控制反转）。

是一种设计思想，在Java开发中，将你设计好的对象交给容器控制，而不是显示地用代码进行对象的创建。

把创建和查找依赖对象的控制权交给 IoC 容器，由 IoC 容器进行注入、组合对象。这样对象与对象之间是松耦合、便于测试、功能可复用（减少对象的创建和内存消耗），使得程序的整个体系结构可维护性、灵活性、扩展性变高。

使用 IoC 的好处：

资源集中管理，实现资源的可配置和易管理
降低了资源的依赖程度，即松耦合
便于测试
功能可复用（减少对象的创建和内存消耗）
使得程序的整个体系结构可维护性、灵活性、扩展性变高

DI（Dependency Injection）依赖注入，是 IoC 容器装配、注入对象的一种方式。
通过依赖注入机制，简单的配置即可注入需要的资源，完成自身的业务逻辑，不需要关心资源的出处和具体实现。

spring 提供了三种主要的方式来配置 IoC 容器中的 bean
1.基于 XML 文件配置
2.基于注解配置
3.基于注解 + java 代码显式配置

=DI不是IoC=

2、demo(xml文件配置)：

实体类：

package com.itcast.pojo;

public class Hello {
    private String str;

    public Hello() {
    }

    public Hello(String str) {
        this.str = str;
    }

    public String getStr() {
        return str;
    }

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

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

使用spring配置文件beans.xml
将实体类属性注入值
bean相当于new
对比：
Hello hello = new Hello();
id:变量名 、 class 类型 、 <property 属性注入 ，name字段名 value/ref 注入的值或引用

<?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="hello" class="com.itcast.pojo.Hello">
        <property name="str" value="Hello Spring IoC"/>
    </bean>
</beans>

测试：

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

public class MyTest {
    @Test
    public void HelloIoc(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Hello hello = context.getBean("hello", Hello.class);
        System.out.println(hello.toString());
    }
}

结果
【也可以使用构造器注入（不好用）】

3、*.xml配置

①别名：alias / name

    <alias name="hello" alias="abcxyz"/>
    <bean id="hello" class="com.itcast.pojo.Hello">
        <property name="str" value="Hello Spring IoC"/>
    </bean>

<!--    <alias name="hello" alias="abcxyz"/>-->
    <bean id="hello" class="com.itcast.pojo.Hello" name="abcxyz">
        <property name="str" value="Hello Spring IoC"/>
    </bean>

测试：

  ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Hello h1 = context.getBean("abcxyz", Hello.class);
        System.out.println(h1.toString());

② import：
可以将多个配置文件导入到一个配置文件中

4、DI（依赖注入）

①构造器注入(不好用)
②set方式依赖注入
依赖：bean对象的创建依赖于容器
注入：bean对象的属性，由容器来注入
准备：
实体类：
Student

package com.itcast.pojo;

import java.util.*;

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

    public Student() {
    }

    public Student(String name, Address address, String[] books, List<String> hobbies, Map<String, String> card, Set<String> games, String wife, Properties info) {
        this.name = name;
        this.address = address;
        this.books = books;
        this.hobbies = hobbies;
        this.card = card;
        this.games = games;
        this.wife = wife;
        this.info = info;
    }

    public String getName() {
        return name;
    }

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

    public Address getAddress() {
        return address;
    }

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

    public String[] getBooks() {
        return books;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public List<String> getHobbies() {
        return hobbies;
    }

    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }

    public Map<String, String> getCard() {
        return card;
    }

    public void setCard(Map<String, String> card) {
        this.card = card;
    }

    public Set<String> getGames() {
        return games;
    }

    public void setGames(Set<String> games) {
        this.games = games;
    }

    public String getWife() {
        return wife;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }

    public Properties getInfo() {
        return info;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address +
                ", books=" + Arrays.toString(books) +
                ", hobbies=" + hobbies +
                ", card=" + card +
                ", games=" + games +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
    }
}

Address

package com.itcast.pojo;

public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

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

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

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 name="address" class="com.itcast.pojo.Address">
        <property name="address" value="quanzhou"/>
    </bean>

    <bean name="student" class="com.itcast.pojo.Student">
<!--        普通值注入 value-->
        <property name="name" value="Lutra"/>
<!--        bean注入 ref-->
        <property name="address" ref="address"/>
<!--        数组array-->
        <property name="books">
            <array>
                <value>Java</value>
                <value>MySQL</value>
                <value>Vue</value>
            </array>
        </property>
<!--        list-->
        <property name="hobbies">
            <list>
                <value>唱</value>
                <value>跳</value>
                <value>Rap</value>
            </list>
        </property>
<!--        Map-->
        <property name="card">
            <map>
                <entry key="ID" value="123321"/>
            </map>
        </property>
<!--        Set-->
        <property name="games">
            <set>
                <value>WZRY</value>
                <value>LOL</value>
            </set>
        </property>
<!--        Properties-->
        <property name="info">
            <props>
                <prop key="姓名">kkk</prop>
                <prop key="sex">male</prop>
                <prop key="age">28</prop>
            </props>
        </property>
<!--        null-->
        <property name="wife">
            <null/>
        </property>
    </bean>

</beans>

测试：

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

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student s = context.getBean("student", Student.class);
        System.out.println(s.toString());
    }
}

结果：

Student{name='Lutra', address=Address{address='quanzhou'}, books=[Java, MySQL, Vue], hobbies=[唱, 跳, Rap], card={ID=123321}, games=[WZRY, LOL], wife='null', info={姓名=kkk, sex=male, age=28}}

③其它方式
p命名方式 / c命名方式
p命名方式（set方式）：
*.xml导入约束：

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

<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">

    <bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close"
        p:driverClassName="com.mysql.jdbc.Driver"
        p:url="jdbc:mysql://localhost:3306/mydb"
        p:username="root"
        p:password="misterkaoli"/>

</beans>

c命名方式（构造器方式）：
*.xml导入约束：

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

<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">

    <bean id="beanTwo" class="x.y.ThingTwo"/>
    <bean id="beanThree" class="x.y.ThingThree"/>

    <!-- traditional declaration with optional argument names -->
    <bean id="beanOne" class="x.y.ThingOne">
        <constructor-arg name="thingTwo" ref="beanTwo"/>
        <constructor-arg name="thingThree" ref="beanThree"/>
        <constructor-arg name="email" value="something@somewhere.com"/>
    </bean>

    <!-- c-namespace declaration with argument names -->
    <bean id="beanOne" class="x.y.ThingOne" c:thingTwo-ref="beanTwo"
        c:thingThree-ref="beanThree" c:email="something@somewhere.com"/>
</beans>

5、Bean的作用域

①singleton（默认）
(Default) Scopes a single bean definition to a single object instance for each Spring IoC container.
在这里插入图片描述

<bean id="accountService" class="com.something.DefaultAccountService"/>

<!-- the following is equivalent, though redundant (singleton scope is the default) -->
<bean id="accountService" class="com.something.DefaultAccountService" scope="singleton"/>

②Prototype
Scopes a single bean definition to any number of object instances.
在这里插入图片描述

<bean id="accountService" class="com.something.DefaultAccountService" scope="prototype"/>

③Request, Session, Application, and WebSocket Scopes

eeeEasyMoney
关注
专栏目录
Spring控制反转IOC与依赖注入DI和AOP切面编程
m0_37601917的博客
12-25 504
IOC控制反转         IoC叫控制反转，英文Inversion of Control，控制反转就是把 由程序代码直接操作的对象第调用权交给容器处理，通过容器实现对象组件的装配和管理。说白了就是 对组件对象控制权的转移，从程序转移到外部容器，由容器创建对象并管理对象间依赖关系。         控制反转的技术大大促进了代码间的松耦合。一个对象依赖的其他对象会通过被动的方式传递进来，而不...
Spring——Spring核心（IoC）控制反转详细说明
Java_zhujia的博客
11-15 508
控制反转IoC(Inversion of Control） 是一个概念，是一种思想。指将传统上由程序代码直接操控的对象调用权交给容器，通过容器来实现对象的装配和管理。控制反转就是对对象控制权的转移，从程序代码本身反转到了外部容器。通过容器实现对象的创建，属性赋值， 依赖的管理。IoC 是一个概念，是一种思想，其实现方式多种多样。当前比较流行的实现方式是依赖注入。应用广泛。
什么是 IoC？
ConstXiong
07-15 7258
什么是 IoC？ IoC，Inversion of Control（控制反转）。 是一种设计思想，在Java开发中，将你设计好的对象交给容器控制，而不是显示地用代码进行对象的创建。 把创建和查找依赖对象的控制权交给 IoC 容器，由 IoC 容器进行注入、组合对象。这样对象与对象之间是松耦合、便于测试、功能可复用（减少对象的创建和内存消耗），使得程序的整个体系结构可维护性、灵活性、扩展...
什么是IOC
xfans12000的专栏
03-05 1293
 什么是IOC关键词： spring    IOC（控制反转）                                           近日，组长要我们每两个人学一种技术，让我和另一个组员学习spring，我就看了一些资料，得知spring是面向方面编程（AOP）和控制反转 （IOC） 容器。那什么是IOC呢，在网上搜到了一非常有意思的讲解。IoC就是Inversi
什么是IoC控制反转思想？
最新发布
luming的博客
07-18 1476
IoC（Inversion of Control）即控制反转，这里的控制是代表控制权的意思，IoC是一种编程思想，旨在降低代码之间的耦合度、降低代码的维护成本。这种思想的具体内容就是将对象的创建和管理交给外部的容器和框架，不再是由对象的调用者去new一个对象。在这个过程中，对象的创建和管理的权力由传统的对象调用者转移到了外部的容器和框架，即对象的控制权发生了反转。
IOC是什么
welcomejzh的专栏
01-24 8597
IoC是什么？Inversion of Control，即反转控制，或许说为依赖注入更为合适。IoC就是IoC，不是什么技术，与GoF一样，是一种设计模式。     Interface Driven Design接口驱动，接口驱动有很多好处，可以提供不同灵活的子类实现，增加代码稳定和健壮性等等，但是接口一定是需要实现的，也就是如下语句迟早要执 行：AInterface a = new AInt
什么是IOC？
热门推荐
weixin_51585717的博客
06-07 4万+
把复杂系统分解成相互合作的对象，这些对象类通过封装以后，内部实现对外部是透明的，从而降低了解决问题的复杂度，而且可以灵活地被重用和扩展。
什么是ioc
qq_40876052的博客
03-30 2792
    spring会把对象控制权交给容器，容器创建了一个又一个的对象，通过DI呢，又确定了各个对象之间的关系。但是你们会不会好奇，spring是怎么把容器里的对象给到我们的呢？今天我们就来聊一聊spring的应用上下文。 1、容器在spring里面是如何存在的？   spring的容器，我们一般称之为ioc容器，其实就是项目中的一个xml配置文件，通过配置这个xml，我们来控制各个对象之间的...
Spring框架控制反转IOC和依赖注入DI详解
01-20
本文介绍了Spring框架中的控制反转IOC和依赖注入DI，欢迎阅读，共同学习，一起进步。 Spring框架基础参考：深入学习Spring基础 文章目录一.入门程序和IOC简介二.IOC-控制反转三.DI-依赖注入四. IOC和DI五.Spring...
Spring.Net控制反转IoC入门使用
08-30
本文主要关注的是Spring.NET的核心特性——控制反转（Inversion of Control，简称IoC）。 控制反转是一种设计模式，它将对象的创建和依赖关系的管理从应用代码中解耦出来。通过IoC，对象不再负责创建和管理其依赖项...
Spring核心之控制反转(IOC)
一名很普通的互联网打工人
04-30 403
如何理解IoC Spring Bean是什么 IoC Container管理的是Spring Bean， 那么Spring Bean是什么呢？ 本人整理各种Java核心知识点与多家公司面试知识点整理 免费分享给大家，我认为是非常有用的，想要资料的话请点 白嫖这份礼物←戳我 Spring里面的bean就类似是定义的一个组件，而这个组件的作用就是实现某个功能的，这里所定义的bean就相当于给了你一个更为简便的方法来调用这个组件去实现你要完成的功能。 IoC是什么 Ioc—Inversion ..
IoC是什么
weixin_33832340的博客
04-11 85
IoC是什么 Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下： ●谁控制谁，控制什么：传统Java...
什么是IOC?
weixin_64572002的博客
06-12 5816
介绍：Spring框架是一个开源代码的J2EE应用程序框架，由Rod Johnson发起，是针对bean的生命周期进行管理的轻量级容器（lightweight container）。 Spring解决了开发者在J2EE开发中遇到的许多常见的问题，提供了功能强大IOC、AOP及Web MVC等功能。Spring可以单独应用于构筑应用程序，也可以和Struts、Webwork、Tapestry等众多Web框架组合使用，并且可以与 Swing等桌面应用程序AP组合。因此， Spring不仅仅能应用于J2EE应用程
Spring框架：控制反转IOC入门详解
控制反转（IoC）是Spring框架的核心概念，它是Spring框架实现模块化、松耦合和可测试性的重要手段。在Spring中，IoC技术允许开发者将对象的依赖关系管理交由容器负责，而不是在代码中硬编码。这种设计模式有助于减少...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值