Las 20 preguntas más clásicas de la entrevista de Spring Boot, más del 95% se preguntarán, no están convencidos de luchar.

Las 20 preguntas más frecuentes en las entrevistas técnicas de Spring Boot.

1. ¿Cuáles son las características de Spring Boot?

Spring Boot es una extensión de Spring que elimina la configuración repetitiva necesaria para configurar las aplicaciones de Spring.

• configuración automática

Esta es la característica más importante de Spring Boot. Esto elimina en gran medida la configuración manual. El marco base viene con una biblioteca integrada llamada configuración automática que hace este trabajo por nosotros. Detecta la presencia de ciertas clases y su presencia en el classpath, y las configura automáticamente para nosotros.

Por ejemplo: — Cuando agregamos la dependencia spring-boot-starter-web en nuestro proyecto, la configuración automática de Spring Boot busca si Spring MVC está en el classpath. Configura automáticamente dispatcherServlet, páginas de error predeterminadas y web jars. — De manera similar, cuando agregamos
la dependencia spring-boot-starter-data-jpa, vemos la configuración automática de Spring Boot, la configuración automática de una fuente de datos y un administrador de entidades.

• Servidor web Tomcat incorporado

Spring Boot se envía con el servidor Tomcat de forma predeterminada. Por lo tanto, no necesitamos configurar un servidor para ejecutar la aplicación (si nuestro servidor preferido es Tomcat).

• Primeros pasos POM

Spring Boot proporciona una serie de POM de inicio para realizar las tareas más comunes en la vida de desarrollo. Podemos confiar en ellos y en el propio marco sin tener que ir a bibliotecas de terceros. Enumero algunos de ellos aquí.

1. spring-boot-starter-web: crear una API REST
2. spring-boot-starter-data-jpa: conectarse a la base de datos SQL
3. spring-boot-starter-data-mongodb: conectarse a MongoDB
4. spring-boot-starter-aop: aplicación de conceptos de programación orientada a aspectos
5. spring-boot-starter-security: implementa seguridad como la autenticación basada en roles
6. spring-boot-starter-test: implementar pruebas unitarias

• API del actuador

Spring Boot Actuator es un subproyecto del marco Spring Boot. Nos permite ver información y métricas y monitorear aplicaciones en ejecución a través de un conjunto de puntos finales de API. No necesitamos crearlos manualmente.

1. Estadísticas de la base de datos: uso de la fuente de datos
2. Uso de la memoria de la CPU
3. ciclo de cromatografía de gases
4. Seguimiento de solicitudes HTTP

• Inicializador Spring Boot

Esta es una interfaz de usuario basada en la web que brinda principalmente la capacidad de crear un nuevo proyecto Spring Boot con las dependencias disponibles y descargar el proyecto creado como un archivo zip. Así que no tenemos que crearlo desde cero. Toda la estructura básica del proyecto ya está en este zip descargado. Spring Initializer se proporciona como un complemento IDE, también con un nombre diferente.

Por ejemplo: para IntelliJ, el complemento es Spring Assistant o Spring Initializer.

2. ¿Sabe cómo funciona internamente la anotación "@SpringBootApplication"?

Una aplicación Spring Boot se ejecuta utilizando esta anotación. En realidad es una combinación de otras 3 anotaciones:

Escaneo de componentes、Habilitar configuración automática和Configuración。

@SpringBootApplication = @ComponentScan + @EnableAutoConfiguration + @Configuration

• "@Configuración": todas las clases anotadas se consideran como configuración AD de Spring Boot y son elegibles para crear beans y volver al contenedor IOC.
• "@ComponentScan": todas las clases anotadas se escanearán a través de paquetes (dónde buscar) y ayudarán a crear instancias de estas clases.
• "@EnableAutoConfiguration": esta es la anotación mágica. Esto busca el classpath. El marco base viene con una biblioteca integrada llamada configuración automática que hace este trabajo por nosotros. Detecta la presencia de ciertas clases y su presencia en el classpath, y las configura automáticamente para nosotros. Pongo una instantánea de la biblioteca a continuación. Si se dirige al archivo spring.factories, verá las configuraciones de clase disponibles.

 

