Spring-bean的生命周期-终篇

于 2024-09-11 08:38:04 发布
阅读量868 收藏 25
点赞数 19
分类专栏： Spring 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45653328/article/details/142121689
版权
阶段8：Bean属性设置阶段

属性设置阶段分为3个小的阶段

  • 实例化后阶段
  • Bean属性赋值前处理
  • Bean属性赋值

实例化后阶段
这里也有spring给我们预留了扩展，就是实现InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法，开发者实现这个接口，重写此方法可以了
源码：

for (BeanPostProcessor bp : getBeanPostProcessors()) {
    if (bp instanceof InstantiationAwareBeanPostProcessor) {
        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
        if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
            return;
        }
    }
}

postProcessAfterInstantiation 方法返回false的时候，后续的Bean属性赋值前处理、Bean属性赋值都会被跳过了。

spring源码位置：

default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
    return true;
}

来个案例，先建一个process

/**
 * @description: 设置赋值前，如果返回false将不会被赋值
 *
 * 会调用 InstantiationAwareBeanPostProcessor 接口的 postProcessAfterInstantiation 这个方
 * 法，调用逻辑如下：，
 * 后续的Bean属性赋值前处理、Bean
 * 属性赋值都会被跳过了。
 * @author: stone
 * @date: Created by 2021/3/25 20:25
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.lifecycle.setprop
 */
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    /**
     * 后续的Bean属性赋值前处理、Bean
     *  属性赋值都会被跳过了。
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
//        System.out.println("调用 MyInstantiationAwareBeanPostProcessor#postProcessAfterInstantiation");
        if ("pig1".equalsIgnoreCase(beanName)) {
            return false;
        }

        return true;
    }

再来一个spring bean

package com.shiguiwu.springmybatis.spring.lifecycle.definition;

import com.shiguiwu.springmybatis.spring.lifecycle.instance.MyAutowire;
import lombok.Data;

/**
 * @description: 小猪
 * @author: stone
 * @date: Created by 2021/3/17 14:08
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.lifecycle.definition
 */
@Data
public class Pig {

    private String name;
    private Integer age;

    private String description;

    public Pig() {
    }

    @MyAutowire
    public Pig(String name, Integer age) {
        System.out.println("增强候选注解@MyAutowire ！！！！");
        this.name = name;
        this.age = age;
    }

    public Pig(String name, Integer age, String description) {
        this.name = name;
        this.age = age;
        this.description = description;
    }
}

测试案例如下：

public class InstancedTests {

    public static void main(String[] args) {
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
        factory.addBeanPostProcessor(new MyInstantiationAwareBeanPostProcessor());

        BeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(Pig.class)
                .addPropertyValue("name", "猪八戒")
                .addPropertyValue("age", 30)
                .getBeanDefinition();

        BeanDefinition beanDefinition1 = BeanDefinitionBuilder.genericBeanDefinition(Pig.class)
                .addPropertyValue("name", "猪悟能")
                .addPropertyValue("age", 35)
                .getBeanDefinition();

        factory.registerBeanDefinition("pig", beanDefinition);
        factory.registerBeanDefinition("pig1", beanDefinition1);

        Arrays.stream(factory.getBeanDefinitionNames()).forEach(s -> System.out.println(factory.getBean(s)));

    }
}

打印结果

Connected to the target VM, address: '127.0.0.1:52046', transport: 'socket'
20:22:20.387 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'pig'
调用InstantiationAwareBeanPostProcessor #postProcessProperties
Pig(name=猪无能, age=12, description=null)
20:22:20.770 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'pig1'
Pig(name=null, age=null, description=null)
Disconnected from the target VM, address: '127.0.0.1:52046', transport: 'socket'

被指定的bean名称，跳过了属性赋值

Bean属性赋值前阶段
这个阶段，spring照样为开发者预留了干涉spring bean赋值前阶段的操作，这个阶段会调用 InstantiationAwareBeanPostProcessor 接口的postProcessProperties 方法，调
用逻辑：
代码如下：

for (BeanPostProcessor bp : getBeanPostProcessors()) {
    if (bp instanceof InstantiationAwareBeanPostProcessor) {
        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
        PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
        if (pvsToUse == null) {
            if (filteredPds == null) {
                filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            }
            pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds,
                    bw.getWrappedInstance(), beanName);
            if (pvsToUse == null) {
                return;
            }
        }
        pvs = pvsToUse;
    }
}

