Spring Master's Road 11 - Descifrado de BeanDefinition: la piedra angular de la construcción y gestión de Spring Beans

  BeanDefinitionEs Springun concepto muy importante en el mundo. Contiene toda la información necesaria Springpara la creación y configuración de contenedores . BeanComprender el funcionamiento interno BeanDefinitionpuede ayudarnos a desarrollar un dominio más profundo .Spring

1. Explora BeanDefinition

Primero, tengamos BeanDefinitionuna comprensión general de.

1.1 Interpretación de BeanDefinition en documentos oficiales

La documentación oficial es un recurso muy importante   para comprender Springlos conceptos y componentes del marco . SpringAcerca de BeanDefinition, el documento oficial es el siguiente:

  BeanDefinitionContiene una gran cantidad de información de configuración que puede guiar Springla creación Bean, incluidos Beanparámetros del constructor, valores de atributos, métodos de inicialización, nombres de métodos de fábrica estáticos, etc. Además, el hijo BeanDefinitionpuede BeanDefinitionheredar información de configuración del padre y también puede sobrescribir o agregar nueva información de configuración. Este patrón de diseño reduce efectivamente la información de configuración redundante y hace que la configuración sea más concisa.

A continuación, comprendamos mejor a través de un ejemplo concreto BeanDefinition.

Considere una Javaclase simple Person:

public class Person {
    
    
    private String name;
    private int age;

    public Person() {
    
    }

    public Person(String name, int age) {
    
    
        this.name = name;
        this.age = age;
    }

    // getters and setters
}

Podemos definir un tipo usando XMLconfiguración o configuración , y la información de configuración se encapsulará en .JavaPersonBeanBeanBeanDefinition

En XMLuna configuración, una Person Beanpodría definirse de la siguiente manera:

<bean id="person" class="com.example.Person">
    <constructor-arg name="name" value="John"/>
    <constructor-arg name="age" value="25"/>
</bean>

Aquí, BeanDefinitionla información incluye classlos nombres y valores de las propiedades (nombres de clase completamente calificados) y los parámetros del constructor.

En Javala configuración podemos definir uno como este Person Bean:

@Configuration
public class AppConfig {
    
    
    @Bean
    public Person person() {
    
    
        return new Person("John", 25);
    }
}

  En este ejemplo, BeanDefinitionla información incluye classpropiedades (nombres de clase completos) y parámetros del constructor. Podemos obtener este nombre de clase completo a través del método BeanDefinition.getBeanClassName()

1.2 Análisis de métodos clave de BeanDefinition

BeanDefinitionToda la metainformación definida por la interfaz Beanincluye principalmente los siguientes métodos:

• get/setBeanClassName() - obtiene/establece Beanel nombre de la clase
• get/setScope() - obtiene/establece Beanel alcance
• isSingleton() / isPrototype() - Determina si es un alcance singleton/prototipo
• get/setInitMethodName() - Obtiene/establece el nombre del método de inicialización
• get/setDestroyMethodName() - Obtiene/establece el nombre del método de destrucción
• get/setLazyInit() - Obtener/establecer si retrasar la inicialización
• get/setDependsOn() - Obtener/establecer dependenciasBean
• get/setPropertyValues() - Obtener/establecer valores de propiedad
• get/setAutowireCandidate() - Obtiene/establece si se puede cablear el autowire
• get/setPrimary() - Obtiene/establece si se prefiere el cableado automáticoBean

  Debido a BeanDefinitionla longitud del código fuente, no todo está publicado aquí, puedes comprobarlo tú mismo. BeanDefinitionTambién implementa AttributeAccessoruna interfaz a través de la cual se pueden agregar metadatos personalizados. Se utilizarán ejemplos AttributeAccessoren las siguientes secciones.

  Como se puede ver en lo anterior, BeanDefinitiones el objeto de metadatos Springutilizado para describir en el marco . Estos metadatos contienen información básica, incluidos los siguientes aspectos:BeanBean

