Spring Annotations nos permite configurar dependencias e implementar la inyección de dependencias a través de programas Java. Esas son una forma de metadatos que proporciona datos sobre un programa. La anotación @Required en primavera es una anotación a nivel de método utilizada en el método setter de una propiedad de bean y, por lo tanto, hace que la inyección setter sea obligatoria. Esta anotación sugiere que la propiedad requerida del bean debe inyectarse con un valor en el momento de la configuración que mostraremos y explicaremos en el siguiente ejemplo.
requisitos previos :
Implementación:
Paso 1: Primero, creemos una aplicación Spring simple e inyectemos los valores literales mediante inyección de setter. Por lo tanto, cree una clase simple Student que tenga tres atributos rollNo, name y age. Cree métodos setter para estos dos atributos y un método simple para imprimir los detalles del estudiante.
Archivo: Student.java
Java
// Java Program to Illustrate Student Class
// Class
public class Student {
// Class data members
private int rollNo;
private String name;
private int age;
// Setter
public void setRollNo(int rollNo)
{
this.rollNo = rollNo;
}
// Setter
public void setName(String name) { this.name = name; }
// Setter
public void setAge(int age) { this.age = age; }
// Method
public void display()
{
// Printing attributes of student
System.out.println("Roll No: " + rollNo);
System.out.println("Name: " + name);
System.out.println("Age: " + age);
}
}
Paso 2: Vamos a crear un archivo de propiedades en su classpath y nombrarlo como student-info.properties (para este ejemplo lo llamamos así, puede nombrarlo según sus necesidades). Y en este archivo, vamos a escribir algo como esto
student.rollNo = 201 student.name = Asish student.age = 30
Paso 3: establezcamos los valores del archivo de propiedades utilizando la anotación @Value. Entonces, podemos modificar nuestro archivo Student.java algo como esto
Java
import org.springframework.beans.factory.annotation.Value;
public class Student {
private int rollNo;
private String name;
private int age;
@Value("${student.rollNo}")
public void setRollNo(int rollNo) {
this.rollNo = rollNo;
}
@Value("${student.name}")
public void setName(String name) {
this.name = name;
}
@Value("${student.age}")
public void setAge(int age) {
this.age = age;
}
public void display(){
System.out.println("Roll No: " + rollNo);
System.out.println("Name: " + name);
System.out.println("Age: " + age);
}
}
Paso 4: Ahora vamos a crear un Student Bean en el archivo beans.xml. A continuación se muestra el código completo para el archivo beans.xml
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 https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <context:annotation-config/> <context:property-placeholder location="classpath:student-info.properties"/> <bean id="student" class="Student"> </bean> </beans>
Paso 5: Ahora nuestro frijol está listo. Ahora vamos a crear una clase y definir el método main() dentro de esa clase. Supongamos que hemos creado una clase llamada Main y hemos definido el método main() dentro de esta clase. A continuación se muestra el código de la clase Main.java . Los comentarios se agregan dentro del código para una mejor comprensión.
A. Archivo: Main.java
Java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
// Using ApplicationContext tom implement Spring IoC
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
// Get the bean student
Student student = context.getBean("student", Student.class);
// Calling the methods
student.display();
}
}
Ahora ejecuta tu método main() y el resultado será así.
Producción:
Roll No: 201 Name: Asish Age: 30
Así que nuestra aplicación está funcionando bien. Ahora volvamos al archivo Student.java y eliminemos @Value(“${student.rollNo}”) antes del método setRollNo(). Así que ahora nuestro archivo Student.java modificado es algo así como lo siguiente:
B. Archivo: Student.java
Java
import org.springframework.beans.factory.annotation.Value;
public class Student {
private int rollNo;
private String name;
private int age;
public void setRollNo(int rollNo) {
this.rollNo = rollNo;
}
@Value("${student.name}")
public void setName(String name) {
this.name = name;
}
@Value("${student.age}")
public void setAge(int age) {
this.age = age;
}
public void display(){
System.out.println("Roll No: " + rollNo);
System.out.println("Name: " + name);
System.out.println("Age: " + age);
}
}
Ahora vuelva a ejecutar su método main() y el resultado será así.
Producción:
Roll No: 0 Name: Asish Age: 30
Por lo tanto, se crea el objeto de la clase Student pero no se ha asignado el valor Roll no. Pero queremos que el valor Roll No se complete antes de crear el objeto de clase Student. Puede considerar que Roll no es una clave principal y no queremos que este valor sea nulo. Así que aquí entra en escena la anotación @Required . Entonces, si modificamos nuestro archivo Student.java como los siguientes, obtendremos excepciones en nuestro programa.
C. Archivo: Student.java
Java
import org.springframework.beans.factory.annotation.Required;
import org.springframework.beans.factory.annotation.Value;
public class Student {
private int rollNo;
private String name;
private int age;
@Required
public void setRollNo(int rollNo) {
this.rollNo = rollNo;
}
@Value("${student.name}")
public void setName(String name) {
this.name = name;
}
@Value("${student.age}")
public void setAge(int age) {
this.age = age;
}
public void display(){
System.out.println("Roll No: " + rollNo);
System.out.println("Name: " + name);
System.out.println("Age: " + age);
}
}
Excepción:
Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'student' defined in class path resource [beans.xml]: Initialization of bean failed; nested exception is org.springframework.beans.factory.BeanInitializationException: Property 'rollNo' is required for bean 'student'
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:610)
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:524)
at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:335)
at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:234)
at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:333)
at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:208)
at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:944)
at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:918)
at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:583)
at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:144)
at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:85)
at Main.main(Main.java:7)
Caused by: org.springframework.beans.factory.BeanInitializationException: Property 'rollNo' is required for bean 'student'
at org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor.postProcessPropertyValues(RequiredAnnotationBeanPostProcessor.java:158)
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1418)
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:601)
... 11 more
Entonces, en este escenario, la consola de excepción intenta decirnos que es obligatorio proporcionar el valor a Roll no para crear el objeto de clase Student. Entonces, si desea que algún valor de campo se complete con algún valor, entonces debe usar la anotación @Required. Entonces podemos modificar nuestro archivo Student.java algo como esto de la siguiente manera:
D. Archivo: Student.java
Java
// Java Program to Illustrate Modified Student Class
// Importing required classes
import org.springframework.beans.factory.annotation.Required;
import org.springframework.beans.factory.annotation.Value;
// Class
public class Student {
// Class data members
private int rollNo;
private String name;
private int age;
// Annotation
@Required
@Value("${student.rollNo}")
// Setter
public void setRollNo(int rollNo)
{
this.rollNo = rollNo;
}
// Setter
@Value("${student.name}")
public void setName(String name)
{
// this keyword refers to current instance itself
this.name = name;
}
// Setter
@Value("${student.age}") public void setAge(int age)
{
this.age = age;
}
// Method
public void display()
{
// Display message only
System.out.println("Roll No: " + rollNo);
System.out.println("Name: " + name);
System.out.println("Age: " + age);
}
}
Regrese el programa nuevamente y obtendrá el resultado como se muestra a continuación:
Producción:
Roll No: 0 Name: Asish Age: 30
Publicación traducida automáticamente
Artículo escrito por AmiyaRanjanRout y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA