Spring4系列之IOC和DI

最新推荐文章于 2024-07-23 10:48:19 发布
最新推荐文章于 2024-07-23 10:48:19 发布
阅读量242 收藏
点赞数
分类专栏： Spring Java 文章标签： spring java ioc bean
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42189489/article/details/105667938
版权

阅读目录

1 概述

1.1 IOC

IOC（Inversion of Control）其思想就是反转资源获取的方向，传统的资源查找方式要求组件向容器发送请求查找资源，作为回应，容器适时的返回资源，而应用了IOC之后，则是容器主动地将资源推送给它所管理的组件，组件所要做的仅是选择一种合适的方式来接受资源，这种行为也被称为查找的被动方式

1.2 DI

DI(Dependency Injection) --IOC另一种的表述方式：即组件以一些预先定义好的方式（例如setter方法）接受来自如容器的资源注入，相对于IOC而言，而这种表述更直接

2 配置Bean

  • 配置形式：基于 XML 文件的方式；基于注解的方式
  • Bean 的配置方式：通过全类名（反射）、通过工厂方法（静态工厂方法 & 实例工厂方法）、FactoryBean
  • IOC 容器 BeanFactory & ApplicationContext 概述
  • 依赖注入的方式：属性注入；构造器注入
2.1 在 xml 文件中通过 bean 节点来配置 bean

配置bean

id：Bean 的名称。

  • 在 IOC 容器中必须是唯一的
  • 若 id 没有指定，Spring 自动将权限定性类名作为 Bean 的名字
  • id 可以指定多个名字，名字之间可用逗号、分号、或空格分隔
2.2 Spring 容器
  • 在 Spring IOC 容器读取 Bean 配置创建 Bean 实例之前, 必须对它进行实例化. 只有在容器实例化后, 才可以从 IOC 容器里获取 Bean 实例并使用.
  • Spring 提供了两种类型的 IOC 容器实现.
    • Spring 提供了两种类型的 IOC 容器实现.
    • ApplicationContext: 提供了更多的高级特性. 是 BeanFactory 的子接口.
    • BeanFactory 是 Spring 框架的基础设施，面向 Spring 本身；ApplicationContext 面向使用 Spring 框架的开发者，几乎所有的应用场合都直接使用 ApplicationContext 而非底层的 BeanFactory
    • 无论使用何种方式, 配置文件时相同的.

ApplicationContext 代表IOC容器

2.3 ApplicationContext 概述

uml图

  • ApplicationContext 的主要实现类：
    • ClassPathXmlApplicationContext：从 类路径下加载配置文件
    • FileSystemXmlApplicationContext: 从文件系统中加载配置文件
  • ConfigurableApplicationContext 扩展于 ApplicationContext，新增加两个主要方法：refresh() 和 close()， 让 ApplicationContext 具有启动、刷新和关闭上下文的能力
  • ApplicationContext 在初始化上下文时就实例化所有单例的 Bean。
  • WebApplicationContext 是专门为 WEB 应用而准备的，它允许从相对于 WEB 根目录的路径中完成初始化工作

3 从 IOC 容器中获取 Bean

  • 调用 ApplicationContext 的 getBean() 方法
  HelloWorld helloWorld = (HelloWorld) ctx.getBean("helloWorld");
  //第二种 通过class类获取，前提是IOC容器中只能有一个该类型的bean
 HelloWorld helloWorld = ctx.getBean(helloWorld.class);

在这里插入图片描述

3.1 依赖注入的方式

Spring 支持 3 种依赖注入的方式

  • 属性注入
  • 属性注入即通过 setter 方法注入Bean 的属性值或依赖的对象
  • 属性注入使用 property标签 元素, 使用 name 属性指定 Bean 的属性名称，value 属性或 value标签 子节点指定属性值
  • 属性注入是实际应用中最常用的注入方式

在这里插入图片描述

  • 构造器注入
  • 通过构造方法注入Bean 的属性值或依赖的对象，它保证了 Bean 实例在实例化后就可以使用。
  • 构造器注入在< constructor-arg > 元素里声明属性, < constructor-arg > 中没有 name 属性
  • 按索引匹配入参：

按索引匹配入参

  • 按类型匹配入参：
    按类型匹配入参
  • 工厂方法注入（很少使用，不推荐）

4 属性配置的细节

4.1 字面值
  • 字面值：可用字符串表示的值，可以通过 元素标签或 value 属性进行注入。
  • 基本数据类型及其封装类、String 等类型都可以采取字面值注入的方式
  • 若字面值中包含特殊字符，可以使用 <![CDATA[]]> 把字面值包裹起来。

car的源代码

public class Car {

	private String company;
	private String brand;

	private int maxSpeed;
	private float price;

	public Car(String company, String brand, float price) {
		super();
		this.company = company;
		this.brand = brand;
		this.price = price;
	}

	public Car(String company, String brand, int maxSpeed) {
		super();
		this.company = company;
		this.brand = brand;
		this.maxSpeed = maxSpeed;
	}

	public Car(String company, String brand, int maxSpeed, float price) {
		super();
		this.company = company;
		this.brand = brand;
		this.maxSpeed = maxSpeed;
		this.price = price;
	}

	@Override
	public String toString() {
		return "Car [company=" + company + ", brand=" + brand + ", maxSpeed="
				+ maxSpeed + ", price=" + price + "]";
	}
}

<bean id="car2" class="com.zs.spring.beans.Car">
        <constructor-arg value="ChangAnMazda"></constructor-arg>
        <!-- 若字面值中包含特殊字符, 则可以使用 DCDATA 来进行赋值. (了解) -->
        <constructor-arg>
            <value><![CDATA[<ATARZA>]]></value>
        </constructor-arg>
        <constructor-arg value="180" type="int"></constructor-arg>
    </bean>
4.2 引用其它 Bean
  • 组成应用程序的 Bean 经常需要相互协作以完成应用程序的功能. 要使 Bean 能够相互访问, 就必须在 Bean 配置文件中指定对 Bean 的引用
  • 在 Bean 的配置文件中, 可以通过 <ref> 元素或 ref 属性为 Bean 的属性或构造器参数指定对 Bean 的引用. 这样的 Bean 称为外部 Bean****
	<bean id="car2" class="com.zs.spring.beans.Car">
   		<!-- 省略 -->
    </bean>
	<bean id="person" class="con.zs.spring.beans.Person">
		<property name="name" value="Tom"></property>
		<property name="age" value="24"></property>
		<!-- 可以使用property的ref属性建立bean之间的引用关系 -->
		<!-- <property name="car" ref="car2"></property> -->
		<property name="car">
			<ref bean="car2"/>
		</property>
    </bean>

