SpringIOC

最新推荐文章于 2022-03-10 00:37:58 发布
最新推荐文章于 2022-03-10 00:37:58 发布
阅读量86 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40485495/article/details/113371274
版权
本文详细介绍了Spring框架中的控制反转（IOC）和依赖注入（DI）概念，通过实例展示了如何通过XML配置文件进行无参创建（设值注入）和有参创建（构造注入）。此外，还探讨了拓展的注入方式，包括p和c命名空间的使用，强调了这些设计原则可以减少代码耦合，提高灵活性。
摘要由CSDN通过智能技术生成

目录

IOC（控制反转）

解释
 控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是Spring来创建的。
 反转：程序本身不创建对象，而变成被动的接受对象


依赖注入（DI）

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

在配置文件加载的时候，容器中管理的对象就已经初始化了！且属于 单例模式

无参创建（设值 (set) 注入）

实体类Student

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String,String> card;
    private Set<String> games;
    private String wife;
    private Properties 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> getHobbys() {return hobbys;}

    public void setHobbys(List<String> hobbys) {this.hobbys = hobbys;}

    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;}

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

实体类Address

public class Address {
    private String address;

    public String getAddress() {return address;}

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

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

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

    <bean id="address" class="com.cf.pojo.Address">
        <property name="address" value="大连"/>
    </bean>
    <!--使用Spring来创建对象，在Spring这些都成为Bean
        类型  变量名 = new 类型();
       Hello hello = new Hello();

       id = 变量名
       class = new的对象
       property 相当于给对象中的属性设置一个值！
    -->
    <bean id="student" class="com.cf.pojo.Student">
        <!--普通值注入，value-->
        <property name="name" value="眯帝"/>
        <!--Bean注入，ref-->
        <property name="address" ref="address"/>
        <!--
        ref :引用Spring容器中创建好的对象
        value :具体的值,基本数据类型!
        -->
        
        <!--数组-->
        <property name="books">
            <array>
                <value>人生失格</value>
                <value>战争与和平</value>
                <value>昆虫记</value>
            </array>
        </property>
        <!--list-->
        <property name="hobbys">
            <list>
                <value>桌游</value>
                <value>象棋</value>
                <value>影视</value>
            </list>
        </property>
        <!--map-->
        <property name="card">
            <map>
                <entry key="身份证" value="1252335"/>
                <entry key="会员卡" value="scx111"/>
            </map>
        </property>
        <!--set-->
        <property name="games">
            <set>
                <value>King</value>
                <value>饥荒</value>
                <value>三国杀</value>
            </set>
        </property>
        <!--null-->
        <property name="wife">
            <null/>
        </property>
        <!--Properties-->
        <property name="info">
            <props>
                <prop key="driver">2003</prop>
                <prop key="url">127.0.0.1</prop>
                <prop key="username">root</prop>
                <prop key="password">root</prop>
            </props>
        </property>
    </bean>
</beans>

测试类

public static void main(String[] args) {
        //获取Spring的上下文的对象！
        //Spring容器，类似于婚介所网站！不管你用不用，它会将里面的全部实例化
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //我们的对象现在都在Spring中的管理了，我们要使用，直接去里面取出来就可以！
        Student student = (Student)context.getBean("student");
        System.out.println(student);
    }

结果

Student{
name=‘眯帝’,
address=Address{address=‘大连’},
books=[人生失格, 战争与和平, 昆虫记],
hobbys=[桌游, 象棋, 影视],
card={身份证=1252335, 会员卡=scx111},
games=[King, 饥荒, 三国杀],
wife=‘null’,
info={password=root,
url=127.0.0.1, driver=2003, username=root}
}

OK，到了现在，我们彻底不用再程序中去改动了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓的loC,一句话搞定:对象由Spring来创建，管理，装配

有参创建（构造注入）

实体类（User）

public class User {
    private String name;

    public String getName() {
        return name;
    }

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

    public User(String name) {
        this.name = name;
    }

    public User() {}

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

applicationContext.xml
三种赋值方式
 1、下标赋值

	<bean id="user" class="com.cf.pojo.User">  
		<constructor-arg index="0" value="眯帝"></constructor-arg>
	</bean>

 2、类型创建（不建议使用，存在同类型参数就会混乱）

	<bean id="user" class="com.cf.pojo.User">
		<constructor-arg type="java.lang.String" value="眯帝"></constructor-arg>
	</bean>

 3、通过参数名设置

	<bean id="user" class="com.cf.pojo.User">
		<constructor-arg name="name" value="眯帝"></constructor-arg>
	</bean>

拓展范方式注入

我们可以使用p命令空间和c命令空间进行注入
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"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--p命名空间注入，可以直接注入属性的值：properties-->
    <bean id="user" class="com.cf.pojo.User" p:age="18" p:name="mid"/>

