Capítulo 8: "¿Qué es...?" — Los 40 conceptos más preguntados en entrevistas

Objetivo

Este capítulo agrupa las preguntas tipo "¿Qué es un DTO?", "¿Qué es MVC?" — las preguntas de vocabulario y conceptos que todo entrevistador hace primero. Si solo puede repasar un capítulo, que sea este.

---

1. ¿Qué es un DTO (Data Transfer Object)?

Un DTO es un objeto simple que sirve para transportar datos entre las capas de la aplicación, sin lógica de negocio.

¿Por qué no usar la Entity directamente?

Entity	DTO
Mapeada a la base de datos	Solo un contenedor de datos
Contiene relaciones JPA (lazy loading)	Contiene solo los campos necesarios
Puede exponer datos sensibles (contraseña, rol)	Se elige exactamente qué exponer
Cambiar la BDD = cambiar la API	API independiente de la BDD

Ejemplo concreto

// ENTITY (relacionada con la BDD)
@Entity
public class User {
    @Id @GeneratedValue
    private Long id;
    private String name;
    private String email;
    private String password;     // ← ¡nunca debe ser expuesto!
    private String role;

    @OneToMany(mappedBy = "user")
    private List<Order> orders;  // ← lazy loading, puede causar N+1
}

// DTO (lo que recibe el cliente)
public record UserDTO(
    Long id,
    String name,
    String email
    // sin password, sin rol, sin orders
) {}

// Conversión en el Service
@Service
public class UserService {
    public UserDTO toDto(User user) {
        return new UserDTO(user.getId(), user.getName(), user.getEmail());
    }
}

Frase de entrevista

"Un DTO es un objeto simple usado para transferir datos entre capas. Uso DTOs para evitar exponer entidades JPA en la API — esto previene filtrar campos sensibles como contraseñas y evita problemas de lazy-loading."

---

2. ¿Qué es MVC (Model-View-Controller)?

Un patrón arquitectónico que separa la aplicación en 3 responsabilidades:

Componente	Rol	En Spring Boot
Model	Los datos y la lógica de negocio	Entity, Service, Repository
View	La presentación (lo que ve el usuario)	JSON (API REST) o Thymeleaf (HTML)
Controller	El orquestador que recibe las peticiones y coordina	@Controller o @RestController

En Spring Boot REST, la "View" es el JSON

@RestController   // Controller
@RequestMapping("/api/users")
public class UserController {

    @GetMapping("/{id}")
    public UserDTO getUser(@PathVariable Long id) {
        return userService.findById(id);  // Model → convertido a JSON (View)
    }
}

Frase de entrevista

"MVC separa la aplicación en Model (datos/lógica), View (presentación) y Controller (manejo de peticiones). En una API REST, la View es la respuesta JSON serializada automáticamente por Jackson."

---

3. ¿Qué es una API REST?

API = Application Programming Interface (interfaz para que dos programas se comuniquen)

REST = Representational State Transfer (estilo arquitectónico para APIs web)

Las 6 reglas de REST

Regla	Significado
Cliente-Servidor	El cliente y el servidor están separados
Sin estado (Stateless)	Cada petición contiene toda la información necesaria
Cache	Las respuestas pueden ser almacenadas en caché
Interfaz uniforme	URLs coherentes, métodos HTTP estándar
Sistema en capas	El cliente no sabe si habla con el servidor final
Código bajo demanda (opcional)	El servidor puede enviar código ejecutable

Los métodos HTTP

Método	Acción	Ejemplo	Código de retorno
GET	Leer	GET /api/users/1	200 OK
POST	Crear	POST /api/users	201 Created
PUT	Reemplazar completamente	PUT /api/users/1	200 OK
PATCH	Modificar parcialmente	PATCH /api/users/1	200 OK
DELETE	Eliminar	DELETE /api/users/1	204 No Content

Frase de entrevista

"REST es un estilo arquitectónico para APIs web. Utiliza métodos HTTP (GET, POST, PUT, DELETE) para realizar operaciones CRUD sobre recursos identificados por URLs. Es stateless — cada petición es independiente."

---

