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

public static void main(String[] args) {
    SpringApplication application = new SpringApplication(CicloUrbanaApplication.class);
    ConfigurableApplicationContext context = application.run(args);
    // The context stays alive: while Tomcat is listening, the process does not end
}

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

 Ribalta municipal electric bike network
 Application version      : ${application.version:no-version}
 Spring Boot              : ${spring-boot.version}
 Active profiles          : ${spring.profiles.active:none}

# Switch it off entirely
spring.main.banner-mode=off

# Send it to the log instead of the console
spring.main.banner-mode=log

# Use a file with a different name or location
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
└──────── date and time ─────┘ └level┘ └PID┘    └ app ─┘  └─ thread ─┘ └──── class (abbreviated) ───┘ └─ message ─┘

# Prints a report of which autoconfigurations were applied and which were not
debug=true

# Trace Spring's startup process
logging.level.org.springframework.boot.autoconfigure=DEBUG

package com.ciclourbana.stations;

import org.springframework.stereotype.Component;

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

/**
 * In-memory store for the stations of the Ribalta network.
 * A stopgap until module 4, where it will be replaced by
 * a Spring Data JPA repository.
 */
@Component
public class StationStore {

    private final List<Station> stations = new ArrayList<>();

    public List<Station> listAll() {
        return List.copyOf(stations);   // immutable copy: nobody modifies it from outside
    }

    public void add(Station station) {
        stations.add(station);
    }

    public int count() {
        return stations.size();
    }

    public int totalCapacity() {
        return stations.stream()
                .mapToInt(Station::capacity)
                .sum();
    }
}

package com.ciclourbana.common;

import com.ciclourbana.stations.StationStore;
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;

/**
 * Logs a summary of the network's state as soon as
 * CicloUrbana has finished starting up.
 */
@Component
public class StartupNotice {

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

    private final StationStore stationStore;
    private final Environment environment;

    // Constructor injection: Spring passes in the required beans when creating this class
    public StartupNotice(StationStore stationStore, Environment environment) {
        this.stationStore = stationStore;
        this.environment = environment;
    }

    @EventListener(ApplicationReadyEvent.class)
    public void onReady() {
        String port = environment.getProperty("server.port", "8080");

        log.info("================================================");
        log.info(" CicloUrbana ready - Ribalta municipal network");
        log.info(" Stations loaded  : {}", stationStore.count());
        log.info(" Total capacity   : {} docks", stationStore.totalCapacity());
        log.info(" API available at : http://localhost:{}/api/v1/stations", port);
        log.info("================================================");
    }
}

package com.ciclourbana.stations;

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

/**
 * Loads the initial stations of the Ribalta network at startup.
 * A stopgap until module 4, where the data will come from the
 * database through Flyway migrations.
 */
@Component
@Order(1)   // runs before other runners with a higher @Order
public class DemoStationLoader implements CommandLineRunner {

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

    private final StationStore stationStore;

    public DemoStationLoader(StationStore stationStore) {
        this.stationStore = stationStore;
    }

    @Override
    public void run(String... args) {
        log.info("Loading Ribalta's demo stations...");

        stationStore.add(new Station(1L, "Main Square",
                "Main Square 1", 24, 40.4168, -3.7038));
        stationStore.add(new Station(2L, "North Station",
                "Station Avenue 3", 30, 40.4290, -3.7020));
        stationStore.add(new Station(3L, "River Park",
                "Riverside Walk 12", 18, 40.4105, -3.6950));
        stationStore.add(new Station(4L, "University",
                "South Campus, Gate B", 36, 40.4402, -3.7255));

        log.info("Loaded {} stations", stationStore.count());
    }
}

package com.ciclourbana.stations;

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/stations")
public class StationController {

    private final StationStore stationStore;

    public StationController(StationStore stationStore) {
        this.stationStore = stationStore;
    }

    @GetMapping
    public List<Station> listStations() {
        return stationStore.listAll();
    }
}

... o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port 8080 (http)
... c.c.s.DemoStationLoader                 : Loading Ribalta's demo stations...
... c.c.s.DemoStationLoader                 : Loaded 4 stations
... c.c.CicloUrbanaApplication              : Started CicloUrbanaApplication in 2.301 seconds
... c.c.common.StartupNotice                : ================================================
... c.c.common.StartupNotice                :  CicloUrbana ready - Ribalta municipal network
... c.c.common.StartupNotice                :  Stations loaded  : 4
... c.c.common.StartupNotice                :  Total capacity   : 108 docks
... c.c.common.StartupNotice                :  API available at : http://localhost:8080/api/v1/stations
... c.c.common.StartupNotice                : ================================================

package com.ciclourbana.common;

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

/**
 * An example of reading command-line options.
 * Usage: java -jar ciclourbana.jar --mode=maintenance --verbose
 */
@Component
public class ArgumentReader implements ApplicationRunner {

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

