作为Java程序员还不知道Spring中Bean创建过程和作用？

1.简单的来说

在Spring框架中，Bean的生命周期是指一个Bean从创建到销毁的过程。包括以下几个阶段：

1. 实例化：当Spring容器启动时，会根据配置文件或注解等方式创建Bean的实例。
2. 属性赋值：在实例化完成后，Spring容器会自动将相应的属性值赋值给Bean的成员变量。
3. BeanPostProcessor前置处理器：在属性赋值完成后，Spring容器会调用BeanPostProcessor接口的postProcessBeforeInitialization方法，可以在该方法中对Bean进行一些自定义处理。
4. 自定义初始化方法：如果需要在初始化时执行一些自定义逻辑，可以在Bean中定义一个初始化方法，并在该方法中编写相应的逻辑。Spring容器会自动调用该方法。
5. BeanPostProcessor后置处理器：在自定义初始化方法执行完成后，Spring容器会调用BeanPostProcessor接口的postProcessAfterInitialization方法，可以在该方法中对Bean进行一些自定义处理。
6. 注册监听器：在Bean初始化完成后，Spring容器会将该Bean注册到ApplicationContext中，以便其他组件可以访问和使用该Bean。

在Bean的生命周期中，可以进行许多操作，例如自定义初始化和销毁方法、注入属性、设置依赖关系等。

2.Spring中Bean的生命周期就是Bean在Spring中从创建到销毁的整个过程，主要分为以下5个部分

1.实例化： 给Bean分配内存空间（对应JVM中的“加载”，这里只是分配了内存）；

2.设置属性： 进行Bean的注入和装配；

3.初始化：

执行各种通知；
执行初始化的前置工作；
进行初始化工作（使用注解 @PostConstruct 初始化 或者 使用（xml）init-method 初始化， 前者技术比后者技术先进~）；
执行初始化的后置工作；
4.使用Bean

5.销毁Bean

3.代码演示

package com.lp.bean;

import org.springframework.beans.factory.BeanNameAware;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * @author liu pei
 * @date 2024年01月09日 下午7:36
 * @Description:
 */
@Component
public class BeanTestComponent implements BeanNameAware {
    //执行各种通知
    @Override
    public void setBeanName(String s) {
        System.out.println("执行了通知"+ s);
    }

    //初始化的前置和后置方法不能写在这个Bean中！

    //执行初始化方法(注解)
    @PostConstruct
    public void postConstruct() {
        System.out.println("通过注解 @PostConstruct 执行了初始化方法");
    }

    //使用
    public void useBean() {
        System.out.println("使用Bean");
    }

    //销毁
    @PreDestroy
    public void preDestory() {
        System.out.println("执行了销毁方法");
    }
}

package com.lp.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

/**
 * @author liu pei
 * @date 2024年01月09日 下午7:34
 * @Description:
 */
@Component
public class BeanTest implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("执行了初始化的前置方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("执行了初始化的后置方法");
        return bean;
    }
}

4测试

package com.lp;

import com.lp.bean.BeanTestComponent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;

/**
 * @author liu pei
 * @date 2023年12月05日 下午12:29
 * @Description:
 */
@SpringBootApplication
public class DemoApplication extends SpringBootServletInitializer{

    private static final Logger logger = LoggerFactory.getLogger(DemoApplication.class);

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(DemoApplication.class, args);
        ConfigurableEnvironment env = context.getEnvironment();

       
        //获取Bean
        BeanTestComponent beanTestComponent = context.getBean("beanTestComponent", BeanTestComponent.class);
        //使用Bean
        beanTestComponent.useBean();
        //销毁Bean
        beanTestComponent.preDestory();
    }


    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(this.getClass());
    }
}