Spring控制反转和依赖注入

最新推荐文章于 2024-08-15 18:07:41 发布
最新推荐文章于 2024-08-15 18:07:41 发布
阅读量509 收藏 1
点赞数 2
分类专栏： SSM 文章标签： Spring依赖注入和控制反转
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SkjEndZhq/article/details/90545277
版权

Spring是一个容器，可以帮助我们创建和管理对象。Spring的俩大特性是IOC和AOP。
IOC是指控制反转：IOC是一种思想，IOC把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是 松散耦合，这样也方便测试，利于功能复用，使得程序的整个体系结构变得非常灵活。
示例;
在这里插入图片描述
实现控制反转有3种方式(bean的实例化)

  1. 构造器方式（默认）：
    示例：
package com.icss.biz;

public class Dog {
	private String name;
	public Dog(){
		System.out.println("初始化Dog");
	}

package com.icss.ui;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.icss.biz.Dog;
public class Test {
public static void main(String[] args) {
	  //IoC容器
    ApplicationContext ctx=
            new ClassPathXmlApplicationContext("beans.xml");
    //从容器中获取对象
   Dog dog = (Dog)ctx.getBean("dog");
}
}


<?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="dog" class="com.icss.biz.Dog">          
        </bean>
</beans>

输出结果：

初始化Dog

注意：当beans配置了有参构造时，有参构造会覆盖无参构造。
示例：

package com.icss.biz;

public class Dog {
	private String name;
	private int  age;
	public Dog(){
		System.out.println("初始化Dog");
	}
	public Dog(String name,int age){
		this.name = name;
		this.age = age;
		System.out.println("初始化Dog"+this.name+this.age+"岁了");
	}
	
}


package com.icss.ui;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.icss.biz.Dog;
public class Test {
public static void main(String[] args) {
	  //IoC容器
    ApplicationContext ctx=
            new ClassPathXmlApplicationContext("beans.xml");
    //从容器中获取对象
   Dog dog = (Dog)ctx.getBean("dog");
}
}


<?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="dog" class="com.icss.biz.Dog">
            <constructor-arg name="name" value="旺财"></constructor-arg>  
            <constructor-arg name="age" value="3"></constructor-arg>  
        </bean>

</beans>

输出结果：

初始化Dog旺财3岁了

注意：以下内容中的name可以换为index=“0”,index="1"即成员变量的序号，结果一样

    <constructor-arg name="name" value="旺财"></constructor-arg>  
            <constructor-arg name="age" value="3"></constructor-arg>
  1. 静态工厂方式：beans配置工厂类以及工厂类定义创建实例的方法
    示例：
package com.icss.biz;
public class Dog {
	private String name;
	private int  age;
	public void getname() {
		System.out.println("调用工程类生产对象的getname方法");
	}
}

package com.icss.biz;
public class StaticFactory {
public static Dog  getDog() {
	return new Dog();
}
}

package com.icss.ui;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.icss.biz.Dog;
public class Test {
public static void main(String[] args) {
	  //IoC容器
    ApplicationContext ctx=
            new ClassPathXmlApplicationContext("beans.xml");
    //从容器中获取对象
   Dog dog = (Dog)ctx.getBean("dog");
   dog.getname();
}
}

<?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="dog" class="com.icss.biz.StaticFactory" factory-method="getDog">     
        </bean>
</beans>

输出结果：

调用工程类生产对象的getname方法
  1. 普通工厂方式：初始化工厂类的实例，通过执行工厂类的方法创建对象并返回
package com.icss.biz;

public class Dog {
	private String name;
	private int  age;
	public void getname() {
		System.out.println("调用工程类生产对象的getname方法");
	}
	
}


package com.icss.biz;

public class Factory {
public Dog createDog() {
	return new Dog();
}
}


package com.icss.ui;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.icss.biz.Dog;
import com.icss.biz.Factory;
public class Test {
public static void main(String[] args) {
	  //IoC容器
    ApplicationContext ctx=
            new ClassPathXmlApplicationContext("beans.xml");
    //从容器中获取对象
   Dog dog = (Dog)ctx.getBean("dog");
   dog.getname();
}
}


<?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="factory" class="com.icss.biz.Factory">
        </bean>
        <bean id="dog" factory-bean="factory" factory-method="createDog" >
        </bean>
		 
</beans>

输出结果：

调用工程类生产对象的getname方法

beans的xml文件中还可以用以下这种方式引入另外一个xml配置文件

