spring生命周期步骤简要说明

最新推荐文章于 2024-03-22 11:53:57 发布
最新推荐文章于 2024-03-22 11:53:57 发布
阅读量195 收藏
点赞数
分类专栏： java 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40564810/article/details/128476792
版权

  1. 实例化前
    为啥需要实例化前这个动作呢？在Spring中，实例化对象之前，Spring提供了一个扩展点，允许用户来控制是否在某个或某些Bean实例化之前做一些启动动作。怎么理解实例化前？实例化，也就是new一个对象，实例化前，也就是在new对象之前执行。

    @Component
public class MyPostProcess implements InstantiationAwareBeanPostProcessor {

    @Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
    if ("other1Entity".equals(beanName)){
        System.out.println("实例化前可以做一些操作，比如往redis设值，等等");
    }
    return null;
}

    如上代码会导致，在other1Entity这个Bean实例化前，会进行打印。

    值得注意的是，postProcessBeforeInstantiation()是有返回值的，如果这么实现：

    @Component
public class MyPostProcess implements InstantiationAwareBeanPostProcessor {

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if ("other1Entity".equals(beanName)){
            System.out.println("实例化前可以做一些操作，比如往redis设值，等等");
            return new Other1Entity();
        }
        return null;
    }
}

    other1Entity这个Bean，在实例化前会直接返回一个由我们所定义的Other1Entity对象。如果是这样，表示不需要Spring来实例化了，并且后续的Spring依赖注入也不会进行了，会跳过一些步骤，直接执行初始化后这一步。怎么验证这句话的真实性呢？请看以下代码：

    @Component
public class MyPostProcess implements InstantiationAwareBeanPostProcessor {

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if ("other1Entity".equals(beanName)){
            System.out.println("实例化前可以做一些操作，比如往redis设值，等等");
            return new Other1Entity();
        }
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        System.out.println("这是实例化后的操作，在这里面，对other1Entity的Name属性进行了赋值，但是并没有成功设置值");
        if ("other1Entity".equals(beanName)){
            Other1Entity o = (Other1Entity)bean;
            o.setName("yzyyzyzyzyzy");
            System.out.println("postProcessAfterInstantiation:" + beanName);
        }
        return false;
    }
}

    在这里插入图片描述
    可以看到，在实例化后的操作里面，对other1Entity的Name属性进行了赋值，但是并没有成功设置值。也就验证了那句话。

  2. 实例化
    在这个步骤中就会根据BeanDefinition去创建一个对象了。
    2.1. 通过Supplier创建对象。请看代码：

    @Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        AbstractBeanDefinition beanDefinition = (AbstractBeanDefinition)beanFactory.getBeanDefinition("other2Entity");
        beanDefinition.setInstanceSupplier(() -> {
            System.out.println("通过supplier构建other2Entity");
            return new Other2Entity();
        });
    }
}

    @Data
@Component
public class Other2Entity {
    private String name;
}

    在这里插入图片描述
    可以看出来：other2Entity是通过Supplier创建出来的，如果把MyBeanFactoryPostProcessor 的@Component注释掉，会发生什么呢？咱们试试
    在这里插入图片描述
    从结果得知，这就不是通过Supplier创建的other2Entity，那是怎么创建出来的呢？
    当然，这涉及到推断构造方法，spring默认使用无参的构造方法进行实例化。

    @Component
public class Other2Entity {
    private String name;

    public Other2Entity(){
        System.out.println("通过无参构造方法创建Other2Entity");
    }

    public Other2Entity(String name){
        this.name = name;
        System.out.println("通过有参构造方法创建Other2Entity");
    }
}

    public class Test {
    public static void main(String[] args) throws IOException {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringAnnotationTest.class);
        Other2Entity testPrimary = (Other2Entity)context.getBean("other2Entity");
        System.out.println(testPrimary);
    }
}

    在这里插入图片描述
    如果不存在无参的构造方法，但是只有一个有参的构造方法，也不会报错

    @Component
@Data
public class Other2Entity {
    private String name;

    private Other1Entity other1Entity;

//    public Other2Entity(){
//        System.out.println("通过无参构造方法创建Other2Entity");
//    }

//    @Autowired
    public Other2Entity(Other1Entity other1Entity){
        this.other1Entity = other1Entity;
        System.out.println("通过有参构造方法创建Other2Entity");
    }

//    public Other2Entity(Other1Entity other1Entity, TestPrimary testPrimary){
//        this.other1Entity = other1Entity;
//        System.out.println("通过有参构造方法创建Other2Entity");
//    }
}

    在这里插入图片描述

    如果有多个有参构造方法，但是没有无参构造方法，会报错。

    @Component
