Spring源码-源码层面讲解实例对象工厂方法、静态工厂方法、无参构造方法如何创建对象(从源头分析)

于 2024-08-15 07:30:00 发布
阅读量386 收藏 9
点赞数 18
分类专栏： Spring源码详解 Spring java学习 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37200262/article/details/141198805
版权

前置准备工作

factoryMethod.xml配置文件创建
bean标签，person是静态对象工厂方法；
person2是用的实例对象工厂；

<?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="person" class="com.mashibing.factoryMethod.PersonStaticFactory" factory-method="getPerson">
        <!--constructor-arg：可以为方法指定参数-->
        <constructor-arg value="123"></constructor-arg>
    </bean>
    <bean id="personInstanceFactory" class="com.mashibing.factoryMethod.PersonInstanceFactory"></bean>
    <bean id="person2" class="com.mashibing.factoryMethod.Person" factory-bean="personInstanceFactory" factory-method="getPerson">
        <constructor-arg value="wangwu"></constructor-arg>
    </bean>
</beans>

bean标签，person是静态对象工厂方法；

public class PersonStaticFactory {

    public static Person getPerson(String name){
        Person person = new Person();
        person.setId(1);
        person.setName(name);
        return person;
    }

    public static Person getPerson(int age){
        return new Person();
    }

    public static Person getPerson(String name,int id){
        Person person = new Person();
        person.setId(1);
        person.setName(name);
        return person;
    }
}

person2是用的实例对象工厂；

public class PersonInstanceFactory {
    public Person getPerson(String name){
        Person person = new Person();
        person.setId(1);
        person.setName(name);
        return person;
    }
}

public class Person {
    private int id;
    private String name;
    private int age;
    private String gender;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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 String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }
}

启动方法

public class TestFactoryMethod {

    public static void main(String[] args) {

        ApplicationContext ac = new ClassPathXmlApplicationContext("factoryMethod.xml");
        Person person = ac.getBean("person", Person.class);
        System.out.println(person);
        Person person2 = ac.getBean("person2", Person.class);
        System.out.println(person2);
    }
}

解析配置文件factory-method和factory-bean标签

factory-method解析
调用链路

parseBeanDefinitionElement:537, BeanDefinitionParserDelegate (org.springframework.beans.factory.xml)
parseBeanDefinitionElement:445, BeanDefinitionParserDelegate (org.springframework.beans.factory.xml)
parseBeanDefinitionElement:410, BeanDefinitionParserDelegate (org.springframework.beans.factory.xml)
processBeanDefinition:326, DefaultBeanDefinitionDocumentReader (org.springframework.beans.factory.xml)
parseDefaultElement:199, DefaultBeanDefinitionDocumentReader (org.springframework.beans.factory.xml)
parseBeanDefinitions:178, DefaultBeanDefinitionDocumentReader (org.springframework.beans.factory.xml)
doRegisterBeanDefinitions:150, DefaultBeanDefinitionDocumentReader (org.springframework.beans.factory.xml)
registerBeanDefinitions:97, DefaultBeanDefinitionDocumentReader (org.springframework.beans.factory.xml)
registerBeanDefinitions:526, XmlBeanDefinitionReader (org.springframework.beans.factory.xml)
doLoadBeanDefinitions:397, XmlBeanDefinitionReader (org.springframework.beans.factory.xml)
loadBeanDefinitions:341, XmlBeanDefinitionReader (org.springframework.beans.factory.xml)
loadBeanDefinitions:310, XmlBeanDefinitionReader (org.springframework.beans.factory.xml)
loadBeanDefinitions:190, AbstractBeanDefinitionReader (org.springframework.beans.factory.support)
loadBeanDefinitions:234, AbstractBeanDefinitionReader (org.springframework.beans.factory.support)
loadBeanDefinitions:197, AbstractBeanDefinitionReader (org.springframework.beans.factory.support)
loadBeanDefinitions:267, AbstractBeanDefinitionReader (org.springframework.beans.factory.support)
loadBeanDefinitions:150, AbstractXmlApplicationContext (org.springframework.context.support)
loadBeanDefinitions:102, AbstractXmlApplicationContext (org.springframework.context.support)
refreshBeanFactory:138, AbstractRefreshableApplicationContext (org.springframework.context.support)
obtainFreshBeanFactory:718, AbstractApplicationContext (org.springframework.context.support)
refresh:577, AbstractApplicationContext (org.springframework.context.support)
<init>:150, ClassPathXmlApplicationContext (org.springframework.context.support)
<init>:87, ClassPathXmlApplicationContext (org.springframework.context.support)
main:10, TestFactoryMethod (com.mashibing.factoryMethod)