运用构造器进行注入

	<bean id="car2" class="com.zs.spring.beans.Car">
   		<!-- 省略 -->
    </bean>
	<bean id="person" class="con.zs.spring.beans.Person">
		<constructor-arg  value="Tom"></constructor-arg>
		<constructor-arg  value="24"></constructor-arg>
		<!-- 可以使用property的ref属性建立bean之间的引用关系 -->
	    <constructor-arg  ref="car2"></constructor-arg>
    </bean>
  • 也可以在属性或构造器里包含 Bean 的声明, 这样的 Bean 称为内部 Bean
    • 当 Bean 实例仅仅给一个特定的属性使用时, 可以将其声明为内部 Bean. 内部 Bean 声明直接包含在 或 元素里, 不需要设置任何 id 或 name 属性
    • 内部 Bean 不能使用在任何其他地方
	<bean id="car2" class="com.zs.spring.beans.Car">
   		<!-- 省略 -->
    </bean>
	<bean id="person" class="com.zs.spring.beans.Person">
		<property name="name" value="Tom"></property>
		<property name="age" value="24"></property>
		<!--  内部bean的引用 -->
	  	<property name="car">
			<bean class="com.zs.spring.beans.Car">
				<constructor-arg value="Ford"></constructor-arg>
				<constructor-arg value="Changan"></constructor-arg>
				<constructor-arg value="200000" type="double"></constructor-arg>
			</bean>
	  	</property>
    </bean>

或者

	<bean id="car2" class="com.zs.spring.beans.Car">
   		<!-- 省略 -->
    </bean>
	<bean id="person" class="com.zs.spring.beans.Person">
		<constructor-arg  value="Tom"></constructor-arg>
		<constructor-arg  value="24"></constructor-arg>
		<!--  内部bean的引用 -->
	  	<constructor-arg>
			<bean class="com.zs.spring.beans.Car">
				<constructor-arg value="Ford"></constructor-arg>
				<constructor-arg value="Changan"></constructor-arg>
				<constructor-arg value="200000" type="double"></constructor-arg>
			</bean>
	  	</constructor-arg>
    </bean>
4.3 注入参数详解：null 值和级联属性
  • 可以使用专用的<null/> 元素标签为 Bean 的字符串或其它对象类型的属性注入 null 值
	<bean id="person" class="con.zs.spring.beans.Person">
		<constructor-arg  value="Tom"></constructor-arg>
		<constructor-arg  value="24"></constructor-arg>
		<!-- 测试null -->
	    <constructor-arg ><null/></constructor-arg>
    </bean>
  • 和 Struts、Hibernate 等框架一样，Spring 支持级联属性的配置。
	<bean id="car2" class="com.zs.spring.beans.Car">
   		<!-- 省略 -->
    </bean>
	<bean id="person" class="con.zs.spring.beans.Person">
		<constructor-arg  value="Tom"></constructor-arg>
		<constructor-arg  value="24"></constructor-arg>	 
	    <constructor-arg ref="car"> </constructor-arg>
	    <!-- 为级联属性赋值 ，注意：属性需要先初始化后才可以为级联属性赋值，否则会有异常，和struts2不同-->
	    <property name="car.maxSpeed" value="300000"></property>
    </bean>
4.4 集合属性
  • 在 Spring中可以通过一组内置的 xml 标签(例如: <list>, <set> 或 <map>) 来配置集合属性.
  • 配置 java.util.List 类型的属性, 需要指定 <list> 标签, 在标签里包含一些元素. 这些标签可以通过 <value> - 指定简单的常量值, 通过 <ref> 指定对其他 Bean 的引用. 通过<bean> 指定内置 Bean 定义. 通过 <null/> 指定空元素. 甚至可以内嵌其他集合.
  • 数组的定义和 List 一样, 都使用 <list>
  • 配置 java.util.Set 需要使用 <set> 标签, 定义元素的方法与 List 一样.
  • Java.util.Map 通过 <map> 标签定义, <map> 标签里可以使用多个 <entry> 作为子标签. 每个条目包含一个键和一个值.
  • 必须在 <key> 标签里定义键
  • 因为键和值的类型没有限制, 所以可以自由地为它们指定 <value>, <ref>, <bean> 或 <null> 元素.
  • 可以将 Map 的键和值作为 <entry> 的属性定义: 简单常量使用 key 和 value 来定义; Bean 引用通过 key-ref 和 value-ref 属性定义
  • 使用 <props> 定义 java.util.Properties, 该标签使用多个 <prop> 作为子标签. 每个 <prop> 标签必须定义 key 属性.
//新建的person类
package com.zs.spring.beans.collections;
public class Person{
private String name;
private Integer age;
private List<Car> cars;
//getter  AND setter省略
}

List集合

	<bean id="car1" class="com.zs.spring.beans.Car">
   		<!-- 省略 -->
    </bean>
    <bean id="car2" class="com.zs.spring.beans.Car">
   		<!-- 省略 -->
    </bean>
<!-- 测试如何配置集合属性 -->
<bean id="person3" class="com.zs.spring.beans.Person">
	<property name="name" value="mike"></property>
	<property name="age" value="27"></property>
	<property name="cars">
	<!-- 使用list标签为list集合赋值 -->
		<list>
			<ref bean="car1"/>
			<ref bean="car2"/>
		</list>
	</property>
</bean>

Map集合
新建NewPerson类

package com.zs.spring.beans.collections;
public class NewPerson{
private String name;
private int age;
private Map<String,Car> cars;
//getter  AND setter省略
}

<bean id="car1" class="com.zs.spring.beans.Car">
   		<!-- 省略 -->
</bean>
<bean id="car2" class="com.zs.spring.beans.Car">
   		<!-- 省略 -->
</bean>
<!-- 配置Map属性值 -->
<bean id="newPerson" class="com.zs.spring.beans.collections.NewPerson">
	<property name="name" value="Rose"></property>
	<property name="age" value="28"></property>
	<property name="cars">
	<!-- 使用map节点以及map的entry子节点配置Map类型的成员变量 -->
		<map>
			<entry key="AA" value-ref="car1"/>
			<entry key="BB" value-ref="car2"/>
		</map>
	</property>
