首页 > 其他分享 >【重写SpringFramework】第一章beans模块：Bean的初始化（chapter 1-8）

【重写SpringFramework】第一章beans模块：Bean的初始化（chapter 1-8）

时间：2024-06-19 22:31:18浏览次数：19  
标签：chapter 初始化 Object bean 接口 Bean SpringFramework 方法 public

1.前言

前边我们介绍了创建实例和填充对象的流程，这是整个创建流程最重要的工作。有时候用户需要对 Bean 进行自定义的操作，这一过程称为初始化。此外，还有一些比较特殊的对象，本身管理着一定的资源，当对象销毁时需要释放这些资源，因此我们还需要相应的销毁操作。初始化和销毁操作统称为 Bean 的生命周期，这些操作的自主程度很高，具体实现取决于开发人员的需求。本节主要讨论 Bean 的初始化，至于销毁工作将在下一节介绍。

2. 初始化方式

2.1 概述

Spring 提供了三种方式来处理初始化操作，简单介绍如下：

  1. 实现 InitlizeBean 接口
  2. 在方法上声明 @PostConstruct 注解，该注解是由 JDK 提供的
  3. 设置 AbstractBeanDefinition 类的 initMethodName 属性

从执行顺序上来说，注解 > 接口 > 自定义方法。从适用情况上来说，三种方式有细微的差别。接口主要用于 Spring 框架内部，继承情况一目了然，方便管理。注解主要是用户使用，看重的是便捷性。自定义方法主要用于整合第三方框架的组件，一般来说，这些组件不会使用 Spring 提供的接口或 JDK 的注解，因此需要指定具体的初始化或销毁方法。

2.2 InitializingBean

InitializingBean 接口定义了初始化的方法，任何实现该接口的对象都将执行 afterPropertiesSet 方法。这种情况不需要额外的组件来处理，只需要使用 instanceof 关键字进行判断即可。

public interface InitializingBean {
    void afterPropertiesSet() throws Exception;
}

2.3 注解声明

@PostConstruct 注解仅起到标识的作用，具体工作是由 InitDestroyAnnotationBeanPostProcessor 组件完成的。

public class Foo {

    @PostConstruct
    public void init() {}
}

BeanPostProcessor 接口本身定义了初始化操作，DestructionAwareBeanPostProcessor 作为子接口定义销毁操作。本节不介绍该接口，仅作为继承结构中的一环。InitDestroyAnnotationBeanPostProcessor 实现了 DestructionAwareBeanPostProcessor 接口，同时拥有初始化和销毁操作的功能，负责处理注解声明的方法。其中initAnnotationType 字段表示初始化方法的注解，destroyAnnotationType 字段表示销毁方法的注解，默认的构造方法指定了注解类。

public class InitDestroyAnnotationBeanPostProcessor implements DestructionAwareBeanPostProcessor, PriorityOrdered {
    private Class<? extends Annotation> initAnnotationType;
    private Class<? extends Annotation> destroyAnnotationType;
    private transient final Map<Class<?>, LifecycleMetadata> lifecycleMetadataCache = new ConcurrentHashMap<>(256);

    public InitDestroyAnnotationBeanPostProcessor() {
        this.initAnnotationType = PostConstruct.class;
        this.destroyAnnotationType = PreDestroy.class;
    }
}

该类的逻辑与 AutowiredAnnotationBeanPostProcessor 类似，都是通过元数据进行处理。内部类 LifecycleMetadata 表示一个类的初始化和销毁信息，LifecycleElement 表示一个初始化或销毁方法。

private class LifecycleMetadata{
    private final Collection<LifecycleElement> initMethods;     //init方法集合
    private final Collection<LifecycleElement> destroyMethods;  //destroy方法集合
}

private static class LifecycleElement {
    private final Method method;
}

2.4 自定义初始化方法

一般来说，Spring 对于同一功能提供两种解决方案。一种是编程式的，另一种是声明式的，正如 InitializingBean 接口和 @PostConstruct 注解。那么什么情况下需要使用自定义的初始化方法？实际上 Spring 内部用于处理特殊情况，比如 XML 文件中 bean 标签的 init-method 属性，以及 @Bean 注解的 initMethod 属性。