可以看出这个标签解析之后，bean对象 factoryMethodName属性有值了；

    <bean id="person" class="com.mashibing.factoryMethod.PersonStaticFactory" factory-method="getPerson">
        <!--constructor-arg：可以为方法指定参数-->
        <constructor-arg value="123"></constructor-arg>
    </bean>

在这里插入图片描述
factory-method和factory-bean解析
调用链路

parseBeanDefinitionAttributes:663, BeanDefinitionParserDelegate (org.springframework.beans.factory.xml)
parseBeanDefinitionElement:530, BeanDefinitionParserDelegate (org.springframework.beans.factory.xml)
parseBeanDefinitionElement:445, BeanDefinitionParserDelegate (org.springframework.beans.factory.xml)
parseBeanDefinitionElement:410, BeanDefinitionParserDelegate (org.springframework.beans.factory.xml)
processBeanDefinition:326, DefaultBeanDefinitionDocumentReader (org.springframework.beans.factory.xml)
parseDefaultElement:199, DefaultBeanDefinitionDocumentReader (org.springframework.beans.factory.xml)
parseBeanDefinitions:178, DefaultBeanDefinitionDocumentReader (org.springframework.beans.factory.xml)
doRegisterBeanDefinitions:150, DefaultBeanDefinitionDocumentReader (org.springframework.beans.factory.xml)
registerBeanDefinitions:97, DefaultBeanDefinitionDocumentReader (org.springframework.beans.factory.xml)
registerBeanDefinitions:526, XmlBeanDefinitionReader (org.springframework.beans.factory.xml)
doLoadBeanDefinitions:397, XmlBeanDefinitionReader (org.springframework.beans.factory.xml)
loadBeanDefinitions:341, XmlBeanDefinitionReader (org.springframework.beans.factory.xml)
loadBeanDefinitions:310, XmlBeanDefinitionReader (org.springframework.beans.factory.xml)
loadBeanDefinitions:190, AbstractBeanDefinitionReader (org.springframework.beans.factory.support)
loadBeanDefinitions:234, AbstractBeanDefinitionReader (org.springframework.beans.factory.support)
loadBeanDefinitions:197, AbstractBeanDefinitionReader (org.springframework.beans.factory.support)
loadBeanDefinitions:267, AbstractBeanDefinitionReader (org.springframework.beans.factory.support)
loadBeanDefinitions:150, AbstractXmlApplicationContext (org.springframework.context.support)
loadBeanDefinitions:102, AbstractXmlApplicationContext (org.springframework.context.support)
refreshBeanFactory:138, AbstractRefreshableApplicationContext (org.springframework.context.support)
obtainFreshBeanFactory:718, AbstractApplicationContext (org.springframework.context.support)
refresh:577, AbstractApplicationContext (org.springframework.context.support)
<init>:150, ClassPathXmlApplicationContext (org.springframework.context.support)
<init>:87, ClassPathXmlApplicationContext (org.springframework.context.support)
main:10, TestFactoryMethod (com.mashibing.factoryMethod)

可以看到解析之后，bean里相关方法名和对象名已经有值了。
在这里插入图片描述

使用静态工厂方法创建对象

创建对象链路

createBeanInstance:1435, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
doCreateBean:675, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
createBean:630, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
lambda$doGetBean$0:417, AbstractBeanFactory (org.springframework.beans.factory.support)
getObject:-1, 447981768 (org.springframework.beans.factory.support.AbstractBeanFactory$$Lambda$17)
getSingleton:370, DefaultSingletonBeanRegistry (org.springframework.beans.factory.support)
doGetBean:414, AbstractBeanFactory (org.springframework.beans.factory.support)
getBean:260, AbstractBeanFactory (org.springframework.beans.factory.support)
preInstantiateSingletons:993, DefaultListableBeanFactory (org.springframework.beans.factory.support)
finishBeanFactoryInitialization:1024, AbstractApplicationContext (org.springframework.context.support)
refresh:614, AbstractApplicationContext (org.springframework.context.support)
<init>:150, ClassPathXmlApplicationContext (org.springframework.context.support)
<init>:87, ClassPathXmlApplicationContext (org.springframework.context.support)
main:10, TestFactoryMethod (com.mashibing.factoryMethod)

