五、SpringIOC容器 -- （一）创建对象

最新推荐文章于 2024-02-29 15:00:29 发布
最新推荐文章于 2024-02-29 15:00:29 发布
阅读量122 收藏
点赞数
分类专栏： 小白 - WEB框架（高） - Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45602227/article/details/107591423
版权

一、创建对象

		SpringIOC容器，是spring核心内容。
		作用： 创建对象 & 处理对象的依赖关系

		
		IOC容器创建对象, 有几种方式：
					1） 调用无参数构造器
					2） 带参数构造器
					3） 工厂创建对象
							工厂类，静态方法创建对象
							工厂类，非静态方法创建对象
1.1 调用无参构造器
	
	<!-- 1.无参的构造器 -->
	<bean id="user1"  class="org.jsoft.b_create.User"   ></bean>
>>>>>> 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"
     xmlns:p="http://www.springframework.org/schema/p"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans.xsd">

	
	<!-- 1.无参的构造器 -->
	<bean id="user1"  class="org.jsoft.b_create.User"   ></bean>
	
	<!-- 2.带参的构造器 -->
	<!-- 构造参数顺序不能打乱 -->
	<bean id="user2_a"  class="org.jsoft.b_create.User"   >
		<constructor-arg value="王胡塞" ></constructor-arg>
		<constructor-arg value="12" ></constructor-arg>
	</bean>
	
	<!-- 构造参数顺序可以打乱 -->
	<bean id="user2_b"  class="org.jsoft.b_create.User"   >
		<constructor-arg value="12" index="1" type="int"></constructor-arg>
		<constructor-arg value="王胡塞" index="0" type="java.lang.String"></constructor-arg>
	</bean>
	
	
	<!-- 构造参数引用字符串 -->
	<!-- 创建一个Jack的字符串  String str=new String("王虎") -->
	<bean id="str"  class="java.lang.String">
		<constructor-arg value="王虎"></constructor-arg>
	</bean>
	
	<bean id="user2_c"  class="org.jsoft.b_create.User"   >
		<constructor-arg ref="str" ></constructor-arg>
		<constructor-arg value="12" ></constructor-arg>
	</bean>
	
	<!-- 3.工厂类创建对象 -->
	<!-- #工厂类实例方法 -->
	<bean id="fac"  class="org.jsoft.b_create.ObjectFactory"></bean>
	<bean id="user3_a" factory-bean="fac" factory-method="getInstance"></bean>
	
	<!-- 工厂类静态方法 -->
	<!--  class：指定工厂类   factory-method：指定工厂类的静态方法   -->
	<bean id="user3_b"  class="org.jsoft.b_create.ObjectFactory" factory-method="getStaticInstance"></bean>
</beans>
>>>>>> User.java
public class User {
	
	private String name;
	private int age;
	
	public User() {
		super();
		System.out.println("--user对象创建--");
	}
	
	
	
	public User(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}



	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public void user_init() {
		System.out.println("创建对象之后，初始化");
	}
	
	public void user_destoty(){
		System.out.println("IOC容器销毁，调用");
	}
}
>>>>>> App.java
public class App {
	
	
	public static void main(String[] args) {
		
		//加载配置文件,创建Bean工程
		ApplicationContext ac=new ClassPathXmlApplicationContext("org/jsoft/b_create/applicationContext.xml");
		
		//获取对象
		User u=(User) ac.getBean("user1");
		System.out.println(u);
	
	}
	
}

在这里插入图片描述

1.2 调用有参构造器
		
		调用有参构造器(参数不能打乱):
					<bean id="user2_a"  class="org.jsoft.b_create.User"   >
							<constructor-arg value="王胡塞" ></constructor-arg>
							<constructor-arg value="12" ></constructor-arg>
					</bean>
		
		调用有参构造器(参数可以打乱):
					<bean id="user2_b"  class="org.jsoft.b_create.User"   >
							<constructor-arg value="12" index="1" type="int"></constructor-arg>
							<constructor-arg value="王胡塞" index="0" type="java.lang.String"></constructor-arg>
					</bean>
		
		调用有参构造器(参数引用其他对象):
					<!-- 构造参数引用字符串 -->
					<!-- 创建一个Jack的字符串  String str=new String("王虎") -->
					<bean id="str"  class="java.lang.String">
						<constructor-arg value="王虎"></constructor-arg>
					</bean>
	
					<bean id="user2_c"  class="org.jsoft.b_create.User"   >
						<constructor-arg ref="str" ></constructor-arg>
						<constructor-arg value="12" ></constructor-arg>
					</bean>