如下所示，在 Spring 的配置文件中，使用 bean 标签来加载对象，此时可以通过 init-method 属性指定初始化方法。

<?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="foo" class="cn.stimd.spring.Foo" init-method="customInit"></bean>
</beans>

还有就是配置类中的工厂方法，声明 @Bean 注解并指定 initMethod 属性。工厂方法的作用与 Spring 配置文件中的 bean 标签是一样的，表现形式不同而已。

@Configuration
public class XxxConfig {

    @Bean(initMethod="customInit")
    public Foo foo() {
        return new Foo();
    }
}

注：本教程不实现 XML 方式的任何功能，一律使用声明注解的方式来代替。因此，我们不介绍 Spring 配置文件的具体实现，至于配置类的内容将在第三章 context 模块进行介绍。

3.初始化流程

3.1 概述

回到 AbstractAutowireCapableBeanFactory 的 doCreateBean 方法，第四步执行了初始化流程。

//所属类[cn.stimd.spring.beans.factory.support.AbstractAutowireCapableBeanFactory]
//创建对象
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) {
    //1. Bean的实例化（略）
    //2. 提前暴露Bean解决循环依赖（TODO）
    //3. 属性填充（略）

    //4. 初始化
    Object exposedObject = initializeBean(beanName, exposedObject, mbd);
    //5. 注册需要destroy方法的Bean（TODO）
    return exposedObject;
}

initializeBean 方法一共分为四步，简单介绍如下：

  1. 处理感知接口
  2. 通过 BeanPostProcessor 完成初始化前的处理
  3. 处理实现了 InitlizeBean 接口的对象
  4. 通过 BeanPostProcessor 完成初始化后的处理
//所属类[cn.stimd.spring.beans.factory.support.AbstractAutowireCapableBeanFactory]
//初始化
protected Object initializeBean(String beanName, final Object bean, RootBeanDefinition mbd) {
    //1. 调用Aware接口
    invokeAwareMethods(bean);

    //2. 调用PostProcessor在Bean初始化之前进行处理（比如InitDestroyAnnotationBeanPostProcessor处理使用@PostConstruct的初始化方法）
    Object wrappedBean = bean;
    if (!mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    //3. 调用初始化方法
    invokeInitMethods(wrappedBean, mbd);

    //4. 调用PostProcessor在Bean初始化之后进行处理（比如AbstractAutoProxyCreator创建代理对象）
    if (!mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    return wrappedBean;
}

3.2 Aware 感知接口

Aware 是一个标记接口，本身没有定义任何方法。Aware 接口的作用是标记一个类对指定类型感兴趣，Spring 容器将对应的组件赋给目标对象。感知接口注入的组件一般是 Spring 框架内置的，比如 BeanFactoryAware 负责注入 BeanFactory。后续我们还会讲到 ApplicationContext、ResourceLoader、Enviroment、ServletContext 等组件以及对应的感知接口，它们都是 Spring 框架自带的。

//标记接口
public interface Aware {}

public interface BeanFactoryAware extends Aware {
    //注入BeanFactory
    void setBeanFactory(BeanFactory beanFactory);
}

回到 Bean 的初始化流程，invokeAwareMethods 方法的实现较为简单，判断实例是否实现了某个感知接口，然后调用对应的回调方法即可。

//所属类[cn.stimd.spring.beans.factory.support.AbstractAutowireCapableBeanFactory]
//回调感知接口
private void invokeAwareMethods(Object bean) {
    if(bean instanceof Aware){
        //注入BeanFactory
        if(bean instanceof BeanFactoryAware){
            ((BeanFactoryAware) bean).setBeanFactory(this);
        }
    }
}

3.3 初始化前操作

applyBeanPostProcessorsBeforeInitialization 方法负责初始化之前的一些操作，调用 BeanPostProcessor 接口的 postProcessBeforeInitialization 方法。典型应用是InitDestroyAnnotationBeanPostProcessor 组件处理声明了 @PostConstruct 注解的初始化方法。

//所属类[cn.stimd.spring.beans.factory.support.AbstractAutowireCapableBeanFactory]
private Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) {
    Object result = existingBean;
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        //执行初始化前的操作
        Object current = processor.postProcessBeforeInitialization(result, beanName);
        if(current == null){
            return result;
        }
        result = current;
    }
    return result;
}

