Skip to content

6. Escopos de dados

Uma aplicação web atende muitos usuários ao mesmo tempo, e cada um deles faz numerosas requisições. Os dados podem, portanto, ser compartilhados em três níveis, chamados de escopo:

  • escopo de aplicação: os dados são compartilhados por todos os usuários durante todo o tempo de vida do servidor (a lista de médicos, por exemplo);
  • escopo de requisição: os dados existem apenas durante uma requisição (o modelo de uma view);
  • escopo de cliente: os dados são específicos de um usuário e devem persistir de uma requisição para a seguinte (o idioma escolhido, o usuário conectado).

As aplicações web há muito tempo usam sessões para esse último escopo: um espaço de memória, mantido pelo servidor, específico de cada navegador e recuperado por meio de um cookie de identificação ([JSESSIONID] em [Java]). [Spring MVC] ainda usa isso por padrão para os atributos flash (Exemplo 20). No entanto, o estudo de caso não o utiliza, nem os exemplos deste documento (exceto os atributos flash em alguns exemplos, como os Exemplos 20 e 21): os dados do lado do cliente são armazenados pelo navegador em cookies. O servidor não armazena nada entre duas requisições de um mesmo usuário: diz-se que ele é stateless ([stateless]). É isso que permite, por exemplo, executar vários servidores idênticos atrás de um balanceador de carga. A contrapartida: um cookie está sob o controle do usuário, que pode lê-lo e modificá-lo. Portanto, só se armazenam ali dados não sensíveis, ou dados assinados ou criptografados pelo servidor, que pode então detectar qualquer modificação: é o caso do token de autenticação (Capítulo 8).

No lado do servidor, os escopos de aplicação e de requisição correspondem a os escopos dos beans do [Spring] (veja o Exemplo 06). Um bean é criado e mantido pelo [Spring]; seu escopo especifica quantas instâncias são criadas e por quanto tempo. Três deles nos interessam:

Anotação
Escopo
Uma instância...
(nenhuma)
singleton
durante todo o tempo de vida da aplicação, compartilhada por todas as requisições. É o escopo padrão
[@RequestScope]
request
por requisição HTTP, compartilhada por todos que a solicitarem durante essa requisição
[@Scope("prototype")]
prototype
A cada vez que o bean é solicitado ao [Spring]: duas solicitações, duas instâncias

Esses são os tempos de vida [Singleton], [Scoped] e [Transient] do [ASP.NET Core]. Existe também um escopo de sessão ([@SessionScope]), que não usaremos.

6.1. Exemplo 23: Três escopos

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

Os arquivos [pom.xml], [application.properties], [Example23Application.java], e [WebConfig.java] (que simplesmente serve os arquivos do [Bootstrap]) são os dos exemplos anteriores.

6.1.1. Os três beans

O arquivo [services/CounterService.java]:

package example23.services;

import java.util.concurrent.atomic.AtomicInteger;

import org.springframework.stereotype.Service;

// escopo de APLICAÇÃO (singleton, o escopo padrão dos beans): uma única
// instância, compartilhada por TODAS as requisições de TODOS os usuários
@Service
public class CounterService {

    // várias requisições podem ser executadas AO MESMO TEMPO: AtomicInteger
    // garante que dois incrementos simultâneos não se percam
    private final AtomicInteger total = new AtomicInteger();

    public int increment() {
        return total.incrementAndGet();
    }
}
  • linha 9: um bean, sem nenhuma outra especificação: é um singleton. Seu campo [total] tem, portanto, escopo de aplicação;
  • Linhas 14–18: um servidor web processa várias requisições simultaneamente em várias threads ([threads]). Se duas requisições executarem [total++] ao mesmo tempo, ambas podem ler o mesmo valor, e um incremento se perde. Um [AtomicInteger] é um inteiro que o método [incrementAndGet] lê, incrementa e grava de volta em uma única operação indivisível. Um bean singleton deve sempre desconfiar desses acessos concorrentes.

O arquivo [services/RequestService.java]:

package example23.services;

import java.util.concurrent.atomic.AtomicInteger;

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

// escopo de REQUISIÇÃO (@RequestScope): uma NOVA instância para cada requisição HTTP,
// compartilhada por todos que a solicitam DURANTE essa requisição
@Service
@RequestScope
public class RequestService {

    // static: um contador compartilhado por todas as instâncias
    private static final AtomicInteger CREATED_INSTANCES = new AtomicInteger();

    private final int number = CREATED_INSTANCES.incrementAndGet();

