Java JSF: Como usar os escopos ConversationScoped e ViewScoped

Os escopos descrevem os limites superiores e inferiores de determinado assunto, assim, quando tratamos do escopo de vari�veis sabemos at� onde elas poder�o ser acessadas, como no escopo local, escopo global e etc.

Os escopos do JSF tamb�m seguem o mesmo princ�pio, pois definem at� quando aquele bean deve permanecer sendo gerenciado, ou seja, com seu estado mantido. Logo, teremos um projeto bem estruturado.

Neste artigo trataremos de dois escopos diferentes: o ViewScoped, proveniente do JSF 2.0, e o ConversationScoped, proveniente do CDI. Explicaremos qual a fun��o de cada um e daremos exemplos pr�ticos de como utiliz�-los.

ViewScoped

Este escopo est� entre outros dois muito utilizados at� hoje, mas que perderam um pouco o seu �trono� com a vinda do ViewScoped: o Request e o Session.

O Request mant�m o estado do bean apenas durante uma requisi��o, ou seja, era normal realizar v�rias consultas ao banco de dados a cada requisi��o feita pelo usu�rio, consequentemente, tornando a aplica��o mais lenta e sobrecarregada quando h� diversos usu�rios fazendo requisi��es simult�neas. Por outro lado, temos o Session, que mant�m o estado do bean durante toda a sess�o, ou seja, at� a sua destrui��o, seja por timeout ou explicitamente. Resolvia usar o Session, j� que o estado do bean � mantido e n�o precisamos fazer v�rias consultas ao banco de dados, por�m, quando temos um sistema com muitos beans gerenci�veis e todos em sess�o, podemos sofrer com lentid�es ou at� estouro de mem�ria dependendo da quantidade de informa��es que cada bean mant�m.

Percebemos aqui que temos um problema, pois o escopo de Request � curto demais para manter o bean na quantidade de tempo que desejamos e o escopo Session � longo demais e acaba mantendo o bean al�m do que desejamos. O ViewScoped veio para tentar resolver esse problema, criando um meio-termo entre o Request e o Session.

O ViewScoped mant�m o estado do bean enquanto houver requisi��es da mesma view/p�gina, e quando ele muda de p�gina o estado do bean � descartado.

A cada requisi��o realizada o bean � gravado em um �map�, chamado de �view map� e, por conta disso, este bean deve implementar a interface Serializable. Vejamos um exemplo pr�tico do uso deste escopo na Listagem 1.

Listagem 1. Usando @ViewScoped


      1 package lab;
     2 
     3 import java.io.Serializable;
     4 import java.util.ArrayList;
     5 import java.util.List;
     6 
     7 import javax.annotation.PostConstruct;
     8 import javax.faces.bean.ManagedBean;
     9 import javax.faces.bean.ViewScoped;
     10 import javax.faces.model.DataModel;
     11 import javax.faces.model.ListDataModel;
     12 
     13 @ManagedBean
     14 @ViewScoped
     15 public class Bean implements Serializable {
     16 
     17 private List<Item> list;
     18 private transient DataModel<Item> model;
     19 private Item item = new Item();
     20 private boolean edit;
     21 
     22 @PostConstruct
     23 public void init() {
     24 // list = dao.list();
     25 // APenas para exemplificar, a lista deveria ser capturada atrav�s do DAO, que faz um HINT ao banco de dados.
     26 list = new ArrayList<Item>();
     27 list.add(new Item(1L, "item1"));
     28 list.add(new Item(2L, "item2"));
     29 list.add(new Item(3L, "item3"));
     30 }
     31 
     32 public void add() {
     33 // dao.create(item);
     34 // Apenas para exemplificar, mas o ID deveria ser configurado pelo banco
     35 item.setId(list.isEmpty() ? 1 : list.get(list.size() - 1).getId() + 1);
     36 list.add(item);
     37 item = new Item(); // Para resetar o placeholder
     38 }
     39 
     40 public void edit() {
     41 item = model.getRowData();
     42 edit = true;
     43 }
     44 
     45 public void save() {
     46 // dao.update(item);
     47 item = new Item(); // Para resetar o placeholder
     48 edit = false;
     49 }
     50 
     51 public void delete() {
     52 // dao.delete(item);
     53 list.remove(model.getRowData());
     54 }
     55 
     56 public List<Item> getList() {
     57 return list;
     58 }
     59 
     60 public DataModel<Item> getModel() {
     61 if (model == null) {
     62 model = new ListDataModel<Item>(list);
     63 }
     64 
     65 return model;
     66 }
     67 
     68 public Item getItem() {
     69 return item;
     70 }
     71 
     72 public boolean isEdit() {
     73 return edit;
     74 }
     75 
     76 public void setList(List<Item> list) {
     77 this.list = list;
     78 }
     79 
     80 public void setModel(DataModel<Item> model) {
     81 this.model = model;
     82 }
     83 
     84 public void setItem(Item item) {
     85 this.item = item;
     86 }
     87 
     88 public void setEdit(boolean edit) {
     89 this.edit = edit;
     90 } 
     91 
     92 }