InitDestroyAnnotationBeanPostProcessor 的处理过程与 AutowiredAnnotationBeanPostProcessor 类似，这里省略了具体的实现过程，详情参考代码。大致的逻辑是，以反射的方式遍历当前对象，寻找声明了 @PostConstruct 或 @PreDestroy 注解的方法，并添加到元数据的缓存中，最后通过反射的方式调用所有的初始化方法。

3.4 初始化操作

invokeInitMethods 方法定义了两种初始化的方式。一是实现 InitializingBean 接口，并调用 afterPropertiesSet 回调方法。二是自定义的初始化方法，方法名保存在 AbstractBeanDefinition 的 initMethodName 属性中。

//所属类[cn.stimd.spring.beans.factory.support.AbstractAutowireCapableBeanFactory]
private void invokeInitMethods(final Object bean, RootBeanDefinition mbd) throws Exception {
    //如果是InitializingBean，调用初始化方法（主要是框架内部使用，检查各项属性是否设置成功，否则抛出异常，中止容器的创建过程）
    if(bean instanceof InitializingBean){
        ((InitializingBean) bean).afterPropertiesSet();
    }

    //调用自定义初始化方法，比如Xml或@Bean的initMethod属性指定的方法
    if(mbd != null){
        String initMethodName = mbd.getInitMethodName();
        if(initMethodName != null && !"afterPropertiesSet".equals(initMethodName)){
            Method initMethod = BeanUtils.findMethod(bean.getClass(), initMethodName);
            if(initMethod != null){
                ReflectionUtils.makeAccessible(initMethod);
                initMethod.invoke(bean);
            }
        }
    }
}

3.5 初始化后操作

BeanPostProcessor 接口的 postProcessAfterInitialization 方法用于在 Bean 初始化之后的一些操作，最典型的应用是创建代理对象。此时实例已经创建完毕，依赖注入和初始化的工作也都完成了，可以说是万事俱备，正是创建代理对象的最佳时机。（有关代理的部分将在第二章 aop 模块中介绍，此处不深入讨论）

//所属类[cn.stimd.spring.beans.factory.support.AbstractAutowireCapableBeanFactory]
private Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) {
    Object result = existingBean;
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        //执行初始化后的操作
        Object current = processor.postProcessAfterInitialization(result, beanName);
        if(current == null){
            return result;
        }
        result = current;
    }
    return result;
}

4. 扩展

4.1 所有单例实例化

初始化的操作都是在 getBean 方法中执行的，getBean 方法的使用场景有两个，一是在依赖注入时由容器自动调用，二是用户在代码中手动调用。现在的问题是，如何保证所有的单例都被创建？要知道并不是所有的单例都是依赖项，也不能指望由用户完成这一工作，因此 Spring 框架必须提供一个解决方案。ConfigurableBeanFactory 接口定义了 preInstantiateSingletons 方法，用于实例化所有的单例 Bean。

public interface ConfigurableBeanFactory  {
    void preInstantiateSingletons();
}

DefaultListableBeanFactory 实现了该方法。所有的单例在创建之前都以 BeanDefinition 的形式缓存起来了，因此只需要遍历 beanDefinitionNames，依次调用 getBean 方法即可。

public class DefaultListableBeanFactory {
    //BeanDefinition名称
    private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

    @Override
    public void preInstantiateSingletons() {
        //实例化所有非懒加载的单例Bean
        List<String> beanNames = new ArrayList<>(beanDefinitionNames);
        for(String beanName : beanNames){
            RootBeanDefinition bd = getMergedBeanDefinition(beanName);
            if(bd.isSingleton() && !bd.isLazyInit()){
                getBean(beanName);
            }
        }

        //所有单例Bean实例化后，触发SmartInitializingSingleton回调
        for (String beanName : beanNames) {
            Object singletonInstance = getSingleton(beanName);
            if (singletonInstance instanceof SmartInitializingSingleton) {
                ((SmartInitializingSingleton) singletonInstance).afterSingletonsInstantiated();
            }
        }
    }
}

4.2 SmartInitializingSingleton 接口

