Skip to content

6. Ámbitos de los datos

Una aplicación web atiende a muchos usuarios a la vez, y cada uno de ellos realiza numerosas solicitudes. Por lo tanto, los datos pueden compartirse en tres niveles, conocidos como su ámbito (scope):

  • ámbito de aplicación (application): los datos son compartidos por todos los usuarios durante toda la vida del servidor (por ejemplo, la lista de médicos);
  • ámbito de solicitud (request): los datos existen solo durante una solicitud (el modelo de una vista);
  • ámbito de cliente (client): los datos son específicos de un usuario y deben persistir de una solicitud a la siguiente (el idioma seleccionado, el usuario conectado).

Las aplicaciones web han usado durante mucho tiempo las sesiones para este último ámbito: un espacio de memoria, mantenido por el servidor, específico de cada navegador y recuperado mediante una cookie de identificación ([JSESSIONID] en [Java]). [Spring MVC] todavía lo usa de forma predeterminada para los atributos Flash (ejemplo 20). Sin embargo, el caso de estudio no lo utiliza, ni tampoco los ejemplos de este documento (salvo los atributos Flash en algunos ejemplos, como los ejemplos 20 y 21): los datos del lado del cliente los almacena el navegador en cookies. El servidor no guarda nada entre dos solicitudes del mismo usuario: se dice que es sin estado ([stateless]). Esto es lo que permite, por ejemplo, ejecutar varios servidores idénticos detrás de un balanceador de carga. La contrapartida: una cookie está bajo el control del usuario, quien puede leerla y modificarla. Por lo tanto, solo se almacenan en ella datos no sensibles, o datos firmados o cifrados por el servidor, que de este modo puede detectar cualquier modificación: este es el caso del token de autenticación (capítulo 8).

Del lado del servidor, los ámbitos de aplicación y de solicitud corresponden a los ámbitos de los beans de [Spring] (véase el ejemplo 06). Un bean es creado y mantenido por [Spring]; su ámbito especifica cuántas instancias se crean y durante cuánto tiempo. Tres de ellos nos interesan:

Anotación
Ámbito
Una instancia...
(ninguna)
singleton
durante toda la vida de la aplicación, compartida por todas las solicitudes. Este es el ámbito predeterminado
[@RequestScope]
request
por solicitud HTTP, compartida por todos los que la requieran durante esa solicitud
[@Scope("prototype")]
prototype
Cada vez que se solicita el bean a [Spring]: dos solicitudes, dos instancias

Estos son los ciclos de vida [Singleton], [Scoped], y [Transient] de [ASP.NET Core]. También existe un ámbito de sesión ([@SessionScope]), que no usaremos.

6.1. Ejemplo 23: Tres ámbitos

23-scopes/
├── src/main/java/example23/
│   ├── config/
│   │   ├── StartFilter.java
│   │   └── WebConfig.java
│   ├── controllers/
│   │   └── ScopesController.java
│   ├── services/
│   │   ├── CounterService.java
│   │   ├── ToolService.java
│   │   └── RequestService.java
│   └── Example23Application.java
├── src/main/resources/
│   ├── templates/scopes/
│   │   └── scopes.html
│   └── application.properties
└── pom.xml

Los archivos [pom.xml], [application.properties], [Example23Application.java], y [WebConfig.java] (que simplemente sirve los archivos de [Bootstrap]) son los de los ejemplos anteriores.

6.1.1. Los tres beans

El archivo [services/CounterService.java]:

package example23.services;

import java.util.concurrent.atomic.AtomicInteger;

import org.springframework.stereotype.Service;

// ámbito APPLICATION (singleton, el ámbito por defecto de los beans): una única
// instancia, compartida por TODAS las solicitudes de TODOS los usuarios
@Service
public class CounterService {

    // varias solicitudes pueden ejecutarse AL MISMO TIEMPO: AtomicInteger
    // garantiza que dos incrementos simultáneos no se pierdan
    private final AtomicInteger total = new AtomicInteger();