从上面可以看出，如果 InstantiationAwareBeanPostProcessor 中的
postProcessProperties 和 postProcessPropertyValues 都返回空的时候，表示这个bean不
需要设置属性，直接返回了，直接进入下一个阶段。

来看一下 postProcessProperties 这个方法的定义：

@Nullable
default PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
    return pvs;
}

PropertyValues中保存了bean实例对象中所有属性值的设置，所以我们可以在这个这个方法中对PropertyValues值进行修改

示例代码如下：

@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
    System.out.println("调用InstantiationAwareBeanPostProcessor #postProcessProperties");
    if (beanName.equals("pig")) {
        if (pvs==null) {
            pvs = new MutablePropertyValues();
        }
        if (pvs instanceof MutablePropertyValues) {
            MutablePropertyValues pv = (MutablePropertyValues) pvs;
            //偷梁换柱，给属性辅助
            pv.add("name", "猪无能");
            pv.add("age", 12);
        }
    }
    return null;
}

Bean属性赋值阶段
这个过程比较简单了，循环处理 PropertyValues 中的属性值信息，通过反射调用set方法将属性的值设置到bean实例中。
PropertyValues中的值是通过bean xml中property元素配置的，或者调用MutablePropertyValues中add方法设置的值。

阶段9：Bean初始化阶段

这个阶段分为5个小的阶段

  • Bean Aware接口回调
  • Bean初始化前操作
  • Bean初始化操作
  • Bean初始化后操作
  • Bean初始化完成操作

Bean Aware接口回调,这里也是spring给我们的扩展
这块的源码：

private void invokeAwareMethods(final String beanName, final Object bean) {
    if (bean instanceof Aware) {
        if (bean instanceof BeanNameAware) {
            ((BeanNameAware) bean).setBeanName(beanName);
        }
        if (bean instanceof BeanClassLoaderAware) {
            ClassLoader bcl = getBeanClassLoader();
            if (bcl != null) {
                ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
            }
        }
        if (bean instanceof BeanFactoryAware) {
            ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
        }
    }
}

如果我们的bean实例实现了上面的接口，会按照下面的顺序依次进行调用：

BeanNameAware：将bean的名称注入进去
BeanClassLoaderAware：将BeanClassLoader注入进去
BeanFactoryAware：将BeanFactory注入进去

来一个实现这三个接口的类：

/**
 * @description: 三个接口
 * @author: stone
 * @date: Created by 2021/3/28 11:54
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.lifecycle.init
 */
public class MyAware implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware {
    @Override
    public void setBeanName(String name) {
        System.out.println("beanName:" + name);

    }


    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("classLoader:" + classLoader);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("beanFactory:" + beanFactory);
    }
}

测试代码：

package com.shiguiwu.springmybatis.spring.lifecycle.init;

import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;

/**
 * @description: 9.1初始化-aware接口回调
 * @author: stone
 * @date: Created by 2021/3/28 11:51
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.lifecycle.init
 */
public class AwareTests {

    public static void main(String[] args) {
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
        BeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(MyAware.class).getBeanDefinition();
        factory.registerBeanDefinition("myAware", beanDefinition);
        System.out.println(factory.getBean(MyAware.class));

    }
}

输出信息

Connected to the target VM, address: '127.0.0.1:55707', transport: 'socket'
22:21:14.221 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'myAware'
beanName:myAware
classLoader:sun.misc.Launcher$AppClassLoader@18b4aac2
beanFactory:org.springframework.beans.factory.support.DefaultListableBeanFactory@6c3f5566: defining beans [myAware]; root of factory hierarchy
com.shiguiwu.springmybatis.spring.lifecycle.init.MyAware@71248c21
Disconnected from the target VM, address: '127.0.0.1:55707', transport: 'socket'

Bean初始化前操作，spring给开发者的扩展
这个阶段的源码：

@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException {
    Object result = existingBean;
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        Object current = processor.postProcessBeforeInitialization(result, beanName);
        if (current == null) {
            return result;
        }
        result = current;
    }
    return result;
}