    public int getNumber() {
        return number;
    }
}
  • linha 11: a anotação [@RequestScope] dá ao bean o escopo "request";
  • linha 15: um campo [static] pertence à classe, não a uma instância; é compartilhado por todas as instâncias. Ele conta o número de instâncias criadas;
  • linha 17: cada instância recebe um número ao ser criada. Como o bean tem escopo de requisição, o número muda a cada requisição.

O arquivo [services/ToolService.java]:

package example23.services;

import java.util.concurrent.atomic.AtomicInteger;

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

// escopo PROTOTYPE: uma NOVA instância A CADA vez que o bean é solicitado ao 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;
    }
}

O mesmo contador de instâncias, para um bean com escopo [prototype] (linha 10).

6.1.2. Dados com escopo de requisição: os atributos da requisição

O arquivo [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;

// um filtro (veja o capítulo 7): executado para cada requisição, ANTES do Spring MVC.
// Escopo de REQUISIÇÃO: os atributos da requisição nascem e morrem com ela.
@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); // passamos o controle ao restante
    }
}
  • Linhas 17–18: um filtro servlet (o próximo capítulo os descreve em detalhes). Ele processa cada requisição antes do [Spring MVC]. A classe [OncePerRequestFilter] do [Spring] garante que ele seja executado apenas uma vez por requisição; a anotação [@Component] basta para que o [Spring Boot] o adicione à cadeia de filtros;
  • Linha 23: o filtro armazena o horário de recebimento da requisição em um atributo de requisição. O objeto [HttpServletRequest] contém um dicionário de atributos, criado e destruído junto com a requisição: tudo o que a processa (filtros, controller, view) pode lê-lo e escrever nele. É o equivalente de [HttpContext.Items] do [ASP.NET Core];
  • linha 24: o filtro passa o controle para a etapa seguinte: os demais filtros e, em seguida, o [Spring MVC].

6.1.3. O controller