 <import resource="引入配置文件相对于当前配置文件的相对路径"/>

那么，现在对象已经有了，我们如何管理这些对象以及这些对象之间的关系呢？------->依赖注入机制
依赖注入有俩种方案

  • 手动注入：分为构造注入和Setter注入，
    Setter注入示例代码：
package com.icss.biz;

public class Dog {
	private String name;
	private int  age;
	public String getName() {
		System.out.println("狗狗的名字为"+this.name);
		return name;
	}
	public void setName(String name) {
		
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}


package com.icss.biz;

public class Boy {
	private String name;
	
private  Dog dog;

public String getName() {
	
	return name;
}

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

public Dog getDog() {
	return dog;
	
}

public void setDog(Dog dog) {
	this.dog = dog;
}

}


package com.icss.ui;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.icss.biz.Boy;
import com.icss.biz.Dog;
import com.icss.biz.Factory;
public class Test {
public static void main(String[] args) {
	  //IoC容器
    ApplicationContext ctx=
            new ClassPathXmlApplicationContext("beans.xml");
    //从容器中获取对象
    Boy boy = (Boy)ctx.getBean("boy");
    System.out.println("男孩的名字为"+boy.getName());
    Dog dog = boy.getDog();
    dog.getName();
   }
}


<?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="dog" class="com.icss.biz.Dog">
        	<property name="name" value="旺财" ></property>
        	<property name="age" value="3" ></property>
        </bean>
        <bean id="boy" class="com.icss.biz.Boy">
        	<property name="name" value="小王"></property>
        	<property name="dog" ref="dog" ></property>
        	
        </bean>
        
		
</beans>

输出结果

男孩的名字为小王
狗狗的名字为旺财

构造注入：Spring在初始化bean组件时调用含参数的构造函数对全局变量进行赋值
示例代码：

package com.icss.biz;

public class Dog {
	private String name;
	private int  age;
	public String getName() {
		System.out.println("狗狗的名字为"+this.name);
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

}


package com.icss.biz;

public class Boy {
	private String name;
	private  Dog dog;
	public  Boy(String name, Dog dog) {
		this.name = name;
		this.dog = dog;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Dog getDog() {
		return dog;
	}
	public void setDog(Dog dog) {
		this.dog = dog;
	}
	
}


package com.icss.ui;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.icss.biz.Boy;
import com.icss.biz.Dog;
import com.icss.biz.Factory;
public class Test {
public static void main(String[] args) {
	  //IoC容器
    ApplicationContext ctx=
            new ClassPathXmlApplicationContext("beans.xml");
    //从容器中获取对象
    Boy boy = (Boy)ctx.getBean("boy");
    System.out.println("男孩的名字为"+boy.getName());
    Dog dog = boy.getDog();
    dog.getName();
   }
}


<?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="dog" class="com.icss.biz.Dog">
        	<property name="name" value="旺财" ></property>
        	<property name="age" value="3" ></property>
        </bean>
        <bean id="boy" class="com.icss.biz.Boy">
        	<constructor-arg index="0" value="小明"></constructor-arg>
        	<constructor-arg index="1" ref="dog"></constructor-arg>
        </bean>
        
		
</beans>

运行结果：

男孩的名字为小明
狗狗的名字为旺财
  • 自动注入（了解即可）

bean的初始化时间：（Spring创建javaBean的时间）

