Descubre los Secretos de Spring: 40 Preguntas para Dominar el Framework

Evaluación completa con código detallado para fortalecer tus habilidades en Spring

Puntos Clave de Esta Evaluación

Conceptos Fundamentales y Avanzados: Preguntas que abarcan IoC, DI, AOP, Spring MVC, Data, Security y Boot.
Ejemplos Prácticos: Desarrollo de código detallado para demostrar la implementación de cada concepto.
Configuración y Buenas Prácticas: Cubre desde la configuración XML y por anotaciones hasta la integración de pruebas y manejo de excepciones.

40 Preguntas de Evaluación de Conocimiento en Spring

A continuación se muestra una lista de 40 preguntas de evaluación que cubren aspectos teóricos y prácticos del framework Spring. Cada pregunta incluye una respuesta completa y, en aquellos casos que requieren desarrollo de código, se presenta un ejemplo detallado.

Preguntas Teóricas Básicas

1. ¿Qué es el framework Spring?

Respuesta: Spring es un framework de código abierto para desarrollar aplicaciones Java empresariales. Proporciona un contenedor IoC (Inversión de Control) que gestiona la creación, configuración y ensamblado de objetos (beans) de manera modular y desacoplada.

2. ¿Cuáles son los principales beneficios de usar Spring?

Respuesta: Entre los beneficios se incluyen la disminución del acoplamiento del código, facilidades para la inyección de dependencias, soporte para AOP (Programación Orientada a Aspectos), manejo de transacciones, y una configuración flexible mediante anotaciones o XML.

3. Define Inversión de Control (IoC) y su importancia en Spring.

Respuesta: IoC es un principio de diseño en el que el control de creación y gestión de objetos se transfiere a un contenedor. En Spring, el contenedor IoC permite a los desarrolladores producir aplicaciones más modulares y fácilmente testeables, administrando la inyección de dependencias de forma automática.

4. ¿Qué es la Inyección de Dependencias (DI) en Spring?

Respuesta: DI es un patrón de diseño mediante el cual las dependencias de un objeto se inyectan desde el exterior en lugar de ser instanciadas internamente, permitiendo un acoplamiento más bajo y una mayor facilidad para realizar pruebas unitarias.

5. ¿Cuál es el propósito del archivo `applicationContext.xml` en Spring?

Respuesta: Es utilizado para definir y configurar los beans, así como las dependencias entre ellos. Aunque muchas aplicaciones modernas usan la configuración basada en anotaciones o Java, este archivo sigue siendo fundamental en proyectos más tradicionales.

Spring MVC y Desarrollo Web

6. ¿Qué es Spring MVC y cuáles son sus componentes principales?

Respuesta: Spring MVC es un framework para crear aplicaciones web basadas en el patrón Modelo-Vista-Controlador. Sus componentes clave incluyen el DispatcherServlet (front controller), controladores (@Controller), resolutores de vistas, y modelos que transportan información entre el controlador y la vista.

7. Explica el papel del `DispatcherServlet` en Spring MVC.

Respuesta: El DispatcherServlet actúa como un front controller que intercepta todas las solicitudes HTTP, delegándolas a los controladores adecuados según la configuración y las rutas definidas.

8. ¿Cómo se mapean las solicitudes a métodos en un controlador Spring MVC?

Respuesta: Se utilizan anotaciones como @GetMapping, @PostMapping, @PutMapping y @DeleteMapping para mapear patrones de URL a métodos específicos en el controlador.

9. ¿Cuál es la función de un `ViewResolver` en Spring MVC?

Respuesta: El ViewResolver determina qué tecnología de vistas se usará (por ejemplo, JSP, Thymeleaf) y mapea nombres lógicos de vistas a sus archivos reales.

10. ¿Cómo se validan formularios en Spring MVC?

Respuesta: La validación se realiza utilizando anotaciones de validación de Bean Validation (por ejemplo, @NotNull, @Email) junto con la anotación @Valid en el controlador y el manejo de resultados con BindingResult.

Spring JDBC y Acceso a Datos

11. ¿Qué es Spring JDBC y cuáles son sus ventajas?

Respuesta: Spring JDBC es un módulo que simplifica el acceso a bases de datos usando JDBC. Entre sus ventajas se encuentran la reducción de la complejidad del código y una gestión centralizada de recursos y excepciones.

12. Define el rol de `JdbcTemplate` en Spring.

