spring生命周期步骤简要说明

最新推荐文章于 2024-03-22 11:53:57 发布
最新推荐文章于 2024-03-22 11:53:57 发布
阅读量191 收藏
点赞数
分类专栏： 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 1149
一、生命周期 Spring容器中的生命周期方法分为4类： Bean自身方法 Bean级生命周期接口方法 容器级生命周期接口方法 工厂级生命周期接口方法 1.1 Bean自身生命周期方法 Bean自身的方法： 构造函数实例化bean initMethod指定方法（指定某个方法在bean实例化完成，依赖关系结束后执行） destroyMethod指定方法（指定某个方法在bean销毁之前执行） 定义一个类： @Component public class XiaoChao { @Value("小超
Spring 注解版简单实例之影响生命周期的两个注解(三)
有 prepare , No out
07-03 1773
1 分别为@PostConstruct @PreDestroy 在UserService里面使用 @Component("userService") public class UserService { private UserDAO userDAO; @PostConstruct public void init() { System.out.println
第八节HarmonyOS @Component自定义组件的生命周期
yyxhzdm的博客
11-28 1718
页面：即应用的UI页面。可以由一个或者多个自定义组件组成，@Entry装饰的自定义组件为页面的入口组件，即页面的根节点，一个页面有且仅能有一个@Entry。只有被@Entry装饰的组件才可以调用页面的生命周期。：组件即将出现时回调该接口，具体时机为在创建自定义组件的新实例后，在执行其build()函数之前执行。、自定义组件：@Component装饰的UI单元，可以组合多个系统组件实现UI的复用。：在自定义组件即将析构销毁时执行。：当用户点击返回按钮时触发。：页面每次隐藏时触发一次。：页面每次显示时触发。
【Spring注解必知必会】深度解析@Component注解实现原理
m0_71777195的博客
08-16 5121
想必@Component注解大家一直在使用，只要类上加上它，就可以被Spring容器管理，那大家有想过它是怎么实现的吗？本篇文章就带领到家揭秘。用来标记的类是一个“组件”或者说是一个Bean，Spring会自动扫描标记@Component注解的类作为一个Spring Bean对象。@Indexed/***/}复制代码value: 自定义当前组件或者说bean的名称，可以不配置， 不配置的话默认为组件的首字母小写的类名。该注解只能使用在类，接口、枚举、其他注解上该注解的生命周期是运行时JVM。...
@Component注解的使用及解析
张三博客
09-28 7417
@Component 可作用于类、接口、枚举类型等 (Target) @Component 生命周期为运行时 (Retention) @Component 可以使用JavaDoc命令生成文档后查看说明 (Documented) @Component 该类会存储到 META-INF/spring.components (Indexed)
spring源码1
08-08
2. **Spring IOC**：Spring的IoC（Inversion of Control，控制反转）是其核心特性之一，它负责管理对象的生命周期和依赖关系。初始化通常从创建`ClassPathXmlApplicationContext`开始。 - 在创建`...
cxf 结合spring所需jar包
08-17
整合CXF和Spring的主要目的是利用Spring的IoC和AOP能力来管理CXF服务的生命周期和行为。以下是一些关键的整合步骤： 1. **创建CXF服务接口和实现**：定义一个Java接口，代表你的Web服务，并提供一个实现该接口的类...
struts2+hibernate+spring整合
11-20
它提供了一个容器（ApplicationContext），可以管理Bean的生命周期和依赖关系。Spring的DI（Dependency Injection）特性使得对象之间的依赖关系可以通过配置文件或注解来管理，增强了代码的可测试性和可维护性。...
简要SSH2项目
05-10
在这个项目中，Spring被用来管理对象的生命周期和依赖关系，同时也可能用于实现事务管理。Spring的IoC容器负责初始化、配置和组装应用程序中的对象，而AOP则用于编写横切关注点，如日志、事务处理等。 3. **...
微信小程序：页面Page和组件Component生命周期执行的先后顺序
彭世瑜的博客
10-14 5290
页面 // pages/test-page/test-page.js Page({ /** * 生命周期函数--监听页面加载 */ onLoad: function (options) { console.log('Page onLoad'); }, /** * 生命周期函数--监听页面初次渲染完成 */ onReady: function () { console.log('Page onReady'); }, /** * 生命
Vue快速入门---组件component、生命周期
weixin_50163576的博客
12-16 1089
组件component：可复用的 Vue 实例，且带有一个名字。（这个名字没有编程作用，一般用于调试代码使用，安装vue-devtool工具，在这个工具里面name才有用） 1）全局组件:在所有Vue实例里面都可以使用（当标签来用）。 Vue.component('组件名称建议短横线命名',{ // {}里面的选项和vue实例的选项是一样的 // data选项必须是一个函数 }) 2）局部组件:在定义该组件的Vue实例里面可以使用 new Vue({ componen
【spring】@Component注解学习
最新发布
一个写了10年bug的程序员日常笔记。
03-22 1945
Component 是 Spring 框架中的一个注解，用于将一个类标记为 Spring 上下文中的一个组件。当一个类被标记为 @Component 时，Spring 容器会在启动时自动扫描并实例化这个类，并将其注册到 Spring 上下文中。@Component 注解可以用于任何类，包括控制器、服务、DAO 等。当一个类被标记为 @Component 时，它就成为了 Spring 上下文中的一个 bean，可以被其他 bean 通过依赖注入的方式使用。
Spring bean 生命周期
donghao_1009的博客
12-10 635
springbean生命周期
初学React-Native——Component 生命周期
xxx_19942的博客
01-19 403
我们先来看看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 1088
目录什么是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 1869
浅入生命周期 前几天，菜鸟写完了component组件（有兴趣可以自己看我的文章微信小程序：你必须知道的component自定义组件），然后感觉这组件进去了，那生命周期如何？ 这次就不拖泥带水了 component代码： Component({ created:function () { console.log("land created") }, attached:fun...
Dagger2 Scope 注解如何保证依赖在 component 生命周期内的单例性？
heng615975867的专栏
06-04 787
本文是 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 的创建、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值