会调用 BeanPostProcessor的postProcessBeforeInitialization 方法，若返回null，当前方法将结束。
通常称postProcessBeforeInitialization这个方法为：bean初始化前操作。
这个接口有2个实现类，比较重要,画重点：

org.springframework.context.support.ApplicationContextAwareProcessor
org.springframework.context.annotation.CommonAnnotationBeanPostProcessor

ApplicationContextAwareProcessor注入6个Aware接口对象
如果bean实现了下面的接口，在ApplicationContextAwareProcessor#postProcessBeforeInitialization 中会依次调用下面接口中的方法，将 Aware 前缀对应的对象注入到bean实例中。

EnvironmentAware：注入Environment对象
EmbeddedValueResolverAware：注入EmbeddedValueResolver对象
ResourceLoaderAware：注入ResourceLoader对象
ApplicationEventPublisherAware：注入ApplicationEventPublisher对象
MessageSourceAware：注入MessageSource对象
ApplicationContextAware：注入ApplicationContext对象

从名称上可以看出这个类以 ApplicationContext 开头的，说明这个类只能在 ApplicationContext 环境中使用。

CommonAnnotationBeanPostProcessor调用@PostConstruct标注的方法
CommonAnnotationBeanPostProcessor#postProcessBeforeInitialization 中会调用bean中所有标注@PostConstruct注解的方法
整体来个案例

package com.shiguiwu.springmybatis.spring.lifecycle.init;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.context.EmbeddedValueResolverAware;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.MessageSource;
import org.springframework.context.MessageSourceAware;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ResourceLoader;
import org.springframework.util.StringValueResolver;

import javax.annotation.PostConstruct;

/**
 * @description: 初始化前操作
 * @author: stone
 * @date: Created by 2021/3/28 12:06
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.lifecycle.init
 */
public class BeforeBean implements EnvironmentAware, EmbeddedValueResolverAware,
        ResourceLoaderAware, ApplicationEventPublisherAware, MessageSourceAware,
        ApplicationContextAware {

    @PostConstruct
    public void postConstruct1() {
        System.out.println("postConstruct1");
    }


    @PostConstruct
    public void postConstruct2() {
        System.out.println("postConstruct2");
    }


    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("applicationContext：" + applicationContext);
    }

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        System.out.println("applicationEventPublisher：" + applicationEventPublisher);
    }

    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        System.out.println("resolver：" + resolver);
    }

    @Override
    public void setEnvironment(Environment environment) {
        System.out.println("environment：" + environment);
    }

    @Override
    public void setMessageSource(MessageSource messageSource) {
        System.out.println("messageSource：" + messageSource);
    }

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        System.out.println("resourceLoader：" + resourceLoader);
    }
}

测试代码如下：

package com.shiguiwu.springmybatis.spring.lifecycle.init;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @description: 9.2初始化前
 * @author: stone
 * @date: Created by 2021/3/28 12:04
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.lifecycle.init
 */
public class BeforeInitTests {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext factory = new AnnotationConfigApplicationContext();
//        BeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(BeforeBean.class).getBeanDefinition();
//        factory.("beforeBean", beanDefinition);
        factory.register(BeforeBean.class);
        factory.refresh();
        System.out.println(factory.getBean(BeforeBean.class));
    }
}

打印结果

