Resorte: anotación requerida

Considere un escenario en el que un desarrollador desea convertir algunos de los campos en campos obligatorios. Al usar Spring Framework , un desarrollador puede usar la anotación @Required en esos campos al transferir la responsabilidad de dicha verificación al contenedor. Por lo tanto, el contenedor debe verificar si esos campos se están configurando o no.

• Spring Framework admite varias anotaciones personalizadas de Java 5+.
• A partir de Spring 2.0, en lugar de usar XML para describir el cableado de un bean, el desarrollador puede realizar la configuración en la propia clase del componente mediante el uso de anotaciones en la clase, el método o la declaración de campo relevantes.
• Introdujo la posibilidad de hacer cumplir las propiedades requeridas con la anotación @Required y puede registrarse como definiciones de beans individuales.

@Anotación requerida

1. La anotación @Required está disponible en el paquete org.springframework.beans.factory.annotation desde 2.0.

org.springframework.beans.factory.anotación

Tipo de anotación Obligatorio

En desuso a partir de 5.1, a favor de usar la inyección de constructor para la configuración requerida.

2. Se aplica a los métodos de establecimiento de propiedades de bean.

3. Proporciona una anotación a nivel de método que se aplica a los métodos de establecimiento de propiedades de bean para hacer que la inyección de establecimiento sea obligatoria. Esto significa que se puede usar para marcar una propiedad como ‘requerida-para-establecerse’.

4. Para que el contenedor verifique el método anotado (setter) de una clase si está configurado para inyectar dependencia con un valor o no. De lo contrario, el contenedor lanzará una excepción en tiempo de ejecución.

5. Esta anotación indica que la propiedad del bean afectado debe completarse en el momento de la configuración: ya sea a través de un valor de propiedad explícito en una definición de bean o mediante cableado automático.

@Deprecated
@Retention(value=RUNTIME)
@Target(value=METHOD)
public @interface Required

Simplemente anotar las propiedades ‘setter’ de las clases no es suficiente para obtener el comportamiento requerido, un desarrollador debe habilitar o activar la anotación @Required para que pueda procesarse adecuadamente. Podemos habilitar la anotación @Required de dos maneras en la configuración de Spring XML:

• Ya sea registrando RequiredAnnotationBeanPostProcessor en la definición del bean.
• O puede registrarse implícitamente al incluir la etiqueta <context:annotation-config/> en una configuración de Spring basada en XML.

Método 1: RequiredAnnotationBeanPostProcessor

1. Spring proporciona la interfaz BeanPostProcessor y sus clases de implementación que imponen la configuración de las propiedades JavaBean requeridas.

2. Si un desarrollador quiere implementar alguna lógica personalizada después de que el contenedor Spring termine de crear instancias, configurar e inicializar un bean, puede usar una o más implementaciones de BeanPostProcessor.

3. Esta interfaz define métodos de devolución de llamada que los desarrolladores pueden implementar para proporcionar su propia lógica de creación de instancias, lógica de resolución de dependencia, etc.

Un ejemplo es RequiredAnnotationBeanPostProcessor de Spring : una implementación especial de BeanPostProcessor que es @Required-aware que garantiza que las propiedades de JavaBean estén marcadas con una anotación @Required debe inyectarse como dependencia con un valor.

java.lang.Object
org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor
Class RequiredAnnotationBeanPostProcessor

Ilustración:

@Deprecated
public class RequiredAnnotationBeanPostProcessor
extends Object
implements SmartInstantiationAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware

• Una vez que RequiredAnnotationBeanPostProcessor se define en el archivo de configuración Spring XML, después de completar la creación de instancias, la configuración y la inicialización de un bean, el contenedor verificará si la propiedad del bean afectado se ha completado o no; de lo contrario, generará una excepción.
• Esto permite fallas ansiosas y explícitas y evita cualquier excepción más adelante.

Podemos usar RequiredAnnotationBeanPostProcessor en el archivo de configuración Spring XML como se muestra a continuación.

Ejemplo:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
 
    <bean class="org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor" />
 
</beans>

Método 2: contexto: anotación-config

1. <context:annotation-config/> busca las anotaciones en beans en el mismo contexto de aplicación en el que está definido.

2. Esto se usa principalmente para activar las anotaciones de inyección de dependencia como @Required, @Autowired, @PostConstruct, @PreDestroy, etc.

Podemos usar <context:annotation-config/> en el archivo Spring XML como se muestra a continuación.

Ejemplo:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
 
    <context:annotation-config/>
 
</beans>

Nota: Ya se registrará un RequiredAnnotationBeanPostProcessor predeterminado si está utilizando la etiqueta XML «context:annotation-config». Puede eliminar o desactivar la configuración de anotación predeterminada si la intención es especificar una definición de bean RequiredAnnotationBeanPostProcessor personalizada.

Implementación: Crearemos una aplicación Java básica usando Spring para mostrar un título, nombre de sujeto e ID. Los pasos son los siguientes:

1. Cree una aplicación Java y agréguele los archivos de biblioteca Spring necesarios.
2. Cree una clase de bean para definir las propiedades, los métodos getter y setter.
3. Cree el archivo de configuración Spring XML.
4. Cree una clase de prueba para ejecutar la aplicación.

Paso 1: Cree una aplicación Java y agréguele los archivos de biblioteca Spring necesarios

• En este ejemplo, estamos usando Eclipse IDE. Cree una aplicación Java en Eclipse.
• Descargue los archivos Spring jar necesarios del repositorio Maven y agréguelos al proyecto Java.
• A continuación se mostrará la estructura del proyecto después de crear todas las clases necesarias.