</bean>

<prop>标签的使用
新建DataSoure类

package com.zs.spring.beans.collections;
import java.util.Properties;
public class DataSource
{
	private Properties properties;
	//getter  AND setter省略
}

<!-- 配置Properties属性值 -->
<bean id="dataSource" class="com.zs.spring.beans.collections.DataSource">
	<property name="properties">
	<!-- 使用props和prop子节点来为Properties属性赋值 -->
		<props>
			<prop key="user">root</prop>
			<prop key="password">123</prop>
			<prop key="jdbcUrl">jdbc:mysql:///test</prop>
			<prop key="driverClass">com.mysql.jdbc.Driver</prop>
		</props>
	</property>	
</bean>
4.5 使用 utility scheme 定义集合
  • 使用基本的集合标签定义集合时, 不能将集合作为独立的 Bean 定义, 导致其他 Bean 无法引用该集合, 所以无法在不同 Bean 之间共享集合.
  • 可以使用 util schema 里的集合标签定义独立的集合 Bean. 需要注意的是, 必须在 <beans> 根元素里添加 util schema 定义
    配置独立的集合bean，以供多个bean进行使用，需要引入Spring命名空间 util -http://www.springframework.org/schema/util
<util.list id="cars">
	<ref bean="car1"/>
	<ref bean="car2"/>
</util.list>
<bean id="person" class="com.zs.spring.beans.collections.Person">
	<property name="name" value="jack"></property>
	<property name="age" value="29"></property>
	<property name="cars" ref="cars"></property>
</bean>
4.6 使用 p 命名空间
  • 为了简化 XML 文件的配置，越来越多的 XML 文件采用属性而非子元素配置信息。
  • Spring 从 2.5 版本开始引入了一个新的 p 命名空间，可以通过 <bean> 元素属性的方式配置 Bean 的属性。
  • 使用 p 命名空间后，基于 XML 的配置方式将进一步简化
<util.list id="cars">
	<ref bean="car1"/>
	<ref bean="car2"/>
</util.list>
<!-- 通过P命名空间为bean的属性赋值，需要先导入p命名空间 -->
<bean id="person" class="com.zs.spring.beans.collections.Person"
 p:age="30" 
 p:name="Qess" 
 p:cars-ref="cars">
</bean>

5 自动装配

5.1 XML 配置里的 Bean 自动装配
  • Spring IOC 容器可以自动装配 Bean. 需要做的仅仅是在 <bean> 的 autowire 属性里指定自动装配的模式
  • byType(根据类型自动装配): 若 IOC 容器中有多个与目标 Bean 类型一致的 Bean. 在这种情况下, Spring 将无法判定哪个 Bean 最合适该属性, 所以不能执行自动装配.
  • byName(根据名称自动装配): 必须将目标 Bean 的名称和属性名设置的完全相同.
  • constructor(通过构造器自动装配): 当 Bean 中存在多个构造器时, 此种自动装配方式将会很复杂. 不推荐使用

示例：再新建Person类放在com.zs.spring.beans.autowire包中


public class Person
{
	private String name;
	private Address address; 
	private Car car;
	//getter  AND setter省略
	
}

	<bean id="address" class="com.zs.spring.beans.autowire.Address" 
		p:city="beijing" 
		p:street="huiLongguan">
	</bean>
	<bean id="car" class="com.zs.spring.beans.autowire.Car"
		p:brand="audi" 
		p:price="300000">
	</bean>
		<!-- 可以使用autowire属性指定自动装配的方式，
		byName根据bean的名字和当前bean
		的setter风格的属性名进行自动装配，若有匹配的，则进行自动装配，若没有匹配的，
		则不装配 
		byType根据bean的类型和当前bean的属性的类型进行自动装配
		-->
	<bean id="person" class="com.zs.spring.beans.autowire.Person"
		p:name="Tom" 
		autowire="byName"
	 >
	</bean>
5.2 XML 配置里的 Bean 自动装配的缺点
  • 在 Bean 配置文件里设置 autowire 属性进行自动装配将会装配 Bean 的所有属性. 然而, 若只希望装配个别属性时, autowire 属性就不够灵活了.
  • autowire 属性要么根据类型自动装配, 要么根据名称自动装配, 不能两者兼而有之.
  • 一般情况下，在实际的项目中很少使用自动装配功能，因为和自动装配功能所带来的好处比起来，明确清晰的配置文档更有说服力一些

6 Bean之间的关系

6.1 Bean之间的继承关系
  • Spring 允许继承 bean 的配置, 被继承的 bean 称为父 bean. 继承这个父 Bean 的 Bean 称为子 Bean
  • 子 Bean 从父 Bean 中继承配置, 包括 Bean 的属性配置
  • 子 Bean 也可以覆盖从父 Bean 继承过来的配置
  • 父 Bean 可以作为配置模板, 也可以作为 Bean 实例. 若只想把父 Bean 作为模板, 可以设置 的abstract 属性为 true, 这样 Spring 将不会实例化这个 Bean
  • 并不是 元素里的所有属性都会被继承. 比如: autowire, abstract 等.
  • 也可以忽略父 Bean 的 class 属性, 让子 Bean 指定自己的类, 而共享相同的属性配置. 但此时 abstract 必须设为 true
<!-- 抽象bean：bean的abstract属性为true的bean
。这样的bean不能被IOC容器实例化，只能用来被继承配置，若一个bean的class属性没指定，则该bean必须是一个抽象bean -->
<bean id="address" 
p:city="Beijing" p:street="Wudaokou"></bean>
<!-- bean配置的继承：使用bean的parent属性指定继承哪个bean的配置 -->
<bean id="address2" class="com.zs.spring.beans.autowire.Address" p:street="Dazhongsi" parent="address"></bean>

获取资源后的两个对象值输出为：

address：[city="Beijing",street="Wudaokou"]

address2：[city="Beijing",street="Dazhongsi"]
6.2 Bean之间的依赖关系
  • Spring 允许用户通过 depends-on 属性设定 Bean 前置依赖的Bean，前置依赖的 Bean 会在本 Bean 实例化之前创建好
  • 如果前置依赖于多个 Bean，则可以通过逗号，空格或的方式配置 Bean 的名称