创建person对象，静态工厂方法，后续会标志静态

    <bean id="person" class="com.mashibing.factoryMethod.PersonStaticFactory" factory-method="getPerson">
        <!--constructor-arg：可以为方法指定参数-->
        <constructor-arg value="123"></constructor-arg>
    </bean>

在这里插入图片描述
**instantiateUsingFactoryMethod方法:**这里会进else

// 从mbd中获取配置的FactoryBean名
		String factoryBeanName = mbd.getFactoryBeanName();
		// 如果factoryBeanName不为null
		if (factoryBeanName != null) {
			// 如果factoryBean名与beanName相同
			if (factoryBeanName.equals(beanName)) {
				throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
						"factory-bean reference points back to the same bean definition");
			}
			// 从bean工厂中获取factoryBeanName所指的factoryBean对象
			factoryBean = this.beanFactory.getBean(factoryBeanName);
			// 如果mbd配置为单例作用域 且 beanName已经在bean工厂的单例对象的高速缓存Map中
			if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
				// 这个时候意味着Bean工厂中已经有beanName的Bean对象，而这个还要生成多一个Bean名为BeanName的Bean对象，导致了冲突
				// 抛出ImplicitlyAppearedSingletonException，
				throw new ImplicitlyAppearedSingletonException();
			}
			// 获取factoryBean的Class对象
			factoryClass = factoryBean.getClass();
			// 设置isStatic为false,表示不是静态方法
			isStatic = false;
		}
		else {
			// It's a static factory method on the bean class.
			// 这是bean类上的静态工厂方法
			// 如果mbd没有指定bean类
			if (!mbd.hasBeanClass()) {
				throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
						"bean definition declares neither a bean class nor a factory-bean reference");
			}
			// 将factoryBean设为null
			factoryBean = null;
			// 指定factoryClass引用mbd指定的bean类
			factoryClass = mbd.getBeanClass();
			// 设置isStatic为true，表示是静态方法
			isStatic = true;
		}

instantiateUsingFactoryMethod:562, ConstructorResolver (org.springframework.beans.factory.support)
instantiateUsingFactoryMethod:1634, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
createBeanInstance:1436, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)

静态工厂方法调用
ConstructorResolver类的instantiateUsingFactoryMethod方法开始获取工厂方法创建对象
该方法这里开始生成:

	// 使用factoryBean生成与beanName对应的Bean对象,并将该Bean对象保存到bw中
	bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, factoryMethodToUse, argsToUse));

链路：

getPerson:6, PersonStaticFactory (com.mashibing.factoryMethod)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
instantiate:218, SimpleInstantiationStrategy (org.springframework.beans.factory.support)
instantiate:936, ConstructorResolver (org.springframework.beans.factory.support)
instantiateUsingFactoryMethod:908, ConstructorResolver (org.springframework.beans.factory.support)

在这里插入图片描述
在这里插入图片描述

使用无参构造创建personInstanceFactory对象

该方法代码如下，默认会有一个无参构造，在实例化的时候会使用无参构造的形式：

public class PersonInstanceFactory {
    public Person getPerson(String name){
        Person person = new Person();
        person.setId(1);
        person.setName(name);
        return person;
    }
}

在这里插入图片描述

instantiateBean:1605, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
createBeanInstance:1495, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
doCreateBean:675, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)

在这里插入图片描述
bd.hasMethodOverrides()是false取反是true,所以不会用cglib来动态代理，这里会直接获取默认构造方法实例化