Estructura del proyecto

Paso 2: Cree una clase de bean para definir las propiedades, los métodos getter y setter. Cree una clase de bean Java para definir todas las propiedades requeridas y sus métodos getter/setter. ( AsuntoBean.java)

Ejemplo:

package com.beans;
 
import org.springframework.beans.factory.annotation.Required;
 
public class SubjectBean {
 
    private Integer subId;
    private String subName;
 
    @Required
    public void setSubName(String subName) {
        this.subName = subName;
    }
 
    public String getSubName() {
        return subName;
    }
 
    public Integer getSubId() {
        return subId;
    }
 
    public void setSubId(Integer subId) {
        this.subId = subId;
    }
 
}

• Creó un JavaBean llamado » SubjectBean » con dos propiedades subName y subId.
• Marque el método de establecimiento de subName como @Required, de modo que la propiedad debe establecerse con un valor, un campo obligatorio.

Paso 3: Cree un archivo de configuración Spring XML. Para configurar los valores del bean, defínalos en el archivo de configuración XML.

Archivo: applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
 
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
     
    <!-- use any one of the below bean definition to activate/enable the @Required annotation -->
     
    <!-- Method 1: -->
    <bean class="org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor" />
     
    <!-- or -->
     
    <!-- Method 2:
    <context:annotation-config/> -->
     
    <bean id="subjectBean" class="com.beans.SubjectBean">
        <property name="subName" value="Java Spring - Annotations" />
        <property name="subId" value="1002" />
    </bean>
 
</beans>

• Como se explicó anteriormente, podemos usar cualquiera de los RequiredAnnotationBeanPostProcessor o context:annotation-config para habilitar la anotación.
• Cree un objeto bean para la clase SubjectBean y establezca los valores de los parámetros usando la etiqueta de propiedad como se muestra.

Paso 4 : Cree una clase de prueba para ejecutar la aplicación.

Cree SubjectBeanTest.java para obtener el bean e imprimir los valores de propiedad.

Archivo: SubjectBeanTest.java

package com.test;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.beans.SubjectBean;
 
public class SubjectBeanTest {
 
    public static void main(String[] args) throws Exception {
 
        ApplicationContext con = new ClassPathXmlApplicationContext("com/resource/applicationContext.xml");
        SubjectBean subject = (SubjectBean) con.getBean("subjectBean");
         
        System.out.println("Welcome to GeeksforGeeks");
        System.out.println("Subject Name: "+ subject.getSubName());
        System.out.println("Subject ID: "+ subject.getSubId());
    }
 
}

• Cree el objeto ApplicationContext y obtenga el objeto bean.
• Imprime los valores de propiedad en la consola.

Ejecución/Salida:

• Después de crear las clases necesarias y el archivo XML, ejecute el proyecto como aplicación Java.
• La salida debe ser la siguiente,

Producción

• Ahora, para verificar la anotación @Required, elimine/comente el valor de propiedad de subName en el archivo XML como se muestra a continuación,

<?xml version="1.0" encoding="UTF-8"?>
 
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
     
    <!-- use any one of the below bean definition to activate/enable the @Required annotation -->
     
    <!-- Method 1: -->
    <bean class="org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor" />
     
    <!-- or -->
     
    <!-- Method 2:
    <context:annotation-config/> -->
     
    <bean id="subjectBean" class="com.beans.SubjectBean">
        <!-- <property name="subName" value="Java Spring - Annotations" /> -->
        <property name="subId" value="1002" />
    </bean>
 
</beans>

• Aquí, solo estamos configurando el valor de subId.
• Ahora, vuelva a ejecutar el proyecto como una aplicación Java. Obtendremos el siguiente error.

ADVERTENCIA: se encontró una excepción durante la inicialización del contexto: se canceló el intento de actualización: org.springframework.beans.factory.BeanCreationException: error al crear el bean con el nombre ‘subjectBean’ definido en el recurso de ruta de clase [com/resource/applicationContext.xml]: la inicialización del bean falló; la excepción anidada es org.springframework.beans.factory.BeanInitializationException: se requiere la propiedad ‘subName’ para el bean ‘subjectBean’

Excepción en el subproceso «principal» org.springframework.beans.factory.BeanCreationException: error al crear el bean con el nombre ‘subjectBean’ definido en el recurso de ruta de clase [com/resource/applicationContext.xml]: error en la inicialización del bean; la excepción anidada es org.springframework.beans.factory.BeanInitializationException: se requiere la propiedad ‘subName’ para el bean ‘subjectBean’

en org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:587)

en org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:501)

en org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:317)

en org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:228)

en org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:315)

en org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:199)

en org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:760)

en org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:869)

en org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:550)

en org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:144)

en org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:85)

en com.test.SubjectBeanTest.main(SubjectBeanTest.java:12)

Provocado por: org.springframework.beans.factory.BeanInitializationException: se requiere la propiedad ‘subName’ para el bean ‘subjectBean’

en org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor.postProcessPropertyValues(RequiredAnnotationBeanPostProcessor.java:156)

en org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1344)

en org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:578)

… 11 más

El contenedor verificará si la propiedad subName está inicializada o no. Aquí no estamos estableciendo el valor. Por lo tanto, el contenedor arroja la excepción que dice «Se requiere la propiedad ‘subName’ para el bean ‘subjectBean'» .

Conclusión: De esta manera, podemos usar la anotación @Required para los métodos de establecimiento en los frijoles de primavera para que al darle al contenedor de primavera la responsabilidad de verificar si se están configurando los valores de propiedad requeridos.