<bean id="address" 
p:city="Beijing" p:street="Wudaokou"></bean>
<!-- bean配置的继承：使用bean的parent属性指定继承哪个bean的配置 -->
<bean id="address2" class="com.zs.spring.beans.autowire.Address" p:street="Dazhongsi" parent="address"></bean>
<bean id="car" class="com.zs.spring.beans.autowire.Car" p:brand="Audi" p:price="30000"></bean>
<!-- 要求在配置Person时，必须有一个关联的car！换句话说person这个bean依赖于Car这个bean -->
<bean id="person" class="com.zs.spring.beans.autowire,Person"
p:name="Tom" p:address-ref="address2" depends-on="car"
></bean>

7 Bean的作用域

  • 在 Spring 中, 可以在 元素的 scope 属性里设置 Bean 的作用域.
  • 默认情况下, Spring 只为每个在 IOC 容器里声明的 Bean 创建唯一一个实例, 整个 IOC 容器范围内都能共享该实例：所有后续的 getBean() 调用和 Bean 引用都将返回这个唯一的 Bean 实例.该作用域被称为 singleton, 它是所有 Bean 的默认作用域.
  • spring作用域
<!-- 使用bean的scope属性来配置bean的作用域
	singleton:默认值。容器初始化时创建Bean实例，在整个容易的生命周期内只创建这一个
	prototype:原型的。容器初始化时不创建bean的实例，而在每次请求时都创建一个新的Bean实例，并返回
 -->
<bean id="car" class="com.zs.spring.beans.autowire.Car" scope="">
	<property name="brand" value="Audi"></property>
	<property name="price" value="30000"></property>
</bean>

ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-scope.xml");
Car car = (Car)ctx.getBean("car");
Car car2 = (Car)ctx.getBean("car");
System.out.prinrln(car==car2);
//结果为true ，说明car和car2是同一个对象 ，也就是说bean的默认作用域是单例的
//scope="prototype" 原型的，每次向容器获取bean时都会获取一个新的对象System.out.prinrln(car==car2); 结果为：false

8 使用外部属性文件

  • 在配置文件里配置 Bean 时, 有时需要在 Bean 的配置里混入系统部署的细节信息(例如: 文件路径, 数据源配置信息等). 而这些部署细节实际上需要和 Bean 配置相分离
  • Spring 提供了一个 PropertyPlaceholderConfigurer 的 BeanFactory 后置处理器, 这个处理器允许用户将 Bean 配置的部分内容外移到属性文件中. 可以在 Bean 配置文件里使用形式为 ${var} 的变量, PropertyPlaceholderConfigurer 从属性文件里加载属性, 并使用这些属性来替换变量.
  • Spring 还允许在属性文件中使用 ${propName}，以实现属性之间的相互引用。

创建 db.properties 属性文件

user = root
paassword = 1230
driverclass=com.mysql.jdbc.Driver
jdbcurl=jdbc:mysql:///test

创建 beans-properties.xml 进行测试

<!--
 <beans> 中添加 context Schema 定义
在配置文件中加入如下配置:  
-->
<context:property-placegolder location="classpath:db.properties"/>
<bean id="dataSource" class="com.mchange.v2.c3p0,ComboPooledDataSource">
	<!-- 使用外部化属性文件的属性 -->
	<property name="user" value="${user}"/>
	<property name="password" value="${password}"/>
	<property name="driverClass" value="%{driverclass}"/>
	<property name="jdbcUrl" value="${jdbcurl}"/>
</bean>

9 Spring表达式语言：SpEL

  • Spring 表达式语言（简称SpEL）：是一个支持运行时查询和操作对象图的强大的表达式语言。
  • 语法类似于 EL：SpEL 使用 #{…} 作为定界符，所有在大框号中的字符都将被认为是 SpEL
  • SpEL 为 bean 的属性进行动态赋值提供了便利
  • 通过 SpEL 可以实现：
    • 通过 bean 的 id 对 bean 进行引用
    • 调用方法以及引用对象中的属性
    • 计算表达式的值
    • 正则表达式的匹配
9.1 SpEL:字面量
  • 字面量的表示：
    • 整数：<property name=“count” value="#{5}"/>
    • 小数：<property name=“frequency” value="#{89.7}"/>
    • 科学计数法：<property name=“capacity” value="#{1e4}"/>
    • String可以使用单引号或者双引号作为字符串的定界符号：<property name=“name” value="#{‘Chuck’}"/> 或 <property name=‘name’ value=’#{“Chuck”}’/>
    • Boolean：<property name=“enabled” value="#{false}"/>
9.2 SpEL：引用 Bean、属性和方法（1）

  • 引用其他对象：
    在这里插入图片描述

  • 引用其他对象的属性
    在这里插入图片描述

  • 调用其他方法，还可以链式操作
    在这里插入图片描述
    在这里插入图片描述

  • 调用静态方法或静态属性：通过 T() 调用一个类的静态方法，它将返回一个 Class Object，然后再调用相应的方法或属性：
    在这里插入图片描述

Car类

public class Car {
 private String brand;
 private double price;
//轮胎的周长
private double tyrePerimeter;

//....getter/setter方法忽略
}

Person类

public class Person{
 private String name;
 private Car car;
 //引用address bean的city属性
 private String city;
 //根据car的price群顶info：car的price>=300000：金领，否则为：白领
 private String info; 
//....getter/setter方法忽略
}

新建beans-spel.xml

<bean id="address" class="com.zs.spring.beans.spel.Address">
	<property name="city" value="#{'beijing'}"/>
	<property name="street" value="WuDaoKou"/>
	<!--使用spel引用类的静态属性-->
	<property name="tyrePerimeter" value="#{T(java.Lang.Math).PI*80}"/>
</bean>

<bean id="person" class="com.zs.spring.beans.spel.Person">
	<!-- 使用Spel来应用其他的bean -->
	<property name="car" value="#{car}"/>
	<!--- 使用Spel来应用其他bean的属性 ->
	<property name="city" value="#{address.city}"/>
	<!-- 在Spel中使用运算符 -->
	<property name="info" value="#{car.price>300000?'金领':'白领'}"/>
	<property name="name" value="Tom"/>
</bean>

显示结果：
在这里插入图片描述