@Data
public class Other2Entity {
    private String name;

    private Other1Entity other1Entity;

//    public Other2Entity(){
//        System.out.println("通过无参构造方法创建Other2Entity");
//    }

//    @Autowired
    public Other2Entity(Other1Entity other1Entity){
        this.other1Entity = other1Entity;
        System.out.println("通过有参构造方法创建Other2Entity");
    }

    public Other2Entity(Other1Entity other1Entity, TestPrimary testPrimary){
        this.other1Entity = other1Entity;
        System.out.println("通过有参构造方法创建Other2Entity");
    }
}

    在这里插入图片描述
    如果有多个有参构造方法，但是没有无参构造方法，但是在某个有参构造方法上加上@Autowired，则默认使用加了@Autowired进行实例化，不会报错。

    @Component
@Data
public class Other2Entity {
    private String name;

    private Other1Entity other1Entity;

//    public Other2Entity(){
//        System.out.println("通过无参构造方法创建Other2Entity");
//    }

    @Autowired
    public Other2Entity(Other1Entity other1Entity){
        this.other1Entity = other1Entity;
        System.out.println("通过有参构造方法创建Other2Entity");
    }

    public Other2Entity(Other1Entity other1Entity, TestPrimary testPrimary){
        this.other1Entity = other1Entity;
        System.out.println("通过有参构造方法创建Other2Entity");
    }
}

    在这里插入图片描述

  3. BeanDefinition的后置处理
    Bean对象实例化出来之后，接下来就应该给对象的属性赋值了。在真正给属性赋值之前，Spring又提供了一个扩展点MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()，可以对此时的BeanDefinition进行加工，比如：

    @Component
public class MyMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor {
    @Override
    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
        if ("other2Entity".equals(beanName)){
            beanDefinition.setScope("prototype");
        }
    }
}

    以上代码就是把other2Entity的beanDefinition的作用范围改为原型的

    public class Test {
    public static void main(String[] args) throws IOException {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringAnnotationTest.class);
        Other2Entity other2Entity = (Other2Entity)context.getBean("other2Entity", new Other1Entity());
        System.out.println(other2Entity);

        Other2Entity other2Entity1 = (Other2Entity)context.getBean("other2Entity", new Other1Entity());
        System.out.println(other2Entity1);
    }
}

    在这里插入图片描述
    虽然Other2Entity在BeanDefinition的后置处理中改为了原型的，但是在实例化的时候，其还是原型的，也就是说在单例池中，也还是会有Other2Entity这个Bean的，证明：
    在这里插入图片描述

  4. 实例化后
    在处理完BeanDefinition后，Spring又设计了一个扩展点：InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()，比如：

    @Component
public class MyPostProcess implements InstantiationAwareBeanPostProcessor {

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if ("other2Entity".equals(beanName)){
            System.out.println("实例化前可以做一些操作，比如往redis设值，等等");
        }
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        // 实例化后的操作
        if ("other2Entity".equals(beanName)){
            Other2Entity o = (Other2Entity)bean;
            o.setName("yzyyzyzyzyzy");
        }
        return false;
    }
}

    在实例化后步骤中，我们把Other2Entity 的name属性设置为yzyyzyzyzyzy。测试：

    public class Test {
    public static void main(String[] args) throws IOException {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringAnnotationTest.class);

        Other2Entity other2Entity = (Other2Entity)context.getBean("other2Entity", new Other1Entity());
        System.out.println(other2Entity.getName());

        Other2Entity other2Entity1 = (Other2Entity)context.getBean("other2Entity", new Other1Entity());
        System.out.println(other2Entity1.getName());
    }
}

    在这里插入图片描述
    到这里，实例化后操作完成。