• Información de clase de Bean : este es Beanel nombre de clase completo, es decir, Beanel tipo específico después de la creación de instancias.

• Información de atributos del bean : incluido Beanel alcance de (si es un singleton o un prototipo), si es principal Bean( primary), información de descripción, etc.

• Características de comportamiento de Bean : por ejemplo, Beansi admite carga diferida, si puede ser candidato para cableado automático y Beansus métodos de inicialización y destrucción, etc.

• La relación entre Bean y otros Beans : por ejemplo, Beande qué más depende Beany Beansi tiene un padre Bean.

• Información de configuración del Bean : esto incluye Beanlos parámetros del constructor, los valores de las propiedades, etc.

1.3 Aplicación práctica de algunos métodos de BeanDefinition

  A continuación, se utiliza un ejemplo de código detallado para ilustrar BeanDefinitionel uso de cada método en la interfaz, y el significado real de estos métodos se explica con ejemplos de código reales. A continuación, proporcionaré BeanDefinitionejemplos de código para algunos aspectos importantes.

El código completo es el siguiente:

Primero, aquí está nuestra Javaclase de configuración y Personla definición de clase:

package com.example.demo.configuration;

import com.example.demo.bean.Person;
import org.springframework.context.annotation.*;

@Configuration
public class AppConfig {
    
    

    @Bean(initMethod = "init", destroyMethod = "cleanup")
    @Scope("singleton")
    @Lazy
    @Primary
    @Description("A bean for person")
    public Person person() {
    
    
        return new Person("John", 25);
    }
}

package com.example.demo.bean;

public class Person {
    
    
    private String name;
    private int age;

    public Person(String name, int age) {
    
    
        this.name = name;
        this.age = age;
    }

    // getters and setters

    public void init() {
    
    
        System.out.println("Initializing Person bean");
    }

    public void cleanup() {
    
    
        System.out.println("Cleaning up Person bean");
    }
}

A continuación se explica cómo BeanDefinitionobtener cada atributo:

package com.example.demo;

import com.example.demo.configuration.AppConfig;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.util.Arrays;

public class DemoApplication {
    
    
    public static void main(String[] args) {
    
    
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        String personBeanName = "person";
        BeanDefinition personBeanDefinition = context.getBeanFactory().getBeanDefinition(personBeanName);

        // 获取Bean的类信息
        System.out.println("Bean Class Name: " + context.getBean(personBeanName).getClass().getName());

        // 获取Bean的属性
        System.out.println("Scope: " + personBeanDefinition.getScope());
        System.out.println("Is primary: " + personBeanDefinition.isPrimary());
        System.out.println("Description: " + personBeanDefinition.getDescription());

        // 获取Bean的行为特征
        System.out.println("Is lazy init: " + personBeanDefinition.isLazyInit());
        System.out.println("Init method: " + personBeanDefinition.getInitMethodName());
        System.out.println("Destroy method: " + personBeanDefinition.getDestroyMethodName());

        // 获取Bean的关系
        System.out.println("Parent bean name: " + personBeanDefinition.getParentName());
        System.out.println("Depends on: " + Arrays.toString(personBeanDefinition.getDependsOn()));

        // 获取Bean的配置属性
        System.out.println("Constructor argument values: " + personBeanDefinition.getConstructorArgumentValues());
        System.out.println("Property values: " + personBeanDefinition.getPropertyValues());
    }
}

resultado de la operación:

  Este ejemplo contiene BeanDefinitionla mayoría de los métodos y muestra lo que hacen. Tenga en cuenta que en este ejemplo, los resultados devueltos de algunos métodos como getDependsOn(),,, pueden no mostrar ninguna sustancia, porque no configuramos estos valores . Si estos valores se establecen en la aplicación real, estos métodos devolverán los resultados correspondientes.getParentName()getConstructorArgumentValues()getPropertyValues()person Bean

1.4 Clasificación profunda de la estructura de información de BeanDefinition

