Análisis detallado del principio de inicio de Springboot

Desarrollamos cualquier proyecto de Spring Boot, usaremos la siguiente clase de inicio

@SpringBootApplication
public class Application {
    
    
     public static void main(String[] args) {
    
    
         SpringApplication.run(Application.class, args);
     }
 }

Como se puede ver en el código anterior, la definición de anotación (@SpringBootApplication) y la definición de clase (SpringApplication.run) son las más deslumbrantes, por lo que para descubrir el misterio de SpringBoot, tenemos que comenzar con estos dos.

Uno, el secreto detrás de SpringBootApplication

@SpringBootApplication注解是Spring Boot的核心注解，它其实是一个组合注解：
@Target(ElementType.TYPE)
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
 @Inherited
 @SpringBootConfiguration
 @EnableAutoConfiguration
 @ComponentScan(excludeFilters = {
    
    
         @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
         @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
 public @interface SpringBootApplication {
    
    
 ...
 }

Aunque la definición usa múltiples anotaciones para marcar la información original, solo tres anotaciones son realmente importantes:

• @Configuration (@SpringBootConfiguration haga clic para verificar y encontrar que @Configuration todavía se aplica)
• @EnableAutoConfiguration
• @ComponenteScan

Es decir, @SpringBootApplication =
(propiedad predeterminada) @Configuration + @ EnableAutoConfiguration + @ComponentScan.

Por lo tanto, si usamos la siguiente clase de inicio SpringBoot, toda la aplicación SpringBoot aún puede ser funcionalmente equivalente a la clase de inicio anterior:

@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application {
    
    
    public static void main(String[] args) {
    
    
        SpringApplication.run(Application.class, args);
    }
}

Es agotador escribir estos 3 cada vez, por lo que es conveniente escribir una @SpringBootApplication. A continuación, presentaremos estas 3 anotaciones respectivamente.

1 、 @ Configuración

La @Configuration aquí no nos es desconocida. Es la @Configuration utilizada por la clase de configuración del contenedor Spring Ioc en la forma de JavaConfig. La comunidad SpringBoot recomienda usar el formulario de configuración basado en JavaConfig. Por lo tanto, la clase de inicio aquí está marcada con @Configuration. En realidad, es una clase de configuración de un contenedor de IoC.

Dé algunos ejemplos simples para revisar, la diferencia entre XML y los métodos de configuración de configuración:

(1) Nivel de expresión

La forma basada en la configuración XML es así:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"
       default-lazy-init="true">
    <!--bean定义-->
</beans>

El método de configuración basado en JavaConfig es así:

@Configuration
public class MockConfiguration{
    
    
    //bean定义
}

Cualquier definición de clase Java marcada con @Configuration es una clase de configuración JavaConfig.

(2) Registre el nivel de definición de frijol

El formulario de configuración basado en XML es así:

<bean id="mockService" class="..MockServiceImpl">
    ...
</bean>

El formulario de configuración basado en JavaConfig se ve así:

@Configuration
public class MockConfiguration{
    
    
    @Bean
    public MockService mockService(){
    
    
        return new MockServiceImpl();
    }
}

Para cualquier método marcado con @Bean, su valor de retorno se registrará como una definición de bean en el contenedor de IoC de Spring, y el nombre del método será el ID de la definición de bean por defecto.

(3) Nivel de relación de inyección de dependencia expresa

Para expresar la dependencia entre bean y bean, generalmente es así en formato XML:

<bean id="mockService" class="..MockServiceImpl">
   <propery name ="dependencyService" ref="dependencyService" />
</bean>
<bean id="dependencyService" class="DependencyServiceImpl"></bean>

El formulario de configuración basado en JavaConfig se ve así:

@Configuration
public class MockConfiguration{
    
    
    @Bean
    public MockService mockService(){
    
    
        return new MockServiceImpl(dependencyService());
    }

    @Bean
    public DependencyService dependencyService(){
    
    
        return new DependencyServiceImpl();
    }
}

Si la definición de un bean depende de otros beans, simplemente llame directamente al método de creación del bean dependiente en la clase JavaConfig correspondiente.

@Configuration: mencionar @Configuration es mencionar a su socio @Bean. Con estas dos anotaciones, puede crear una clase de configuración de primavera simple, que se puede usar para reemplazar el archivo de configuración xml correspondiente.

<beans> 
    <bean id = "car" class="com.test.Car"> 
        <property name="wheel" ref = "wheel"></property> 
    </bean> 
    <bean id = "wheel" class="com.test.Wheel"></bean> 
</beans>

Es equivalente a:

@Configuration 
public class Conf {
    
     
    @Bean 
    public Car car() {
    
     
        Car car = new Car(); 
        car.setWheel(wheel()); 
        return car; 
    }

    @Bean 
    public Wheel wheel() {
    
     
        return new Wheel(); 
    } 
}

La clase de anotación @Configuration indica que esta clase puede usar el contenedor Spring IoC como fuente de definiciones de bean.

La anotación @Bean le dice a Spring que un método anotado con @Bean devolverá un objeto que debería registrarse como un bean en el contexto de la aplicación Spring.

2 、 @ ComponentScan

La anotación @ComponentScan es muy importante en Spring. Corresponde a los elementos en la configuración XML. La función de @ComponentScan es en realidad escanear y cargar automáticamente componentes calificados (como @Component y @Repository, etc.) o definiciones de bean, y finalmente definir estos beans Cargue en el contenedor de IoC.

Podemos precisar el alcance del escaneo automático de @ComponentScan a través de atributos como paquetes base. Si no se especifica, la implementación del marco de Spring predeterminada escaneará desde el paquete donde se declara la clase @ComponentScan.

Nota: Por lo tanto, la clase de inicio de SpringBoot está mejor ubicada debajo del paquete raíz, porque basePackages no se especifica de forma predeterminada.

3 、 @ EnableAutoConfiguration

Personalmente, creo que @EnableAutoConfiguration es la Anotación más importante. ¿Todavía recuerdas las definiciones de Anotación que comienzan con @Enable proporcionadas por el marco de Spring?
Por ejemplo, @EnableScheduling,
@EnableCaching , @EnableMBeanExport, etc., la filosofía y la forma de hacer las cosas de @EnableAutoConfiguration están realmente en la misma línea Un breve resumen es recopilar y registrar definiciones de bean relacionadas con escenarios específicos con el apoyo de @Import.

@EnableScheduling carga todas las definiciones de bean relacionadas con el marco de programación Spring en el contenedor de IoC a través de @Import.

@EnableMBeanExport es cargar definiciones de bean relacionadas con JMX en el contenedor de IoC a través de @Import.

Y @EnableAutoConfiguration también usa la ayuda de @Import para cargar todas las definiciones de bean que cumplen con las condiciones de configuración automática en el contenedor de IoC, ¡nada más!

@EnableAutoConfiguration configurará automáticamente el proyecto de acuerdo con las dependencias jar en la ruta de clase. Por ejemplo, si se agrega la dependencia spring-boot-starter-web, las dependencias de Tomcat y Spring MVC se agregarán automáticamente, y Spring Boot configurará automáticamente Tomcat y Spring MVC .

@EnableAutoConfiguration, como una anotación compuesta, define la información clave de la siguiente manera:

@SuppressWarnings("deprecation")
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(EnableAutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
    
    
    ...
}

Entre ellos, el más crítico es @Import (EnableAutoConfigurationImportSelector.class). Con la ayuda de EnableAutoConfigurationImportSelector, @EnableAutoConfiguration puede ayudar a las aplicaciones SpringBoot a cargar todas las configuraciones elegibles de @Configuration en el contenedor IoC actual creado y utilizado por SpringBoot. Al igual que un "pulpo", con el apoyo de una clase de herramienta original del marco Spring: SpringFactoriesLoader, @EnableAutoConfiguration puede configurar de forma inteligente y automática la función para que tenga éxito.

El héroe detrás de la configuración automática: SpringFactoriesLoader explica que
SpringFactoriesLoader es una extensión privada del marco Spring. Su función principal es cargar la configuración desde el archivo de configuración especificado META-INF / spring.factories.

public abstract class SpringFactoriesLoader {
    
    
    //...
    public static <T> List<T> loadFactories(Class<T> factoryClass, ClassLoader classLoader) {
    
    
        ...
    }
    public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
    
    
        ....
    }
}

Cuando se usa con @EnableAutoConfiguration, es más para proporcionar un soporte de función de búsqueda de configuración, es decir, de acuerdo con el nombre de clase completo de @EnableAutoConfiguration org.springframework.boot.autoconfigure.EnableAutoConfiguration como la clave a buscar, se obtiene un conjunto de clases de @Configuration correspondientes.

La imagen de arriba es un extracto del archivo de configuración META-INF / spring.factories en el paquete de dependencia de autoconfiguración de SpringBoot, que puede ilustrar bien el problema.

Por lo tanto, el caballero mágico de la configuración automática de @EnableAutoConfiguration se convierte en: buscar todos los archivos de configuración META-INF / spring.factories desde la ruta de clase y pasar los elementos de configuración correspondientes a org.springframework.boot.autoconfigure.EnableutoConfiguration a través de la reflexión (Java Refletion) se crea una instancia en la clase de configuración de contenedor de IoC correspondiente en forma de JavaConfig marcado con @Configuration, y luego se agrega en uno y se carga en el contenedor de IoC.

Dos, exploración en profundidad del proceso de ejecución de SpringApplication

La implementación del método de ejecución de SpringApplication es la ruta principal de nuestro viaje. El proceso principal de este método se puede resumir de la siguiente manera:

(1) Si estamos usando el método de ejecución estática de SpringApplication, entonces, en este método, primero debemos crear una instancia de objeto SpringApplication y luego llamar al método de instancia SpringApplication creado. Cuando se inicializa la instancia de SpringApplication, hará varias cosas por adelantado:

• Según si existe una clase de entidad org.springframework.web.context.ConfigurableWebApplicationContext en la ruta de clase, se determina si se debe crear un tipo ApplicationContext para aplicaciones web.
• Utilice SpringFactoriesLoader para buscar y cargar todos los ApplicationContextInitializers disponibles en la ruta de clases de la aplicación.
• Utilice SpringFactoriesLoader para buscar y cargar todos los ApplicationListeners disponibles en la ruta de clases de la aplicación.
• Deduzca y establezca la clase de definición del método principal.

(2) Después de que se completa la inicialización de la instancia de SpringApplication y se completa la configuración, se ejecuta la lógica del método de ejecución. Al comienzo de la ejecución del método, todos los SpringApplicationRunListeners que SpringFactoriesLoader puede encontrar y cargar se recorren y cargan. Llame a su método started () para decirle a estos SpringApplicationRunListener, "¡Oye, la aplicación SpringBoot está a punto de comenzar la ejecución!".

(3) Cree y configure el entorno que utilizará la aplicación Spring Boot actual (incluidos PropertySource y el perfil a configurar).

(4) Recorra los métodos environmentPrepared () que llaman a todos los SpringApplicationRunListener y les dicen: "¡El entorno utilizado por la aplicación SpringBoot actual está listo!".

(5) Si la propiedad showBanner de SpringApplication se establece en true, se imprime el banner.

(6) Según si el usuario ha establecido explícitamente el tipo applicationContextClass y el resultado de la inferencia de la fase de inicialización, decida qué tipo de ApplicationContext debe crearse para la aplicación SpringBoot actual y créelo, y luego decida si agregar ShutdownHook de acuerdo con las condiciones, y decida si usar un BeanNameGenerator personalizado, y decida Ya sea para usar un ResourceLoader personalizado, por supuesto, lo más importante es configurar el Entorno preparado previamente en el ApplicationContext creado.

(7) Después de que se crea ApplicationContext, SpringApplication volverá a usar Spring-FactoriesLoader para buscar y cargar todos los ApplicationContext-Initializers disponibles en la ruta de clase, y luego atravesar y llamar a los métodos initialize (applicationContext) de estos ApplicationContextInitializers para procesar aún más el ApplicationContext creado .

(8) Recorra y llame a todos los métodos contextPrepared () de SpringApplicationRunListener.

(9) El paso más importante es cargar todas las configuraciones obtenidas previamente a través de @EnableAutoConfiguration y otras formas de configuración de contenedores de IoC en el ApplicationContext preparado.

(10) Recorra y llame a todos los métodos contextLoaded () de SpringApplicationRunListener.

(11) Llame al método refresh () de ApplicationContext para completar el último proceso disponible para el contenedor de IoC.

(12) Averigüe si hay CommandLineRunners registrados en el ApplicationContext actual, y si es así, recorra y ejecútelos.

(13) En circunstancias normales, recorra y ejecute el método terminado () de SpringApplicationRunListener, (si todo el proceso es anormal, el método terminado () de todo SpringApplicationRunListener todavía se llama, pero en este caso, la información de la excepción se pasará para su procesamiento)

Después de eliminar el punto de notificación de eventos, todo el proceso es el siguiente:

Este artículo toma como ejemplo la depuración de un programa de inicio SpringBoot real y se refiere al diagrama de clases principal en el proceso para analizar su lógica de inicio y principios de configuración automática.

Visión general:

La imagen de arriba es el diagrama de estructura de inicio de SpringBoot. Descubrimos que el proceso de inicio se divide principalmente en tres partes:

• La primera parte es el módulo de inicialización de SpringApplication y configura algunas variables de entorno básicas, recursos, constructores y oyentes;
• La segunda parte implementa el plan de inicio específico de la aplicación, incluido el módulo de monitoreo del proceso de inicio, el módulo de entorno de configuración de carga y el módulo de entorno de contexto de creación del núcleo;
• La tercera parte es el módulo de configuración automática, que es el núcleo de la configuración automática de springboot, que se discutirá en detalle en el siguiente análisis. En el siguiente procedimiento de inicio conectaremos las funciones principales de la estructura en serie.

puesta en marcha:

Cada programa SpringBoot tiene una entrada principal, es decir, el método principal. En main, se llama a SpringApplication.run () para iniciar todo el programa SpringBoot. La clase donde se encuentra el método debe anotarse con @SpringBootApplication y @ImportResource (si es necesario), @ SpringBootApplication incluye tres anotaciones, las funciones son las siguientes:

• @EnableAutoConfiguration: SpringBoot configura automáticamente el marco de Spring en función de las dependencias declaradas por la aplicación.
• @SpringBootConfiguration (internamente @Configuration): la clase marcada es igual al archivo de configuración XML de primavera (applicationContext.xml), que ensambla todas las transacciones de frijoles y proporciona un entorno de contexto de primavera.
• @ComponentScan: escaneo de componentes, que puede descubrir y ensamblar Beans automáticamente. De forma predeterminada, se escanea el archivo en la ruta del paquete de Booter.class en el método de ejecución de SpringApplication, por lo que es mejor poner la clase de inicio en la ruta del paquete raíz.

Clase de inicio SpringBoot

Primero ingrese el método de ejecución: En el

método de ejecución, se crea una instancia de SpringApplication. En el método de construcción, podemos encontrar que ha llamado a un método de inicialización inicializado.

Aquí se trata principalmente de asignar algunos valores iniciales al objeto SpringApplication. Después de que se ejecuta el constructor, regresamos al método de ejecución

Los siguientes pasos clave se implementan en este método:
1. Cree el detector de aplicaciones SpringApplicationRunListeners y comience a escuchar

2. Cargue el entorno de configuración SpringBoot (ConfigurableEnvironment), si se publica a través del contenedor web, cargará el StandardEnvironment, que eventualmente hereda el ConfigurableEnvironment, el diagrama de clases es el siguiente:

Se puede ver que * Environment finalmente implementa la interfaz PropertyResolver.Cuando generalmente obtenemos el método value correspondiente a la Key especificada en el archivo de configuración a través del objeto environment, llamamos al método getProperty de la interfaz propertyResolver.

3. Configure el entorno (Entorno) para unirse al objeto de escucha (SpringApplicationRunListeners)

4. Cree el objeto de retorno del método de ejecución: ConfigurableApplicationContext (contexto de configuración de la aplicación), podemos mirar el método de creación: el

método primero obtendrá el contexto de la aplicación establecido explícitamente (applicationContextClass), si no existe, luego cargará la configuración del entorno predeterminado (a través de si Es un juicio de entorno web), el contexto de anotación AnnotationConfigApplicationContext se selecciona por defecto (al escanear todas las clases de anotación para cargar el bean), y finalmente el objeto de contexto se instancia a través de BeanUtils y se devuelve.

El diagrama de clases ConfigurableApplicationContext es el siguiente:

Depende principalmente de las dos direcciones de su herencia:

• LifeCycle: clase de ciclo de vida, que define si el inicio comienza, la parada finaliza e isRunning ejecuta un método de valor nulo de ciclo de vida medio
• ApplicationContext: clase de contexto de aplicación, que principalmente hereda beanFactory (clase de fábrica de frijoles)

5. Volviendo al método de ejecución, el método prepareContext asocia componentes importantes como oyentes, entorno, applicationArguments y banner con el objeto de contexto.

6. El siguiente método refreshContext (context) (el método de inicialización es el siguiente) será la clave para realizar la configuración automática de spring-boot-starter- * (mybatis, redis, etc.), incluida la carga de spring.factories, la instanciación de beans y otras tareas principales .

Después de la configuración, Springboot hizo un trabajo de acabado básico y devolvió el contexto del entorno de la aplicación. Recordando el proceso general, el inicio de Springboot crea principalmente un entorno de configuración (entorno), oyentes de eventos (oyentes) y contexto de aplicación (applicationContext). En función de las condiciones anteriores, comenzamos a crear una instancia de los beans que necesitamos en el contenedor. Hasta ahora, lo iniciamos a través de SpringBoot. El programa ha sido construido, analicemos cómo realizar la configuración automática.

Configuración automática:

En el diagrama de estructura de inicio anterior, notamos que tanto la inicialización de la aplicación como el proceso de ejecución específico han invocado el módulo de configuración automática SpringBoot.

Módulo de configuración automática SpringBoot

El módulo de configuración utiliza principalmente SpringFactoriesLoader, el cargador de fábrica de Spring. El objeto proporciona el método loadFactoryNames. Los parámetros de entrada son factoryClass y classLoader, lo que significa que el nombre de la clase de fábrica y el cargador de clases correspondiente en la figura anterior deben pasarse. El método se basará en El cargador de clases especificado carga el archivo especificado en la ruta de búsqueda del sumador de clases, es decir, el archivo spring.factories. La clase de fábrica pasada es la interfaz y la clase correspondiente en el archivo es la clase de implementación de la interfaz, o finalmente como la clase de implementación, por lo que El archivo es generalmente una colección de uno a muchos de nombres de clase, como se muestra en la figura siguiente. Después de obtener los nombres de clase de estas clases de implementación, el método loadFactoryNames devuelve una colección de nombres de clase. Una vez que el llamador del método obtiene estas colecciones, los objetos de clase de estas clases se obtienen mediante reflexión. , Método de construcción, y finalmente generar una instancia.

Interfaz de fábrica y sus varios nombres de interfaz de clase de implementación

La siguiente figura nos ayuda a comprender el proceso de configuración automática.

Diagrama de relación de componentes clave de configuración automática SpringBoot

Los archivos META-INF de mybatis-spring-boot-starter, spring-boot-starter-web y otros componentes contienen el archivo spring.factories. En el módulo de configuración automática, SpringFactoriesLoader recopila el nombre completo de la clase en el archivo y devuelve un nombre completo de la clase. Se crea una instancia del nombre completo de la clase devuelta mediante la reflexión para formar una instancia de fábrica concreta, y la instancia de fábrica genera los beans que el componente necesita específicamente.

Anteriormente mencionamos la anotación EnableAutoConfiguration, y su diagrama de clases es el siguiente:

puede encontrar que finalmente implementa ImportSelector (selector) y BeanClassLoaderAware (middleware de cargador de clases de bean), centrándose en el método selectImports de AutoConfigurationImportSelector.

Este método se ejecuta antes de que se instancia el bean de proceso de inicio de springboot, y devuelve una lista de información de clase para instanciar. Sabemos que si se obtiene la información de la clase, Spring puede cargar naturalmente la clase en el jvm a través del cargador de clases.Ahora hemos confiado en los componentes que necesitamos a través del método de dependencia de arranque de arranque de primavera, entonces la información de clase de estos componentes está en el método de selección El medio también se puede obtener, no te preocupes, seguimos analizando a la baja.

El método getCandidateConfigurations en este método, aprendido a través de la anotación del método, devuelve una lista de nombres de clases de clases de configuración automática, el método llama al método loadFactoryNames, verifique este método

En el código anterior, puede ver que el configurador automático encontrará la clave correspondiente en todos los archivos spring.factories debajo de la ruta del sistema del proyecto de acuerdo con el factoryClass.getName () importado, y cargará las clases dentro. Seleccionemos el archivo spring.factories en mybatis-spring-boot-autoconfigure

Ingrese org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration, mire principalmente el encabezado de la clase:

Descubrí que Spring's @Configuration es como un springBean marcado por anotaciones. Continúe mirando hacia abajo:

• @ConditionalOnClass ({SqlSessionFactory.class,
  SqlSessionFactoryBean.class}): la
  clase de configuración MybatisAutoConfiguration se analiza cuando hay dos clases de SqlSessionFactory.class y SqlSessionFactoryBean.class, de lo contrario, esta clase de configuración no se utilizará, no será necesario cambiar esta clase. Para devolver el objeto de sesión, debe haber una clase relacionada con la fábrica de sesiones.
• @CondtionalOnBean (DataSource.class): solo procesa el origen de datos que se ha declarado como bean.
• @ConditionalOnMissingBean (MapperFactoryBean.class) Esta anotación significa que si el bean especificado por nombre no existe en el contenedor, se creará una inyección de bean, de lo contrario no se ejecutará (el código fuente de esta clase es más largo y el límite de espacio no es suficiente para pegar)

La configuración anterior puede garantizar que los componentes requeridos por mybatis, como sqlSessionFactory, sqlSessionTemplate y dataSource, se puedan configurar automáticamente. La anotación @Configuration ha proporcionado el entorno de contexto Spring, por lo que el método de configuración de los componentes anteriores se configura a través del archivo mybatis.xml cuando se inicia Spring. A un efecto.

A través del análisis, podemos encontrar que siempre que haya SqlSessionFactory.class, SqlSessionFactoryBean.class en la ruta de clase de un proyecto SpringBoot, y el dataSourceBean se haya registrado en el contenedor, la configuración automatizada se puede activar, lo que significa que solo necesitamos agregar mybatis al proyecto maven Las dependencias requeridas pueden desencadenar la configuración automática, pero si se introduce la dependencia nativa de mybatis, se debe modificar la clase de configuración automática de cada función integrada, y el efecto no se obtendrá de forma inmediata.

Por tanto, Spring-boot nos proporciona un iniciador unificado que puede configurar directamente clases relacionadas, y las dependencias (mybatis) necesarias para activar la configuración automática son las siguientes:

Aquí están todas las dependencias en el archivo pom.xml en el código fuente de mybatis-spring-boot-starter:

Debido a la transitividad de la dependencia de maven, podemos confiar en todas las clases que deben configurarse automáticamente siempre que dependamos del motor de arranque para lograr la funcionalidad lista para usar. También muestra que Springboot simplifica la gran cantidad de configuración XML y la compleja gestión de dependencias que ofrece el marco Spring, lo que permite a los desarrolladores prestar más atención al desarrollo de la lógica empresarial.

Si cree que está bien, puede dar el visto bueno. Si hay alguna deficiencia, puede asesorarlo.

El trabajo no es fácil, la tecnología es así, el salario de CRUD no es alto todos los días, ¡eh! ¡La vida es muy dura! Especialmente este año es más difícil, así que si hay un socio pequeño que necesita encontrar un trabajo o un socio pequeño que necesita aprender, he compilado materiales de aprendizaje de Java y las preguntas de la entrevista de Java de este año, que se pueden proporcionar a todos de forma gratuita. Puede hacer clic para ingresar si lo necesita , y el código: cszq , también puedes seguirme + mensaje privado. ¡Espero ayudar a todos!

Finalmente, ¡te deseo todo lo mejor en tu trabajo!