Curso de Spring Boot desde cero, en español

Spring Boot es la forma más usada de hacer aplicaciones de servidor con Java: las APIs que consultan las apps de un banco, el sistema de pedidos de una tienda en línea o los servicios internos de una aseguradora. Si ya sabes algo de Java (clases, interfaces, listas) pero nunca has usado Spring, este curso es para ti. Empieza desde cero, explica el porqué de cada pieza antes de usarla y, en cada lección, enseña un error típico con el mensaje real que verás en tu pantalla. Usamos Spring Boot 4.2.0, que salió el 19 de noviembre de 2026, con Java 25 y Maven.

La ruta: ocho lecciones

Están pensadas para leerse en orden, porque cada una usa lo de la anterior. Las dos primeras están en esta misma página y las demás tienen la suya. Todas siguen el mismo ejemplo: el catálogo de productos de una tienda, con precios en pesos. Cada lección trae al menos un esquema, un recuadro «El error que te ahorra» con un fallo típico y su mensaje real, y retos al final con la solución escondida. Al terminar hay un test de 24 preguntas.

Lo que necesitas saber antes

No necesitas saber nada de Spring, pero sí lo básico de Java: qué es una clase y un objeto, qué es una interfaz, cómo se usa una List y qué son las anotaciones (esas palabras con @ delante, como @Override). Si te falta algo, el curso y los ejemplos de Java lo cubren. También ayuda saber qué es una petición HTTP; lo repasamos en la lección 3.

Lección 1. Primeros pasos

Qué es Spring y qué agrega Spring Boot

Spring Framework apareció en 2004 como una alternativa más sencilla a las herramientas oficiales de Java para empresas de aquella época, que obligaban a escribir mucha configuración y a instalar servidores pesados. Su idea central es un contenedor: un objeto que crea las piezas de tu aplicación, las conecta entre sí y las administra mientras el programa corre. Alrededor de ese contenedor creció una familia de módulos: para hacer sitios y APIs web, para hablar con bases de datos, para seguridad, para mensajería.

El problema es que juntar todo eso a mano era laborioso: había que elegir versiones compatibles de decenas de bibliotecas, escribir la configuración de cada una e instalar un servidor como Tomcat para desplegar ahí la aplicación. Spring Boot, que salió en 2014, resuelve justo eso con tres ideas:

  • Starters. En vez de elegir 20 bibliotecas, pides una: spring-boot-starter-webmvc trae todo lo necesario para una API web, en versiones que ya se probaron juntas.
  • Autoconfiguración. Spring Boot revisa qué bibliotecas tienes y configura lo razonable por su cuenta. Si ve el starter web, levanta un servidor; si ve una base de datos, prepara la conexión. Tú solo cambias lo que no te sirva.
  • Servidor incluido. Tomcat viaja dentro de tu aplicación. No instalas nada: tu programa es un solo archivo .jar que se ejecuta con java -jar.

Piénsalo así

Spring Framework es una cocina profesional con todos los utensilios. Spring Boot es esa misma cocina, pero ya instalada: la estufa conectada, los cuchillos en su lugar y una receta por omisión para cada platillo. Tú llegas a cocinar, no a armar muebles. Y si quieres otra estufa, la cambias.

Cuatro capas, de arriba abajo: tu código, con controladores, servicios y entidades; Spring Boot, que pone los starters, la autoconfiguración y el servidor Tomcat; Spring Framework, con el contenedor de beans y los módulos de web y datos; y Java 25, la máquina virtual. Cada capa se apoya en la de abajoQué pone cada capaTu códigocontroladores, servicios, entidadesSpring Bootstarters, autoconfiguración, TomcatSpring Frameworkcontenedor de beans, web, datosJava 25la máquina virtual (JVM)cada capa se apoya en la de abajo
Spring Boot no reemplaza a Spring: se pone encima y lo configura por ti. Esquema: decodigo.com.

Lo que necesitas instalar

Spring Boot 4.2 pide Java 17 o más nuevo y funciona hasta Java 27. Te recomendamos Java 25, que es la versión de soporte largo (LTS) más reciente; un buen lugar para descargarlo es Eclipse Temurin, en adoptium.net, gratuito para cualquier uso. Instala el JDK (el kit para programar), no solo el JRE. Después, abre una terminal y comprueba la versión:

terminal (en el contenedor donde probamos el curso)$ java -version
openjdk version "25.0.5.1" 2026-11-17 LTS
OpenJDK Runtime Environment Temurin-25.0.5.1+2 (build 25.0.5.1+2-LTS)
OpenJDK 64-Bit Server VM Temurin-25.0.5.1+2 (build 25.0.5.1+2-LTS, mixed mode, sharing)
$ ./mvnw -v
Apache Maven 3.10.1 (3afd8084b5629f80b97750906a719879ed4cd283)
Maven home: …
Java version: 25.0.5.1, vendor: Eclipse Adoptium, runtime: /opt/java/openjdk

Maven, la herramienta que descarga las bibliotecas y compila el proyecto, no hace falta instalarla: cada proyecto trae un Maven Wrapper (los archivos mvnw y mvnw.cmd) que baja la versión correcta la primera vez. Para escribir código, cualquier editor sirve, pero uno con soporte de Java ayuda mucho: IntelliJ IDEA (su edición gratuita basta), VS Code con el paquete de extensiones de Java o Eclipse.

Crear el proyecto con start.spring.io

Nadie arma un proyecto de Spring Boot desde una carpeta vacía. El equipo de Spring mantiene start.spring.io (también llamado Spring Initializr), una página donde eliges lo que quieres y descargas un proyecto listo. Para este curso:

  • OpciónQué elegirPor qué
  • ProjectMavenLa página ofrece Gradle por omisión; el curso usa Maven, el más común en empresas. Los dos sirven.
  • LanguageJavaTambién hay Kotlin y Groovy.
  • Spring Boot4.2.0La más nueva estable. Las que dicen SNAPSHOT están en desarrollo.
  • Group / Artifactcom.ejemplo / holaEl paquete queda como com.ejemplo.hola.
  • PackagingJarUn solo archivo ejecutable.
  • Java25La página propone 17; elige la que tengas instalada.
  • DependenciesSpring WebBotón «Add dependencies». Es el starter para hacer APIs.

Pulsa Generate, descomprime el zip y abre la carpeta en tu editor. Si prefieres la terminal, la misma página acepta peticiones con curl. Esta orden descarga exactamente el proyecto de la tabla:

curl https://start.spring.io/starter.zip -d type=maven-project -d javaVersion=25 \
     -d dependencies=web -d groupId=com.ejemplo -d artifactId=hola -o hola.zip
Árbol del proyecto hola: pom.xml con las dependencias; mvnw y mvnw.cmd, el Maven Wrapper; src/main/java/com/ejemplo/hola/HolaApplication.java, la clase que arranca; src/main/resources/application.properties, los ajustes; y src/test/java con HolaApplicationTests.java, las pruebasLo que trae el proyectohola/pom.xmldependenciasmvnw, mvnw.cmdMaven Wrappersrc/main/java/com/ejemplo/hola/HolaApplication.javaarranquesrc/main/resources/application.propertiesajustessrc/test/java/…/HolaApplicationTests.javapruebas
El proyecto que descarga start.spring.io: cinco archivos importan. Esquema: decodigo.com.

El pom.xml: la lista de lo que usa tu proyecto

El pom.xml le dice a Maven qué bibliotecas necesita el proyecto. Lo más importante son estas partes:

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>4.2.0</version>
</parent>

El parent hereda la configuración de Spring Boot 4.2.0, incluida la versión de cada una de las cientos de bibliotecas que conoce. Por eso, más abajo, las dependencias no llevan número de versión: Spring Boot ya sabe qué versión de Tomcat, de Jackson o de Hibernate va con la 4.2.0.

<dependencies>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-webmvc</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-webmvc-test</artifactId>
		<scope>test</scope>
	</dependency>
</dependencies>

Son dos starters: spring-boot-starter-webmvc trae Spring MVC, Tomcat y Jackson (que convierte objetos a JSON), y spring-boot-starter-webmvc-test, solo para las pruebas, trae JUnit, AssertJ, Mockito y las herramientas de Spring para probar controladores. Desde Spring Boot 4, cada starter tiene su starter de pruebas con el mismo nombre más -test. El spring-boot-maven-plugin, al final del archivo, es el que empaqueta todo en un jar ejecutable.