    <!--c命名空间注入，通过构造器注入：construct-args-->
    <bean id="user2" class="com.cf.pojo.User" c:age="19" c:name="mid"/>

</beans>

测试

@Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //p命令空间
        User user = context.getBean("user",User.class);
        System.out.println(user);

		//c命令空间
        User user2 = context.getBean("user2",User.class);
        System.out.println(user2);
    }

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

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

眯帝
关注
spring ioc
03-06
标题 "Spring IOC" 描述了我们讨论的核心主题——Spring 框架中的依赖注入（Inversion of Control，简称 IOC）机制。Spring 是一个广泛应用的 Java 应用开发框架，其核心特性之一就是IOC，它极大地简化了软件组件...
springIoc实现原理
04-20
**Spring Ioc 实现原理详解** Spring Ioc（Inversion of Control，控制反转）是Spring框架的核心特性之一，它改变了传统应用程序中对象的创建和管理方式。在传统的软件设计中，对象的创建和依赖关系的维护通常由...
Spring IOC
weixin_42213903的博客
12-09 357
what is IOC 控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup） Dependency Injection 依赖注入 关于什么是依赖 关于注入和查找以及拖拽...
SpringIoc
m0_49024941的博客
03-10 317
.Spring框架的概念 .Spring中ioc操作 .Spring的工作原理 一.Spring框架的概念 Spring是一个开源容器框架，可以接管web层，业务层，dao层，持久层的组件，并且可以配置各种bean,和维护bean与bean之间的关系。其核心就是控制反转(IOC),和面向切面(AOP),简单的说就是一个分层的轻量级开源框架。 二.Spring中的Ioc IOC：(全称:Inverse Of Control )，控制反转容器主动将资源推送给它所管理的组件，组件所做的是选择一种合理的
详解Spring IOC 容器启动流程分析
08-25
Spring IOC 容器启动流程分析 Spring IOC 容器是 Java 企业级应用程序的核心组件之一，它提供了一个统一的依赖注入机制，使得应用程序的组件之间能够松耦合。Spring IOC 容器的启动流程是整个 Spring 框架的核心...
SPRING IOC注入方式过程解析
08-25
SPRING IOC注入方式过程解析 SPRING IOC是一种轻量级的控制反转（Inversion of Control）容器框架，主要用于解耦合Java应用程序中的组件。其中，IOC（Inversion of Control）注入是SPRING IOC的核心机制之一。下面...
Spring实现一个简单的SpringIOC容器
08-30
Spring的IOC（Inversion of Control，控制反转）容器是其核心特性之一，它负责管理和装配应用程序中的对象。本文将深入探讨如何实现一个简单的Spring IOC容器，以及涉及的主要知识点。 首先，控制反转是一种设计...
springIOC
wca1995的博客
04-06 635
IOC:指程序中对象的获取方式发生了反转，从最初的new方式创建，转变为第三方框架创建，注入（DI）,它降低了对象之间的耦合度，是spring框架的基础与核心。IOC为一种控制反转的思想，DI是实现IOC的主要技术途径。DI：依赖注入，将一起工作具有关系的对象，通过构造方法参数或方法参数传入建立关联。DI实现方式：1.构造器注入2.setter注入3.接口注入（不常用）创建应用对象之间协作关系的行...
Spring IoC
qq_33700236的博客
03-29 127
1. Spring概述 Spring 中，它会认为 Java 类都是资源，而资源都 Bean ，容纳这些 Bean 的是 Spring 所提供的 IoC 容器，所以 Spring 种基于 Bean的编程。 2.SpringIoC概述 有如下的例子： 现实中系统的开发者是个团队，团队由许多开发者组成。现在假设你在一个电商网站负责开发工作，你熟悉商品交易流程，但是对财务却不怎么熟悉，而团队中有些成员对于财务处理分熟悉，在交易的过程中，商品交易流程需要调度财务的相关接口，才能得以实现，那么你的期望应该是： 熟
spring的ioc
qq_51476492的博客
10-29 1091
spring的核心技术：ioc,aop，能实现模块之间、类之间的解耦合。 依赖：class a 中使用了class b的属性或者方法，则称class a依赖class b。 1.ioc(Inversion of control):控制反转 使用ioc的目的是减少对代码的改动，实现不同的功能，即解耦合。 ...
Spring-IOC
Lubin_9527的博客
10-31 207
spring框架 Spring是什么： Spring是一个轻量级的DI和AOP容器框架。 说它轻量级有一大部分原因是相对与EJB的用，重要的是，Spring是非侵入式的，基于spring开发的应用一般不依赖于spring的类。 DI:称作依赖注入(Dependency Injection),和控制反转一个概念，具体的讲，当一个角色需要另外一个角色协助的时候，在传统的程序设计中，通常有调用者来创...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值