/**
	 * 如果发现是有方法重载的，就需要用cglib来动态代理，如果没有就直接获取默认构造方法实例化
	 */
	@Override
	public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
		// bd对象定义中，是否包含MethodOverride列表，spring中有两个标签参数会产生MethodOverrides,分别是lookup-method,replaced-method
		// 没有MethodOverrides对象，可以直接实例化
		if (!bd.hasMethodOverrides()) {
			// 实例化对象的构造方法
			Constructor<?> constructorToUse;
			// 锁定对象，使获得实例化构造方法线程安全
			synchronized (bd.constructorArgumentLock) {
				// 查看bd对象里使用否含有构造方法
				constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
				// 如果没有
				if (constructorToUse == null) {
					// 从bd中获取beanClass
					final Class<?> clazz = bd.getBeanClass();
					// 如果要实例化的beanDefinition是一个接口，则直接抛出异常
					if (clazz.isInterface()) {
						throw new BeanInstantiationException(clazz, "Specified class is an interface");
					}
					try {
						// 获取系统安全管理器
						if (System.getSecurityManager() != null) {
							constructorToUse = AccessController.doPrivileged(
									(PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
						}
						else {
							// 获取默认的无参构造器
							constructorToUse = clazz.getDeclaredConstructor();
						}
						// 获取到构造器之后将构造器赋值给bd中的属性
						bd.resolvedConstructorOrFactoryMethod = constructorToUse;
					}
					catch (Throwable ex) {
						throw new BeanInstantiationException(clazz, "No default constructor found", ex);
					}
				}
			}
			// 通过反射生成具体的实例化对象
			return BeanUtils.instantiateClass(constructorToUse);
		}
		else {
			// Must generate CGLIB subclass.
			// 必须生成cglib子类
			return instantiateWithMethodInjection(bd, beanName, owner);
		}
	}

可以看出这里是无参构造形式，实例化对象
在这里插入图片描述
** BeanUtils.instantiateClass(constructorToUse);**

	/**
	 * 调用构造函数实例化
	 *使用给定构造函数实例化类的方便方法。
	 * 请注意，如果给定不可访问(即非公共)构造函数，则此方法尝试将构造函数设置为可访问的，并支持带有可选参数和默认值的Kotlin类
	 */
	public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
		Assert.notNull(ctor, "Constructor must not be null");
		try {
			ReflectionUtils.makeAccessible(ctor);
			if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
				return KotlinDelegate.instantiateClass(ctor, args);
			}
			else {
				Class<?>[] parameterTypes = ctor.getParameterTypes();
				Assert.isTrue(args.length <= parameterTypes.length, "Can't specify more arguments than constructor parameters");
				Object[] argsWithDefaultValues = new Object[args.length];
				//获得参数
				for (int i = 0 ; i < args.length; i++) {
					if (args[i] == null) {
						Class<?> parameterType = parameterTypes[i];
						argsWithDefaultValues[i] = (parameterType.isPrimitive() ? DEFAULT_TYPE_VALUES.get(parameterType) : null);
					}
					else {
						argsWithDefaultValues[i] = args[i];
					}
				}
				return ctor.newInstance(argsWithDefaultValues);
		}
		}
		catch (InstantiationException ex) {
			throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
		}
		catch (IllegalAccessException ex) {
			throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
		}
		catch (IllegalArgumentException ex) {
			throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
		}
		catch (InvocationTargetException ex) {
			throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
		}
	}

使用实例对象工厂方法创建person2对象

    <bean id="person2" class="com.mashibing.factoryMethod.Person" factory-bean="personInstanceFactory" factory-method="getPerson">
        <constructor-arg value="wangwu"></constructor-arg>
    </bean>

在这里插入图片描述

**instantiateUsingFactoryMethod方法:**这里会进if

// 从mbd中获取配置的FactoryBean名
		String factoryBeanName = mbd.getFactoryBeanName();
		// 如果factoryBeanName不为null
		if (factoryBeanName != null) {
			// 如果factoryBean名与beanName相同
			if (factoryBeanName.equals(beanName)) {
				throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
						"factory-bean reference points back to the same bean definition");
			}
			// 从bean工厂中获取factoryBeanName所指的factoryBean对象
			factoryBean = this.beanFactory.getBean(factoryBeanName);
			// 如果mbd配置为单例作用域 且 beanName已经在bean工厂的单例对象的高速缓存Map中
			if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
				// 这个时候意味着Bean工厂中已经有beanName的Bean对象，而这个还要生成多一个Bean名为BeanName的Bean对象，导致了冲突
				// 抛出ImplicitlyAppearedSingletonException，
				throw new ImplicitlyAppearedSingletonException();
			}
			// 获取factoryBean的Class对象
			factoryClass = factoryBean.getClass();
			// 设置isStatic为false,表示不是静态方法
			isStatic = false;
		}
		else {
			// It's a static factory method on the bean class.
			// 这是bean类上的静态工厂方法
			// 如果mbd没有指定bean类
			if (!mbd.hasBeanClass()) {
				throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
						"bean definition declares neither a bean class nor a factory-bean reference");
			}
			// 将factoryBean设为null
			factoryBean = null;
			// 指定factoryClass引用mbd指定的bean类
			factoryClass = mbd.getBeanClass();
			// 设置isStatic为true，表示是静态方法
			isStatic = true;
		}