La clase que arranca todo

start.spring.io crea una sola clase de Java:

package com.ejemplo.hola;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class HolaApplication {

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

}

El main le pasa el control a SpringApplication.run, que crea el contenedor, revisa tus clases y arranca el servidor. La anotación @SpringBootApplication junta tres trabajos en uno:

  • Escanear componentes: buscar clases marcadas como piezas de Spring en el paquete com.ejemplo.hola y en todos los que cuelgan de él. Ojo con esto: una clase en otro paquete no se encuentra (es la primera de las rarezas).
  • Autoconfigurar: activar la configuración automática según las bibliotecas que haya.
  • Ser configuración: la propia clase puede declarar piezas con métodos @Bean, que verás en la lección 2.

Tu primer endpoint

Un endpoint es una dirección de tu aplicación que responde a peticiones, como /hola. Crea este archivo junto a HolaApplication.java, en la misma carpeta:

package com.ejemplo.hola;

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

@RestController
public class HolaController {

    @GetMapping("/hola")
    public String hola(@RequestParam(defaultValue = "mundo") String nombre) {
        return "¡Hola, " + nombre + "! Saludos desde Spring Boot.";
    }
}

@RestController le dice a Spring que esta clase atiende peticiones web y que lo que devuelvan sus métodos se manda tal cual como respuesta. @GetMapping("/hola") conecta el método con las peticiones GET a /hola, y @RequestParam toma el parámetro ?nombre= de la dirección; si no viene, usa «mundo». No hay que registrar la clase en ningún lado: el escaneo de componentes la encuentra sola.

Arrancar la aplicación

Desde la carpeta del proyecto, en la terminal:

./mvnw spring-boot:run          # Linux y macOS
mvnw.cmd spring-boot:run        # Windows

La primera vez tarda un poco porque el wrapper descarga Maven y las bibliotecas. Después verás el logotipo de Spring dibujado con letras y un registro como este (lo recortamos a las líneas que importan):

registro de ./mvnw spring-boot:run2026-11-22T09:59:32.408-06:00  INFO 194 --- [hola] [           main] com.ejemplo.hola.HolaApplication         : Starting HolaApplication using Java 25.0.5.1 with PID 194 (/tmp/hola/target/classes started by ubuntu in /tmp/hola)
2026-11-22T09:59:32.410-06:00  INFO 194 --- [hola] [           main] com.ejemplo.hola.HolaApplication         : No active profile set, falling back to 1 default profile: "default"
2026-11-22T09:59:32.873-06:00  INFO 194 --- [hola] [           main] o.s.boot.tomcat.TomcatWebServer          : Tomcat initialized with port 8080 (http)
2026-11-22T09:59:33.134-06:00  INFO 194 --- [hola] [           main] o.s.boot.tomcat.TomcatWebServer          : Tomcat started on port 8080 (http) with context path '/'
2026-11-22T09:59:33.137-06:00  INFO 194 --- [hola] [           main] com.ejemplo.hola.HolaApplication         : Started HolaApplication in 0.98 seconds (process running for 1.18)

Léelo de arriba abajo: la aplicación empieza, no hay perfil activo (lo verás en la lección 4), Tomcat se prepara en el puerto 8080 y arranca, y al final Started HolaApplication con el tiempo que tardó. Mientras esa ventana siga abierta, la aplicación está escuchando. Abre en tu navegador http://localhost:8080/hola, o usa curl desde otra terminal:

terminal$ curl -s localhost:8080/hola
¡Hola, mundo! Saludos desde Spring Boot.
$ curl -s "localhost:8080/hola?nombre=Ana"
¡Hola, Ana! Saludos desde Spring Boot.
$ curl -s localhost:8080/adios
{"timestamp":"2026-11-22T15:59:33.354Z","status":404,"error":"Not Found","path":"/adios"}

La tercera petición pide una dirección que no existe y Spring responde con un error 404 en formato JSON, con la hora, el código y la ruta. En el navegador verías la «Whitelabel Error Page», una página blanca con el mismo error. Para detener la aplicación, vuelve a su terminal y pulsa Ctrl+C.