O arquivo [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;

// um controller é ele próprio um bean SINGLETON: é criado uma única vez
@Controller
public class ScopesController {

    private final CounterService counter;
    // um bean com escopo de requisição injetado em um singleton: o Spring injeta um
    // "proxy", que encaminha cada chamada à instância da requisição ATUAL
    private final RequestService request;
    // um prototype injetado em um singleton: criado UMA VEZ, com o controller
    private final ToolService injectedTool;
    // para obter um novo prototype a cada vez: peça-o ao 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) {
        // escopo de CLIENTE: um dado mantido pelo NAVEGADOR (cookie),
        // reenviado ao servidor a cada requisição
        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 ou "abc" -> 0
    private static int toInteger(String text) {
        try {
            return Integer.parseInt(text);
        } catch (NumberFormatException e) {
            return 0;
        }
    }
}

Vamos comentar este código:

  • Linhas 16–17: um controller é, ele próprio, um bean e, portanto, um singleton: o [Spring] o cria uma única vez e injeta suas dependências nesse momento, de uma vez por todas (linhas 29–35). É aqui que as coisas ficam interessantes;
  • linha 20: um singleton injetado em um singleton, nada fora do comum;
  • linha 23: um bean com escopo de requisição injetado em um singleton. Na inicialização, não há nenhuma requisição ativa e, portanto, nenhuma instância de [RequestService] para injetar. Em vez disso, o [Spring] injeta um proxy (um intermediário): um objeto que tem os mesmos métodos que [RequestService] e que encaminha cada chamada para a instância da requisição atual, criada conforme a necessidade. É isso que [@RequestScope] faz;
  • linha 25: um bean prototype injetado em um singleton. O [Spring] cria uma instância... apenas uma, durante a injeção. O controller a manterá durante todo o seu tempo de vida: esse campo nunca muda. Esta é a armadilha do escopo prototype: ele só cria uma nova instância a cada solicitação ao contêiner [Spring], e um singleton solicita suas dependências uma única vez;
  • linha 27: para obter uma nova instância a cada vez, o controller recebe um [ObjectProvider<ToolService>], um objeto capaz de solicitar um [ToolService] ao [Spring] sempre que necessário, por meio de seu método [getObject()] (linha 50);
  • linha 37: o modelo da view, um record (veja o Exemplo 03);
  • Linha 41: o escopo de cliente, um contador armazenado em um cookie. A anotação [@CookieValue] vincula o parâmetro ao cookie [myVisits] enviado pelo navegador; [required = false]: o parâmetro recebe [null] se o cookie estiver ausente (na primeira visita);
  • linha 45: o contador do navegador, incrementado de 1. O método [toInteger] (linhas 55–61) converte o texto do cookie em inteiro; [Integer.parseInt] lança uma [NumberFormatException] se o texto não for um inteiro ou se for igual a [null]: o contador é então reiniciado em 0;
  • linhas 46–48: o cookie é redefinido com seu novo valor. [ResponseCookie] é uma classe do [Spring] que gera o valor de um cabeçalho [Set-Cookie]: os métodos que definem suas características (caminho, [HttpOnly], [SameSite]) são chamados em sequência e, depois, [build()] cria o objeto. O cabeçalho é adicionado à resposta por [response.addHeader];
  • linhas 49–50: os valores são passados para a view: o contador da aplicação, o número da instância de [RequestService] da requisição atual, o número da instância do prototype injetado, o número da instância de um prototype solicitado naquele momento e o contador do cliente.

6.1.4. A view

O arquivo [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: a view também pede os beans ao Spring,
           durante a MESMA requisição */-->
    <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>
  • linha 9: [th:object] (veja os exemplos 18 e 19) refere-se ao objeto [model]; as expressões [*{...}] nas tags filhas referem-se às suas propriedades: [*{total}] equivale a [${model.total}];
  • linha 14: [[[...]]] insere o valor de uma expressão no texto, com escape, exatamente como [th:text] faria (veja o exemplo 14);
  • Linhas 15 e 18: a expressão [${@name}] refere-se ao bean com esse nome (veja o Exemplo 16). A view, por sua vez, solicita os beans [requestService] and [toolService] ao [Spring] durante a mesma requisição da action: poderemos comparar as instâncias recebidas pelo controller e pela view;
  • linha 16: o atributo de requisição definido pelo filtro. Para o [Thymeleaf], os atributos de requisição são variáveis como quaisquer outras.

6.1.5. Execução

Uma página, na URLhttp://localhost:5000/:

Image

Vamos simular dois navegadores usando [curl] e dois arquivos de cookies, [a.txt] e [b.txt]: a opção [-b] envia os cookies do arquivo, enquanto a opção [-c] salva no arquivo os cookies definidos pelo servidor. O navegador A fez duas requisições, depois o navegador B fez uma e, em seguida, A fez uma última requisição (o servidor acabou de ser reiniciado):

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>

(apenas os itens da lista são mostrados). Observamos que:

  • o contador da aplicação conta todas as visitas: 1, 2, 3, 4;
  • cada requisição tem sua própria instância de [RequestService]: 1, 2, 3, 4. Durante uma requisição, o controller (por meio de seu proxy) e a view acessam a mesma instância;
  • o prototype injetado no controller é sempre o nº 1: criado na inicialização junto com o controller, nunca será substituído. Os prototypes solicitados são novos a cada vez: o controller e a view recebem dois diferentes, e cada requisição cria dois novos;
  • o contador do cliente é exclusivo de cada navegador: A tem 3 visitas, B tem 1.

O arquivo [a.txt], mantido pelo [curl], contém o cookie do 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

Esse cookie é controlado pelo cliente, que pode enviar o valor que quiser:

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 um contador de visitantes, isso é irrelevante. Para dados sensíveis (a identidade do usuário, seu papel), o servidor precisa ser capaz de detectar adulterações: o Capítulo 8 mostra como.

Desses escopos decorre uma regra: um bean não deve reter um bean com escopo mais curto. Um singleton que recebesse diretamente uma instância com escopo de requisição a manteria indefinidamente, muito além da requisição para a qual foi criada. O [ASP.NET Core] verifica essa regra na inicialização, em modo de desenvolvimento, e se recusa a iniciar se ela for violada. O [Spring] adota outra abordagem: para o escopo de requisição, [@RequestScope] injeta um proxy, o que torna a injeção segura; para o escopo prototype, não realiza nenhuma verificação, e acabamos de ver o resultado: um “prototype” que se comporta como um singleton. Quando uma nova instância é realmente necessária, ela é solicitada ao [Spring] por meio de um [ObjectProvider].

No estudo de caso:

Escopo
Dados
Onde?
Aplicação
listas de médicos e clientes, dicionários, CAPTCHAs pendentes, contadores de tentativas
Beans singleton ([ApplicationModel], [Translator], [CaptchaService], [AttemptLimiterService]...); a camada de negócio e o acesso a dados também são singletons stateless
requisição
modelo da view, usuário conectado
o modelo ([Model]), complementado por [CommonModel]; o contexto de segurança do [Spring Security]
cliente
token de autenticação, idioma, mensagem flash
cookies