En Spring, BeanDefinitionse incluye la siguiente información principal:

• Clase : este es el nombre de clase completo. SpringUtilice esta información para crear Beaninstancias mediante reflexión. Por ejemplo, com.example.demo.bean.Bookcuando Springnecesita crear Book beanuna instancia de, creará Bookuna instancia de la clase mediante la reflexión basada en este nombre de clase.

• Nombre : Este es Beanel nombre de. En las aplicaciones, normalmente usamos este nombre para obtener Beaninstancias de . Por ejemplo, podríamos tener un nombre "bookService"y Beanpodemos context.getBean("bookService")obtener Beanuna instancia de este a través de .

• Alcance : Esto define Beanel alcance de, por ejemplo, singletono prototype. En caso scopeafirmativo singleton, Springel contenedor creará solo una Beaninstancia y devolverá esta instancia en cada solicitud. En caso scopeafirmativo prototype, el contenedor creará una nueva instancia cada Beanvez que se solicite .SpringBean

• Argumentos del constructor : Estos son Beanlos argumentos del constructor utilizados para crear instancias. Por ejemplo, si tenemos una Bookclase cuyo constructor requiere un Stringparámetro de tipo title, entonces podemos BeanDefinitionconfigurarlo constructor argumentspara proporcionar este parámetro.

• Propiedades : estos son Beanlos valores de propiedad que deben inyectarse. Por ejemplo, podríamos tener una Bookclase que tenga una titlepropiedad que podamos BeanDefinitionconfigurar propertiespara proporcionar el valor de esta propiedad. Estos valores también se pueden inyectar en clases o archivos de configuración mediante <property>etiquetas o anotaciones.@Value

• Modo de cableado automático : este es el modo de cableado automático. Si se establece en byType, Springel contenedor conectará automáticamente Beanla propiedad, que buscará un tipo de propiedad coincidente en el contenedor Beany lo inyectará. Si se establece en byName, el contenedor buscará un contenedor con un nombre que coincida con el nombre de la propiedad Beany lo inyectará. También hay una opción constructorque se refiere a Beanborrar automáticamente las dependencias a través de los tipos de parámetros del constructor.

• Inicialización diferida : si se establece en true, Beanse creará en la primera solicitud en lugar de cuando se inicie la aplicación. Esto puede hacer que su aplicación se inicie más rápido, pero puede Beanintroducir cierta latencia en la primera solicitud.

• Método de inicialización y método de destrucción : estos son Beanlos métodos de inicialización y destrucción de . Por ejemplo, podemos tener una BookServiceclase que tiene un initmétodo de inicialización nombrado y un cleanupmétodo de destrucción nombrado. Podemos BeanDefinitionconfigurar estos dos métodos en, luego el contenedor llamará al método después de Springla creación y al método antes de la destrucción .BeaninitBeancleanup

• Beans de dependencia : Estas son Beanlas dependencias de . Por ejemplo , podríamos tener a BookService Bean, que depende de a BookRepository Bean, luego podemos configurarlo BookService, luego el contenedor se creará primero antes de crear .BeanDefinitiondependency beans"bookRepository"BookService BeanSpringBookRepository Bean

  Lo anterior es BeanDefinitionla información principal contenida en , que le indicará Springcómo se crea y configura el contenedor Bean. Diferentes BeanDefinitionimplementaciones pueden tener más información de configuración. Por ejemplo, RootBeanDefinition, ChildBeanDefinitionetc. GenericBeanDefinitionson BeanDefinitionclases de implementación concretas de la interfaz y pueden contener más opciones de configuración.

2. Análisis del sistema constructivo BeanDefinition

  Primero aclaremos BeanDefinitionlos roles. BeanDefinitionEs Springel componente central de .Define la beaninformación de configuración, incluido el nombre de la clase, el alcance, los parámetros del constructor, los valores de los atributos, etc. Echemos un vistazo a BeanDefinitioncómo Springse ve el diseño.