curl en Windows. Windows 10 y 11 ya traen curl. En PowerShell escríbelo como curl.exe, porque en Windows PowerShell 5.1 la palabra curl es un alias de otra orden con opciones distintas. Las comillas también cambian: en las lecciones con JSON te damos la versión para PowerShell.

El error que te ahorra: el puerto 8080 ya está ocupado

Te va a pasar: dejaste la aplicación corriendo en otra ventana, o tienes otro programa en el 8080, y al arrancar de nuevo esto es lo que aparece:

registro: la aplicación no arranca***************************
APPLICATION FAILED TO START
***************************

Description:

Web server failed to start. Port 8080 was already in use.

Action:

Identify and stop the process that's listening on port 8080 or configure this application to listen on another port.

Spring Boot no muestra una traza de 200 líneas, sino un resumen: qué pasó (Description) y qué hacer (Action). Detén la otra copia o arranca esta en otro puerto. Con ./mvnw spring-boot:run -Dspring-boot.run.arguments=--server.port=8081, o con java -jar como en la lección 8, se elige el puerto al arrancar; para dejarlo fijo, escribe server.port=8081 en application.properties. Así respondió en el 8081:

terminal$ curl -s localhost:8081/hola
¡Hola, mundo! Saludos desde Spring Boot.
2026-11-22T09:59:45.983-06:00  INFO 246 --- [puerto-ocupado] [           main] o.s.boot.tomcat.TomcatWebServer          : Tomcat started on port 8081 (http) with context path '/'

Lección 2. Beans e inyección de dependencias

Esta es la idea más importante de Spring, y la que más confunde al principio porque parece magia. No lo es. Vamos con un ejemplo: un servicio que calcula el total de un pedido sumando el envío.

El problema: cada clase fabrica lo que necesita

Sin Spring, lo natural sería que el servicio creara su propia calculadora de envío:

public class ServicioPedidos {

    private final CalculadoraEnvio envio = new EnvioEstandar();   // la clase elige y fabrica

    public BigDecimal total(BigDecimal subtotal) {
        return subtotal.add(envio.costo(subtotal));
    }
}

Funciona, pero tiene tres problemas que crecen con la aplicación. Para cambiar a envío exprés hay que editar ServicioPedidos. Para probarlo con un envío falso que no consulte una paquetería real, no hay forma de meterlo. Y si diez clases necesitan la calculadora, se crean diez copias, cada una con su propia configuración.

La solución: pedirlo en el constructor

La inyección de dependencias le da la vuelta: la clase no fabrica lo que necesita, lo pide en su constructor, y alguien más se lo entrega. Ese alguien es el contenedor de Spring. A cada objeto que el contenedor crea y administra se le llama bean.

Piénsalo así

En una cocina de restaurante, el cocinero no va al mercado cada vez que le falta cebolla. Avisa qué ingredientes necesita para su platillo y el encargado de almacén se los deja en la mesa. Si un día cambia de proveedor, el cocinero ni se entera. El contenedor de Spring es ese encargado.

Así queda el ejemplo con Spring. Primero, la interfaz y una implementación marcada con @Component, que significa «Spring: crea un objeto de esta clase y guárdalo»:

package com.ejemplo.pedidos;

import java.math.BigDecimal;

public interface CalculadoraEnvio {
    BigDecimal costo(BigDecimal subtotal);
}
package com.ejemplo.pedidos;

import java.math.BigDecimal;
import org.springframework.stereotype.Component;

@Component
public class EnvioEstandar implements CalculadoraEnvio {

    private static final BigDecimal GRATIS_DESDE = new BigDecimal("999");
    private static final BigDecimal TARIFA = new BigDecimal("149");

    @Override
    public BigDecimal costo(BigDecimal subtotal) {
        return subtotal.compareTo(GRATIS_DESDE) >= 0 ? BigDecimal.ZERO : TARIFA;
    }
}

Después, el servicio. Pide una CalculadoraEnvio en el constructor y no sabe cuál le van a dar:

package com.ejemplo.pedidos;

import java.math.BigDecimal;
import org.springframework.stereotype.Service;

@Service
public class ServicioPedidos {