preInstantiateSingletons 方法在确保所有的单例实例化之后，还执行了 SmartInitializingSingleton 接口的相关操作。SmartInitializingSingleton 接口的作用是什么？我们先来看源码中的定义：

This interface can be implemented by singleton beans in order to perform some initialization after the regular singleton instantiation algorithm, avoiding side effects with accidental early initialization.

该接口可以被单例实现，在常规的单例实例化流程结束之后进行一些操作，避免了提前初始化可能产生的副作用。

当我们在初始化时进行某些操作时，并不能保证所有的单例都已经创建完成了。如果调用了 getBeansOfType 这种涉及全部单例的方法，可能会使得某些单例提前实例化，从而导致不可预知的结果，这便是所谓的副作用。如果需要对所有单例进行操作，可以实现 SmartInitializingSingleton 接口。此时所有的单例都已创建，也不会产生副作用了。我们在上一节介绍依赖注入时，分析了为什么要避免提前实例化，可见 Spring 在原则性问题上保持一贯的立场。

5. 测试

5.1 初始化操作

测试类 MyInitBean 实现了三种初始化方式，init 方法声明注解，afterPropertiesSet 方法实现接口，customInit 是自定义的初始化方法。

//测试类：实现了三种方式的初始化
public class MyInitBean implements InitializingBean {

    @PostConstruct
    private void init(){
        System.out.println("初始化 PostConstruct...");
    }

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

    public void customInit(){
        System.out.println("初始化 customInit...");
    }
}

测试方法比较简单，需要注意三点。一是向 BeanFactory 添加 InitDestroyAnnotationBeanPostProcessor 组件来处理 @PostConstruct 注解。二是创建 RootBeanDefinition 对象后，调用 setInitMethodName 方法指定初始化方法的名称。三是调用 preInstantiateSingletons 方法确保所有单例都被创建，取代了调用 getBean 方法。

//测试方法
@Test
public void testInitMethod(){
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    //添加InitDestroyAnnotationBeanPostProcessor来处理@PostConstruct注解
    factory.addBeanPostProcessor(new InitDestroyAnnotationBeanPostProcessor());

    RootBeanDefinition definition = new RootBeanDefinition(MyInitBean.class);
    //设置自定义初始化方法
    definition.setInitMethodName("customInit");
    factory.registerBeanDefinition("initBean", definition);

    //确保所有单例实例化
    factory.preInstantiateSingletons();
}

从测试结果中可以看到，不同初始化方式的执行顺序。先是注解声明的方法，然后是接口方法，最后是自定义的初始化方法。

初始化 @PostConstruct 注解方法...
初始化 InitializingBean 接口方法...
初始化自定义 init 方法...

5.2 代理对象

测试类 SimpleProxy 实现了 InvocationHandler 接口，说明这是 JDK 动态代理。target 字段表示目标对象。getProxy 方法的作用是创建 JDK 代理对象。invoke 方法在执行代理对象的任何方法时均会触发，这里打印日志模拟拦截操作，然后调用目标对象的方法。

//测试类：动态代理简单实现
public class SimpleProxy implements InvocationHandler {
    private Object target;

    public SimpleProxy(Object target) {
        this.target = target;
    }

    //创建JDK代理对象
    public Object getProxy() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //模拟拦截逻辑
        System.out.println("代理拦截：目标对象 [" + this.target.getClass().getName() + "], 方法名 [" + method.getName() + "]");
        //调用目标对象的方法
        return method.invoke(target, args);
    }
}

测试类 SimpleProxyPostProcessor 实现了 InstantiationAwareBeanPostProcessor 接口，postProcessAfterInitialization 方法的作用是在对象初始化后创建代理对象。

//测试类：创建SimpleProxy代理对象
public class SimpleProxyPostProcessor implements InstantiationAwareBeanPostProcessor {
    private Set<String> cache = new HashSet<>();

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (!this.cache.contains(beanName)) {
            System.out.println("初始化后创建代理对象");
            //返回代理对象，而非原始对象
            return createProxy(bean);
        }
        return bean;
    }

    private Object createProxy(Object bean) {
        if (bean instanceof ITarget) {
            return new SimpleProxy(bean).getProxy();
        }
        return bean;
    }
}