4. ¿Qué es CRUD?

Las 4 operaciones básicas sobre los datos:

Letra	Operación	SQL	HTTP	Spring Data
C	Create	INSERT	POST	save()
R	Read	SELECT	GET	findById(), findAll()
U	Update	UPDATE	PUT/PATCH	save()
D	Delete	DELETE	DELETE	deleteById()

---

5. ¿Qué es un POJO?

POJO = Plain Old Java Object

Un objeto Java simple, sin ninguna dependencia de un framework:

// Esto es un POJO — solo campos, getters, setters
public class User {
    private String name;
    private String email;

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

Un Java Bean es un POJO que sigue convenciones: constructor sin argumentos, getters/setters, serializable.

Un Spring Bean es un objeto gestionado por el contenedor Spring (puede ser un POJO anotado con @Component, @Service, etc.).

---

6. ¿Qué es un Bean de Spring?

Un objeto creado y gestionado por el contenedor Spring (ApplicationContext).

// Esto es un Bean de Spring — Spring lo crea y lo gestiona
@Service
public class UserService {
    // Spring lo instancia automáticamente al arrancar
    // Spring lo inyecta donde sea necesario
    // Spring gestiona su ciclo de vida
}

// Esto NO es un Bean — creado manualmente
UserService service = new UserService();

¿Cómo crear un Bean?

Método	Ejemplo
Anotaciones estereotipo	@Component, @Service, @Repository, @Controller
@Bean en @Configuration	Método que retorna un objeto
@Import	Importar una clase de configuración

Frase de entrevista

"Un Spring Bean es un objeto gestionado por el contenedor IoC de Spring. Spring lo crea, inyecta sus dependencias y gestiona su ciclo de vida. Por defecto, los beans son singleton."

---

7. ¿Qué es IoC (Inversión de Control)?

Sin IoC: el código crea sus propias dependencias.

Con IoC: el contenedor crea las dependencias y las provee al código.

// SIN IoC — el código controla la creación
public class OrderService {
    private UserRepository repo = new UserRepository();  // Se crea a sí mismo
    private EmailService email = new EmailService();      // Se crea a sí mismo
}

// CON IoC — Spring controla la creación
@Service
public class OrderService {
    private final UserRepository repo;   // Spring provee
    private final EmailService email;    // Spring provee

    public OrderService(UserRepository repo, EmailService email) {
        this.repo = repo;    // Inyectado por Spring
        this.email = email;  // Inyectado por Spring
    }
}

La inyección de dependencias (DI) es el mecanismo concreto que implementa IoC.

---

8. ¿Qué es ORM, JPA y Hibernate?

Término	Definición	Analogía
ORM	Object-Relational Mapping — técnica que mapea los objetos Java a tablas SQL	El traductor entre Java y SQL
JPA	Jakarta Persistence API — la especificación (interfaz) del ORM en Java	El contrato / el estándar
Hibernate	La implementación más popular de JPA	El software que hace el trabajo

JPA (especificación)    →  Hibernate (implementación)
      ↓                          ↓
 "así debería funcionar"    "este es el código que
                             lo hace funcionar"

// Anotaciones JPA (estándar)
@Entity                // JPA dice: "esta clase es una entidad"
@Table(name = "users") // JPA dice: "mapeada a la tabla users"
public class User {
    @Id                // JPA dice: "esta es la clave primaria"
    @GeneratedValue    // JPA dice: "auto-incrementada"
    private Long id;

