Spring - Configuración basada en Java

Hasta ahora, ha visto cómo configuramos Spring beans usando un archivo de configuración XML. Si se siente cómodo con la configuración XML, entonces realmente no es necesario que aprenda cómo proceder con la configuración basada en Java, ya que obtendrá el mismo resultado utilizando cualquiera de las configuraciones disponibles.

La opción de configuración basada en Java le permite escribir la mayor parte de su configuración Spring sin XML, pero con la ayuda de algunas anotaciones basadas en Java que se explican en este capítulo.

@Configuration & @Bean Anotaciones

Anotar una clase con el @Configurationindica que el contenedor Spring IoC puede utilizar la clase como fuente de definiciones de beans. los@BeanLa anotación le dice a Spring que un método anotado con @Bean devolverá un objeto que debería registrarse como un bean en el contexto de la aplicación Spring. La clase @Configuration más simple posible sería la siguiente:

package com.tutorialspoint;
import org.springframework.context.annotation.*;

@Configuration
public class HelloWorldConfig {
   @Bean 
   public HelloWorld helloWorld(){
      return new HelloWorld();
   }
}

El código anterior será equivalente a la siguiente configuración XML:

<beans>
   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" />
</beans>

Aquí, el nombre del método está anotado con @Bean funciona como ID de bean y crea y devuelve el bean real. Su clase de configuración puede tener una declaración para más de un @Bean. Una vez que sus clases de configuración están definidas, puede cargarlas y proporcionarlas al contenedor Spring usando AnnotationConfigApplicationContext de la siguiente manera:

public static void main(String[] args) {
   ApplicationContext ctx = new AnnotationConfigApplicationContext(HelloWorldConfig.class);
   
   HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
   helloWorld.setMessage("Hello World!");
   helloWorld.getMessage();
}

Puede cargar varias clases de configuración de la siguiente manera:

public static void main(String[] args) {
   AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();

   ctx.register(AppConfig.class, OtherConfig.class);
   ctx.register(AdditionalConfig.class);
   ctx.refresh();

   MyService myService = ctx.getBean(MyService.class);
   myService.doStuff();
}

Ejemplo

Tengamos un IDE de Eclipse en funcionamiento y sigamos los siguientes pasos para crear una aplicación Spring:

Pasos	Descripción
1	Cree un proyecto con un nombre SpringExample y cree un paquete com.tutorialspoint bajo elsrc carpeta en el proyecto creado.
2	Agregue las bibliotecas Spring requeridas usando la opción Agregar JAR externos como se explica en el capítulo Ejemplo de Spring Hello World .
3	Debido a que está utilizando anotaciones basadas en Java, también debe agregar CGLIB.jar desde su directorio de instalación de Java y la biblioteca ASM.jar , que se puede descargar de asm.ow2.org .
4	Cree clases Java HelloWorldConfig , HelloWorld y MainApp en el paquete com.tutorialspoint .
5	El paso final es crear el contenido de todos los archivos Java y el archivo de configuración de Bean y ejecutar la aplicación como se explica a continuación.

Aquí está el contenido de HelloWorldConfig.java archivo

package com.tutorialspoint;
import org.springframework.context.annotation.*;

@Configuration
public class HelloWorldConfig {
   @Bean 
   public HelloWorld helloWorld(){
      return new HelloWorld();
   }
}

Aquí está el contenido de HelloWorld.java archivo

package com.tutorialspoint;

public class HelloWorld {
   private String message;

   public void setMessage(String message){
      this.message  = message;
   }
   public void getMessage(){
      System.out.println("Your Message : " + message);
   }
}

A continuación se muestra el contenido de la MainApp.java archivo

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.*;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext ctx = 
         new AnnotationConfigApplicationContext(HelloWorldConfig.class);
   
      HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
      helloWorld.setMessage("Hello World!");
      helloWorld.getMessage();
   }
}

Una vez que haya terminado de crear todos los archivos de origen y agregar las bibliotecas adicionales necesarias, ejecutemos la aplicación. Debe tener en cuenta que no se requiere ningún archivo de configuración. Si todo está bien con su aplicación, imprimirá el siguiente mensaje:

Your Message : Hello World!

Inyectar dependencias de frijoles

Cuando @Beans tienen dependencias entre sí, expresar que la dependencia es tan simple como tener un método de bean llamando a otro de la siguiente manera:

package com.tutorialspoint;
import org.springframework.context.annotation.*;

@Configuration
public class AppConfig {
   @Bean
   public Foo foo() {
      return new Foo(bar());
   }
   @Bean
   public Bar bar() {
      return new Bar();
   }
}

