Spring Boot – Configuración

Vimos anteriormente que se puede hacer la inyección de dependencias por medio de archivos xml y usando anotaciones; sin embargo también podemos usar clases de configuración para instanciar objetos de manera fácil y limpia.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class AppConfig {
     
    @Bean("student")
    public Student getStudent(Service service) {
        return new StudentImpl(service);
    }
     
    @Bean("service")
    public Service getService() {
        return new ServiceImpl();
    }
}

La ventaja de este método es que permite liberar a las clases de negocio de anotaciones, dejándolas limpias.

La clave es marcar la clase con el decorador @Configuration, es cual es procesado por el Spring IoC, que en este caso crea las instancias marcadas con @Bean.

Veamos un ejemplo muy básico:

1. Creamos una interfaz con un método de prueba:

   public interface Service {
       String hello();
   }

2. Creamos la implementación del servicio:

   public class ServiceImpl implements Service {
       @Override
       public String hello() {
           return "Hola";
       }
   }

3. Creamos el archivo de configuración:

   @Configuration
   public class Config {
       @Bean("service")
       public Service getService() {
           Service myService = new ServiceImpl();
           System.out.println(myService.hello());
           return myService;
       }
   }

   Lo que hacemos es instanciar la implementación e imprimir en consola el String que viene del método hello, lo que resulta que al ejecutar la aplicación veamos un “hola” en consola.

     .   ____          _            __ _ _
    /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
   ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
    \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
     '  |____| .__|_| |_|_| |_\__, | / / / /
    =========|_|==============|___/=/_/_/_/
    :: Spring Boot ::                (v2.7.0)
   
   Hola

Al ser una clase Java obtenemos las ventajas propias del lenguaje, como asegurarnos del tipado correcto, comprobación en tiempo de compilación y algo mas amigable para la lectura.

También si se desea, podemos usar las anotaciones en conjunto con con las clases de configuración.