    @Column(name = "full_name") // JPA dice: "mapeado a esta columna"
    private String name;
}

// Hibernate hace el trabajo detrás: genera las consultas SQL,
// gestiona el caché, el lazy loading, las transacciones...

Frase de entrevista

"JPA es la especificación que define cómo los objetos Java se mapean a tablas de base de datos. Hibernate es la implementación más popular de JPA. Uso anotaciones JPA para que mi código no dependa específicamente de Hibernate."

---

9. ¿Qué es Maven?

Una herramienta de gestión de build y dependencias para proyectos Java.

Funcionalidad	Descripción
Dependencias	Descarga automáticamente las librerías (desde Maven Central)
Build	Compila, prueba, empaqueta la aplicación (.jar)
Lifecycle	mvn clean → mvn compile → mvn test → mvn package
pom.xml	El archivo de configuración del proyecto

<!-- pom.xml — el corazón de Maven -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

Maven vs Gradle: Maven usa XML (verboso pero estándar), Gradle usa Groovy/Kotlin (más conciso pero curva de aprendizaje).

---

10. ¿Qué es Tomcat?

Un servidor web / contenedor de servlets que ejecuta aplicaciones Java.

Spring Boot integra Tomcat directamente:

java -jar miapp.jar
       ↓
  ┌──────────────────────┐
  │     Spring Boot       │
  │  ┌──────────────────┐ │
  │  │  Tomcat integrado│ │  ← escucha en el puerto 8080
  │  │  (embedded)      │ │
  │  └──────────────────┘ │
  │  ┌──────────────────┐ │
  │  │  Su código       │ │
  │  │  Controllers     │ │
  │  │  Services        │ │
  │  └──────────────────┘ │
  └──────────────────────┘

No es necesario instalar Tomcat por separado — Spring Boot lo incluye en el .jar.

---

11. ¿Qué es JSON?

JSON = JavaScript Object Notation — un formato de datos ligero y legible.

{
    "id": 1,
    "name": "Jean Dupont",
    "email": "jean@mail.com",
    "active": true,
    "roles": ["USER", "ADMIN"],
    "address": {
        "city": "Montréal",
        "postalCode": "H2X 1Y4"
    }
}

En Spring Boot, Jackson convierte automáticamente los objetos Java a JSON y viceversa:

// Java → JSON (serialización)
@GetMapping("/users/1")
public UserDTO getUser() {
    return new UserDTO(1L, "Jean", "jean@mail.com");
    // Jackson transforma automáticamente a JSON
}

// JSON → Java (deserialización)
@PostMapping("/users")
public void create(@RequestBody UserDTO dto) {
    // Jackson transforma el JSON del body en objeto UserDTO
}

---

12. ¿Qué es Postman y Swagger?

Herramienta	Rol
Postman	Cliente HTTP para probar manualmente las API REST (enviar GET, POST, etc.)
Swagger / OpenAPI	Genera automáticamente una documentación interactiva de la API

Swagger en Spring Boot:

<!-- Agregar en pom.xml -->
<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
    <version>2.3.0</version>
</dependency>

Luego, acceda a http://localhost:8080/swagger-ui.html para probar sus endpoints directamente desde el navegador.

---

13. ¿Qué es Docker?

Docker crea contenedores: entornos aislados que contienen su aplicación + todas sus dependencias.

Sin Docker:                 Con Docker:
"Funciona en mi máquina"    "Funciona en TODAS PARTES"

Mi PC:                      Contenedor:
├── Java 17                 ├── Java 17
├── Maven 3.9               ├── Maven 3.9
├── PostgreSQL 15           ├── App.jar
└── Mi App                  └── (todo está incluido)
    ↕ Posibles conflictos       ↕ Aislado y portable

# Dockerfile para Spring Boot
FROM eclipse-temurin:17-jre
COPY target/app.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

---

14. ¿Qué es CI/CD?

Término	Significado	Cuándo
CI — Integración Continua	Compilar + probar automáticamente en cada git push	En cada commit
CD — Entrega Continua	Desplegar automáticamente en producción	Después de las pruebas

Herramientas: GitHub Actions, Jenkins, GitLab CI, CircleCI.

---

15. ¿Qué es Git y GitHub?

Término	Definición
Git	Herramienta de control de versiones — sigue el historial de cambios del código
GitHub	Plataforma web que aloja los repositorios Git + colaboración

git add .              # Preparar los cambios
git commit -m "fix"    # Guardar en el historial local
git push origin main   # Enviar a GitHub
git pull               # Obtener los cambios de otros
git branch feature-x   # Crear una rama
git merge feature-x    # Fusionar una rama

---

16. ¿Qué es la arquitectura en capas (Layered Architecture)?

Regla de oro

Cada capa solo se comunica con la capa directamente inferior.

✅ Controller → Service → Repository → Database
❌ Controller → Repository (¡nunca directamente!)
❌ Controller → Database (¡nunca directamente!)

Frase de entrevista

"Sigo una arquitectura en capas: Controller maneja HTTP, Service contiene la lógica de negocio, Repository gestiona el acceso a datos. Cada capa solo habla con la capa directamente inferior. Esta separación hace el código testeable y mantenible."

---

17. ¿Qué es el Spring IoC Container (ApplicationContext)?

El contenedor que crea, configura y ensambla todos los beans de Spring al arrancar:

Arranque de la aplicación:

1. @SpringBootApplication → inicia el escaneo
2. Encuentra @Component, @Service, @Repository, @Controller
3. Crea las instancias (beans)
4. Resuelve las dependencias (@Autowired)
5. Inyecta las dependencias
6. Llama a @PostConstruct
7. ══════ Aplicación lista ══════

---

18. ¿Qué es @Autowired? ¿Qué es la inyección de dependencias?

3 formas de inyectar en Spring:

// ✅ 1. Inyección por CONSTRUCTOR (recomendada)
@Service
public class OrderService {
    private final UserRepository userRepo;
    private final EmailService emailService;