9.3 SpEL支持的运算符号（1）
  • *算数运算符：+, -, , /, %, ^：
    算术运算符
  • 加号还可以用作字符串连接：
    在这里插入图片描述
  • 比较运算符： <, >, ==, <=, >=, lt, gt, eq, le, ge
    在这里插入图片描述
    在这里插入图片描述
  • 逻辑运算符号： and, or, not, |
    在这里插入图片描述
  • if-else 运算符：?: (ternary), ?: (Elvis)
    在这里插入图片描述
  • if-else 的变体
    在这里插入图片描述
  • 正则表达式：matches
    在这里插入图片描述

10 IOC 容器中 Bean 的生命周期

  • Spring IOC 容器可以管理 Bean 的生命周期, Spring 允许在 Bean 生命周期的特定点执行定制的任务.
  • Spring IOC 容器对 Bean 的生命周期进行管理的过程:
    • 通过构造器或工厂方法创建 Bean 实例
    • 为 Bean 的属性设置值和对其他 Bean 的引用
    • 调用 Bean 的初始化方法
    • Bean 可以使用了
    • 当容器关闭时, 调用 Bean 的销毁方法
  • 在 Bean 的声明里设置 init-method 和 destroy-method 属性, 为 Bean 指定初始化和销毁方法

创建com.zs.spring.beans.cycle包
Car类

public class Car{
	public Car()
	{
		System.out.println("Car`s Constructor...");
	}
	private String brand;
	public void setBrand(String brand)
	{
		System.out.println("setBrand...");
		this.brand = brand;
	}
	public void init()
	{
		System.out.println("init...");
	}
	public void destory()
	{
		System.out.println("destory...");
	}
}

创建 beans-cycl.xml配置文件

<bean id="car" class="com.zs.spring.beans.cycle.Car" init-method="init"
destory-method="destory">
<property name="brand" value="Audi"/>
</bean>

测试：

ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans-cycl.xml");
Car car = ctx.getBean(Car.class);
System.out.println(car);
//关闭IOC容器
ctx.close();

在这里插入图片描述

10.1 创建Bean后置处理器
  • Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理.
  • Bean 后置处理器对 IOC 容器里的所有 Bean 实例逐一处理, 而非单一实例. 其典型应用是: 检查 Bean 属性的正确性或根据特定的标准更改 Bean 的属性.
  • 对Bean 后置处理器而言, 需要实现接口. 在初始化方法被调用前后, Spring 将把每个 Bean 实例分别传递给上述接口的以下两个方法:
    在这里插入图片描述

新建MyBeanPostProcessor类

public class MyBeanPostProcessor implements BeanPostProcessor{

public Object postProcessBeforeInitialization(Object bean,String beanName) throws BeansException{
System.out.println("postProcessBeforeInitialization:"+beanName+","+beanName);
return bean;
	}
}

public Object postProcessAfterInitialization(Object bean,String beanName) throws BeansException{
System.out.println("postProcessAfterInitialization:"+bean+","+beanName);
return bean;
	}
}

在beans-cycl.xml添加配置

<!-- 实现BeanPostProcessot接口，并具体提供
Object postProcessBeforeInitialization(Object bean,String beanName):init-method之前被调用
Object postProcessAfterInitialization(Object bean,String beanName)：init-method之后被调用
的实现方法
bean是实例本身
beanName：IOC容器配置的bean的名字
返回值：是实际上返回给用户的那个bean，注意：可以在以上两个方法中修改返回的bean，甚至返回一个新的bean
 -->
<!-- 配置bean的后置处理器：不需要ID，IOC容器自动识别是一个BeanPostProcessor -->
<bean class="com.zs.spring.beans.cycle.MyBeanPostProcessor"/>

再次执行测试：
在这里插入图片描述

添加 Bean 后置处理器后 Bean 的生命周期

  • Spring IOC 容器对 Bean 的生命周期进行管理的过程:
    • 通过构造器或工厂方法创建 Bean 实例
    • 为 Bean 的属性设置值和对其他 Bean 的引用
    • 将 Bean 实例传递给 Bean 后置处理器的 postProcessBeforeInitialization 方法
    • 调用 Bean 的初始化方法
    • 将 Bean 实例传递给 Bean 后置处理器的 postProcessAfterInitialization方法
    • Bean 可以使用了
    • 当容器关闭时, 调用 Bean 的销毁方法
10.2 通过调用静态工厂方法创建 Bean
  • 调用静态工厂方法创建 Bean是将对象创建的过程封装到静态方法中. 当客户端需要对象时, 只需要简单地调用静态方法, 而不同关心创建对象的细节.
  • 要声明通过静态方法创建的 Bean, 需要在 Bean 的 class 属性里指定拥有该工厂的方法的类, 同时在 factory-method 属性里指定工厂方法的名称. 最后, 使用 <constrctor-arg> 元素为该方法传递方法参数.

创建com.zs.spring.beans.factory 包，

Car类

public class Car{
	private String brand;
	private double price;
	//...getter setter省略
}

创建一个静态工厂方法

/**
* 静态工厂方法：直接调用某一个类的静态方法就可以返回Bean的实例
*/
public class StaticCarFactory{
	
	private static Map<String,Car> cars = new HashMap<String,Car>();

	static{
		cars.put("Audi",new Car("audi",30000));
		cars.put("ford",new Car("ford",40000));
	}
	 
	public static Car getCar(String name)
	{
		return cars.get(name);
	}
}

创建beans-factory.xml配置文件

<!-- 通过静态方法来配置bean，注意不是配置静态工厂方法实例，而是配置bean实例 -->
<!-- 
	class属性：只想静态工厂方法的全类名
	factory-method:指向静态工厂方法的名字
	constructor-arg:如果工厂方法需要传入参数，则使用constructor-arg来配置参数
 -->
<bean id="car1" class="com.zs.spring.beans.factory.StaticCarFactory" factory-method="getCar">
<constructor-arg value="audi"></constructor-arg>
</bean>

测试

public void test(){
	ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-factory.xml");
	Car car1 = (Car)ctx.getBean("car1");
	System.out.println(car1);
}

在这里插入图片描述