La imagen de arriba es el JAR dependiente de la configuración automática

Supongamos que agregamos una dependencia JPA: Spring Boot verifica la ruta de clase para ver qué está disponible y
las propiedades definidas en el archivo application.properties/yml. Aquí estarán la URL de la base de datos y las credenciales.

Las clases del repositorio JPA también se anotan con algunas anotaciones condicionales, como "@ConditionalOnBean", "@ConditionalOnClass", de acuerdo con estas reglas, se genera la configuración.

3. ¿Qué es un frijol?

Los beans son simplemente objetos de Java. En el contexto de Spring Boot, se consideran objetos Java + objetos que se inicializan automáticamente al iniciar la aplicación y son administrados por el contenedor Spring IOC. Tenemos la anotación "@Bean" para lograr esto.

4. ¿Qué es la Inversión de Control (IOC) en Spring?

Inversión de control:

El principio de transferir el control de un objeto o parte de un programa a un contenedor o marco. Lo usamos más a menudo en  el contexto de la programación orientada a objetos  . En pocas palabras, el control lo maneja el marco, no nosotros, lo contrario del flujo de control del programa. Lo opuesto es el movimiento de Tao.

Contenedor IOC de resorte:

Un contenedor que crea objetos, configura y ensambla sus dependencias y gestiona todo su ciclo de vida. Utiliza inyección de dependencia (DI) para administrar los componentes que componen la aplicación.

5. ¿Cómo implementamos la inyección de dependencia en Spring Boot?

DI — pasar un objeto como dependencia a otro objeto

En Spring Boot, podemos usar la anotación "@Autowired" para lograr esto. El contenedor Spring IOC luego creará los objetos en nuestro nombre. Por lo general, en la capa del controlador inyectamos el servicio y en la capa del servicio inyectamos el repositorio para usar esta anotación.

6. ¿Cuáles son las capas de los microservicios de Spring Boot?

• Capa de controlador: todos los controladores con métodos definidos para puntos finales de API. Las clases se anotan con la anotación "@RestController".
• Capa Repositorio/DAO: Todas las interfaces del repositorio están incluidas en esta capa para consultar la base de datos seleccionada (SQL/no SQL). Las interfaces se anotan con la anotación "@Repository".
• Capa de servicio: aquí se incluye toda la lógica comercial. Por lo general, en esta capa se accede a la capa DAO para realizar algunas operaciones. Las clases se anotan con la anotación "@Service".
• Capa de entidad: todas las clases que se asignan al mundo real están contenidas en esta capa. Por lo general, todas las anotaciones relacionadas con ORM se colocan en estas clases. — Anotamos el nombre de la tabla con "@Entity" si se conecta con MySQL. — Si está conectado a MongoDB, anotamos el nombre de la colección con "@Document".

Además, podemos definir getters y setters aquí usando una biblioteca como Lombok.

9. ¿Cómo usar Spring Boot para conectarse a la base de datos?

Por lo general, no necesitamos crear una clase de base de datos singleton, un método de grupo de conexiones ni ninguna otra implementación. Spring Boot Auto Configuration hará todas estas clases y configuración por nosotros. Solo hay que configurar.

1. Agregue dependencias iniciales para bases de datos (MySQL/MongoDB/Redis) al POM.
2. Defina la configuración en el archivo application.properties/yml, por ejemplo: URL de la base de datos y credenciales

10. ¿Cómo escribir una consulta personalizada en la capa DAO?

Por lo general, en la capa de Repositorio, ampliamos la interfaz con la interfaz JPARepository o MongoRepository. Posteriormente, nuestro Repositorio (DAO) tendrá todos los métodos disponibles en la interfaz de Spring Boot Repository. Es: save(), saveAll(), findById(), find(), etc.