Respuesta: JdbcTemplate es una clase que simplifica la ejecución de operaciones de JDBC mediante la abstracción del manejo de conexiones, la gestión de excepciones y la iteración sobre ResultSet, lo cual reduce significativamente el código repetitivo.

Spring Data JPA y Repositorios

13. ¿Qué es Spring Data JPA y para qué se utiliza?

Respuesta: Es un módulo que simplifica el acceso a datos mediante JPA (Java Persistence API), permitiendo que las operaciones CRUD se realicen con mínima configuración y reduciendo la necesidad de escribir consultas SQL complejas.

14. ¿Qué es un Repository en Spring Data JPA?

Respuesta: Es una interfaz que extiende JpaRepository y ofrece métodos predeterminados para operaciones CRUD. Además, permite la creación de consultas personalizadas definidas por el nombre de métodos o mediante anotaciones.

15. ¿Cómo se definen métodos de consulta personalizados en un Repository?

Respuesta: Se definen mediante la creación de métodos en la interfaz usando el nombre de la propiedad, por ejemplo, findByNombre(String nombre), o a través de consultas JPQL en la anotación @Query.

Spring Boot y Configuración Rápida

16. ¿Qué es Spring Boot y qué ventajas ofrece?

Respuesta: Spring Boot es un proyecto que facilita la creación de aplicaciones Spring independientes al proporcionar configuraciones automáticas, un conjunto de "starters" (dependencias preconfiguradas) y un servidor embebido para simplificar la puesta en producción.

17. ¿Cómo se crea una aplicación Spring Boot usando Spring Initializr?

Respuesta: Se puede crear utilizando el portal web de Spring Initializr (start.spring.io), donde se seleccionan las dependencias necesarias y se genera un proyecto base que se importa en el IDE de preferencia.

18. Explica la auto-configuración en Spring Boot

Respuesta: La auto-configuración permite a Spring Boot configurar automáticamente la aplicación basada en las dependencias presentes en el classpath. Esto significa que se configuran beans y componentes sin la necesidad de definiciones manuales en archivos XML o clases de configuración complejas.

19. ¿Qué son los Starters en Spring Boot?

Respuesta: Los Starters son colecciones de dependencias predefinidas que facilitan la incorporación de funcionalidades específicas (como web, JPA, seguridad) sin necesidad de definir manualmente cada dependencia.

20. ¿Cómo se ejecuta una aplicación Spring Boot?

Respuesta: Se puede ejecutar usando el comando mvn spring-boot:run en Maven o ejecutando directamente el archivo JAR generado (por ejemplo, java -jar mi-aplicacion.jar).

Spring Security y Autenticación

21. ¿Qué es Spring Security?

Respuesta: Es un framework que proporciona autenticación y autorización para aplicaciones basadas en Spring. Permite definir roles, reglas de acceso y proteger endpoints en aplicaciones web o APIs REST.

22. Menciona las principales funcionalidades de Spring Security.

Respuesta: Autenticación, autorización basada en roles y permisos, protección contra ataques CSRF, integración con OAuth2 y manejo de sesiones seguras.

23. ¿Cómo se configura la autenticación básica en Spring Security?

Respuesta: Usando una clase que extienda WebSecurityConfigurerAdapter y configurando los endpoints y los roles en el método configure(HttpSecurity http). Se puede emplear autenticación HTTP básica, formularios o tokens.

24. Diferencia entre `@Autowired` y `@Inject`.

Respuesta: Ambas sirven para inyectar dependencias. @Autowired es específica de Spring y ofrece funcionalidades adicionales como la inyección por nombre y cantidad, mientras que @Inject es parte de la especificación de Java.

25. ¿Cómo se protege un endpoint de API REST usando Spring Security?

Respuesta: Se configura en el método configure(HttpSecurity http) definiendo patrones de URL y restringiendo el acceso a usuarios autenticados o con roles específicos, habilitando autenticación básica o basada en tokens.

Preguntas Prácticas con Desarrollo de Código

26. Crear un servicio CRUD para gestionar una entidad `Usuario` usando Spring Data JPA.

Respuesta: Se debe definir la entidad, el repositorio y luego un servicio que encapsule la lógica CRUD.


// Entidad Usuario
@Entity
public class Usuario {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String nombre;
    private String email;
    // Getters y Setters
}

// Repositorio
public interface UsuarioRepository extends JpaRepository<Usuario, Long> {
    List<Usuario> findByNombre(String nombre);
}