    private final CalculadoraEnvio envio;

    public ServicioPedidos(CalculadoraEnvio envio) {
        this.envio = envio;
    }

    public BigDecimal total(BigDecimal subtotal) {
        return subtotal.add(envio.costo(subtotal));
    }
}

Para probarlo sin montar todavía una API web, usamos un CommandLineRunner: un bean que Spring ejecuta en cuanto termina de arrancar. Este proyecto usa el starter básico, spring-boot-starter, sin servidor web; por eso la aplicación termina sola al acabar:

package com.ejemplo.pedidos;

import java.math.BigDecimal;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class PedidosApplication {

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

    @Bean
    CommandLineRunner probar(ServicioPedidos pedidos) {
        return args -> {
            System.out.println("Pedido de $450: total $" + pedidos.total(new BigDecimal("450")));
            System.out.println("Pedido de $1,200: total $" + pedidos.total(new BigDecimal("1200")));
        };
    }
}
salidaPedido de $450: total $599
Pedido de $1,200: total $1200

Nadie escribió new ServicioPedidos(...) ni new EnvioEstandar(). Al arrancar, Spring encontró las clases marcadas, vio que ServicioPedidos necesita una CalculadoraEnvio, buscó un bean de ese tipo, encontró EnvioEstandar y armó todo en orden. El runner pidió el servicio en sus parámetros y lo recibió igual.

Dentro del contenedor de Spring, el ApplicationContext, hay tres piezas: EnvioEstandar, marcada con @Component, se inyecta en ServicioPedidos, marcada con @Service, y ese servicio se inyecta en tu runner o tu controlador. Tú declaras qué necesita cada clase; Spring crea los objetos y los conectaEl contenedor arma y entregacontenedor de Spring (ApplicationContext)EnvioEstandar@Componentlo inyectaServicioPedidos@Servicetu runner o tu controladortú declaras qué necesita cada clase;Spring crea los objetos y los conecta
La inyección de dependencias: cada clase declara qué necesita y el contenedor lo entrega. Esquema: decodigo.com.

@Component, @Service, @Repository y @Controller

Las cuatro hacen lo mismo para el contenedor: marcan una clase para que Spring cree su bean. La diferencia es el mensaje para quien lee el código, y algún detalle extra:

  • AnotaciónPara qué claseDetalle
  • @ComponentCualquier piezaLa general.
  • @ServiceLógica del negocioSolo comunica la intención.
  • @RepositoryAcceso a datosTraduce los errores de la base de datos a excepciones de Spring.
  • @RestControllerAtender peticiones webLo que devuelven sus métodos es la respuesta (lección 3).

Por qué en el constructor

Spring también sabe inyectar en un atributo marcado con @Autowired, y lo verás en muchos tutoriales viejos. En código nuevo, usa el constructor. Los atributos pueden ser final, así que nadie los cambia después; la clase deja claro qué necesita para funcionar; y en una prueba puedes crearla con new ServicioPedidos(envioFalso) sin arrancar Spring. Cuando una clase tiene un solo constructor, Spring lo usa sin que pongas @Autowired. En las rarezas está lo que pasa cuando alguien hace new de una clase que esperaba inyección en atributos.

Beans de clases que no son tuyas: @Bean

No puedes ponerle @Component a una clase de Java como Clock, porque no es tu código. Para esos casos se escribe un método que construye el objeto, marcado con @Bean, dentro de una clase @Configuration. Spring llama al método una vez y guarda lo que devuelve como bean:

package com.ejemplo.reloj;

import java.time.Clock;
import java.time.ZoneId;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RelojConfig {

    @Bean
    Clock reloj() {
        return Clock.system(ZoneId.of("America/Mexico_City"));
    }
}

Ahora cualquier clase puede pedir un Clock. Inyectar el reloj, en vez de llamar a LocalTime.now() directamente, es un truco muy usado: en las pruebas se le pasa un reloj fijo y el resultado no depende de la hora a la que corras la prueba.

package com.ejemplo.reloj;

import java.time.Clock;
import java.time.LocalTime;
import org.springframework.stereotype.Service;

@Service
public class Saludador {

    private final Clock reloj;

    public Saludador(Clock reloj) {
        this.reloj = reloj;
    }