Vamos entender como funciona o c�digo:

Linha 9: Atente para fazer o import correto da anota��o ViewScoped, pois existe outra classe ViewScoped em outro pacote, por�m com objetivo diferente do nosso;
Linha 15: Veja que estamos implementando Serializable para possibilitar ao ViewScoped armazenar o estado do nosso bean no �view map�;
Linhas 22-29: A anota��o @PostConstruct faz com que nosso m�todo init() seja chamado logo ap�s a inicializa��o do bean gerenciado, ou seja, isso ocorre depois da chamada do construtor do m�todo. Dentro do init() temos uma lista de objetos Item, onde colocamos o dao.list apenas para exemplificar que devemos retornar uma lista da camada DAO. Para evitar que o artigo perca o seu foco decidimos inicializar a lista de forma manual, criando item a item;
Linhas 32-38: O m�todo add() adiciona um objeto do tipo Item � lista de itens; colocamos aqui tamb�m um dao.create() para demonstrar que a cria��o do objeto deve ser feita na camada DAO, onde este dever� preencher corretamente o ID do bean. Decidimos abstrair a camada DAO e logo em seguida fazemos a cria��o manual do mesmo e adicionamos esta a lista de itens. Perceba que ap�s criamos um item, substituindo os valores da vari�vel �item�, possibilitando que novos valores sejam inseridos;
Linhas 40-43: Atrav�s de um DataModel conseguimos capturar o item que foi selecionado para edi��o e habilitamos a flag �edit� para true, assim a nossa camada de visualiza��o saber� que estamos trabalhando com uma edi��o;
Linhas 45-49: Quando o usu�rio clicar em salvar deve-se chamar um m�todo na camada DAO que fa�a a atualiza��o do registro no banco de dados, por isso deixamos comentado esse trecho, j� que n�o utilizaremos o mesmo neste momento. Depois disso criamos um item para que os campos sejam �limpos�, j� que novos valores dever�o ser inseridos. Logo ap�s colocamos a flag �edit� igual a false, sinalizando que terminamos de realizar a edi��o no item desejado;
Linhas 51-54: Assim como podemos inserir/atualizar um registro no banco de dados, tamb�m podemos deletar e, para isso, dever�amos chamar um m�todo respons�vel pela remo��o do registro na camada DAO. Em seguida removemos o item da lista de itens que est� sendo mostrada ao usu�rio.

O restante do c�digo � apenas getters e setters dos atributos e dispensa maiores explica��es. Na Listagem 2 mostraremos a classe Item apenas para exemplificar o uso do objeto �item� da Listagem 1.

Listagem 2. Classe Item


      import java.io.Serializable;
      public class Item implements Serializable {
    
             
             /**
              *
              */
             private static final long serialVersionUID = 1L;
             
             private Long id;
             private String value;
             
             public Long getId() {
                   return id;
             }
             public void setId(Long id) {
                   this.id = id;
             }
             public String getValue() {
                   return value;
             }
             public void setValue(String value) {
                   this.value = value;
             }
             @Override
             public int hashCode() {
                   final int prime = 31;
                   int result = 1;
                   result = prime * result + ((id == null) ? 0 : id.hashCode());
                   result = prime * result + ((value == null) ? 0 : value.hashCode());
                   return result;
             }
             @Override
             public boolean equals(Object obj) {
                   if (this == obj)
                          return true;
                   if (obj == null)
                          return false;
                   if (getClass() != obj.getClass())
                          return false;
                   Item other = (Item) obj;
                   if (id == null) {
                          if (other.id != null)
                                 return false;
                   } else if (!id.equals(other.id))
                          return false;
                   if (value == null) {
                          if (other.value != null)
                                 return false;
                   } else if (!value.equals(other.value))
                          return false;
                   return true;
             }
      }