qq_40564810
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring组件的生命周期详细全过程
小超的博客
02-28 1155
一、生命周期 Spring容器中的生命周期方法分为4类： Bean自身方法 Bean级生命周期接口方法 容器级生命周期接口方法 工厂级生命周期接口方法 1.1 Bean自身生命周期方法 Bean自身的方法： 构造函数实例化bean initMethod指定方法（指定某个方法在bean实例化完成，依赖关系结束后执行） destroyMethod指定方法（指定某个方法在bean销毁之前执行） 定义一个类： @Component public class XiaoChao { @Value("小超
第八节HarmonyOS @Component自定义组件的生命周期
yyxhzdm的博客
11-28 1776
页面：即应用的UI页面。可以由一个或者多个自定义组件组成，@Entry装饰的自定义组件为页面的入口组件，即页面的根节点，一个页面有且仅能有一个@Entry。只有被@Entry装饰的组件才可以调用页面的生命周期。：组件即将出现时回调该接口，具体时机为在创建自定义组件的新实例后，在执行其build()函数之前执行。、自定义组件：@Component装饰的UI单元，可以组合多个系统组件实现UI的复用。：在自定义组件即将析构销毁时执行。：当用户点击返回按钮时触发。：页面每次隐藏时触发一次。：页面每次显示时触发。
【Spring注解必知必会】深度解析@Component注解实现原理
m0_71777195的博客
08-16 5181
想必@Component注解大家一直在使用，只要类上加上它，就可以被Spring容器管理，那大家有想过它是怎么实现的吗？本篇文章就带领到家揭秘。用来标记的类是一个“组件”或者说是一个Bean，Spring会自动扫描标记@Component注解的类作为一个Spring Bean对象。@Indexed/***/}复制代码value: 自定义当前组件或者说bean的名称，可以不配置， 不配置的话默认为组件的首字母小写的类名。该注解只能使用在类，接口、枚举、其他注解上该注解的生命周期是运行时JVM。...
@Component注解的使用及解析
张三博客
09-28 7470
@Component 可作用于类、接口、枚举类型等 (Target) @Component 生命周期为运行时 (Retention) @Component 可以使用JavaDoc命令生成文档后查看说明 (Documented) @Component 该类会存储到 META-INF/spring.components (Indexed)
微信小程序：页面Page和组件Component生命周期执行的先后顺序
彭世瑜的博客
10-14 5313
页面 // pages/test-page/test-page.js Page({ /** * 生命周期函数--监听页面加载 */ onLoad: function (options) { console.log('Page onLoad'); }, /** * 生命周期函数--监听页面初次渲染完成 */ onReady: function () { console.log('Page onReady'); }, /** * 生命
spring源码1
08-08
2. **Spring IOC**：Spring的IoC（Inversion of Control，控制反转）是其核心特性之一，它负责管理对象的生命周期和依赖关系。初始化通常从创建`ClassPathXmlApplicationContext`开始。 - 在创建`...
《软件工程》作业答题说明1
08-03
比如，“论述软件工程中需求分析的重要性”，应先指出需求分析是软件生命周期的关键阶段，然后讨论其对项目成功、减少后期变更风险等方面的影响，最后总结其不可或缺的角色。 4. **应用题**： - 应用题需要结合...
spring、mybatis 配置方式详解(常用两种方式)
08-28
在本文中，我们将深入探讨两种常用的Spring与MyBatis集成的配置方式。...另一种方式则更注重将MyBatis的配置融入Spring的上下文，让Spring完全管理MyBatis的生命周期。选择哪种方式取决于项目的具体需求和个人偏好。
cxf 结合spring所需jar包
08-17
整合CXF和Spring的主要目的是利用Spring的IoC和AOP能力来管理CXF服务的生命周期和行为。以下是一些关键的整合步骤： 1. **创建CXF服务接口和实现**：定义一个Java接口，代表你的Web服务，并提供一个实现该接口的类...
Vue快速入门---组件component、生命周期
weixin_50163576的博客
12-16 1094
组件component：可复用的 Vue 实例，且带有一个名字。（这个名字没有编程作用，一般用于调试代码使用，安装vue-devtool工具，在这个工具里面name才有用） 1）全局组件:在所有Vue实例里面都可以使用（当标签来用）。 Vue.component('组件名称建议短横线命名',{ // {}里面的选项和vue实例的选项是一样的 // data选项必须是一个函数 }) 2）局部组件:在定义该组件的Vue实例里面可以使用 new Vue({ componen
Spring对象生命周期控制
CWeeYii的专栏
01-08 4244
1.Spring中常用对象Spring框架中最常用对象有两个：BeanFactory和Bean。1.1 BeanFactoryBeanFactory作用是：保存所有bean名字、类型等和beanDefinition的映射关系，以及保存实力化后单例bean名字、类型等和bean对象的映射关系。其中MVC框架中有两个beanFactory：一个是保存业务对象@Service @Commpont等注解产生
【spring】@Component注解学习
最新发布
一个写了10年bug的程序员日常笔记。
03-22 2107
Component 是 Spring 框架中的一个注解，用于将一个类标记为 Spring 上下文中的一个组件。当一个类被标记为 @Component 时，Spring 容器会在启动时自动扫描并实例化这个类，并将其注册到 Spring 上下文中。@Component 注解可以用于任何类，包括控制器、服务、DAO 等。当一个类被标记为 @Component 时，它就成为了 Spring 上下文中的一个 bean，可以被其他 bean 通过依赖注入的方式使用。
Spring bean 生命周期
donghao_1009的博客
12-10 640
springbean生命周期
初学React-Native——Component 生命周期
xxx_19942的博客
01-19 406
我们先来看看Component的定义，这是React的基础组件，我感觉这个就和flutter的Widget相似，但是因为我才接触RN如果差距很大的话，我后面补一篇文章详细谈谈。 // Base component for plain JS classes interface Component<P = {}, S = {}, SS = any> extends ComponentLifecycle<P, S, SS> { } 那么Component的生命周期管理我们就看看Com
React component生命周期详解
banban008的博客
08-19 1093
目录什么是react component通过函数定义的component通过class定义的componentreact component的生命周期Mounting(挂载时)Updating(更新时)Unmounting(卸载时)Error Handling错误处理常见的生命周期方法constructor()render()componentDidMount()componentDidUpdate()componentWillUnmount()例子-计时器参考 阅读前需要具备下面两个知识点 props
Component 组件的详细说明和生命周期
热门推荐
梦家之家
03-28 2万+
组件的详细说明和生命周期（Component Specs and Lifecycle） Edit on GitHub 组件的详细说明（Component Specifications） 当通过调用 React.createClass() 来创建组件的时候，你应该提供一个包含 render 方法的对象，并且也可以包含其它的在这里描述的生命周期方法。 render
微信小程序：带component后的生命周期
PBitW的博客
03-23 1872
浅入生命周期 前几天，菜鸟写完了component组件（有兴趣可以自己看我的文章微信小程序：你必须知道的component自定义组件），然后感觉这组件进去了，那生命周期如何？ 这次就不拖泥带水了 component代码： Component({ created:function () { console.log("land created") }, attached:fun...
Dagger2 Scope 注解如何保证依赖在 component 生命周期内的单例性？
heng615975867的专栏
06-04 790
本文是 Piasy 原创https://blog.piasy.com/2016/04/11/Dagger2-Scope-Instance/Dagger2 已经在项目中用了一年多了，之前曾看到过一篇文章，里面说 Scope 注解可以保证依赖在每个 component 生命周期内的单例性，即局部单例。但上周一天和同事一起看生成的 injector 代码，却并未发现这一点是怎么做到的，于是得出“单例性需...
spring生命周期和bean生命周期
10-25
Spring 生命周期和 Bean 生命周期是密切相关的。在 Spring 容器中，每个 Bean 都有一个完整的生命周期，即从实例化、依赖注入，到销毁的过程，Spring 容器为我们管理了这些过程。Bean 生命周期包括 Bean 的创建、初始化、使用和销毁。具体来说，Spring 生命周期包括以下阶段： 1.实例化 Bean：容器根据配置文件或注解等方式创建 Bean 的实例。 2.设置 Bean 的属性值：容器会将 Bean 的属性值注入到 Bean 中，这是 Bean 生命周期的第二个阶段。Spring 提供了两种常用方式来实现 Bean 的属性注入：构造函数注入和 Setter 方法注入。 3.调用 Bean 的初始化方法：在 Bean 的所有属性被设置之后，Spring 容器会调用 Bean 的初始化方法，这个方法可以是自定义的方法，也可以是 Spring 提供的初始化方法。 4.使用 Bean：在 Bean 初始化完成之后，Spring 容器会将 Bean 注入到需要使用它的地方，比如其他 Bean 或者 Controller 等。 5.销毁 Bean：当 Bean 不再需要时，Spring 容器会调用 Bean 的销毁方法，这个方法可以是自定义的方法，也可以是 Spring 提供的销毁方法。 Bean 生命周期是 Spring 生命周期的一部分，它描述了一个 Bean 在 Spring 容器中的生命周期。Bean 生命周期包括以下阶段： 1.实例化 Bean：容器根据配置文件或注解等方式创建 Bean 的实例。 2.设置 Bean 的属性值：容器会将 Bean 的属性值注入到 Bean 中，这是 Bean 生命周期的第二个阶段。Spring 提供了两种常用方式来实现 Bean 的属性注入：构造函数注入和 Setter 方法注入。 3.调用 Bean 的初始化方法：在 Bean 的所有属性被设置之后，Spring 容器会调用 Bean 的初始化方法，这个方法可以是自定义的方法，也可以是 Spring 提供的初始化方法。 4.使用 Bean：在 Bean 初始化完成之后，Spring 容器会将 Bean 注入到需要使用它的地方，比如其他 Bean 或者 Controller 等。 5.销毁 Bean：当 Bean 不再需要时，Spring 容器会调用 Bean 的销毁方法，这个方法可以是自定义的方法，也可以是 Spring 提供的销毁方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值