Skip to content

20. Exercício de aplicação – Versão 10

A versão anterior mostrou que os dados tributários, compartilhados por todos os usuários da aplicação, devem ser armazenados em uma memória de escopo [application]. Usaremos um servidor Redis (https://redis.io) para implementar isso.

20.1. Redis

O Redis é um servidor que armazena dados em memória na forma de pares [key, value]. É muito rápido e amplamente usado por aplicações web como cache, isto é, como um repositório de dados custosos de obter. A memória de escopo [application] será implementada por um servidor Redis. Os scripts PHP que precisarem dessa memória de aplicação serão clientes desse servidor:

Image

  • Em [1], um script (PHP) envia um comando ao servidor Redis, por exemplo, para solicitar o valor associado a uma chave;
  • Em [2], o servidor Redis responde.

O servidor Redis funciona de forma independente dos scripts PHP: os dados armazenados nele continuam disponíveis de uma requisição para outra e para todos os usuários da aplicação.

20.2. Instalação do Redis

[Laragon] vem com um servidor Redis desativado por padrão. Você pode ativá-lo nas preferências do [Laragon] (menu [Preferences], aba [Services & Ports]) marcando a caixa de seleção [Redis]. Deixe a porta [6379] como está, pois é a porta padrão usada pelos clientes Redis. O servidor Redis é então iniciado junto com os demais serviços do [Laragon] (Apache, MySQL...) ao clicar no botão [Start All].

20.3. O cliente Redis em modo de comando

O servidor Redis pode ser consultado em modo de comando. Abra um terminal do [Laragon] e digite o comando [redis-cli], que inicia o cliente do servidor Redis em modo de comando. O cliente exibe então o prompt [127.0.0.1:6379>]: ele está conectado ao servidor Redis da máquina local (endereço IP 127.0.0.1) na porta 6379. Eis uma sessão de exemplo:

> redis-cli
127.0.0.1:6379> command count
(integer) 240
127.0.0.1:6379> set title "PHP 8 by example"
OK
127.0.0.1:6379> get title
"PHP 8 by example"
127.0.0.1:6379> exists title
(integer) 1
127.0.0.1:6379> del title
(integer) 1
127.0.0.1:6379> get title
(nil)
127.0.0.1:6379> exists title
(integer) 0
127.0.0.1:6379> quit
  • Linha 3: O cliente Redis tem mais de 200 comandos para se comunicar com o servidor. Um deles, [command count], exibe o número exato de comandos disponíveis na versão utilizada;
  • Linhas 4–7: Veremos apenas os comandos de que precisaremos em nossa aplicação PHP. Usaremos o Redis para uma única coisa: associar um valor a uma chave na memória do Redis. Isso é feito com o comando Redis [set key value]. O valor pode então ser recuperado com o comando [get key]. É tudo de que precisaremos;
  • linhas 8–9: O comando [exists] verifica se uma chave existe: retorna 1 se a chave existe e 0 caso contrário;
  • linhas 10–11: O comando [del] exclui uma chave;
  • linhas 12–13: se você solicitar o valor de uma chave inexistente, obtém o valor [nil], indicando que a chave não foi encontrada;
  • linha 16: Para sair do cliente Redis, digite o comando [quit].

Pode ser necessário limpar toda a memória do Redis. Isso é feito com o comando [flushdb].

20.4. Instalação de um cliente Redis para PHP

Agora precisamos de um cliente Redis para PHP. Existem dois principais:

  • a extensão PHP [phpredis], escrita em C, que deve ser adicionada à configuração do PHP;
  • a biblioteca [Predis] (https://github.com/predis/predis), escrita em PHP, que é instalada com o [Composer].

Como no curso de PHP 7, usaremos o [Predis], versão 3. Ele está declarado no arquivo [composer.json] da pasta [php8-oct-2026] e foi instalado junto com as demais bibliotecas do curso pelo comando [composer install]. Pode ser encontrado na pasta [vendor/predis/predis]. O carregador de classes do [Composer] o suporta: ao contrário do curso de PHP 7, não há mais um arquivo [predis/autoload.php] a incluir nem um método [Predis\Autoloader::register] a chamar.

20.5. Código do servidor

O servidor da versão 10 é composto pelos seguintes arquivos:

1
2
3
4
5
6
scripts-web/tax/version-10
├── Data
│   ├── .htaccess
│   ├── config-server.json
│   └── logs.txt
└── tax-server.php

O arquivo de configuração [config-server.json] muda da seguinte forma:

{
    "databaseFilename": "../version-08/Data/database-mysql.json",
    "dependencies": [
        "../../../scripts-console/tax/version-05/Entities/TaxException.php",
        "../../../scripts-console/tax/version-05/Entities/TaxAdminData.php",
        "../../../scripts-console/tax/version-05/Entities/Database.php",
        "../../../scripts-console/tax/version-05/Utilities/Utilities.php",
        "../version-08/Dao/InterfaceServerDao.php",
        "../version-08/Dao/ServerDao.php",
        "../version-09/Dao/ServerDaoWithSession.php",
        "../version-08/Business/InterfaceServerBusiness.php",
        "../version-08/Business/ServerBusiness.php",
        "../version-09/Utilities/Logger.php",
        "../version-09/Utilities/SendAdminMail.php"
    ],
    "users": [
        {
            "login": "admin",
            "passwd": "admin"
        }
    ],
    "adminMail": {
        "smtp-server": "localhost",
        "smtp-port": 1025,
        "from": "guest@localhost",
        "to": "guest@localhost",
        "subject": "tax calculation server crash",
        "tls": false,
        "attachments": []
    },
    "logsFilename": "Data/logs.txt",
    "redis": {
        "scheme": "tcp",
        "host": "127.0.0.1",
        "port": 6379
    }
}

Comentários

  • linhas 3–15: A versão 10 não traz nenhuma novidade além do script [tax-server.php]. Ela usa elementos das versões 5, 8 e 9;
  • Linhas 32–37: Parâmetros de conexão ao servidor Redis: o protocolo (tcp), o host e a porta. Esses são os valores padrão do [Predis], mas é melhor especificá-los na configuração: se o servidor Redis mudar para outro host ou outra porta, só será necessário atualizar a configuração.

O código do servidor [tax-server.php] muda da seguinte forma:

<?php

// conformidade estrita com os tipos declarados dos parâmetros e resultados das funções
declare(strict_types=1);

// namespace
namespace Application;

// dependências do Symfony
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\Session\Session;
// dependências do Predis
use Predis\Client as RedisClient;
use Predis\PredisException;
// alias de classe: a camada [dao] da versão 9 é usada com o Redis
use Application\ServerDaoWithSession as ServerDaoWithRedis;

// os erros do PHP não são enviados ao cliente (vão para o log do servidor web)
ini_set("display_errors", "0");

// a pasta raiz do servidor: os caminhos do arquivo de configuração são relativos a esta pasta
const ROOT_DIRECTORY = __DIR__;
// caminho do arquivo de configuração
const CONFIG_FILENAME = ROOT_DIRECTORY . "/Data/config-server.json";

// recuperamos a configuração
$config = json_decode(file_get_contents(CONFIG_FILENAME), true, flags: JSON_THROW_ON_ERROR);

// incluímos as dependências necessárias ao script
require_once ROOT_DIRECTORY . "/../../../vendor/autoload.php";
foreach ($config["dependencies"] as $dependency) {
    require_once ROOT_DIRECTORY . "/$dependency";
}

// sessão: agora ela contém apenas o identificador do usuário autenticado
$session = new Session();
$session->start();

// criação do arquivo de log
try {
    $logger = new Logger(ROOT_DIRECTORY . "/" . $config["logsFilename"]);
} catch (TaxException $ex) {
    // erro 500 sem logs - a mensagem não deve revelar a árvore de arquivos do servidor
    $message = "Failed to create the log file [{$config["logsFilename"]}]";
    doInternalServerError($message, $config["adminMail"]);
    // concluído
    exit;
}

// 1º log
$logger->write("---new request");

// recuperamos a requisição atual
$request = Request::createFromGlobals();
// autenticação apenas na 1ª vez
if (!$session->has("user")) {
    // log
    $logger->write("Authentication in progress…");
    // as credenciais enviadas pelo cliente (null se ele não enviou nenhuma)
    $requestUser = $request->getUser();
    $requestPassword = $request->getPassword();
    // o usuário é um dos usuários autorizados?
    $found = $requestUser !== null && $requestPassword !== null
        && array_any(
            $config["users"],
            fn(array $user): bool => $user["login"] === $requestUser && hash_equals($user["passwd"], $requestPassword)
        );
    if (!$found) {
        // não encontrado - código 401
        sendResponse(
            ["error" => "Authentication failed [$requestUser]"],
            Response::HTTP_UNAUTHORIZED,
            ["WWW-Authenticate" => 'Basic realm="Tax calculation server"'],
            $logger
        );
        // concluído
        exit;
    }
    // registramos na sessão que o usuário foi autenticado
    $session->set("user", $requestUser);
    // log
    $logger->write("Authentication successful [$requestUser]");
} else {
    // log
    $logger->write("Authentication taken from the session…");
}

// temos um usuário válido - verificamos os parâmetros recebidos
$errors = [];
// devemos ter uma requisição GET com três parâmetros
if ($request->getMethod() !== "GET" || $request->query->count() !== 3) {
    $errors[] = "GET method required with only the parameters [married, children, salary]";
}
// o estado civil
if (!$request->query->has("married")) {
    $errors[] = "missing married parameter";
} else {
    $married = strtolower(trim($request->query->getString("married")));
    if (!in_array($married, ["yes", "no"], true)) {
        $errors[] = "invalid married parameter [$married]";
    }
}
// o número de filhos e o salário: inteiros >= 0
$values = [];
foreach (["children", "salary"] as $parameter) {
    if (!$request->query->has($parameter)) {
        $errors[] = "missing $parameter parameter";
        continue;
    }
    $value = trim($request->query->getString($parameter));
    if (preg_match('/^\d+$/', $value) !== 1) {
        $errors[] = "invalid $parameter parameter [$value]";
    } else {
        $values[$parameter] = (int) $value;
    }
}
// há outros parâmetros na requisição?
foreach (array_diff(array_keys($request->query->all()), ["married", "children", "salary"]) as $parameter) {
    $errors[] = "invalid parameter [$parameter]";
}
// erros?
if ($errors !== []) {
    // enviamos um código de erro 400 ao cliente
    sendResponse(["errors" => $errors], Response::HTTP_BAD_REQUEST, [], $logger);
    // concluído
    exit;
}
// log
[$children, $salary] = [$values["children"], $values["salary"]];
$logger->write("valid parameters ['married'=>$married, 'children'=>$children, 'salary'=>$salary]");

// temos tudo o que é preciso para trabalhar
// a memória de escopo [application]: um servidor Redis
try {
    // o cliente Redis
    $redis = new RedisClient($config["redis"]);
    // conectamo-nos ao servidor de imediato para saber se ele está disponível
    $redis->connect();
} catch (PredisException $ex) {
    // erro 500
    doInternalServerError("[redis], {$ex->getMessage()}", $config["adminMail"], $logger);
    // concluído
    exit;
}
// criação da camada [dao]
$json = $redis->get("taxAdminData");
if ($json === null) {
    // os dados tributários são obtidos do banco de dados
    $logger->write("tax data taken from the database");
    try {
        // construção da camada [dao]
        $dao = new ServerDaoWithRedis(ROOT_DIRECTORY . "/" . $config["databaseFilename"]);
        // colocamos a string JSON dos dados tributários na memória de escopo [application]
        $redis->set("taxAdminData", (string) $dao->getTaxAdminData());
    } catch (TaxException $ex) {
        // erro 500
        doInternalServerError("[dao], {$ex->getMessage()}", $config["adminMail"], $logger, $redis);
        // concluído
        exit;
    }
} else {
    // os dados tributários são obtidos da memória de escopo [application]
    $taxAdminData = TaxAdminData::fromArray(json_decode($json, true, flags: JSON_THROW_ON_ERROR));
    // instanciação da camada [dao]
    $dao = new ServerDaoWithRedis($taxAdminData);
    // log
    $logger->write("tax data taken from Redis");
}
// criação da camada [business]
$business = new ServerBusiness($dao);
// cálculo do imposto
$result = $business->calculateTax($married, $children, $salary);
// retornamos a resposta
sendResponse($result, Response::HTTP_OK, [], $logger, $redis);
// fim
exit;

// --------------------------------------------------------------------------
// erro fatal: um e-mail ao administrador e uma resposta 500 ao cliente
function doInternalServerError(
    string $message,
    array $adminMail,
    ?Logger $logger = null,
    ?RedisClient $redis = null
): void {
    // a mensagem de erro de um driver de SGBD pode não estar codificada em UTF-8 (Windows-1252 no Windows)
    if (!mb_check_encoding($message, "UTF-8")) {
        $message = mb_convert_encoding($message, "UTF-8", "Windows-1252");
    }
    // enviamos um e-mail ao administrador
    // [SendAdminMail] captura todas as exceções e as registra ela mesma
    (new SendAdminMail($adminMail, $logger))->send($message);
    // enviamos um código de erro 500 ao cliente
    sendResponse(["error" => $message], Response::HTTP_INTERNAL_SERVER_ERROR, [], $logger, $redis);
}

// envio da resposta HTTP ao cliente
// $result: o array a enviar, na forma ["response" => $result]
// $statusCode: o status HTTP da resposta
// $headers: cabeçalhos HTTP a adicionar à resposta
// $logger: o log da aplicação (null se não pôde ser criado)
// $redis: o cliente Redis (null se ainda não foi criado)
function sendResponse(
    array $result,
    int $statusCode,
    array $headers = [],
    ?Logger $logger = null,
    ?RedisClient $redis = null
): void {
    // a resposta JSON
    $response = new JsonResponse(null, $statusCode, $headers);
    $response->setEncodingOptions(JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_PRESERVE_ZERO_FRACTION);
    $response->setData(["response" => $result]);
    // envio
    $response->send();
    // log
    $logger?->write($response->getContent());
    // fechamento da conexão com o servidor Redis
    $redis?->disconnect();
}

Comentários

  • Linhas 15–16: as classes do [Predis] que utilizamos. A classe [Predis\Client] é o cliente Redis. Damos a ela o alias [RedisClient], mais descritivo em nosso código. [PredisException] é a classe pai de todas as exceções lançadas pelo [Predis];
  • Linha 18: Damos o alias [ServerDaoWithRedis] à classe [ServerDaoWithSession] da versão 9 para refletir a mudança na implementação do script do servidor. A classe [ServerDaoWithSession] pode construir a camada [dao] a partir de dados tributários previamente obtidos: não importa se os dados vêm de uma sessão ou de um servidor Redis;
  • linhas 38–39: a sessão é mantida. Há duas informações a ter em mente aqui:
    • o fato de o usuário ter se autenticado com sucesso. Essa informação tem escopo [session]: está ligada a um usuário específico e não se aplica a outros usuários. Ela permanece na sessão;
    • os dados da administração tributária. Essa informação tem escopo [application]: não está ligada a um usuário específico, mas se aplica a todos os usuários. Ela é armazenada no servidor Redis;
  • linhas 135–145: criação do cliente [Predis], que se comunicará com o servidor Redis usando os parâmetros de conexão do arquivo de configuração:
    • linha 140: O cliente é conectado imediatamente ao servidor para verificar se ele está respondendo;
    • se a conexão com o servidor Redis falhar, uma resposta de erro é enviada ao cliente e um e-mail é enviado ao administrador da aplicação. A mensagem de erro é prefixada com [[redis]] para indicar a origem do erro;
  • linha 148: o servidor Redis é consultado sobre o valor da chave [taxAdminData]. O cliente [Predis] oferece um método para cada comando Redis: o método [get] envia o comando [get taxAdminData]. Ele retorna o valor da chave, ou [null] se ela não existir;
  • linha 149: se a chave não for encontrada, os dados tributários são obtidos do banco de dados;
  • linha 156: a chave [taxAdminData] é armazenada na memória do Redis, associada à string JSON do objeto [TaxAdminData] obtido da camada [dao]. O método [set] espera uma string como valor da chave. A conversão [(string)] chama o método [__toString] da classe [TaxAdminData], que retorna a string JSON do objeto. O script do PHP 7 deixava o PHP fazer essa conversão implicitamente; com [declare(strict_types=1)], é melhor escrevê-la explicitamente;
  • Linha 159: Se a leitura do banco de dados falhar, retorna-se um erro 500 e envia-se um e-mail ao administrador; a mensagem é prefixada com [[dao]];
  • linhas 164–169: A chave [taxAdminData] está na memória do Redis. Sabemos que seu valor é a string JSON de um objeto [TaxAdminData]:
    • linha 165: a string JSON é decodificada em um array associativo; em seguida, o método estático [TaxAdminData::fromArray] da versão 5 constrói o objeto [TaxAdminData] a partir desse array, verificando seus dados;
    • linha 167: a camada [dao] é instanciada com esses dados;
  • linhas 182–187: A função [doInternalServerError] tem um parâmetro adicional—o cliente Redis—, que ela repassa à função [sendResponse]. Quando uma função tem muitos parâmetros, eles são escritos um por linha;
  • linha 221: A função [sendResponse] fecha a conexão com o servidor Redis, se ela foi aberta.

20.6. Código do cliente

A versão 10 do cliente é idêntica à versão 9. A única mudança é no arquivo de configuração [config-client.json]:

{
    "urlServer": "http://localhost/php8-oct-2026/scripts-web/tax/version-10/tax-server.php",
    "user": {
        "login": "admin",
        "passwd": "admin"
    },
    "httpClientOptions": {
        "verify_peer": false,
        "verify_host": false
    },
    "taxPayersDataFilename": "Data/taxpayersdata.json",
    "resultsFilename": "Data/results.json",
    "errorsFilename": "Data/errors.json",
    "dependencies": [
        "../version-05/Entities/TaxException.php",
        "../version-05/Entities/TaxPayerData.php",
        "../version-05/Utilities/Utilities.php",
        "../version-05/Dao/TraitDao.php",
        "../version-08/Dao/InterfaceClientDao.php",
        "../version-09/Dao/ClientDao.php",
        "../version-08/Business/InterfaceClientBusiness.php",
        "../version-08/Business/ClientBusiness.php"
    ]
}
  • Linha 2: a URL do servidor da versão 10;
  • linha 20: a camada [dao] do cliente é a da versão 9.

A pasta [scripts-console/tax/version-10] contém, portanto, apenas a pasta [Data], o script principal [Main/MainTaxClient.php] (o da versão 8) e o script de teste [Tests/ClientBusinessTest.php].

Antes de executar o cliente, vamos excluir a chave [taxAdminData] da memória do servidor Redis com o comando [del taxAdminData] do [redis-cli]. Em seguida, vamos executar o cliente:

1
2
3
> php MainTaxClient.php
The results have been saved in the file [Data/results.json]
Done

Os resultados são os mesmos da versão 9. Os logs do servidor são os seguintes:

01/10/26 18:10:12.890 : ---new request
01/10/26 18:10:12.891 : Authentication in progress…
01/10/26 18:10:12.891 : Authentication successful [admin]
01/10/26 18:10:12.891 : valid parameters ['married'=>yes, 'children'=>2, 'salary'=>55555]
01/10/26 18:10:12.907 : tax data taken from the database
01/10/26 18:10:12.909 : {"response":{"tax":2814,"surcharge":0,"discount":0,"reduction":0,"rate":0.14}}
01/10/26 18:10:12.912 : ---new request
01/10/26 18:10:12.912 : Authentication taken from the session…
01/10/26 18:10:12.912 : valid parameters ['married'=>yes, 'children'=>2, 'salary'=>50000]
01/10/26 18:10:12.913 : tax data taken from Redis
01/10/26 18:10:12.913 : {"response":{"tax":1384,"surcharge":0,"discount":384,"reduction":347,"rate":0.14}}
01/10/26 18:10:12.916 : ---new request
…
  • Linha 5: Durante a primeira requisição, os dados tributários são obtidos do banco de dados;
  • linha 10: durante a requisição seguinte, os dados são obtidos do Redis.

Agora vamos testar um novo cenário de erro: o servidor Redis está indisponível. Podemos parar o servidor Redis pelo [Laragon]. Em vez disso, definimos a porta 6380—na qual nenhum servidor escuta—na configuração do servidor ([redis]). O resultado no console é o seguinte:

1
2
3
> php MainTaxClient.php
Error no. 42: {"HTTP status":500,"error":"[redis], Connection refused [tcp://127.0.0.1:6380]"}
Done

Os logs do servidor mostram que o administrador foi notificado por e-mail:

1
2
3
4
5
6
01/10/26 18:10:32.255 : ---new request
01/10/26 18:10:32.255 : Authentication in progress…
01/10/26 18:10:32.256 : Authentication successful [admin]
01/10/26 18:10:32.256 : valid parameters ['married'=>yes, 'children'=>2, 'salary'=>55555]
01/10/26 18:10:32.305 : Message [[redis], Connection refused [tcp://127.0.0.1:6380]] sent to guest@localhost
01/10/26 18:10:32.305 : {"response":{"error":"[redis], Connection refused [tcp://127.0.0.1:6380]"}}

Em seguida, restauramos a porta 6379 na configuração.

20.7. Testes do cliente com [PHPUnit]

A classe de teste [ClientBusinessTest] da versão 10 é idêntica à da versão 9; o ambiente de teste é o do cliente da versão 10. Antes de iniciar os testes, use o cliente [redis-cli] para excluir a chave [taxAdminData] da memória do servidor Redis (comando [del taxAdminData]). Agora, execute o teste:

> php vendor/bin/phpunit scripts-console/tax/version-10/Tests --testdox
PHPUnit 12.5.37 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.5.11
Configuration: .../php8-oct-2026/phpunit.xml

...........                                                       11 / 11 (100%)

Time: 00:00.063, Memory: 16.00 MB

Client Business (Application\Tests\ClientBusiness)
 ✔ Calculate tax with data set "couple, 2 children, 55555"
 ✔ Calculate tax with data set "couple, 2 children, 50000"
 ✔ Calculate tax with data set "couple, 3 children, 50000"
 ✔ Calculate tax with data set "single, 2 children, 100000"
 ✔ Calculate tax with data set "single, 3 children, 100000"
 ✔ Calculate tax with data set "couple, 3 children, 100000"
 ✔ Calculate tax with data set "couple, 5 children, 100000"
 ✔ Calculate tax with data set "single, 0 children, 100000"
 ✔ Calculate tax with data set "couple, 2 children, 30000"
 ✔ Calculate tax with data set "single, 0 children, 200000"
 ✔ Calculate tax with data set "couple, 3 children, 200000"

OK (11 tests, 22 assertions)

Vamos examinar os logs [logs.txt] do servidor:

01/10/26 18:10:32.488 : ---new request
01/10/26 18:10:32.488 : Authentication in progress…
01/10/26 18:10:32.488 : Authentication successful [admin]
01/10/26 18:10:32.488 : valid parameters ['married'=>yes, 'children'=>2, 'salary'=>55555]
01/10/26 18:10:32.489 : tax data taken from the database
01/10/26 18:10:32.491 : {"response":{"tax":2814,"surcharge":0,"discount":0,"reduction":0,"rate":0.14}}
01/10/26 18:10:32.495 : ---new request
01/10/26 18:10:32.495 : Authentication in progress…
01/10/26 18:10:32.495 : Authentication successful [admin]
01/10/26 18:10:32.495 : valid parameters ['married'=>yes, 'children'=>2, 'salary'=>50000]
01/10/26 18:10:32.496 : tax data taken from Redis
01/10/26 18:10:32.496 : {"response":{"tax":1384,"surcharge":0,"discount":384,"reduction":347,"rate":0.14}}
01/10/26 18:10:32.500 : ---new request
01/10/26 18:10:32.500 : Authentication in progress…
01/10/26 18:10:32.500 : Authentication successful [admin]
01/10/26 18:10:32.500 : valid parameters ['married'=>yes, 'children'=>3, 'salary'=>50000]
01/10/26 18:10:32.501 : tax data taken from Redis
01/10/26 18:10:32.501 : {"response":{"tax":0,"surcharge":0,"discount":720,"reduction":0,"rate":0.14}}
…

Já mencionamos que, antes de cada teste, o método [setUp] da classe de teste é reexecutado, o que significa que a classe [ClientDao] em teste é instanciada, a cada teste, com um cookie de sessão inexistente. É, portanto, como se os 11 testes representassem 11 usuários diferentes, com 11 sessões diferentes:

  • linhas 2–3, 8–9, 14–15: Cada teste se autentica porque inicia uma nova sessão;
  • linha 5: os dados tributários são obtidos do banco de dados;
  • linhas 11, 17: os dados tributários são obtidos da memória do Redis. Isso demonstra claramente que existe uma memória de escopo [application] compartilhada por todos os usuários da aplicação.

20.8. Visualização do conteúdo do servidor Redis

Vimos que o servidor Redis pode ser gerenciado em modo de comando. O comando [get taxAdminData] exibe o valor da chave [taxAdminData]: reconhecemos a string JSON como pertencente a um objeto do tipo [TaxAdminData]:

> redis-cli get taxAdminData
"{\"limits\":[9964,27519,73779,156244,0],\"coeffR\":[0,0.14,0.3,0.41,0.45],\"coeffN\":[0,1394.96,5798,13913.69,20163.45],\"halfShareQfCeiling\":1551,\"singleIncomeCeilingForReduction\":21037,\"coupleIncomeCeilingForReduction\":42074,\"halfShareReductionValue\":3797,\"singleDiscountCeiling\":1196,\"coupleDiscountCeiling\":1970,\"coupleTaxCeilingForDiscount\":2627,\"singleTaxCeilingForDiscount\":1595,\"tenPercentAllowanceMax\":12502,\"tenPercentAllowanceMin\":437}"

O [redis-cli] exibe a string entre aspas, precedendo cada aspa que ela contém com o caractere [\].

O servidor Redis também pode ser gerenciado por meio de uma interface gráfica. A ferramenta oficial é o [Redis Insight] (https://redis.io/insight), que é gratuito e está disponível para Windows. Depois de conectado ao servidor [127.0.0.1:6379], ele exibe a lista de chaves armazenadas no servidor. Ao clicar na chave [taxAdminData], você vê seu valor, que a ferramenta exibe como um objeto JSON. Também é possível excluir uma chave, adicionar uma nova ou executar comandos do [redis-cli] em um console integrado.