Pero dependiendo de las necesidades de nuestro negocio, es posible que necesitemos otros métodos.

Ej: findByEmail(), findUsersByRegion() etc... singleton

Así que tenemos que proporcionar una consulta personalizada en este caso. Tenemos la anotación "@Query" para lograr esto. Simplemente defina la consulta antes de cada definición de método. ¡eso es todo!

Si usamos JPA, tenemos que crear consultas usando JPQL (Java Persistence Query Language). Está definido en la especificación JPA y es un lenguaje de consulta orientado a objetos para realizar operaciones de base de datos en entidades persistentes.

Ejemplo: Buscar solo usuarios en un área determinada

@Query(<font>"select u from users u where u.region =: region"</font><font>) 
Optional<List<User>> findUsersByRegion(String region);
</font>

11. ¿Cómo manejar transacciones en Spring Boot? ¿Alguna anotación utilizada?

Spring Boot proporciona una anotación llamada "@Transactional" para administrar transacciones.

Supongamos un escenario de pedido de productos. Necesitamos procesar el pedido en el Servicio de pedidos y enviar los detalles del pago al Servicio de pago a través de una llamada REST. Imagine que un servicio de pago se detiene repentinamente. Si guarda los detalles del pedido en su propia base de datos antes de enviar la llamada API al servicio de pago, habrá discrepancias en el futuro porque los datos del servicio de pago están perdiendo ese registro.

Para evitar esto, podemos poner la anotación "@Transactional" en el método del servicio de pedidos. Luego, a partir de ahí, si hay una falla al llamar al servicio de pago, ¡todos los datos en el proceso en curso se revertirán!

@Transactional
 <b>public</b> Order orderProduct(Product product, Double payment) { 
    <font><i>// 处理订单</i></font><font>
    </font><font><i>// 向支付服务发送 REST 调用</i></font><font>
}
</font>

12. ¿Dónde necesitamos usar la anotación "@Qualifier"?

Esta anotación se usa para decirle específicamente a Spring Boot que obtenga una clase en particular de todos sus beans de implementación disponibles. La anotación @Qualifier se usa junto con la anotación "@Autowired" para la inyección de dependencia.

Supongamos que tenemos 1 interfaz y 2 clases de implementación diferentes.

Por ejemplo: interfaz UserService => AdminUserService, clase StaffUserService

Tanto AdminUserService como StaffUserService están implementando la interfaz UserService. Tenemos que seleccionar StaffUserService al inicio del servicio. De lo contrario, Spring Boot lanzará una excepción y se quejará de demasiados candidatos.

Vea el error a continuación...

Description:
Field userService in com.example.demo.UserExecutor required a single bean, but 2 were found:
 - adminUserService: defined in file [/home/salitha/Downloads/demo/target/<b>class</b>es/com/example/demo/AdminUserService.<b>class</b>]
 - staffUserService: defined in file [/home/salitha/Downloads/demo/target/<b>class</b>es/com/example/demo/StaffUserService.<b>class</b>]
Action:
Consider marking one of the beans as @Primary, updating the consumer to accept multiple beans, or using @Qualifier to identify the bean that should be consumed

Así que deberíamos poner la anotación de calificador después de Autowired para resolver este problema:

@Autowired 
@Qualifier(<font>"staffUserService"</font><font>) 
<b>private</b> UserService userService;
</font>

Ejemplo de configuración de clase Java para probar esto:

<b>import</b> org.springframework.beans.factory.annotation.Autowired;
<b>import</b> org.springframework.beans.factory.annotation.Qualifier;
<b>import</b> org.springframework.boot.SpringApplication;
<b>import</b> org.springframework.boot.autoconfigure.SpringBootApplication;
<b>import</b> org.springframework.context.annotation.AnnotationConfigApplicationContext;
<b>import</b> org.springframework.context.annotation.ComponentScan;
<b>import</b> org.springframework.context.annotation.Configuration;
<b>import</b> org.springframework.stereotype.Component;
<b>import</b> org.springframework.stereotype.Service;

