Introduction détaillée à la classe BeanDefinition du code source Spring

Le contenu de cet article est une introduction détaillée à la classe BeanDefinition du code source de Spring. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

La version Spring est la 5.1.5

Tous ceux qui ont utilisé Spring savent que nous injectons des objets dans le conteneur Spring et laissons Spring le gérer pour nous. Ce type d'objet est appelé objet bean. Mais sous quelle forme ces objets haricots existent-ils dans le conteneur Spring, et quels attributs et comportements ont-ils ? Aujourd'hui, nous entrons dans le code source du printemps pour le découvrir.

L'usine de création du bean BeanFactory a une classe d'implémentation par défaut DefaultListableBeanFactory, qui contient une carte qui stocke toutes les informations sur les objets du bean injectés

/** Map of bean definition objects, keyed by bean name. */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

L'objet de valeur de la carte BeanDefinition est la définition du bean au printemps et la description , l'aperçu spécifique est le suivant :

属性	行为	解释
parentName	String getParentName(); void setParentName(@Nullable String parentName);	bean定义对象的父类定义对象名称
beanClassName	String getBeanClassName(); void setBeanClassName(@Nullable String beanClassName);	bean对象的实际class类
scope	String getScope(); void setScope(@Nullable String scope);	bean对象是否为单例
lazyInit	boolean isLazyInit(); void setLazyInit(boolean lazyInit);	是否懒加载
dependsOn	String[] getDependsOn(); void setDependsOn(@Nullable String... dependsOn);	设置依赖的bean对象，被依赖的bean对象总是会比当前bean对象先创建
autowireCandidate	boolean isAutowireCandidate(); void setAutowireCandidate(boolean autowireCandidate);	设置是否可以自动注入。只对@Autowired注解有效，配置文件中可以通过property显示注入
primary	boolean isPrimary(); void setPrimary(boolean primary);	配置bean为主要候选bean。当同一个接口的多个实现类或者一个类多次注入到spring容器时，通过该属性来配置某个bean为主候选bean，通过类型来注入时，默认为使用主候选bean注入
factoryBeanName	String getFactoryBeanName(); void setFactoryBeanName(@Nullable String factoryBeanName);	设置创建bean的工厂名称
factoryMethodName	String getFactoryMethodName(); void setFactoryMethodName(@Nullable String factoryMethodName);	设置创建bean的工厂中，创建bean的具体方法
initMethodName	String getInitMethodName(); void setInitMethodName(@Nullable String initMethodName);	设置创建bean时，默认初始化的方法
destroyMethodName	String getDestroyMethodName(); void setDestroyMethodName(@Nullable String destroyMethodName);	设置销毁bean时调用的方法名称。注意需要调用context的close()方法才会调用
role	int getRole(); void setRole(int role);	设置bean的分类
description	String getDescription(); void setDescription(@Nullable String description);	对bean对象的描述

Remarque : BeanDefinition est une interface qui ne définit que certains comportements de base de l'objet bean en interne. Les propriétés du tableau ci-dessus n'existent pas réellement dans BeanDefinition, elles sont uniquement définies et obtenues via les méthodes set et get. Une partie du code source de BeanDefinition est extraite ci-dessous pour la perception de chacun

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
    /**
     * Override the target scope of this bean, specifying a new scope name.
     * @see #SCOPE_SINGLETON
     * @see #SCOPE_PROTOTYPE
     */
    void setScope(@Nullable String scope);

    /**
     * Return the name of the current target scope for this bean,
     * or {@code null} if not known yet.
     */
    @Nullable
    String getScope();
}

Utilisation réelle

Supposons qu'il existe les deux beans suivants et que le code Java est le suivant

MyTestBean

package com.yuanweiquan.learn.bean;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Description;

public class MyTestBean {
    @Autowired
    private AutowireCandidateBean autowireCandidateBean;

    public void init() {
        System.out.println("inti MyTestBean");
    }

    public AutowireCandidateBean getAutowireCandidateBean() {
        return autowireCandidateBean;
    }
    public void setAutowireCandidateBean(AutowireCandidateBean bean) {
        this.autowireCandidateBean = bean;
    }
}

AutowireCandidateBean

package com.yuanweiquan.learn.bean;

public class AutowireCandidateBean {
    public void initBean() {
        System.out.println("init AutowireCandidateBean");
    }

    public void destroyBean() {
        System.out.println("destroy AutowireCandidateBean");
    }
}

Voyons comment le configurer dans le fichier de configuration applicationContext.xml

   <bean id="myTestBean" class="com.yuanweiquan.learn.bean.MyTestBean" 
         depends-on="autowireCandidateBean" 
         init-method="init"/>
         
   <bean id="autowireCandidateBean" 
         class="com.yuanweiquan.learn.bean.AutowireCandidateBean"
         init-method="initBean"
         autowire-candidate="true"
         destroy-method="destroyBean"
         scope="singleton"
         parent="myTestBean"
         lazy-init="default"
         primary="true">
      <description>autowireCandidateBean description</description>
   </bean>

La prochaine étape est le code de test

FileSystemXmlApplicationContext factory = 
        new FileSystemXmlApplicationContext("classpath:applicationContext.xml");
BeanDefinition myTestBeanDefinition = 
        factory.getBeanFactory().getBeanDefinition("autowireCandidateBean");
//输出
System.out.println("bean description:" + myTestBeanDefinition.getDescription());
System.out.println("bean class name:" + myTestBeanDefinition.getBeanClassName());
System.out.println("parent name:" + myTestBeanDefinition.getParentName());
System.out.println("scope:" + myTestBeanDefinition.getScope());
System.out.println("is lazyinit:" + myTestBeanDefinition.isLazyInit());
System.out.println("depends On:" + myTestBeanDefinition.getDependsOn());
System.out.println("is autowireCandidate:" + myTestBeanDefinition.isAutowireCandidate());
System.out.println("is primary:" + myTestBeanDefinition.isPrimary());
System.out.println("factory bean name:"+myTestBeanDefinition.getFactoryBeanName());
System.out.println("factory bean method name:" + myTestBeanDefinition.getFactoryMethodName());
System.out.println("init method name:" + myTestBeanDefinition.getInitMethodName());
System.out.println("destory method name:" + myTestBeanDefinition.getDestroyMethodName());
System.out.println("role:" + myTestBeanDefinition.getRole());
//关闭context，否则不会调用bean的销毁方法
factory.close();

Contrôle La sortie de la station est la suivante

init AutowireCandidateBean
inti MyTestBean
bean description:autowireCandidateBean description
bean class name:com.yuanweiquan.learn.bean.AutowireCandidateBean
parent name:myTestBean
scope:singleton
is lazyinit:false
depends On:null
is autowireCandidate:true
is primary:true
factory bean name:null
factory bean method name:null
init method name:initBean
destory method name:destroyBean
role:0
destroy AutowireCandidateBean

Jusqu'à présent, grâce aux informations ci-dessus, nous pouvons voir clairement les valeurs correspondant à chaque attribut. Le but du code de test ci-dessus est de nous permettre à tous de voir sous quelle forme le bean existe dans le conteneur Spring, quels attributs spécifiques il possède, quelle est sa valeur et quelle est sa valeur par défaut. Cela peut être considéré comme une révélation préliminaire des haricots dans le conteneur de printemps. En fait, ce n’est pas aussi mystérieux qu’on l’imaginait.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!