Inyectar propiedades de Spring Boot con @Value

Configurar propiedades personalizadas en Spring Boot y consumirlas desde clases de configuración es una habilidad fundamental para cualquier desarrollador Java. Aquí se explica paso a paso cómo definir valores en el archivo application.properties, inyectarlos con la anotación @Value y exponerlos a través de un bean con su respectiva interfaz e implementación.

¿Cómo se definen propiedades en application.properties?

El archivo application.properties es el punto central donde Spring Boot almacena configuraciones. Dentro de él se pueden crear propiedades personalizadas con una sintaxis sencilla de clave-valor [00:18]:

• name=Michael — define el nombre.
• apellido=García — define el apellido.
• random=random.value — aprovecha la propiedad random.value que Spring Boot ofrece por defecto para generar valores aleatorios.

Estas tres líneas bastan para tener datos listos para ser consumidos en cualquier parte de la aplicación.

¿Cómo se inyectan propiedades con la anotación @Value?

Una vez creadas las propiedades, se necesita una clase de configuración para leerlas. Dentro del paquete configuration se crea una clase llamada GeneralConfiguration anotada con @Configuration [01:05]. Este estereotipo le indica a Spring que la clase contendrá definiciones de beans y configuraciones.

Para traer cada valor del archivo properties se utiliza la anotación @Value con la sintaxis ${nombrePropiedad} [01:22]:

java @Configuration public class GeneralConfiguration {

@Value("${name}")
private String name;

@Value("${apellido}")
private String apellido;

@Value("${random}")
private String random;

}

El patrón ${} resuelve en tiempo de ejecución el valor almacenado en properties y lo asigna a la variable correspondiente.

¿Cómo se expone un bean que recibe esas propiedades?

Dentro de la misma clase de configuración se declara un @Bean que retorna una instancia de MyBeanWithPropertiesImplement, pasando name y apellido como argumentos del constructor [02:02]:

java @Bean public MyBeanWithProperties myBeanWithProperties() { return new MyBeanWithPropertiesImplement(name, apellido); }

¿Cómo se crean la interfaz y la implementación del bean?

Primero se define la interfaz con un único método [02:30]:

java public interface MyBeanWithProperties { String function(); }

Después se implementa la clase que recibe los parámetros por constructor y concatena ambos valores [02:48]:

java public class MyBeanWithPropertiesImplement implements MyBeanWithProperties {

private String nombre;
private String apellido;

public MyBeanWithPropertiesImplement(String nombre, String apellido) {
    this.nombre = nombre;
    this.apellido = apellido;
}

@Override
public String function() {
    return nombre + " " + apellido;
}

}

Esta separación entre interfaz e implementación respeta el principio de inversión de dependencias, facilitando pruebas y mantenimiento.

¿Cómo se consume el bean en la clase principal?

En FundamentosApplication se inyecta MyBeanWithProperties como dependencia a través del constructor [03:20]:

java private final MyBeanWithProperties myBeanWithProperties;

public FundamentosApplication(MyBeanWithProperties myBeanWithProperties) { this.myBeanWithProperties = myBeanWithProperties; }

Para verificar el resultado se imprime la salida del método function() [03:55]:

java System.out.println(myBeanWithProperties.function());

Al ejecutar la aplicación, la consola muestra "Michael García", confirmando que los valores definidos en properties se inyectaron correctamente y fluyeron hasta la capa de presentación [04:15].

El flujo completo es: properties → @Value → clase de configuración → @Bean → inyección por constructor → uso en la aplicación. Dominar este patrón permite externalizar cualquier configuración sin modificar código fuente, algo esencial en entornos con múltiples perfiles de despliegue.

Si quieres profundizar en el uso de POJOs con @ConfigurationProperties y cómo agrupar propiedades de forma más robusta, comparte tus dudas en los comentarios.