// Servicio
@Service
public class UsuarioService {
    @Autowired
    private UsuarioRepository usuarioRepository;

    public Usuario crearUsuario(Usuario usuario) {
        return usuarioRepository.save(usuario);
    }

    public List<Usuario> obtenerUsuarios() {
        return usuarioRepository.findAll();
    }

    public Usuario actualizarUsuario(Usuario usuario) {
        return usuarioRepository.save(usuario);
    }

    public void eliminarUsuario(Long id) {
        usuarioRepository.deleteById(id);
    }
}

27. Crear un controlador REST que devuelva el mensaje "Hola Mundo".

Respuesta: Se definirá un controlador con la anotación @RestController y un método mapeado a la ruta /hello.


@RestController
public class HelloWorldController {
    @GetMapping("/hello")
    public String hello() {
        return "Hola Mundo";
    }
}

28. Crear un interceptor en Spring MVC para registrar información de las solicitudes.

Respuesta: Se implementa la interfaz HandlerInterceptor y se configura en la clase que implementa WebMvcConfigurer.


@Component
public class LogInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws Exception {
        System.out.println("Request URI: " + request.getRequestURI());
        return true;
    }
}

@Configuration
public class AppConfig implements WebMvcConfigurer {
    @Autowired
    private LogInterceptor logInterceptor;
  
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(logInterceptor).addPathPatterns("/**");
    }
}

29. Implementar un ejemplo de inyección de dependencias vía constructor.

Respuesta: Se crea un servicio que dependa de otro componente y la inyección se realiza por medio del constructor.


@Service
public class EmployeeService {
    private final Department department;
  
    @Autowired
    public EmployeeService(@Qualifier("ITDepartment") Department department) {
        this.department = department;
    }
}

@Component("ITDepartment")
public class ITDepartment implements Department {
    // Implementaciones de métodos de la interfaz Department
}

30. Crear un aspecto que registre el tiempo de ejecución de un método.

Respuesta: Se utiliza AOP de Spring para medir y registrar la ejecución de métodos.


@Aspect
@Component
public class PerformanceAspect {
    @Around("execution(* com.example..*(..))")
    public Object measureExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long end = System.currentTimeMillis();
        System.out.println("Execution Time of " + joinPoint.getSignature() + ": " + (end - start) + "ms");
        return result;
    }
}
  
@Configuration
@EnableAspectJAutoProxy
public class AspectConfig {
}

31. Crear un controlador MVC con validación de formularios

Respuesta: Se crea un controlador que procese un formulario con validación, utilizando @Valid y BindingResult.


@Controller
public class FormularioController {
    @PostMapping("/submitForm")
    public String procesarFormulario(@Valid Formulario formulario, BindingResult result, Model model) {
        if(result.hasErrors()){
            return "formulario";
        }
        // Procesar y guardar los datos
        return "redirect:/success";
    }
}
  
@Data
public class Formulario {
    @NotNull(message = "El nombre es obligatorio")
    private String nombre;
  
    @Email(message = "El email debe ser válido")
    private String email;
}

32. Configurar un bean con alcance de sesión en Spring.

Respuesta: Se define un bean con el alcance “session” para que se cree una nueva instancia por sesión de usuario.


@Component
@Scope(value = "session", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class SessionBean {
    private String valor;
    // Métodos getters y setters
}

33. Configurar un scheduler para ejecutar tareas periódicas.

Respuesta: Se utiliza la anotación @Scheduled para programar tareas de forma periódica.


@Component
public class SchedulerTask {
    @Scheduled(fixedDelay = 5000) // Cada 5 segundos
    public void ejecutarTarea() {
        System.out.println("Ejecutando tarea programada: " + new Date());
    }
}

@Configuration
@EnableScheduling
public class SchedulingConfig {
}

34. Implementar un controlador de Spring que maneje la actualización de un usuario (CRUD – UPDATE).

Respuesta: Se define un endpoint REST que actualiza los datos de un usuario existente.


@PutMapping("/usuarios/{id}")
public ResponseEntity<Usuario> actualizarUsuario(@PathVariable Long id, @RequestBody Usuario usuarioDetalles) {
    Usuario usuario = usuarioRepository.findById(id)
        .orElseThrow(() -> new ResourceNotFoundException("Usuario no encontrado"));
    usuario.setNombre(usuarioDetalles.getNombre());
    usuario.setEmail(usuarioDetalles.getEmail());
    Usuario usuarioActualizado = usuarioRepository.save(usuario);
    return ResponseEntity.ok(usuarioActualizado);
}

35. Crear una prueba unitaria utilizando Mockito para el servicio de usuarios.

Respuesta: Se construye un test unitaria para verificar la lógica de guardado de un usuario.


@RunWith(MockitoJUnitRunner.class)
public class UsuarioServiceTest {

    @InjectMocks
    private UsuarioService usuarioService;

    @Mock
    private UsuarioRepository usuarioRepository;

    @Test
    public void testCrearUsuario() {
        Usuario usuario = new Usuario();
        usuario.setNombre("Juan");
        usuario.setEmail("juan@example.com");

        when(usuarioRepository.save(usuario)).thenReturn(usuario);
        Usuario resultado = usuarioService.crearUsuario(usuario);
        assertEquals("Juan", resultado.getNombre());
    }
}

36. Crear un filtro HTTP que capture todas las solicitudes entrantes.

Respuesta: Se implementa la interfaz Filter y se registra mediante FilterRegistrationBean.


@Component
public class CustomFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
        throws IOException, ServletException {
        System.out.println("Custom Filter: Petición recibida");
        chain.doFilter(request, response);
    }
}

