Este artículo presenta una breve discusión sobre el principio de inyección de dependencia de los contenedores de Spring IOC, y lo comparte con usted, de la siguiente manera:
La tarea principal de inicializar el contenedor IOC es establecer un mapa de datos de beandefinition en el contenedor IOC. No vi el contenedor del COI inyectando la relación de dependencia del frijol.
Suponiendo que el contenedor del COI actual ha cargado información de frijol definida por el usuario, la inyección de dependencia ocurre principalmente en dos etapas.
En circunstancias normales, se activa cuando el usuario solicita un frijol del contenedor del COI por primera vez.
Sin embargo, podemos controlar el atributo de la INITA Lazy en la información de BeanDefinition para permitir que el contenedor se complete precipitado, es decir, el proceso de inyección de dependencia de ciertos frijoles se completa durante el proceso de inicialización.
1. Inyección de dependencia activada por GetBean
En la interfaz de contenedor BAY de CIECO BeanFactory, hay una definición de interfaz para GetBean. La implementación de esta interfaz es donde ocurre la inyección de dependencia del activador. Para comprender mejor el proceso de inyección de dependencia, comenzamos con la clase base AbstractBeanFactory de defaultListableBeanFactory para analizar la implementación de GetBean
// Aquí está la implementación de la interfaz de BeanFactory, como el método de la interfaz GetBean // estos métodos de interfaz GetBean se implementan en última instancia llamando a DogetBean @Override Public Object GetBean (nombre de cadena) arroja BeanSexception {return dogetBean (nombre, nulo, falso); } @Override public <T> t getBean (nombre de cadena, clase <t> requerido) lanza Beansexception {return dogetBean (name, requiredType, null, false); } @Override Public Object getBean (nombre de cadena, objeto ... args) arroja Beansexception {return dogetBean (nombre, nulo, args, falso); } public <t> t getBean (nombre de cadena, clase <T> requerido tytepe, objeto ... args) arroja beansexception {return dogetBean (nombre, requirirype, args, falso); } // Aquí es donde realmente se obtiene el bean, es decir, donde la inyección de dependencia se desencadena @suppleswarnings ("sin verificar") protegido <t> t dogetBean (nombre de cadena final, clase final <T> requerido, objeto final [], argumento boolean typechonly) tira beanSexception {final de cadena de beaneNe = transformedbeanName (nombre (nombre); Objeto frijol; // Consulte ansiosamente la caché de singleton para singletons registrados manualmente. // Consulte ansiosamente la caché de singleton para singletons registrados manualmente. // Revise ansiosamente Singleton Cache para un registro manual singletons // obtenga los frijoles del caché primero y procese los frijoles singleton que se han creado. No cree repetidamente objeto compartirinstance = getsingleton (beanName); if (SharedInstance! = NULL && args == null) {if (logger.isdeBugeNabled ()) {if (isSingLetIncurrentlyIncreation (beanName)) {logger.debug ("devolver ansiosamente la instancia de caché de bean '" + beanName + + "eso no está completamente inicializado, una consecuencia de una referencia circular"); "); } else {logger.debug ("Devuelve la instancia en caché de Singleton Bean" + BeanName + "'"); }} // El getObjectForBeanInstance aquí completa el procesamiento relevante de FactoryBean para obtener el procesamiento relevante de FactoryBean para obtener los resultados de producción de FactoryBean. La diferencia entre BeanFactory y FactoryBean se ha mencionado anteriormente. Este proceso se analizará en detalle más adelante. = getObjectForBeanInstance (SharedInstance, Name, BeanName, NULL); } else {// fall si ya estamos creando esta instancia de Bean: // se asume dentro de una referencia circular. if (isProTotyPecurrentlyIncreation (beanName)) {tirar nueva beanCurrentlyIncreationException (beanName); } // // Verifique si existe la beandefinition en el contenedor IOC. Si no existe en la fábrica actual, siga la cadena principal de BeanFactory y mira hacia arriba el beanfactory parentbeanFactory = getparentBeanFactory (); if (parentBeanFactory! = null &&! ContinsBeanDefinition (beanName)) {// no encontrado -> Verifique el padre. Cadena nametolookup = originalBeanName (nombre); if (args! = null) {// delegación al padre con args explícitos. return (t) parentBeanFactory.getBean (nametolookup, args); } else {// no args -> delegado al método GetBean estándar. return parentBeanFactory.getBean (nametolookup, requiredType); }} if (! typecheckonly) {markbeanascreated (beanName); } try {// Get Beandefinition final RootBeanDefinition mbd = getMergedLocalBeanDefinition (BeanName); checkmergedBeanDefinition (MBD, BeanName, Args); // Garantizar la inicialización de los frijoles de los que depende el frijol actual. // obtiene recursivamente todos los frijoles que el bean actual depende de (si alguna) cadena [] dependson = mbd.getdependson (); if (dependentson! = null) {for (string dep: dependson) {if (isdependent (beanName, dep)) {Throw New BeanCreationException (mbd.getResourcedescription (), beanName, "circular depende de la relación entre '" + beanName + "y" + dep + "" ""); } RegistroDependentBean (DEP, BeanName); getBean (DEP); }} // Crear instancia de singleton bean llamando al método createBean if (mbd.issingleton ()) {compartirinstance = getSingLeton (beanName, nuevo objectFactory <ject> () {@Override public getObject () lanza beanseSexception {try {return createBean (beanName, mbd);} getObject (beanexception ex) { / / / /returny create creeBean (beanName, Mbd);} De Singleton Cache: podría haber sido colocado allí // por el proceso de creación, para permitir la resolución de referencia circular bean = getObjectForBeanInstance (SharedInstance, Name, BeanName, MBD); } // Este es el lugar para crear un prototipo de frijol más if (mbd.isprototype ()) {// Es un prototipo -> crear una nueva instancia. Objeto prototypeInstance = null; intente {antes de la creación de behyprototypreation (beanName); PrototypeInstance = createBean (BeanName, MBD, Args); } Finalmente {AfterPrototyPecReation (BeanName); } bean = getObjectForBeanInstance (prototypeInstance, nombre, beanName, mbd); } else {string scopeName = mbd.getscope (); alcance final alcance = this.scopes.get (Scopename); if (scope == null) {lanzar nueva ilegalstateException ("no hay alcance registrado para el nombre del alcance '" + scopeName + "'"); } try {object scopedInstance = scope.get (beanName, new ObjectFactory <Sect> () {@Override Public Object getObject () lanza BeanseException {antes de antes de la placa (beanName); intente {return createBean (beanName, mbd, args);} finalmente {después bean = getObjectForBeanInstance (ScopedInstance, Name, BeanName, MBD); } Catch (ilegalStateException ex) {Throw New BeanCreationException (BeanName, "Scope" " + ScopeName +" 'no está activo para el hilo actual; considere " +" definiendo un proxy alcanzado para este bean si tiene la intención de referirse a él desde un singleton ", ex); }}} Catch (Beansexception ex) {CleanupafeRBeatCreationFailure (BeanName); tirar ex; }} // Verifique si el tipo requerido coincide con el tipo de la instancia de Bean real. // La comprobación de tipo se realiza en el frijol creado aquí. Si no hay problema, se devuelve el recién creado Bean. Este frijol ya es un frijol que contiene la dependencia if (requiredType! = Null && bean! = Null &&! RequireType.isassignableFrom (bean.getClass ())) {try {return getTypeConverter (). ConvertifNecessary (bean, requiredType); } catch (typemismatchException ex) {if (logger.isDebugeNabled ()) {logger.debug ("Falling to convertir '" + name + "' al tipo requerido '" + classUtilss.getQualifiedName (requiredType) + "", ex); } tirar new BeanNotOfRequiredTypeException (nombre, requiredType, bean.getClass ()); }} return (t) bean; }La inyección de dependencia se activa aquí. La inyección de dependencia ocurre cuando se han establecido los datos de BeanDefinition en el contenedor. Aunque podemos describir el contenedor del COI de la manera más simple, es decir, tratarlo como un hashmap, solo podemos decir que este hashmap es la estructura de datos más básica del contenedor, no todo el contenedor del COI.
Este proceso de inyección de dependencia se explicará en detalle a continuación. La Figura 1.1 muestra el proceso general de inyección de dependencia.
Figura 1.1 Proceso de inyección de dependencia
GetBean es el punto de partida de la inyección de dependencia. Después de eso, se llamará a la factura de creación en abstractAutOUTOWIRECAPABLE para producir los frijoles requeridos, y la inicialización de los bean también se procesa, como implementar la definición de atributo init-método en beandefinition, bean post-procesador, etc. Lo siguiente es comprender este proceso a través del código create behebean behebean.
@Override Protected Object createBean (String BeanName, rootBeanDefinition mbd, object [] args) arroja beanCreationException {if (logger.isDebugeNabled ()) {logger.debug ("Creación de instancia de bean '" + beanName + "'"); } RootbeanDefinition mbdTouse = mbd; // Asegúrese de que la clase de frijoles realmente se resuelva en este punto, y // clone la definición de frijoles en caso de una clase resuelta dinámicamente // que no se puede almacenar en la definición compartida de frijoles fusionados. // Aquí determinamos si el bean a crear se puede instanciar, si esta clase se puede cargar a través de la clase del cargador de clase <?> ResuelveClass = resolveBeanClass (MBD, beanName); if (resuelveClass! = null &&! mbd.hasbeanClass () && mbd.getBeanClassName ()! = null) {mbdTouse = new rootBeanDefinition (mbd); mbdTouse.SetBeanClass (resuelveClass); } // Preparar el método anula. intente {mbdTouse.PreparemethodoverRides (); } Catch (BeanDefinitionValidationException ex) {tire New BeandefinitionStoreException (MBDTouse.getResourceDescription (), BeanName, "Validación del método anulaciones fallidas", ex); } Try {// Dé a BeanPostProcessors la oportunidad de devolver un proxy en lugar de la instancia de Bean de destino. // Si el bean ha configurado el postprocesador, entonces el objeto proxy devuelto bean = resolveBeforeinstantiation (beanName, mbdTouse); if (bean! = null) {return bean; }} Catch (Throwable Ex) {Throw New BeanCreationException (mbdTouse.getResourcedescription (), BeanName, "BeanPostProcessor antes de la instancia de la instancia de Bean", ex); } try {object beanInstance = doCreateBean (beanName, mbdTouse, args); if (logger.isDebugeNabled ()) {logger.debug ("terminó creando instancia de bean '" + beanName + "'"); } return BeanInstance; } Catch (BeanCreationException ex) {// Una excepción previamente detectada con un contexto de creación de frijoles adecuado ya ... tirar ex; } Catch (implícitamente apagadosingletonexception ex) {// una explicación ilegal para ser comunicada hasta el incumplimiento de fausional } Catch (Throwable Ex) {Throw New BeanCreationException (mbdTouse.getResourceDescription (), BeanName, "Excepción inesperada durante la creación de frijoles", ex); }} // al lado de DoCreate para ver cómo los frijoles se generan objeto protegido DoCreateBean (Final String BeanName, Final RootBeanDefinition MBD, Objeto final [] args) {// Instanciar el bean. // se usa para mantener el objeto de bean creado beanwrapper instancewrapper = null; // Si es un singleton, primero borre el frijol del mismo nombre en la caché if (mbd.issingleton ()) {instancewrapper = this.FactoryBeanInstancecache.remove (beanName); } // Este es el lugar para crear el bean, y lo realiza createBeanInstance if (instancewrapper == null) {// crea una nueva instancia basada en la frijol especificada utilizando la estrategia correspondiente, como: método de fábrica, inyección automática de constructor, sencilla inicialización de instituciones = createBeanIninstance (BeanName, MBD); } final de objeto final = (instancewrapper! = null? instancewrapper.getwrappedInstance (): null); Clase <?> BeanType = (instancewrapper! = Null? Instancewrapper.getwrappedClass (): null); // Permitir que los postprocesadores modifiquen la definición de frijol fusionado. sincronizado (mbd.postprocessinglock) {if (! mbd.postprocessed) {applymergedBeanDefinitionPostProcessors (MBD, beanType, beanName); mbd.postprocessed = true; }} // Cache Singletons para poder resolver referencias circulares // incluso cuando se activan por interfaces de ciclo de vida como BeanFactoryaware. // ¿Es necesario exponer de antemano: Singleton & Permitir dependencias cíclicas y se está creando el bean actual, detectar dependencias cíclicas boolean tempranogletonexposure = (mbd.issingleton () && this. allowcircularReferences && issingletoncurrentCreation (beanName)); if (EarlySingletOnExPoure) {if (logger.isdeBugeNabled ()) {logger.debug ("cacharora de bean" + beanname + "'para permitir la resolución de posibles referencias circulares"); } // Para evitar las dependencias del ciclo tardío, laFactory de Object que crea una instancia se puede agregar a la fábrica antes de que se complete la inicialización de frijoles. AddSingLetOnFactory (BeanName, New ObjectFactory <SPET> () {@Override Public Object getObject () arroja beanSexception {// Reladita Rele getEarlyBeanReference (BeanName, MBD, Bean); } // Inicializa la instancia de Bean. // Esta es la inicialización del bean, y la inyección de dependencia a menudo ocurre aquí. Este objeto expuesto se arrepiente de haber regresado como Bean después de procesarse la inicialización. Objeto exposedobject = bean; Pruebe {// Pon el bean e inyecte cada valor de atributo. Entre ellos, puede haber atributos que dependen de otros frijoles, el bean de dependencia se inicializará recursivamente, la poca población (BeanName, MBD, InstanceWrapper); if (exposedObject! = null) {// llamando al método de inicialización, como init-method exposedObject = inicializeBean (beanName, exposedObject, mbd); }} Catch (Showable Ex) {if (ex instanceof BeanCreationException && beanName.equals ((((((( } else {Throw New BeanCreationException (mbd.getResourceDescription (), BeanName, "Inicialización de Bean falló", ex); }} if (EarlySingletOnExPosure) {Object EarlySingletonReference = GetSingLeton (BeanName, False); // EarlySingletOnreference no es vacía solo si se detecta una dependencia circular si (EarlySingletOnreference! = NULL) {if (exposedObject == Bean) {// Si exposedObject no se cambia en el método de inicialización, no se mejora expositedObject = EarlySingLetOnreferference; } else if (! this. allowrawinjectionDespitewrapping && hasDependentBean (beanName)) {string [] dependentBeans = getDependentBeans (beanName); Establecer <String> RealDependentBeans = new LinkedHashset <String> (dependenceBeans.length); para (String DependentBeans: DependentBeans) {// Detección Dependencia if (! RemoveSingLetOnifCreateDfortyPeCheckonly (dependiente)) {RealDependentBeanss.Add (dependiente); }} // Debido a que los frijoles de los que depende de después de que se cree el bean debe haberse creado, RealDependentBeans no está vacío, lo que significa que los frijoles de los que depende después de que se cree el bean actual no se ha creado, es decir, hay una dependencia circular if (! DependentBeanss.isEmpty ()) inyectado en otros frijoles [" + StringUtils.CollectionToCommadelimitedString (RealDependentBeans) +"] en su versión RAW como parte de una referencia circular, pero finalmente ha sido " +" envuelto en el tipo de frijoles. La bandera de 'YIfMageerInit' apagó, por ejemplo "); }}}}} // Registre el frijol como desechable. Pruebe {// Registre el bean basado en el alcance de registroDisponsableBeanifnecessary (BeanName, Bean, MBD); } Catch (beandefinitionValidationException ex) {tire nueva beancreationException (mbd.getResourcedescription (), beanName, "firma de destrucción inválida", ex); } return exposedObject; }La inyección de dependencia en realidad implica dos procesos principales
De lo anterior podemos ver que los métodos que están particularmente relacionados con la inyección de dependencia incluyen
createBeanInstance
Generar objetos Java contenidos en frijoles
PopulateBean.
Procesar el proceso de procesamiento de las propiedades de varios objetos de frijoles (es decir, el proceso de procesamiento de dependencia)
Echemos un vistazo al código fuente CREATEBEanInstance primero
/** * Cree una nueva instancia para el bean especificado, utilizando una estrategia de instancia apropiada: * Método de fábrica, autos de constructor o instancia simple. * @param beanName El nombre del bean * @param mbd La definición de bean para el bean * @param args args argumentos explícitos para usar para constructor o invocación de métodos de fábrica * @return un beanwrapper para la nueva instancia */ protegido beanwraper create createBeanInstance (string beanNeNeNeMeadBeanDeFinition Mbd, objeción [], objeto [] Args) {// // Argumento de Bean. // Confirma que la clase de la instancia de Bean que desea crear puede ser instanciada clase <?> beanclass = resolBeanClass (mbd, beanName); if (beanclass! = null &&! Modifier.ispublic (beanclass.getModifiers ()) &&! Mbd.isnonPublicAccessAllowed ()) {Throw New BeanCreationException (mbd.getResourceDescription (), "Bean Class no es pública y no pública no se permite el acceso público:" + beanclass.cetName ()); } Proveedor <?> InstancesUpplier = mbd.getInStancesUplier (); if (instancesUpplier! = null) {return obtainFromSupplier (instancesupplier, beanName); } // Si el método de fábrica no está vacío, use la estrategia del método de fábrica para instanciar el bean if (mbd.getFactoryMethodName ()! = Null) {return instantiateUsingFactoryMethod (beanName, mbd, args); } // atajo al recrear el mismo frijol ... boolean resuelto = false; boolean autowIrEnEcsary = false; if (args == null) {sincronizado (mbd.constructorArgumentLock) {// Una clase tiene múltiples constructores, cada constructor tiene diferentes parámetros, por lo que antes de llamar, debe bloquear el constructor o el método de fábrica correspondiente de acuerdo con los parámetros si (mbd.resolvedConstructororRetoryMethod! AUTOWIRECESSARY = MBD.ConstructorArGumentsResolved; }}} // Si se ha analizado, use el método de constructor analizado sin bloquear nuevamente si (resuelto) {if (autowIreneCessary) {// constructor inyecta automáticamente return AutoWIreconstructor (BeanName, MBD, NULL, NULL); } else {// constructor utilizando el constructor predeterminado para constructor instantiateBean (beanName, mbd); }} // necesita determinar el constructor ... // instanciar el bean usando el constructor constructor <?> [] ctors = determineconstructorsFrombeanPostProcessors (beanClass, beanName); if (ctors! = null || mbd.getResOlvedaUtewireMode () == rootBeanDefinition.aUtowire_constructor || mbd.hasconstructorArGumentValues () || objetuTils.isempty (args)) {return AutoWiConstructor (BeanName, MBD, CTORS, Args); } // Sin manejo especial: simplemente use el constructor no-arg. // instanciar el bean usando su constructor predeterminado; } /*** Instanciar el bean dado usando su constructor predeterminado. * @param beanName El nombre del bean * @param mbd La definición de frijol para el bean * @return un beanwrapper para la nueva instancia */// la instantánea más común protegida Beanwrapper InstantiateBean (Final String BeanName, RootBeanDefinition final MBD) {// La estrategia de instanciación predeterminada es // cglibsubclassinginstantiationstrategy, es decir, instanciar el bean usando cglib. intente {objeto beanInstance; Final BeanFactory Parent = this; if (system.getSecurityManager ()! = NULL) {beanInstance = AccessController.Doprivileged (new PrivilegEdaction <ject> () {@Override public Object run () {return getInstantiAtionStrateGy (). Instantiate (MBD, BeanName, Parent);}}, getaccessControlContextExt ()); } else {beanInstance = getInstantiationstrategy (). Instantiate (MBD, BeanName, Parent); } Beanwrapper bw = new BeanWrapperImpl (BeanInstance); InitBeanWrapper (BW); regresar BW; } Catch (Throwable Ex) {Throw New BeanCreationException (mbd.getResourceDescription (), BeanName, "Instanciación de bean fallido", ex); }}CGLIB se usa aquí para instanciar frijoles. CGLIB es una biblioteca de clases para generadores de bytecode, que proporciona una serie de API para proporcionar la función de generar y convertir Java Bytecode.
En Spring AOP, CGLIB también se usa para mejorar el bytecodo Java. En los contenedores del COI, para comprender cómo usar CGLIB para generar objetos de frijoles, debe observar la clase SimpleInstantiationstrategy. Es la clase predeterminada utilizada por Spring para generar objetos de frijoles. Proporciona dos métodos para instanciar objetos de frijoles.
clase pública SimpleInstantiationsTrategy implementa InstantiationsTrategy {@Override Public Object Instantiate (rootBeanDefinition bd, string beanName, beanFactory propietario) {// No anule la clase con cglib si no anule. if (bd.getMethodoverRides (). isEmpty ()) {// Aquí obtienes el constructor especificado o el método de fábrica para instanciar el beanConstructor <?> Constructortouse; sincronizado (bd.ConstructorAngumentLock) {constructiveSO = (constructor <?>) bd.resolvedConstructorOrFactoryMethod; if (constructiveuse == null) {clase final <?> clazz = bd.getBeanClass (); if (clazz.isinterface ()) {lanzar nueva beanInstantiationException (Clazz, "La clase especificada es una interfaz"); } try {if (System.getSecurityManager ()! = NULL) {constructiveuse = accessController.DoPrivileged (new PrivilegedExceptionAction <Constructor <? >> () {@Override Public Constructor <?> Run () Excepción {return Clazz.getDeclaredConstrucor ((class []) null);}};}}); } else {constructiveuse = clazz.getDeClaredConstructor ((class []) null); } bd.ResOlvedConstructorOrFactoryMethod = constructiveuse; } Catch (Throwable Ex) {Throw New BeanInstantiationException (Clazz, "No se encontró constructor predeterminado", ex); }}} // Instanciar a través de Beanutils. La instancia de este beanutils instancia al bean a través del constructor. En los beanutils, puede ver la llamada específica ctor.newinstance (args) return beanutil.instantiateclass (constructiveuse); } else {// instanciar el objeto return instantiatewithmethodinyection (bd, beanName, propietario); }}}Manejo de dependencias entre frijoles
La entrada al procesamiento de dependencia es el método PopulateBean mencionado anteriormente. Como hay demasiados aspectos involucrados, no publicaré el código aquí. Una breve introducción al proceso de procesamiento de dependencia: en el método de pueblos,
Primero, obtenga el valor de la propiedad establecido en BeanDefinition y luego comience el proceso de inyección de dependencia.
Primero, la inyección de AutoWire se puede procesar, byname o junto al alumno, y luego se inyectan los atributos.
Entonces necesitas analizar la referencia de frijoles. Después de analizar la gerencia, Manageneset, Managemap, etc., ha preparado condiciones para la inyección de dependencia. Aquí es donde realmente establece el objeto Bean en otra propiedad de frijoles en la que depende, y las propiedades procesadas son varias.
La inyección de dependencia ocurre en los SetPropertyValues de BeanWrapper, pero la finalización específica se implementa en la subclase BeanWrapper BeanWrapperMpl. Completará la inyección del valor de la propiedad del bean, incluida la inyección de matriz, la inyección de clases de recolección como la lista y la inyección de clases de no colección.
Después de una serie de inyecciones, se completa el proceso de inyección de dependencia de varias propiedades de Bean.
Durante el proceso de creación de frijoles e inyección de dependencia de objetos, la inyección de dependencia debe completarse de manera recursiva en función de la información en BeanDefinition.
De los procesos de recursión anteriores, podemos ver que estas recursiones son portátiles con GetBean.
Una recursión es encontrar los frijoles requeridos y crear la llamada recursiva a los frijoles en el sistema de contexto;
Otra recursión es llamar al método GetBean del contenedor de manera recursiva durante la inyección de dependencia para obtener el frijol de dependencia del bean actual, y también activar la creación y la inyección del frijol de dependencia.
Al realizar la inyección de dependencia de las propiedades de un frijol, el proceso de análisis también es un proceso recursivo. De esta manera, de acuerdo con la dependencia, la creación y la inyección del frijol se completan la capa por capa hasta que finalmente se complete la creación del frijol actual. Con la creación de este frijol de nivel superior y la finalización de su inyección de dependencia de atributos, significa que se completa la solución de inyección de toda la cadena de dependencia relacionada con el frijol actual.
Después de que se completan la creación de frijoles y la inyección de dependencia, se establece una serie de frijoles vinculados por dependencias en el contenedor del COI. Este frijol ya no es un objeto Java simple. Después de establecer la relación de dependencia entre la serie Bean y los frijoles, se puede usar muy convenientemente para aplicaciones de nivel superior a través de los métodos de interfaz relevantes de COI.
2. Atributo de la In-Init y Pre-Instance
En el método de actualización anterior, podemos ver que se llama a finkbeanFactoryInitialization para procesar los frijoles configurados con la inyente lazy.
De hecho, en este método, el procesamiento del atributo de la inyente perezoso se encapsula, y el procesamiento real se realiza en el método preinstanciado de la línea del contenedor básico de defaultListableBeanFactory. Este método completa los frijoles singleton previos, y esta finalización previa a la entrada está inteligentemente delegada al contenedor para implementar. Si se requiere preinstanado, entonces GetBean se usa aquí para activar la inyección de dependencia. En comparación con los desencadenantes de inyección de dependencia normales, el tiempo de activación y la ocasión son solo diferentes. Aquí, la inyección de dependencia ocurre durante el proceso de actualización del contenedor, es decir, durante el proceso de inicialización del contenedor IOC, a diferencia de la inyección de dependencia ordinaria, cuando el contenedor solicita el bean por primera vez después de que el contenedor del COI se inicialice a través de GetBean.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.