Quiz: Primeros Pasos con Spring Boot

Ponga a prueba sus conocimientos sobre la creación y la estructura de un proyecto Spring Boot.

30 preguntas - Haga clic en cada pregunta para revelar la respuesta.

Preguntas 1-10: Spring Initializr y Estructura

Pregunta 1: ¿Qué es Spring Initializr?

Respuesta: Spring Initializr es una herramienta web (start.spring.io) que genera la estructura base de un proyecto Spring Boot:

Elección del tipo de proyecto (Maven/Gradle)
Versión de Java y Spring Boot
Dependencias iniciales
Metadatos del proyecto (groupId, artifactId)

Pregunta 2: ¿Cuál es la estructura estándar de un proyecto Spring Boot?

Respuesta:

src/
├── main/
│   ├── java/
│   │   └── com/example/demo/
│   │       └── DemoApplication.java
│   └── resources/
│       ├── application.properties
│       ├── static/
│       └── templates/
└── test/
    └── java/
pom.xml

Pregunta 3: ¿Para qué sirve el archivo pom.xml?

Respuesta: El archivo pom.xml (Project Object Model) define:

Metadatos del proyecto (groupId, artifactId, version)
Dependencias
Plugins de Maven
Configuración de build
Parent Spring Boot (spring-boot-starter-parent)

Pregunta 4: ¿Qué es spring-boot-starter-parent?

Respuesta: Un parent de Maven que proporciona:

Gestión de versiones de dependencias
Configuración predeterminada de plugins
Codificación UTF-8
Versión de Java configurada
Perfiles de build

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

Pregunta 5: ¿Qué es un starter de Spring Boot?

Respuesta: Un starter es un conjunto de dependencias preconfiguradas para un uso específico:

Starter	Uso
`spring-boot-starter-web`	API REST
`spring-boot-starter-data-jpa`	Base de datos
`spring-boot-starter-security`	Seguridad
`spring-boot-starter-test`	Pruebas

Pregunta 6: ¿Dónde colocar el archivo application.properties?

Respuesta: En src/main/resources/application.properties o application.yml.

Este archivo contiene la configuración de la aplicación (puerto, base de datos, etc.).

Pregunta 7: ¿Cuál es la diferencia entre application.properties y application.yml?

Respuesta:

# application.properties
server.port=8080
spring.datasource.url=jdbc:postgresql://localhost/db

# application.yml
server:
  port: 8080
spring:
  datasource:
    url: jdbc:postgresql://localhost/db

YAML es más legible para configuraciones jerárquicas.

Pregunta 8: ¿Para qué sirve la carpeta static/?

Respuesta: La carpeta src/main/resources/static/ contiene los archivos estáticos servidos directamente:

CSS
JavaScript
Imágenes
Archivos HTML estáticos

Accesible vía http://localhost:8080/fichier.css

Pregunta 9: ¿Para qué sirve la carpeta templates/?

Respuesta: La carpeta src/main/resources/templates/ contiene los templates del lado del servidor:

Thymeleaf (.html)
FreeMarker (.ftl)
Mustache (.mustache)

Utilizado para aplicaciones web con renderizado en el servidor.

Pregunta 10: ¿Cómo ejecutar una aplicación Spring Boot?

Respuesta:

# Con Maven
mvn spring-boot:run

# O compilando el JAR
mvn clean package
java -jar target/app.jar

# Desde el IDE
# Ejecutar la clase main

Preguntas 11-20: Clase Principal y Anotaciones

Pregunta 11: ¿Qué contiene la clase principal?

Respuesta:

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

Es el punto de entrada que inicia el contexto de Spring.

Pregunta 12: ¿Qué hace @SpringBootApplication?

Respuesta: @SpringBootApplication combina tres anotaciones:

@Configuration: clase de configuración
@EnableAutoConfiguration: auto-configuración de Spring Boot
@ComponentScan: escaneo de componentes

Pregunta 13: ¿Qué es la auto-configuración?

Respuesta: Spring Boot configura automáticamente los beans según:

Las dependencias presentes
Las propiedades definidas
Los beans existentes

Ejemplo: agregar spring-boot-starter-data-jpa configura automáticamente un DataSource.

Pregunta 14: ¿Qué es @RestController?

Respuesta: Anotación que combina:

@Controller: componente web
@ResponseBody: retorna JSON/XML

@RestController
public class UserController {
    
    @GetMapping("/users")
    public List<User> getAll() {
        return userService.findAll();
    }
}

Pregunta 15: ¿Cuáles son las anotaciones de mapeo HTTP?

Respuesta:

Anotación	Método HTTP
`@GetMapping`	GET
`@PostMapping`	POST
`@PutMapping`	PUT
`@DeleteMapping`	DELETE
`@PatchMapping`	PATCH
`@RequestMapping`	Todas (configurable)