@Configuration
public class FilterConfig {
    @Bean
    public FilterRegistrationBean<CustomFilter> registrationBean() {
        FilterRegistrationBean<CustomFilter> registration = new FilterRegistrationBean<>();
        registration.setFilter(new CustomFilter());
        registration.addUrlPatterns("/*");
        return registration;
    }
}

37. Utilizar Spring Security para proteger un endpoint con acceso restringido a un rol específico.

Respuesta: Se crea una configuración de seguridad en Spring definiendo rutas específicas para cada rol.


@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/admin/<b>").hasRole("ADMIN")
            .antMatchers("/user/</b>").hasAnyRole("USER","ADMIN")
            .and()
            .httpBasic();
    }
  
    @Bean
    public BCryptPasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

38. Implementar un proveedor de autenticación personalizado con Spring Security.

Respuesta: Se implementa la interfaz AuthenticationProvider para gestionar la autenticación de manera personalizada.


@Component
public class CustomAuthenticationProvider implements AuthenticationProvider {
    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        String username = authentication.getName();
        String password = String.valueOf(authentication.getCredentials());
      
        // Lógica personalizada para autenticar al usuario
        if("admin".equals(username) && "1234".equals(password)){
            List<GrantedAuthority> authorities = Arrays.asList(new SimpleGrantedAuthority("ROLE_ADMIN"));
            return new UsernamePasswordAuthenticationToken(username, password, authorities);
        } else {
            throw new BadCredentialsException("Usuario o clave incorrecta");
        }
    }
  
    @Override
    public boolean supports(Class<?> authentication) {
        return UsernamePasswordAuthenticationToken.class.isAssignableFrom(authentication);
    }
}

39. Configurar CORS en un controlador de Spring MVC.

Respuesta: Se configura CORS para permitir métodos, orígenes y cabeceras específicas en un controlador o a nivel global.


@Configuration
public class CorsConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
            .allowedOrigins("http://example.com")
            .allowedMethods("GET", "POST", "PUT", "DELETE")
            .allowedHeaders("*");
    }
}

40. Desarrollar un ejemplo de autenticación OAuth2 en Spring Security para asegurar una API REST.

Respuesta: Se configura Spring Security para actuar como un Resource Server utilizando JWT para la autenticación OAuth2.


@Configuration
@EnableResourceServer
public class OAuth2ResourceServerConfig extends ResourceServerConfigurerAdapter {
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/api/public/**").permitAll()
            .anyRequest().authenticated();
    }
}
  
@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
    @Bean
    public TokenStore tokenStore() {
        return new InMemoryTokenStore();
    }
  
    // Otros detalles de configuración de autorización
}

Resumen de las Secciones de Preguntas

Sección	Descripción
Preguntas Teóricas Básicas	Conceptos fundamentales de IoC, DI, configuración, Spring MVC y validación.
Spring JDBC y JPA	Acceso a datos y configuración de Repositories usando Spring Data JPA y JdbcTemplate.
Spring Boot	Configuración rápida y auto-configuración, uso de Starters y despliegue.
Spring Security	Autenticación, autorización, manejo de roles, filtros y proveedores de autenticación.
Desarrollo de Código Práctico	Ejemplos detallados que incluyen controladores, servicios, validación y pruebas unitarias.