10.3 通过调用实例工厂方法创建 Bean
  • 实例工厂方法: 将对象的创建过程封装到另外一个对象实例的方法里. 当客户端需要请求对象时, 只需要简单的调用该实例方法而不需要关心对象的创建细节.
  • 要声明通过实例工厂方法创建的 Bean
    • 在 bean 的 factory-bean 属性里指定拥有该工厂方法的 Bean
    • 在 factory-method 属性里指定该工厂方法的名称
    • 使用 construtor-arg 元素为工厂方法传递方法参数

创建实例工厂方法Factory

/**
* 实例工厂方法：实力工厂的方法，即现需要创建工厂本身，再调用工厂的实例方法来返回bean的实例
*/
public void InstanceCarFactory{
	private Map<String,Car> cars = null;

	public InstanceCarFactory(){
		cars.put("Audi",new Car("audi",30000));
		cars.put("ford",new Car("ford",40000));
	}

	public Car getCar(String brand){
		return cars.get(brand);
	}
}

beans-factory.xml

<!-- 通过实例工厂方法来配置bean -->
<!-- 
	factory-bean属性：指向实例工厂方法的bean
	factory-method:指向静态工厂方法的名字
	constructor-arg:如果工厂方法需要传入参数，则使用constructor-arg来配置参数
 -->
<!-- 配置工厂的实例 -->
<bean id="carFactory" class="com.zs.spring.beans.factory.InstanceCarFactory"></bean>
<!-- 通过实例工厂方法来配置bean -->
<bean id="car2" factory-bean="carFactory" factory-method="getCar">
	<constructor-arg value="ford"></constructor-arg>
</bean>

测试

public void test(){
	ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-factory.xml");
	Car car2 = (Car)ctx.getBean("car2");
	System.out.println(car2);
}

在这里插入图片描述

10.4 实现 FactoryBean 接口在 Spring IOC 容器中配置 Bean
  • Spring 中有两种类型的 Bean, 一种是普通Bean, 另一种是工厂Bean, 即FactoryBean.
  • 工厂 Bean 跟普通Bean不同, 其返回的对象不是指定类的一个实例, 其返回的是该工厂 Bean 的 getObject 方法所返回的对象
    在这里插入图片描述

创建com.zs.spring.beans.factorybean包

创建创建CarFactoryBean类

//自定义的FactoryBean需要实现Spring提供的FactoryBean接口
public class CarFactoryBean implements FactoryBean<Car>
{
	private String brand;
	public void setBrand(String brand)
	{
		this.brand = brand;
	}
	//返回Bean的对象
	@Override
	public Car getObject() throws Exception{
		return new Car(brand,500000);
	}
	//返回bean的类型
	@Override
	public Class<?> getObjectType(){
		return Car.class;
	}
	//是否是单例的
	@Override
	public boolean isSingleton(){
		return true;
	}
}

创建配置文件beans-beanfactory.xml

<!-- 
	通过FactoryBean来配置Bean的实例
	clas：指向FactoryBean的全类名
	property：配置FactoryBean的属性
	但实际返回的额实例却是FactoryBean的getObject()方法返回的实例
 -->
<bean id="car" class="com.zs.spring.beans.factorybean.CarFactoryBean">
	<property name="brand" value="BMW"></property>
</bean>

测试

public void test(){
	ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.beanfactory.xml");
	Car car= (Car)ctx.getBean("car");
	System.out.println(car);
}

在这里插入图片描述

10.4 在 classpath 中扫描组件
  • 组件扫描(component scanning): Spring 能够从 classpath 下自动扫描, 侦测和实例化具有特定注解的组件.
  • 特定组件包括:
    • @Component: 基本注解, 标识了一个受 Spring 管理的组件
    • @Respository: 标识持久层组件
    • @Service: 标识服务层(业务层)组件
    • @Controller: 标识表现层组件
  • 对于扫描到的组件, Spring 有默认的命名策略: 使用非限定类名, 第一个字母小写. 也可以在注解中通过 value 属性值标识组件的名称
  • 当在组件类上使用了特定的注解之后, 还需要在 Spring 的配置文件中声明 <context:component-scan> ：
    • base-package 属性指定一个需要扫描的基类包，Spring 容器将会扫描这个基类包里及其子包中的所有类.
    • 当需要扫描多个包时, 可以使用逗号分隔.
    • 如果仅希望扫描特定的类而非基包下的所有类，可使用 resource-pattern 属性过滤特定的类，示例：
      示意图
    • <context:include-filter> 子节点表示要包含的目标类
    • <context:exclude-filter> 子节点表示要排除在外的目标类
    • <context:component-scan> 下可以拥有若干个 <context:include-filter> 和 <context:exclude-filter> 子节点
  • <context:include-filter> 和 <context:exclude-filter> 子节点支持多种类型的过滤表达式：
    在这里插入图片描述
    代码演示：
    新建 com.zs.spring.beans.annotation 包 ，下面创建
    TestObject 类
@Component
public class TetsObject{

}

新建 com.zs.spring.beans.annotation.repository 包 ，下面创建
UserRepository 接口类

public interface UserRepository{
	void save();
}

UserRepositoryImpl接口实现类

@Repository
public class UserRepositoryImpl implements UserRepository{
	@Override
	public void save(){
		System.out.println("UserRepository Save....");
	}	
}

新建 com.zs.spring.beans.annotation.service 包 ，下面创建
UserService 类

@Service
public class UserService{
	public void add(){
		System.out.println("UserService add...");
	}
}

新建 com.zs.spring.beans.annotation.controller 包 ，下面创建
UserController 类

@Controller
public class UserController{
	public void execute(){
		System.out.println("UserController execute...");
	}
}

创建beans-annotation.xml配置文件

<!-- 指定spring ioc容器扫描的包 -->
<!-- 可以通过reource-pattern指定扫描的资源 -->
<context:component-scan base-package="com.zs.spring.beans.annotation"
resource-pattern="repository/*.class"
>
</context:component-scan>
<!-- exclude-filter 子节点指定排除哪些指定表达式的组件 -->
<!-- include-filter 子节点指定包含哪些表达式的组件，该子节点需要use-defult-filters使用 -->
<context:component-scan base-package="com.zs.spring.beans.annotation" use-default-filters="false">
		<!-- 
		<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository">
		<context:include-filter type="annotation" expression="org.springframework.stereotype.Repository">
		 -->
		 <!-- 只排除com.zs.spring.beans.annotation.repository.UserRepository
		<context:exclude-filter type="assignable" expression="com.zs.spring.beans.annotation.repository.UserRepository"/>
		 -->
		  <!-- 只包含com.zs.spring.beans.annotation.repository.UserRepository
		<context:include-filter type="assignable" expression="com.zs.spring.beans.annotation.repository.UserRepository"/>
		 -->