>>>>>> 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"
     xmlns:p="http://www.springframework.org/schema/p"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- 2.带参的构造器 -->
	<!-- 构造参数顺序不能打乱 -->
	<bean id="user2_a"  class="org.jsoft.b_create.User"   >
		<constructor-arg value="王胡塞" ></constructor-arg>
		<constructor-arg value="12" ></constructor-arg>
	</bean>
	
	<!-- 构造参数顺序可以打乱 -->
	<bean id="user2_b"  class="org.jsoft.b_create.User"   >
		<constructor-arg value="12" index="1" type="int"></constructor-arg>
		<constructor-arg value="王胡塞" index="0" type="java.lang.String"></constructor-arg>
	</bean>
	
	
	<!-- 构造参数引用字符串 -->
	<!-- 创建一个Jack的字符串  String str=new String("王虎") -->
	<bean id="str"  class="java.lang.String">
		<constructor-arg value="王虎"></constructor-arg>
	</bean>
	
	<bean id="user2_c"  class="org.jsoft.b_create.User"   >
		<constructor-arg ref="str" ></constructor-arg>
		<constructor-arg value="12" ></constructor-arg>
	</bean>

</beans>
>>>>>> User.java
public class User {
	
	private String name;
	private int age;
	
	public User() {
		super();
		System.out.println("--user对象创建--");
	}
	
	
	
	public User(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}



	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public void user_init() {
		System.out.println("创建对象之后，初始化");
	}
	
	public void user_destoty(){
		System.out.println("IOC容器销毁，调用");
	}
}
>>>>>> App.java
public class App {
	
	
	public static void main(String[] args) {
		
		//加载配置文件,创建Bean工程
		ApplicationContext ac=new ClassPathXmlApplicationContext("org/jsoft/b_create/applicationContext.xml");
		
		//获取对象
		User u=(User) ac.getBean("user2_b");
		System.out.println(u);
	
	}
	
}
1.3 调用工厂类创建对象
	
	+++ 调用工厂类实例方法，创建对象
				<!--构造工厂类实例-->
				<bean id="fac"  class="org.jsoft.b_create.ObjectFactory"></bean>
				<!--调用工厂类实例方法-->
				<bean id="user3_a" factory-bean="fac" factory-method="getInstance"></bean>

	+++ 调用工厂类静态方法，创建对象
				<!--  class：指定工厂类   factory-method：指定工厂类的静态方法   -->
				<bean id="user3_b"  class="org.jsoft.b_create.ObjectFactory" factory-method="getStaticInstance"></bean>
1.3.1 调用工厂类的实例方法，创建对象
>>>>>> 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"
     xmlns:p="http://www.springframework.org/schema/p"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans.xsd">

	
	<!-- 3.工厂类创建对象 -->
	<!-- #工厂类实例方法 -->
	<bean id="fac"  class="org.jsoft.b_create.ObjectFactory"></bean>
	<bean id="user3_a" factory-bean="fac" factory-method="getInstance"></bean>
	

</beans>
>>>>>> ObjectFactory .java
public class ObjectFactory {
	
	public User getInstance() {
		System.out.println("工厂类，实例方法");
		return new  User();
	}
	
	public static User getStaticInstance() {
		System.out.println("工厂类，静态方法");
		return new  User();
	}
}
>>>>>> User.java
public class User {
	
	private String name;
	private int age;
	
	public User() {
		super();
		System.out.println("--user对象创建--");
	}
	
	
	
	public User(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}



	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public void user_init() {
		System.out.println("创建对象之后，初始化");
	}
	
	public void user_destoty(){
		System.out.println("IOC容器销毁，调用");
	}
}
>>>>>> App.java
public class App {
	
	
	public static void main(String[] args) {
		
		//加载配置文件,创建Bean工程
		ApplicationContext ac=new ClassPathXmlApplicationContext("org/jsoft/b_create/applicationContext.xml");
		
		//获取对象
		User u=(User) ac.getBean("user3_a");
		System.out.println(u);
	
	}
	
}