获取到的实例工厂对象的对象以及类型，
在这里插入图片描述

			// 如果candidateList为null
			if (candidates == null) {
				// 让candidateList引用一个新的ArrayList
				candidates = new ArrayList<>();
				// 根据mbd的是否允许访问非公共构造函数和方法标记【RootBeanDefinition.isNonPublicAccessAllowed】来获取factoryClass的所有候选方法
				Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
				// 遍历rawCandidates,元素名为candidate
				for (Method candidate : rawCandidates) {
					// 如果candidate的修饰符与isStatic一致且candidate有资格作为mdb的工厂方法
					if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
						// 将candidate添加到candidateList中
						candidates.add(candidate);
					}
				}
			}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

instantiate:218, SimpleInstantiationStrategy (org.springframework.beans.factory.support)
instantiate:936, ConstructorResolver (org.springframework.beans.factory.support)
instantiateUsingFactoryMethod:908, ConstructorResolver (org.springframework.beans.factory.support)
instantiateUsingFactoryMethod:1634, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)

在这里插入图片描述
调用实例对象的工厂方法创建对象！

努力的布布
关注
  • 18
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java怎么无参构造方法_Java中如何在无参构造方法中调用有参构造？
weixin_39593961的博客
02-16 4279
展开全部一般正常的都是参数多的调用参数少的。有参数的调用无参数的居e68a843231313335323631343130323136353331333365643537多。当然你要无参调用的参的也可以。你用无参，调用有参的。那你有参的参数你需要怎么传呢。当然如果换一个角度也可以。我手写下。没经过IDE的。提供下思路。我有两种思路，写同一个功能。public class Person{privat...
spring源码14: 实例化 无参构造器
12-22
本文主要探讨的是在Spring源码中如何通过无参构造器来实例化Bean。这个过程主要集中在`doCreateBean`方法中，它位于`AbstractAutowireCapableBeanFactory`类中。我们将深入分析这个方法中的关键步骤，特别是`...
Spring高手之路21——深入剖析Spring AOP代理对象的创建
最新发布
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
07-27 1万+
本文详细介绍了Spring AOP代理对象的创建过程，分为三个核心步骤：判断是否增强、匹配增强器和创建代理对象。通过源码分析和时序图展示，深入剖析了Spring AOP的工作原理，帮助读者全面理解Spring AOP代理对象的生成机制及其实现细节。
Alian解读SpringBoot 2.6.0 源码（一）：SpringApplication对象创建（Spring工厂加载机制）
嘉禾嘉宁papa
12-03 5992
一、背景 二、SpringApplication实例化 2.1、实例化方法入口 2.2、推断应用程序类型 2.3、Spring工厂加载机制 2.3.1、获取Spring工厂实例（重要） 2.3.2、loadFactoryNames 2.3.3、loadSpringFactories（核心） 2.4、获取引导注册初始化器 2.5、设置容器初始化器 2.6、设置容器监听器 2.7、推断main方法所在类 结语
Spring中@Bean标注的方法是如何创建对象呢？
热门推荐
沉淀、分享、成长，让自己和他人都能有所收获！
11-10 2万+
在本文中，我们将深入探讨Spring框架中使用@Bean标注的方法是如何创建对象的。我们将通过分析源码和实际案例演示，揭示Spring是如何通过FactoryMethod机制实现Bean的创建和管理的。此外，我们还会详细研究了@Bean标注方法中的参数注入过程，包括对同类型Bean的决策过程和使用@Primary注解的情况。通过本文的深入研究，我们对Spring框架中@Bean标注方法的创建过程和参数注入流程有了更清晰的认识。
【Spring源码--IOC容器的实现】（五）Bean对象的创建
Frankenstein的博客
08-22 3598
本文主要讲述通过bean的不同配置根据不同的策略生成对象的源码，并附带了lookup-method和replace-method的简单解释。
【spring源码系列-02】通过refresh方法剖析IOC的整体流程
zhenghuishengq的博客
06-02 1万+
通过refresh方法剖析IOC的整体流程
SpringBoot源码分析之SpringApplication构造方法核心源码分析
波波烤鸭的博客
12-23 5457
SpringBoot核心源码之SpringApplication构造方法讲解
SpringBoot （走读源码）静态方法中调用spring注入的对象，注入对象为null？
默默不代表沉默
07-06 2544
spring 静态注入问题，源码走读深思
【spring源码系列-01】spring底层源码整体概述
zhenghuishengq的博客
05-30 1万+
spring源码整体概述
Spring源码阅读之bean对象的创建过程
qq_38238296的博客
06-10 3719
Spring源码阅读之bean对象的创建过程 ​ Spring是通过IOC容器来管理对象的，该容器不仅仅只是帮我们创建了对象那么简单，它负责了对象的整个生命周期-创建、装配、销毁。这种方式成为控制反转（组件对象控制权的转移，从程序代码本身转移到了外部容器，容器创建完对象后注入组件中）。 ​ Spring的核心的是容器，不过这个容器并不是唯一的，框架本身就提供了很多个容器的实现，大概分为两种类型： BeanFactory：最简单的容器，只能提供基本的DI（依赖注入）功能。 ApplicationCont
99%的人答不对Spring推断构造方法！打破你三观！！！（范例→源码）
12-21
本文将深入探讨 Spring 如何推断构造方法进行依赖注入，并通过示例和源码分析来揭示其工作原理。 首先，我们来看 Spring 为何推荐使用构造方法注入。构造方法注入是在创建对象时，通过构造函数将依赖注入到类中。...
Spring创建实例源码分析
01-20
首先，创建一个User类并将user注入到Spring容器中去，并且在无参构造器中打印创建实例对象提示，然后创建一个测试类在main方法中创建容器 User类 package com.stanley.springSource; public class User { private ...
06 源码分析-spring自定义标签解析过程
06-19
4. **返回`BeanDefinition`**：`parse()`方法完成后，返回的`BeanDefinition`会被添加到`BeanDefinitionRegistry`中，这样Spring在启动时就能根据这些定义创建Bean实例。 5. **属性转换**：在解析过程中，Spring还...
【框架源码篇 01】Spring源码-手写IOC
10-21
IOC是一种设计模式，它将对象的创建和管理职责从应用代码中解耦出来，转交给一个外部容器（在此案例中即为Spring框架）来处理。这样做的好处是提高了软件的灵活性、可测试性和可维护性。 首先，我们来看看Spring是...
Spring 源码分析（Bean的初始化）
12-21
3. **AOP代理**：如果Bean配置了AOP代理，Spring会创建一个代理对象来包装原始的Bean实例，以便在方法调用时执行拦截器逻辑。 4. **单例管理**：对于单例模式的Bean，Spring会缓存其实例，确保后续请求得到的是同一...
Spring源码缺失的spring-cglib-repack-3.2.6.jar和spring-objenesis-repack-2.6.jar
05-31
在Spring框架中，`spring-cglib-repack-3.2.6.jar`和`spring-objenesis-repack-2.6.jar`是两个重要的依赖库，它们在Spring源码环境中扮演着不可或缺的角色。本文将详细介绍这两个库以及它们在Spring框架中的作用。 ...
官方原版源码 spring-framework-5.1.16.RELEASE.zip
06-10
IoC使得对象的创建和管理由框架负责，而DI则通过构造函数、setter方法或注解来实现依赖关系的注入，降低了组件之间的耦合度。 此外，Spring的AOP（Aspect-Oriented Programming）模块提供了声明式事务管理、日志...
spring高版本源码分析缺lib spring-cglib-repack-3.2.4.jar和spring-objenesis-repack-2.4.jar
12-01
Objenesis是一个用于实例化新对象的库，特别适用于那些没有无参数构造函数的对象。在某些情况下，Spring框架需要使用Objenesis来实例化没有默认构造器的类，尤其是当使用CGLIB进行代理时。Objenesis通过一些内部优化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值