    public int increment() {
        return total.incrementAndGet();
    }
}
  • línea 9: un bean, sin ninguna otra especificación: es un singleton. Por lo tanto, su campo [total] tiene ámbito de aplicación;
  • Líneas 14-18: un servidor web procesa varias solicitudes simultáneamente en varios hilos ([threads]). Si dos solicitudes ejecutan [total++] al mismo tiempo, ambas pueden leer el mismo valor y un incremento se pierde. Un [AtomicInteger] es un entero que el método [incrementAndGet] lee, incrementa y vuelve a escribir en una única operación indivisible. Un bean singleton siempre debe desconfiar de esos accesos concurrentes.

El archivo [services/RequestService.java]:

package example23.services;

import java.util.concurrent.atomic.AtomicInteger;

import org.springframework.stereotype.Service;
import org.springframework.web.context.annotation.RequestScope;

// ámbito REQUEST (@RequestScope): una instancia NUEVA por cada solicitud HTTP,
// compartida por todos los que la piden DURANTE esta solicitud
@Service
@RequestScope
public class RequestService {

    // static: un contador compartido por todas las instancias
    private static final AtomicInteger CREATED_INSTANCES = new AtomicInteger();

    private final int number = CREATED_INSTANCES.incrementAndGet();

    public int getNumber() {
        return number;
    }
}
  • línea 11: la anotación [@RequestScope] da al bean el ámbito "request";
  • línea 15: un campo [static] pertenece a la clase, no a una instancia; es compartido por todas las instancias. Cuenta el número de instancias creadas;
  • línea 17: a cada instancia se le asigna un número al crearse. Como el bean tiene ámbito de solicitud, el número cambia con cada solicitud.

El archivo [services/ToolService.java]:

package example23.services;

import java.util.concurrent.atomic.AtomicInteger;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;

// ámbito PROTOTYPE: una instancia NUEVA CADA vez que se solicita el bean a Spring
@Service
@Scope("prototype")
public class ToolService {

    private static final AtomicInteger CREATED_INSTANCES = new AtomicInteger();

    private final int number = CREATED_INSTANCES.incrementAndGet();

    public int getNumber() {
        return number;
    }
}

El mismo contador de instancias, para un bean con ámbito [prototype] (línea 10).

6.1.2. Datos con ámbito de solicitud: los atributos de la solicitud

El archivo [config/StartFilter.java]:

package example23.config;

import java.io.IOException;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

// un filtro (vea el capítulo 7): se ejecuta por cada solicitud, ANTES de Spring MVC.
// Ámbito REQUEST: los atributos de la solicitud nacen y mueren con ella.
@Component
public class StartFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain next)
            throws ServletException, IOException {
        request.setAttribute("start", LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS")));
        next.doFilter(request, response); // se cede el control al resto
    }
}
  • Líneas 17-18: un filtro de servlet (el próximo capítulo los describe en detalle). Procesa cada solicitud antes que [Spring MVC]. La clase [OncePerRequestFilter] de [Spring] garantiza que se ejecute una sola vez por solicitud; la anotación [@Component] basta para que [Spring Boot]lo agregue a la cadena de filtros;
  • Línea 23: el filtro almacena la hora de recepción de la solicitud en un atributo de solicitud. El objeto [HttpServletRequest] contiene un diccionario de atributos, que se crea y se destruye junto con la solicitud: todo lo que la procesa (filtros, controlador, vista) puede leerlo y escribir en él. Es el equivalente de [HttpContext.Items] de [ASP.NET Core];
  • línea 24: el filtro pasa el control al siguiente paso: los demás filtros y luego [Spring MVC].

6.1.3. El controlador

El archivo [controllers/ScopesController.java]:

package example23.controllers;

import org.springframework.beans.factory.ObjectProvider;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseCookie;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.CookieValue;
import org.springframework.web.bind.annotation.GetMapping;

import example23.services.CounterService;
import example23.services.ToolService;
import example23.services.RequestService;
import jakarta.servlet.http.HttpServletResponse;