A través de esto IDEApodemos obtener el siguiente diagrama de relación de herencia:

Si bien hay muchas interfaces, clases abstractas y extensiones, solo debemos centrarnos en las claves.

2.1 Tipos de BeanDefinition y sus aplicaciones

En Spring, los objetos guardan la beaninformación de configuración BeanDefinition. Según las beandiferentes fuentes y métodos de configuración, BeanDefinitionse divide en muchos tipos, seleccionaremos algunos de ellos para explicarlos.

• RootBeanDefinition : Cuando XMLdefinimos uno en el archivo de configuración bean, se creará un objeto Springpara este objeto. Este objeto contiene toda la información utilizada para la creación, como nombre de clase, valores de atributos, etc. Por ejemplo:beanRootBeanDefinitionbeanbean

<bean id="exampleBean" class="com.example.ExampleBean">
    <property name="stringProperty" value="stringValue"/>
</bean>

  Esta XMLconfiguración define un nombre "exampleBean", beansu clase es "com.example.ExampleBean"y hay un "stringProperty"valor de atributo llamado es "stringValue". Cuando Springse lee esta configuración, se crea un objeto RootBeanDefinitionpara guardar toda la información de configuración de este bean.

  Resumen: cuando XMLdefine uno en un archivo bean, Springse creará una instancia RootBeanDefinitiony esta instancia guardará toda la información de configuración, como el nombre de la clase, los valores de los atributos, etc.

• ChildBeanDefinition : Puede usarse cuando necesitamos que uno beanherede la configuración de otro . Por ejemplo:beanChildBeanDefinition

<bean id="parentBean" class="com.example.ParentBean">
    <property name="stringProperty" value="stringValue"/>
</bean>

<bean id="childBean" parent="parentBean">
    <property name="anotherStringProperty" value="anotherStringValue"/>
</bean>

  En esta XMLconfiguración, todas las configuraciones "childBean"se heredan "parentBean"y se agrega un nuevo atributo "anotherStringProperty". Cuando Springse lee esta configuración, primero se creará un objeto "parentBean"y RootBeanDefinitionluego se creará "childBean"un objeto al que este objeto hará referencia .ChildBeanDefinition"parentBean"BeanDefinition

  Resumen: si tiene uno beany desea crear uno nuevo bean, que beandebe heredar beantoda la configuración original, pero también necesita agregar o modificar alguna información de configuración, Springse creará una ChildBeanDefinitioninstancia .

• GenericBeanDefinition : Este es genérico BeanDefinitiony se puede convertir a RootBeanDefinitiono según sea necesario ChildBeanDefinition. Por ejemplo, el uso de anotaciones en una clase de configuración @Beandefine un bean:

@Configuration
public class AppConfig {
    
    
    @Bean
    public MyComponent myComponent() {
    
    
        return new MyComponent();
    }
}

  En este código, definimos una clase "myComponent"llamada . Cuando se analiza esta clase de configuración, se crea un objeto para el método. Este objeto contendrá el nombre del método (que también es su nombre), su tipo de retorno y cualquier parámetro o propiedad del constructor requerido. En este ejemplo, no hemos definido ningún parámetro o propiedad, por lo que el objeto solo contiene información básica. Luego, el contenedor puede utilizar este objeto para las instancias generadas .bean"MyComponent"SpringmyComponent()GenericBeanDefinitionGenericBeanDefinitionbeanGenericBeanDefinitionGenericBeanDefinitionSpringbean

  Resumen: cuando define uno usando anotaciones Javaen una clase de configuración , se crea una instancia .@BeanbeanSpringGenericBeanDefinition

• AnnotatedBeanDefinition@Component : cuando usamos anotaciones (como ,, etc.) para definir en el código , se creará una @Serviceinstancia de la interfaz . Por ejemplo:@RepositorybeanSpringAnnotatedBeanDefinition