  1. 当scope=“prototype”，每次在获取对象的实例时创建一个对象的实例。
  2. 当scope=“singleton”,会根据bean标签的lazy-init属性值选择创建的时间:（默认default相当于flase）
    当lazy-init=“true”， 第一次获取对象实例时创建对象
    当lazy-init=“false",在容器加载时创建对象。
    bean的销毁：
    Spring在创建bean实例后，调用bean的初始化方法，Spring容器关闭后，bean不在被Spring容器调用，进入垃圾可回收阶段，在容器关闭之前，会调用bean的销毁方法（只有scope="singleton"时，bean才会执行销毁方法）
zz小王子
关注
专栏目录
spring 控制反转和依赖注入.docx
11-14
Spring 控制反转和依赖注入基础知识详解 Spring 框架是 Java 企业级开发的轻量级开发框架，于 2003 年创建，主要用于解决企业级开发的复杂性。其主要优势在于分层架构，允许在不同层级中使用一个组件（其他框架）...
详解Spring框架----控制反转与依赖注入
qq_44227032的博客
06-24 1205
Spring是一个轻量级的框架，它的主要特点是控制反转IOC（Inversion Of Control）和面向切面AOP。好处：可以降低程序的耦合，便于编码。
[javaweb]——spring框架之控制反转(IOC)与依赖注入(DI)
Panci_的博客
10-28 2737
spring框架的两大核心思想：控制反转，面向切面编程。控制反转：简称IOC，对象的创建控制权由程序自身转移到外部（容器），这种思想称为控制反转依赖注入：简称DI，容器为程序提供运行时所依赖的资料，称为依赖注入。Bean对象：IOC容器中创建、管理的对象叫bean对象最后缕一缕：1.由于代码的高内聚(多功能混一块了)，我们设计了出三层架构模式，Controller Service Dao，2.但是代码的耦合问题(一个模块对另一模块有依赖)没有解决，于是就有了控制反转与依赖注入，这两步合起来就是分层解耦。
Spring 控制反转与依赖注入
时间如瑾 代码如诗
07-24 652
本文介绍了控制反转(IoC)和依赖注入(DI)在Spring框架中的作用，通过实例阐述了它们如何帮助实现对象的解耦、提高灵活性和可维护性，以及如何在代码中应用这些设计原则。
Spring学习总结【二】---IoC(控制反转)
weixin_42190209的博客
03-02 591
文章目录IoC理论推导IoC本质工作原理IoC创建对象的方式 IoC理论推导 在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改原代码，如果程序代码量十分大，修改一次的成本代价十分昂贵! 之前，程序是主动创建对象，控制权在程序猿手上。 使用了set注入后，程序不再具有主动性，而是变成了被动的接受对象。 这种思想，从本质上解决了问题，我们程序猿不用再去管理对象的创建了。系统的耦合性大大降低，可以更加专注的在业务的实现上！ 这是IOC的原型！ IoC本质 控制反转IoC(
Spring：IoC（控制反转、依赖注入、循环依赖）
燕双嘤
01-21 1638
1，IoC（Spring的核心和基础） 1.1，IoC原理 纵观所有的Java应用（从基于Applet的小应用到多层结构的企业级应用），这些应用中大量存在A对象调用B对象方法的情况，者请情况被Spring称为依赖，即A对象依赖B对象。对于Java应用而言，它们总是由一些相互调用的对象构成的，Spring把这种相互调用的关系称为依赖关系。假如A组件调用了B组件的方法，即可称A组件依赖B组件。 Spring框架的核心功能有两个： Spring容器作为超级大工厂，负责创建、管理所有的Java对象，这些J
理解Spring中的依赖注入和控制反转
qiaotl的博客
02-28 1050
通过理论介绍和demo代码的方式理解java中的依赖注入工作原理
Spring 控制反转 依赖注入
04-15
**Spring 框架中的控制反转 (IoC) 和依赖注入 (DI)** 在软件开发中，控制反转（Inversion of Control，简称IoC）是一种设计原则，它将对象的创建和管理权从代码中剥离出来，转交给一个外部容器（如Spring框架）。...
实例讲解Java的Spring框架中的控制反转和依赖注入
09-02
在Java的Spring框架中，控制反转（IoC，Inversion of Control）和依赖注入（DI，Dependency Injection）是核心设计理念，它们旨在降低组件之间的耦合度，提高代码的可测试性和可维护性。Spring框架通过IoC容器来管理...
Spring(一)控制反转和依赖注入
weixin_44458879的博客
11-21 298
想要深入学习Spring的朋友,一定会有收获的
Spring框架的控制反转和依赖注入
qq_63437335的博客
04-18 711
依赖注入的基本思想是：明确地定义组件接口，独立开发各个组件，然后根据组件的依赖关系组装运行。在使用依赖注入时，如果注入的是 Bean 对象，那么要求注入的 Bean 对象与被注入的 Bean 对象都需要 Spring IOC 容器来实例化。配置信息后，会通过反射方式调用实例的构造方法，如果是有参构造方法，可以在构造方法中传入所需的参数值，最后创建类对象。最主流的注入方法，这种注入方法简单、直观，它是在被注入的类中声明一个。被依赖的实例，构造方法可以是有参的或者是无参的。依赖注入通常有两种实现方式，一种是。
Spring依赖注入与控制反转
Bugxiu_fu的博客
08-16 377
spring容器的依赖注入，与案例实现
Java学习---Spring依赖注入和控制反转
weixin_63108463的博客
08-08 564
Java学习
spring控制反转与依赖注入
qq_51700372的博客
05-20 1236
1）什么是控制反转 传统的编程思路是，当我需要某个对象时，我便自己去实例化调用它 。而控制反转则是，当我需要某个对象时，自然有人帮我们实例化它 。简单的来说，这是一种衣来张口，饭来伸手式的控制模式，这也符合spring最根本的使命--简化java开发 。 2）什么是依赖注入 依赖注入，即是SpringIOC的一种实现方式，在我们完成业务开发的过程中，需要引入的依赖，都由交由spring容器管理注入 。简单的说，就是由spring容器替我们实例化对象 。 3）依赖注入解决了什么问题 在传统的业务实现
深入理解 Spring IoC 与 DI：控制反转与依赖注入解析
最新发布
weixin_71246590的博客
08-15 929
在接触 Spring 框架之前，通常我们会在 main 方法或其他业务逻辑中手动 new 对象，然后调用这些对象的方法来完成任务。手动创建对象的方式意味着我们自己掌握了对象的控制权。 然而，在 Spring 中，我们不再直接在代码中手动创建对象，而是将对象的创建、管理、依赖注入等职责交给了 Spring 容器。Spring 框架通过 IoC（控制反转）和 DI（依赖注入）来实现这一点。
Spring中的依赖注入和控制反转
weixin_46372265的博客
07-08 1093
控制反转（Inversion of Control, IoC）是一种设计原则，它将对象的创建和依赖管理的控制权从应用程序代码转移到容器中。在传统的编程模式中，对象通常由应用程序显式创建和管理，而在IoC中，容器负责创建和管理对象，这使得代码更加灵活和易于测试。依赖注入（Dependency Injection, DI）是一种实现控制反转的技术，通过将对象的依赖关系在外部进行配置并注入，而不是在对象内部自行创建依赖。这样可以降低对象之间的耦合度，提高代码的灵活性和可测试性。
Spring Boot中的依赖注入和控制反转
技术研究中心
07-06 818
通过自动配置、注解驱动和Java配置类，Spring Boot提供了一种优雅的方式来管理Spring应用中的Bean和依赖关系。理解和掌握Spring Boot中的依赖注入和控制反转，不仅可以提高代码的可维护性和可测试性，还能帮助开发者构建更灵活和可扩展的应用。通过依赖注入和控制反转，组件之间的依赖关系由容器管理，减少了代码的耦合性，使得代码更加模块化和可维护。通过Spring的配置文件和注解，可以很容易地添加或修改Bean的配置，增强了系统的可扩展性。通过构造函数注入，所有依赖在对象创建时就传递给对象。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值