在这里插入图片描述

1.3.2 调用工厂类的静态方法，创建对象
>>>>>> 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"
     xmlns:p="http://www.springframework.org/schema/p"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans.xsd">

	
	<!-- 工厂类静态方法 -->
	<!--  class：指定工厂类   factory-method：指定工厂类的静态方法   -->
	<bean id="user3_b"  class="org.jsoft.b_create.ObjectFactory" factory-method="getStaticInstance"></bean>
	

</beans>
>>>>>> ObjectFactory .java
public class ObjectFactory {
	
	public User getInstance() {
		System.out.println("工厂类，实例方法");
		return new  User();
	}
	
	public static User getStaticInstance() {
		System.out.println("工厂类，静态方法");
		return new  User();
	}
}
>>>>>> User.java
public class User {
	
	private String name;
	private int age;
	
	public User() {
		super();
		System.out.println("--user对象创建--");
	}
	
	
	
	public User(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}



	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public void user_init() {
		System.out.println("创建对象之后，初始化");
	}
	
	public void user_destoty(){
		System.out.println("IOC容器销毁，调用");
	}
}
>>>>>> App.java
public class App {
	
	
	public static void main(String[] args) {
		
		//加载配置文件,创建Bean工程
		ApplicationContext ac=new ClassPathXmlApplicationContext("org/jsoft/b_create/applicationContext.xml");
		
		//获取对象
		User u=(User) ac.getBean("user3_b");
		System.out.println(u);
	
	}
	
}

在这里插入图片描述

1.3.3 利用工厂类的方法创建Bean，给方法传参

		利用构造方法创建Bean:
						<bean id="user2_c"  class="org.jsoft.b_create.User"   >
							<constructor-arg ref="str" ></constructor-arg>
							<constructor-arg value="12" ></constructor-arg>
						</bean>
		
		利用工厂类创建对象时，如果工厂类的方法带参数，则传参方式和构造方法传参相同。
			<bean id="userDao_proxy" class="org.jsoft.d_proxy_e_myaop_2.ObjectFactory" factory-method="getInstance">
		 		<constructor-arg index="0" ref="userDao"></constructor-arg>
		 		<constructor-arg index="1" ref="myAop"></constructor-arg>
 			</bean>

	<bean id="user3_b"  class="org.jsoft.b_create.ObjectFactory" factory-method="getStaticInstance"></bean>
>>>>>> 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"
    
    xmlns:p="http://www.springframework.org/schema/p"  
    
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

	
 	<bean id="user" class="org.jsoft.c_property_e_param.ObjectFactory" factory-method="createUser">
 		<constructor-arg index="0" value="12"></constructor-arg>
 		<constructor-arg index="1" value="小白"></constructor-arg>
 	</bean>
	
	
</beans>
>>>>>> ObjectFactory .java
public class ObjectFactory {
	
	public static User createUser(int age,String name) {
		return new User(age, name);
	}
}
>>>>>> User.java
public class User {
	
	private int age;
	private String name;
	
	
	
	public User() {
		super();
	}


	public User(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}
	
	
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	
	
}
>>>>>> App.java
public class App {
	public static void main(String[] args) {
		//加载配置文件,创建Bean工程
		ApplicationContext ac=new ClassPathXmlApplicationContext("org/jsoft/c_property_e_param/applicationContext.xml");
		
		User u=(User) ac.getBean("user");
		System.out.println(u.getName());		
	}
}

在这里插入图片描述

1.4 总结
>>>>>> 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"
    
    xmlns:p="http://www.springframework.org/schema/p"  
    
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
	
	<!-- ###############	调用无参构造 	 ############### -->
	<bean id="user1" class="org.jsoft.c_property_e_param.User"></bean>
	
	
	<!-- ###############	调用有参构造 	 ############### -->
	<bean id="user2" class="org.jsoft.c_property_e_param.User">
		<constructor-arg index="0" value="12"></constructor-arg>
		<constructor-arg index="1" value="小黑"></constructor-arg>
	</bean>
	
	
	<!-- ###############	调用工厂类 	 ############### -->
	<!-- 1.实例方法 -->
	<bean id="beanFac" class="org.jsoft.c_property_e_param.ObjectFactory"></bean>
	<bean id="user3" factory-bean="beanFac" factory-method="getInstance"></bean>
 	
	<!-- 2.静态方法 -->
	<bean id="user4" class="org.jsoft.c_property_e_param.ObjectFactory" factory-method="getInstanceByStatic"></bean>

	<!-- 3.工厂类方法带有参数-->
 	<bean id="user5" class="org.jsoft.c_property_e_param.ObjectFactory" factory-method="getInstanceByStatic">
 		<constructor-arg index="0" value="12"></constructor-arg>
 		<constructor-arg index="1" value="小白"></constructor-arg>
 	</bean>
	
	