@Component("myComponent")
public class MyComponent {
    
    
    // some fields and methods
}

  En este código, definimos una clase "myComponent"llamada bean, su clase es "MyComponent"y hay una anotación en esta clase @Component. Cuando Springse analiza esta clase, se crea un objeto AnnotatedBeanDefinition. Este AnnotatedBeanDefinitionobjeto guardará el nombre de la clase (que también es beanel nombre), el tipo de clase y toda la información de anotaciones de la clase. En este ejemplo, AnnotatedBeanDefinitionla instancia contendrá @Componentla anotación y todos sus metadatos. AnnotatedBeanDefinitionLuego, el contenedor puede utilizar esta instancia Springpara generar beaninstancias, y la información de anotaciones Springalmacenada en ella también se puede utilizar AnnotatedBeanDefinitionpara procesamiento posterior, como AOPproxy, gestión de transacciones, etc.

@ComponentResumen: cuando utiliza anotaciones (como ,,, etc.)   en una clase para @Servicedefinir una , se creará una instancia que implementa la interfaz, como o . Esta instancia guardará el nombre de la clase, el tipo de clase y toda la información de anotaciones de la clase.@RepositorybeanSpringAnnotatedBeanDefinitionAnnotatedGenericBeanDefinitionScannedGenericBeanDefinition

  GenericBeanDefinitionAnnotatedBeanDefinitionLa principal diferencia entre y es que AnnotatedBeanDefinitionla información de anotaciones en la clase se guarda, mientras que GenericBeanDefinitionno. Esto permite que Springestas anotaciones se lean y procesen en tiempo de ejecución, lo que proporciona una funcionalidad más completa.

  En la mayoría de los casos, no es necesario que nos importe Springcuál beanse crea BeanDefinition. SpringEstos se gestionan BeanDefinition, crean y configuran automáticamente en función de su tipo y de la información que contienen bean.

2.2 Análisis de los principios de generación de BeanDefinition

  Este BeanDefinitionobjeto es leído y generado Springpor varias clases de implementación durante el proceso de inicio .BeanDefinitionReader

SpringHay tres formas principales de crearlo   en BeanDefinition:

• Método de configuración XML :

Primero, XMLdefinimos uno en el archivo bean:

<bean id="bookService" class="com.example.demo.service.BookService">
    <property name="bookRepository" ref="bookRepository"/>
</bean>

<bean id="bookRepository" class="com.example.demo.repository.BookRepository"/>

  En este caso, cuando Springse inicie, XmlBeanDefinitionReaderse leerá el archivo XML, se analizarán los elementos que contiene y se creará un objeto <bean>para cada elemento .<bean>BeanDefinition

Una descripción simple es: XmlBeanDefinitionReaderleer XMLel archivo, analizar <bean>los elementos y generarlos BeanDefinition.

• Método de configuración de anotaciones :

Usamos anotaciones como @Component, @Serviceetc. @Repositorypara definir la clase bean, por ejemplo:

@Repository
public class BookRepository {
    
    
    // ... repository methods
}

@Service
public class BookService {
    
    
    private final BookRepository bookRepository;
    
    public BookService(BookRepository bookRepository) {
    
    
        this.bookRepository = bookRepository;
    }
    
    // ... service methods
}

  En este caso, cuando Springse inicie, ClassPathBeanDefinitionScannerse escaneará la ruta del paquete especificado para encontrar todas las clases con anotaciones específicas y BeanDefinitionse crearán objetos para estas clases. Lo que se genera de esta forma BeanDefinitionsuele ser ScannedGenericBeanDefinitionde tipo.

  La descripción simple es: escanee ClassPathBeanDefinitionScannerlas clases anotadas en la ruta del paquete especificada y generelas BeanDefinition.

• Método de configuración de Java :

Usamos anotaciones @Configurationy @Beanpara definir clases de configuración y bean, por ejemplo:

@Configuration
public class AppConfig {
    
    

    @Bean
    public BookRepository bookRepository() {
    
    
        return new BookRepository();
    }