<b>import</b> javax.annotation.PostConstruct;

@SpringBootApplication
<b>public</b> <b>class</b> DemoApplication {
   <b>public</b> <b>static</b> <b>void</b> main(String args) {
      SpringApplication.run(DemoApplication.<b>class</b>, args);
   }
}

<b>interface</b> UserService {
   <b>void</b> login();
}

@Service
<b>class</b> AdminUserService implements UserService {
   @Override
   <b>public</b> <b>void</b> login() {
      System.out.println(<font>"Admin Login"</font><font>);
   }
}

@Service
<b>class</b> StaffUserService  implements UserService {
   @Override
   <b>public</b> <b>void</b> login() {
      System.out.println(</font><font>"Staff Login"</font><font>);
   }
}

@Configuration
@ComponentScan(</font><font>"com.example.demo"</font><font>)
<b>class</b> AppConfig {
   @Autowired
   UserExecutor userExecutor;

   @PostConstruct
   <b>void</b> testBeans() {
      userExecutor.getLogin();
   }
}

@Component
<b>class</b> UserExecutor {
   @Autowired
   @Qualifier(</font><font>"staffUserService"</font><font>)
   <b>private</b> UserService userService;
   <b>public</b> <b>void</b> getLogin() {
      userService.login();
   }
}
</font>

13. ¿Se puede reemplazar el servidor Tomcat en el proyecto Spring Boot?

Sí. Podemos eliminar el servidor Tomcat si es necesario agregando exclusión maven en POM. De hecho, el servidor web está incluido en la dependencia de inicio Spring Boot de la web iniciada. Se deben agregar exclusiones.

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

Luego tenemos que agregar cualquier otro servidor (como Jetty) al POM. De todos modos, tenemos que agregar un servidor web después de eliminar Tomcat.

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

Ahora verá los registros del servidor Jetty en lugar de Tomcat.

2022-08-03 13:22:12.551 INFO 57495 --- [main] osbweb.embedded.jetty.JettyWebServer：Jetty 在端口 8080 (http/1.1) 上启动，上下文路径为“/”

14. ¿Cuál es la diferencia entre "@PathVariable" y "@RequestParam"?

PathVariable: use parámetros separados por "/" cuando establezcamos el punto final de la API.

@GetMapping(path = <font>"/profile/{username}"</font><font>) 
<b>public</b> ResponseEntity<?> getUser( @PathVariable(</font><font>"username"</font><font>) String username) { 
    <b>return</b> ResponseEntity.ok().body(authService.findUserByUsername(username)); 
}
</font>

API 端点:
http://localhost/api/profile/salitha

RequestParam: se usa cuando configuramos el punto final de la API, los parámetros de consulta están separados por "&" y comienzan con "?".

@GetMapping(path = <font>"/confirm"</font><font>) 
<b>public</b> ResponseEntity<?> confirmUser( @RequestParam(</font><font>"token"</font><font>) String token) { 
    <b>return</b> ResponseEntity. ok ().body(authService.confirmUser(token)); 
}
</font>

Referencia de la API:
http://localhost/api/profile?token=12345678

15. ¿Cuál es el uso de la anotación "@Primary"?

@Primary indica que se debe dar prioridad a un bean cuando varios candidatos son elegibles para autoconectar una dependencia de un solo valor.

17. ¿Cómo validar las solicitudes entrantes y notificar a los usuarios de los errores?

Hay varios pasos principales que deben realizarse para esto. Si seguimos estos, es solo cuestión de validar la solicitud.

1. Hemos agregado la dependencia de validación del habilitador al POM.

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

2. Agregue la anotación "@Valid" antes de la anotación "RequestBody".

3. Cree un DTO separado para que la solicitud muestre mensajes de restricción de validación.