</context:component-scan>
10.5 组件装配
  • <context:component-scan> 元素还会自动注册 AutowiredAnnotationBeanPostProcessor 实例, 该实例可以自动装配具有 @Autowired 和 @Resource 、@Inject注解的属性.

使用 @Autowired 自动装配 Bean

  • @Autowired 注解自动装配具有兼容类型的单个 Bean属性
    • 构造器, 普通字段(即使是非 public), 一切具有参数的方法都可以应用@Authwired 注解
    • 默认情况下, 所有使用 @Authwired 注解的属性都需要被设置. 当 Spring 找不到匹配的 Bean 装配属性时, 会抛出异常, 若某一属性允许不被设置, 可以设置 @Authwired 注解的 required 属性为 false
    • 默认情况下, 当 IOC 容器里存在多个类型兼容的 Bean 时, 通过类型的自动装配将无法工作. 此时可以在 @Qualifier 注解里提供 Bean 的名称. Spring 允许对方法的入参标注 @Qualifiter 已指定注入 Bean 的名称
    • @Authwired 注解也可以应用在数组类型的属性上, 此时 Spring 将会把所有匹配的 Bean 进行自动装配.
    • @Authwired 注解也可以应用在集合属性上, 此时 Spring 读取该集合的类型信息, 然后自动装配所有与之兼容的 Bean.
    • @Authwired 注解用在 java.util.Map 上时, 若该 Map 的键值为 String, 那么 Spring 将自动装配与之 Map 值类型兼容的 Bean, 此时 Bean 的名称作为键值

使用 @Resource 或 @Inject 自动装配 Bean

  • Spring 还支持 @Resource 和 @Inject 注解，这两个注解和 @Autowired 注解的功用类似
  • @Resource 注解要求提供一个 Bean 名称的属性，若该属性为空，则自动采用标注处的变量或方法名作为 Bean 的名称
  • @Inject 和 @Autowired 注解一样也是按类型匹配注入的 Bean， 但没有 reqired 属性
  • 建议使用 @Autowired 注解

11. Spring 4.x 新特性：泛型依赖注入

  • Spring 4.x 中可以为子类注入子类对应的泛型类型的成员变量的引用
    在这里插入图片描述
11.1 创建 com.zs.spring.beans.generic.di 包
11.2 创建 BaseRepository 类
public class BaseRepository<T>{
}
11.3 创建BaseService 类
public class BaseService<T>{

	@Autowired 
	protected BaseRepository<T> repository;

	public void add(){
		System.out.println("add...");
		System.out.println(repository);
	}
}
11.4 创建子类 UserService
@Service
public class UserService extends BaseService<User>{
}

public class User{

}
11.5 创建子类 UserRepository 类
@Repository
public class UserRepository extends BaseRepository<User>{

}
11.6 创建配置文件 beans-generic.xml
<context:component-scan base-package="com.zs.spring.beans.generic.di"/>

测试：

public void test(){

	ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-generic.xml");
	
	UserService userService =(UserService) ctx.getBean("userService");

	userService.add();

}

结果：
在这里插入图片描述

整合多个配置文件：

  • Spring 允许通过 将多个配置文件引入到一个文件中，进行配置文件的集成。这样在启动 Spring 容器时，仅需要指定这个合并好的配置文件就可以。
  • import 元素的 resource 属性支持 Spring 的标准的路径资源
    在这里插入图片描述