    @Bean
    public BookService bookService(BookRepository bookRepository) {
    
    
        return new BookService(bookRepository);
    }
}

  En este caso, al Springiniciar, ConfigurationClassPostProcessorestas clases de configuración se procesarán y se entregarán ConfigurationClassParserpara su análisis. Para cada @Beanmétodo marcado con en la clase de configuración, BeanDefinitionse creará un objeto. Lo que se genera de esta forma BeanDefinitionsuele ser ConfigurationClassBeanDefinitionde tipo.

  La descripción simple es: procesar ConfigurationClassPostProcessorla clase marcada , analizar los métodos y @Configurationgenerarlos .@BeanBeanDefinition

  En general, no importa si elegimos XMLconfiguración, configuración de anotaciones o Javamétodo de configuración, Springestas configuraciones se analizarán al inicio y BeanDefinitionse generarán los objetos correspondientes para guiar Springal contenedor sobre cómo crear y administrar Beaninstancias.

  Estos contenidos pueden ser abstractos y complejos, pero para principiantes, solo necesita comprender: BeanDefinitiones un objeto Springutilizado para almacenar Beaninformación de configuración. Se genera Springleyendo la configuración durante el proceso de inicio BeanDefinitionReader. El método de generación específico depende de la configuración utilizada. método ( XML, anotación o Javaconfiguración), en cuanto al principio de implementación específico, aprenderemos más sobre él más adelante.

2.3 AttributeAccessor en la práctica: una poderosa herramienta para la manipulación de atributos

  AttributeAccessores Springuna interfaz importante en el marco que proporciona una forma flexible de adjuntar metadatos adicionales a los Springcomponentes principales. SpringMuchas clases importantes incluidas en BeanDefinitionComponentes implementan AttributeAccessorinterfaces para que se puedan agregar y obtener propiedades adicionales de estos componentes dinámicamente. Un beneficio significativo de esto es que los desarrolladores pueden administrar de manera flexible información adicional para estos componentes sin cambiar la definición de clase original.

Echemos un vistazo a un ejemplo: el código completo es el siguiente:

BookCrea un objeto primero

class Book {
    
    
    private String title;
    private String author;

    public Book() {
    
    }

    public Book(String title, String author) {
    
    
        this.title = title;
        this.author = author;
    }

    // getter 和 setter 省略...
}

Programa principal:

package com.example.demo;

import com.example.demo.bean.Book;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.RootBeanDefinition;

public class DemoApplication {
    
    

    public static void main(String[] args) {
    
    
        // 创建一个BeanDefinition, BeanDefinition是AttributeAccessor的子接口
        BeanDefinition bd = new RootBeanDefinition(Book.class);

        // 设置属性
        bd.setAttribute("bookAttr", "a value");

        // 检查和获取属性
        if(bd.hasAttribute("bookAttr")) {
    
    
            System.out.println("bookAttr: " + bd.getAttribute("bookAttr"));

            // 移除属性
            bd.removeAttribute("bookAttr");
            System.out.println("bookAttr: " + bd.getAttribute("bookAttr"));
        }
    }
}

  En este ejemplo, creamos una RootBeanDefinitioninstancia para describir cómo crear una Bookinstancia de una clase. RootBeanDefinitionSí BeanDefinition, BeanDefinitionimplementa AttributeAccessorla interfaz, por lo RootBeanDefinitionque hereda AttributeAccessorel método.

