이 기사는 Spring IOC 컨테이너의 종속성 주입 원칙에 대한 간단한 토론을 소개하고 다음과 같이 공유합니다.
IOC 컨테이너를 초기화하는 주요 작업은 IOC 컨테이너에 Beandefinition 데이터 맵을 설정하는 것입니다. IOC 컨테이너가 Bean 의존성 관계를 주입하는 것을 보지 못했습니다.
현재 IOC 컨테이너가 사용자 정의 BEAN 정보를로드했다고 가정하면 종속성 주입은 주로 두 단계로 발생합니다.
정상적인 상황에서는 사용자가 IOC 컨테이너에서 처음으로 콩을 요청하면 트리거됩니다.
그러나 Beandefinition 정보의 게으른 속성 속성을 제어하여 컨테이너가 Bean을 사전 인스팅 할 수 있도록 할 수 있습니다.
1. Getbean에 의해 트리거 된 의존성 주입
기본 IOC 컨테이너 인터페이스 BeanFactory에는 GetBean에 대한 인터페이스 정의가 있습니다. 이 인터페이스의 구현은 트리거 의존성 주입이 발생하는 곳입니다. 종속성 주입 과정을 더 이해하기 위해 GetBean의 구현을 살펴보기 위해 DefaultListableBeanFactory의 기본 클래스 AbstractBeanFactory부터 시작합니다.
// getBean 인터페이스 메소드와 같은 BeanFactory 인터페이스의 구현이 있습니다. // 이러한 getBean 인터페이스 메소드는 dogetBean @override public object getBean (String Name)을 호출하여 궁극적으로 구현됩니다. a Beansexception {return dogetBean (이름, null, null, false); } @override public <t> t getBean (문자열 이름, 클래스 <t> requesstype)은 beansexception {return dogetBean (이름, 필수 유형, null, false); . } public <t> t getBean (문자열 이름, 클래스 <T> 필수 유형, 객체 ... args)은 beansexception {return dogetBean (이름, requesstype, args, false); } // 이것은 콩이 실제로 얻어지는 곳, 즉 종속성 주입이 @suppresswarnings ( "확인되지 않은") 보호 된 <t> t dogetbean (최종 문자열 이름, 최종 클래스 <T> 필수 유형, 최종 오브젝트 [] args, 부울 타자 Xception {final String beanname = transtinmedbeanname (name); 물체 콩; // 수동으로 등록 된 싱글 톤에 대한 싱글 톤 캐시를 간절히 확인하십시오. // 수동으로 등록 된 싱글 톤에 대한 싱글 톤 캐시를 간절히 확인하십시오. // 수동 등록 싱글 톤에 대한 싱글 톤 캐시를 간절히 점검하십시오. // 캐시에서 콩을 먼저 가져와 생성 된 싱글 톤 콩을 처리하십시오. 객체 sharedInstance = getsingleton (beanname)을 반복적으로 생성하지 마십시오. if (sharedInstance! = null && args == null) {if (logger.isdebugenabled ()) {if (issingletoncurrentyIncreation (beanname)) {logger.debug ( "싱글 톤 Bean '" + beanname + "' ' + beaname +"' ') } else {logger.debug ( "싱글 톤 Bean의 캐시 된 인스턴스를 반환" " + beanname +" ""); }} // 여기에서 getObjectforBeanInstance는 FactoryBean의 관련 처리를 얻기 위해 FactoryBean의 관련 처리를 완료합니다. Beanfactory와 FactoryBean의 차이점은 앞에서 언급되었습니다. 이 프로세스는 나중에 자세히 분석됩니다. = getObjectForBeanInstance (sharedInstance, name, beanname, null); } else {// 이미이 Bean 인스턴스를 만들고 있다면 실패합니다. // 우리는 원형 참조 내에서 가정됩니다. if (isprotoTypeCurrentyIncreation (beanname)) {새 beancurrentyIncreationException (beanname); } // // IOC 컨테이너의 beandefinition이 존재하는지 확인하십시오. 현재 공장에 존재하지 않는 경우, 부모의 BeanFactory 체인을 따르고 Beanfactory ParentBeanFactory = getParentBeanFactory ()를 위쪽으로보십시오. if (parentbeanfactory! = null &&! containsbeandefinition (beanname)) {// 찾을 수 없음 -> 부모를 확인하십시오. String nametolookup = OriginalBeanName (이름); if (args! = null) {// 명백한 args가있는 부모에게 위임됩니다. return (t) parentbeanfactory.getBean (nametolookup, args); } else {// args 없음 -> 표준 getbean 메소드를 대표합니다. ParentBeanFactory.getBean (nametolookup, requesstype)을 반환합니다. }} if (! typecheckonly) {MarkBeanAscreated (beanname); } try {// beandefinition 최종 rootbeandefinition mbd = getMergedLocalBeanDefinition (beanname); CheckmergedBeendefinition (MBD, Beanname, Args); // 현재 콩이 의존하는 콩의 초기화를 보장합니다. // 현재 콩이 (있는 경우) string [] fextson = mbd.getDependson ()에 의존하는 모든 콩을 재귀 적으로 얻습니다. if (sextentson! = null) {for (string dep : depentson) {if (isdependent (beaname, dep)) {throw new beancreationException (mbd.getResourcedEscription (), "" " + beanname +"와 ' " + dep +" ") 사이의 관계에 따라 관계가 있습니다. } registerDependentBean (dep, beanname); getbean (dep); }} // (mbd.issingleton ()) {sharedInstance = getSingleton (beanname, new objectFactory <object> () {@override public object getObject () {return reakebean (beanname, mbd, args) {exexemence ex) 싱글 톤 캐시 : 원형 참조 해상도를 허용하기 위해서는 콩에 대한 일시적인 참조를 허용한다. bean = getObjectForBeanInstance (sharedInstance, name, beanname, mbd); } // 이것은 프로토 타입 Bean을 만들기위한 장소입니다. if (mbd.isprototype ()) {// 프로토 타입입니다 -> 새 인스턴스를 만듭니다. Object PrototypeInstance = null; {prefrotoTypeCreceation (beanname)을 시도하십시오. Prototypeinstance = CreateBean (Beanname, MBD, Args); } 마침내 {후 프로토 타입이 생성 (BeanName); } bean = getObjectForBeanInstance (PrototypeInstance, name, beanname, mbd); } else {String scopename = mbd.getScope (); 최종 범위 범위 = this.scopes.get (scopename); if (scope == null) {throw new new ElegalStateException ( "스코프 이름에 등록되지 않은 스코프 없음 '" + ScoPename + "'"); } try {object scopedInstance = scope.get (beanname, new ObjectFactory <botort> () {@override public object (getObject ()는 beansexception {prectoTypeCreation (beanname); retud createbean (beanname, mbd, args); {afterPrototyPecrcrcr (beanname);}); bean = getObjectForBeanInstance (scopedinstance, name, beanname, mbd); } catch (불법 스테이트 exception ex) {Throw New BeancreationException (Beaname, "Scope '" + Scopename + "' '는 현재 스레드에 대해 활성화되지 않으며,이 Bean에 대한 스코프 프록시 정의를 고려하십시오. }}} catch (beansexception ex) {cleanupfterbeancreationfailure (beanname); ex 던지기; }} // 필요한 유형이 실제 Bean 인스턴스 유형과 일치하는지 확인합니다. // 유형 확인은 여기에서 생성 된 콩에서 수행됩니다. 문제가 없으면 새로 생성 된 콩이 반환됩니다. 이 콩은 이미 (requirettype! = null && bean! = null &&! requirettype.isassignablefrom (bean.getClass ()))를 포함하는 의존성을 포함하는 Bean입니다. } catch (typemismatchException ex) {if (logger.isdebugenabled ()) {logger.debug ( "bean '" + name + "' '' + name +" '' + classutils.getqualifiedName (requiLifiedName) + " ', ex); } 새 beannotofrequiredtypeexception 던지기 (name, requesstype, bean.getClass ()); }} return (t) bean; }의존성 주입이 여기에서 트리거됩니다. 의존성 주입은 컨테이너의 beandefinition 데이터가 설정되었을 때 발생합니다. 우리는 IOC 컨테이너를 가장 간단한 방식으로 설명 할 수 있지만, 즉 해시 맵으로 취급 할 수 있지만,이 해시 맵은 전체 IOC 컨테이너가 아닌 컨테이너의 가장 기본적인 데이터 구조라고 만 말할 수 있습니다.
이 종속성 주입 프로세스는 아래에 자세히 설명됩니다. 그림 1.1은 의존성 주입의 일반적인 과정을 보여줍니다.
그림 1.1 종속성 주입 과정
GetBean은 의존성 주입의 시작점입니다. 그 후, AbstractAutoweRecapableBeanFactory의 CreateBean은 필요한 콩을 생성하도록 호출되며 Beandefinition, Bean Post-Processor 등에서 Init-Method 속성 정의 구현과 같은 Bean 초기화도 처리됩니다. 다음은 CreateBean 코드를 통해이 프로세스를 이해하는 것입니다.
@Override Protected Object CreateBean (String BeanName, RootBeanDefinition MBD, Object [] args)는 BeancreationException {if (logger.isdebugenabled ()) {logger.debug ( "Bean '" " + Beanname +" ""); } rootBeanDefinition MBDTOUSE = MBD; //이 시점에서 Bean 클래스가 실제로 해결되었는지 확인하고 // 공유 병합 Bean 정의에 저장할 수없는 동적으로 해결 된 클래스의 경우 Bean 정의를 복제하십시오. // 여기서 우리는 생성 될 콩을 인스턴스화 할 수 있는지,이 클래스를 클래스 로더 클래스 <?> resolvedClass = resolveBeanClass (mbd, beanname)를 통해로드 할 수 있는지 여부; if (resolvedClass! = null &&! mbd.hasbeanclass () && mbd.getBeanClassName ()! = null) {mbdTouse = new RootBeanDefinition (mbd); MBDTOUSE.SETBEANCLASS (RESOLVEDCLASS); } // 메소드 재정의 준비. try {mbdtouse.preparemethodoverrides (); } catch (beanDefinitionValidationException ex) {wrach new beandefinitionStoreException (mbdTouse.getResourcedEscription (), BeanName, "메소드 유효성 유효성 실패", 예); } try {// BeanPostProcessors에게 대상 Bean 인스턴스 대신 프록시를 반환 할 수있는 기회를 제공합니다. // Bean에 후 처리기가 구성된 경우 반환 된 프록시 객체 Bean = ResolveBeforeInstantiation (Beanname, MBDTouse); if (bean! = null) {return bean; }} catch (Throwable ex) {Throw New BeancreationException (mbdtouse.getResourcedEscription (), BeanName, "Bean의 인스턴스화 전 BeanPostProcessor", ex); } try {object beaninstance = docreatebean (beanname, mbdtouse, args); if (logger.isdebugenabled ()) {logger.debug ( "Bean의 인스턴스 작성" " + Beanname +" ' "); } return beaninstance; } catch (beancreationException ex) {// 이미 적절한 Bean Creation Context에서 이전에 감지 된 예외 ... Throw Ex; } catch (commistryAppearedSeletOnexception ex) {// 불법 스테이트 exception을 기본값으로 전달할 수 있습니다. } catch (Throwable ex) {Throw New BeancreationException (mbdtouse.getResourcedEscription (), "Bean Creation 동안 예기치 않은 예외", ex); }} // docreate 옆에 콩이 어떻게 생성되는지 확인하기 위해 보호 대상 Docreatebean (최종 문자열 Beaname, Final RootBeendefinition MBD, Final Object [] args) {// 콩을 인스턴스화합니다. // 생성 된 Bean 객체를 고정하는 데 사용됩니다 BeanWrapper instanceWrapper = null; // 싱글 톤 인 경우 먼저 (mbd.issingleton ()) {instanceWrapper = this.ctoryBeanInstanceCache.Remove (beanname); } // 이것은 Bean을 만들기위한 장소이며, CreateBeanInstance if (instanceWrapper == null) {// 다음과 같은 해당 전략을 사용하여 지정된 Bean을 기반으로 새 인스턴스를 만듭니다. } final Object bean = (instanceWrapper! = null? instanceWrapper.getWrapedInstance () : null); class <?> beantype = (instanceWrapper! = null? instanceWrapper.getWrapedClass () : null); // 후 처리기가 병합 된 Bean 정의를 수정하도록 허용합니다. Synchronized (MBD.PostProcessingLock) {if (! mbd.postprocessed = true; }} // 싱글 레틀 톤은 원형 참조를 해결할 수 있도록 싱글 톤을 열렬히 캐시합니다. // 미리 노출해야합니까 : Singleton & Sectlic의 종속성을 허용하고 현재 콩이 생성되고 있으며, 순환 종속성을 감지하고 부울 EarlySingletonexposure = (mbd.issingleton () && this.allowcircularReferences && issingletoncurrenty -sincreation (beanname)); if (earlysingletonexposure) {if (logger.isdebugenabled ()) {logger.debug ( "잠재적 인 원형 참조를 해결하기 위해 Bean '" + Beanname + "' '); } // 후기 사이클 종속성을 피하기 위해 BEAN 초기화가 완료되기 전에 인스턴스를 생성하는 객체 기능을 공장에 추가 할 수 있습니다. AddSingleTonfactory (beanname, new objectory <bood>> () {@override public object getObject ()는 beansexception {// 콩에 대한 의존 콩에 의존합니다. getearlybeanReference (Beanname, MBD, Bean); } // bean 인스턴스를 초기화합니다. // 이것은 콩의 초기화이며, 종속성 주입이 종종 여기에서 발생합니다. 초기화가 처리 된 후 콩으로 돌아 오는이 노출 된이 노출 후회가 후회합니다. 물체 ExposedObject = Bean; {// bean을 넣고 각 속성 값을 주입하십시오. 그중에는 다른 콩에 의존하는 속성이있을 수 있으며, 종속성 Bean은 재귀 적으로 포환 된 바닥 (Beanname, MBD, instanceWrapper)이 초기화됩니다. if (exposedObject! = null) {// 초기화 메소드를 호출, 예 : init-method exposedObject = initializebean (beanname, ExposedObject, mbd); }} catch (trashable ex) {if (ex instanceof beancreationException && beanname.equals (((beancreationException))) .getBeanName ())) {strow (beancreationException) ex; } else {Throw New BeanCreationException (mbd.getResourcedEscription (), BeanName, "Bean 실패 초기화", ex); }} if (earlysingletonexposure) {개체 earlysingletonreference = getsingleton (beanname, false); // 초기 징글 론적 회의는 원형 의존성이 (EarlySingleTonReference! = null)을 감지하는 경우에만 비어 있지 않습니다. {if (ExposedObject == Bean) {// 초기화 메소드에서 ExposedObject가 변경되지 않으면 ExposedObject = EarlySingleTonReference가 향상되지 않습니다. } else if (! this. this.hallowRawinjectionDespiteWrapping && hasdependentBean (beanname)) {string [] fexendentBeans = getDependentBeans (beanname); <string> realdependentbeans = new LinkedHashset <string> (fexendbeans.length); for (string dependentBean : dependentBeans) {// Detection Dependency (! REMOVESINGLETONIFCREATEDFORECECKONLY (fexenDENBEAN)) {realDependentBeans.Add (fectionentBean); }} // 콩이 생성 된 후에 의존하는 콩이 생성되어야하기 때문에, 실제 의존적 비난은 비어 있지 않기 때문에, 현재 콩이 생성 된 후에 의존하는 콩이 생성되지 않았다는 것을 의미합니다. 다른 콩 [Collection.collectiontocommadelimitedString (실제 의존적 비정기) + "는 원형 참조의 일부로," + "는" + "콩의 최종 버전을 사용하지 않는다는 것을 의미합니다. 예를 들어 꺼짐. "); }}}}}} // Bean을 일회용으로 등록하십시오. 시도 {// SCOPE RegisterDisposableBeanIfNecessary (BeanName, Bean, MBD)를 기반으로 Register Bean; } catch (beanDefinitionValidationException ex) {Throw New BeanCreationException (mbd.getResourcedEscription (), "Invalid Destruction Signature", ex); } return ExposedObject; }의존성 주입에는 실제로 두 가지 주요 프로세스가 포함됩니다
위에서부터 의존성 주입과 특히 밀접한 관련이있는 방법에는
Beaninstance를 작성하십시오
콩에 포함 된 자바 물체를 생성합니다
Populebean.
다양한 Bean 객체의 특성을 처리하는 프로세스 처리 (즉, 종속성 처리 프로세스)
CreateBeanInstance 소스 코드를 먼저 살펴 보겠습니다.
/** * 적절한 인스턴스 전략을 사용하여 지정된 Bean의 새 인스턴스를 만듭니다. * 공장 방법, 생성자 자동화 또는 간단한 인스턴스. * @param beanname Bean의 이름 * @param mbd bean에 대한 Bean 정의 * @param args 생성자 또는 공장 메소드 호출에 사용하기위한 명시 적 인수 * @return 새 인스턴스에 대한 콩나무 awprapper */ protected beanwrapper createBeanInstance (String beanname, rootbeandefinition mbd, object [] {// ehl classe가 실제로 Point and this point and this point been this this point in this point ad // 생성하려는 Bean 인스턴스의 클래스가 인스턴스화 클래스 <?> beanclass = resolveBeanClass (mbd, beanname) 일 수 있는지 확인합니다. if (beanclass! = null &&! modifier.ispublic (beanclass.getModifiers ()) &&! mbd.isnonPublicAccessallowed ()) {Throw New BeancreationException (mbd.getResourcedEscription (), Beanname, "Bean Class가 공개적이지 않으며, + 콩류 액세스가 허용되지 않는다"); } supplier <?> instancesUpplier = mbd.getInstancesUpplier (); if (instancesUpplier! = null) {return acefromsUpplier (InstancesUpplier, beanname); } // 팩토리 메소드가 비어 있지 않은 경우 공장 메소드 전략을 사용하여 Bean을 인스턴스화하면 (MBD.GETFACTORYMETHODNAME ()! = NULL) {return instantiateUsingFactoryMethod (BeanName, MBD, Args); } // 같은 콩을 재창조 할 때 바로 가기 ... 부울 해결 = false; 부울 autowirenecessary = false; if (args == null) { synchronized (mbd.constructorArgumentLock) { // A class has multiple constructors, each constructor has different parameters, so before calling, you need to lock the constructor or the corresponding factory method according to the parameters if (mbd.resolvedConstructorOrFactoryMethod != null) { resolved = true; autowirenecessary = mbd.constructorargumentsResolved; }}} // 구문 분석 된 경우 (resolved) {if (autowirenecessary) {// autowereconstructor (beanname, mbd, null, null)를 자동으로 주입합니다. } else {// 생성자 InstantiateBean (Beanname, MBD)에 기본 생성자를 사용한 생성자; }} // 생성자를 결정해야합니다. if (ctors! = null || mbd.getResolvedaUtowiremode () == rootbeanDefinition.autowire_constructor || mbd.hasconstructorArgumentValues () ||! isoverutils.isempty (args)) {return autoweReconstructor (beanname, mbd, ctors, arg); } // 특수 취급 없음 : 간단히 ARG 생성자를 사용하십시오. // 기본 생성자를 사용하여 Bean을 인스턴스화합니다. } /*** 기본 생성자를 사용하여 주어진 Bean을 인스턴스화합니다. * @param beanname Bean의 이름 * @param mbd bean의 bean 정의 * @return 새 인스턴스의 콩 wrapper * // 가장 일반적인 Instantiatebean Protected BeanWrapper InstantiateBean (최종 문자열 Beanname, Final RootbeanDefinition MBD) {// 기본 인스턴티션 전략을 사용하여 Bean을 인스턴스화합니다. 기본 인스턴스화 전략은 // cglibsubclassinginstantiationtrategy, 즉 cglib를 사용하여 Bean을 인스턴스화합니다. {object beaninstance; 최종 Beanfactory Parent = this; if (system.getSecurityManager ()! = null) {BeanInstance = accessController.Doprivileged (new PrivilegedAction <botorge> () {@override public 객체 run () {return getInstantivationstrategy (). Instantiate (mbd, beaname, parent);}}); } else {beaninstance = getInstantiationStrategy (). Instantiate (MBD, BeanName, Parent); } beanwrapper bw = new BeanWrapperImpl (BeanInstance); InitbeanWrapper (BW); 반품 bw; } catch (Throwable ex) {Throw New BeancreationException (mbd.getResourcedEscription (), BeanName, "Bean 실패의 인스턴스화", ex); }}CGLIB는 여기에서 콩을 인스턴스화하는 데 사용됩니다. CGLIB는 바이트 코드 생성기를위한 클래스 라이브러리로, Java 바이트 코드를 생성하고 변환하는 기능을 제공하기위한 일련의 API를 제공합니다.
Spring Aop에서 CGLIB는 Java Bytecode를 향상시키는 데 사용됩니다. IOC 컨테이너에서 CGLIB를 사용하여 Bean 객체를 생성하는 방법을 이해하려면 SimpleInstantiationStrategy 클래스를 살펴 봐야합니다. Spring에서 Bean 객체를 생성하는 데 사용되는 기본 클래스입니다. 콩 물체를 인스턴스화하는 두 가지 방법을 제공합니다.
공개 클래스 SimpleInstantiationStrategy는 InstantiationStrategy {@override public Object Instantiate (rootBeanDefinition BD, String BeanName, BeanFactory 소유자) {// 재정의가없는 경우 CGLIB로 클래스를 비난하지 않습니다. if (bd.getMethodoverrides (). isempty ()) {// 여기에서 지정된 생성자 또는 팩토리 메소드를 얻을 수있는 beanconstructor <?> constructortouse; 동기화 (bd.constructorargumentlock) {constructortouse = (생성기 <?>) bd.resolvedConstructorOcorFactoryMethod; if (constructortouse == null) {Final Class <?> clazz = bd.getBeanClass (); if (clazz.isinterface ()) {Throw New BeanStantiationException (Clazz, "지정된 클래스는 인터페이스입니다"); } try {if (system.getSecurityManager ()! = null) {constructOrouse = accessController.Doprivileged (new PrivilegedExceptionAction <constructor <? >> () {@override public constructor <?> run () rows exception {return clazz.getDeclaredConstructor (class [])); } else {constructorTouse = clazz.getDeclaredConstructor ((class []) null); } bd.ResolvedConstructorOrorToryMethod = ConstructOrouse; } catch (Throwable ex) {Throw New BeanStantiationException (Clazz, "Default Constructor Found 없음", Ex); }}} // beanutils를 통해 인스턴스. 이 beanutils의 인스턴스화는 생성자를 통해 콩을 인스턴스화합니다. Beanutils에서는 특정 호출 ctor.newinstance (args) return beanutils.instantiateclass (constructortouse)를 볼 수 있습니다. } else {// 객체를 Instantiate instantiateWithmethodinjection (bd, beanname, 소유자); }}}콩 간의 종속성 처리
의존성 처리에 대한 입력은 위에서 언급 한 Populebean 방법입니다. 너무 많은 측면이 관련되어 있으므로 여기에 코드를 게시하지 않습니다. 의존성 처리 과정에 대한 간단한 소개 : Populebean 방법,
먼저 BeanDefinition에서 속성 값을 설정 한 다음 종속성 주입 프로세스를 시작하십시오.
먼저, Autowire 주입을 바이로 또는 이형으로 처리 한 다음 속성을 주입합니다.
그런 다음 Bean 참조를 구문 분석해야합니다. 관리자, Manageset, Managemap 등을 구문 분석 한 후에 의존성 주입 조건이 준비되었습니다. 이곳은 실제로 Bean 객체를 다른 Bean 속성으로 설정하는 곳이며, 처리 된 특성은 다양합니다.
종속성 주입은 BeanWrapper의 SetPropertyValues에서 발생하지만 특정 완료는 BeanWrapper 서브 클래스 BeanWrapperImpl에서 구현됩니다. 배열 주입, 목록과 같은 수집 클래스의 주입 및 수집 등급 주입을 포함하여 Bean의 특성 값 주입을 완료합니다.
일련의 주사 후, 다양한 Bean 특성의 의존성 주입 공정이 완료됩니다.
콩과 물체 의존성 주입 과정에서 의존성 주입은 콩 정화의 정보에 따라 재귀 적으로 완료되어야합니다.
이전 재귀 프로세스에서, 우리는 이러한 재귀가 모두 Getbean과 휴대용임을 알 수 있습니다.
재귀는 필요한 콩을 찾아 컨텍스트 시스템에서 콩에 대한 재귀 호출을 만드는 것입니다.
또 다른 재귀는 의존성 주입 중에 컨테이너의 getbean 방법을 재귀 적으로 호출하여 현재 Bean의 종속성 Bean을 얻고 의존성 Bean의 생성 및 주입을 트리거하는 것입니다.
Bean의 특성에 대한 의존성 주입을 수행 할 때, 구문 분석 프로세스도 재귀 과정입니다. 이러한 방식으로, 의존성에 따라, 콩의 생성 및 주입은 현재 콩의 생성이 마침내 완성 될 때까지 층에 의해 층으로 완성된다. 이 최상위 Bean의 생성과 속성 의존성 주입의 완료를 통해 현재 Bean과 관련된 전체 의존성 체인의 주입 솔루션이 완료됨을 의미합니다.
Bean 생성 및 의존성 주입이 완료된 후, 의존성으로 연결된 일련의 콩이 IOC 컨테이너에 설정됩니다. 이 콩은 더 이상 간단한 자바 물체가 아닙니다. Bean 시리즈와 Bean 사이의 종속성 관계가 설정된 후, IOC의 관련 인터페이스 방법을 통해 상위 레벨 애플리케이션에 매우 편리하게 사용할 수 있습니다.
2. 게으른 속성 속성과 사전 인스턴스
이전의 새로 고침 방법에서는 Lazy-Init로 구성된 Bean을 처리하기 위해 FinishBeanCactoryInitialization이 호출된다는 것을 알 수 있습니다.
실제로이 방법에서는 게으른 이니트 속성의 처리가 캡슐화되고 실제 처리는 DefaultListableBeanFactory의 기본 컨테이너의 사전 입체 조정 방법에서 수행됩니다. 이 방법은 사전 인스턴스 싱글 톤 콩을 완성하며,이 사전 인스턴스 완료는 컨테이너에 영리하게 위임되어 구현됩니다. 사전 인스턴스가 필요한 경우 여기에서 GetBean이 의존성 주입을 트리거하는 데 사용됩니다. 정상 의존성 주입 트리거와 비교하여 트리거링 시간과 경우는 다릅니다. 여기서, 의존성 주입은 컨테이너의 새로 고침 프로세스 중, 즉 IOC 컨테이너 초기화 프로세스 중에 일반 의존성 주입과 달리, 컨테이너가 GetBean을 통해 IOC 컨테이너를 초기화 한 후 처음으로 Bean을 요청할 때 IOC 컨테이너 초기화 프로세스 중에 발생합니다.
위는이 기사의 모든 내용입니다. 모든 사람의 학습에 도움이되기를 바랍니다. 모든 사람이 wulin.com을 더 지원하기를 바랍니다.