Trabalhando com Cookies em Páginas Visualforce

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