Pregunta 16: ¿Cómo obtener un parámetro de URL?

Respuesta:

// Path variable: /users/123
@GetMapping("/users/{id}")
public User getUser(@PathVariable Long id) {
    return userService.findById(id);
}

// Query param: /users?name=John
@GetMapping("/users")
public List<User> search(@RequestParam String name) {
    return userService.findByName(name);
}

Pregunta 17: ¿Cómo obtener el cuerpo de una petición?

Respuesta:

@PostMapping("/users")
public User create(@RequestBody UserRequest request) {
    return userService.create(request);
}

@RequestBody deserializa el JSON en un objeto Java.

Pregunta 18: ¿Para qué sirven @Component, @Service, @Repository?

Respuesta: Son estereotipos de Spring que marcan las clases como beans:

Anotación	Uso
`@Component`	Bean genérico
`@Service`	Lógica de negocio
`@Repository`	Acceso a datos
`@Controller`	Capa web

Todos son variantes de @Component.

Pregunta 19: ¿Qué son @Configuration y @Bean?

Respuesta:

@Configuration
public class AppConfig {
    
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@Configuration: clase de configuración
@Bean: método que produce un bean

Pregunta 20: ¿Cómo inyectar una dependencia?

Respuesta:

@Service
public class UserService {
    
    private final UserRepository userRepository;
    
    // Inyección por constructor (recomendado)
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

Preguntas 21-30: Configuración y Repositories

Pregunta 21: ¿Cómo definir el puerto del servidor?

Respuesta:

# application.properties
server.port=9090

# application.yml
server:
  port: 9090

Por defecto: 8080

Pregunta 22: ¿Cómo usar perfiles?

Respuesta:

# application.yml (común)
spring:
  profiles:
    active: dev

# application-dev.yml
server:
  port: 8080

# application-prod.yml
server:
  port: 80

Activación: --spring.profiles.active=prod

Pregunta 23: ¿Cómo leer una propiedad de configuración?

Respuesta:

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

@Value("${app.timeout:5000}")  // Valor por defecto
private int timeout;

Pregunta 24: ¿Qué es JpaRepository?

Respuesta: Interfaz de Spring Data JPA que proporciona métodos CRUD:

public interface UserRepository extends JpaRepository<User, Long> {
    // Métodos heredados: save, findById, findAll, delete, count...
}

Pregunta 25: ¿Cómo crear una entidad JPA?

Respuesta:

@Entity
@Table(name = "users")
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String name;
    
    private String email;
    
    // Getters, setters
}

Pregunta 26: ¿Cómo configurar H2 en memoria?

Respuesta:

spring:
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
  h2:
    console:
      enabled: true  # Consola: /h2-console

Perfecto para desarrollo y pruebas.

Pregunta 27: ¿Cómo genera Spring Data las consultas?

Respuesta: Por el nombre del método:

List<User> findByName(String name);
// SELECT * FROM users WHERE name = ?

List<User> findByEmailContaining(String email);
// SELECT * FROM users WHERE email LIKE '%?%'

List<User> findByAgeGreaterThanOrderByNameAsc(int age);
// SELECT * FROM users WHERE age > ? ORDER BY name ASC

Pregunta 28: ¿Cómo iniciar la aplicación con datos?

Respuesta:

@Component
public class DataInitializer implements CommandLineRunner {
    
    private final UserRepository repository;
    
    @Override
    public void run(String... args) {
        repository.save(new User("Admin", "admin@example.com"));
    }
}

O con src/main/resources/data.sql.

Pregunta 29: ¿Cómo ver las consultas SQL ejecutadas?

Respuesta:

spring:
  jpa:
    show-sql: true
    properties:
      hibernate:
        format_sql: true

logging:
  level:
    org.hibernate.SQL: DEBUG
    org.hibernate.orm.jdbc.bind: TRACE

Pregunta 30: ¿Cómo crear un JAR ejecutable?

Respuesta:

mvn clean package

# Resultado: target/app-0.0.1-SNAPSHOT.jar

java -jar target/app-0.0.1-SNAPSHOT.jar

El JAR contiene la aplicación y un servidor Tomcat embebido.

Puntuación

Puntuación	Nivel
27-30	Excelente - Fundamentos dominados
21-26	Bien - Algunas revisiones
15-20	Medio - Repase los capítulos
Menos de 15	A revisar

Volver al Módulo 2

Preguntas 1-10: Spring Initializr y Estructura​

Preguntas 11-20: Clase Principal y Anotaciones​

Preguntas 21-30: Configuración y Repositories​

Puntuación​

Preguntas 1-10: Spring Initializr y Estructura

Preguntas 11-20: Clase Principal y Anotaciones

Preguntas 21-30: Configuración y Repositories

Puntuación