// un controlador es en sí mismo un bean SINGLETON: se crea una sola vez
@Controller
public class ScopesController {

    private final CounterService counter;
    // un bean de ámbito request inyectado en un singleton: Spring inyecta un
    // "proxy", que reenvía cada llamada a la instancia de la solicitud ACTUAL
    private final RequestService request;
    // un prototype inyectado en un singleton: se crea UNA SOLA VEZ, junto con el controlador
    private final ToolService injectedTool;
    // para obtener un nuevo prototype cada vez: pídaselo a Spring
    private final ObjectProvider<ToolService> tools;

    public ScopesController(CounterService counter, RequestService request, ToolService injectedTool,
            ObjectProvider<ToolService> tools) {
        this.counter = counter;
        this.request = request;
        this.injectedTool = injectedTool;
        this.tools = tools;
    }

    public record ScopesModel(int total, int instance, int injectedTool, int requestedTool, int myVisits) {
    }

    @GetMapping("/")
    public String scopes(@CookieValue(name = "myVisits", required = false) String cookie,
            HttpServletResponse response, Model model) {
        // ámbito CLIENT: un dato conservado por el NAVEGADOR (cookie),
        // reenviado al servidor en cada solicitud
        int myVisits = toInteger(cookie) + 1;
        ResponseCookie newCookie = ResponseCookie.from("myVisits", String.valueOf(myVisits))
                .path("/").httpOnly(true).sameSite("Lax").build();
        response.addHeader(HttpHeaders.SET_COOKIE, newCookie.toString());
        model.addAttribute("model", new ScopesModel(counter.increment(), request.getNumber(),
                injectedTool.getNumber(), tools.getObject().getNumber(), myVisits));
        return "scopes/scopes";
    }

    // "41" -> 41; null o "abc" -> 0
    private static int toInteger(String text) {
        try {
            return Integer.parseInt(text);
        } catch (NumberFormatException e) {
            return 0;
        }
    }
}

Comentemos este código:

  • Líneas 16-17: un controlador es en sí mismo un bean y, por lo tanto, un singleton: [Spring] lo crea una sola vez e inyecta sus dependencias en ese momento, de una vez por todas (líneas 29-35). Aquí es donde la cosa se pone interesante;
  • línea 20: un singleton inyectado en un singleton, nada fuera de lo común;
  • línea 23: un bean con ámbito de solicitud inyectado en un singleton. Al iniciar, no hay ninguna solicitud activa y, por lo tanto, ninguna instancia de [RequestService] que inyectar. En su lugar, [Spring] inyecta un proxy (un intermediario): un objeto que tiene los mismos métodos que [RequestService] y que reenvía cada llamada a la instancia de la solicitud actual, creada según sea necesario. Esto es lo que hace [@RequestScope];
  • línea 25: un bean prototype inyectado en un singleton. [Spring] crea una instancia... una sola, durante la inyección. El controlador la conservará durante toda su vida: este campo nunca cambia. Esta es la trampa del ámbito prototype: crea una nueva instancia solo con cada solicitud al contenedor de [Spring], y un singleton solicita sus dependencias una sola vez;
  • línea 27: para obtener una nueva instancia cada vez, el controlador recibe un [ObjectProvider<ToolService>], un objeto capaz de solicitar un [ToolService] a [Spring] siempre que sea necesario, mediante su método [getObject()] (línea 50);
  • línea 37: el modelo de la vista, un record (véase el ejemplo 03);
  • Línea 41: el ámbito de cliente, un contador almacenado en una cookie. La anotación [@CookieValue] vincula el parámetro a la cookie [myVisits] enviada por el navegador; [required = false]: el parámetro toma el valor [null] si falta la cookie (en la primera visita);
  • línea 45: el contador del navegador, incrementado en 1. El método [toInteger] (líneas 55-61) convierte el texto de la cookie en un entero; [Integer.parseInt] lanza una [NumberFormatException] si el texto no es un entero o si es igual a [null]: el contador se reinicia entonces en 0;
  • líneas 46-48: la cookie se vuelve a establecer con su nuevo valor. [ResponseCookie] es una clase de [Spring] que genera el valor de un encabezado [Set-Cookie]: los métodos que establecen sus características (ruta, [HttpOnly], [SameSite]) se llaman de forma secuencial y luego [build()] crea el objeto. El encabezado se agrega a la respuesta mediante [response.addHeader];
  • líneas 49-50: se pasan valores a la vista: el contador de la aplicación, el número de instancia de [RequestService] para la solicitud actual, el número de instancia del prototype inyectado, el número de instancia de un prototype solicitado en ese momento y el contador del cliente.

