94 preguntas de entrevista de Spring Boot para contratar a los mejores ingenieros

Contratar a desarrolladores de Spring Boot puede ser complicado porque el framework es muy versátil y abarca muchas áreas del desarrollo backend. Los reclutadores necesitan un conjunto de preguntas bien estructurado para identificar a los candidatos que realmente comprenden la tecnología y pueden aplicarla eficazmente, especialmente dado el auge de los microservicios, algo en lo que inciden nuestras habilidades requeridas para la oferta de empleo de desarrollador Spring Boot.

Esta entrada de blog proporciona una lista cuidadosamente seleccionada de preguntas para entrevistas de Spring Boot, categorizadas por nivel de experiencia, desde recién graduados hasta profesionales experimentados, incluyendo una sección de preguntas tipo test (MCQs). Le equipará con las preguntas adecuadas para evaluar los conocimientos y las habilidades prácticas de los candidatos.

Al utilizar estas preguntas, podrá optimizar su proceso de entrevista e identificar al mejor talento de Spring Boot; para un enfoque más estandarizado y basado en datos, considere utilizar la Prueba de Java Spring de Adaface para preseleccionar a los candidatos antes de las entrevistas.

Tabla de contenidos

Preguntas de entrevista de Spring Boot para principiantes

Preguntas de entrevista de Spring Boot para juniors

Preguntas de entrevista intermedias de Spring Boot

Preguntas de entrevista de Spring Boot para experimentados

Spring Boot MCQ

¿Qué habilidades de Spring Boot debes evaluar durante la fase de entrevista?

3 consejos para usar preguntas de entrevista de Spring Boot

Evalúa el talento de Spring Boot con evaluaciones específicas

Descarga la plantilla de preguntas de entrevista de Spring Boot en múltiples formatos

Preguntas de entrevista de Spring Boot para principiantes

1. ¿Qué es Spring Boot y por qué lo usan los desarrolladores?

Spring Boot es un framework que simplifica el desarrollo de aplicaciones basadas en Spring. Autoconfigura la aplicación en función de las dependencias, lo que significa que puedes crear aplicaciones Spring independientes de grado de producción con una configuración mínima. Incorpora servidores como Tomcat, Jetty o Undertow directamente, por lo que no necesitas implementarlos en un servidor externo.

Los desarrolladores usan Spring Boot porque reduce drásticamente el código repetitivo y el tiempo de configuración. Características como la autoconfiguración, las dependencias de inicio (por ejemplo, spring-boot-starter-web) y el Spring Initializr permiten un rápido desarrollo de aplicaciones. Optimiza el proceso de desarrollo, permitiendo a los desarrolladores centrarse en escribir lógica de negocio en lugar de configurar la infraestructura.

Algunos beneficios clave son:

• Tiempo de desarrollo reducido
• Configuración simplificada
• Fácil implementación
• Mayor productividad

2. ¿Puedes explicar el concepto de 'autoconfiguración' en Spring Boot?

La autoconfiguración en Spring Boot configura automáticamente su aplicación en función de las dependencias presentes en su classpath. Examina los JARs que ha añadido e intenta configurar los beans que cree que necesitará. Por ejemplo, si tiene spring-boot-starter-web en su classpath, Spring Boot configurará automáticamente un DispatcherServlet, Tomcat y otros componentes relacionados con la web.

Esencialmente, Spring Boot proporciona clases de configuración predefinidas (usando la anotación @Configuration) que se aplican condicionalmente en función de la presencia de clases o propiedades específicas. Esto reduce la cantidad de configuración estándar que necesita escribir manualmente. Su objetivo es minimizar la carga de configuración, lo que permite a los desarrolladores centrarse en escribir la lógica de negocio en lugar de configurar la infraestructura.

3. ¿Qué son los Spring Boot Starters y cómo simplifican la gestión de dependencias?

Los Spring Boot Starters son un conjunto de descriptores de dependencias convenientes que puede incluir en su aplicación. Proporcionan una forma optimizada de añadir todas las dependencias necesarias para una tecnología o característica específica. En lugar de añadir manualmente las dependencias individuales, puede añadir una única dependencia de starter.

Simplifican la gestión de dependencias agrupando las dependencias relacionadas en una única unidad lógica. Por ejemplo, el starter spring-boot-starter-web incluye todas las dependencias necesarias para construir una aplicación web, como Spring MVC, Tomcat y Jackson. Esto reduce el riesgo de conflictos de dependencias y asegura que tiene todos los componentes necesarios para la funcionalidad deseada. También gestionan las versiones de las dependencias, asegurando la compatibilidad.

4. ¿Cómo crearía una sencilla aplicación '¡Hola, mundo!' usando Spring Boot?

1. Crea un nuevo proyecto Spring Boot: Puedes usar Spring Initializr (https://start.spring.io/) para generar una estructura de proyecto básica. Agrega la dependencia 'Spring Web'.
2. Crea un Controlador: Crea una clase de controlador simple con un método para manejar la solicitud. Anota la clase con @RestController y el método con @GetMapping. El método debe devolver "¡Hola, Mundo!".

@RestController public class HelloController { @GetMapping("/") public String hello() { return "¡Hola, Mundo!"; } }

3. Ejecuta la aplicación: La anotación @SpringBootApplication en tu clase de aplicación principal se encarga de configurar automáticamente Spring y arrancar la aplicación. Construye y ejecuta la aplicación (por ejemplo, usando mvn spring-boot:run o gradle bootRun).
4. Accede a la aplicación: Abre tu navegador web y navega a http://localhost:8080/ (o el puerto en el que se está ejecutando tu aplicación) para ver el mensaje '¡Hola, Mundo!'.

5. ¿Cuál es el propósito de la anotación `@SpringBootApplication`?

La anotación @SpringBootApplication es una anotación de conveniencia que agrupa otras tres anotaciones de Spring Boot comúnmente usadas:

• @Configuration: Indica que la clase declara uno o más métodos @Bean o contiene la importación de otras configuraciones.
• @EnableAutoConfiguration: Habilita el mecanismo de autoconfiguración de Spring Boot, que configura automáticamente su aplicación Spring en función de las dependencias que haya agregado. Intenta deducir y configurar los beans que probablemente necesite.
• @ComponentScan: Habilita el escaneo de componentes para encontrar y registrar beans dentro de los paquetes especificados (de forma predeterminada, el paquete de la clase anotada y sus subpaquetes). Busca componentes como @Component, @Service, @Repository y @Controller.

Efectivamente, usar @SpringBootApplication marca una clase como fuente de definiciones de beans, activa la autoconfiguración y habilita el escaneo de componentes. Esto simplifica la configuración y el proceso de arranque para las aplicaciones Spring Boot. Normalmente se coloca en la clase principal de la aplicación.

6. Explique qué es un servidor embebido en el contexto de Spring Boot.

En Spring Boot, un servidor embebido es un servidor web que se incluye directamente dentro del artefacto implementable de la aplicación (por ejemplo, un archivo JAR). Esto elimina la necesidad de implementar la aplicación en un servidor web separado y preinstalado como Tomcat o Jetty.

Spring Boot es compatible con varios servidores embebidos, siendo Tomcat el predeterminado. Otros incluyen Jetty y Undertow. La elección del servidor embebido se puede configurar en el archivo pom.xml o build.gradle. Usar un servidor embebido simplifica la implementación y reduce la huella general de la aplicación. El servidor se inicia cuando se inicia la aplicación Spring Boot y se detiene cuando la aplicación se cierra. Ejemplo de dependencia para Tomcat:

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>

7. ¿Cómo se configuran diferentes entornos (por ejemplo, desarrollo, producción) en una aplicación Spring Boot?

Spring Boot ofrece varias formas de configurar diferentes entornos. Un enfoque común es usar archivos application-{profile}.properties o application-{profile}.yml. Por ejemplo, application-dev.properties contendría configuraciones específicas para el desarrollo. Se activa un perfil específico utilizando la propiedad spring.profiles.active en su application.properties o configurando una variable de entorno.

Otra forma es mediante el uso directo de variables de entorno o propiedades del sistema. Puede acceder a ellas usando @Value("${TU_PROPIEDAD}") o System.getenv("TU_VARIABLE_DE_ENTORNO"). Los perfiles también se pueden activar programáticamente dentro de la configuración de su aplicación si es necesario. Por ejemplo, una clase @Configuration anotada con @Profile("dev") solo se cargaría cuando el perfil "dev" esté activo.

8. ¿Cuáles son algunas anotaciones comunes de Spring Boot que has usado o de las que has oído hablar?

• @SpringBootApplication: Esta es una anotación de conveniencia que combina @Configuration, @EnableAutoConfiguration y @ComponentScan. Típicamente se usa en la clase principal de la aplicación.
• @RestController: Marca una clase como un controlador donde cada método devuelve un objeto de dominio en lugar de una vista. Combina @Controller y @ResponseBody.
• @RequestMapping: Se usa para mapear peticiones web a métodos manejadores específicos.
• @GetMapping, @PostMapping, @PutMapping, @DeleteMapping, @PatchMapping: Versiones especializadas de @RequestMapping para métodos HTTP específicos.
• @Autowired: Inyecta dependencias en una clase. Spring gestiona la inyección de dependencias.
• @Component, @Service, @Repository, @Controller: Estas son especializaciones de @Component para diferentes capas de una aplicación. Marcan una clase como un bean de Spring.
• @Configuration: Indica que una clase declara uno o más métodos @Bean y puede ser procesada por el contenedor Spring para generar definiciones de beans y atender peticiones de esos beans en tiempo de ejecución.
• @Bean: Se usa en un método para definir un nuevo bean gestionado por el contenedor Spring.
• @Value: Inyecta valores desde archivos de propiedades o variables de entorno.
• @Transactional: Habilita el comportamiento transaccional para un método o clase. Útil para operaciones de base de datos.
• @EnableAutoConfiguration: Habilita el mecanismo de auto-configuración de Spring Boot. Intenta configurar automáticamente tu aplicación Spring basándose en las dependencias que has añadido.

@PathVariable: Extrae valores de la ruta URI. @RequestBody: Vincula el cuerpo de la solicitud HTTP a un parámetro de método. @RequestParam: Extrae valores de los parámetros de consulta.

9. ¿Cómo maneja Spring Boot el manejo de excepciones?

Spring Boot ofrece varias formas de manejar excepciones, brindando flexibilidad y personalización. Los mecanismos principales son:

• @ControllerAdvice: Esta anotación permite definir manejadores de excepciones globales que se aplican a todos los controladores. Puede crear métodos anotados con @ExceptionHandler para manejar excepciones específicas o grupos de excepciones.
• @ExceptionHandler: Esta anotación se utiliza dentro de una clase @ControllerAdvice o un @Controller específico para manejar excepciones lanzadas por los métodos de manejo de solicitudes. Permite definir lógica personalizada para manejar diferentes tipos de excepciones y devolver respuestas apropiadas.
• ResponseEntityExceptionHandler: Esta es una clase base conveniente para las clases @ControllerAdvice que proporciona manejo de excepciones predefinido para excepciones comunes de Spring. Puede extender esta clase y anular sus métodos para personalizar el manejo de estas excepciones.

Por defecto, Spring Boot también proporciona una página de error predeterminada para las excepciones no controladas. Esto se puede personalizar proporcionando su propia página de error o configurando la propiedad server.error.path.

10. ¿Puede describir cómo acceder a las propiedades definidas en `application.properties` o `application.yml`?

Se puede acceder a las propiedades definidas en los archivos application.properties o application.yml de varias maneras en Spring Boot.

• Usando la anotación @Value: Esta es la forma más sencilla de inyectar valores de propiedades individuales directamente en los campos. Por ejemplo: @Value("${my.property.name}") private String myPropertyValue;
• Usando la anotación @ConfigurationProperties: Esto se utiliza para enlazar un grupo de propiedades con un prefijo común a una clase Java. Este enfoque proporciona seguridad de tipos y validación. Debería definir una clase anotada con @ConfigurationProperties(prefix = "my.prefix") y Spring Boot enlazará automáticamente las propiedades con claves que comiencen con my.prefix a los campos de esta clase. Estas clases deben registrarse como un bean para el contenedor Spring.

11. ¿Cuál es la diferencia entre `@RestController` y `@Controller` en Spring Boot?

@Controller y @RestController son ambas anotaciones de Spring usadas para manejar peticiones web, pero difieren en su comportamiento por defecto con respecto a cómo se maneja la respuesta.

@Controller se usa para aplicaciones MVC tradicionales donde el objetivo principal es devolver una vista (por ejemplo, HTML). Los métodos en un @Controller típicamente usan anotaciones @RequestMapping y devuelven un String que representa el nombre de la vista. El ViewResolver luego resuelve este nombre a una plantilla de vista real. Para devolver datos directamente (por ejemplo, JSON o XML) desde un @Controller, necesitarías usar la anotación @ResponseBody en el método.

@RestController es una anotación de conveniencia que combina @Controller y @ResponseBody. Está diseñado para construir APIs RESTful donde el valor de retorno del método se serializa directamente en el cuerpo de la respuesta (por ejemplo, como JSON o XML). No necesitas agregar @ResponseBody a cada método en un @RestController. Implica que los métodos del controlador devolverán datos directamente, no nombres de vistas.

12. ¿Cómo puedes realizar operaciones de base de datos usando Spring Boot y Spring Data JPA?

Spring Boot y Spring Data JPA simplifican significativamente las operaciones de base de datos. Empezamos por definir entidades JPA que se mapean a tablas de la base de datos. Spring Data JPA luego nos permite crear repositorios (interfaces) que extienden JpaRepository, CrudRepository, o PagingAndSortingRepository. Estas interfaces proporcionan operaciones CRUD básicas (Crear, Leer, Actualizar, Eliminar) listas para usar.

Para consultas más complejas que las básicas CRUD, puede definir métodos en la interfaz de su repositorio siguiendo convenciones de nomenclatura (por ejemplo, findByLastName), que Spring Data JPA implementará automáticamente. Alternativamente, puede usar la anotación @Query para definir consultas personalizadas usando JPQL o SQL nativo. La Inyección de Dependencias se utiliza para inyectar estos repositorios en su capa de servicio, donde puede realizar operaciones de base de datos utilizando los métodos proporcionados. Las transacciones se gestionan típicamente usando la anotación @Transactional.

13. ¿Qué es un Spring Bean y cómo se gestionan los beans en una aplicación Spring Boot?

Un Spring Bean es simplemente un objeto que es gestionado por el contenedor IoC (Inversión de Control) de Spring. Spring gestiona el ciclo de vida, las dependencias y la configuración del bean.

En una aplicación Spring Boot, los beans se gestionan típicamente utilizando anotaciones como @Component, @Service, @Repository y @Controller. El escaneo de componentes de Spring detecta automáticamente estas clases anotadas y las registra como beans en el contexto de la aplicación. También puede definir beans explícitamente utilizando métodos anotados con @Bean dentro de clases @Configuration. El contenedor Spring se encarga de crear, configurar y conectar estos beans basándose en las dependencias declaradas (a menudo usando @Autowired para la inyección de dependencias).

14. Explique cómo Spring Boot simplifica el proceso de creación de APIs RESTful.

Spring Boot simplifica la creación de API REST principalmente a través de sus capacidades de autoconfiguración y dependencias de inicio. spring-boot-starter-web es una dependencia clave que incluye todas las bibliotecas necesarias como Spring MVC, Jackson para el procesamiento JSON y un contenedor de servlet integrado (por ejemplo, Tomcat, Jetty) para comenzar rápidamente.

Además, anotaciones como @RestController, @RequestMapping, @GetMapping, @PostMapping, etc., proporcionan una forma concisa de definir mapeos de solicitudes y manejar métodos HTTP. Spring Boot configura automáticamente conversores de mensajes para manejar cargas útiles de solicitud y respuesta en formatos como JSON y XML, reduciendo el código repetitivo. Ejemplo de un controlador simple:

@RestController @RequestMapping("/api") public class MyController { @GetMapping("/hello") public String hello() { return "¡Hola, Mundo!"; } }

15. ¿Cuáles son algunas ventajas de usar Spring Boot sobre el desarrollo tradicional de Spring?

Spring Boot simplifica significativamente el desarrollo de Spring. Ofrece auto-configuración, reduciendo el código repetitivo y los archivos de configuración. Las dependencias se gestionan a través de POMs de inicio, agilizando el proceso de construcción. Los servidores integrados (como Tomcat, Jetty o Undertow) eliminan la necesidad de la implementación de un servidor externo, simplificando la implementación y gestión de la aplicación. Esto conduce a ciclos de desarrollo más rápidos y un mantenimiento de aplicaciones más sencillo.

En comparación con Spring tradicional, Spring Boot promueve una visión 'con opiniones', guiando a los desarrolladores hacia las mejores prácticas y reduciendo la fatiga de la toma de decisiones. Funciones como Actuator proporcionan capacidades integradas de monitoreo y gestión, simplificando aún más las tareas operativas. Los desarrolladores pueden centrarse en la lógica de negocio en lugar de dedicar tiempo a configuraciones complejas.

16. ¿Cómo implementaría una aplicación Spring Boot en una plataforma en la nube como AWS o Azure?

Para desplegar una aplicación Spring Boot en AWS o Azure, normalmente se empaquetaría como un archivo JAR o WAR y luego se elegiría un servicio de despliegue adecuado. Para AWS, las opciones incluyen EC2 (máquinas virtuales), Elastic Beanstalk (PaaS), ECS/EKS (orquestación de contenedores) y Lambda (sin servidor). Elastic Beanstalk simplifica el despliegue y la gestión, mientras que ECS/EKS ofrece más control y escalabilidad para aplicaciones en contenedores usando Docker. Para Azure, existen opciones similares, como Azure VMs, Azure App Service (PaaS), Azure Container Instances/Azure Kubernetes Service (AKS) y Azure Functions (sin servidor).

El proceso de despliegue generalmente implica:

• Construcción: Creación de un archivo JAR o WAR ejecutable.
• Configuración: Configuración del servicio en la nube elegido (por ejemplo, creación de un entorno Elastic Beanstalk o un plan de Azure App Service).
• Despliegue: Carga del artefacto al servicio en la nube. Considere el uso de pipelines CI/CD (por ejemplo, AWS CodePipeline, Azure DevOps) para despliegues automatizados. Configure variables de entorno, conexiones de base de datos y cualquier otra configuración necesaria específica para el entorno de destino. Además, asegúrese de que la registro y la monitorización adecuadas estén implementadas.

17. ¿Qué es Spring Data REST y cómo ayuda a construir servicios RESTful?

Spring Data REST construye APIs RESTful sobre repositorios de Spring Data. Simplifica el desarrollo de API REST al exponer automáticamente sus datos a través de puntos finales compatibles con HATEOAS, reduciendo el código repetitivo.

Específicamente, hace lo siguiente:

• Generación automática de puntos finales: Expone repositorios como puntos finales REST.
• Soporte HATEOAS: Genera enlaces en las respuestas para facilitar el descubrimiento.
• Personalización: Permite la personalización de puntos finales, el manejo de solicitudes/respuestas y la validación.
• Utiliza Spring Data: Aprovecha la abstracción del repositorio de Spring Data para el acceso a datos.

18. Explica cómo Spring Boot maneja la seguridad.

La seguridad de Spring Boot se maneja principalmente a través de Spring Security. Proporciona funciones de autenticación y autorización, lo que le permite controlar quién puede acceder a los recursos de su aplicación. Configura las reglas de seguridad utilizando anotaciones como @EnableWebSecurity junto con clases de configuración que extienden WebSecurityConfigurerAdapter (obsoleto, ahora se prefieren los componentes que implementan SecurityFilterChain).

Las medidas de seguridad comunes incluyen: autenticación para verificar la identidad del usuario, autorización para controlar el acceso basado en roles/permisos, protección contra vulnerabilidades web comunes (CSRF, XSS) y gestión de sesiones. Spring Security se integra perfectamente con varios proveedores de autenticación (por ejemplo, LDAP, OAuth, autenticación de base de datos) y mecanismos de autorización (por ejemplo, control de acceso basado en roles, control de acceso basado en expresiones). Por ejemplo, puede definir reglas de seguridad en su configuración como:

@Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http .authorizeHttpRequests((authz) -> authz .requestMatchers("/admin/").hasRole("ADMIN") .requestMatchers("/user/").hasRole("USER") .anyRequest().permitAll() ) .formLogin(withDefaults()); return http.build(); }