    public OrderService(UserRepository userRepo, EmailService emailService) {
        this.userRepo = userRepo;
        this.emailService = emailService;
    }
}

// ⚠️ 2. Inyección por SETTER
@Service
public class OrderService {
    private UserRepository userRepo;

    @Autowired
    public void setUserRepo(UserRepository userRepo) {
        this.userRepo = userRepo;
    }
}

// ❌ 3. Inyección por CAMPO (no recomendada)
@Service
public class OrderService {
    @Autowired
    private UserRepository userRepo;
}

¿Por qué el constructor es el mejor?

Criterio	Constructor	Setter	Campo
Inmutabilidad (final)	✅	❌	❌
Testeable sin Spring	✅	⚠️	❌
Dependencias obligatorias	✅	❌	❌
Detecta dependencias circulares	✅	❌	❌

Frase de entrevista

"Prefiero la inyección por constructor porque permite campos final (inmutabilidad), hace explícitas las dependencias y funciona sin Spring para pruebas. Desde Spring 4.3, @Autowired es opcional en un único constructor."

---

19. ¿Qué es un Record en Java?

Un Record (Java 16+) es un tipo especial para objetos inmutables que solo contienen datos:

// Antes (POJO clásico — 30 líneas)
public class UserDTO {
    private final Long id;
    private final String name;
    private final String email;

