Para integrar Spring Security en tu proyecto, el primer paso es asegurarte de tener las dependencias necesarias. Si utilizas Maven, puedes incluirlas en tu archivo pom.xml:

<dependency>
   <groupId>org.springframework.security</groupId>
   <artifactId>spring-security-web</artifactId>
   <version>${spring.security.version}</version>
</dependency>
<dependency>
   <groupId>org.springframework.security</groupId>
   <artifactId>spring-security-config</artifactId>
   <version>${spring.security.version}</version>
</dependency>
<dependency>
   <groupId>org.springframework.security</groupId>
   <artifactId>spring-security-core</artifactId>
   <version>${spring.security.version}</version>
</dependency>
<dependency>
   <groupId>org.springframework.security</groupId>
   <artifactId>spring-security-taglibs</artifactId>
   <version>${spring.security.version}</version>
</dependency>
   

Configuración de web.xml

Es necesario configurar el contexto de Spring para que cargue los archivos de configuración necesarios, incluyendo el de Spring Security. Añade los siguietnes parámetros a tu web.xml:

<!-- Configuración para cargar archivos de contexto -->
<context-param>
   <param-name>contextConfigLocation</param-name>
   <param-value>classpath*:applicationContext.xml,classpath:spring-security.xml</param-value>
</context-param>
   

Además, debes configurar el filtro springSecurityFilterChain para que intercepte todas las solicitudes:

<filter>
   <filter-name>springSecurityFilterChain</filter-name>
   <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
</filter>
<filter-mapping>
   <filter-name>springSecurityFilterChain</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>
   

Creación del archivo spring-security.xml

Este archivo es el corazón de la configuración de Spring Security. Define las reglas de acceso, las páginas de inicio y cierre de sesión, y la autenticación.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:security="http://www.springframework.org/schema/security"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://www.springframework.org/schema/security
   http://www.springframework.org/schema/security/spring-security.xsd">

   <!-- Excluir recursos públicos del filtrado de seguridad -->
   <security:http pattern="/login.jsp" security="none"/>
   <security:http pattern="/failer.jsp" security="none"/>
   <security:http pattern="/css/**" security="none"/>
   <security:http pattern="/img/**" security="none"/>
   <security:http pattern="/plugins/**" security="none"/>

   <!-- Configuración de reglas de acceso -->
   <security:http auto-config="true" use-expressions="false">
       <!-- Interceptar todas las rutas, requiriendo rol USER o ADMIN -->
       <security:intercept-url pattern="/**" access="ROLE_USER,ROLE_ADMIN"/>

       <!-- Configuración del formulario de inicio de sesión -->
       <security:form-login
               login-page="/login.jsp"                    <!-- Página de inicio de sesión -->
               login-processing-url="/login.do"            <!-- URL que procesa el login -->
               default-target-url="/index.jsp"             <!-- URL por defecto tras login exitoso -->
               authentication-failure-url="/failer.jsp"    <!-- URL en caso de fallo de autenticación -->
               authentication-success-forward-url="/pages/main.jsp" <!-- URL a la que se reenvía tras éxito -->
       />

       <!-- Deshabilitar protección CSRF -->
       <security:csrf disabled="true"/>

       <!-- Configuración de cierre de sesión -->
       <security:logout invalidate-session="true" logout-url="/logout.do" logout-success-url="/login.jsp"/>

   </security:http>

   <!-- Gestor de autenticación para usar un servicio de usuario personalizado -->
   <security:authentication-manager>
       <security:authentication-provider user-service-ref="appUserService">
           <!-- Opcional: Configurar un codificador de contraseñas -->
           <!-- <security:password-encoder ref="passwordEncoder"/> -->
       </security:authentication-provider>
   </security:authentication-manager>

   <!-- Bean para el codificador de contraseñas (ejemplo con BCrypt) -->
   <bean id="passwordEncoder" class="org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder"/>

   <!-- Ejemplo de configuración de autenticación en memoria (descomentar para pruebas rápidas) -->
   <!--
   <security:authentication-manager>
       <security:authentication-provider>
           <security:user-service>
               <security:user name="admin" password="{noop}admin" authorities="ROLE_USER"/>
           </security:user-service>
       </security:authentication-provider>
   </security:authentication-manager>
   -->

</beans>
   

Implementación del Servicio de Usuario

Para gestionar la autenticación con datos de usuarios almacenados, se necesita una implementación de la enterfaz UserDetailsService. Este servicio será responsable de cargar los detalles del usuario desde la base de dattos y proporcionarlos a Spring Security.

package com.example.security.service.impl;

import com.example.security.dao.UserDao;
import com.example.security.domain.Role;
import com.example.security.domain.UserInfo;
import com.example.security.service.AppUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;

/**
* Implementación del servicio para cargar detalles del usuario.
*/
@Service("appUserService")
@Transactional
public class AppUserServiceImpl implements AppUserService {

   @Autowired
   private UserDao userDao; // Asume que tienes un DAO para interactuar con la tabla de usuarios

   @Override
   public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
       UserInfo userInfo = userDao.findUserByUsername(username); // Método del DAO para buscar usuario
       if (userInfo == null) {
           throw new UsernameNotFoundException("Usuario no encontrado: " + username);
       }

       // Construcción del objeto User de Spring Security
       // Asegúrate de que el método findUserByUsername devuelva un objeto UserInfo con username, password, y status.
       // El estado (status) se mapea a la propiedad 'enabled' del User de Spring Security.
       // {noop} es un prefijo para indicar que la contraseña no está codificada (para pruebas, usar BCryptPasswordEncoder en producción).
       boolean enabled = userInfo.getStatus() == 1; // Suponiendo que status=1 significa usuario activo
       User springSecurityUser = new User(
               userInfo.getUsername(),
               "{noop}" + userInfo.getPassword(), // Cargar la contraseña (revisar la codificación)
               enabled,
               true, // cuenta no expirará
               true, // credenciales no expirarán
               true, // usuario no bloqueado
               getAuthorities(userInfo.getRoles()) // Roles del usuario
       );

       return springSecurityUser;
   }

   /**
    * Convierte la lista de roles de la aplicación a una lista de SimpleGrantedAuthority.
    * @param roles Lista de roles del usuario.
    * @return Lista de SimpleGrantedAuthority.
    */
   private List<SimpleGrantedAuthority> getAuthorities(List<Role> roles) {
       List<SimpleGrantedAuthority> authorities = new ArrayList<>();
       for (Role role : roles) {
           // Se antepone "ROLE_" a cada nombre de rol para que Spring Security lo reconozca
           authorities.add(new SimpleGrantedAuthority("ROLE_" + role.getRoleName()));
       }
       return authorities;
   }
}