6.1.4. La vista

El archivo [templates/scopes/scopes.html]:

<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="utf-8">
  <title>Scopes</title>
  <link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
</head>
<body>
  <div class="container py-3" th:object="${model}">
    <h1 class="h3">The scopes of data</h1>
    <!--/* @requestService, @toolService: la vista también pide a Spring los beans,
           durante la MISMA solicitud */-->
    <ul>
      <li>application: [[*{total}]] visit(s) to the site, all browsers combined</li>
      <li>request: instance no. [[*{instance}]] of RequestService (no. [[${@requestService.number}]] in the view),
        request received at [[${start}]]</li>
      <li>prototype: instance no. [[*{injectedTool}]] (injected into the controller),
        no. [[*{requestedTool}]] (requested by the controller), no. [[${@toolService.number}]] (requested by the view)</li>
      <li>client: [[*{myVisits}]] visit(s) from this browser</li>
    </ul>
  </div>
</body>
</html>
  • línea 9: [th:object] (véanse los ejemplos 18 y 19) hace referencia al objeto [model]; las expresiones [*{...}] de las etiquetas hijas hacen referencia a sus propiedades: [*{total}] equivale a [${model.total}];
  • línea 14: [[[...]]] inserta el valor de una expresión en el texto, escapado, igual que lo haría [th:text] (véase el ejemplo 14);
  • Líneas 15 y 18: la expresión [${@name}] hace referencia al bean con ese nombre (véase el ejemplo 16). A su vez, la vista solicita los beans [requestService] y [toolService] a [Spring] durante la misma solicitud que la acción: podremos comparar las instancias recibidas por el controlador y por la vista;
  • línea 16: el atributo de solicitud establecido por el filtro. Para [Thymeleaf], los atributos de la solicitud son variables como cualquier otra.

6.1.5. Ejecución

Una página, en la URLhttp://localhost:5000/:

Image

Simulemos dos navegadores con [curl] y dos archivos de cookies, [a.txt] y [b.txt]: la opción [-b] envía las cookies del archivo, mientras que la opción [-c] guarda en el archivo las cookies establecidas por el servidor. El navegador A realizó dos solicitudes, luego el navegador B realizó una y después A realizó una última solicitud (el servidor acaba de reiniciarse):

1
2
3
4
curl -c a.txt -b a.txt http://localhost:5000/
curl -c a.txt -b a.txt http://localhost:5000/
curl -c b.txt -b b.txt http://localhost:5000/
curl -c a.txt -b a.txt http://localhost:5000/
browser A:
<li>application: 1 visit(s) to the site, all browsers combined</li>
<li>request: instance no. 1 of RequestService (no. 1 in the view),
request received at 18:47:52.627</li>
<li>prototype: instance no. 1 (injected into the controller),
no. 2 (requested by the controller), no. 3 (requested by the view)</li>
<li>client: 1 visit(s) from this browser</li>

browser A:
<li>application: 2 visit(s) to the site, all browsers combined</li>
<li>request: instance no. 2 of RequestService (no. 2 in the view),
request received at 18:47:53.015</li>
<li>prototype: instance no. 1 (injected into the controller),
no. 4 (requested by the controller), no. 5 (requested by the view)</li>
<li>client: 2 visit(s) from this browser</li>

