Detaillierte Einführung in die BeanDefinition-Klasse des Spring-Quellcodes

Der Inhalt dieses Artikels ist eine detaillierte Einführung in die BeanDefinition-Klasse des Spring-Quellcodes. Ich hoffe, dass er für Freunde hilfreich ist.

Spring-Version ist 5.1.5

Jeder, der Spring verwendet hat, weiß, dass wir Objekte in den Spring-Container injizieren und den Spring für uns verwalten lassen. Diese Art von Objekt wird als Bean-Objekt bezeichnet. Aber in welcher Form existieren diese Bean-Objekte im Spring-Container und welche Attribute und Verhaltensweisen haben sie? Heute geben wir den Spring-Quellcode ein, um das herauszufinden.

Beans Erstellungsfabrik BeanFactory verfügt über eine Standardimplementierungsklasse DefaultListableBeanFactory, die eine Map enthält, die alle injizierten Bean-Objektinformationen speichert

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

Map-Wertobjekt BeanDefinition ist die Definition und Beschreibung von Beans im Frühling Die spezifische Übersicht lautet wie folgt:

属性	行为	解释
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对象的描述

Hinweis: BeanDefinition ist eine Schnittstelle, die nur einige grundlegende Verhaltensweisen des Bean-Objekts intern definiert. Die Eigenschaften in der obigen Tabelle sind in der BeanDefinition nicht tatsächlich vorhanden, sie werden nur über die Methoden set und get festgelegt und abgerufen. Ein Teil des BeanDefinition-Quellcodes wird unten für jedermanns Verständnis extrahiert

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();
}

Tatsächliche Verwendung

Angenommen, es gibt die folgenden zwei Beans, der Java-Code lautet wie folgt

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");
    }
}

Sehen wir uns an, wie man es in der Konfigurationsdatei applicationContext.xml konfiguriert

   <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>

Der nächste Schritt ist der Testcode

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();

Die Konsolenausgabe ist wie folgt

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

Bisher können wir anhand der obigen Informationen klar erkennen, welche Werte jedem Attribut entsprechen. Der Zweck des obigen Testcodes besteht darin, uns allen zu ermöglichen, zu sehen, welche Form die Bean im Spring-Container hat, welche spezifischen Attribute sie hat, welchen Wert sie hat und welchen Standardwert sie hat. Es kann als eine vorläufige Enthüllung der Bohnen im Frühlingsbehälter betrachtet werden. Tatsächlich ist es nicht so mysteriös, wie wir es uns vorgestellt haben.

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in die BeanDefinition-Klasse des Spring-Quellcodes. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!