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:

- 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:
| 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:
| > 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:
| > 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:
| 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.
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.