由于我们使用的是 JDK 动态代理，需要定义一个接口，然后让测试类 TargetBean 实现该接口。

//测试类：用于创建代理的接口
public interface ITarget {
    void handle();
}

//测试类：用于创建代理的实现类
public class TargetBean implements ITarget{

    public void handle() {
        System.out.println("执行handle方法...");
    }
}

在测试方法中，需要注意两点。其一，将 SimpleProxyPostProcessor 组件注册到 Spring 容器中。其二，获取对象是必须是接口类型，如果指定 TargetBean 将报错，这是因为此时的 Bean 是一个代理。

//测试方法
@Test
public void testCreateProxy() {
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    factory.addBeanPostProcessor(new SimpleProxyPostProcessor());
    factory.registerBeanDefinition("target", new RootBeanDefinition(TargetBean.class));

    ITarget target = factory.getBean("target", ITarget.class);
    target.handle();
    System.out.println("Bean的实际类型：" + target.getClass().getName());
}

从测试结果可以看到，在执行 handle 方法时，先执行了 SimpleProxy 的拦截逻辑。对象的实际类型为 com.sun.proxy.$Proxy5，说明代理对象创建成功。

初始化后创建代理对象[target]
代理拦截：目标对象 [beans.lifecycle.TargetBean], 方法名 [handle]
执行handle方法...
Bean的实际类型：com.sun.proxy.$Proxy5

6. 总结

本节介绍了 Bean 的初始化流程，包括三种实现方式，分别是实现接口、声明注解、以及指定自定义方法。这三种方式没有本质区别，只是在调用顺序上有先后之分。整个初始化流程分为四个部分，如下所示：

  • 感知接口注入：回调 Aware 接口的相关方法，为当前对象注入感兴趣的组件。
  • 初始化前操作：回调 BeanPostProcessor 接口的 postProcessBeforeInitialization 方法，比如处理声明了 @PostConstruct 注解的初始化方法。
  • 初始化操作：包括两方面，一是调用 InitializingBean 接口的初始化方法，二是调用自定义的初始化方法。
  • 初始化后操作：回调 BeanPostProcessor 接口的 postProcessAfterInitialization 方法，最典型的应用是创建代理对象。

在这里插入图片描述

除此之外，在容器的创建过程中，还有两个与初始化相关的流程。一是确保所有单例都被实例化，这一点由 ConfigurableBeanFactory 接口的 preInstantiateSingletons 方法来实现。二是 SmartInitializingSingleton 接口，作用是在全部的单例创建完毕后执行某些操作，这一机制有效避免了提前实例化可能产生的副作用。

7. 项目信息

新增修改一览，新增（12），修改（4）。

beans
└─ src
   ├─ main
   │  └─ java
   │     └─ cn.stimd.spring.beans
   │        └─ factory
   │           ├─ annotation
   │           │  ├─ AutowiredAnnotationBeanPostProcessor.java (*)
   │           │  └─ InitDestroyAnnotationBeanPostProcessor.java (+)
   │           ├─ config
   │           │  ├─ ConfigurableBeanFactory.java (*)
   │           │  └─ DestructionAwareBeanPostProcessor.java (+)
   │           ├─ support
   │           │  ├─ AbstractAutowireCapableBeanFactory.java (*)
   │           │  └─ DefaultListableBeanFactory.java (*)
   │           ├─ Aware.java (+)
   │           ├─ BeanFactoryAware.java (+)
   │           ├─ InitializingBean.java (+)
   │           └─ SmartInitializingSingleton.java (+)
   └─ test
      └─ java
         └─ beans
            └─ lifecycle
               ├─ ITarget.java (+)
               ├─ LifecycleTest.java (+)
               ├─ MyInitBean.java (+)
               ├─ SimpleProxy.java (+)
               ├─ SimpleProxyPostProcessor.java (+)
               └─ TargetBean.java (+)

注：+号表示新增、*表示修改

  • 项目地址：https://gitee.com/stimd/spring-wheel

  • 本节分支：https://gitee.com/stimd/spring-wheel/tree/chapter1-8

注：项目的 master 分支会跟随教程的进度不断更新，如果想查看某一节的代码，请选择对应小节的分支代码。

