Heim >Java >javaLernprogramm >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(); }
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!