Algunas personas pueden preguntarse: Libro no tiene la variable miembro bookAttr. ¿Cómo se le asigna un valor?

  En Springel marco, AttributeAccessorlas interfaces definen métodos para adjuntar, obtener y eliminar RootBeanDefinitionmetadatos asociados con un objeto (por ejemplo), en lugar de manipular Bookcampos en el objeto (por ejemplo) en sí.

  Entonces, cuando RootBeanDefinitionllamas setAttribute("bookAttr", "a value")a un método en una instancia, en realidad no estás Bookconfigurando un bookAttrcampo nombrado en la instancia. En su lugar, RootBeanDefinitionse adjuntan metadatos a la instancia, siendo la clave "bookAttr"y el valor "a value".

  En usos posteriores getAttribute("bookAttr")del método, devolverá el valor de metadatos establecido previamente "a value"en lugar de intentar acceder a los campos Bookde la clase bookAttr( Bookque en realidad no tienen bookAttrcampos).

  En pocas palabras, estos metadatos se adjuntan al RootBeanDefinitionobjeto, no a la instancia RootBeanDefinitiondescrita por el objeto Book.

resultado de la operación:

Resumir:

  BeanDefinitionAttributeAccessorEs una clase importante que implementa la interfaz. BeanDefinitionEl objeto es la estructura de datos Springutilizada por el marco para almacenar beaninformación de configuración. Cuando usamos anotaciones como @Bean, y para definir a en la clase de configuración , se creará un objeto para esto y los metadatos de estas @Scopeanotaciones se adjuntarán a este objeto.@LazybeanSpringbeanBeanDefinitionBeanDefinition

  Cuando Springel contenedor necesite crear una instancia más adelante bean, examinará este BeanDefinitionobjeto y creará y administrará la instancia de acuerdo con los metadatos (como scopeinicialización lazy, métodos de inicialización y destrucción, etc.) bean. Estos metadatos no se adjuntan directamente a beanla instancia, sino que se almacenan en BeanDefinitionobjetos y Springel contenedor los gestiona y utiliza.

  Entonces, cuando obtenemos e mainimprimimos sus propiedades en el método , en realidad estamos mirando las estructuras de datos internas utilizadas por el marco para administrar el , en lugar de mirar directamente el estado de la instancia en sí.ApplicationContextBeanDefinitionSpringbeanbean

  El beneficio de este enfoque es que desacopla estos metadatos adicionales de beanla propia instancia, lo que permite beanla flexibilidad de cambiarlos sin modificar la clase y permite que los datos se compartan entre diferentes subprocesos en AttributeAccessorel mismo proceso. JVMEs por eso que podemos cambiar el alcance, ya sea carga diferida, etc., modificando el archivo de configuración o las anotaciones beansin modificar beanla definición de clase.

3. Revisión y resumen de BeanDefinition

  A medida que profundizamos en Springel marco, aprendemos BeanDefinitionsobre Springun concepto muy crítico. BeanDefinitionSu principal responsabilidad es servir como un objeto de datos que almacena información detallada sobre cómo crear, inicializar y configurar una Beaninstancia específica.

En particular, BeanDefinitioncontiene la siguiente información principal:

• Nombre de clase completo para que el contenedor cree Springinstancias mediante reflexión Bean.
• El nombre y alias del bean , utilizado para hacer referencia y encontrarlo en la aplicación Bean.
• El alcance de un bean , como singleton o prototipo, determina Springcómo Beanse gestiona el ciclo de vida de la instancia.
• Parámetros del constructor y valores de propiedad , utilizados para la creación de instancias Beany la inyección de dependencias.
• Modo de cableado automático , que indica Springcómo inyectar dependencias automáticamente.
• Los métodos de inicialización y destrucción le permiten saber cómo ejecutar lógica personalizada Springen momentos específicos del ciclo de vida.Bean
• Dependencias de beans , que indican cuáles deben crearse antes de Springcrear el actual .BeanBean

  No importa qué método de configuración usemos ( XML, anotación o Javaconfiguración), Springestas configuraciones se analizarán al inicio y luego BeanDefinitionse generarán los objetos correspondientes. Estos BeanDefinitionobjetos son como Springrecetas dentro del contenedor, que le dicen Springal contenedor cómo crear y configurar cada objeto Bean.

Bienvenido a la conexión triple con un clic ~

Si tiene alguna pregunta, deje un mensaje, discutamos y aprendamos juntos

----------------------Hablar es barato , muéstrame el código ----- ------------------