帅气的小哥哥z
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
请简述什么是spring的ioc和di_理解Spring中的IoC和DI
weixin_42497593的博客
12-28 3044
什么是IoC和DIIoC(Inversion of Control 控制反转)：是一种面向对象编程中的一种设计原则，用来减低计算机代码之间的耦合度。其基本思想是：借助于“第三方”实现具有依赖关系的对象之间的解耦。DI(Dependence Injection 依赖注入)：将实例变量传入到一个对象中去(Dependency injection means giving an object its i...
请简述什么是spring的ioc和di_Spring中的IoC与DI的理解
weixin_30099989的博客
12-28 1736
1.IoC是什么？IoC(Inversion of Control)控制反转，IoC是一种新的Java编程模式，目前很多轻量级容器都在广泛使用的模式。2.IoC解决了什么问题？在IoC出现以前，组件之间的协调关系是由程序内部代码来控制的，或者说，以前我们使用New关键字来实现两组间之间的依赖关系的。这种方式就造成了组件之间的互相耦合。IoC(控制反转)就是来解决这个问题的，它将实现组件间的关系从程...
Spring详解—— IOC 和 DI 区别
说故事的五公子
06-25 1567
我们只要提到Spring这个词，有简单了解过Spring的人基本上都会脱口而出IoC、DI和AOP这几个概念。但是对于初学者来说，一下子搞懂IoC和DI的概念还是挺麻烦的。比如之前我自己刚刚学习Spring的时候，只知道IoC能够帮我们创建对象，不再需要我们自己去创建了，并且那时IoC和DI傻傻分不清，对AOP的概念就更加不用说了。所以这次一定要好好理解。IoC（Inversion of Control）的意思是“控制反转”，它是Spring最核心的点，并且贯穿始终。IoC并不是一门技术，而是一种设计思想。
Spring——IoC和DI
浪漫不死的博客
03-02 3133
目录一、初识Spring为什么要使用Spring什么是SpringSpring框架的核心由哪些模块组成二、Core Container（核心容器）IoC（控制反转）什么是 IoCIoC 的作用IoC 的优点IoC 的缺点DI（依赖注入）什么是DI依赖注入的基本原则依赖注入的优势不同类型的依赖注入实现方式构造器依赖注入和 Setter方法注入的区别顶级接口BeanFactory 和 ApplicationContext 的区别BeanFactory和ApplicationContext的关系详解Applica
spring中IoC和DI浅析
ldcaws的专栏
08-16 984
IoC和DI都是spring框架中的重要概念，通常也是成对出现的，下面对IoC和DI及其关系进行简单分析。
【Spring进阶系列丨第三篇】Spring核心技术之 IoC 与 DI 实战案例
热门推荐
陈橘又青的博客
11-20 2万+
在上一篇文章中，我们学习了IoC与DI的相关概念与原理，现在让我们一同感受一下Spring框架带给我们开发的便捷性。
spring IOC和DI 理解
zhang2383906154的博客
11-15 2741
IOC(控制反转)和DI（依赖注入）是spring中的重要组成部分，下面是个人的一些理解，不代表官方。 1、IOC是什么？ IOC:全名是Inversion of Controller 中文解释是控制反转，不是什么技术，是一种设计思想。在java开发中IOC意味着你设计好的对象交给容器控制，而不是传统的在你对象内部直接控制。如何理解好IOC那？理解IOC的关键是要明确：“谁控制谁”、“控制什么”、为何是反转（有反转就应该有正转）哪些方面反转了，我们来分析一下： 1）谁控制谁，控制什么：传统的java
深入浅出讲解Spring IOC和DI的区别
小电玩
10-21 705
很多人都会把ioc和di说成同一个东西，其实IOC和DI虽然在概念上可以笼统地视为同一事物，但其本质上存在区别。IOC（Inverse of Control，控制反转）从容器的角度描述，而DI（Dependency Injection，依赖注入）则从应用程序的角度描述。换言之，IOC是依赖倒置原则的设计思想，而DI则是该原则的具体实现方式。因此，我们希望能够更加严谨地区分这两个概念，以更好地理解和应用它们。
spring基础知识（IOC、DI、AOP）
qq_38151401的博客
05-09 6229
一、spring概述 Spring 的主要作用就是为代码“解耦”，降低代码间的耦合度。就是让对象和对象（模块和模块）之间关系不是使用代码关联，而是通过配置来说明。减轻对项目模块之间的管理，类和类之间的管理， 帮助开发人员创建对象，管理对象之间的关系。 Spring 根据代码的功能特点，使用 Ioc 降低业务对象之间耦合度。IoC 使得主业务在相互调用过程中，不用再自己维护关系了，即不用再自己创建要使用的对象了。而是由 Spring 容器统一管理，自动“注入”,注入即赋值。 而 AOP 使得系统级服务得..
Spring - 关于IOC和DI的一些个人理解
Maggieq8324的博客
08-04 1380
前言 CRUD三年多，看过很多对Spring的IOC理解的文章，借用最近经常看到的一句话，“听君一席话，如听一席话”，怎一个晦涩难懂能表达，现在回头看看，从一开始接触到的就是Spring，不懂J2EE的痛点自然是理解不了的。网上不乏一些高质量关于IOC、DI理解的文章，这里限于个人能力低微，就不做些贻笑大家的事了，只是结合自己的情况整理下各路大佬们通俗易懂的解释。 Bromon的blog上对IoC与DI浅显易懂的讲解 IOC作为Spring的标志象征，想要理解它的含义一定要谈及它的出现是基于什么，Brom
Spring IOC和DI实现原理及实例解析
08-19
Spring IOC和DI实现原理及实例解析 Spring IOC（Inversion of Control，控制反转）是Spring框架的基础，它简单地说就是创建对象由以前的程序员调用new构造方法，变成了交由Spring创建对象。DI（Dependency Inject，...
springIOC和DI
05-08
什么是spring，spring核心，spring优点，spring体系结构， 入门案例，DI基础，核心API，文档内附代码
spring的IoC和DI详解
08-28
Spring的IoC和DI详解 Spring 框架中的控制反转（IoC）和依赖注入（DI）是两个紧密相关的概念，它们都是Spring框架的核心机制。IoC是指将对象的创建权由Spring管理，而不是由程序员手动创建对象。DI则是将对象依赖的...
Spring之IOC和DI(三)
01-21
(九)DI的概念和作用 (十)构造函数注入 (十一)set方法注入 (十二)注入复杂类型数据 (十三)业务层实现类调用持久层的方法 (一)IOC的概念和作用 IOC：Inversion of Control，是控制反转的意思 我们之前想new谁就new谁，...
笔记28-JAVAEE之Spring IoC&DI
01-25
JAVAEE之Spring IoC&DI Spring IoC(Inversion of Control，即控制反转)是Spring框架的核心机制之一，它提供了一种解耦合的方式，使得应用程序的各个组件之间能够松散耦合，提高了系统的灵活性和可维护性。 在传统...
OAuth2.0 or Spring Session or 单点登录流程
qq_53374893的博客
07-20 341
一句话精辟解释： 在过滤器放行的时候，偷偷的把原生的 request 和 response 对象换成了它的实现，也就是 调用getSession 的时候拿到的 其实是对redis 操作的Session。但其他的操作还是使用原生的，只不过重写的方法，调用的是子类的，也就是往 redis 里放入 Session，把原生的操作给替换了！分布式Session原理，使用子域名，的时候放入父域名的 JsessionId 然后将这个ID 的所存的内容放入Redis ，这样实现不同域名共享同一sessionID.
Vue 3 和 SpringBoot 实现文件分片上传示例
exlink2012的专栏
07-22 335
实现分片上传，并使用Spring Boot在后端保存文件。前端将文件分片并逐个上传到后端，后端接收到所有分片后再进行合并，最终保存为一个完整文件。
SpringBoot整合Elastic-Job 2.1.53版本任务调度，手动任务，动态添加任务演示
最新发布
小哇
07-23 139
zookeeper安装并成功运行。
SpringMVC 控制层框架-下
woai3364的博客
07-20 999
因此，在开发过程中，合理处理异常、避免异常产生、以及对异常进行有效的调试是非常重要的。如果张三负责的模块按照 A 方案处理异常，李四负责的模块按照 B 方案处理异常...各个模块处理异常的思路、代码、命名细节都不一样，那么就会让整个项目非常混乱。在Web 应用三层架构体系中，表述层负责接收浏览器提交的数据，业务逻辑层负责数据的处理。一个网站有 5、6个资源，其中有一个为登录资源，两个无需登录即可访问，另外三个需要登录后才能访问，如果不登录就访问那三个资源，需要拦截，并且提示登录后访问。
Spring框架详解：IOC与DI原理
"Spring的核心IOC和DI概念及其重要性" 在软件开发领域，Spring框架是一个备受推崇的Java平台上的开源框架，特别适用于后端开发。它以其Inversion of Control（控制反转，简称IOC）和Dependency Injection（依赖注入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值