4. Cree un controlador de excepciones global usando "@RestControllerAdvice" y maneje MethodArgumentNotValidException en un método separado
.

5. Cree lógica para devolver errores a los usuarios finales según sea necesario. Podemos extraer el mensaje de excepción en esta lógica.es

18. ¿Qué es el actuador Spring Boot?

En pocas palabras, un subproyecto del marco Spring Boot que utiliza puntos finales HTTP para exponer información operativa sobre cualquier aplicación en ejecución.

Esta información incluye métricas de la aplicación, estado de la base de datos conectada, estado de la aplicación, información de beans, seguimientos de solicitudes y más.

Está disponible como una dependencia de inicio. Podemos usar esta biblioteca instalando las siguientes dependencias.

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

19. ¿Cómo lidiar con las excepciones en los microservicios de Spring Boot?

Podemos hacer esto de manera centralizada. Necesitamos una clase de configuración global para predefinir métodos de manejo de excepciones para cada clase de excepción. También podemos usar el propio controlador para definir el código de estado HTTP devuelto.

• Cree un controlador de excepciones global con "@RestControllerAdvice" y maneje cada excepción en un método separado.
• Cree lógica para devolver errores a los usuarios finales según sea necesario. Podemos extraer el mensaje de excepción en esta lógica.

@RestControllerAdvice
<b>public</b> <b>class</b> GlobalExceptionHandler {

    @ExceptionHandler(MethodArgumentNotValidException.<b>class</b>)
    <b>public</b> ResponseEntity<Map<String, List<String>>> handleValidationErrors(MethodArgumentNotValidException ex) {
        List<String> errors = ex.getBindingResult().getFieldErrors()
                .stream().map(FieldError::getDefaultMessage).collect(Collectors.toList());
        <b>return</b> <b>new</b> ResponseEntity<>(getErrorsMap(errors), <b>new</b> HttpHeaders(), HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(UserNotFoundException.<b>class</b>)
    <b>public</b> ResponseEntity<Map<String, List<String>>> handleNotFoundException(UserNotFoundException ex) {
        List<String> errors = Collections.singletonList(ex.getMessage());
        <b>return</b> <b>new</b> ResponseEntity<>(getErrorsMap(errors), <b>new</b> HttpHeaders(), HttpStatus.NOT_FOUND);
    }

    @ExceptionHandler(Exception.<b>class</b>)
    <b>public</b> <b>final</b> ResponseEntity<Map<String, List<String>>> handleGeneralExceptions(Exception ex) {
        List<String> errors = Collections.singletonList(ex.getMessage());
        <b>return</b> <b>new</b> ResponseEntity<>(getErrorsMap(errors), <b>new</b> HttpHeaders(), HttpStatus.INTERNAL_SERVER_ERROR);
    }

    @ExceptionHandler(RuntimeException.<b>class</b>)
    <b>public</b> <b>final</b> ResponseEntity<Map<String, List<String>>> handleRuntimeExceptions(RuntimeException ex) {
        List<String> errors = Collections.singletonList(ex.getMessage());
        <b>return</b> <b>new</b> ResponseEntity<>(getErrorsMap(errors), <b>new</b> HttpHeaders(), HttpStatus.INTERNAL_SERVER_ERROR);
    }

    <b>private</b> Map<String, List<String>> getErrorsMap(List<String> errors) {
        Map<String, List<String>> errorResponse = <b>new</b> HashMap<>();
        errorResponse.put(<font>"errors"</font><font>, errors);
        <b>return</b> errorResponse;
    }

}
</font>

20. ¿Cuál es la diferencia entre las anotaciones "@Entity" y "@Table"?

Las entidades representan las clases que usará en su programa y las tablas representan las tablas de la base de datos real a las que accederá a través de su programa.

Las anteriores son las preguntas más completas que se harán en más del 90 % de las entrevistas. Si necesita una versión completa del archivo PDF, puede hacer [ clic ]