environment：StandardEnvironment {activeProfiles=[], defaultProfiles= ...
resolver：org.springframework.beans.factory.config.EmbeddedValueResolver@3a52dba3
resourceLoader：org.springframework.context.annotation.AnnotationConfigApplicationContext@11438d26, started on Tue Nov 02 22:59:30 CST 2021
applicationEventPublisher：org.springframework.context.annotation.AnnotationConfigApplicationContext@11438d26, started on Tue Nov 02 22:59:30 CST 2021
messageSource：org.springframework.context.annotation.AnnotationConfigApplicationContext@11438d26, started on Tue Nov 02 22:59:30 CST 2021
applicationContext：org.springframework.context.annotation.AnnotationConfigApplicationContext@11438d26, started on Tue Nov 02 22:59:30 CST 2021
postConstruct1
postConstruct2
com.shiguiwu.springmybatis.spring.lifecycle.init.BeforeBean@610f7aa

大家可以去看一下AnnotationConfigApplicationContext的源码，其内部会添加很多
BeanPostProcessor 到 DefaultListableBeanFactory 中。

Bean初始化阶段
2个步骤

  1. 调用InitializingBean接口的afterPropertiesSet方法
  2. 调用定义bean的时候指定的初始化方法
    调用InitializingBean接口的afterPropertiesSet方法
public interface InitializingBean {
    public void afterPropertiesSet() throws Exception;
}

当我们的bean实现了这个接口的时候，会在这个阶段被调用
调用bean定义的时候指定的初始化方法
方式1：xml方式指定初始化方法

<bean init-method="bean中方法名称"/>

方式2：@Bean的方式指定初始化方法

@Bean(initMethod = "初始化的方法")

方式3：api的方式指定初始化方法

this.beanDefinition.setInitMethodName(methodName);

初始化方法最终会赋值给下面这个字段

org.springframework.beans.factory.support.AbstractBeanDefinition#initMethodName

案例如下：

package com.shiguiwu.springmybatis.spring.lifecycle.init;

import org.springframework.beans.factory.InitializingBean;

/**
 * @description: 初始化bean
 * @author: stone
 * @date: Created by 2021/3/28 13:04
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.lifecycle.init
 */
public class InitializeBean implements InitializingBean {

    public void init() {
        System.out.println("初始化方法！！！！");

    }
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("afterPropertiesSet");

    }
}

测试代码

package com.shiguiwu.springmybatis.spring.lifecycle.init;

import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;

/**
 * @description: 9.3初始化阶段
 * @author: stone
 * @date: Created by 2021/3/28 13:02
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.lifecycle.init
 */
public class InitializeTests {

    public static void main(String[] args) {
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
        BeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(InitializeBean.class).getBeanDefinition();
        beanDefinition.setInitMethodName("init");
        factory.registerBeanDefinition("initializeBean", beanDefinition);
        System.out.println(factory.getBean(InitializeBean.class));
    }
}

输出结果

23:09:16.350 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory 
afterPropertiesSet
初始化方法！！！！
com.shiguiwu.springmybatis.spring.lifecycle.init.InitializeBean@221af3c0
'socket'

调用顺序：InitializingBean中的afterPropertiesSet、然后在调用自定义的初始化方法

Bean初始化后阶段

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
    Object result = existingBean;
    Object current;
    for(Iterator iterator = this.getBeanPostProcessors().iterator(); iterator.hasNext(); result = current) {
        BeanPostProcessor processor = (BeanPostProcessor)iterator.next();
        current = processor.postProcessAfterInitialization(result, beanName);
        if (current == null) {
            return result;
        }
    }
    return result;
}

调用 BeanPostProcessor接口的postProcessAfterInitialization方法 ，返回null的时候，会中断上面的操作,注意这里也是扩展哦
通常称postProcessAfterInitialization这个方法为：bean初始化后置操作。
来个案例

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("bean :" + beanName);
        System.out.println("初始化后》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》");
        return bean;
    }
}

测试代码

package com.shiguiwu.springmybatis.spring.lifecycle.init;

import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;

/**
 * @description: 9.4初始化后阶段
 * @author: stone
 * @date: Created by 2021/3/28 13:07
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.lifecycle.init
 */
public class AfterInitializeTests {
    public static void main(String[] args) {
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
        //叫一个初始化后处理器
        factory.addBeanPostProcessor(new MyBeanPostProcessor());

        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(String.class)
                .addConstructorArgValue( "shiguiwu")
                .getBeanDefinition();

        AbstractBeanDefinition beanDefinition1 = BeanDefinitionBuilder.genericBeanDefinition(Integer.class)
                .addConstructorArgValue(15)
                .getBeanDefinition();

        factory.registerBeanDefinition("shiguiwuabc", beanDefinition);
        factory.registerBeanDefinition("shiguiwuA", beanDefinition1);

        System.out.println(factory.getBean(String.class));
        System.out.println(factory.getBean(Integer.class));
    }
}

输出结果

Connected to the target VM, address: '127.0.0.1:56910', transport: 'socket'
23:20:37.770 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'shiguiwuabc'
bean :shiguiwuabc
初始化后》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
shiguiwu
23:20:38.099 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'shiguiwuA'
bean :shiguiwuA
初始化后》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
15
Disconnected from the target VM, address: '127.0.0.1:56910', transport: 'socket'