Aquí, el bean foo recibe una referencia a bar a través de la inyección del constructor. Ahora veamos otro ejemplo práctico.

Ejemplo

Tengamos un IDE de Eclipse en funcionamiento y sigamos los siguientes pasos para crear una aplicación Spring:

Pasos	Descripción
1	Cree un proyecto con un nombre SpringExample y cree un paquete com.tutorialspoint bajo elsrc carpeta en el proyecto creado.
2	Agregue las bibliotecas Spring requeridas usando la opción Agregar JAR externos como se explica en el capítulo Ejemplo de Spring Hello World .
3	Debido a que está utilizando anotaciones basadas en Java, también debe agregar CGLIB.jar desde su directorio de instalación de Java y la biblioteca ASM.jar , que se puede descargar de asm.ow2.org .
4	Crear clases de Java TextEditorConfig , TextEditor , corrector ortográfico y MainApp bajo la com.tutorialspoint paquete.
5	El paso final es crear el contenido de todos los archivos Java y el archivo de configuración de Bean y ejecutar la aplicación como se explica a continuación.

Aquí está el contenido de TextEditorConfig.java archivo

package com.tutorialspoint;
import org.springframework.context.annotation.*;

@Configuration
public class TextEditorConfig {
   @Bean 
   public TextEditor textEditor(){
      return new TextEditor( spellChecker() );
   }

   @Bean 
   public SpellChecker spellChecker(){
      return new SpellChecker( );
   }
}

Aquí está el contenido de TextEditor.java archivo

package com.tutorialspoint;

public class TextEditor {
   private SpellChecker spellChecker;

   public TextEditor(SpellChecker spellChecker){
      System.out.println("Inside TextEditor constructor." );
      this.spellChecker = spellChecker;
   }
   public void spellCheck(){
      spellChecker.checkSpelling();
   }
}

A continuación se muestra el contenido de otro archivo de clase dependiente SpellChecker.java

package com.tutorialspoint;

public class SpellChecker {
   public SpellChecker(){
      System.out.println("Inside SpellChecker constructor." );
   }
   public void checkSpelling(){
      System.out.println("Inside checkSpelling." );
   }
}

A continuación se muestra el contenido de la MainApp.java archivo

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.*;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext ctx = 
         new AnnotationConfigApplicationContext(TextEditorConfig.class);

      TextEditor te = ctx.getBean(TextEditor.class);
      te.spellCheck();
   }
}

Una vez que haya terminado de crear todos los archivos de origen y agregar las bibliotecas adicionales necesarias, ejecutemos la aplicación. Debe tener en cuenta que no se requiere ningún archivo de configuración. Si todo está bien con su aplicación, imprimirá el siguiente mensaje:

Inside SpellChecker constructor.
Inside TextEditor constructor.
Inside checkSpelling.

La anotación @Import

los @ImportLa anotación permite cargar definiciones de @Bean desde otra clase de configuración. Considere una clase ConfigA de la siguiente manera:

@Configuration
public class ConfigA {
   @Bean
   public A a() {
      return new A(); 
   }
}

Puede importar la declaración Bean anterior en otra Declaración Bean de la siguiente manera:

@Configuration
@Import(ConfigA.class)
public class ConfigB {
   @Bean
   public B b() {
      return new B(); 
   }
}

Ahora, en lugar de tener que especificar ConfigA.class y ConfigB.class al crear una instancia del contexto, solo se debe proporcionar ConfigB de la siguiente manera:

public static void main(String[] args) {
   ApplicationContext ctx = new AnnotationConfigApplicationContext(ConfigB.class);
   
   // now both beans A and B will be available...
   A a = ctx.getBean(A.class);
   B b = ctx.getBean(B.class);
}

Devoluciones de llamada del ciclo de vida

La anotación @Bean admite la especificación de métodos de devolución de llamada de inicialización y destrucción arbitrarios, al igual que los atributos init-method y destroy-method de Spring XML en el elemento bean -

public class Foo {
   public void init() {
      // initialization logic
   }
   public void cleanup() {
      // destruction logic
   }
}
@Configuration
public class AppConfig {
   @Bean(initMethod = "init", destroyMethod = "cleanup" )
   public Foo foo() {
      return new Foo();
   }
}

Especificar el alcance del frijol

El alcance predeterminado es singleton, pero puede anularlo con la anotación @Scope de la siguiente manera:

@Configuration
public class AppConfig {
   @Bean
   @Scope("prototype")
   public Foo foo() {
      return new Foo();
   }
}