La anotación @EnableWebSecurity y para qué sirve

Spring Security es una herramienta realmente potente, pero para empezar a usarla en tu proyecto tienes que activar el mecanismo de seguridad. La anotación @EnableWebSecurity, como imaginarás por el nombre, sirve justamente para eso.

En pocas palabras, @EnableWebSecurity:

• habilita la posibilidad de usar Spring Security en tu aplicación.
• activa las configuraciones de seguridad vía la clase WebSecurityConfigurerAdapter o directamente mediante SecurityFilterChain.
• inicializa los filtros de Spring Security para procesar todas las peticiones HTTP entrantes.

Sin añadirla, Spring Security estará en tu proyecto como una pieza de museo — estética, pero poco útil. Vamos a ver cómo funciona y por qué es tan importante.

¿Qué pasa después de añadir @EnableWebSecurity?

¿Sabes qué pasa cuando añades @EnableWebSecurity en tu código? ¡Spring Security se despierta y empieza a proteger tu aplicación! Veamos qué hay bajo el capó de esta magia:

1. Spring crea una cadena de filtros de seguridad — como un control de acceso para todas las peticiones entrantes. Cada petición ahora pasa por este sistema de seguridad antes de llegar a tu aplicación.
2. Spring Security habilita de inmediato una protección básica — como poner cerraduras en todas las puertas. Por defecto, todos los recursos HTTP quedan cerrados, y sin las "llaves" correctas (autenticación) no se puede acceder.
3. Y lo más interesante: ¡puedes configurar este sistema a tu gusto! ¿Quieres añadir comprobaciones propias? Usa SecurityFilterChain.

Y si te interesa la historia, antes se usaba WebSecurityConfigurerAdapter (aunque desde la versión 5.7 ya se considera antiguo).

Fundamentos de configuración con @EnableWebSecurity

Aquí tienes un ejemplo de configuración mínima de seguridad:

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    // Por ahora la configuración está vacía, ¡pero toda la seguridad ya está activada!
}

Si ejecutas esa aplicación y tratas de acceder a cualquiera de tus URLs de recursos o controladores, verás que Spring Security te redirige automáticamente a la página de login. Ese comportamiento es el predeterminado.

Personalización de la configuración

Vamos a añadir algo de personalización útil. Para eso podemos definir una configuración usando un bean de SecurityFilterChain:

Ejemplo con reglas personalizadas:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeRequests() // Configuramos la autorización de peticiones
                .antMatchers("/public/**").permitAll() // Permitimos acceso a todas las URL que empiezan con /public
                .anyRequest().authenticated() // Todas las demás peticiones requieren autenticación
            .and()
            .formLogin() // Activamos el formulario de login estándar
                .loginPage("/login") // Página de login personalizada
                .permitAll()
            .and()
            .logout() // Activamos logout estándar
                .permitAll();
        return http.build();
    }
}

Veamos qué hace este código:

1. Restricción de acceso por URL: los métodos antMatchers permiten definir acceso basado en URLs concretas. Por ejemplo, todas las peticiones a /public están permitidas sin autenticación.
2. Formulario de login: hemos personalizado el formulario estándar indicando nuestra página de login con loginPage. Ahora, en vez de la página de login por defecto, los usuarios verán tu interfaz personalizada.
3. Logout: permitimos a cualquier usuario realizar logout.

Tras añadir esta configuración, tu aplicación estará protegida de forma más razonable que con la configuración básica de Spring Security.

¿Para qué servía WebSecurityConfigurerAdapter?

Ya hemos mencionado que hasta la versión 5.7 la personalización normalmente se hacía heredando de WebSecurityConfigurerAdapter. Así era:

import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/public/**").permitAll()
                .anyRequest().authenticated()
            .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
            .and()
            .logout()
                .permitAll();
    }
}

Si aún ves ese enfoque en código antiguo, no te asustes. Pero mejor acostúmbrate a usar SecurityFilterChain, porque es el enfoque más moderno.

Ejemplos de configuración de seguridad básica

1. Ejemplo sencillo donde todas las páginas están protegidas:

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .anyRequest().authenticated()
            .and()
            .formLogin() // Habilitar el formulario de login
            .and()
            .httpBasic(); // Esto añade soporte para autenticación básica
        return http.build();
    }
}

Ahora, al intentar acceder a cualquier recurso, el usuario tendrá que introducir usuario/contraseña en el navegador o autenticarse vía HTTP Basic.

2. Ejemplo con recursos públicos:

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/css/**", "/js/**", "/images/**").permitAll() // Abrimos recursos estáticos
                .antMatchers("/", "/home").permitAll() // Hacemos pública la página principal
                .anyRequest().authenticated()
            .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
            .and()
            .logout()
                .permitAll();
        return http.build();
    }
}

Este ejemplo permite ver ciertos recursos públicos (por ejemplo, assets estáticos o la página principal), pero protege el resto.

Errores comunes y cómo solucionarlos

1. Error: están bloqueados todos los recursos, incluida la página de login. Si configuras todo mal, puedes bloquear incluso el acceso a tu propia página de login. Asegúrate de que la página de login (u otros recursos públicos) tenga acceso explícitamente permitido con permitAll().
2. Error: olvidaste añadir @EnableWebSecurity. Sin esta anotación, tu configuración no se aplicará y la aplicación simplemente no estará protegida.
3. Error: usas el enfoque obsoleto WebSecurityConfigurerAdapter. Con el cambio a SecurityFilterChain muchos ejemplos en Internet pueden confundirte. Usa versiones más recientes de Spring Security para evitar problemas de compatibilidad.

Práctica: configurar una configuración básica

Añadamos seguridad a nuestra app de ejemplo. Imagina que tenemos una app web para gestionar libros. Necesitamos:

1. Hacer una página de login.
2. Permitir a todos los usuarios acceso a las páginas /login y /register.
3. Proteger el acceso al resto de páginas.

Configuración:

@Configuration
@EnableWebSecurity
public class BookAppSecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/login", "/register").permitAll() // Acceso para todos
                .anyRequest().authenticated() // Todo lo demás requiere autenticación
            .and()
            .formLogin() // Activamos el formulario de login estándar
                .loginPage("/login") // Indicamos la página de login personalizada
                .permitAll()
            .and()
            .logout()
                .permitAll(); // Logout accesible para todos
        return http.build();
    }
}

Ahora nuestra aplicación está segura: puedes registrarte o iniciar sesión, pero sin autorización el acceso al resto de páginas está cerrado.

Enlace a la documentación de Spring Security para profundizar.