</beans>
>>>>>> ObjectFactory .java
public class ObjectFactory {
	
	

	/**
	 * 实例方法
	 * @return
	 */
	public  User getInstance() {
		return new User();
	}
	
	/**
	 * 静态方法（不带参数）
	 * @return
	 */
	public static User getInstanceByStatic() {
		return new User();
	}
	
	/**
	 * 静态方法（带参数）
	 * @param age
	 * @param name
	 * @return
	 */
	public static User getInstanceByStatic(int age,String name) {
		return new User(age, name);
	}
}
>>>>>> User.java
public class User {
	
	private int age;
	private String name;
	
	
	
	public User() {
		super();
	}


	public User(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}
	
	
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	
	
}
>>>>>> App.java
public class App {
	public static void main(String[] args) {
		//加载配置文件,创建Bean工程
		ApplicationContext ac=new ClassPathXmlApplicationContext("org/jsoft/c_property_e_param/applicationContext.xml");
		
		User u=(User) ac.getBean("user3");
		System.out.println(u.getName());		
	}
}
二旬、
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring之IOC容器创建对象
TH226的专栏
02-09 697
1.术语了解1.1组件/框架设计 侵入式设计 引入了框架，对现有的类的结构有影响；即需要实现或继承某些特定类。 例如： Struts框架非侵入式设计 引入了框架，对现有的类结构没有影响。 例如：Hibernate框架 / Spring框架控制反转: Inversion on Control , 控制反转 IOC 对象的创建交给外部容器完成，这个就做控制反转. 依赖注入：        depend...
Spring(一)——用Spring IOC容器创建对象
吃饭了吗
02-15 824
1. 什么是spring 2. 第一个spring的小例子 3. Spring两大核心技术
【Spring】IOC容器创建对象
Evan_QB的博客
10-18 322
SpringIOC容器，是spring核心内容。 作用：创建对象 & 处理对象的依赖关系   IOC容器创建对象： 创建对象, 有几种方式： 1） 调用无参数构造器 2） 带参数构造器 3） 工厂创建对象                    工厂类，静态方法创建对象                    工厂类，非静态方法创建对象 @Test public void test
使用spring框架，通过spring容器来创建对象并使用
Self_discipline8的博客
04-19 280
使用spring框架，通过spring容器来创建对象并使用 spring容器创建对象并使用的步骤如下： 第一，在pom.xml文件中配置spring框架 <!-- 加入springframework依赖--> <!-- https://mvnrepository.com/artifact/org.springframework/spring-context --> <dependency> <groupId>org.sprin
IOC容器创建对象的方式
weixin_52385232的博客
11-28 142
IOC容器创建对象的方式
2.IOC容器创建对象的方式
m0_56379670的博客
10-23 225
IOC容器创建对象的方式
Java-Spring-SpringIoC容器-SpringIoC的学习
10-11
Spring IoC容器通过XML配置或注解实现了对象的创建、管理和依赖注入，极大地简化了Java应用的复杂性。理解并熟练运用Spring IoC，能够帮助开发者构建更灵活、易于测试和维护的系统。在实际开发中，还可以结合@...
Spring-IoC 容器 - v1.01
08-03
工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。在Spring中，工厂模式可以用于创建Bean。Spring的BeanFactory就是这样一个工厂，它负责根据配置创建和管理Bean实例。当使用工厂模式时，对象的创建...
Spring实现一个简单的SpringIOC容器
08-30
本文将深入探讨如何实现一个简单的Spring IOC容器，以及涉及的主要知识点。 首先，控制反转是一种设计模式，它将对象的创建和管理从对象本身转移到一个外部容器，即IOC容器。Spring的IOC容器通过读取配置文件（如...
Spring IOC---使用maven创建
kitiyang的博客
08-28 550
Spring IOC---小白快速了解什么是Spring IOC？ 什么是Spring IOC？ IOC是控制反转的意思,是一个概念，是一种思想。指将传统上由程序代码直接操控的对象调用权交给容器，通过容器来实现对象的装配和管理。控制反转就是对对象控制权的转移，从程序代码本身反转到了外部容器。通过容器实现对象的创建，属性赋值， 依赖的管理。 ...
IOC容器，创建对象详细解析
mischen520的博客
08-14 2318
下面模仿一个具体的实例来说明问题， 1.bean.xml <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/s
IOC创建对象的方式
qq_40004922的博客
02-11 1143
看看spring到底是怎么创建对象的！ 思考一下：为什么spring管理的bean，我们可以直接get到，它肯定得new出来之后才能get到吧。得想一下，spring是在什么时候new的！ 演示： 创建一个实体类，默认会有一个无参构造，我们把它写出来，在里面再加上句话 我们知道在Java中，java对象要能够使用，那么他就必须得new出来 ...
spring--ioc创建对象的方式
niceYF的博客
03-21 189
1.使用无参构造，默认方式。 public class User { private String str; public User(){ System.out.println("无参构造"); } public String getStr() { return str; } public void setStr(String str) { this.str = str; } @Over
IOC创建对象的三种方式
zhang__1234的博客
02-18 349
IOC创建对象方式 使用无参构造创建对象 默认！ 假设我们要使用有参构造创建对象 <bean id="user" class="com.zzz.pojo.User"> <!-- 第一种 下标赋值--> <constructor-arg index="0" value="张三"/> </bean> <!-- 第二种方式通过类型创建--> <bean id="user" class="c
Spring 框架学习（三）---- IOC创建对象
rain67的博客
06-23 1091
  写完了第一个Spring的程序，相信已经对spring已经有所了解了，那么我们这节来了解一下，IOC是如何创建对象，什么时候创建对象的。  Spring 提供了两种 IoC 容器，分别为 BeanFactory 和 ApplicationContext我们先对两种进行介绍一下  BeanFactory 是基础类型的 IoC 容器，简单来说，BeanFactory 就是一个管理 Bean的工厂，它主要负责初始化各种 Bean，并调用它们的生命周期方法。  BeanFactory 接口有多个实现类，最常见的
Spring中IOC创建对象的两种方式和创建时机
jike11231的博客
05-02 1340
最近在学习Spring相关知识，官网文档如下 Spring Core Technologies: https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-constructor-injection. 方式一：通过无参构造方法来创建 package com.zhang.pojo; public class User { private String name; public Use
Spring学习-IOC容器怎样创建对象
最新发布
qq_65568592的博客
02-29 909
通常我们在new一个对象时会调用这个类的构造器，即使我们在编写一个类时不写构造方法，系统也会生成一个默认的无参构造方法，这个无参构造方法实际上继承的是万类之父Object的无参构造方法，所以即使我们不写构造函数也能直接new创建。从运行结果可以看出，我们在获取对象之前就调用了两次构造函数，这就说明当我们在获得Spring的上下文对象时Spring就已经创建好了所有的对象，后面我们获取的时候直接拿就行了，这也就是为什么叫做容器的原因了。所以同一个id的对象Spring只会创建一个，每次获取的都是同一个对象。
IOC创建对象的几种方式
醉卧雕龙舫，的博客
06-04 1327
1.无参构造创建对象 2.有参构造创建对象 1）根据index下标 2）根据参数名 3）根据参数类型
SpringIOC容器-创建对象
松门一枝花
05-09 2020
SpringIOC容器，是spring核心内容。功能：创建对象，处理对象的依赖关系 IOC容器创建对象： 创建对象, 有几种方式： 1） 调用无参数构造器 2） 带参数构造器 3） 工厂创建对象 工厂类，静态方法创建对象 工厂类，非静态方法创建对象 spring配置文件在创建对象的配置 <beans xmlns="http://www.springframewo
Spring IoC容器详解：从BeanFactory到Dependency Injection
《Spring的IoC容器全面介绍》是一本深入探讨Spring框架中的Inversion of Control (IoC)容器的书籍，由王福强所著，提供了一个全面的视角来理解Spring框架的核心组件如BeanFactory和ApplicationContext。本书主要关注...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值