    public String saludo() {
        int hora = LocalTime.now(reloj).getHour();
        if (hora < 12) return "Buenos días";
        if (hora < 19) return "Buenas tardes";
        return "Buenas noches";
    }
}
package com.ejemplo.reloj;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class RelojApplication {

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

    @Bean
    CommandLineRunner probar(Saludador saludador, ApplicationContext contexto) {
        return args -> {
            System.out.println(saludador.saludo() + " (zona: " + contexto.getBean(java.time.Clock.class).getZone() + ")");
            Saludador otro = contexto.getBean(Saludador.class);
            System.out.println("¿Es el mismo objeto? " + (otro == saludador));
        };
    }
}
salidaBuenos días (zona: America/Mexico_City)
¿Es el mismo objeto? true

La segunda línea muestra otra cosa importante: por omisión, cada bean es único (un singleton). Pedirlo dos veces da el mismo objeto. Por eso un bean no debe guardar en sus atributos datos de un usuario o de una petición: lo comparten todos. Lo vemos con un ejemplo en las rarezas.

Dos candidatos para el mismo hueco

¿Qué pasa si agregamos una segunda implementación, EnvioExpress, también con @Component? El servicio pide «una CalculadoraEnvio» y ahora hay dos. Spring no adivina; se niega a arrancar:

registro: la aplicación no arranca***************************
APPLICATION FAILED TO START
***************************

Description:

Parameter 0 of constructor in com.ejemplo.pedidos.ServicioPedidos required a single bean, but 2 were found:
	- envioEstandar: defined in URL [jar:nested:/tmp/pedidos-dos/target/pedidos-dos-0.0.1-SNAPSHOT.jar/!BOOT-INF/classes/!/com/ejemplo/pedidos/EnvioEstandar.class]
	- envioExpress: defined in URL [jar:nested:/tmp/pedidos-dos/target/pedidos-dos-0.0.1-SNAPSHOT.jar/!BOOT-INF/classes/!/com/ejemplo/pedidos/EnvioExpress.class]

This may be due to missing parameter name information

Action:

Consider marking one of the beans as @Primary, updating the consumer to accept multiple beans, or using @Qualifier to identify the bean that should be consumed