Process finished with exit code 0

此致，终篇完毕，内容有点，希望能好好消化，接下来就是尾篇。

码农小伙
关注
专栏目录
V3-09 vue 组件化思想+ 路由(vue语法---终篇)
pingzhuyan的博客
07-03 216
1.Vue 组件化思想 1.1 分布式 -->传统项目的设计思想 说明: 单体项目架构设计在同一个Tomcat服务器中,如有个模块出现问题, 影响整个服务器无法运行 1.2 分布式思想 核心理念: 根据特定的规则,将程序进行拆分, (微服务架构思想) ---->根据模块拆分 说明: 根据不同模块拆分不同服务器,一个出现问题, 不影响其他 ---->按照层级拆分 ----->分布式总结 分布式架构设计主要解决系统架构设计的耦合性(架构师+压测+后台监控) .
SpringBootBean的生命周期
m0_72686268的博客
02-12 395
SpringBoot的Bean生命周期
Springboot bean生命周期
q_2540638774的博客
06-10 769
生命周期 Bean的生命周期的过程，它大致分为Bean定义、Bean的初始化、Bean 的生存期和Bean的销毁4个部分。其中Bean定义过程大致如下： Spring通过我们的配置，如@ComponentScan 定义的扫描路径去找到带有 @Component的类，这个过程就是一个资源定位的过程。 一旦找到了资源，那么它就开始解析，并且将定义的信息保存起来。注意，此时还没有初始化Bean,也就没有Bean的实例，它有的仅仅是Bean的定义。 然后就会把Bean定义发布到SpringIoC容器中。此时，
springboot bean的生命周期
qq_36669347的博客
08-26 719
Spring bean 的生命周期 步骤一： Bean容器先找到配置文件中Spring Bean的定义。 Bean容器利用Java Reflection API创建一个Bean的实例。 如果涉及到一些属性值 利用set方法设置一些属性值。 步骤二： 实现*Aware接口 在Bean中使用Spring框架的一些对象 如果Bean实现了BeanNameAware接口，调用setBeanName()方法，传入Bean的名字。 如果Bean实现了BeanClassLoa...
springboot bean生命周期
zjshuster的博客
08-10 1815
springboot 生命周期
LayaAir_简单跑酷JS版_-_05-终篇.zip_funnylkz_harborjqs_laya3Dqiuqiupaoku
07-15
layaair做的跑裤游戏，非常不错，用js开发的。
clickhouse如何解决GLIBC不兼容问题--终篇
liyang910910的专栏
12-05 2830
在上一篇文章中我们介绍了如何将共享库与binary文件打包来解决clickhouse运行时GLIBC不兼容的问题。但是经过我们的实践发现这种方案其实是有副作用的，而这种副作用在生产环境是致命的，会造成clickhouse进程crash。所以本文推翻了上一篇文章中的方案，使用clickhouse自身的机制彻底解决了GLIBC不兼容问题。共享库与binary文件打包的副作用test_getaddrinfo.cpp#include <sys/types.h> #include &l
Spring Cloud终篇 | 总结 一：一个完整的企业级SpringCloud架构（Mybatis--多数据源）
刘军的博客
05-11 3241
一、简介 前面归纳了一些Spring Cloud组件的核心原理及用法，主要是开发这一块的Eureka、Ribbon、Feign、Hystrix、Zuul、Config等组件和其相关的扩展。当然Spring Cloud还有一些偏运维的zipkin（Sleuth 服务链路追踪）、Hystrix Dashboard/Turbine(断路器监控方面)等等组件，可以用来查看服务之间的调用、异常啊等功能，后...
SpringBoot Bean的生命周期demo.zip
09-17
一般情况下，我们只是关心如何正确地将Bean装配到容器中，并不关心Ioc容器是如何装配和销毁Bean的过程。但是恰恰有时候，我们需要自定义初始化或销毁Bean的过程，以满足一些“特殊的”需求。比如，数据源在关闭的时候调用其close方法，这是项目开发过程中很常见的需求。
SpringBoot Bean的生命周期
朗朗繁星的博客
09-17 4701
一般情况下，我们只是关心如何正确地将Bean装配到容器中，并不关心Ioc容器是如何装配和销毁Bean的过程。但是恰恰有时候，我们需要自定义初始化或销毁Bean的过程，以满足一些“特殊的”需求。比如，数据源在关闭的时候调用其close方法，这是项目开发过程中很常见的需求。 Bean的生命周期大致可以分为4个部分： 1. Bean的定义 2. Bean的初始化 3. Bean的生存期 4. Bean的销毁 Bean的定义 资源定位的过程。 如使用@ComponentScan定义的扫描路径去找@Com
SpringBoot Bean生命周期
专注基础架构领域
03-17 407
首先Spring在实例化Bean的时候，会先调用它的构造函数，进行Bean的实例化，然后进行Bean的初始化，Bean的初始化经过三个阶段初始化之前（至此，我们Bean的生命周期探索初步结束，后面再做进一步深入学习，在学习本节课时要多进行调试，断点跟踪，会更加有效果。然后就开始利用Bean进行业务逻辑处理，最后容器正常关闭，Spring开始销毁Bean，Bean的销毁过程相对比较简单，调用。注：Spring Boot Bean的生命周期，什么是Bean的生命周期，就是Bean从创建到销毁的过程。
springboot-bean生命周期
zhouping118的博客
08-04 1962
1.spring bean生命周期 2.Aware接口 2.1.作用 一个标记，标记在spring容器初始化时需要获取上下文中当前的一些运行环境； 2.2.常用接口 ApplicationContextAware：获取ApplicationContext spring上下文； ApplicationEventPublisherAware：获取ApplicationEventPublisher事件发布器； BeanClassLoaderAware：获取当前的ClassLoader类加载器； BeanFac
SpringBoot中bean的生命周期
最新发布
zhangjianfzf的博客
05-03 1277
Bean 生命周期管理是 Spring Boot 中的关键功能之一。它负责管理应用程序中的 Java 对象，这些对象被称为 Beans。Spring Boot 通过创建、配置、初始化和销毁这些 Beans 来确保应用程序的正常运行。这个功能的目的是提供一种灵活的方式，使开发人员能够轻松地管理对象的生命周期，从而实现高效的依赖注入和组件化开发。1、实例化：在 Spring 容器启动时，Spring 会创建配置中定义的所有 Bean。这是通过 Java 类的构造函数或工厂方法来完成的。
JavaEE SpringBean的生命周期
char_m的博客
09-29 293
在传统的Java应用中，bean的生命周期很简单，使用Java关键字 new 进行Bean 的实例化，然后该Bean 就能够使用了。一旦bean不再被使用，则由Java自动进行垃圾回收。 相比之下，Spring管理Bean的生命周期就复杂多了，正确理解Bean 的生命周期非常重要，因为Spring对Bean的管理可扩展性非常强，下面展示了一个Bean的构造过程 如上图所示，Bean 的生命周期还是比较复杂的，下面来对上图每一个步骤做文字描述: 1、Spring启动，查找并加载需要被Spring管理的bea
SpringBoot：Bean生命周期介绍
qq_46119575的博客
03-23 4428
Bean 是 SpringBoot 中一个非常重要的组成部分，是面试中经常会问到的一个问题。本文介绍了 Bean 的整个生命周期：创建前准备阶段、创建实例阶段、依赖注入阶段、容器缓存阶段和销毁实例阶段。Bean 生命周期全过程大致分为五个阶段：创建前准备阶段、创建实例阶段、依赖注入阶段、容器缓存阶段和销毁实例阶段1、创建前准备阶段这个阶段主要的作用是，Bean 在开始加载之前，需要从上下文和相关配置中解析并查找 Bean 有关的扩展实现。
SpringBoot实践（三十七）：Bean的生命周期
叶子叶来
01-05 735
了解springBoot启动过程能够帮助我们快速熟悉/集成/定制化第三方依赖包，快速地上手搭建工程，在实际上要完成比较复杂的业务代码，还需要继续探索bean的生命周期管理，并且能够在bean的生命周期内增加各种自定义的逻辑，bean的生命周期包括：创建，使用，销毁。bean的使用大家一般都比较熟悉，但最重要的是bean的创建过程，也就是跟随springBoot启动中加载bean的过程。；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值