A classe apresentada possui apenas dois atributos que vamos utilizar em nosso XHTML: ID e VALUE. � importante salientar que a sua classe deve implementar Serializable, pois ela est� dentro do bean gerenci�vel, mesmo que ela n�o seja diretamente o bean anotado com o @ViewScoped. Al�m disso, por padr�o, sempre colocamos o equals() e hashCode() em nossos Java Beans para que compara��es sejam feitas de forma correta.

Vamos agora ver a nossa p�gina XHTML, que far� uso do bean anotado com o @ViewScoped, conforme mostra a Listagem 3.

Listagem 3. crud.xhtml


      1 <!DOCTYPE html>
      2 <html xmlns="http://www.w3.org/1999/xhtml"
      3 xmlns:f="http://java.sun.com/jsf/core"
      4 xmlns:h="http://java.sun.com/jsf/html">
      5 <h:head>
      6 <title>CRUD para ViewScoped</title>
      7 </h:head>
      8 <h:body>
      9 <h3>Lista de Itens</h3>
      10 <h:form rendered="#{not empty bean.list}">
      11 <h:dataTable value="#{bean.model}" var="item">
      12 <h:column><f:facet name="header">ID</f:facet>#{item.id}</h:column>
      13 <h:column><f:facet name="header">Value</f:facet>#{item.value}</h:column>
      14 <h:column><h:commandButton value="edit" action="#{bean.edit}" /></h:column>
      15 <h:column><h:commandButton value="delete" action="#{bean.delete}" /></h:column>
      16 </h:dataTable>
      17 </h:form>
      18 <h:panelGroup rendered="#{empty bean.list}">
      19 <p>A tabela est� vazia, por favor adicione itens</p>
      20 </h:panelGroup>
      21 <h:panelGroup rendered="#{!bean.edit}">
      22 <h3>Add item</h3>
      23 <h:form>
      24 <p>Value: <h:inputText value="#{bean.item.value}" /></p>
      25 <p><h:commandButton value="add" action="#{bean.add}" /></p>
      26 </h:form>
      27 </h:panelGroup>
      28 <h:panelGroup rendered="#{bean.edit}">
      29 <h3>Edit item #{bean.item.id}</h3>
      30 <h:form>
      31 <p>Value: <h:inputText value="#{bean.item.value}" /></p>
      32 <p><h:commandButton value="save" action="#{bean.save}" /></p>
      33 </h:form>
      34 </h:panelGroup>
      35 </h:body>
      36 </html>

Quando citamos o termo �Bean gerenci�vel� trata-se do bean que o JSF, CDI ou qualquer outro framework que possua inje��o de depend�ncias est� gerenciando, evitando a instancia��o manualmente desta classe. Assim, chamaremos o bean gerenciado de BK (BackingBean) para facilitar as explica��es.

Ao abrir a p�gina crud.xhmtl, o BK � inicializado no contexto da aplica��o e o m�todo init() � chamado ap�s a sua constru��o ter sido finalizada com sucesso. A partir deste momento o ViewScoped � acionado e o estado do BK ser� mantido enquanto estivermos fazendo requisi��es na mesma p�gina, ou seja, na crud.xhtml.

Repare que na nossa p�gina temos a seguinte divis�o:

Linhas 10-20: Temos a listagem de itens contidos no atributo List<Item> do BK. O dataTable s� � mostrado/renderizado se houverem itens a serem mostrados, caso contr�rio, o panelGroup ser� renderizado mostrando a mensagem �A tabela est� vazia, por favor adicione itens�;
Linhas 21-27: Se��o para adicionar novos itens digitando o valor que deseja colocar e depois em �add�. Assim, este item ser� adicionado na lista e um novo ser� criado, permitindo adicionar novos valores. Aqui o ViewScoped j� come�a a atuar, pois quando clicamos em add veremos que o datatable crescer�, ou seja, o estado do BK ser� mantido. Prova disto � que a lista cresce sem perder seu valor anterior;
Linhas 28-34: Podemos escolher um item na lista e clicar em editar para alterarmos o seu valor. Logo em seguida, clicando em salvar, persistiremos os dados alterados no banco de dados.