    public UserDTO(Long id, String name, String email) {
        this.id = id; this.name = name; this.email = email;
    }
    public Long getId() { return id; }
    public String getName() { return name; }
    public String getEmail() { return email; }
    // + equals(), hashCode(), toString()...
}

// Después (Record — ¡1 línea!)
public record UserDTO(Long id, String name, String email) {}
// Genera automáticamente: constructor, getters, equals, hashCode, toString

Ideal para: DTOs, peticiones, respuestas, eventos.

---

20. ¿Qué es Lombok?

Una librería que genera automáticamente el código repetitivo (boilerplate) en compilación:

// Sin Lombok — 50+ líneas
public class User {
    private Long id;
    private String name;
    private String email;
    // constructor, getters, setters, equals, hashCode, toString...
}

// Con Lombok — 5 líneas
@Data                    // getters, setters, equals, hashCode, toString
@NoArgsConstructor       // constructor sin argumentos
@AllArgsConstructor      // constructor con todos los argumentos
@Builder                 // patrón Builder
public class User {
    private Long id;
    private String name;
    private String email;
}

Anotación Lombok	Genera
@Getter / @Setter	Getters y/o setters
@ToString	toString()
@EqualsAndHashCode	equals() y hashCode()
@Data	Todo lo anterior
@Builder	Patrón Builder
@NoArgsConstructor	Constructor vacío
@AllArgsConstructor	Constructor completo
@Slf4j	Logger log

---

21. ¿Qué es ResponseEntity?

Un objeto de Spring que representa la respuesta HTTP completa (estatus + headers + body):

// Sin ResponseEntity — sin control sobre el estatus
@GetMapping("/{id}")
public UserDTO getUser(@PathVariable Long id) {
    return userService.findById(id);  // siempre 200 OK
}

// Con ResponseEntity — control total
@GetMapping("/{id}")
public ResponseEntity<UserDTO> getUser(@PathVariable Long id) {
    return userService.findById(id)
        .map(ResponseEntity::ok)                      // 200 OK
        .orElse(ResponseEntity.notFound().build());    // 404 Not Found
}

@PostMapping
public ResponseEntity<UserDTO> create(@Valid @RequestBody CreateUserRequest req) {
    UserDTO created = userService.create(req);
    return ResponseEntity
        .status(HttpStatus.CREATED)     // 201 Created
        .header("Location", "/api/users/" + created.id())
        .body(created);
}

@DeleteMapping("/{id}")
public ResponseEntity<Void> delete(@PathVariable Long id) {
    userService.delete(id);
    return ResponseEntity.noContent().build();  // 204 No Content
}

---

22. ¿Qué es @Valid y la validación Bean Validation?

// DTO con restricciones de validación
public record CreateUserRequest(
    @NotBlank(message = "El nombre es obligatorio")
    String name,

    @Email(message = "Email inválido")
    @NotBlank
    String email,

    @Size(min = 8, message = "Mínimo 8 caracteres")
    String password,

    @Min(value = 18, message = "Mínimo 18 años")
    int age
) {}

// Controller — @Valid dispara la validación
@PostMapping
public ResponseEntity<UserDTO> create(@Valid @RequestBody CreateUserRequest req) {
    // Si la validación falla → 400 Bad Request automático
    return ResponseEntity.status(HttpStatus.CREATED)
        .body(userService.create(req));
}

Anotación	Verifica
@NotNull	No nulo
@NotBlank	No nulo, no vacío, no solo espacios
@NotEmpty	No nulo, no vacío
@Email	Formato de email válido
@Size(min, max)	Tamaño entre min y max
@Min / @Max	Valor numérico min/max
@Pattern(regexp)	Coincide con una expresión regular
@Past / @Future	Fecha en el pasado/futuro

---

23. ¿Qué es application.properties / application.yml?

El archivo de configuración de la aplicación Spring Boot:

# application.yml
server:
  port: 8080

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb
    username: admin
    password: secret
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

app:
  jwt:
    secret: mySecretKey
    expiration: 86400000

Se accede a los valores con @Value:

@Value("${app.jwt.secret}")
private String jwtSecret;

@Value("${server.port}")
private int port;

---

24. ¿Qué es Spring Security?

El framework de seguridad de Spring para autenticación y autorización:

Concepto	Pregunta	Ejemplo
Autenticación	"¿Quién es usted?"	Login + contraseña, JWT
Autorización	"¿Tiene permiso?"	Rol USER, ADMIN

---

25. ¿Qué es JWT (JSON Web Token)?

Un token enviado en cada petición para probar la identidad del usuario:

JWT = HEADER.PAYLOAD.SIGNATURE

eyJhbGciOiJIUzI1NiJ9.          ← Header (algoritmo)
eyJzdWIiOiJhbGljZSJ9.          ← Payload (datos: usuario, rol, expiración)
SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c  ← Firma (verificación)

El flujo

1. POST /api/auth/login  { "email": "alice@mail.com", "password": "123" }
2. El servidor verifica → Genera un JWT → Lo retorna al cliente
3. El cliente almacena el JWT
4. GET /api/users  Header: Authorization: Bearer eyJhbG...
5. El servidor valida el JWT → Autoriza la petición

---

26. ¿Qué es CORS?

CORS = Cross-Origin Resource Sharing

Cuando su frontend (localhost:3000) llama a su backend (localhost:8080), el navegador bloquea la petición por seguridad. CORS permite estas peticiones cross-origin.

@Configuration
public class CorsConfig {
    @Bean
    public WebMvcConfigurer corsConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            public void addCorsMappings(CorsRegistry registry) {
                registry.addMapping("/api/**")
                    .allowedOrigins("http://localhost:3000")
                    .allowedMethods("GET", "POST", "PUT", "DELETE");
            }
        };
    }
}

