public static void main(String[] args) {
    SpringApplication.run(CicloUrbanaApplication.class, args);
}

public static void main(String[] args) {
    SpringApplication aplicacion = new SpringApplication(CicloUrbanaApplication.class);
    ConfigurableApplicationContext contexto = aplicacion.run(args);
    // El contexto queda vivo: mientras Tomcat escuche, el proceso no termina
}

   _____ _      _       _   _      _
  / ____(_)    | |     | | | |    | |
 | |     _  ___| | ___ | | | |_ __| |__   __ _ _ __   __ _
 | |    | |/ __| |/ _ \| | | | '__| '_ \ / _` | '_ \ / _` |
 | |____| | (__| | (_) | |_| | |  | |_) | (_| | | | | (_| |
  \_____|_|\___|_|\___/ \___/|_|  |_.__/ \__,_|_| |_|\__,_|

 Red municipal de bicicletas electricas de Ribalta
 Version de la aplicacion : ${application.version:sin-version}
 Spring Boot              : ${spring-boot.version}
 Perfiles activos         : ${spring.profiles.active:ninguno}

# Desactivarlo por completo
spring.main.banner-mode=off

# Enviarlo al log en lugar de a la consola
spring.main.banner-mode=log

# Usar un fichero con otro nombre o ubicación
spring.banner.location=classpath:banners/ciclourbana.txt

2026-08-31T10:22:40.812+02:00  INFO 18422 --- [ciclourbana] [  restartedMain] c.c.CicloUrbanaApplication               : Starting CicloUrbanaApplication using Java 21.0.5 with PID 18422 (/home/joan/ciclourbana/target/classes started by joan in /home/joan/ciclourbana)
2026-08-31T10:22:40.815+02:00  INFO 18422 --- [ciclourbana] [  restartedMain] c.c.CicloUrbanaApplication               : No active profile set, falling back to 1 default profile: "default"
2026-08-31T10:22:41.104+02:00  INFO 18422 --- [ciclourbana] [  restartedMain] .e.DevToolsPropertyDefaultsPostProcessor : Devtools property defaults active! Set 'spring.devtools.add-properties' to 'false' to disable
2026-08-31T10:22:42.688+02:00  INFO 18422 --- [ciclourbana] [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port 8080 (http)
2026-08-31T10:22:42.703+02:00  INFO 18422 --- [ciclourbana] [  restartedMain] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2026-08-31T10:22:42.704+02:00  INFO 18422 --- [ciclourbana] [  restartedMain] o.apache.catalina.core.StandardEngine    : Starting Servlet engine: [Apache Tomcat/10.1.31]
2026-08-31T10:22:42.760+02:00  INFO 18422 --- [ciclourbana] [  restartedMain] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2026-08-31T10:22:42.761+02:00  INFO 18422 --- [ciclourbana] [  restartedMain] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 1920 ms
2026-08-31T10:22:42.905+02:00  INFO 18422 --- [ciclourbana] [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port 8080 (http) with context path '/'
2026-08-31T10:22:42.918+02:00  INFO 18422 --- [ciclourbana] [  restartedMain] c.c.CicloUrbanaApplication               : Started CicloUrbanaApplication in 2.174 seconds (process running for 2.512)

2026-08-31T10:22:42.905+02:00  INFO 18422 --- [ciclourbana] [restartedMain] o.s.b.w.e.tomcat.TomcatWebServer : Tomcat started on port 8080
└──────── fecha y hora ──────┘ └nivel┘ └PID┘    └ app ─┘  └── hilo ──┘ └──── clase (abreviada) ────┘ └─ mensaje ─┘

# Muestra un informe de qué autoconfiguraciones se aplicaron y cuáles no
debug=true

# Traza el proceso de arranque de Spring
logging.level.org.springframework.boot.autoconfigure=DEBUG

package com.ciclourbana.estaciones;

import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

/**
 * Almacén en memoria de las estaciones de la red de Ribalta.
 * Es una solución provisional hasta el módulo 4, donde se
 * sustituirá por un repositorio de Spring Data JPA.
 */
@Component
public class AlmacenEstaciones {

    private final List<Estacion> estaciones = new ArrayList<>();

    public List<Estacion> listarTodas() {
        return List.copyOf(estaciones);   // copia inmutable: nadie la modifica desde fuera
    }

    public void agregar(Estacion estacion) {
        estaciones.add(estacion);
    }

    public int contar() {
        return estaciones.size();
    }

    public int capacidadTotal() {
        return estaciones.stream()
                .mapToInt(Estacion::capacidad)
                .sum();
    }
}

package com.ciclourbana.comun;

import com.ciclourbana.estaciones.AlmacenEstaciones;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.event.EventListener;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

/**
 * Registra en el log un resumen del estado de la red
 * en cuanto CicloUrbana termina de arrancar.
 */
@Component
public class AvisoArranque {

    private static final Logger log = LoggerFactory.getLogger(AvisoArranque.class);

    private final AlmacenEstaciones almacenEstaciones;
    private final Environment entorno;

    // Inyección por constructor: Spring pasa los beans necesarios al crear esta clase
    public AvisoArranque(AlmacenEstaciones almacenEstaciones, Environment entorno) {
        this.almacenEstaciones = almacenEstaciones;
        this.entorno = entorno;
    }

    @EventListener(ApplicationReadyEvent.class)
    public void alEstarLista() {
        String puerto = entorno.getProperty("server.port", "8080");

        log.info("================================================");
        log.info(" CicloUrbana lista - red municipal de Ribalta");
        log.info(" Estaciones cargadas : {}", almacenEstaciones.contar());
        log.info(" Capacidad total     : {} anclajes", almacenEstaciones.capacidadTotal());
        log.info(" API disponible en   : http://localhost:{}/api/v1/estaciones", puerto);
        log.info("================================================");
    }
}

package com.ciclourbana.estaciones;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * Carga las estaciones iniciales de la red de Ribalta al arrancar.
 * Provisional hasta el módulo 4, donde los datos vendrán de la
 * base de datos mediante migraciones de Flyway.
 */
@Component
@Order(1)   // se ejecuta antes que otros runners con @Order superior
public class CargadorEstacionesDemo implements CommandLineRunner {

    private static final Logger log = LoggerFactory.getLogger(CargadorEstacionesDemo.class);

    private final AlmacenEstaciones almacenEstaciones;

    public CargadorEstacionesDemo(AlmacenEstaciones almacenEstaciones) {
        this.almacenEstaciones = almacenEstaciones;
    }

    @Override
    public void run(String... args) {
        log.info("Cargando estaciones de demostración de Ribalta...");

        almacenEstaciones.agregar(new Estacion(1L, "Plaza Mayor",
                "Plaza Mayor, 1", 24, 40.4168, -3.7038));
        almacenEstaciones.agregar(new Estacion(2L, "Estación Norte",
                "Avenida de la Estación 3", 30, 40.4290, -3.7020));
        almacenEstaciones.agregar(new Estacion(3L, "Parque del Río",
                "Paseo Fluvial 12", 18, 40.4105, -3.6950));
        almacenEstaciones.agregar(new Estacion(4L, "Universidad",
                "Campus Sur, acceso B", 36, 40.4402, -3.7255));

        log.info("Cargadas {} estaciones", almacenEstaciones.contar());
    }
}

package com.ciclourbana.estaciones;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping("/api/v1/estaciones")
public class EstacionController {

    private final AlmacenEstaciones almacenEstaciones;

    public EstacionController(AlmacenEstaciones almacenEstaciones) {
        this.almacenEstaciones = almacenEstaciones;
    }

    @GetMapping
    public List<Estacion> listarEstaciones() {
        return almacenEstaciones.listarTodas();
    }
}

... o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port 8080 (http)
... c.c.e.CargadorEstacionesDemo            : Cargando estaciones de demostración de Ribalta...
... c.c.e.CargadorEstacionesDemo            : Cargadas 4 estaciones
... c.c.CicloUrbanaApplication              : Started CicloUrbanaApplication in 2.301 seconds
... c.c.comun.AvisoArranque                 : ================================================
... c.c.comun.AvisoArranque                 :  CicloUrbana lista - red municipal de Ribalta
... c.c.comun.AvisoArranque                 :  Estaciones cargadas : 4
... c.c.comun.AvisoArranque                 :  Capacidad total     : 108 anclajes
... c.c.comun.AvisoArranque                 :  API disponible en   : http://localhost:8080/api/v1/estaciones
... c.c.comun.AvisoArranque                 : ================================================

package com.ciclourbana.comun;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

/**
 * Ejemplo de lectura de opciones de línea de comandos.
 * Uso: java -jar ciclourbana.jar --modo=mantenimiento --verbose
 */
@Component
public class LectorArgumentos implements ApplicationRunner {

    private static final Logger log = LoggerFactory.getLogger(LectorArgumentos.class);

    @Override
    public void run(ApplicationArguments args) {
        // Opciones con nombre, del estilo --clave=valor
        log.info("Opciones recibidas: {}", args.getOptionNames());

        if (args.containsOption("modo")) {
            // getOptionValues devuelve una lista: una opción puede repetirse
            String modo = args.getOptionValues("modo").get(0);
            log.info("Arrancando en modo: {}", modo);
        }

        // Argumentos sueltos, sin el prefijo --
        log.info("Argumentos sin nombre: {}", args.getNonOptionArgs());
    }
}

package com.ciclourbana;

import org.springframework.boot.Banner;
import org.springframework.boot.WebApplicationType;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;

@SpringBootApplication
public class CicloUrbanaApplication {

    public static void main(String[] args) {
        new SpringApplicationBuilder(CicloUrbanaApplication.class)
                // Sin banner: los agregadores de logs lo agradecen
                .bannerMode(Banner.Mode.OFF)
                // Forzar el tipo de aplicación en lugar de deducirlo del classpath
                .web(WebApplicationType.SERVLET)
                // Perfil activo por defecto si no se indica otro (módulo 7)
                .profiles("default")
                // Propiedades por defecto: las de menor prioridad de todas
                .properties("spring.application.name=ciclourbana")
                // Listener para un evento anterior a la creación del contexto
                .listeners(evento -> {
                    if (evento instanceof org.springframework.boot.context.event.ApplicationStartingEvent) {
                        System.out.println(">> Arrancando CicloUrbana...");
                    }
                })
                // Registrar el hook de apagado de la JVM (activo por defecto)
                .registerShutdownHook(true)
                .run(args);
    }
}

new SpringApplicationBuilder(CicloUrbanaApplication.class)
        .web(WebApplicationType.NONE)   // sin Tomcat: el proceso termina al acabar
        .bannerMode(Banner.Mode.OFF)
        .run(args);

# src/main/resources/application.properties

# Al recibir la señal de parada, dejar de aceptar peticiones nuevas
# y esperar a que terminen las que están en curso
server.shutdown=graceful

# Tiempo máximo de espera antes de forzar el cierre (por defecto 30s)
spring.lifecycle.timeout-per-shutdown-phase=20s

... o.s.b.w.e.tomcat.GracefulShutdown : Commencing graceful shutdown. Waiting for active requests to complete
... o.s.b.w.e.tomcat.GracefulShutdown : Graceful shutdown complete

package com.ciclourbana.comun;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.event.ContextClosedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@Component
public class AvisoApagado {

    private static final Logger log = LoggerFactory.getLogger(AvisoApagado.class);

    @EventListener(ContextClosedEvent.class)
    public void alCerrar() {
        log.info("CicloUrbana se está deteniendo. Cerrando recursos abiertos...");
        // Aquí liberarías conexiones externas, volcarías caches pendientes, etc.
    }
}

spring.main.register-shutdown-hook=false

# src/main/resources/banner.txt
  ____ _      _        _   _      _
 / ___(_) ___| | ___  | | | |_ __| |__   __ _ _ __   __ _
| |   | |/ __| |/ _ \ | | | | '__| '_ \ / _` | '_ \ / _` |
| |___| | (__| | (_) || |_| | |  | |_) | (_| | | | | (_| |
 \____|_|\___|_|\___/  \___/|_|  |_.__/ \__,_|_| |_|\__,_|

 Aplicacion : ${application.title:ciclourbana}
 Version    : ${application.version:desarrollo}
 Boot       : ${spring-boot.version}
 Perfil     : ${spring.profiles.active:default}
 Red municipal de bicicletas electricas de Ribalta

./mvnw spring-boot:run
# Muestra el banner con Boot 3.3.5 y perfil "default"

# Desactivarlo temporalmente sin tocar el fichero de propiedades
./mvnw spring-boot:run -Dspring-boot.run.arguments=--spring.main.banner-mode=off

# O de forma permanente en application.properties
echo "spring.main.banner-mode=off" >> src/main/resources/application.properties

package com.ciclourbana.comun;

import com.ciclourbana.estaciones.AlmacenEstaciones;
import com.ciclourbana.estaciones.Estacion;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * Comprueba al arrancar que la red de Ribalta está en un estado válido.
 * Se ejecuta DESPUÉS del cargador de estaciones gracias a @Order(2).
 */
@Component
@Order(2)
public class VerificadorArranque implements CommandLineRunner {

    private static final Logger log = LoggerFactory.getLogger(VerificadorArranque.class);
    private static final int MINIMO_ESTACIONES = 3;

    private final AlmacenEstaciones almacenEstaciones;

    public VerificadorArranque(AlmacenEstaciones almacenEstaciones) {
        this.almacenEstaciones = almacenEstaciones;
    }

    @Override
    public void run(String... args) {
        log.info("Verificando la configuración de la red de Ribalta...");

        List<Estacion> estaciones = almacenEstaciones.listarTodas();

        // Comprobación 1: número mínimo de estaciones
        if (estaciones.size() < MINIMO_ESTACIONES) {
            throw new IllegalStateException(
                    "La red necesita al menos " + MINIMO_ESTACIONES
                    + " estaciones para operar, pero solo hay " + estaciones.size()
                    + ". Revise el cargador de datos.");
        }

        // Comprobación 2: ninguna estación sin anclajes
        List<String> sinCapacidad = estaciones.stream()
                .filter(estacion -> estacion.capacidad() <= 0)
                .map(Estacion::nombre)
                .toList();

        if (!sinCapacidad.isEmpty()) {
            throw new IllegalStateException(
                    "Hay estaciones con capacidad 0, lo que impide devolver bicicletas: "
                    + String.join(", ", sinCapacidad));
        }

        log.info("Verificación superada: {} estaciones válidas, {} anclajes en total",
                estaciones.size(), almacenEstaciones.capacidadTotal());
    }
}

... APPLICATION FAILED TO START
...
java.lang.IllegalStateException: La red necesita al menos 3 estaciones para operar,
pero solo hay 2. Revise el cargador de datos.

package com.ciclourbana.comun;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.event.ContextClosedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

import java.time.Duration;
import java.time.Instant;

/**
 * Registra el tiempo de arranque y el tiempo total de actividad
 * de CicloUrbana.
 */
@Component
public class CronometroAplicacion {

    private static final Logger log = LoggerFactory.getLogger(CronometroAplicacion.class);

    // Momento en que se construye el bean: durante el refresh del contexto
    private final Instant instanteCreacion = Instant.now();
    private Instant instanteListo;

    @EventListener(ApplicationReadyEvent.class)
    public void alEstarLista(ApplicationReadyEvent evento) {
        this.instanteListo = Instant.now();

        // El propio evento sabe cuándo arrancó SpringApplication
        long milisegundosTotales = evento.getTimeTaken().toMillis();

        log.info("CicloUrbana lista. Arranque completo en {} ms", milisegundosTotales);
        log.info("Desde la creación de los beans hasta el arranque: {} ms",
                Duration.between(instanteCreacion, instanteListo).toMillis());
    }

    @EventListener(ContextClosedEvent.class)
    public void alCerrar() {
        if (instanteListo == null) {
            log.warn("CicloUrbana se detiene antes de haber terminado de arrancar");
            return;
        }
        Duration actividad = Duration.between(instanteListo, Instant.now());
        log.info("CicloUrbana se detiene tras {} horas, {} minutos y {} segundos de servicio",
                actividad.toHours(),
                actividad.toMinutesPart(),
                actividad.toSecondsPart());
    }
}

# src/main/resources/application.properties
server.shutdown=graceful
spring.lifecycle.timeout-per-shutdown-phase=20s
logging.level.org.springframework.boot.web.embedded.tomcat.GracefulShutdown=INFO

# Terminal 1
java -jar target/ciclourbana-0.0.1-SNAPSHOT.jar

# Terminal 2: enviar SIGTERM al proceso (equivale a docker stop)
kill $(pgrep -f ciclourbana)

... o.s.b.w.e.tomcat.GracefulShutdown : Commencing graceful shutdown. Waiting for active requests to complete
... c.c.comun.CronometroAplicacion    : CicloUrbana se detiene tras 0 horas, 1 minutos y 34 segundos de servicio
... o.s.b.w.e.tomcat.GracefulShutdown : Graceful shutdown complete