Saltar al contenido principal

Custom Implementation Example

Abrir en ChatGPT

Esta guía explica cómo construir una implementación de seguridad personalizada completa utilizando autenticación basada en sesiones. Aprenderás cómo las cuatro interfaces centrales trabajan juntas al implementarlas desde cero.

La mayoría de las aplicaciones deberían usar Spring Security

La integración de Spring Security configura automáticamente todo lo que se muestra aquí. Solo construye seguridad personalizada si tienes requisitos específicos o no estás utilizando Spring Boot.

Lo que construirás​

Un sistema de seguridad funcional con cuatro clases:

  • SecurityConfiguration - Define el comportamiento de seguridad y las ubicaciones de redirección
  • SecurityContext - Rastrear quién ha iniciado sesión utilizando sesiones HTTP
  • SecurityManager - Coordina las comprobaciones de seguridad y proporciona inicio/cierre de sesión
  • SecurityRegistrar - Conecta todo al inicio de la aplicación

Este ejemplo utiliza almacenamiento basado en sesiones, pero podrías implementar las mismas interfaces utilizando consultas a bases de datos, LDAP o cualquier otro backend de autenticación.

Cómo funcionan juntos los componentes​

Flujo:

  1. SecurityRegistrar se ejecuta al inicio, crea el gestor, registra evaluadores y adjunta el observador
  2. SecurityManager coordina todo: proporciona el contexto y la configuración a los evaluadores
  3. SecurityContext responde "¿Quién ha iniciado sesión?" leyendo desde sesiones HTTP
  4. SecurityConfiguration responde "¿Dónde redirigir?" para páginas de inicio de sesión y acceso denegado
  5. Evaluators toman decisiones de acceso utilizando el contexto y la configuración

Paso 1: Definir la configuración de seguridad​

La configuración le dice al sistema de seguridad cómo comportarse y dónde redirigir a los usuarios:

SecurityConfiguration.java
package com.securityplain.security;

import com.webforj.router.history.Location;
import com.webforj.router.security.RouteSecurityConfiguration;
import java.util.Optional;

/**
 * Configuración de seguridad para la aplicación.
 *
 * <p>
 * Define dónde redirigir a los usuarios cuando se requiere autenticación o se deniega el acceso.
 * </p>
 */
public class SecurityConfiguration implements RouteSecurityConfiguration {

  @Override
  public boolean isEnabled() {
    return true;
  }

  @Override
  public boolean isSecureByDefault() {
    return false;
  }

  @Override
  public Optional<Location> getAuthenticationLocation() {
    return Optional.of(new Location("/login"));
  }

  @Override
  public Optional<Location> getDenyLocation() {
    return Optional.of(new Location("/access-denied"));
  }
}
  • isEnabled() = true - La seguridad está activa
  • isSecureByDefault() = false - Las rutas son públicas a menos que se anoten (usa true para requerir autenticación en todas las rutas por defecto)
  • /login - A dónde van los usuarios no autenticados
  • /access-denied - A dónde van los usuarios autenticados sin permisos

Paso 2: Implementar el contexto de seguridad​

El contexto rastrea quién está conectado. Esta implementación utiliza sesiones HTTP para almacenar la información del usuario:

SecurityContext.java
package com.securityplain.security;

import com.webforj.Environment;
import com.webforj.router.security.RouteSecurityContext;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.Set;

/**
* Contexto de seguridad basado en sesiones simple.
*
* <p>
* Almacena el principal del usuario y los roles en la sesión HTTP. Esta es una implementación mínima para propósitos educativos.
* </p>
*/
public class SecurityContext implements RouteSecurityContext {
private static final String SESSION_USER_KEY = "security.user";
private static final String SESSION_ROLES_KEY = "security.roles";
private static final String SESSION_ATTRS_KEY = "security.attributes";

Cómo funciona:

  • isAuthenticated() verifica si existe un principal de usuario en la sesión
  • getPrincipal() recupera el nombre de usuario del almacenamiento de sesión
  • hasRole() verifica si el conjunto de roles del usuario contiene el rol especificado
  • getAttribute() / setAttribute() gestionan atributos de seguridad personalizados
  • Environment.getSessionAccessor() proporciona acceso a la sesión seguro para hilos

Paso 3: Crear el gestor de seguridad​

El gestor coordina las decisiones de seguridad. Extiende AbstractRouteSecurityManager, que maneja cadenas de evaluadores y la denegación de acceso:

SecurityManager.java
package com.securityplain.security;

import com.webforj.environment.ObjectTable;
import com.webforj.environment.SessionObjectTable;
import com.webforj.router.Router;
import com.webforj.router.security.AbstractRouteSecurityManager;
import com.webforj.router.security.RouteAccessDecision;
import com.webforj.router.security.RouteSecurityConfiguration;
import com.webforj.router.security.RouteSecurityContext;

import java.util.Set;

/**
* Implementación simple de un gestor de seguridad.
*
* <p>
* Proporciona métodos estáticos para inicio/cierre de sesión y gestiona el contexto de seguridad.
* </p>
*/
public class SecurityManager extends AbstractRouteSecurityManager {

Cómo funciona:

  • Extiende AbstractRouteSecurityManager para heredar la lógica de cadenas de evaluadores
  • Proporciona implementaciones de getConfiguration() y getSecurityContext()
  • Agrega login() para autenticar usuarios y almacenar credenciales en la sesión
  • Agrega logout() para limpiar la sesión y redirigir a la página de inicio de sesión
  • Usa SessionObjectTable para un almacenamiento de sesiones simple
  • Se almacena a sí mismo en ObjectTable para acceso a nivel de aplicación

Paso 4: Conectar todo al inicio​

El registrador conecta todas las piezas cuando la aplicación comienza:

SecurityRegistrar.java
package com.securityplain.security;

import com.webforj.App;
import com.webforj.AppLifecycleListener;
import com.webforj.annotation.AppListenerPriority;
import com.webforj.router.Router;
import com.webforj.router.security.RouteSecurityObserver;
import com.webforj.router.security.evaluator.AnonymousAccessEvaluator;
import com.webforj.router.security.evaluator.DenyAllEvaluator;
import com.webforj.router.security.evaluator.PermitAllEvaluator;
import com.webforj.router.security.evaluator.RolesAllowedEvaluator;

/**
 * Registra componentes de seguridad de ruta durante el inicio de la aplicación.
 *
 * <p>
 * Configura el gestor de seguridad y los evaluadores con el enrutador.
 * </p>
 */
@AppListenerPriority(1)
public class SecurityRegistrar implements AppLifecycleListener {

  /**
   * {@inheritDoc}
   */
  @Override
  public void onWillRun(App app) {
    // Crear gestor de seguridad
    SecurityManager securityManager = new SecurityManager();
    securityManager.saveCurrent(securityManager);

    // Registrar evaluadores incorporados con prioridades
    securityManager.registerEvaluator(new DenyAllEvaluator(), 0);
    securityManager.registerEvaluator(new AnonymousAccessEvaluator(), 1);
    securityManager.registerEvaluator(new PermitAllEvaluator(), 2);
    securityManager.registerEvaluator(new RolesAllowedEvaluator(), 3);

    // Crear observador de seguridad y adjuntarlo al enrutador
    RouteSecurityObserver securityObserver = new RouteSecurityObserver(securityManager);
    Router router = Router.getCurrent();
    if (router != null) {
      router.getRenderer().addObserver(securityObserver);
    }
  }
}

Registrar el oyente:

Crea src/main/resources/META-INF/services/com.webforj.AppLifecycleListener con:

com.securityplain.security.SecurityRegistrar

Esto registra tu AppLifecycleListener para que se ejecute al inicio de la aplicación.

Cómo funciona:

  • Se ejecuta temprano (@AppListenerPriority(1)) para configurar la seguridad antes de que se carguen las rutas
  • Crea el gestor de seguridad y lo almacena globalmente
  • Registra evaluadores incorporados en orden de prioridad (números más bajos se ejecutan primero)
  • Crea el observador que intercepta la navegación
  • Adjunta el observador al enrutador para que las comprobaciones de seguridad ocurran automáticamente

Después de esto, la seguridad está activa para toda la navegación.

Usando tu implementación​

Crear una vista de inicio de sesión​

La siguiente vista utiliza el componente Login.

LoginView.java
package com.securityplain.views;

import com.securityplain.security.SecurityManager;
import com.webforj.component.Composite;
import com.webforj.component.login.Login;
import com.webforj.router.Router;
import com.webforj.router.annotation.FrameTitle;
import com.webforj.router.annotation.Route;
import com.webforj.router.history.Location;
import com.webforj.router.security.annotation.AnonymousAccess;

@Route("/login")
@FrameTitle("Inicio de sesión")
@AnonymousAccess
public class LoginView extends Composite<Login> {
  private Login self = getBoundComponent();

  public LoginView() {
    self.onSubmit(e -> {
      var result = SecurityManager.getCurrent().login(
        e.getUsername(), e.getPassword()
      );
      
      if (result.isGranted()) {
        Router.getCurrent().navigate(new Location("/"));
      } else {
        self.setError(true);
        self.setEnabled(true);
      }
    });

    self.whenAttached().thenAccept(c -> self.open());
  }
}