---

27. ¿Qué es Singleton en Spring?

Por defecto, cada bean de Spring es un Singleton — una sola instancia compartida en toda la aplicación:

@Service
public class UserService { ... }  // UNA sola instancia, compartida en toda la app

// En toda la app, es el MISMO objeto UserService
@RestController
class UserController {
    private final UserService userService; // misma instancia
}

@RestController
class AdminController {
    private final UserService userService; // ¡misma instancia!
}

---

28. ¿Cuál es la diferencia entre PUT y PATCH?

Método	Acción	Ejemplo
PUT	Reemplaza todo el objeto	Enviar todos los campos
PATCH	Modifica parcialmente	Enviar solo los campos a modificar

// PUT — reemplaza todo
@PutMapping("/{id}")
public UserDTO update(@PathVariable Long id, @RequestBody UserDTO dto) {
    // Todos los campos son sobrescritos
}

// PATCH — modifica parcialmente
@PatchMapping("/{id}")
public UserDTO patch(@PathVariable Long id, @RequestBody Map<String, Object> updates) {
    // Solo los campos enviados son modificados
}

---

29. ¿Qué es una Exception Custom?

// Excepción personalizada
@ResponseStatus(HttpStatus.NOT_FOUND)
public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException(String message) {
        super(message);
    }
}

// Uso
public User findById(Long id) {
    return userRepository.findById(id)
        .orElseThrow(() -> new ResourceNotFoundException("User not found: " + id));
}

// Manejo global
@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleNotFound(ResourceNotFoundException ex) {
        return ResponseEntity.status(404)
            .body(new ErrorResponse(404, ex.getMessage()));
    }
}

public record ErrorResponse(int status, String message) {}

---

30. ¿Qué es Spring Actuator?

Endpoints de monitoreo listos para usar:

# application.yml
management:
  endpoints:
    web:
      exposure:
        include: health, info, metrics

Endpoint	Qué muestra
/actuator/health	La app está UP o DOWN
/actuator/info	Información sobre la app
/actuator/metrics	Métricas (memoria, CPU, peticiones)
/actuator/env	Variables de entorno

---

Resumen — Los 30 conceptos en 1 frase

Concepto	En 1 frase
DTO	Objeto para transportar datos sin exponer la entidad
MVC	Model (datos), View (presentación), Controller (peticiones)
API REST	Interfaz web que usa GET/POST/PUT/DELETE sobre URLs
CRUD	Create, Read, Update, Delete
POJO	Objeto Java simple sin dependencia de framework
Bean	Objeto creado y gestionado por Spring
IoC	Spring crea las dependencias en vez del código
ORM/JPA	Mapear objetos Java a tablas SQL
Maven	Gestión de dependencias y build
Tomcat	Servidor web integrado en Spring Boot
JSON	Formato de datos ligero (clave-valor)
Postman	Cliente para probar APIs
Swagger	Documentación automática de la API
Docker	Contenedor aislado para la aplicación
CI/CD	Build + test + despliegue automático
Git	Control de versiones del código fuente
Capas	Controller → Service → Repository → DB
@Autowired	Inyección automática de dependencias
Record	Clase inmutable auto-generada (Java 16+)
Lombok	Genera getters/setters/equals automáticamente
ResponseEntity	Respuesta HTTP completa (estatus + body)
@Valid	Dispara la validación de entradas
application.yml	Archivo de configuración de Spring Boot
Spring Security	Autenticación + autorización
JWT	Token para identificar al usuario
CORS	Permitir peticiones cross-origin
Singleton	Una sola instancia del bean en toda la app
PUT vs PATCH	PUT reemplaza todo, PATCH modifica parcialmente
Exception Custom	Excepción personalizada con código HTTP
Actuator	Monitoreo y métricas de la aplicación

---

⬅️ Capítulo 7: Colecciones Java | ⬅️ Volver al Módulo 18