browser B:
<li>application: 3 visit(s) to the site, all browsers combined</li>
<li>request: instance no. 3 of RequestService (no. 3 in the view),
request received at 18:47:53.099</li>
<li>prototype: instance no. 1 (injected into the controller),
no. 6 (requested by the controller), no. 7 (requested by the view)</li>
<li>client: 1 visit(s) from this browser</li>

browser A:
<li>application: 4 visit(s) to the site, all browsers combined</li>
<li>request: instance no. 4 of RequestService (no. 4 in the view),
request received at 18:47:53.133</li>
<li>prototype: instance no. 1 (injected into the controller),
no. 8 (requested by the controller), no. 9 (requested by the view)</li>
<li>client: 3 visit(s) from this browser</li>

(solo se muestran los elementos de la lista). Observamos que:

  • el contador de la aplicación cuenta todas las visitas: 1, 2, 3, 4;
  • cada solicitud tiene su propia instancia de [RequestService]: 1, 2, 3, 4. Durante una solicitud, el controlador (a través de su proxy) y la vista acceden a la misma instancia;
  • el prototype inyectado en el controlador es siempre el n.º 1: creado al iniciar junto con el controlador, nunca será reemplazado. Los prototypes solicitados son nuevos cada vez: el controlador y la vista reciben dos distintos, y cada solicitud crea dos nuevos;
  • el contador del cliente es propio de cada navegador: A tiene 3 visitas, B tiene 1.

El archivo [a.txt], mantenido por [curl], contiene la cookie del navegador A:

1
2
3
4
5
# Netscape HTTP Cookie File
# https://curl.se/docs/http-cookies.html
# This file was generated by libcurl! Edit at your own risk.

#HttpOnly_localhost    FALSE    /    FALSE    0    myVisits    3

Esta cookie está controlada por el cliente, que puede enviar el valor que desee:

curl -i -b "myVisits=41" http://localhost:5000/
HTTP/1.1 200
Set-Cookie: myVisits=42; Path=/; HttpOnly; SameSite=Lax
Content-Type: text/html;charset=UTF-8

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Scopes</title>
  <link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
</head>
<body>
  <div class="container py-3">
    <h1 class="h3">The scopes of data</h1>

    <ul>
      <li>application: 5 visit(s) to the site, all browsers combined</li>
      <li>request: instance no. 5 of RequestService (no. 5 in the view),
        request received at 18:47:53.178</li>
      <li>prototype: instance no. 1 (injected into the controller),
        no. 10 (requested by the controller), no. 11 (requested by the view)</li>
      <li>client: 42 visit(s) from this browser</li>
    </ul>
  </div>
</body>
</html>

Para un contador de visitas, esto es irrelevante. Para datos sensibles (la identidad del usuario, su rol), el servidor debe poder detectar la manipulación: el capítulo 8 muestra cómo.

De estos ámbitos se deriva una regla: un bean no debe retener un bean con un ámbito más corto. Un singleton que recibiera directamente una instancia con ámbito de solicitud la retendría indefinidamente, mucho más allá de la solicitud para la que se creó. [ASP.NET Core] verifica esta regla al iniciar, en modo de desarrollo, y se niega a arrancar si se infringe. [Spring] adopta un enfoque diferente: para el ámbito de solicitud, [@RequestScope] inyecta un proxy, lo que hace segura la inyección; para el ámbito prototype, no realiza ninguna verificación, y acabamos de ver el resultado: un "prototype" que se comporta como un singleton. Cuando realmente se necesita una nueva instancia, se solicita a [Spring] mediante un [ObjectProvider].

En el caso de estudio:

Ámbito
Datos
¿Dónde?
Aplicación
listas de médicos y de clientes, diccionarios, CAPTCHA pendientes, contadores de intentos
Beans singleton ([ApplicationModel], [Translator], [CaptchaService], [AttemptLimiterService]...); la capa de negocio y el acceso a datos también son singletons sin estado
solicitud
modelo de la vista, usuario conectado
el modelo ([Model]), complementado por [CommonModel]; el contexto de seguridad de [Spring Security]
cliente
token de autenticación, idioma, mensaje flash
cookies