19. ¿Cómo se agrega el registro a una aplicación Spring Boot?

Para agregar registro a una aplicación Spring Boot, puedes aprovechar la configuración de registro predeterminada de Spring Boot, que utiliza Logback. Puedes agregar dependencias como spring-boot-starter-logging, pero normalmente ya está incluida.

Para utilizar el registro, simplemente inyectas una instancia de Logger en tu clase:

import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class MyClass { private static final Logger logger = LoggerFactory.getLogger(MyClass.class); public void myMethod() { logger.info("Este es un mensaje informativo"); logger.warn("Este es un mensaje de advertencia"); logger.error("Este es un mensaje de error"); } }

Puedes configurar los niveles de registro (por ejemplo, DEBUG, INFO, WARN, ERROR) en application.properties o application.yml. Por ejemplo, para establecer el nivel de registro raíz en DEBUG:

logging.level.root=DEBUG

También puedes configurar el registro para paquetes específicos:

logging.level.com.example.myapp=DEBUG

20. ¿Qué son los Spring Boot Actuators y qué tipo de información proporcionan?

Los Spring Boot Actuators son subproyectos dentro de Spring Boot que proporcionan funciones listas para la producción para monitorear y administrar tu aplicación. Exponen información operativa sobre la aplicación en ejecución a través de endpoints HTTP o JMX.

Los Actuators proporcionan una variedad de información, incluyendo:

• Salud de la aplicación: Muestra el estado general de la salud de la aplicación.
• Métricas: Proporciona métricas detalladas sobre el rendimiento de la aplicación (por ejemplo, uso de memoria, uso de CPU, conteos de solicitudes).
• Información: Muestra la información de la aplicación, como los detalles de la compilación, el ID de confirmación de Git, etc.
• Auditoría: Registra eventos como intentos de autenticación y acceso a recursos seguros.
• Configuración: Muestra las propiedades de configuración de la aplicación.
• Beans: Proporciona una lista de todos los beans de Spring en el contexto de la aplicación.
• Entorno: Muestra las propiedades del entorno de la aplicación.
• Volcado de hilos: Muestra una instantánea de todos los hilos en la JVM.
• Trazas HTTP: Muestra los intercambios recientes de solicitud-respuesta HTTP.

21. ¿Cómo se puede probar una aplicación Spring Boot?

Probar una aplicación Spring Boot implica varios enfoques, centrándose en diferentes capas de la aplicación. Las pruebas unitarias verifican componentes individuales (por ejemplo, servicios, repositorios) de forma aislada, utilizando marcos de mocking como Mockito para simular dependencias. Las pruebas de integración, a menudo usando @SpringBootTest, prueban la interacción entre múltiples componentes o capas dentro del contexto de la aplicación. Podrían involucrar una base de datos real o una base de datos embebida como H2.

Las pruebas de extremo a extremo validan todo el flujo de la aplicación, simulando interacciones reales del usuario, comúnmente a través de API REST. Herramientas como RestTemplate o WebTestClient (para aplicaciones reactivas) se utilizan para realizar solicitudes HTTP. Las pruebas de secciones con anotaciones como @WebMvcTest o @DataJpaTest también proporcionan pruebas enfocadas de partes específicas de la aplicación. MockMvc se puede usar en WebMvcTest para probar controladores.

22. Si tiene una aplicación Spring Boot que necesita interactuar con API externas, ¿cómo abordaría eso?

Para interactuar con APIs externas en una aplicación Spring Boot, normalmente usaría RestTemplate o WebClient (de Spring WebFlux) para realizar peticiones HTTP. RestTemplate es más simple para operaciones síncronas y bloqueantes, mientras que WebClient ofrece un enfoque reactivo y no bloqueante que puede ser beneficioso para el rendimiento, especialmente bajo alta carga. Crearía una clase de la capa de servicio para encapsular la lógica de interacción con la API, manejar el mapeo de solicitud/respuesta (usando Jackson o similar), el manejo de errores (por ejemplo, usando bloques try-catch y manejo de excepciones personalizadas), y potencialmente implementar mecanismos de reintento o interruptores de circuito (usando bibliotecas como Resilience4j o Spring Retry) para la resiliencia. Las consideraciones de seguridad, como el manejo de claves de API o tokens de autenticación, también se abordarían en esta capa, potencialmente almacenando datos sensibles de forma segura utilizando Spring Cloud Config o una solución similar.

Por ejemplo, usando RestTemplate:

@Service public class ApiService { @Autowired private RestTemplate restTemplate; public String getDataFromApi(String apiUrl) { try { return restTemplate.getForObject(apiUrl, String.class); } catch (RestClientException e) { // Handle exception return null; } } }

Preguntas de entrevista de Spring Boot para principiantes

1. ¿Qué es Spring Boot y por qué lo usan los desarrolladores?

Spring Boot es un framework que simplifica el desarrollo de aplicaciones basadas en Spring. Elimina gran parte de la configuración estándar tradicionalmente asociada con Spring, lo que hace que sea más rápido y fácil comenzar.

Los desarrolladores usan Spring Boot por varias razones:

• Configuración Reducida: La autoconfiguración configura automáticamente tu aplicación basándose en las dependencias, eliminando la necesidad de configuraciones XML verbosas.
• Servidores Empotrados: Spring Boot incluye servidores empotrados como Tomcat, Jetty, o Undertow, por lo que no necesitas configurarlos por separado.
• Gestión de Dependencias Simplificada: Proporciona una gestión de dependencias con opinión, agilizando las declaraciones de dependencias y reduciendo los conflictos de versiones. El spring-boot-starter-web, por ejemplo, añade todas las dependencias necesarias para crear una aplicación web.
• Actuator: Proporciona características listas para la producción como comprobaciones de estado, métricas y auditoría, listas para usar.
• Desarrollo Rápido: Acelera significativamente los ciclos de desarrollo, permitiendo a los desarrolladores concentrarse en la lógica de negocio en lugar de en las preocupaciones de infraestructura.

2. ¿Puedes explicar el concepto de 'autoconfiguración' en Spring Boot?

La autoconfiguración en Spring Boot es un mecanismo que configura automáticamente tu aplicación Spring basándose en las dependencias presentes en tu classpath. Spring Boot examina las dependencias que has añadido a tu proyecto (por ejemplo, controladores de bases de datos, bibliotecas de servidores web) y, basándose en ellas, configura automáticamente los beans y ajustes necesarios para que tu aplicación se ponga en marcha rápidamente. Esencialmente, elimina la configuración estándar que normalmente tendrías que escribir manualmente.

Por ejemplo, si incluye la dependencia spring-boot-starter-web, Spring Boot configura automáticamente un DispatcherServlet, un servidor Tomcat incorporado (de forma predeterminada) y otros componentes relacionados con la web. De manera similar, si agrega un controlador de base de datos como mysql-connector-java, Spring Boot intentará configurar un DataSource y un JdbcTemplate, siempre que también haya configurado las propiedades de conexión de la base de datos (como spring.datasource.url, spring.datasource.username y spring.datasource.password) en su archivo application.properties o application.yml. Puede excluir configuraciones automáticas específicas si es necesario utilizando la anotación @EnableAutoConfiguration y su atributo exclude o estableciendo spring.autoconfigure.exclude en las propiedades de su aplicación.

3. ¿Qué son los starters de Spring Boot y cómo simplifican la configuración del proyecto?

Los starters de Spring Boot son un conjunto de descriptores de dependencia convenientes que puede incluir en su aplicación. Proporcionan una forma optimizada de agregar todas las dependencias necesarias para una funcionalidad específica, sin tener que buscar y agregar manualmente cada dependencia individual.

Simplifican la configuración del proyecto al:

• Reducción de la gestión de dependencias: Los starters agrupan las dependencias relacionadas, minimizando el riesgo de conflictos de versiones y garantizando la compatibilidad.
• Autoconfiguración: Los starters activan la función de autoconfiguración de Spring Boot, configurando automáticamente los beans en función de las dependencias presentes. Por ejemplo, agregar spring-boot-starter-web configura automáticamente Spring MVC, Tomcat embebido, etc. No es necesario declararlos explícitamente.
• Productividad mejorada para desarrolladores: Los desarrolladores pueden agregar funcionalidades rápidamente sin perder tiempo en la gestión de dependencias, acelerando el proceso de desarrollo. Un starter común es spring-boot-starter-data-jpa que simplifica el acceso a la base de datos. Con este starter, se agregan todas las dependencias necesarias. Simplemente puede agregar el starter como dependencia al pom.xml/build.gradle:

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency>

4. ¿Cómo crearías un punto final de API REST simple usando Spring Boot?

Para crear un punto final de API REST simple usando Spring Boot, normalmente comenzarías creando un proyecto Spring Boot y luego definirías una clase de controlador. Dentro del controlador, usarías anotaciones como @RestController para indicar que es un controlador REST y @RequestMapping para mapear las solicitudes HTTP entrantes a métodos específicos.

Por ejemplo:

@RestController @RequestMapping("/api") public class MyController { @GetMapping("/hello") public String hello() { return "¡Hola mundo!"; } }

En este ejemplo, una solicitud GET a /api/hello devolvería la cadena "¡Hola, mundo!". Se pueden usar otras anotaciones como @PostMapping, @PutMapping y @DeleteMapping para diferentes métodos HTTP. Spring Boot simplifica la gestión de dependencias y la configuración del servidor, lo que hace que el proceso sea sencillo.

5. ¿Cuál es el propósito de la anotación `@SpringBootApplication`?

La anotación @SpringBootApplication es una anotación de conveniencia que agrupa otras tres anotaciones:

• @Configuration: Marca la clase como una fuente de definiciones de bean para el contexto de la aplicación.
• @EnableAutoConfiguration: Habilita el mecanismo de autoconfiguración de Spring Boot. Esto intenta configurar automáticamente su aplicación Spring en función de las dependencias que ha agregado a través de Maven o Gradle.
• @ComponentScan: Indica a Spring que busque otros componentes, configuraciones y servicios en el mismo paquete (y subpaquetes) que la clase anotada. Aquí es donde se descubren los componentes anotados con @Component, @Service, @Repository y @Controller.

6. Explique qué es la inyección de dependencias y cómo Spring Boot ayuda a lograrlo.

La Inyección de Dependencias (DI) es un patrón de diseño donde una clase recibe sus dependencias de fuentes externas en lugar de crearlas por sí misma. Esto promueve el acoplamiento débil y facilita las pruebas. En lugar de que una clase cree sus dependencias con new, estas se "inyectan" en la clase, generalmente a través de su constructor, métodos setter o campos.

Spring Boot simplifica la DI a través de su contenedor de Inversión de Control (IoC), también conocido como Contexto de la Aplicación Spring. Spring gestiona la creación y conexión de beans (objetos gestionados por Spring). Usa anotaciones como @Autowired para declarar dependencias, y Spring las resuelve e inyecta automáticamente. Esto reduce el código repetitivo y la configuración en comparación con los enfoques tradicionales. Por ejemplo:

@Service public class MyService { @Autowired private MyRepository myRepository; // ... }

En este caso, Spring inyectará automáticamente una instancia de MyRepository en MyService.

7. ¿Qué es un servidor embebido en Spring Boot? ¿Por qué es útil?

Un servidor embebido en Spring Boot es un servidor web que se incluye directamente en el artefacto desplegable de su aplicación (típicamente un archivo JAR). Ejemplos comunes incluyen Tomcat, Jetty y Undertow. En lugar de desplegar su aplicación en un servidor web externo preexistente, el servidor se ejecuta dentro de su propia aplicación.

Los servidores embebidos son útiles porque simplifican el despliegue y reducen la sobrecarga de configuración. No es necesario instalar y configurar un servidor web por separado. Spring Boot se encarga de la configuración del servidor, lo que hace que su aplicación sea autocontenida y fácilmente portable. Este enfoque es particularmente beneficioso para microservicios y aplicaciones nativas de la nube.

8. ¿Cómo se pueden configurar diferentes entornos (dev, prod) en Spring Boot?

Spring Boot ofrece varias formas de configurar diferentes entornos (dev, prod):

• Usando application-{profile}.properties o application-{profile}.yml: Creas archivos de configuración específicos del entorno (por ejemplo, application-dev.properties, application-prod.yml). Spring Boot carga automáticamente la configuración según el perfil activo.
• Estableciendo la propiedad spring.profiles.active: Esta propiedad especifica qué perfil(es) activar. Puedes establecerla en application.properties, como una propiedad del sistema o como una variable de entorno. Por ejemplo, establecer spring.profiles.active=dev activa la configuración application-dev.properties.
• Usando variables de entorno: Define configuraciones específicas del entorno como variables de entorno del sistema operativo y accede a ellas en tu aplicación Spring Boot. Esto es particularmente útil para entornos de producción.
• Argumentos de línea de comandos: Puedes pasar información del perfil a través de argumentos de línea de comandos al iniciar la aplicación, como --spring.profiles.active=prod.
• Usando la anotación @Profile: Anota clases @Component, @Service, @Repository y @Configuration con @Profile("dev") o @Profile("prod") para incluirlas o excluirlas según el perfil activo.

9. ¿Cuáles son algunas anotaciones comunes de Spring Boot que has usado?

Algunas anotaciones comunes de Spring Boot que he usado incluyen:

• @SpringBootApplication: Esta es la anotación principal que combina @Configuration, @EnableAutoConfiguration y @ComponentScan. Se utiliza para iniciar la aplicación.
• @RestController: Marca una clase como un controlador donde cada método devuelve un objeto de dominio en lugar de una vista. Combina @Controller y @ResponseBody.
• @RequestMapping: Se utiliza para mapear las solicitudes web a métodos de manejo específicos. Se puede usar a nivel de clase para mapear una URL base y a nivel de método para mapear puntos finales específicos.
• @Autowired: Se utiliza para la inyección de dependencias. Permite a Spring resolver e inyectar automáticamente las dependencias.
• @Service: Marca una clase como un proveedor de servicios (capa de lógica de negocio).
• @Repository: Indica que una clase es un repositorio de datos (capa de acceso a datos).
• @Component: Una anotación de estereotipo genérica que indica que una clase es un componente. Sirve como base para @Service, @Repository y @Controller.
• @Configuration: Indica que una clase declara uno o más métodos @Bean.
• @Bean: Anota un método que produce un bean para ser gestionado por el contenedor Spring.
• @Value: Se utiliza para inyectar valores de archivos de propiedades o variables de entorno en campos.
• @PathVariable: Extrae valores de la ruta URI.
• @RequestParam: Extrae valores de los parámetros de la cadena de consulta.

A menudo uso estos en conjunto. Por ejemplo, un @RestController podría usar @Autowired para inyectar un @Service, que a su vez usa @Autowired para inyectar un @Repository.

10. ¿Cómo se manejan las excepciones en una aplicación Spring Boot?

En Spring Boot, las excepciones se pueden manejar utilizando varios mecanismos. @ControllerAdvice junto con las anotaciones @ExceptionHandler se utilizan comúnmente para crear manejadores de excepciones globales. Esto permite centralizar la lógica de manejo de excepciones para excepciones específicas o tipos de excepciones en toda su aplicación. Puede definir métodos dentro de una clase @ControllerAdvice para manejar diferentes excepciones y devolver códigos de estado HTTP y mensajes de error apropiados al cliente.

Alternativamente, puede manejar excepciones localmente dentro de un controlador específico usando @ExceptionHandler dentro de ese controlador. Además, para las API REST, podría usar ResponseEntity para devolver respuestas de error personalizadas con códigos de estado HTTP y detalles de error específicos. Finalmente, Spring Boot proporciona un mecanismo de manejo de errores predeterminado que muestra una página de error genérica o una respuesta JSON si ocurre una excepción no manejada. Puede personalizar este comportamiento predeterminado proporcionando su propia vista de error o controlador de errores.

11. ¿Cuál es el propósito del archivo application.properties o application.yml?

El archivo application.properties o application.yml en una aplicación Spring Boot se utiliza para configurar el comportamiento de la aplicación. Define varias propiedades relacionadas con el entorno de la aplicación, las fuentes de datos, el registro, las configuraciones del servidor y las integraciones de bibliotecas de terceros.

Estos archivos permiten a los desarrolladores externalizar la configuración, lo que facilita la gestión de diferentes configuraciones para diferentes entornos (por ejemplo, desarrollo, pruebas, producción) sin modificar el código de la aplicación. application.yml utiliza YAML, un formato de serialización de datos legible por humanos, mientras que application.properties utiliza pares clave-valor. Spring Boot carga automáticamente las propiedades de estos archivos al inicio.

12. Explique cómo conectarse a una base de datos utilizando Spring Boot.

Spring Boot simplifica las conexiones a bases de datos utilizando spring-boot-starter-data-jpa (para JPA) o spring-boot-starter-jdbc (para JDBC). Incluya la dependencia adecuada en su pom.xml o build.gradle.

A continuación, configure las propiedades de conexión a la base de datos en application.properties o application.yml. Esto normalmente incluye spring.datasource.url, spring.datasource.username y spring.datasource.password. Spring Boot configura automáticamente un DataSource basado en estas propiedades. Por ejemplo:

spring.datasource.url=jdbc:mysql://localhost:3306/mydb spring.datasource.username=user spring.datasource.password=password

Para JPA, define entidades con @Entity y utiliza repositorios Spring Data JPA (interfaces que extienden JpaRepository) para interactuar con la base de datos. Para JDBC, puedes usar JdbcTemplate para ejecutar consultas SQL.

13. ¿Qué es Spring Data JPA? ¿Cómo simplifica las operaciones de base de datos?

Spring Data JPA es un módulo de Spring que simplifica el trabajo con bases de datos utilizando la API de Persistencia Java (JPA). Proporciona una abstracción de repositorio, generando automáticamente métodos comunes de acceso a datos (operaciones CRUD) basados en definiciones de interfaz. Esto reduce significativamente el código repetitivo típicamente requerido para las interacciones con la base de datos.

Simplifica las operaciones de base de datos al:

• Reducir el código repetitivo: Elimina la necesidad de escribir código repetitivo para operaciones comunes de base de datos.
• Abstracción de repositorio: Proporciona una interfaz consistente y fácil de usar para el acceso a datos.
• Derivación de consultas: Genera automáticamente consultas basadas en los nombres de los métodos.
• Integración con Spring: Se integra perfectamente con otros módulos de Spring.
• Anotación @Repository: Marca una interfaz como un repositorio para el acceso a datos. Spring proporciona la implementación.
• Proporciona interfaces preconstruidas como JpaRepository, que ofrecen métodos estándar como save(), findById(), findAll(), deleteById(), etc.

14. ¿Cómo se prueba una aplicación Spring Boot? ¿Qué tipos de pruebas se pueden escribir?

Probar una aplicación Spring Boot implica varios enfoques. Principalmente, nos centramos en pruebas unitarias, de integración y de extremo a extremo.

• Pruebas unitarias: Estas verifican componentes individuales (por ejemplo, un servicio o un método de controlador) de forma aislada. Es común simular dependencias usando frameworks como Mockito. Ejemplo: @Test public void myServiceTest() { ... }
• Pruebas de integración: Estas confirman que diferentes partes de la aplicación funcionan juntas correctamente. Podrían implicar probar la interacción entre un servicio y una base de datos. Spring proporciona soporte para pruebas de integración con @SpringBootTest y pruebas de segmentos usando anotaciones como @DataJpaTest, @WebMvcTest.
• Pruebas de extremo a extremo (E2E): Estas validan el flujo completo de la aplicación, simulando interacciones del usuario. A menudo se utilizan herramientas como Selenium, Cypress o Playwright. Estas generalmente implican pruebas a través de la interfaz de usuario y potencialmente acceder a servicios externos. Estas pruebas son más completas y generalmente más lentas de ejecutar que las pruebas unitarias o de integración.

15. ¿Cuáles son algunas ventajas de usar Spring Boot sobre Spring tradicional?

Spring Boot simplifica el desarrollo en comparación con Spring tradicional al proporcionar autoconfiguración, que configura automáticamente su aplicación en función de las dependencias que haya agregado. Esto reduce la cantidad de código repetitivo y la configuración XML requerida. También ofrece servidores integrados (como Tomcat, Jetty o Undertow), lo que facilita la implementación, ya que puede crear archivos JAR ejecutables y autónomos.

Las ventajas clave incluyen:

• Configuración reducida: la autoconfiguración minimiza la configuración manual.
• Servidores integrados: simplifica la implementación.
• Starters: la gestión de dependencias se agiliza mediante el uso de POM de inicio, por ejemplo: spring-boot-starter-web proporciona todas las dependencias necesarias para el desarrollo web.
• Actuator: proporciona puntos finales de monitoreo y administración.

16. ¿Cómo puede agregar dependencias personalizadas a su proyecto Spring Boot?

Puede agregar dependencias personalizadas a su proyecto Spring Boot principalmente usando Maven o Gradle. Para Maven, agregaría un bloque <dependency> dentro de la sección <dependencies> de su archivo pom.xml. Este bloque especifica el groupId, artifactId y version de la dependencia. Por ejemplo:

<dependency> <groupId>com.example</groupId> <artifactId>my-custom-library</artifactId> <version>1.0.0</version> </dependency>

Para Gradle, agregaría la dependencia al bloque dependencies en su archivo build.gradle usando la palabra clave implementation o api. Por ejemplo:

dependencies { implementation 'com.example:my-custom-library:1.0.0' }

La gestión de dependencias de Spring Boot se encargará entonces de la resolución y la inclusión de estas dependencias en su proyecto. Después de agregar las dependencias, asegúrese de reconstruir su proyecto para descargarlas e incluirlas.

17. ¿Cuál es el papel de un archivo `pom.xml` en un proyecto Spring Boot?

El archivo pom.xml es el archivo del Modelo de Objeto del Proyecto, el núcleo de los proyectos Maven, incluidos los proyectos Spring Boot. Contiene información sobre el proyecto, sus dependencias y cómo construirlo. Fundamentalmente, gestiona las dependencias, los plugins, las configuraciones de construcción y los metadatos del proyecto.

Específicamente, este:

• Define las dependencias: Enumera todas las bibliotecas externas (como los starters de Spring Boot) requeridas por el proyecto.
• Gestiona las versiones: Especifica la versión exacta de cada dependencia, evitando conflictos.
• Configura el proceso de construcción: Define plugins para compilar código, ejecutar pruebas, empaquetar la aplicación (por ejemplo, en un archivo JAR o WAR).
• Proporciona metadatos del proyecto: Incluye el nombre del proyecto, la versión, el ID del grupo y otra información descriptiva. La etiqueta parent se usa a menudo para heredar la configuración del POM principal de Spring Boot, simplificando la gestión de dependencias.

Ejemplo:

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>

18. Explica el concepto de Spring Beans y cómo se gestionan en Spring Boot.

Los Spring Beans son los componentes centrales de una aplicación Spring. Esencialmente, un Spring Bean es cualquier objeto Java que está gestionado por el contenedor de IoC (Inversión de Control) de Spring. El contenedor es responsable de instanciar, configurar y ensamblar estos beans. Piense en ellos como bloques de construcción que Spring utiliza.

En Spring Boot, la gestión de beans está en gran medida automatizada a través de características como el escaneo de componentes y la autoconfiguración. Spring Boot detecta automáticamente las clases anotadas con @Component, @Service, @Repository y @Controller (que son especializaciones de @Component) y las registra como beans. Además, puedes usar la anotación @Bean dentro de las clases @Configuration para definir y configurar beans explícitamente. El contenedor Spring gestiona el ciclo de vida de estos beans, manejando la inyección de dependencias (DI) para conectarlos, asegurando un acoplamiento débil y modularidad.

19. ¿Cómo asegurarías un endpoint de API de Spring Boot?

Asegurar un endpoint de API de Spring Boot normalmente implica el uso de Spring Security. El enfoque principal es agregar la dependencia spring-boot-starter-security a tu proyecto. La configuración se puede hacer entonces en una clase anotada con @Configuration y @EnableWebSecurity. Esto te permite definir reglas de autenticación y autorización. Por ejemplo, puedes configurar qué endpoints requieren autenticación usando el método authorizeHttpRequests() de HttpSecurity para especificar patrones de URL y reglas de acceso, como permitAll(), authenticated(), hasRole('ADMIN'), etc. Por ejemplo:

@Configuration @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { http.authorizeHttpRequests() .antMatchers("/public/").permitAll() .antMatchers("/admin/").hasRole("ADMIN") .anyRequest().authenticated() .and() .formLogin(); // O otros mecanismos de autenticación como OAuth2, JWT, etc. } }

Este ejemplo demuestra una configuración básica. Métodos más sofisticados implican la integración con OAuth 2.0, JWT (JSON Web Tokens), LDAP o la definición de mecanismos de autenticación personalizados mediante la implementación de UserDetailsService y PasswordEncoder. La validación y saneamiento adecuados de los parámetros de solicitud también son cruciales.

20. ¿Qué son los Spring Boot Actuators? ¿Qué tipo de información exponen?

Los Spring Boot Actuators son submódulos que proporcionan capacidades de monitoreo y gestión a las aplicaciones Spring Boot. Exponen información operativa sobre la aplicación, como su estado de salud, métricas, información, volcado, entorno, beans, etc. Esencialmente, los actuadores proporcionan puntos finales que le permiten monitorear e interactuar con su aplicación en tiempo de ejecución.

Los actuadores exponen varios puntos finales que proporcionan información específica. Los puntos finales comunes incluyen:

• /health: Muestra el estado de salud de la aplicación (up, down, etc.).
• /metrics: Expone varias métricas de la aplicación, como el uso de memoria, el uso de CPU y la latencia de las solicitudes.
• /info: Muestra información general sobre la aplicación.
• /env: Expone las propiedades del entorno de la aplicación.
• /beans: Muestra una lista de todos los beans de Spring en el contexto de la aplicación.
• /loggers: Muestra y modifica la configuración de los registradores en la aplicación.

21. ¿Cómo se maneja el registro en una aplicación Spring Boot?

En Spring Boot, el registro se maneja típicamente utilizando un framework de registro como Logback (predeterminado) o Log4j2. Spring Boot proporciona valores predeterminados sensatos, por lo que el registro básico funciona de inmediato. Para registrar, inyecta una instancia Logger en tu clase usando @Slf4j (de Lombok) o manualmente a través de LoggerFactory.getLogger(YourClass.class). Luego, usa métodos como logger.info(), logger.warn(), logger.error(), logger.debug() y logger.trace() para registrar información en diferentes niveles de severidad.

La configuración generalmente se realiza en application.properties o application.yml. Por ejemplo, puede establecer el nivel de registro para un paquete específico de la siguiente manera: logging.level.com.example=DEBUG. También puede personalizar el formato de salida del registro y los anexos (por ejemplo, para escribir registros en un archivo) creando un archivo logback-spring.xml o log4j2-spring.xml en su directorio src/main/resources. Estos archivos le permiten definir anexos para escribir en archivos, consolas u otros destinos. También puede especificar codificadores para formatear los mensajes de registro. Por ejemplo, así es como podría registrar en un archivo:

<appender name="FILE" class="ch.qos.logback.core.FileAppender"> <file>application.log</file> <encoder> <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern> </encoder> </appender> <root level="info"> <appender-ref ref="FILE" /> </root>

22. ¿Qué es una cola de mensajes y cómo podría usarla en una aplicación Spring Boot?

Una cola de mensajes es una forma de comunicación asíncrona que permite que los servicios se comuniquen entre sí sin necesidad de conocerse. Los mensajes se almacenan en la cola hasta que se procesan, lo que mejora la confiabilidad y la escalabilidad.

En una aplicación Spring Boot, podrías usar una cola de mensajes como RabbitMQ o Apache Kafka para desacoplar servicios. Por ejemplo, una aplicación de comercio electrónico podría usar una cola de mensajes para manejar el procesamiento de pedidos. Cuando un usuario realiza un pedido, los detalles del pedido se envían a la cola de mensajes. Un servicio de procesamiento de pedidos separado consume entonces estos mensajes de la cola y procesa los pedidos de forma asíncrona. Spring proporciona un excelente soporte para colas de mensajes a través de Spring AMQP y Spring Kafka. La anotación @RabbitListener se puede usar para definir fácilmente los oyentes de mensajes en las aplicaciones Spring Boot que usan RabbitMQ.

Por ejemplo:

@RabbitListener(queues = "orderQueue") public void processOrder(Order order) { // Procesar el pedido }

23. Si tuvieras un punto final de API de ejecución lenta, ¿cómo lo solucionarías utilizando las herramientas de Spring Boot?

Para solucionar problemas de un punto final de API de ejecución lenta en Spring Boot, comenzaría habilitando Spring Boot Actuator y su punto final de métricas. Esto proporciona información sobre varios indicadores de rendimiento, como el número de solicitudes, los tiempos de respuesta promedio y el uso de memoria de la JVM. Específicamente, miraría métricas como http.server.requests para identificar los puntos finales lentos y sus tiempos de respuesta. También habilitaría el seguimiento de Micrometer para rastrear las solicitudes de extremo a extremo, buscando consultas lentas de bases de datos o llamadas a servicios externos.

Luego, utilizaría las capacidades de registro integradas de Spring. Al configurar el nivel de registro en DEBUG o TRACE para los componentes relevantes (por ejemplo, controladores, servicios, repositorios), puedo obtener información detallada sobre los tiempos de ejecución de los métodos y los valores de los parámetros. Usaría un perfilador (como VisualVM o JProfiler) para identificar puntos críticos en el código. Esto me permite identificar los métodos o secciones de código que consumen más recursos. Además, verificaría las dependencias externas para descartar las razones externas de la lentitud.

24. ¿Cómo implementaría una aplicación Spring Boot en un entorno en la nube?

Para implementar una aplicación Spring Boot en un entorno en la nube, normalmente seguiría estos pasos. Primero, empaquetaría la aplicación como un archivo JAR o WAR utilizando Maven o Gradle. Luego, dependiendo del proveedor de la nube, elegiría una opción de implementación adecuada. Por ejemplo:

• AWS: Implementar en Elastic Beanstalk, EC2, ECS o EKS. Utilizar imágenes de Docker e implementar a través de servicios de orquestación de contenedores como ECS/EKS para mayor control.
• Azure: Implementar en Azure App Service, Azure VMs o Azure Kubernetes Service (AKS). Similar a AWS, las imágenes de Docker y la orquestación de contenedores son opciones.
• Google Cloud Platform (GCP): Implementar en Google App Engine, Compute Engine o Google Kubernetes Engine (GKE). Utilizar Docker y GKE para implementaciones escalables.

También configuraría pipelines de CI/CD (por ejemplo, Jenkins, GitLab CI, GitHub Actions) para automatizar el proceso de construcción, prueba e implementación. Consideraciones importantes incluyen la configuración adecuada de registros, monitoreo y estrategias de escalado basadas en los requisitos de la aplicación. Las herramientas de infraestructura como código (Terraform, CloudFormation) se usarían para administrar los recursos en la nube de manera repetible y automatizada.

25. ¿Cuál es la diferencia entre `@RestController` y `@Controller` en Spring Boot?

En Spring Boot, tanto @Controller como @RestController se utilizan para manejar solicitudes web, pero difieren en su comportamiento predeterminado con respecto a cómo se manejan las respuestas.

@Controller es una anotación de propósito general. Cuando un método en un @Controller maneja una solicitud, normalmente devuelve el nombre de una vista para ser renderizada (por ejemplo, una página HTML). A menudo usarías @ResponseBody en conjunto con métodos @Controller si deseas serializar el objeto devuelto en el cuerpo de la respuesta (como JSON o XML). @RestController es una anotación de conveniencia que combina @Controller y @ResponseBody. Esencialmente, un @RestController indica que cada método en el controlador serializará el valor de retorno directamente en el cuerpo de la respuesta, a menudo como JSON o XML. Es adecuado para construir API RESTful. Por lo tanto, usar @RestController evita la necesidad de agregar @ResponseBody a cada método del manejador.

26. Explique cómo Spring Boot simplifica la creación de microservicios.

Spring Boot simplifica la creación de microservicios al proporcionar varias características clave que agilizan el desarrollo y la implementación. Ofrece la configuración automática, que configura automáticamente su aplicación en función de las dependencias presentes en su proyecto. Esto reduce el código estándar y la sobrecarga de configuración. Los servidores integrados (como Tomcat, Jetty o Undertow) eliminan la necesidad de la implementación de un servidor de aplicaciones externo, lo que facilita el empaquetado e implementación de microservicios como ejecutables independientes (JAR).

Además, Spring Boot se integra bien con Spring Cloud, ofreciendo herramientas para el descubrimiento de servicios (por ejemplo, Eureka), la gestión de la configuración (por ejemplo, Spring Cloud Config) y las pasarelas API (por ejemplo, Zuul o Spring Cloud Gateway). Estos componentes son cruciales para construir arquitecturas de microservicios resilientes y escalables. Sus dependencias iniciales proporcionan conjuntos de bibliotecas preconfiguradas para tareas comunes como el desarrollo web, el acceso a datos y la seguridad, acelerando en gran medida el proceso de desarrollo. Por ejemplo: spring-boot-starter-web agregará dependencias para construir aplicaciones web con Spring MVC. Finalmente, actuator proporciona puntos finales de monitoreo y gestión para sus microservicios.

27. ¿Cómo simplifica Spring Boot el proceso de creación de tareas programadas?

Spring Boot simplifica la creación de tareas programadas principalmente a través de su anotación @EnableScheduling y la anotación @Scheduled. @EnableScheduling habilita la capacidad de ejecución de tareas programadas de Spring. Luego, puede anotar métodos con @Scheduled para definir su programación de ejecución.

Por ejemplo:

@Configuration @EnableScheduling public class SchedulingConfig { @Scheduled(fixedRate = 5000) // Se ejecuta cada 5 segundos public void doSomething() { // Lógica de la tarea aquí System.out.println("Tarea ejecutada"); } }

Spring Boot abstrae las complejidades de la configuración de ejecutores de tareas y programadores, lo que facilita la definición y gestión de tareas programadas con una configuración mínima. Puede controlar la ejecución usando fixedRate, fixedDelay o expresiones cron.

Preguntas de entrevista intermedias de Spring Boot

1. ¿Cómo maneja Spring Boot la autoconfiguración y cuáles son algunas formas de personalizarla o deshabilitarla?

La autoconfiguración de Spring Boot configura automáticamente su aplicación en función de las dependencias presentes en su classpath. Examina el classpath en busca de bibliotecas y beans específicos, y luego configura los beans que anticipa que su aplicación necesitará. Esto se logra principalmente utilizando @EnableAutoConfiguration, @Configuration, @ConditionalOnClass, @ConditionalOnMissingBean y spring.factories.

Para personalizar o deshabilitar la autoconfiguración, puede utilizar varios enfoques:

• Excluir configuraciones automáticas específicas: Usa el atributo exclude de @EnableAutoConfiguration o @SpringBootApplication. Por ejemplo: @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
• Excluir por nombre: Usa el atributo excludeName, especificando el nombre completo de la clase de configuración automática.
• Exclusión condicional: Usa @ConditionalOnMissingBean para evitar que una configuración automática surta efecto si un bean de un tipo específico ya existe. Esto te permite proporcionar tu propia configuración que tenga precedencia.
• Propiedad spring.autoconfigure.exclude: En application.properties o application.yml, enumera las configuraciones automáticas a excluir: spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
• Crea tus propias configuraciones automáticas: Puedes crear tus propias configuraciones automáticas para anular o complementar las predeterminadas. Asegúrate de que tus configuraciones personalizadas tengan una precedencia más alta. Asegúrate de que se coloquen dentro de un paquete para que Spring las escanee.

2. Explica el módulo Actuator de Spring Boot y sus beneficios para monitorear y gestionar aplicaciones.

Actuator de Spring Boot proporciona características listas para la producción para monitorear y gestionar su aplicación. Expone endpoints que ofrecen información sobre la salud de la aplicación, métricas, configuración y más. Se puede acceder a estos endpoints a través de HTTP o JMX.

Los beneficios incluyen:

• Monitoreo: Proporciona estado de salud, métricas (uso de memoria, conteos de solicitudes HTTP, etc.) e información de la aplicación.
• Gestión: Permite la gestión y configuración remotas de la aplicación.
• Auditoría: Permite el seguimiento de eventos de la aplicación y la actividad del usuario.
• Seguridad: Endpoints seguros con autenticación y autorización.
• Personalización: Extensible para agregar métricas e indicadores de salud personalizados. Por ejemplo, el endpoint /health proporciona información sobre la salud de la aplicación y el endpoint /metrics muestra varias métricas. Puede usar management.endpoints.web.exposure.include=* para exponer todos los endpoints (no recomendado para producción) o management.endpoints.web.exposure.include=health,info para exponer solo los endpoints de salud e información.

3. Describe cómo implementaría el manejo de excepciones en una API REST de Spring Boot, incluyendo el manejo global de excepciones.

En una API REST de Spring Boot, implementaría el manejo de excepciones utilizando una combinación de anotaciones @ExceptionHandler y @ControllerAdvice para el manejo global. Para excepciones específicas dentro de un controlador, usaría métodos @ExceptionHandler dentro de ese controlador. Estos métodos están anotados para manejar tipos de excepción específicos y devolver un ResponseEntity personalizado con un mensaje de error y un código de estado apropiados.

Para el manejo global de excepciones, crearía una clase anotada con @ControllerAdvice. Dentro de esta clase, definiría métodos @ExceptionHandler para manejar las excepciones que pueden ocurrir en toda la aplicación. Esto me permite centralizar la lógica de manejo de errores, asegurando respuestas de error consistentes. Por ejemplo, un caso de uso común sería manejar MethodArgumentNotValidException para fallas en la validación del cuerpo de la solicitud. El @ControllerAdvice devolvería una carga útil JSON que detalla los errores de validación. Aquí hay un ejemplo del código para el manejador global:

@ControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(MethodArgumentNotValidException.class) public ResponseEntity<Object> handleValidationExceptions( MethodArgumentNotValidException ex) { //lógica aquí } }

4. ¿Qué son los Spring Boot starters y cómo simplifican la gestión de dependencias en un proyecto Spring Boot?

Los Spring Boot Starters son un conjunto de descriptores de dependencias convenientes que puede incluir en su aplicación. Cada starter es un conjunto de dependencias relacionadas con una funcionalidad específica, como el desarrollo web, el acceso a datos o la seguridad. Eliminan la necesidad de buscar dependencias en la web y copiar y pegar configuraciones.

Simplifican la gestión de dependencias al:

• Reducir el código repetitivo: Los starters extraen automáticamente todas las dependencias necesarias para una función específica, lo que reduce la cantidad de declaración manual de dependencias en su archivo pom.xml (Maven) o build.gradle (Gradle).
• Proporcionar valores predeterminados sensatos: Cada starter proporciona un conjunto de dependencias preconfiguradas que se sabe que funcionan bien juntas, eliminando los conflictos de versión.
• Facilitar la configuración del proyecto: Agregar un starter es típicamente tan simple como agregar una única dependencia a su archivo de construcción. Por ejemplo, spring-boot-starter-web agrega todas las dependencias para construir aplicaciones web, incluyendo Spring MVC, Tomcat y Jackson.

5. ¿Cómo configurarías diferentes entornos (por ejemplo, desarrollo, pruebas, producción) en una aplicación Spring Boot?

Spring Boot proporciona varias formas de configurar diferentes entornos. Un enfoque común es usar archivos application-{profile}.properties o application-{profile}.yml. Por ejemplo, application-dev.properties para el entorno de desarrollo. Especifica el perfil activo usando la propiedad spring.profiles.active, ya sea en application.properties (configuración común) o como un argumento de línea de comandos (--spring.profiles.active=dev).

Otro método implica el uso de variables de entorno o propiedades del sistema. Puedes acceder a estos dentro de tu configuración de Spring usando la anotación @Value o la interfaz Environment. Las clases de configuración anotadas con @Configuration y @Profile("dev") solo se cargarán cuando el perfil 'dev' esté activo. También puedes aprovechar Spring Cloud Config Server para la gestión centralizada de la configuración, especialmente en arquitecturas de microservicios. Usar archivos de configuración separados para diferentes entornos asegura que la configuración como URLs de base de datos, claves API y niveles de registro se adapten a cada entorno.

6. Explique cómo Spring Boot se integra con bases de datos utilizando Spring Data JPA. Incluya detalles sobre las interfaces de repositorio.

Spring Boot simplifica la integración de bases de datos con Spring Data JPA al proporcionar auto-configuración y convención sobre configuración. Configura automáticamente un DataSource, EntityManagerFactory y JpaTransactionManager basado en dependencias (como spring-boot-starter-data-jpa) y propiedades de configuración (por ejemplo, URL de la base de datos, nombre de usuario, contraseña). Spring Data JPA se enfoca en abstraer el código estándar necesario para el acceso a datos, permitiendo a los desarrolladores trabajar con repositorios.

Las interfaces de repositorio definen métodos de acceso a datos. Spring Data JPA proporciona automáticamente implementaciones para estas interfaces en tiempo de ejecución, eliminando la necesidad de escribir código DAO estándar. Métodos comunes como save(), findById(), findAll(), delete() se implementan automáticamente. Las consultas personalizadas se pueden definir utilizando convenciones de nombres de métodos (por ejemplo, findByLastName) o utilizando la anotación @Query. Por ejemplo:

public interface UserRepository extends JpaRepository<User, Long> { List<User> findByLastName(String lastName); @Query("SELECT u FROM User u WHERE u.email = ?1") User findByEmailAddress(String emailAddress); }

7. Describa el proceso de asegurar una aplicación Spring Boot con Spring Security, incluyendo autenticación y autorización.

Asegurar una aplicación Spring Boot con Spring Security implica autenticación (verificar quién es el usuario) y autorización (determinar a qué puede acceder el usuario). Primero, incluye la dependencia spring-boot-starter-security. A continuación, configura la autenticación creando una clase @Configuration que extiende WebSecurityConfigurerAdapter y sobrescribe el método configure(AuthenticationManagerBuilder auth) para definir los detalles del usuario. Esto puede usar almacenamiento en memoria, JDBC o integrarse con un proveedor de autenticación externo. Luego, la autorización se configura anulando el método configure(HttpSecurity http). Aquí, define patrones de URL y los roles requeridos para acceder a ellos utilizando .authorizeRequests(). Por ejemplo:

@Override protected void configure(HttpSecurity http) throws Exception { http .authorizeRequests() .antMatchers("/admin/").hasRole("ADMIN") .antMatchers("/user/").hasRole("USER") .antMatchers("/").permitAll() .anyRequest().authenticated() .and() .formLogin(); }

Este ejemplo requiere el rol ADMIN para /admin/**, el rol USER para /user/**, permite el acceso no autenticado a / y requiere autenticación para todas las demás solicitudes. Finalmente, considere usar la codificación de contraseñas (por ejemplo, BCryptPasswordEncoder) para almacenar de forma segura las contraseñas de los usuarios.

8. ¿Cómo implementaría el almacenamiento en caché en una aplicación Spring Boot y cuáles son algunos de los proveedores de almacenamiento en caché que puede usar?

Para implementar el almacenamiento en caché en una aplicación Spring Boot, usaría la abstracción de almacenamiento en caché de Spring. Primero, habilitaría el almacenamiento en caché usando la anotación @EnableCaching en mi clase de configuración. Luego, anotaría los métodos cuyos resultados necesitan ser almacenados en caché con las anotaciones @Cacheable, @CachePut o @CacheEvict, especificando el nombre de la caché. Por ejemplo:

@Cacheable("myCache") public String getData(String key) { // ... operación costosa return result; }

Algunos proveedores de almacenamiento en caché que podría usar incluyen:

• En memoria: Caffeine, EhCache, ConcurrentHashMap (SimpleCache de Spring)
• Distribuido: Redis, Memcached

9. Explique cómo usar el soporte de pruebas de Spring Boot para escribir pruebas unitarias e integración para su aplicación.

Spring Boot proporciona un excelente soporte de pruebas a través de la dependencia spring-boot-starter-test, que incluye JUnit, Mockito, Spring Test y otras bibliotecas útiles. Para las pruebas unitarias, concéntrese en probar componentes individuales de forma aislada. Use @MockBean para simular las dependencias de la clase bajo prueba. Por ejemplo:

@ExtendWith(SpringExtension.class) class MyServiceTest { @MockBean private MyRepository myRepository; @Autowired private MyService myService; @Test void testMyMethod() { when(myRepository.findById(1L)).thenReturn(Optional.of(new MyEntity())); // ... afirmaciones } }

Por otro lado, las pruebas de integración verifican la interacción de múltiples componentes o el contexto completo de la aplicación. Usa @SpringBootTest para cargar el contexto completo de la aplicación. Puedes usar TestRestTemplate o WebTestClient para hacer peticiones HTTP a los endpoints de tu aplicación. Para las pruebas de integración de bases de datos, considera usar una base de datos embebida como H2 o Testcontainers para evitar modificar la base de datos de producción. @DataJpaTest es útil para probar los repositorios JPA.

10. Describe cómo configurarías el registro (logging) en una aplicación Spring Boot, incluyendo la configuración de los niveles de registro y los formatos de salida.

Para configurar el registro en una aplicación Spring Boot, normalmente uso application.properties o application.yml. Puedo establecer el nivel de registro para toda la aplicación o para paquetes específicos usando propiedades como logging.level.root=INFO o logging.level.com.example=DEBUG. Spring Boot usa Logback como el framework de registro predeterminado pero también soporta otros.

Para personalizar los formatos de salida, creo un archivo logback-spring.xml en el directorio src/main/resources. Dentro de este archivo, defino appenders (por ejemplo, consola, archivo) y encoders para controlar el formato del registro. Por ejemplo, el uso de <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern> en el encoder me permite especificar el formato de fecha, el nombre del hilo, el nivel de registro, el nombre del logger y el mensaje. También puede usar appenders específicos para la rotación de archivos u otras funcionalidades.

11. ¿Cómo se puede usar Spring Boot para crear y consumir servicios web RESTful?

Spring Boot simplifica la creación y el consumo de servicios web RESTful. Para crear un servicio RESTful, puede definir una clase de controlador con la anotación @RestController. Utilice anotaciones como @GetMapping, @PostMapping, @PutMapping y @DeleteMapping para mapear las solicitudes HTTP a métodos de controlador específicos. Estos métodos pueden devolver objetos que Spring Boot serializa automáticamente en JSON o XML utilizando Jackson u otros convertidores de mensajes configurados. Por ejemplo:

@RestController public class MyController { @GetMapping("/resource/{id}") public MyResource getResource(@PathVariable Long id) { // Lógica para recuperar el recurso return new MyResource(id, "ejemplo"); } }

Para consumir un servicio RESTful, puedes usar RestTemplate o WebClient de Spring. RestTemplate proporciona métodos como getForObject(), postForObject(), put() y delete() para enviar peticiones HTTP y recuperar respuestas. WebClient es una alternativa reactiva y no bloqueante, particularmente útil para microservicios. Por ejemplo:

RestTemplate restTemplate = new RestTemplate(); MyResource resource = restTemplate.getForObject("https://example.com/resource/1", MyResource.class);

12. Explica cómo Spring Boot maneja la gestión de transacciones, y cómo puedes usar anotaciones para controlar las transacciones.

Spring Boot simplifica la gestión de transacciones al proporcionar auto-configuración e integración con varios gestores de transacciones como DataSourceTransactionManager para JDBC o JpaTransactionManager para JPA. Aprovecha la poderosa abstracción de transacciones de Spring. Podemos controlar las transacciones de forma declarativa usando anotaciones. La anotación más común es @Transactional.

Podemos aplicar @Transactional a nivel de clase o de método. Por ejemplo, marcar un método con @Transactional iniciará automáticamente una transacción antes de la ejecución del método y la confirmará al finalizar con éxito o la revertirá en caso de una excepción. Los atributos clave incluyen propagation (define cómo debe propagarse una transacción), isolation (especifica el nivel de aislamiento), timeout (establece un tiempo de espera), readOnly (optimiza las transacciones de solo lectura) y rollbackFor / noRollbackFor (define qué excepciones deben desencadenar una reversión o evitarla, respectivamente). Por ejemplo:

@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED, rollbackFor = Exception.class) public void myTransactionalMethod() { // Operaciones de base de datos aquí }

13. ¿Cuáles son algunas de las mejores prácticas para implementar una aplicación Spring Boot en un entorno de nube como AWS o Azure?

Al implementar una aplicación Spring Boot en AWS o Azure, varias prácticas recomendadas pueden garantizar una implementación fluida y confiable. Primero, containerice su aplicación usando Docker. Esto proporciona consistencia en diferentes entornos. Use una canalización CI/CD (por ejemplo, Jenkins, GitLab CI, GitHub Actions) para automatizar los procesos de compilación, prueba e implementación. Almacene la configuración de su aplicación en variables de entorno en lugar de codificarlas en la aplicación, para permitir cambios fáciles sin volver a implementarla y una mejor gestión de secretos. Utilice servicios nativos de la nube como AWS ECS/EKS o Azure Kubernetes Service (AKS) para la orquestación de contenedores.

Además, implemente registros y monitoreo robustos utilizando herramientas como Prometheus y Grafana, o servicios específicos de la nube como AWS CloudWatch o Azure Monitor, para rastrear la salud y el rendimiento de la aplicación. Emplee herramientas de infraestructura como código (IaC) como Terraform o AWS CloudFormation/Azure Resource Manager para administrar su infraestructura de manera repetible y con control de versiones. Proteja su aplicación siguiendo las mejores prácticas de seguridad en la nube, incluido el uso de roles de IAM y grupos de seguridad de red, y parcheando las vulnerabilidades regularmente. Configure correctamente las comprobaciones de estado y las sondas de preparación para que su plataforma de implementación sepa cuándo su aplicación está lista para recibir tráfico. Considere usar un equilibrador de carga para distribuir el tráfico y garantizar una alta disponibilidad.

14. ¿Cómo admite Spring Boot el procesamiento asíncrono y cómo puedes usar anotaciones como `@Async`?

Spring Boot simplifica el procesamiento asíncrono usando la anotación @EnableAsync y la anotación @Async. Primero, necesitas habilitar la ejecución de métodos asíncronos agregando @EnableAsync a la clase de configuración de tu aplicación Spring Boot. Luego, puedes anotar métodos con @Async para que se ejecuten en un hilo separado. El tipo de retorno de un método @Async debe ser void o Future<?>. Si necesitas manejar excepciones lanzadas por métodos @Async, puedes implementar AsyncUncaughtExceptionHandler y configurarlo.

Por ejemplo:

@Configuration @EnableAsync public class AsyncConfig { } @Service public class MyService { @Async public void doSomethingAsync() { // Tarea asíncrona } }

15. Describe el proceso de creación de un Spring Boot starter personalizado.

Crear un Spring Boot starter personalizado implica varios pasos. Primero, creas un nuevo proyecto Maven o Gradle. Define la funcionalidad principal que deseas encapsular en tu starter. Luego, crea una clase de auto-configuración (@Configuration) que configura beans basados en propiedades definidas en application.properties o application.yml. Usa @ConditionalOnClass, @ConditionalOnProperty y otras anotaciones condicionales para controlar cuándo se crean estos beans.

A continuación, cree un archivo spring.factories en el directorio META-INF de su proyecto. Este archivo enumera su clase de autoconfiguración, lo que permite a Spring Boot configurar automáticamente su starter. Empaquete el proyecto como un archivo JAR y despliéguelo en un repositorio Maven (local o remoto). Finalmente, cualquier proyecto Spring Boot puede incluir su starter agregando una dependencia al groupId y artifactId del starter. Spring Boot detectará y aplicará automáticamente las configuraciones definidas en su starter. Por ejemplo:

<dependency> <groupId>com.example</groupId> <artifactId>my-custom-starter</artifactId> <version>1.0.0</version> </dependency>

16. Explique cómo Spring Boot simplifica el proceso de trabajo con colas de mensajes como RabbitMQ o Kafka.

Spring Boot simplifica significativamente el trabajo con colas de mensajes como RabbitMQ o Kafka al proporcionar autoconfiguración y abstracciones que reducen el código repetitivo. Ofrece módulos como spring-rabbit y spring-kafka que proporcionan APIs de alto nivel para enviar y recibir mensajes. Estas APIs manejan las complejidades de conectarse a los brokers, serializar/deserializar mensajes y gestionar los reconocimientos de mensajes.

Específicamente, Spring Boot simplifica el proceso a través de funciones como:

• Autoconfiguración: Basado en las dependencias en tu pom.xml (Maven) o build.gradle (Gradle), Spring Boot configura automáticamente los beans necesarios (por ejemplo, RabbitTemplate, KafkaTemplate, MessageListenerContainer) para interactuar con la cola de mensajes.
• Configuración Simplificada: Las propiedades en application.properties o application.yml se utilizan para configurar los detalles de la conexión, los nombres de las colas/temas y otras configuraciones, reduciendo la cantidad de código requerido.
• Clases de Plantilla: Spring proporciona clases de plantilla como RabbitTemplate y KafkaTemplate para enviar mensajes fácilmente a la cola. Estas clases manejan los detalles subyacentes de bajo nivel.
• Anotaciones @RabbitListener / @KafkaListener: Estas anotaciones simplifican el proceso de consumir mensajes de las colas. Puedes anotar métodos con estas anotaciones para recibir y procesar automáticamente mensajes de una cola o tema específico. El framework gestiona la creación de listeners de mensajes y la gestión de hilos.
• Manejo de Errores: Spring se integra con los mecanismos de manejo de errores de las colas de mensajes, como los exchanges de cartas muertas (DLX) en RabbitMQ, para manejar los mensajes fallidos con elegancia.

17. ¿Cómo monitorearía su aplicación Spring Boot en producción, incluyendo métricas y comprobaciones de estado?

Monitorearía mi aplicación Spring Boot en producción utilizando una combinación de métricas, comprobaciones de estado y registro. Específicamente, usaría Spring Boot Actuator para exponer endpoints para métricas (como uso de memoria, utilización de CPU, latencia de solicitudes) y comprobaciones de estado (conectividad de la base de datos, espacio en disco). Estas métricas podrían ser recopiladas y visualizadas utilizando herramientas como Prometheus y Grafana.

Para las comprobaciones de estado, Actuator proporciona el endpoint /health que informa el estado de la aplicación. Para implementar comprobaciones de estado personalizadas, implementaría la interfaz HealthIndicator. Para el registro, aprovecharía un sistema de registro centralizado (por ejemplo, ELK stack o Splunk) para agregar y analizar los registros de diferentes instancias de la aplicación. Para garantizar el rendimiento y la estabilidad, es crucial configurar alertas basadas en métricas clave y tasas de error.

18. Describa cómo configuraría y usaría el soporte de Spring Boot para internacionalización (i18n) y localización (l10n).

Para configurar i18n/l10n en Spring Boot, comenzaría por crear paquetes de recursos de mensajes, típicamente nombrados messages.properties (predeterminado), messages_fr.properties (francés), messages_de.properties (alemán), etc., colocándolos en el directorio src/main/resources. Estos archivos contienen pares clave-valor donde las claves son códigos de mensajes y los valores son los mensajes localizados. A continuación, configuraría un bean MessageSource en mi configuración de Spring. Spring Boot configura automáticamente un MessageSource si encuentra paquetes de recursos de mensajes en el classpath. Para personalizarlo aún más, definiría un bean LocaleResolver (por ejemplo, AcceptHeaderLocaleResolver o CookieLocaleResolver) para determinar la configuración regional del usuario basándose en el encabezado Accept-Language o una cookie.

Para usar i18n/l10n en la aplicación, inyectaría el MessageSource en mis componentes y usaría el método getMessage() para recuperar mensajes localizados por sus códigos, pasando cualquier argumento necesario y la configuración regional actual. En las plantillas Thymeleaf, usaría el objeto de utilidad #messages para acceder a los mensajes localizados. Por ejemplo, <span th:text="#{welcome.message}"></span> recupera el valor asociado con la clave welcome.message del paquete de mensajes apropiado según la configuración regional actual. También puedo configurar interceptores para cambiar automáticamente la configuración regional.

19. Explique cómo usar Spring Boot con diferentes tipos de bases de datos (por ejemplo, relacionales, NoSQL).

Spring Boot simplifica las interacciones con bases de datos a través de su auto-configuración y módulos de acceso a datos como Spring Data JPA (para bases de datos relacionales) y Spring Data MongoDB (para NoSQL). Para bases de datos relacionales como MySQL o PostgreSQL, incluiría el iniciador Spring Data JPA apropiado (por ejemplo, spring-boot-starter-data-jpa), la dependencia del controlador de la base de datos (por ejemplo, mysql-connector-java) y configuraría las propiedades spring.datasource.url, spring.datasource.username y spring.datasource.password en application.properties o application.yml. Luego, puede usar repositorios JPA para interactuar con la base de datos utilizando convenciones de nomenclatura de métodos simples. Ejemplo: List<User> findByLastName(String lastName);

Para bases de datos NoSQL como MongoDB, incluirías la dependencia spring-boot-starter-data-mongodb y configurarías los detalles de conexión de MongoDB usando spring.data.mongodb.uri o las propiedades spring.data.mongodb.host y spring.data.mongodb.port. Similar a JPA, Spring Data MongoDB proporciona soporte de repositorio. Puedes definir entidades y repositorios, y Spring Data se encarga de las interacciones subyacentes con la base de datos. Para otras bases de datos NoSQL, normalmente buscarías módulos específicos de Spring Data o usarías el controlador nativo de la base de datos con JdbcTemplate o RestTemplate de Spring para obtener más control.

20. ¿Cómo manejarías las cargas y descargas de archivos en una aplicación Spring Boot?

Para las cargas de archivos en Spring Boot, usaría MultipartFile en un método del controlador. El usuario cargaría un archivo a través de un formulario, y el controlador lo recibiría como un objeto MultipartFile. Luego escribiría el archivo en el sistema de archivos del servidor o en un servicio de almacenamiento en la nube como AWS S3, manejando las posibles excepciones como IOException. Para las descargas, un método del controlador leería el archivo del sistema de archivos o del almacenamiento en la nube y lo devolvería como un Resource (por ejemplo, InputStreamResource), estableciendo el encabezado Content-Disposition apropiado para que el navegador le pida al usuario que guarde el archivo. El manejo de errores y la configuración adecuada del tipo MIME son cruciales para ambos.

Aquí hay un ejemplo básico de carga de archivos:

@PostMapping("/upload") public String uploadFile(@RequestParam("file") MultipartFile file) { try { // Guardar el archivo en un directorio o almacenamiento en la nube file.transferTo(new File("/upload-dir/" + file.getOriginalFilename())); return "Archivo cargado con éxito"; } catch (IOException e) { return "Fallo al cargar el archivo: " + e.getMessage(); } }

21. Describa cómo Spring Boot admite la creación de aplicaciones reactivas con Spring WebFlux.

Spring Boot simplifica la creación de aplicaciones reactivas con Spring WebFlux a través de la autoconfiguración y un modelo de programación familiar. Configura automáticamente los componentes necesarios para WebFlux, como el WebClient para realizar solicitudes HTTP reactivas y un servidor web reactivo (Netty es el predeterminado), reduciendo el código repetitivo. Puede usar anotaciones como @RestController, @GetMapping, @PostMapping de forma similar a Spring MVC, pero en lugar de devolver valores simples, devuelve tipos reactivos como Mono y Flux.

Específicamente, Spring Boot proporciona:

• Infraestructura WebFlux autoconfigurada: Se configura automáticamente una ReactiveWebServerFactory, típicamente usando Netty. Otras implementaciones como Tomcat, Jetty y Undertow también son posibles.
• Integración de WebClient: Para realizar llamadas HTTP reactivas.
• Enrutamiento Funcional: Soporte para el registro funcional de beans (por ejemplo, a través de las APIs RouterFunction y HandlerFunction).
• Repositorios de Datos Reactivos: Spring Data proporciona repositorios reactivos para diversas bases de datos, lo que permite un acceso a datos completamente no bloqueante.

Preguntas de entrevista de Spring Boot para personas con experiencia

1. ¿Cómo funciona internamente la autoconfiguración de Spring Boot, y cómo se pueden personalizar o deshabilitar configuraciones automáticas específicas?

La magia de la autoconfiguración de Spring Boot ocurre a través de algunos componentes clave. Comienza con la anotación @EnableAutoConfiguration (a menudo incluida implícitamente a través de @SpringBootApplication). Esta anotación aprovecha el SpringFactoriesLoader de Spring para encontrar clases listadas en los archivos META-INF/spring.factories en todo su classpath. Estas clases son típicamente clases de configuración anotadas con @Configuration y habilitadas condicionalmente usando anotaciones @Conditional. Estas anotaciones @Conditional verifican la presencia de clases, beans o propiedades específicas para determinar si una autoconfiguración particular debe aplicarse.

Para personalizar o deshabilitar las configuraciones automáticas, tiene varias opciones. Puede excluir configuraciones automáticas específicas utilizando los atributos exclude o excludeName de la anotación @EnableAutoConfiguration. Por ejemplo: @EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class}). También puede controlar el comportamiento de la configuración automática utilizando propiedades en application.properties o application.yml. Muchas configuraciones automáticas proporcionan propiedades que le permiten personalizar su comportamiento o deshabilitarlas por completo. Por ejemplo, spring.datasource.url se puede configurar para deshabilitar la configuración automática de la fuente de datos predeterminada si prefiere configurarla usted mismo.

2. Explique su experiencia con Spring Boot Actuator. ¿Qué métricas personalizadas ha implementado y cómo aseguró los endpoints de Actuator?

He usado Spring Boot Actuator extensamente para monitorear y administrar aplicaciones Spring Boot. Estoy familiarizado con los endpoints integrados como /health, /metrics, /info, /loggers y /env. Mi experiencia incluye configurarlos para exponer datos relevantes de la aplicación.

Respecto a las métricas personalizadas, he implementado varias usando Micrometer. Por ejemplo, rastrear el número de intentos de inicio de sesión exitosos y fallidos usando Counter. También he creado medidores personalizados para monitorear el tamaño de una caché específica o el número de hilos activos. Asegurar los endpoints de Actuator es crucial. He usado principalmente Spring Security para restringir el acceso basado en roles. Por ejemplo, solo los usuarios con el rol ACTUATOR_ADMIN pueden acceder a endpoints sensibles como /shutdown o /env. También he configurado management.endpoints.web.exposure.include y management.endpoints.web.exposure.exclude en application.properties para controlar qué endpoints se exponen.

3. Describe un escenario donde usaste el soporte de base de datos embebida de Spring Boot (por ejemplo, H2). ¿Cuáles fueron las ventajas y desventajas en comparación con el uso de una base de datos externa?

Usé la base de datos H2 embebida de Spring Boot para un proyecto personal que involucraba una API REST simple para administrar una lista de tareas pendientes. La principal ventaja fue la facilidad de configuración y ajuste. Dado que era una aplicación pequeña y autocontenida, no tener que configurar y administrar un servidor de base de datos externo simplificó significativamente el proceso de desarrollo y facilitó compartirlo con otros, ya que no se requería ninguna configuración de base de datos externa. Simplemente incluí las dependencias spring-boot-starter-data-jpa y com.h2database:h2, y Spring Boot configuró automáticamente una instancia de H2 en memoria para mí. Esto me permitió iterar rápidamente en la API y probar diferentes funcionalidades.

Sin embargo, la principal desventaja era la persistencia de datos. Una vez que la aplicación se cerraba, el contenido de la base de datos H2 se perdía (a menos que se configurara para persistir en un archivo, lo que añade complejidad). Esto lo hacía inadecuado para el despliegue en producción, donde el almacenamiento persistente de datos es crucial. Además, el rendimiento y la escalabilidad de H2 no son comparables a los de bases de datos externas más robustas como PostgreSQL o MySQL, que serían necesarias para manejar un mayor número de usuarios o estructuras de datos más complejas. Cambiar a una base de datos externa requería solo cambios menores en el archivo de configuración durante el ciclo de vida del proyecto, lo que resultó muy útil para el desarrollo rápido.

4. ¿Cómo ha implementado el almacenamiento en caché en una aplicación Spring Boot? ¿Qué proveedores de almacenamiento en caché ha utilizado (por ejemplo, Redis, Caffeine) y cuáles son las compensaciones?

He implementado el almacenamiento en caché en Spring Boot utilizando las anotaciones @Cacheable, @CacheEvict y @CachePut de Spring. Estas anotaciones simplifican la adición de lógica de almacenamiento en caché a los métodos. He utilizado diferentes proveedores de almacenamiento en caché en función de las necesidades de la aplicación.

• Caffeine: Es una biblioteca de almacenamiento en caché en memoria. Ofrece alto rendimiento y es adecuada para escenarios donde los datos no cambian con frecuencia y el uso de la memoria es una preocupación. Una desventaja es que la caché es local a la instancia de la aplicación, por lo que no es adecuada para entornos distribuidos sin configuración adicional (como el uso de un puente JCache).
• Redis: Una solución de almacenamiento en caché distribuida más robusta. Es adecuada para aplicaciones donde los datos deben compartirse entre múltiples instancias o servicios. La desventaja es que agrega complejidad a la infraestructura y tiene mayor latencia en comparación con las cachés en memoria como Caffeine. La configuración implica definir un RedisCacheConfiguration y usar RedisCacheManager.

Ejemplo de código:

@Cacheable("miCache") public String obtenerDatos(String clave) { // Operación costosa para recuperar datos return "datos para " + clave; }

5. Explique cómo ha manejado las tareas asíncronas en Spring Boot. ¿Cuáles son los pros y los contras de usar `@Async` vs. una cola de mensajes como RabbitMQ o Kafka?

En Spring Boot, he manejado las tareas asíncronas principalmente usando @Async y colas de mensajes. @Async simplifica la ejecución asíncrona al permitir que un método se ejecute en un hilo separado. Solo necesita anotar un método con @Async y habilitar el procesamiento asíncrono con @EnableAsync en una clase de configuración.

Comparando @Async con colas de mensajes (como RabbitMQ o Kafka): @Async es sencillo para tareas de "lanzar y olvidar" dentro de la misma aplicación. Sin embargo, se limita a una única instancia de la aplicación y carece de características de fiabilidad como la entrega garantizada. Las colas de mensajes proporcionan una solución más robusta para desacoplar servicios, asegurando la entrega de mensajes incluso si un servicio no está disponible temporalmente, y escalando horizontalmente. La elección depende de la complejidad y los requisitos de fiabilidad de la tarea asíncrona. Las colas de mensajes introducen complejidad y gastos generales, por lo que @Async es preferible para casos de uso más simples.

6. Describe su experiencia con el marco de pruebas de Spring Boot. ¿Qué tipos de pruebas ha escrito (por ejemplo, unitarias, de integración, de extremo a extremo) y cómo manejó las dependencias externas?

Tengo amplia experiencia con el marco de pruebas de Spring Boot y he escrito varios tipos de pruebas. Para las pruebas unitarias, utilizo principalmente JUnit y Mockito para aislar y probar componentes individuales, simulando cualquier dependencia. Las pruebas de integración implican probar la interacción entre diferentes partes de la aplicación, a menudo utilizando @SpringBootTest para cargar el contexto de la aplicación. También he utilizado Testcontainers o bases de datos embebidas (como H2) para gestionar las dependencias de la base de datos durante las pruebas de integración. Para las pruebas de extremo a extremo, he utilizado herramientas como Selenium o RestAssured para simular las interacciones del usuario y verificar el comportamiento de la aplicación desde una perspectiva externa.

Para manejar las dependencias externas de las pruebas, utilizo frameworks de simulación como Mockito para crear objetos simulados que imitan el comportamiento de estas dependencias. Esto me permite controlar las respuestas y asegurar que mi código maneja diferentes escenarios correctamente. También utilizo TestRestTemplate o WebTestClient de Spring para probar los endpoints REST y verificar el flujo de petición/respuesta sin involucrar los servicios externos reales. Para colas de mensajes u otra comunicación asíncrona, utilizo brokers embebidos o simulo los componentes de envío/recepción de mensajes.

7. ¿Cómo simplifica Spring Boot el proceso de creación de API RESTful? ¿Cuáles son algunas de las mejores prácticas para diseñar e implementar API REST con Spring Boot?

Spring Boot simplifica la creación de API REST al proporcionar auto-configuración, servidores embebidos (como Tomcat) y el framework Spring MVC. La auto-configuración configura automáticamente muchos componentes, reduciendo el código repetitivo. Spring MVC maneja el enrutamiento de peticiones, serialización/deserialización de datos (JSON, XML), y la generación de respuestas, utilizando anotaciones como @RestController, @RequestMapping, @GetMapping, @PostMapping, etc. Esto reduce drásticamente la configuración y la configuración necesarias en comparación con las aplicaciones Spring tradicionales.

Las mejores prácticas incluyen el uso de los métodos HTTP adecuados (GET, POST, PUT, DELETE) para las acciones correspondientes. Emplear URI de recursos significativos (por ejemplo, /usuarios/{id} en lugar de /obtenerusuario?userid={id}). Implementar códigos de estado correctos (200 OK, 201 Created, 400 Bad Request, 404 Not Found, 500 Internal Server Error). Usar JSON para el intercambio de datos. Considerar la paginación para grandes conjuntos de datos. Implementar la autenticación y autorización adecuadas utilizando Spring Security. Emplear versionado (por ejemplo, /api/v1/usuarios).

8. Explique cómo ha manejado la seguridad en una aplicación Spring Boot. ¿Qué mecanismos de autenticación y autorización ha utilizado (por ejemplo, OAuth2, JWT) y cómo se protegió contra las vulnerabilidades web comunes?

En las aplicaciones Spring Boot, he implementado la seguridad usando Spring Security. Para la autenticación, he usado JWT (JSON Web Tokens) y OAuth2. Los JWT son particularmente útiles para la autenticación sin estado, donde el servidor no necesita mantener sesiones. OAuth2 se implementa usando Spring Authorization Server (o bibliotecas como Spring Security OAuth2) para manejar los flujos de autorización. Para la autorización, aprovecho el control de acceso basado en roles (RBAC) de Spring Security y el control de acceso basado en expresiones usando anotaciones como @PreAuthorize y @PostAuthorize.

Para proteger contra vulnerabilidades web comunes, he tomado varias medidas. Estas incluyen la validación de entrada para prevenir la inyección SQL y los ataques de scripting de sitio cruzado (XSS). También utilizo la protección CSRF (Cross-Site Request Forgery) proporcionada por Spring Security. Por ejemplo, establecer configuraciones CORS adecuadas para prevenir peticiones de origen cruzado. Limitación de frecuencia para prevenir ataques de denegación de servicio (DoS), y usar prácticas de codificación segura, como evitar credenciales codificadas y actualizar regularmente las dependencias para corregir vulnerabilidades de seguridad. Los datos sensibles se cifran tanto en tránsito (usando HTTPS) como en reposo.

9. ¿Cómo has utilizado las características de inyección de dependencias de Spring Boot en aplicaciones complejas? ¿Puedes proporcionar un ejemplo de uso de inyección de constructor, inyección de setter e inyección de campo?

En aplicaciones Spring Boot complejas, he confiado en gran medida en la inyección de dependencias (DI) para promover el desacoplamiento y la capacidad de prueba. Principalmente uso la inyección de constructor, que considero la mejor práctica porque asegura que las dependencias requeridas se proporcionen en la creación del objeto, haciendo que el objeto esté completamente inicializado e inmutable.

Por ejemplo:

@Service public class MyService { private final MyRepository myRepository; @Autowired public MyService(MyRepository myRepository) { this.myRepository = myRepository; } // ... }

Si bien la inyección de constructor es preferida, he usado la inyección de setter en escenarios donde las dependencias son opcionales o pueden cambiarse después de la creación del objeto:

@Service public class AnotherService { private ExternalApi externalApi; @Autowired(required = false) public void setExternalApi(ExternalApi externalApi) { this.externalApi = externalApi; } // ... }

La inyección de campo (usando @Autowired directamente en los campos) se ha utilizado con moderación, principalmente en código heredado o prototipos rápidos, pero generalmente se evita debido a los desafíos en las pruebas y al potencial de excepciones en tiempo de ejecución si las dependencias no están configuradas correctamente. También dificulta la aplicación de la inmutabilidad.

@Service public class YetAnotherService { @Autowired private SomeHelper someHelper; //... }

10. Describa su experiencia con las funciones de acceso a datos de Spring Boot. ¿Qué frameworks ORM ha utilizado (por ejemplo, JPA, Hibernate) y cómo optimizó las consultas a la base de datos?

He usado ampliamente las funciones de acceso a datos de Spring Boot, principalmente a través de Spring Data JPA. Mi experiencia incluye la definición de entidades, repositorios y el aprovechamiento de la gestión de transacciones de Spring. He trabajado con Hibernate como el proveedor ORM subyacente para las implementaciones de JPA. También he usado JdbcTemplate para interacciones JDBC más directas cuando fue necesario.

Para optimizar las consultas a la base de datos, he empleado técnicas como:

• Usando índices: Asegurar que los índices apropiados se definan en columnas consultadas frecuentemente.
• Carga voraz vs. perezosa: Elegir cuidadosamente los tipos de obtención para evitar problemas de consulta N+1.
• Optimización de consultas: Analizar y reescribir consultas de ejecución lenta utilizando herramientas como EXPLAIN PLAN.
• Caché: Implementar estrategias de almacenamiento en caché (por ejemplo, utilizando la abstracción de caché de Spring con Redis o Caffeine) para datos de acceso frecuente.
• Usando proyecciones y DTOs para recuperar solo los campos necesarios. Ejemplo de consulta JPA @Query("SELECT new com.example.MyDto(e.field1, e.field2) FROM MyEntity e WHERE e.someCondition = :someValue") List<MyDto> findBySomeCondition(@Param("someValue") String someValue);

11. ¿Cómo ha monitoreado y administrado aplicaciones Spring Boot en producción? ¿Qué herramientas ha utilizado para el registro, métricas y alertas?

Para monitorear y administrar aplicaciones Spring Boot en producción, he utilizado una combinación de herramientas y técnicas. El registro es crucial, y normalmente configuro Spring Boot para usar Logback o Log4j2, con los registros a menudo enviados a un sistema de registro centralizado como el stack ELK (Elasticsearch, Logstash, Kibana) o Splunk. Esto permite una búsqueda y análisis eficientes del comportamiento de la aplicación.

Para las métricas, utilizo Spring Boot Actuator, que proporciona endpoints integrados para exponer el estado de la aplicación, las métricas y otra información operativa. Estas métricas pueden ser rastreadas por sistemas de monitoreo como Prometheus y visualizadas utilizando Grafana. También hemos utilizado herramientas APM como New Relic y Dynatrace para un monitoreo y rastreo del rendimiento más profundo. Para la alerta, he configurado alertas en Prometheus o en las herramientas APM para notificar al equipo a través de PagerDuty o Slack cuando las métricas críticas superan los umbrales predefinidos.

12. Explique cómo ha utilizado las funciones de gestión de configuración de Spring Boot. ¿Cómo gestionó los diferentes entornos (por ejemplo, desarrollo, pruebas, producción) y cómo externalizó la configuración?

He utilizado ampliamente la gestión de configuración de Spring Boot a través de archivos application.properties o application.yml. Para configuraciones específicas del entorno, utilizo perfiles de Spring. Creo archivos separados como application-dev.properties, application-test.properties y application-prod.properties. La propiedad spring.profiles.active se utiliza para activar el perfil apropiado, ya sea a través de variables de entorno, argumentos de línea de comandos o dentro de application.properties (perfil predeterminado). Para externalizar la configuración, priorizo las variables de entorno y los argumentos de línea de comandos, a menudo en conjunto con herramientas como Docker o Kubernetes. Cuando necesito una configuración jerárquica y quiero evitar fugas de información sensible, utilizo spring cloud config server que centraliza la configuración de la aplicación y proporciona mecanismos del lado del cliente para recuperarla.

Para información sensible, prefiero evitar almacenarla directamente en los archivos de configuración. En cambio, utilizo variables de entorno que se inyectan en tiempo de ejecución, o utilizo una solución de gestión de secretos. En términos de externalización, el orden de precedencia en Spring Boot también es muy útil: argumentos de línea de comandos > variables de entorno > application.properties > propiedades predeterminadas. Esto ayuda a garantizar que la configuración correcta siempre se use en tiempo de ejecución.

13. ¿Cómo implementaría un indicador de estado personalizado en Spring Boot Actuator para monitorear un aspecto específico de su aplicación?

Para implementar un indicador de estado personalizado en Spring Boot Actuator, crea una clase que implemente la interfaz HealthIndicator. Esta interfaz requiere que implementes un método health() donde realizas las comprobaciones del aspecto que deseas monitorear. Dentro del método health(), construyes un objeto Health utilizando los métodos Health.up() o Health.down(), proporcionando detalles sobre el estado (por ejemplo, utilizando .withDetail()).

Por ejemplo:

import org.springframework.boot.actuate.health.Health; import org.springframework.boot.actuate.health.HealthIndicator; import org.springframework.stereotype.Component; @Component public class MyCustomHealthIndicator implements HealthIndicator { @Override public Health health() { if (isMyServiceHealthy()) { return Health.up().withDetail("message", "El servicio está en buen estado").build(); } else { return Health.down().withDetail("message", "El servicio no está en buen estado").build(); } } private boolean isMyServiceHealthy() { // Realiza la lógica de comprobación de estado aquí return true; // O false, dependiendo de la comprobación } }

Spring Boot descubre y registra automáticamente beans de tipo HealthIndicator, haciendo que tu indicador personalizado esté disponible en el endpoint /actuator/health.

14. Describe una situación donde necesitaste crear un Spring Boot starter personalizado. ¿Cuáles fueron los componentes que incluiste en el starter, y cómo lo hiciste configurable?

Una vez construí un Spring Boot starter personalizado para integrarme con un servicio de autenticación interno propietario. Queríamos simplificar el proceso de integración para otros equipos. El starter incluía estos componentes: 1. Clase de auto-configuración: Definía beans para el cliente de autenticación, interceptores y servicios utilitarios. 2. Propiedades de configuración: Una clase @ConfigurationProperties para externalizar la configuración como URLs de endpoints de la API, tiempos de espera y claves de la API. 3. Cliente de autenticación: Un cliente personalizado basado en RestTemplate preconfigurado para manejar las cabeceras de autenticación. 4. Gestión de dependencias: Declaró las dependencias requeridas (por ejemplo, spring-boot-starter-web, spring-boot-starter-security).

Para hacerlo configurable, la clase @ConfigurationProperties permitía a los usuarios especificar ajustes en application.properties o application.yml. Por ejemplo:

my.auth.api-url: "https://auth.example.com" my.auth.api-key: "your_api_key" my.auth.timeout: 5000

La configuración condicional (@ConditionalOnProperty, @ConditionalOnClass) permitía además habilitar/deshabilitar ciertas características del starter basándose en la configuración de propiedades o la presencia de clases específicas en el classpath. Esta configuración garantizaba que el starter fuera fácil de usar y personalizable para diferentes entornos y casos de uso.

15. ¿Cómo manejas las transacciones en Spring Boot, especialmente cuando se trata de múltiples fuentes de datos o microservicios?

En Spring Boot, manejo las transacciones principalmente usando la anotación @Transactional. Para escenarios de una sola fuente de datos, la gestión de transacciones de Spring maneja automáticamente el ciclo de vida de la transacción, asegurando las propiedades de atomicidad, consistencia, aislamiento y durabilidad (ACID). Cuando se involucran múltiples fuentes de datos, uso un PlatformTransactionManager para cada fuente de datos y configuro un ChainedTransactionManager para gestionar la transacción en todas ellas. Esto implica definir los límites de la transacción de forma programática o declarativa.

Para los microservicios, las transacciones distribuidas se vuelven necesarias. Normalmente exploro opciones como el patrón Saga o la confirmación en dos fases (2PC) si las propiedades ACID son primordiales. Con el patrón Saga, se coordina una serie de transacciones locales y se ejecutan transacciones de compensación para deshacer operaciones anteriores si una falla. Frameworks como Axon o implementaciones personalizadas pueden ayudar a gestionar Sagas. Para 2PC, se pueden emplear tecnologías como las transacciones XA, aunque pueden introducir sobrecarga de rendimiento y complejidad. Los enfoques más modernos podrían incluir modelos de consistencia eventual que aprovechan las colas de mensajes para garantizar la sincronización de datos entre servicios.

16. Explique cómo implementaría la limitación de velocidad en una aplicación Spring Boot para protegerla contra abusos.

Implementaría la limitación de velocidad en una aplicación Spring Boot usando una librería como bucket4j. Primero, agregaría la dependencia bucket4j-spring-boot-starter a mi pom.xml o build.gradle. Luego, configuraría las reglas de limitación de velocidad. Estas reglas se pueden definir globalmente en application.yml o application.properties, o dinámicamente usando anotaciones como @RateLimit. Por ejemplo, @RateLimit(value = "myLimit", bandwidths = {@Bandwidth(capacity = 10, refillRefillAmount = 10, refillPeriod = 60, refillPeriodTimeUnit = ChronoUnit.SECONDS)}) limitaría un endpoint específico (o método) a 10 peticiones por minuto.

Cuando una petición excede el límite de velocidad, bucket4j la rechaza automáticamente con un error 429 Too Many Requests. También se puede implementar el manejo de errores personalizado para proporcionar un mensaje más amigable para el usuario. Bajo el capó, bucket4j puede utilizar varias opciones de almacenamiento como en memoria, Redis o Hazelcast para gestionar los buckets de limitación de velocidad. Elegir Redis o Hazelcast asegura que los límites de velocidad se apliquen en múltiples instancias de la aplicación. Bucket4j también proporciona métricas a través de Spring Boot Actuator, lo que permite monitorear el comportamiento de la limitación de velocidad.

17. Describa un escenario donde usó las interfaces `CommandLineRunner` o `ApplicationRunner` de Spring Boot. ¿Qué tipo de tareas realizó durante el inicio de la aplicación?

Usé CommandLineRunner en una aplicación Spring Boot para realizar tareas de inicialización de la base de datos justo después de que el contexto de la aplicación se inicializara. Específicamente, la aplicación requería que algunas tablas de búsqueda se pre-poblaran con valores predeterminados si estaban vacías al inicio.

Implementé la interfaz CommandLineRunner y, dentro de su método run, verifiqué si esas tablas específicas estaban vacías. Si lo estaban, utilicé repositorios de Spring Data JPA para insertar los datos iniciales. Esto aseguró que la aplicación siempre comenzara con los datos necesarios disponibles. Por ejemplo:

@Component public class DataInitializer implements CommandLineRunner { @Autowired private LookupTableRepository lookupTableRepository; @Override public void run(String... args) throws Exception { if (lookupTableRepository.count() == 0) { // Agregar datos iniciales a lookupTableRepository } } }

18. ¿Cómo has utilizado la función de perfiles de Spring Boot para gestionar diferentes configuraciones de aplicación para varios entornos?

He utilizado los perfiles de Spring Boot para gestionar configuraciones específicas del entorno. Por ejemplo, defino diferentes configuraciones de conexión a la base de datos, endpoints de API y niveles de registro para los entornos dev, test y prod.

Logro esto creando archivos application-{profile}.properties o application-{profile}.yml separados (por ejemplo, application-dev.properties). Estos archivos contienen las configuraciones específicas de ese entorno. Luego, activo el perfil deseado utilizando la propiedad spring.profiles.active, ya sea a través de variables de entorno, argumentos de línea de comandos o dentro del archivo application.properties (aunque esto último es menos común para la configuración específica del entorno para evitar cometerlos accidentalmente). A menudo uso anotaciones @Profile("dev") en clases de configuración o beans para habilitarlos condicionalmente en función del perfil activo. Además, incorporo perfiles de Maven y reemplazos de variables en tiempo de compilación, usando marcadores de posición ${}, para ajustar dinámicamente la propiedad spring.profiles.active en application.properties durante el proceso de compilación, lo que permite un mayor control sobre la configuración del entorno sin necesidad de modificar el código.

19. Explique cómo implementaría un programador de trabajos en segundo plano en una aplicación Spring Boot. ¿Cuáles son los pros y los contras de usar `@Scheduled` en comparación con un programador más robusto como Quartz?

La implementación de un programador de trabajos en segundo plano en Spring Boot se puede lograr a través de la anotación @Scheduled o un programador más rico en funciones como Quartz. @Scheduled es simple y adecuado para necesidades básicas de programación, como ejecutar una tarea a intervalos fijos o expresiones cron. Por ejemplo:

@Scheduled(fixedRate = 5000) // Se ejecuta cada 5 segundos public void myTask() { // Lógica de la tarea aquí }

Sin embargo, @Scheduled tiene limitaciones: no hay persistencia, dificultad para administrar dependencias complejas y desafíos en el monitoreo. Quartz ofrece persistencia, lo que permite que los trabajos sobrevivan a los reinicios de la aplicación. Proporciona una API más robusta para la administración de trabajos (pausar, reanudar, eliminar), un mejor manejo de errores y soporte para la agrupación en clústeres. Si bien Quartz requiere más configuración e introduce dependencias externas, sus funciones avanzadas son esenciales para requisitos de programación complejos. @Scheduled es una opción rápida y fácil para tareas simples, mientras que Quartz es preferido para necesidades de programación más sofisticadas y confiables.

20. ¿Cómo ha manejado el versionado de las API REST en una aplicación Spring Boot? ¿Qué estrategias utilizó (por ejemplo, versionado de URI, versionado de encabezado) y cuáles son las compensaciones?

He manejado el versionado de API REST en aplicaciones Spring Boot utilizando varias estrategias. El versionado de URI, como /v1/recurso y /v2/recurso, es sencillo y detectable, pero puede desordenar las URI. El versionado de encabezado, como el uso de Accept o encabezados personalizados, mantiene las URI limpias pero requiere que los clientes administren los encabezados correctamente. Una compensación es que el versionado de encabezado es menos detectable sin la documentación adecuada. Normalmente prefiero el versionado de URI por su simplicidad y detectabilidad, pero considero el versionado de encabezado si la estética de la URI es una preocupación importante.

Específicamente, podría implementar el versionado de URI usando las anotaciones @RequestMapping:

@RestController @RequestMapping("/v1/usuarios") public class UserControllerV1 { ... } @RestController @RequestMapping("/v2/usuarios") public class UserControllerV2 { ... }

21. Describa una situación donde usó el mecanismo de publicación y escucha de eventos de Spring Boot. ¿Qué tipos de eventos publicó y cómo los manejó de forma asíncrona?

Usé el mecanismo de eventos de Spring Boot en un proyecto de microservicios que se ocupaba del registro de usuarios. Tras el registro exitoso de un usuario, se publicó un UserRegisteredEvent. Este evento contenía detalles del usuario como ID y correo electrónico.

Para manejar esto de forma asíncrona y evitar bloquear el flujo de registro, utilicé la anotación @Async en el método del escucha de eventos. El escucha luego realizaba tareas como enviar correos electrónicos de bienvenida y activar otros microservicios (por ejemplo, a través de Kafka) para la creación de perfiles. Esto aseguró que la API de registro de usuarios respondiera rápidamente mientras las tareas en segundo plano se procesaban de forma independiente. Por ejemplo:

@EventListener @Async public void handleUserRegisteredEvent(UserRegisteredEvent event) { // Enviar correo electrónico de bienvenida // Activar la creación de perfil en otro microservicio }

22. ¿Cómo aborda la solución de problemas de rendimiento en aplicaciones Spring Boot? ¿Qué herramientas y técnicas utiliza para identificar cuellos de botella?

Para solucionar problemas de rendimiento en aplicaciones Spring Boot, normalmente empiezo por monitorear métricas clave como el uso de CPU, el consumo de memoria y los tiempos de respuesta. Utilizo herramientas como Spring Boot Actuator para exponer las métricas de la aplicación y las visualizo utilizando Prometheus y Grafana. También aprovecho las herramientas de perfilado de JVM como VisualVM o JProfiler para identificar métodos que consumen mucha CPU, fugas de memoria y cuellos de botella en la recolección de basura.

Analizo volcados de hilos para detectar interbloqueos o hilos de larga duración. Para problemas relacionados con la base de datos, habilito el registro de consultas para identificar consultas lentas y utilizo herramientas de perfilado de bases de datos como pgAdmin o MySQL Workbench para analizar los planes de ejecución de consultas. Técnicas como el almacenamiento en caché (usando Redis o Memcached), la optimización de consultas a la base de datos y el procesamiento asíncrono se pueden aplicar para resolver los cuellos de botella identificados. También uso herramientas como New Relic o Dynatrace para APM (Monitorización del Rendimiento de Aplicaciones).

23. Explique cómo ha implementado el rastreo distribuido en una arquitectura de microservicios Spring Boot utilizando herramientas como Zipkin o Jaeger.

En mi arquitectura de microservicios Spring Boot, he implementado el rastreo distribuido utilizando Spring Cloud Sleuth en conjunto con Zipkin. Spring Cloud Sleuth instrumenta automáticamente mis aplicaciones agregando IDs de rastreo y span a los mensajes de registro y a las cabeceras HTTP. Esto me permite rastrear las peticiones a medida que se propagan a través de los diferentes microservicios.

Específicamente, he añadido las dependencias spring-cloud-starter-sleuth y spring-cloud-starter-zipkin a mis archivos pom.xml. Mis servicios envían entonces automáticamente los datos de rastreo a un servidor central de Zipkin. Puedo configurar la tasa de muestreo en application.properties utilizando spring.sleuth.sampler.probability para controlar la cantidad de datos que se envían a Zipkin, especialmente en entornos de alto rendimiento. Accedo a la interfaz de usuario de Zipkin para visualizar los rastreos, identificar cuellos de botella de rendimiento y comprender las dependencias entre los servicios. Por ejemplo: spring.sleuth.sampler.probability=0.1 muestrearía el 10% de las peticiones.

24. Describe su experiencia con el uso de Spring Boot con programación reactiva. ¿Cómo usó Project Reactor y cuáles fueron los beneficios?

Tengo experiencia en el uso de Spring Boot con programación reactiva, principalmente aprovechando Project Reactor. He usado Flux y Mono para manejar flujos de datos asíncronos, lo que permite operaciones no bloqueantes en aplicaciones web. Por ejemplo, he implementado APIs REST reactivas que recuperan datos de múltiples fuentes simultáneamente usando flatMap y zip, mejorando significativamente los tiempos de respuesta.

Algunos beneficios observados incluyen:

• Mayor rendimiento: Manejo de más solicitudes simultáneamente sin bloquear hilos.
• Mejora de la capacidad de respuesta: Reducción de la latencia para los usuarios.
• Mejor utilización de recursos: Reducción del cambio de contexto de los hilos.

También he utilizado el soporte de pruebas de Reactor (por ejemplo, StepVerifier) para escribir pruebas unitarias completas para componentes reactivos. Un ejemplo típico sería obtener un flujo de eventos y procesarlos en paralelo usando Flux.fromIterable(events).parallel().runOn(Schedulers.boundedElastic()).map(this::processEvent).sequential(). Esto me permitió escalar el procesamiento de eventos de manera efectiva.

Pregunta 1.

¿Cuál de las siguientes afirmaciones describe mejor cómo funciona la función de autoconfiguración de Spring Boot?

Opciones:

Opciones:

Configura automáticamente los beans basándose únicamente en las clases presentes en el classpath, sin ninguna condición.

Configura los beans de forma inteligente basándose en el contenido del classpath y los beans existentes en el contexto de la aplicación, utilizando anotaciones condicionales para determinar cuándo aplicar las configuraciones.

Requiere configuración explícita para cada bean, deshabilitando cualquier capacidad de configuración automática.

Configura los beans aleatoriamente sin considerar el classpath o el contexto existente, simplificando el proceso de desarrollo.

Pregunta 2.

¿Cómo se puede personalizar el banner de la aplicación Spring Boot?

Opciones:

Creando un archivo `banner.txt` en el directorio `src/main/resources`.

Modificando el archivo `application.properties` con configuraciones de banner.

Implementando la interfaz `Banner` y registrándola como un bean.

Todas las anteriores.

Pregunta 3.

¿Cómo se pueden asegurar los endpoints de Spring Boot Actuator en un entorno de producción?

Por defecto, los endpoints de Actuator se aseguran automáticamente con Autenticación HTTP básica usando credenciales generadas automáticamente.

Usando Spring Security para configurar las reglas de autenticación y autorización para la ruta `/actuator/**`.

Deshabilitando todos los endpoints de Actuator en producción.

Los endpoints de Actuator son inherentemente seguros y no requieren ninguna configuración de seguridad adicional.

Pregunta 4.

En Spring Boot, ¿cuál es el orden de precedencia para las propiedades de configuración externalizadas, con la precedencia más alta listada primero?

Opciones:

Argumentos de línea de comandos > Propiedades del sistema Java > Variables de entorno del sistema operativo > application.properties/application.yml

Propiedades del sistema Java > Argumentos de línea de comandos > Variables de entorno del sistema operativo > application.properties/application.yml

Argumentos de línea de comandos > Variables de entorno del sistema operativo > Propiedades del sistema Java > application.properties/application.yml

Variables de entorno del sistema operativo > Propiedades del sistema Java > Argumentos de línea de comandos > application.properties/application.yml

Pregunta 5.

¿Cuál de las siguientes acciones, por defecto, NO desencadenará un reinicio automático de una aplicación Spring Boot cuando se utilizan Spring Boot Devtools?

Opciones:

Modificar un archivo de clase en el directorio `src/main/java`.

Modificar un archivo en el directorio `src/main/resources/static`.

Modificar un archivo en el directorio `src/main/resources/templates` usando Thymeleaf.

Modificar application.properties

Pregunta 6.

En una aplicación Spring Boot, ¿cuál de las siguientes fuentes de propiedades tiene precedencia sobre las demás al resolver una propiedad con el mismo nombre?

Opciones:

Argumentos de línea de comandos

Archivo application.properties en el classpath

Archivo application.yml en el classpath

Propiedades del sistema Java

Pregunta 7.

¿Cómo se puede personalizar globalmente el manejo de excepciones en una aplicación Spring Boot usando @ControllerAdvice?

Elija el enfoque correcto:

Opciones:

Definiendo una clase anotada con `@ControllerAdvice` y métodos anotados con `@ExceptionHandler` para manejar excepciones específicas.

Modificando directamente el `ErrorController` proporcionado por Spring Boot.

Creando un bean `HandlerExceptionResolver` personalizado y registrándolo en el contexto de la aplicación.

Usando `SimpleMappingExceptionResolver` en `application.properties`.

Pregunta 8.

¿Cuál de los siguientes mecanismos permite ejecutar código muy temprano en la secuencia de inicio de la aplicación Spring Boot, antes de que el ApplicationContext se actualice por completo, lo que permite la personalización temprana del entorno o contexto? Opciones:

Opciones:

Implementando la interfaz `CommandLineRunner`.

Usando un método anotado con `@PostConstruct` en un bean gestionado por Spring.

Implementando la interfaz `ApplicationRunner`.

Implementando la interfaz `ApplicationContextInitializer` y referenciándola en `spring.factories`.

Pregunta 9.

En Spring Boot, ¿cuál de las siguientes afirmaciones es la más precisa con respecto al orden de ejecución de los beans `ApplicationListener` que escuchan el `ApplicationReadyEvent`? Asumiendo que no se utilizan las interfaces `@Order` ni `Ordered`.

Opciones:

Opciones:

Los listeners se ejecutan en el orden en que están definidos en el archivo `application.properties`.

Los listeners se ejecutan en un orden aleatorio.

Los listeners se ejecutan en el orden en que son descubiertos por el contexto de Spring, típicamente el orden alfabético de sus nombres de bean o basado en el orden en que se registran en el contexto de la aplicación.

No se garantiza que los listeners se ejecuten para `ApplicationReadyEvent` si no se configuran explícitamente usando la interfaz `@Order` o `Ordered`.

Pregunta 10.

¿Qué anotación se utiliza para habilitar condicionalmente un bean basado en los perfiles activos de Spring?

Opciones:

@Profile

@ConditionalOnBean

@EnableConfigurationProperties

@SpringBootApplication

Pregunta 11.

¿Cuál de las siguientes es la forma correcta de personalizar el puerto del servidor Tomcat embebido en una aplicación Spring Boot programáticamente?

Opciones:

Implementar la interfaz `WebServerFactoryCustomizer<TomcatServletWebServerFactory>` y establecer el puerto usando `factory.setPort(8081)`. Este bean debe ser un bean escaneado por componentes para ser efectivo.

Establezca la propiedad `server.port` directamente dentro de la definición del bean `TomcatServletWebServerFactory`.

Extienda `SpringBootServletInitializer` y anule el método `configure` para establecer el puerto.

Use la anotación `@TomcatCustomizer` y establezca el atributo `port` directamente

Pregunta 12.

En una aplicación Spring Boot, ¿cuál es el orden de precedencia para cargar propiedades de configuración externalizadas, con la precedencia MÁS ALTA enumerada primero? Considere las siguientes opciones:

Opciones:

Argumentos de línea de comandos > Archivos de propiedades de la aplicación en el directorio actual > Archivos de propiedades de la aplicación en el subdirectorio config/ > Archivos de propiedades de la aplicación en el classpath

Archivos de propiedades de la aplicación en el classpath > Archivos de propiedades de la aplicación en el subdirectorio config/ > Archivos de propiedades de la aplicación en el directorio actual > Argumentos de línea de comandos

Archivos de propiedades de la aplicación en el directorio actual > Archivos de propiedades de la aplicación en el classpath > Archivos de propiedades de la aplicación en el subdirectorio config/ > Argumentos de línea de comandos

Archivos de propiedades de la aplicación en el subdirectorio config/ > Archivos de propiedades de la aplicación en el classpath > Argumentos de línea de comandos > Archivos de propiedades de la aplicación en el directorio actual

Pregunta 13.

¿Cómo se puede crear un indicador de estado personalizado en una aplicación Spring Boot para exponer información de estado específica de la aplicación a través del endpoint `/actuator/health`?

Opciones:

Implemente la interfaz `HealthContributor` y regístrela como un bean de Spring.

Implemente la interfaz `HealthIndicator` y regístrela como un bean de Spring.

Extienda la clase `AbstractHealthIndicator` y regístrela como un bean de Spring. Debe exponer información de estado específica de la aplicación a través del endpoint `/actuator/health`.

Cree una clase anotada con `@HealthComponent` y deje que Spring Boot la registre automáticamente.

Pregunta 14.

¿Cuál es el propósito de la propiedad spring.main.web-application-type en una aplicación Spring Boot?

Opciones:

Especifica el tipo de aplicación web que se creará (por ejemplo, servlet, reactiva, ninguna).

Define el puerto en el que se ejecutará la aplicación.

Configura las propiedades de conexión de la fuente de datos.

Habilita o deshabilita Spring Security para la aplicación.

Pregunta 15.

¿Cómo se puede personalizar el Jackson ObjectMapper utilizado por los convertidores de mensajes JSON autoconfigurados de Spring Boot?

Opciones:

Implementar un WebMvcConfigurer y anular configureMessageConverters para configurar manualmente el MappingJackson2HttpMessageConverter.

Crear un @Bean de tipo Jackson2ObjectMapperBuilderCustomizer. Esto le permite personalizar el Jackson2ObjectMapperBuilder, que luego se utiliza para crear el ObjectMapper.

Modificar directamente la instancia ObjectMapper inyectada en el MappingJackson2HttpMessageConverter después de que se inicialice el contexto de la aplicación.

Utilizar spring.jackson.properties en application.properties para configurar el ObjectMapper directamente.

Pregunta 16.

¿Cuál es la diferencia clave entre las interfaces CommandLineRunner y ApplicationRunner en Spring Boot?

`CommandLineRunner` proporciona acceso a argumentos de línea de comandos sin formato como una matriz de String, mientras que `ApplicationRunner` proporciona acceso a ellos como un objeto `ApplicationArguments`.

`ApplicationRunner` se ejecuta antes que `CommandLineRunner`.

`CommandLineRunner` solo se usa para aplicaciones web, mientras que `ApplicationRunner` es para aplicaciones que no son web.

No hay ninguna diferencia; ambos logran la misma funcionalidad de la misma manera.

Pregunta 17.

¿Cuál de los siguientes enfoques es el MENOS adecuado para personalizar el puerto de un servidor Tomcat integrado en una aplicación Spring Boot?

Opciones:

Establecer la propiedad `server.port` en `application.properties` o `application.yml`.

Configurar programáticamente el bean `TomcatServletWebServerFactory`.

Usar variables de entorno para anular `server.port`.

Modificar la variable de entorno `CATALINA_HOME` para que apunte a una instalación de Tomcat personalizada.

Pregunta 18.

Desea implementar un Converter personalizado en una aplicación Spring Boot para convertir un formato específico de String en un objeto personalizado. ¿Cómo se asegura de que Spring registre y use automáticamente su convertidor?

Opciones:

Implemente la interfaz `Converter` y anote la clase de implementación con `@Component`.

Implemente la interfaz `Converter` y regístrela manualmente con el `ConversionService` usando una clase `@Configuration` y un `ConversionServiceFactoryBean`.

Implemente la interfaz `Converter` y declare un bean de tipo `ConverterRegistry` en una clase `@Configuration`.

Implemente la interfaz `Converter`, anote la implementación con `@Service`, y especifique su prioridad usando `@Order`.

Pregunta 19.

¿Qué anotación de prueba de Spring Boot se utiliza para probar solo la capa web de una aplicación, deshabilitando efectivamente la configuración automática completa y escaneando solo `@Controller`, `@RestController` y componentes relacionados?

Opciones:

Opciones:

`@SpringBootTest`

`@DataJpaTest`

`@WebMvcTest`

`@RestClientTest`

Pregunta 20.

¿Qué anotación se utiliza para habilitar la funcionalidad de auditoría en una aplicación Spring Boot con Spring Data JPA?

Opciones:

@EnableJpaRepositories

@EnableAutoConfiguration

@EnableJpaAuditing

@EnableTransactionManagement

Pregunta 21.

En Spring Boot, ¿qué propiedad controla si los beans con el mismo nombre pueden ser anulados en el contexto de la aplicación?

Opciones:

`spring.main.allow-bean-definition-overriding`

`spring.main.allow-circular-references`

`spring.bean.allow-overriding`

`spring.config.allow-bean-overriding`

Pregunta 22.

¿Qué archivo se utiliza principalmente por Spring Boot para habilitar las clases de configuración automática?

Opciones:

application.properties

application.yml

spring.factories

pom.xml

Pregunta 23.

¿Cuál de los siguientes es el enfoque más adecuado para integrar Spring Batch con una aplicación Spring Boot?

Opciones:

Configurar manualmente todos los componentes de Spring Batch (JobRepository, JobLauncher, etc.) como beans regulares de Spring.

Aprovechar la autoconfiguración de Spring Boot para Spring Batch incluyendo la dependencia `spring-boot-starter-batch`.

Usar un contexto Spring separado para Spring Batch e integrarlo a través de las API REST.

Implementar un cargador de clases personalizado para aislar los componentes de Spring Batch de la aplicación principal.

Pregunta 24.

¿Cómo se configuran múltiples fuentes de datos en una aplicación Spring Boot?

Opciones:

Definiendo múltiples beans `DataSource` y usando `@Primary` para designar uno predeterminado.

Definiendo múltiples beans `DataSource` y usando `@ConfigurationProperties` con diferentes prefijos para enlazarlos a configuraciones específicas.

Definiendo un único bean `DataSource` y alternando dinámicamente entre diferentes conexiones de base de datos en tiempo de ejecución.

Spring Boot no soporta la configuración de múltiples fuentes de datos.

Pregunta 25.

¿Cómo se personaliza la ruta de la Consola H2 en una aplicación Spring Boot?

Opciones:

Estableciendo la propiedad `spring.h2.console.path` en `application.properties` o `application.yml`.

Definiendo un `ServletRegistrationBean` para el servlet de la Consola H2 y mapeándolo a la ruta deseada.

Usando la anotación `@H2ConsolePath` en una clase de configuración.

La ruta de la Consola H2 no se puede personalizar y está fija en `/h2-console`.

¿Qué habilidades de Spring Boot deberías evaluar durante la fase de entrevista?

Evaluar las habilidades de Spring Boot de un candidato en una sola entrevista es un desafío, pero centrarse en las competencias básicas es clave. Centrémonos en las habilidades de mayor impacto que pueden revelar rápidamente el potencial de un candidato.

Conceptos básicos de Spring

Puede utilizar una prueba de evaluación de habilidades con preguntas de opción múltiple (MCQ) relevantes para filtrar rápidamente a los candidatos en función de su conocimiento de los conceptos básicos de Spring. Nuestra prueba de Spring incluye preguntas sobre DI, IoC y otros conceptos fundamentales.

Para evaluar aún más la comprensión de un candidato, haga preguntas específicas de la entrevista que le exijan explicar estos conceptos en escenarios prácticos.

Explique la diferencia entre Inyección de Dependencias e Inversión de Control. Proporcione un ejemplo de cómo ha utilizado cada uno en una aplicación Spring Boot.

Busque candidatos que puedan articular claramente los principios detrás de DI e IoC, y proporcionar ejemplos concretos de su experiencia. Las respuestas vagas pueden indicar una comprensión superficial.

Autoconfiguración de Spring Boot

Evalúe la comprensión de la autoconfiguración de un candidato con preguntas de opción múltiple. Nuestra prueba de Spring cubre las diversas funciones de autoconfiguración en Spring Boot.

Haga una pregunta que les exija explicar la mecánica de la autoconfiguración y cómo pueden personalizarla.

Describa cómo funciona la autoconfiguración de Spring Boot. ¿Cómo lo personalizaría para utilizar un grupo de conexiones de base de datos específico?

Los candidatos deben demostrar una comprensión de cómo Spring Boot identifica y configura los beans en función de las dependencias y propiedades del classpath. También deben saber cómo anular los valores predeterminados mediante propiedades de configuración o clases de autoconfiguración personalizadas.

Diseño e implementación de API RESTful

Evalúe la capacidad de un candidato para diseñar e implementar API RESTful utilizando preguntas de opción múltiple. Nuestra prueba de Spring incluye preguntas sobre el diseño de API, el manejo de solicitudes y respuestas, y el trabajo con diferentes métodos HTTP.

Haga una pregunta que les exija describir el proceso de diseño e implementación de un endpoint de API RESTful.

Guíeme a través de los pasos que tomaría para diseñar e implementar un endpoint de API RESTful para crear un nuevo usuario en una aplicación Spring Boot. Incluya consideraciones para la validación de solicitudes, el manejo de errores y la seguridad.

Busque candidatos que puedan articular un proceso claro, que cubra aspectos como la definición de formatos de solicitud/respuesta, el manejo de la validación, la implementación del manejo de errores y la seguridad del endpoint. Deben demostrar conocimiento de los principios y las mejores prácticas de RESTful.

3 Consejos para usar preguntas de entrevista de Spring Boot

Antes de que empiece a poner en práctica lo que ha aprendido, aquí tiene algunos consejos para ayudarle a sacar el máximo provecho de sus preguntas de entrevista de Spring Boot. Estas sugerencias le permitirán evaluar a los candidatos de forma más eficaz y tomar decisiones de contratación informadas.

1. Aproveche las evaluaciones de habilidades para filtrar a los candidatos

Las pruebas de habilidades son una herramienta poderosa para agilizar su proceso de contratación e identificar a los candidatos con las habilidades técnicas que necesita. Mediante el uso de evaluaciones tempranas, puede filtrar a los candidatos que carecen de las habilidades requeridas antes de invertir tiempo en entrevistas.

Para los roles de Spring Boot, considere el uso de evaluaciones que evalúen las habilidades de Java, Spring y SQL. Adaface ofrece una gama de pruebas relevantes, incluyendo el Java Spring Test, Java Spring SQL Test y Spring Test.

El uso de estas pruebas le permite obtener una comprensión basada en datos de las habilidades de cada candidato. Esto le permite ver cómo sus cualificaciones se alinean con los requisitos del puesto de trabajo y priorizar las entrevistas para los individuos más prometedores.

2. Esquematizar Preguntas de Entrevista Relevantes

El tiempo es limitado durante las entrevistas, por lo que es clave elegir el número correcto de preguntas y las preguntas más relevantes. El objetivo es maximizar su capacidad para evaluar a los candidatos eficazmente en habilidades y aspectos importantes.

Considere centrar sus preguntas en áreas que aún no estén cubiertas por las evaluaciones de habilidades. Por ejemplo, si ya ha evaluado las habilidades técnicas, puede utilizar la entrevista para explorar la adaptación cultural o las habilidades de comunicación. También tenemos preguntas de entrevista para comunicación.

Las preguntas de entrevista cuidadosamente seleccionadas pueden proporcionar información valiosa sobre las habilidades de resolución de problemas de un candidato y su experiencia con escenarios del mundo real.

3. Hacer Preguntas de Seguimiento para Medir la Profundidad

Simplemente hacer preguntas de entrevista puede no ser suficiente para evaluar la verdadera profundidad de conocimiento de un candidato. Hacer las preguntas de seguimiento correctas es importante para medir verdaderamente la habilidad de un candidato.

Por ejemplo, si un candidato explica el concepto de inyección de dependencias en Spring Boot, pregúnteles a continuación que describan un escenario donde lo usaron para resolver un problema complejo. Este tipo de pregunta puede ayudar a revelar su experiencia práctica y comprensión del concepto.

Evalúe el talento de Spring Boot con evaluaciones específicas

Al contratar desarrolladores de Spring Boot, evaluar con precisión sus habilidades es clave. La forma más efectiva de hacerlo es a través de pruebas de habilidades. Explore la gama de evaluaciones de Adaface, incluida nuestra Prueba de Java Spring y Prueba de Spring, para asegurarse de que está evaluando a los candidatos de manera efectiva.

Una vez que haya identificado a los mejores candidatos a través de pruebas de habilidades, agilice su proceso de contratación centrándose en los candidatos más prometedores. Regístrese en la plataforma Adaface para comenzar con sus evaluaciones o obtener más información sobre nuestra plataforma de evaluación en línea.

Prueba en línea de Java y Spring

40 minutos | 9 MCQs y 1 pregunta de codificación

La prueba Java Spring Test utiliza preguntas de opción múltiple basadas en escenarios para evaluar la capacidad de los candidatos para trabajar con módulos de Spring, como Core, MVC, Security y Boot, así como su comprensión de la inyección de dependencias, AOP, servicios web RESTful e integración de bases de datos. Otras habilidades clave evaluadas incluyen programación orientada a objetos, patrones de diseño, pruebas, depuración y arquitectura de software. La prueba también incluye una pregunta de codificación para evaluar las habilidades prácticas de programación Java.

[

Prueba Java y Spring en línea

](https://www.adaface.com/assessment-test/java-spring-test)

Descargue la plantilla de preguntas para la entrevista de Spring Boot en múltiples formatos

Preguntas frecuentes sobre las preguntas de la entrevista de Spring Boot

Hay 22 preguntas de entrevista de Spring Boot diseñadas para principiantes, que se centran en los conceptos básicos y fundamentales.

Hay 24 preguntas de entrevista de Spring Boot dirigidas a candidatos con experiencia, que cubren temas avanzados y escenarios del mundo real.

Puede evaluar a los desarrolladores junior de Spring Boot utilizando 27 preguntas que cubren conceptos intermedios y prácticas de codificación.

Utilice estas preguntas para identificar las fortalezas y debilidades de los candidatos. Adapte sus preguntas a los requisitos del trabajo.

Utilice evaluaciones específicas junto con preguntas de entrevista para obtener una imagen completa de las habilidades de Spring Boot de un candidato.