Ensure that your compiler is configured to use the '-parameters' flag.
You may need to update both your build tool settings as well as your IDE.
(See https://github.com/spring-projects/spring-framework/wiki/Spring-Framework-6.1-Release-Notes#parameter-name-retention)

El mensaje nombra a los dos candidatos, envioEstandar y envioExpress, y dice dónde está cada uno. La pista final sobre la opción -parameters del compilador es genérica y aquí no aplica: el parent de Spring Boot ya la activa en Maven. Hay dos formas de resolverlo. Con @Primary en una de las clases, esa se vuelve la elegida cuando no se pide otra:

package com.ejemplo.pedidos;

import java.math.BigDecimal;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;

@Component
@Primary
public class EnvioExpress implements CalculadoraEnvio {

    @Override
    public BigDecimal costo(BigDecimal subtotal) {
        return new BigDecimal("289");
    }
}
salida con @Primary en EnvioExpressPedido de $450: total $739
Pedido de $1,200: total $1489

O, desde el lado de quien la pide, con @Qualifier y el nombre del bean, que es el de la clase con la primera letra en minúscula:

package com.ejemplo.pedidos;

import java.math.BigDecimal;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service
public class ServicioPedidos {

    private final CalculadoraEnvio envio;

    public ServicioPedidos(@Qualifier("envioEstandar") CalculadoraEnvio envio) {
        this.envio = envio;
    }

    public BigDecimal total(BigDecimal subtotal) {
        return subtotal.add(envio.costo(subtotal));
    }
}
salida con @Qualifier("envioEstandar")Pedido de $450: total $599
Pedido de $1,200: total $1200

El error que te ahorra: la clase sin anotación

Se te olvidó el @Service en ServicioPedidos. Compila sin problema, porque para Java no falta nada, pero al arrancar:

registro: la aplicación no arranca***************************
APPLICATION FAILED TO START
***************************

Description:

Parameter 0 of method probar in com.ejemplo.pedidos.PedidosApplication required a bean of type 'com.ejemplo.pedidos.ServicioPedidos' that could not be found.

Action:

Consider defining a bean of type 'com.ejemplo.pedidos.ServicioPedidos' in your configuration.

Traducido: el runner necesita un ServicioPedidos, y en el contenedor no hay ninguno. El mensaje sugiere declarar el bean. Cuando lo veas, revisa tres cosas: que la clase tenga su anotación, que esté en el paquete de la aplicación o debajo de él, y que no haya un error de dedo en el tipo que se pide.

Retos

Reto 1. Agrega al proyecto hola un endpoint GET /navidad que responda cuántos días faltan para el 25 de diciembre, con la fecha de la Ciudad de México.

Ver la solución
package com.ejemplo.hola;

import java.time.LocalDate;
import java.time.ZoneId;
import java.time.temporal.ChronoUnit;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HoraController {

    @GetMapping("/navidad")
    public String navidad() {
        LocalDate hoy = LocalDate.now(ZoneId.of("America/Mexico_City"));
        LocalDate navidad = LocalDate.of(hoy.getYear(), 12, 25);
        if (hoy.isAfter(navidad)) navidad = navidad.plusYears(1);
        return "Faltan " + ChronoUnit.DAYS.between(hoy, navidad) + " días para Navidad";
    }
}
terminal (el 22 de noviembre de 2026)$ curl -s localhost:8080/navidad
Faltan 33 días para Navidad

Es una clase nueva con su @RestController; no hace falta tocar la otra. Si la fecha ya pasó en el año, se cuenta hasta la del siguiente.

Reto 2. Cambia ServicioPedidos para que el total incluya el IVA de 16 % sobre el subtotal (el envío, sin IVA). ¿Hay que tocar EnvioEstandar o el runner?

Ver la solución
package com.ejemplo.pedidos;

import java.math.BigDecimal;
import java.math.RoundingMode;
import org.springframework.stereotype.Service;

@Service
public class ServicioPedidos {

    private static final BigDecimal IVA = new BigDecimal("0.16");
    private final CalculadoraEnvio envio;

    public ServicioPedidos(CalculadoraEnvio envio) {
        this.envio = envio;
    }

    public BigDecimal total(BigDecimal subtotal) {
        BigDecimal conIva = subtotal.add(subtotal.multiply(IVA)).setScale(2, RoundingMode.HALF_UP);
        return conIva.add(envio.costo(subtotal));
    }
}
salidaPedido de $450: total $671.00
Pedido de $1,200: total $1392.00

No: ninguna otra clase cambia, porque cada una solo depende de lo que pide. BigDecimal evita los errores de redondeo de double con el dinero, y setScale(2, HALF_UP) deja dos decimales.

Reto 3. Sin ejecutarlo: si quitas @Component de EnvioEstandar pero dejas @Component en EnvioExpress, ¿la aplicación arranca? ¿Qué total da un pedido de $450?

Ver la solución

Sí arranca: vuelve a haber una sola CalculadoraEnvio en el contenedor, la exprés, y se inyecta sin preguntar. Un pedido de $450 da $739: 450 más 289 del envío exprés. Quitar una anotación cambió qué clase se usa sin tocar el servicio; esa es la ventaja de la inyección, y también la razón para revisar bien qué beans hay cuando algo se comporta distinto.

Cómo está hecho este curso

Cada fragmento de código pertenece a un proyecto Maven completo, con su pom.xml igual al que genera start.spring.io. Cada proyecto se compiló con Spring Boot 4.2.0, Java 25 (Temurin 25.0.5.1) y Maven 3.10.1, la misma versión que descarga el wrapper, en un contenedor limpio de Linux sin acceso a la red. Después se arrancó y se le hicieron las peticiones que ves, con curl, desde el mismo contenedor. Los registros, las respuestas y los mensajes de error están copiados de esa ejecución, con sus horas reales de la Ciudad de México; los mensajes salen en inglés, como en tu computadora.

¿Buscas una receta concreta en vez de una lección? En Ejemplos de Spring Boot hay tareas resueltas: un CRUD completo, paginación, subir archivos, seguridad, caché, tareas programadas… Y si te falta Java, empieza por la sección de Java.