Primavera: inyección de valores literales mediante inyección de constructor

Spring IoC (Inversion of Control) Container es el núcleo de Spring Framework. Crea los objetos, configura y ensambla sus dependencias, gestiona todo su ciclo de vida. El Contenedor utiliza Inyección de Dependencia (DI) para administrar los componentes que componen la aplicación. Obtiene la información sobre los objetos de un archivo de configuración (XML) o Java Code o Java Annotations y Java POJO class. Estos objetos se llaman Beans. Dado que los desarrolladores no controlan los objetos Java y su ciclo de vida, de ahí el nombre Inversion Of Control. 

Las características principales de Spring IoC son las siguientes:

1. Creando Objeto para nosotros,
2. Administrar nuestros objetos,
3. Ayudando a que nuestra aplicación sea configurable,
4. Administrar dependencias

Inyección de dependencia de primavera

La inyección de dependencia es la funcionalidad principal proporcionada por Spring IOC (Inversion of Control). El módulo Spring-Core es responsable de inyectar dependencias a través de los métodos Constructor o Setter. El principio de diseño de Inversion of Control hace hincapié en mantener las clases de Java independientes entre sí y el contenedor las libera de la creación y el mantenimiento de objetos. Estas clases, administradas por Spring, deben cumplir con la definición estándar de Java-Bean. La inyección de dependencia en Spring también asegura un acoplamiento flexible entre las clases. Hay dos tipos de Spring Dependency Injection.

• Inyección de dependencia del setter (SDI)
• Inyección de dependencia del constructor (CDI)

Sugerencia: para leer más sobre la inyección de dependencias de Spring, consulte el artículo: Inyección de dependencias de Spring con ejemplo

Inyección de constructor

En Constructor Injection, la dependencia de inyección se inyectará con la ayuda de constructores. Ahora, para configurar la Inyección de dependencia como Inyección de dependencia del constructor en el bean, se realiza a través del archivo de configuración del bean. Para ello, la propiedad que se establecerá con el CDI se declara bajo la etiqueta <constructor-arg> en el archivo bean-config.

Aquí discutiremos cómo usar Spring para inyectar nuestras dependencias en nuestros valores literales mediante la inyección del constructor. Los literales en Java son una representación sintética de datos booleanos, numéricos, de caracteres o de string. Es un medio para expresar valores particulares en el programa, como una variable entera llamada »/count se le asigna un valor entero en la siguiente instrucción.

int x = 100; 
// Here 100 is a constant/literal

Ilustración:

String s = "Hello";

Implementación: estamos conspirando en el mismo ejemplo que hemos creado en este artículo Inyectar valores literales mediante inyección de Setter . Cree una clase simple Student que tenga dos atributos id y studentName. Cree métodos setter para estos dos atributos y un método simple para imprimir los detalles del estudiante.

A. Archivo: Student.java 

Ejemplo:

// Java Program to Illustrate Student Class
 
// Class
public class Student {
 
    // Class data members
    private int id;
    private String studentName;
 
    // Getters and setters
    public void setId(int id) { this.id = id; }
    public void setStudentName(String studentName)
    {
        // This keyword refers to current instance itself
        this.studentName = studentName;
    }
 
    // Method
    public void displayInfo()
    {
        // Printing name and corresponding
        // roll number of Student
        System.out.println("Student Name is " + studentName
                           + " and Roll Number is " + id);
    }
}

Lo único que necesitamos cambiar es el archivo beans.xml. Ahora vamos a crear un bean de estudiante en el archivo beans.xml y dentro del bean, debe agregar el nombre de su propiedad y sus valores correspondientes dentro de la etiqueta <constructor-arg> en lugar de la etiqueta <property>, así

Sintaxis: Estándar

<bean id="AnyUniqueId" class="YourClassName">
  <constructor-arg name="attributes that you have defined 
  in your class" value="And its corresponding values"/>  
</bean>

Tengamos algunas ilustraciones para este proyecto para las cuales podemos escribir algo como lo siguiente:

Ilustración 1-A:

<bean id="studentAmiya" class="Student">
  <constructor-arg name="id" value="101"/>
  <constructor-arg name="studentName" value="Amiya Rout"/>
</bean>

Del mismo modo, podemos crear otro bean y poner los valores como este

Ilustración 1-B:

<bean id="studentAsish" class="Student">
  <constructor-arg name="id" value="102"/>
  <constructor-arg name="studentName" value="Asish Rout"/>
</bean>

A continuación se muestra el código completo para el archivo beans.xml

B. Archivo: beans.xml  

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans.xsd">
 
    <bean id="studentAmiya" class="Student">
        <constructor-arg name="id" value="101"/>
        <constructor-arg name="studentName" value="Amiya Rout"/>
    </bean>
 
    <bean id="studentAsish" class="Student">
        <constructor-arg name="id" value="102"/>
        <constructor-arg name="studentName" value="Asish Rout"/>
    </bean>
 
</beans>

Así que ahora nuestros dos frijoles están listos. Ahora vamos a crear una clase y definir el método main() dentro de esa clase. Supongamos que hemos creado un nombre de clase Examen y hemos definido el método main() dentro de esta clase. A continuación se muestra el código de la clase Exam.java. Los comentarios se agregan dentro del código para una mejor comprensión. 

C. Archivo: Examen.java   

Ejemplo:

// Importing required classes
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
// Main class
public class Exam {
   
    // Main driver method
    public static void main(String[] args) {
       
        // Implementing Spring IoC
        // using ApplicationContext 
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
 
        // Getting the bean studentAmiya
        Student amiya = context.getBean("studentAmiya", Student.class);
         
        // Calling the methods
        // inside main() method
        amiya.displayInfo();
 
        // Getting the bean studentAsish
        Student asish = context.getBean("studentAsish", Student.class);
        
        // Calling the methods
        asish.displayInfo();
    }
}

Por último, ejecute el método main() y el resultado será así.

Producción:

Student Name is Amiya Rout and Roll Number is 101
Student Name is Asish Rout and Roll Number is 102