Trabalhando com Cookies em Páginas Visualforce nos permitirá manter um controle de estado/conexão no Salesforce, permitindo guardar informações no Navegador do usuário e recuperar essas informações quando recebermos uma requisição na Controller, bom, falando assim pode até parecer complicado, mas fique tranquilo, porque tudo isso é mais fácil do que parece.
Para que serve os Cookies
O protocolo HTTP é stateless, ou seja, ele não mantém um estado/conexão. Toda Requisição Get que o usuário faz ao servidor do Salesforce, acarretará em uma nova requisição e resposta. Temos uma excessão nos casos de uma Requisição Postback, que falei no post anterior onde falamos sobre o Ciclo de Vida de uma Página Visualforce e sua ViewState, sugiro que de uma olhada se ainda não leu o post.
As requisições são independentes e possuem um tempo de vida (conexão, troca de mensagem, encerramento da conexão). O servidor do Salesforce não é capaz de identificar se duas requisições vieram de um mesmo navegador, e o mesmo não faz nenhum gerenciamento em memória para que mensagens sejam compartilhadas entre requisições.
É para suprir esta necessidade que entra por exemplo o uso de cookies.
Mas afinal, o que é um Cookies
Através de cookies o servidor do Salesforce é capaz de trocar informações de estado com o navegador do usuário. Desse modo, somos capazes de adicionar produtos a um carrinho de compras, sem perder estas informações ao mudar de página, sair do website ou até mesmo fechar o navegador.
Tecnicamente falando, um cookie é uma pequena quantidade de informação persistida temporariamente pelo navegador. Os navegadores normalmente limitam o tamanho dos cookies em até 4KB, e apagam cookies com a data de “validade vencida”, falaremos sobre isso mais adiante.
Para entender como essa troca de informação é feita, vamos criar um cookie usando uma Controller e uma Página Visualforce, vamos lá?
Trabalhando com Cookies em Páginas Visualforce
Vamos fazer um exemplo onde vamos criar um Cookie na Controller e exibir um contador do número de vezes que a página foi visitada pelo usuário, não chega a ser um exemplo pratico do dia a dia, afinal existem outras formas muito mais eficiente de fazer um contador de visitas, mas acredito que esse pequeno exemplo pode abrir a sua mente para inúmeras formas de utilização.
Criando a Controller
O primeiro passo é criar uma controller, eu criei a minha com o nome MeuCookieController, criei uma propriedade publica chamada Counter, que será exibida em uma Página Visualforce, e no construtor da controller eu chamei dois métodos, um para ler os dados do Cookie e um para gravar o valor do contador no Cookie. Nossa controller ficou então com a propriedade do contador, o construtor e mais 3 métodos, os dois métodos já mencionados e um método para remover o Cookie do navegador do usuário.
public class MeuCookieController {
public Integer Counter {
get;set;
}
public MeuCookieController() {
loadCookie();
setCookieCounter();
}
public void clearCounter() {
Counter = 0;
Cookie counterCookie = new Cookie('Counter', null, null, 0, false);
ApexPages.currentPage().setCookies(new Cookie[]{counterCookie});
}
private void loadCookie() {
Counter = 0;
Cookie counterCookie = ApexPages.currentPage().getCookies().get('Counter');
if (counterCookie != null)
Counter = Integer.valueOf(counterCookie.getValue());
}
private void setCookieCounter() {
Counter++;
Cookie counterCookie = new Cookie('Counter', String.valueOf(Counter), null, 60 * 60 * 24, true);
ApexPages.currentPage().setCookies(new Cookie[]{counterCookie});
}
}A classe Cookie espera os seguintes parâmetros no seu construtor: Nome (Identificador do seu Cookie), Valor em String que será armazenado no Cookie, Caminho do seu Cookie, Tempo de Vida do Cookie em segundos, e o último parâmetro indica se o Cookie pode ser acessado somente através de uma conexão HTTPS.
O método para criar é praticamente o mesmo para remover um Cookie, com a diferença de que o parâmetro do tempo de vida deve ser 0, dessa forma ele será removido do navegador do usuário automaticamente assim que a requisição for recebida.
Mais informações sobre a classe Apex Cookie você pode ver na documentação do Salesforce.
Criando a Página Visualforce
Agora vamos fazer a mágica acontecer, vamos criar uma Página Visualforce que irá exibir o contador, este contador será incrementado a cada visita na página, mesmo que você feche o navegador e abra novamente, ele continuará contando, note que eu configurei o tempo de vida do meu cookie para 24 horas, então se abrirmos essa mesma página 24 horas depois, o contador voltará para zero, pois o Cookie deixará de existir.
<apex:page title="Meu Contador usando Cookie" showHeader="false" sidebar="false" showQuickActionVfHeader="false" controller="MeuCookieController">
<br/>
<h1>Você já visitou esta página:
<apex:outputLabel value="{!Counter}"></apex:outputLabel>
</h1>
<br/>
<apex:form>
<apex:commandButton value="Zerar Contador" action="{!clearCounter}"></apex:commandButton>
</apex:form>
</apex:page>A página contém um outputLabel com o value do Contador e um CommandButton para zerar o contador, mais simples que isso é impossível, não é?
O resultado
Ao acessar a página pela primeira vez, a página invoca o construtor da Controller, que por sua vez chama o método loadCookie(), que checa se existe o Cookie, e se existir seta o valor na propriedade Counter. Como da primeira vez não existe o Cookie, a propriedade recebe o valor zero e em seguida é chamado o método setCookieCounter() que incrementa o valor do contador, e em seguida cria um novo Cookie com o nome Counter, passando o valor do contador, tempo de vida de 24 horas para o caminho padrão e configurando para somente ser exibido em HTTPS, o cookie é então colocado no Header de retorno da página. Por fim à página é renderizada, exibindo o contador em 1, e o resultado você pode ver abaixo.
Eu deixei o Google Inspetor aberto para exibir os Cookies da página, note que o Salesforce altera o nome do cookie para apex__{NOME DO COOKIE SETADO NA CONTROLLER}, o real motivo dessa troca do nome é um mistério, mas eu acredito que seja para manter uma padronização, é isso é um ponto muito importante a ser observado, pois caso você queira fazer a manipulação desse Cookie via JavaScript por exemplo, para manipula-ló você deverá procurar pelo nome completo dele, e não pelo identificador especificado na Controller.
Após algumas visitas na página, temos o contador incrementado.
E depois de clicar no botão Zerar Contador:
Note que neste momento, o Cookie é automaticamente removido do navegador.
O Salesforce não oferece um recurso comum dos servidores Web usando por exemplo apache com PHP e IIS com C# .NET, que é a Sessão, um estado criado para cada usuário que acessa o seu Website e morre quando o usuário fecha o Navegador, porém é possível fazer uma implementação para suprir essa deficiência, mostrarei como podemos fazer isso em um post futuro, e para isso utilizaremos o Cookie.
Apesar de simples, espero que este exemplo possa te ajudar a entender um pouco mais sobre os Cookies, e espero ainda que você consiga tirar bons proveitos dele, até o próximo post :)
Fernando Sousa
Senior Salesforce Developer
Bacharel em Sistemas da Informação pela Universidade de Taubaté (UNITAU) e MBA em Projeto de Aplicações para Dispositivos Móveis pelo IGTI – Instituto de Gestão em Tecnologia da Informação.
Comecei a programar bem cedo, por volta de 10 anos de idade, de maneira auto-didata passei por várias linguagens.
Em 2015 me conectei a plataforma Salesforce pela primeira vez, para fazer una integração entre um Aplicativos Mobile em android e o Salesforce Platform.
Atualmente com as certificações Salesforce Certified Platform Developer I, Salesforce Certified Platform App Builder, Salesforce Certified Platform Developer II, Salesforce Administrator e Sharing and Visibility.
Acompanhe meu Trailhead aqui.
