Introducción#

Una de las características más poderosas de Spring Boot es la capacidad de trabajar con perfiles, lo que permite a los desarrolladores definir diferentes configuraciones para diferentes entornos (desarrollo, prueba, producción, etc.). En este artículo, vamos a explorar cómo trabajar con perfiles en Spring Boot y cómo utilizarlos para gestionar configuraciones específicas de cada entorno.

¿Qué son los perfiles en Spring Boot?#

Los perfiles en Spring Boot constituyen un mecanismo fundamental para segmentar configuraciones específicas según el entorno de ejecución. Permiten definir conjuntos de configuraciones independientes para entornos como desarrollo (dev), pruebas (test) o producción (prod), facilitando así la transición entre diferentes contextos sin necesidad de modificar el código.

Esta funcionalidad resulta especialmente valiosa porque permite:

• Mantener configuraciones aisladas para cada entorno
• Prevenir conflictos entre configuraciones de diferentes ambientes
• Cargar dinámicamente beans, propiedades y configuraciones específicas según el contexto activo
• Gestionar de manera eficiente las diferencias entre conexiones a bases de datos, configuraciones de seguridad o parámetros de servicios externos según el entorno de despliegue

Configuración de perfiles#

Para trabajar con perfiles, vamos a crear archivos independientes para cada perfil en el directorio src/main/resources con la sintaxis application-{perfil}.properties o application-{perfil}.yml. A continuación, se muestra un ejemplo de cómo estructurar los archivos de configuración:

• application.properties: Configuración común y predeterminada (se carga siempre)

  1
  spring.application.name=mi-aplicacion
  2
  logging.level.root=INFO
  3
  server.port=8080
  

• application-dev.properties: Configuración específica para desarrollo

  1
  spring.datasource.url=jdbc:mysql://localhost:3306/dev_db
  2
  spring.datasource.username=dev_user
  3
  spring.datasource.password=dev_password
  4
  logging.level.org.springframework=DEBUG
  

• application-test.properties: Configuración específica para pruebas

  1
  spring.datasource.url=jdbc:mysql://localhost:3306/test_db
  2
  spring.datasource.username=test_user
  3
  spring.datasource.password=test_password
  4
  logging.level.org.springframework=ERROR
  

• application-prod.properties: Configuración específica para producción

  1
  spring.datasource.url=jdbc:mysql://production-server:3306/prod_db
  2
  spring.datasource.username=prod_user
  3
  spring.datasource.password=${PROD_DB_PASSWORD}
  4
  logging.level.org.springframework=WARN
  

IMPORTANT

Los perfiles tiene un orden de prioridad. Si se define un perfil activo, Spring Boot cargará primero la configuración común y luego la específica del perfil. Si hay propiedades duplicadas, las del perfil específico sobrescribirán las comunes.

Activar un perfil#

Existen varias formas de activar un perfil en Spring Boot. Al iniciar la aplicación, Spring Boot busca automáticamente el archivo application.properties o application.yml y carga la configuración base. Luego, dependiendo del perfil activo, carga las propiedades específicas del perfil correspondiente. A continuación, vamos a ver algunas formas de activar un perfil:

1. A través de la línea de comandos: Podemos pasar el perfil como un argumento al iniciar la aplicación:

1
# Si estás ejecutando el JAR de la aplicación
2
java -jar mi-aplicacion.jar --spring.profiles.active=prod
3

4
# O si estás usando Maven
5
mvn spring-boot:run -Dspring-boot.run.profiles=prod

2. A través de variables de entorno: Podemos establecer la variable de entorno SPRING_PROFILES_ACTIVE para activar un perfil específico:

1
# En Windows
2
set SPRING_PROFILES_ACTIVE=prod
3

4
# En Linux o macOS
5
export SPRING_PROFILES_ACTIVE=prod

3. A través de la configuración de la aplicación: Podemos definir el perfil activo en el archivo application.properties o application.yml:

1
spring.profiles.active=prod

También podemos activar múltiples perfiles separándolos por comas (ya sea en la línea de comandos, variables de entorno o archivos de configuración):

1
spring.profiles.active=dev,qa

Para verificar qué perfil está activo, podemos usar la anotación @Value para inyectar el valor de la propiedad spring.profiles.active en nuestro código:

1
import org.springframework.beans.factory.annotation.Value;
2
import org.springframework.stereotype.Component;
3

4
@Component
5
public class ActiveProfileChecker {
6
    @Value("${spring.profiles.active}")
7
    private String activeProfile;
8

9
    public String getActiveProfile() {
10
        return activeProfile;
11
    }
12
}

NOTE

Cuando se establece la variable de entorno SPRING_PROFILES_ACTIVE, este valor se refleja en la propiedad spring.profiles.active dentro de la aplicación.

Usar perfiles en Beans#

Una de las características más potentes de los perfiles en Spring Boot es la capacidad de cargar beans específicos para cada perfil. Esto permite que ciertos componentes de la aplicación se carguen solo cuando el perfil correspondiente está activo.

1
public interface IMessageService {
2
    String sendMessage();
3
}

1
import org.springframework.context.annotation.Profile;
2
import org.springframework.stereotype.Service;
3

4
// Esta implementación solo se cargará si el perfil activo es "dev"
5
@Service
6
@Profile("dev")
7
public class MessageServiceDev implements IMessageService {
8
    @Override
9
    public String sendMessage() {
10
        return "Hello from Development!";
11
    }
12
}

1
import org.springframework.context.annotation.Profile;
2
import org.springframework.stereotype.Service;
3

4
// Esta implementación solo se cargará si el perfil activo es "prod"
5
@Service
6
@Profile("prod")
7
public class MessageServiceProd implements IMessageService {
8
    @Override
9
    public String sendMessage() {
10
        return "Hello from Production!";
11
    }
12
}

1
import org.springframework.web.bind.annotation.GetMapping;
2
import org.springframework.web.bind.annotation.RestController;
3
import org.springframework.web.bind.annotation.RequestMapping;
4

5
@RestController
6
@RequestMapping("/api/messages")
7
public class MessageController {
8
    private final IMessageService messageService;
9

10
    // Inyectamos el servicio de mensajes
11
    public MessageController(IMessageService messageService) {
12
        this.messageService = messageService;
13
    }
14

15
    @GetMapping
16
    public String getMessage() {
17
        return messageService.sendMessage();
18
    }
19
}

1
spring.profiles.active=dev

1
import org.springframework.context.annotation.Profile;
2
import org.springframework.stereotype.Service;
3

4
// Esta implementación se cargará si el perfil activo es "dev" o "qa"
5
@Service
6
@Profile({"dev", "qa"})
7
public class MessageServiceDevOrQa implements IMessageService {
8
    @Override
9
    public String sendMessage() {
10
        return "Hello from Development or QA!";
11
    }
12
}

1
import org.springframework.context.annotation.Profile;
2
import org.springframework.stereotype.Service;
3

4
// Esta implementación se cargará si el perfil "prod" NO está activo
5
@Service
6
@Profile("!prod")
7
public class MessageServiceNoProd implements IMessageService {
8
    @Override
9
    public String sendMessage() {
10
        return "Hello from Non-Production!";
11
    }
12
}

1
import org.springframework.context.annotation.Profile;
2
import org.springframework.stereotype.Service;
3

4
// Esta implementación se cargará solo si están activos los perfiles "x" y "y"
5
@Service
6
@Profile("x & y")
7
public class MessageServiceXAndY implements IMessageService {
8
    @Override
9
    public String sendMessage() {
10
        return "Hello from X and Y!";
11
    }
12
}

1
import org.springframework.context.annotation.Profile;
2
import org.springframework.stereotype.Service;
3

4
// Esta implementación se cargará si el perfil "x" NO está activo y el perfil "y" NO está activo
5
@Service
6
@Profile("!x & !y")
7
public class MessageServiceNotXAndY implements IMessageService {
8
    @Override
9
    public String sendMessage() {
10
        return "Hello from Not X and Not Y!";
11
    }
12
}

Conclusión#

Los perfiles en Spring Boot son una herramienta poderosa para gestionar configuraciones específicas de entorno. Nos permiten mantener el código limpio y organizado, evitando la necesidad de modificar configuraciones manualmente al cambiar de entorno. Al utilizar perfiles, podemos asegurarnos de que nuestra aplicación se comporte de manera coherente y predecible en diferentes contextos.