Spring: comprensión de la inversión de control con un ejemplo

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.
Hay 2 tipos de contenedores IoC:

• BeanFactory 
• ApplicationContext 

Eso significa que si desea usar un contenedor IoC en primavera, necesitamos usar BeanFactory o ApplicationContext. BeanFactory es la versión más básica de los contenedores IoC y ApplicationContext amplía las características de BeanFactory. Las siguientes son algunas de las características principales de Spring IoC,

• Creando Objeto para nosotros,
• Administrar nuestros objetos,
• Ayudando a que nuestra aplicación sea configurable,
• Administrar dependencias

Implementación: ahora entendamos qué es IoC en Spring con un ejemplo. Supongamos que tenemos una interfaz llamada Sim y tiene algunos métodos abstractos que llaman() y datos().

// Java Program to Illustrate Sim Interface
public interface Sim
{
    void calling();
    void data();
}

Ahora hemos creado otras dos clases, Airtel y Jio, que implementan la interfaz Sim y anulan los métodos de la interfaz.

// Java Program to Illustrate Airtel Class
 
// Class
// Implementing Sim interface
public class Airtel implements Sim {
 
    @Override public void calling()
    {
        System.out.println("Airtel Calling");
    }
 
    @Override public void data()
    {
        System.out.println("Airtel Data");
    }
}

// Java Program to Illustrate Jio Class
 
// Class
// Implementing Sim interface
public class Jio implements Sim{
    @Override
    public void calling() {
        System.out.println("Jio Calling");
    }
 
    @Override
    public void data() {
        System.out.println("Jio Data");
    }
}

 
Ahora llamemos a estos métodos dentro del método principal. Entonces, al implementar el concepto de polimorfismo en tiempo de ejecución , podemos hacer algo como esto

// Java Program to Illustrate Mobile Class
 
// Class
public class Mobile {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating instance of Sim interface
        // inside main() method
        // with reference to Jio class constructor
        // invocation
        Sim sim = new Jio();
 
        // Sim sim = new Airtel();
 
        sim.calling();
        sim.data();
    }
}

 
Pero, ¿qué sucede si en el futuro llega otro nuevo Sim Vodafone y necesitamos cambiar nuevamente el nombre de la clase secundaria en el código, así?

Sim sim = new Vodafone();

Así que tenemos que hacer nuestra configuración en el código fuente. Entonces, ¿cómo hacerlo configurable? No queremos tocar el código fuente de esto. El código fuente debe ser constante. ¿Y cómo podemos lograrlo? Aquí Spring IoC entra en escena. Entonces, en este ejemplo, usaremos ApplicationContext para implementar un contenedor IoC. Primero, tenemos que crear un archivo XML y nombrar el archivo como » beans.xml «.

Ejemplo: archivo beans.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans.xsd">
 
  <bean id="sim" class="Jio"></bean>
 
</beans>

 
Salida Explicación: En el archivo beans.xml, hemos creado beans . Entonces, dentro de la identificación, tenemos que pasar la identificación única y dentro de la clase, tenemos que pasar el nombre de la clase para la que desea crear el bean. Más adelante, dentro del método principal, podemos modificarlo que se describirá en el próximo programa.

Definición de Bean : En Spring, los objetos que forman la columna vertebral de su aplicación y que son administrados por el contenedor Spring IoC se denominan beans. Un bean es un objeto que es instanciado, ensamblado y administrado por un contenedor Spring IoC.

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class Mobile {
    public static void main(String[] args) {
        // Using ApplicationContext tom implement Spring IoC
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
         
        // Get the bean
        Sim sim = applicationContext.getBean("sim", Sim.class);
         
        // Calling the methods
        sim.calling();
        sim.data();
    }
}

Producción:

Jio Calling
Jio Data

Y ahora, si desea usar el simulador de Airtel, debe cambiar solo dentro del archivo beans.xml . El método principal va a ser el mismo.

<bean id="sim" class="Airtel"></bean>

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class Mobile {
    public static void main(String[] args) {
       
        // Using ApplicationContext tom implement Spring IoC
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
         
        // Get the bean
        Sim sim = applicationContext.getBean("sim", Sim.class);
         
        // Calling the methods
        sim.calling();
        sim.data();
    }
}

Producción:

Airtel Calling
Airtel Data