    @Override
    public void run(ApplicationArguments args) {
        // Named options, in the --key=value style
        log.info("Options received: {}", args.getOptionNames());

        if (args.containsOption("mode")) {
            // getOptionValues returns a list: an option may be repeated
            String mode = args.getOptionValues("mode").get(0);
            log.info("Starting in mode: {}", mode);
        }

        // Loose arguments, without the -- prefix
        log.info("Unnamed arguments: {}", 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)
                // No banner: log aggregators will thank you
                .bannerMode(Banner.Mode.OFF)
                // Force the application type instead of inferring it from the classpath
                .web(WebApplicationType.SERVLET)
                // Default active profile if no other is given (module 7)
                .profiles("default")
                // Default properties: the lowest priority of all
                .properties("spring.application.name=ciclourbana")
                // A listener for an event that precedes context creation
                .listeners(event -> {
                    if (event instanceof org.springframework.boot.context.event.ApplicationStartingEvent) {
                        System.out.println(">> Starting CicloUrbana...");
                    }
                })
                // Register the JVM shutdown hook (on by default)
                .registerShutdownHook(true)
                .run(args);
    }
}

new SpringApplicationBuilder(CicloUrbanaApplication.class)
        .web(WebApplicationType.NONE)   // no Tomcat: the process ends when it is done
        .bannerMode(Banner.Mode.OFF)
        .run(args);

# src/main/resources/application.properties

# On receiving the stop signal, stop accepting new requests
# and wait for the in-flight ones to finish
server.shutdown=graceful

# Maximum wait before forcing the close (30s by default)
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.common;

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 ShutdownNotice {

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

    @EventListener(ContextClosedEvent.class)
    public void onClose() {
        log.info("CicloUrbana is stopping. Closing open resources...");
        // Here you would release external connections, flush pending caches, and so on
    }
}

spring.main.register-shutdown-hook=false

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

 Application : ${application.title:ciclourbana}
 Version     : ${application.version:development}
 Boot        : ${spring-boot.version}
 Profile     : ${spring.profiles.active:default}
 Ribalta municipal electric bike network

./mvnw spring-boot:run
# Shows the banner with Boot 3.3.5 and profile "default"

# Disable it temporarily without touching the properties file
./mvnw spring-boot:run -Dspring-boot.run.arguments=--spring.main.banner-mode=off

# Or permanently in application.properties
echo "spring.main.banner-mode=off" >> src/main/resources/application.properties

package com.ciclourbana.common;

import com.ciclourbana.stations.StationStore;
import com.ciclourbana.stations.Station;
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;

/**
 * Checks at startup that the Ribalta network is in a valid state.
 * It runs AFTER the station loader thanks to @Order(2).
 */
@Component
@Order(2)
public class StartupVerifier implements CommandLineRunner {

    private static final Logger log = LoggerFactory.getLogger(StartupVerifier.class);
    private static final int MINIMUM_STATIONS = 3;

    private final StationStore stationStore;

    public StartupVerifier(StationStore stationStore) {
        this.stationStore = stationStore;
    }

    @Override
    public void run(String... args) {
        log.info("Verifying the configuration of the Ribalta network...");

        List<Station> stations = stationStore.listAll();

        // Check 1: minimum number of stations
        if (stations.size() < MINIMUM_STATIONS) {
            throw new IllegalStateException(
                    "The network needs at least " + MINIMUM_STATIONS
                    + " stations to operate, but there are only " + stations.size()
                    + ". Review the data loader.");
        }

        // Check 2: no station without docks
        List<String> withoutCapacity = stations.stream()
                .filter(station -> station.capacity() <= 0)
                .map(Station::name)
                .toList();

        if (!withoutCapacity.isEmpty()) {
            throw new IllegalStateException(
                    "There are stations with capacity 0, which makes returning bikes impossible: "
                    + String.join(", ", withoutCapacity));
        }

        log.info("Verification passed: {} valid stations, {} docks in total",
                stations.size(), stationStore.totalCapacity());
    }
}

... APPLICATION FAILED TO START
...
java.lang.IllegalStateException: The network needs at least 3 stations to operate,
but there are only 2. Review the data loader.

package com.ciclourbana.common;

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;

/**
 * Logs CicloUrbana's startup time and its total
 * time in service.
 */
@Component
public class ApplicationStopwatch {

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

    // The moment the bean is constructed: during the context refresh
    private final Instant createdAt = Instant.now();
    private Instant readyAt;

    @EventListener(ApplicationReadyEvent.class)
    public void onReady(ApplicationReadyEvent event) {
        this.readyAt = Instant.now();

        // The event itself knows when SpringApplication started
        long totalMilliseconds = event.getTimeTaken().toMillis();

        log.info("CicloUrbana ready. Full startup in {} ms", totalMilliseconds);
        log.info("From bean creation to being ready: {} ms",
                Duration.between(createdAt, readyAt).toMillis());
    }

    @EventListener(ContextClosedEvent.class)
    public void onClose() {
        if (readyAt == null) {
            log.warn("CicloUrbana is stopping before it finished starting up");
            return;
        }
        Duration uptime = Duration.between(readyAt, Instant.now());
        log.info("CicloUrbana is stopping after {} hours, {} minutes and {} seconds in service",
                uptime.toHours(),
                uptime.toMinutesPart(),
                uptime.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: send SIGTERM to the process (equivalent to docker stop)
kill $(pgrep -f ciclourbana)

... o.s.b.w.e.tomcat.GracefulShutdown : Commencing graceful shutdown. Waiting for active requests to complete
... c.c.common.ApplicationStopwatch   : CicloUrbana is stopping after 0 hours, 1 minutes and 34 seconds in service
... o.s.b.w.e.tomcat.GracefulShutdown : Graceful shutdown complete