ConversationScoped

O ViewScoped n�o resolve qualquer problema a qualquer hora, pois imagine precisar trabalhar com v�rias p�ginas diferentes para um mesmo bean gerenci�vel: este n�o atender�, pois ele tem uma rela��o 1:1 com a p�gina XHTML. Essa situa��o de muitas p�ginas para um mesmo bean gerenci�vel � muito comum em wizards ou mesmo em processos complexos que exijam muitas telas para o preenchimento correto das informa��es. Ent�o aqui entra o ConversationScoped que, diferentemente do ViewScoped, que � proveniente do JSF, � proveniente do CDI, ou seja, estamos misturando escopos de dois frameworks distintos.

O Escopo de conversa��o difere dos outros pelo fato de poder dizer onde ele terminar e onde come�a, ou seja, voc� delimita as fronteiras. Se quiser que ele comece ao acessar a pagina001.xhtml e termine quando o usu�rio acessar a pagina004.xhtml, isso � totalmente poss�vel. Vejamos um exemplo simples de in�cio e fim de conversa��o na Listagem 4.

Listagem 4. Limitando fronteiras do ConversationScoped


      1 import javax.enterprise.context.Conversation;
     2 
     3 private Conversation conversation;
     4 
     5 public void beginConversation() {
     6 if (conversation.isTransient()) {
     7 conversation.setTimeout(1800000L);
     8 conversation.begin();
     9 } 
     10 }
     11 
     12 public void endConversation() {
     13 if (!conversation.isTransient()) {
     14 conversation.end();
     15 }
     16 }

O c�digo consiste na exemplifica��o b�sica de uma inicializa��o e finaliza��o de uma conversa��o:

Linha 3: � necess�rio termos o atributo do tipo javax.enterprise.context.Conversation para que possamos manipular a conversa��o;
Linhas 5-9: Verificamos aqui se a conversa��o � transiente, ou seja, se ainda n�o foi inicializada. Caso verdadeiro, ent�o iniciamos uma nova com o timeout de 30 minutos;
Linhas 12-14: Verificamos se a conversa��o n�o � transiente e ent�o finalizamos a mesma, garantindo que apenas conversa��es que foram inicializadas podem ser finalizadas.

Poder�amos usar o ConversationScoped para apenas uma p�gina sem problemas, ou seja, 1:1 do XHTML com o seu bean gerenci�vel. Mas, porque usar o ConversationScoped neste caso se podemos usar o ViewScoped?

Em casos que temos v�rias p�ginas para um mesmo bean gerenci�vel cabe perfeitamente o uso da conversa��o.

Lembre-se que devemos explicitamente iniciar a conversa��o quando a p�gina for aberta e fech�-la quando alguma a��o for realizada, por exemplo, quando o usu�rio clicar no bot�o salvar.

Listagem 5. Iniciando a conversa��o de uma p�gina XHTML


      1 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
     2 <html xmlns="http://www.w3.org/1999/xhtml"
     3 xmlns:h="http://java.sun.com/jsf/html"
     4 xmlns:f="http://java.sun.com/jsf/core"
     5 xmlns:ui="http://java.sun.com/jsf/facelets">
     6 
     7 <h:head>
     8 
     9 </h:head>
     10 <h:body>
     11 <h:form>
     12 <f:metadata>
     13 <f:event listener="#{bean.beginConversation()}"
     14 type="preRenderView" />
     15 </f:metadata>
     16 <h:commandButton value="Prox.Pagina" action="#{begin.proxPagina()}" />
     17 </h:form>
     18 
     19 
     20 </h:body>
     21 </html>

O que nos importa na Listagem 5 � verificar que iniciamos a conversa��o antes da renderiza��o da p�gina com o f:event da linha 12. Assim, teremos certeza que as chamadas ao bean que a p�gina far� n�o dar�o erro, pois a conversa��o j� foi inicializada.

Na linha 16 o commandButton tem a fun��o de chamar a action �proxPagina()� que ir� levar o usu�rio a outra p�gina.

