Primavera – ApplicationContext

El contenedor Spring IoC es responsable de instanciar, cablear, configurar y administrar todo el ciclo de vida de los objetos. BeanFactory y ApplicationContext representan los contenedores Spring IoC. ApplicationContext es la subinterfaz de BeanFactory. BeanFactory proporciona funcionalidades básicas y se recomienda su uso para aplicaciones ligeras como dispositivos móviles y applets. ApplicationContext proporciona funciones básicas además de funcionalidades específicas de la empresa, que son las siguientes:

• Publicación de eventos para oyentes registrados mediante la resolución de archivos de propiedades.
• Métodos para acceder a los componentes de la aplicación.
• Apoya la Internacionalización.
• Cargar recursos de archivo de forma genérica.

Nota: Debido a estas características adicionales, los desarrolladores prefieren usar ApplicationContext sobre BeanFactory. 

Clases de implementación de ApplicationContext

Hay diferentes tipos de contenedores de aplicaciones proporcionados por Spring para diferentes requisitos, como se enumeran a continuación, que más adelante se describen junto con la declaración y, por último, brindan un ejemplo para pasar por la parte de implementación con las ayudas pictóricas. Los contenedores son los siguientes:

1. Contenedor AnnotationConfigApplicationContext 
2. AnotaciónConfigWebApplicationContext
3. XmlWebApplicationContextXmlWebApplicationContext

Contenedor 1: AnnotationConfigApplicationContext

La clase AnnotationConfigApplicationContext se introdujo en Spring 3.0. Acepta clases anotadas con @Configuration, @Component y clases compatibles con JSR-330. El constructor de AnnotationConfigApplicationContext acepta una o más clases. Por ejemplo, en la siguiente declaración, dos clases de configuración Appconfig y AppConfig1 se pasan como argumentos al constructor. Los beans definidos en clases posteriores anularán los beans del mismo tipo y nombre en clases anteriores cuando se pasen como argumentos. Por ejemplo, AppConfig y AppConfig1 tienen la misma declaración de bean. El bean definido en AppConfig1 anula el bean en AppConfig.

Sintaxis: Declaración

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class, AppConfig1.class);

Nota: agregue lo siguiente al archivo de propiedades en el IDE para permitir que Spring anule los beans.

spring.main.allow-bean-definition-overriding=true

Contenedor 2: AnnotationConfigWebApplicationContext

La clase AnnotationConfigWebApplicationContext se introdujo en Spring 3.0. Es similar a AnnotationConfigApplicationContext para un entorno web. Acepta clases anotadas con @Configuration, @Component y clases compatibles con JSR-330. Estas clases se pueden registrar a través del método register() o pasando paquetes base al método scan() . Esta clase se puede usar cuando configuramos el detector de servlet ContextLoaderListener o un DispatcherServlet en un web.xml. A partir de Spring 3.1, esta clase se puede instanciar e inyectar en DispatcherServlet utilizando código Java mediante la implementación de WebApplicationInitializer, una alternativa a web.xml.

Ejemplo 

// Class
// Implementing WebApplicationInitializer
public class MyWebApplicationInitializer implements WebApplicationInitializer {

  // Servlet container

  public void onStartup(ServletContext container) throws ServletException {
    AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
    context.register(AppConfig.class);
    context.setServletContext(container);

    // Servlet configuration
  }
}

Contenedor 3: XmlWebApplicationContext

La aplicación web Spring MVC se puede configurar completamente usando código XML o Java. La configuración de este contenedor es similar al contenedor AnnotationConfigWebApplicationContext, lo que implica que podemos configurarlo en web.xml o usando código java.

// Class
// Implementing WebApplicationInitializer
public class MyXmlWebApplicationInitializer implements WebApplicationInitializer {

  // Servlet container
  public void onStartup(ServletContext container) throws ServletException {
    XmlWebApplicationContext context = new XmlWebApplicationContext();
    context.setConfigLocation("/WEB-INF/spring/applicationContext.xml");
    context.setServletContext(container);

    // Servlet configuration
  }
}

Contenedor 4: FileSystemXmlApplicationContext

FileSystemXmlApplicationContext se utiliza para cargar archivos de configuración Spring basados ​​en XML desde el sistema de archivos o desde la URL. Podemos obtener el contexto de la aplicación usando código Java. Es útil para entornos independientes y arneses de prueba. El siguiente código muestra cómo crear un contenedor y usar el XML como información de metadatos para cargar los beans.

Ilustración:

String path = "Documents/demoProject/src/main/resources/applicationcontext/student-bean-config.xml";

ApplicationContext context = new FileSystemXmlApplicationContext(path);
AccountService accountService = context.getBean("studentService", StudentService.class);

Contenedor 5: ClassPathXmlApplicationContext

FileSystemXmlApplicationContext se usa para cargar archivos de configuración de Spring basados ​​en XML desde el classpath. Podemos obtener el contexto de la aplicación usando código Java. Es útil para entornos independientes y arneses de prueba. El siguiente código muestra cómo crear un contenedor y usar el XML como información de metadatos para cargar los beans.

Ilustración:

ApplicationContext context = new ClassPathXmlApplicationContext("applicationcontext/student-bean-config.xml");
StudentService studentService = context.getBean("studentService", StudentService.class);

Ahora, implementemos lo mismo mostrando un ejemplo que es el siguiente:

Implementación:

• Cree un proyecto Spring usando Spring Initializer . 
• Crear clase de estudiante en com.gfg.demo.domain
• Del mismo modo, la clase AppConfig en los paquetes com.gfg.demo.config.
• La clase de aplicación principal en la raíz contiene la creación de un contenedor.
• Por último, el método SpringApplication.run() se proporciona de forma predeterminada en la clase principal cuando se crea el proyecto SpringBoot.

Ejemplo

Paso 1: crear un proyecto Spring usando Spring Initializer como se muestra a continuación.

Paso 2: cree la clase Student en com.gfg.demo.domain y la clase AppConfig en los paquetes com.gfg.demo.config. AppConfig es la clase de configuración que contiene todos los beans Java configurados mediante la configuración basada en Java. La clase Student es la clase POJO .

• Clase 1: clase AppConfig

@Configuration

// Class
public class AppConfig {

  @Bean

  // Method
  public Student student() {

    return new Student(1, "Geek");
  }
}

• Clase 2: Clase de estudiante

// Class
public class Student {

  // member variables
  private int id;
  private String name;

  // Constructor 1
  public Student() {}

  // Constructor 2
  public Student(int id, String name) {
    this.id = id;
    this.name = name;
  }

  // Method of this class
  // @Override
  public String toString() {

    return "Student{" + "id=" + id + ", name='" + name + '\'' + '}';
  }
}

Paso 3: ahora la clase de aplicación principal en la raíz contiene la creación de un contenedor.

// Class
// @SpringBootApplication
public class DemoApplication {

  // Main driver method
  public static void main(String[] args) {

    // SpringApplication.run(DemoApplication.class, args);

    // Creating its object
    ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    Student student = context.getBean(Student.class);

    // Print and display
    System.out.println(student);
  }
}

Paso 4: el método SpringApplication.run() se proporciona de forma predeterminada en la clase principal cuando se crea el proyecto SpringBoot. Crea el contenedor, crea beans, administra la inyección de dependencia y el ciclo de vida de esos beans. Esto se hace usando la anotación @SpringBootApplication .

// Main driver method
public static void main(String[] args) {

  ApplicationContext context = SpringApplication.run(DemoApplication.class, args);

  Student student = context.getBean(Student.class);

  // Print adn display
  System.out.println(student);
}