关注公众号【Java编程探微】，加群一起讨论。
在这里插入图片描述

标签：chapter,初始化,Object,bean,接口,Bean,SpringFramework,方法,public
From： https://blog.csdn.net/Stimd/article/details/139683836

相关文章

  • Spring容器系列-FactoryBean使用/原理
    Spring-FactoryBean使用/原理  概要  在某些情况下，实例化Bean过程比较复杂，若按照传统的方式，则需要在中提供大量的配置信息，不够灵活，这时采用编码的方式能得到一个简单的方案。  Spring为此提供了一个org.springframework.bean.factory.FactoryBean的工厂类接口，用户......
  • 【Spring】Bean管理
    获取Bean要从IOC容器当中来获取到bean对象，需要先拿到IOC容器对象@AutowiredprivateApplicationContextapplicationContext;//IOC容器对象Spring容器中提供了一些方法，可以主动从IOC容器中获取到bean对象，下面介绍3种常用方式：根据name获取beanObjectgetBean(Stringna......
  • 2024-06-17-Spring 源码阅读（三）Bean 的生命周期
    由于Spring源码非常多，博客中贴源码会占用大量篇幅，阅读困难。详细分析部分会以commit提交形式关联源码提交，画图例来说明源码整体逻辑。Bean生命周期主体逻辑相关代码：Bean的基本创建流程、lazyInit、循环依赖Bean对象创建基本流程通过最开始的关键时机点分析，我们知道Bean......
  • Spring容器系列-bean的生命周期
    Spring容器系列-bean的生命周期  bean的生命周期从调用beanFactory的getBean开始，到这个bean被销毁，可以总结为以下七个阶段：  1. 处理名称，检查缓存  2.处理父子容器  3.处理dependsOn  4.选择scope策略  5.创建bean  6.类型转......
  • Bean生命周期
    目录一、bean生命周期基本流程二、流程细节1、初始化方法和销毁方法1）自定义式：2）接口式3）声明式4）执行顺序2、InstantiationAwareBeanPostProcessor实例化后置处理器2、BeanPostProcessor初始化后置处理器3、xxxAware接口三、总结执行流程一、bean生命周期基本流程......
  • Spring中Bean的实例化过程
    AbstractAutowireCapableBeanFactory.doCreateBean方法一、调用createBeanInstance方法中会获取容器中所有的BeanPostProcessor对象，并进行循环筛选出来自于SmartInstantiationAwareBeanPostProcessor接口的实现类，并调用实现类的determineCandidateConstructors方法获取到有@......
  • Spring中Bean的初始化创建AbastractApplicationContext.FinishBeanFactoryInitializat
    AbastractApplicationContext.FinishBeanFactoryInitialization模版调用子类DefaultListableBeanFacotry.preInstantiateSingletons通过循环子类DefaultListableBeanFactory中收集到的所有beanDefinitionNames，对满足条件的Bean进行初始化，getBean操作会调用父类AbstractBean......
  • Spring中GenericBeanDefinition属性
    1.id再Spring容器中作为Bean的唯一标识2.name用于为id属性创建一个或多个别名，用空格、逗号分开3.classBean的类名，全限定名primary多个相同Bean再容器中的优先级5.parent标注该Bean的父类Bean，继承父类Bean的所有属性6.abstract标注Bean是否是抽象的，一般用于父类Bean。......
  • jmeter中beanshell处理器
    Jmeter工具中存在BeanShell取样器，BeanShell预处理程序，BeanShell后置处理程序，那么这次详细整理下BeanShell在JMeter的作用以及案例。beanshell是什么：BeanShell是一个小型嵌入式Java源代码解释器，能够动态地执行java代码，不需要提前编译JMeter在它的BeanShell中内置了变量，用户......
  • Spring系统学习 - Bean的作用域
    bean作用域介绍Spring框架提供了不同的作用域来管理Bean的生命周期和可见性，这对于控制不同类型的组件和处理并发请求尤其重要。singleton（默认）：每个SpringIoC容器只有一个bean实例。当容器创建bean后，它会被缓存起来，后续请求将返回同一个实例。这是默认的作用域，适用于无状......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99