Listagem 6. Finalizando a conversa��o


      1 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
     2 <html xmlns="http://www.w3.org/1999/xhtml"
     3 xmlns:h="http://java.sun.com/jsf/html"
     4 xmlns:f="http://java.sun.com/jsf/core"
     5 xmlns:ui="http://java.sun.com/jsf/facelets">
     6 
     7 <h:head>
     8 
     9 </h:head>
     10 <h:body>
     11 <h:form>
     12 <h:commandButton value="Concluir" action="#{begin.endConversation()}" />
     13 </h:form>
     14 
     15 
     16 </h:body>
     17 </html>

Nesta segunda p�gina da Listagem 6 n�o precisamos inicializar a conversa��o, pois ela j� foi feita na primeira p�gina. Agora, quando o usu�rio clicar em Concluir, o m�todo endConversation() ser� disparado e a conversa��o ser� finalizada.

O CDI envia um par�metro dentro das requisi��es do JSF chamado CID, que � uma etiqueta para a sua conversa��o. � com este que o CDI sabe qual bean deve construir. Quando mudar de p�gina atrav�s de uma action do seu BackingBean (Bean Gerenci�vel), este CID � acoplado automaticamente na sua requisi��o, mas se decidir mudar de p�gina sem passar por uma requisi��o do JSF, ent�o precisar� explicitamente colocar o CID como par�metro, como vemos na Listagem 7.

Listagem 7. Usando CID


      <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
      <html xmlns="http://www.w3.org/1999/xhtml"
               xmlns:h="http://java.sun.com/jsf/html"
               xmlns:f="http://java.sun.com/jsf/core"
               xmlns:ui="http://java.sun.com/jsf/facelets">
       
      <h:head>
       
      </h:head>
      <h:body>
      <h:form>
       
      <h:link outcome="/prox_pagina.xhtml" value="Pagina para Finalizar a Conversa��o">
              <f:param name="cid" value="#{bean.conversation.id}" />
          </h:link>
      
    
      </h:form>
                        
      </h:body>
      </html>

Perceba que n�o fazemos uso do JSF para navegarmos para a pr�xima p�gina, ent�o neste caso devemos explicitamente usar o f:param para dizer o valor do CID, assim, quando a pr�xima p�gina for renderizada carregar� automaticamente o bean gerenci�vel correto. Se n�o passar o CID, neste caso, quando a pr�xima p�gina for aberta, ela n�o encontrar� nenhum bean gerenci�vel e trar� um erro na tela do usu�rio.

Se estiver usando Maven como gerenciador de depend�ncias poderemos adicionar o c�digo da Listagem 8 ao seu pom.xml para usar o Weld, uma implementa��o do CDI.

Listagem 8. Importando CDI no pom.xml


      <dependency>
        <groupId>org.jboss.weld.servlet</groupId>
        <artifactId>weld-servlet</artifactId>
        <version>2.3.0.Final</version>
      </dependency>

Conclu�mos que o ViewScoped serve para situa��es onde precisamos ligar uma p�gina para um bean gerenci�vel, enquanto o ConversationScoped liga N p�ginas para um bean gerenci�vel. Assim, temos a seguinte regra:

ViewScoped � 1 xhtml: 1 BackingBean
ConversationScoped � N xhtml: 1 BackingBean

Isso n�o significa que n�o podemos usar o ConversationScoped em 1:1, mas a pr�tica e a teoria dizem que essa n�o � a melhor forma de us�-lo. � importante tamb�m entender que existem algumas outras vari�veis de escopos de conversa��o, como as propostas pelo JBoss Seam e o pr�prio JSF 2.0, mas neste caso demos prefer�ncia ao CDI pelo seu uso frequente e grande p�blico no mercado.

Tecnologias:

Confira outros conte�dos:

Introdu��o ao JDBC

Novidades do Java

Teste unit�rio com JUnit

Assista grátis a nossa aula inaugural

Perguntas frequentes

Quem somos?

Por que a programação se tornou a profissão mais promissora da atualidade?

Como faço para começar a estudar?

Em quanto tempo de estudo vou me tornar um programador?

Sim, você pode se tornar um programador e não precisa ter diploma de curso superior!

O que eu irei aprender estudando pela DevMedia?

Principais diferenciais da DevMedia

Qual o investimento financeiro que preciso fazer para me tornar um programador?

Como funciona a forma de pagamento da DevMedia?

Por Ronaldo Em 2016

Coment�rios nesta publica��o Escrever um coment�rio sobre conte�do

Rogerio

N�vel 0

Ol�, Ronaldo. Estou implementando a famosa funcionalidade pesquisa com possibilidade de detalhamento dos itens mostrados na lista de resultado. Acredito que o escopo de conversa��o seja interessante, pois a tela de detalhamento usa o mesmo ManagedBean e ela tem um bot�o voltar para retornar � pesquisa feita sem que o usu�rio tenha que refaz�-la. O problema todo �: em que momento a conversa��o ser� encerrada j� que o usu�rio pode ir e voltar infinitas vezes? Resposta: Quando ele sair da p�gina. Mas como eu capturo isso para invocar conversation.end()?

há +1 ano

Ver coment�rio anterior

Ronaldo Lanhellas

N�vel 0

Ol� Rogerio, voc� tem 2 op��es: Ou encerra a conversa��o explicitamente, chamando o conversation.end() ou deixa ela aberta que uma hora ir� receber um timeout e automaticamente ser� encerrada.

Eu aconselharia voc� a fazer o seguinte: Quando o usu�rio executar alguma a��o que ir� redirecion�-lo para outra p�gina, por exemplo um CANCELAR, ent�o voc� chama o conversation.end(). Se ele simplesmente clicar em outro item do MENU, a conversa��o ir� continuar aberta em background mas depois de um tempo ir� ser destru�da (dependendo do seu timeout, que n�o deve ser muito grande).

há +1 ano

Nossos casos de sucesso

Leonardo Carlos

Eu sabia pouqu�ssimas coisas de programa��o antes de come�ar a estudar com voc�s, fui me especializando em v�rias �reas e ferramentas que tinham na plataforma, e com essa bagagem consegui um est�gio logo no in�cio do meu primeiro per�odo na faculdade.

Lucas Rodrigues

Estudo aqui na Dev desde o meio do ano passado! Nesse per�odo a Dev me ajudou a crescer muito aqui no trampo.
Fui o primeiro desenvolvedor contratado pela minha empresa. Hoje eu lidero um time de desenvolvimento!
Minha meta � continuar estudando e praticando para ser um Full-Stack Dev!

Her�clito J�nior

Economizei 3 meses para assinar a plataforma e sendo sincero valeu muito a pena, pois a plataforma � bem intuitiva e muuuuito did�tica a metodologia de ensino. Sinto que estou EVOLUINDO a cada dia. Muito obrigado!

Julio Cablen

Nossa! Plataforma maravilhosa. To amando o curso de desenvolvimento front-end, tinha coisas que eu ainda n�o tinha visto. A did�tica � do jeito que qualquer pessoa consegue aprender. S�rio, to apaixonado, adorando demais.

Joelberth Sena

Adquiri o curso de voc�s e logo percebi que s�o os melhores do Brasil. � um passo a passo incr�vel. S� n�o aprende quem n�o quer. Foi o melhor investimento da minha vida!

Felipe Nunes

Foi um dos melhores investimentos que j� fiz na vida e tenho aprendido bastante com a plataforma. Voc�s est�o fazendo parte da minha jornada nesse mundo da programa��o, irei assinar meu contrato como programador gra�as a plataforma.

Wanderson Oliveira

Comprei a assinatura tem uma semana, aprendi mais do que 4 meses estudando outros cursos. Exerc�cios pr�ticos que n�o tem como n�o aprender, est�o de parab�ns!

Jos� Lucas

Obrigado DevMedia, nunca presenciei uma plataforma de ensino t�o presente na vida acad�mica de seus alunos, parab�ns!

Eduardo Dorneles

Aprendi React na plataforma da DevMedia h� cerca de 1 ano e meio... Hoje estou h� 1 ano empregado trabalhando 100% com React!

Adauto Junior

J� fiz alguns cursos na �rea e nenhum � t�o bom quanto o de voc�s. Estou aprendendo muito, muito obrigado por existirem. Est�o de parab�ns... Espero um dia conseguir um emprego na �rea.

Ver todos os casos de sucesso