// 
//     Licensed to the Apache Software Foundation (ASF) under one
//     or more contributor license agreements.  See the NOTICE file
//     distributed with this work for additional information
//     regarding copyright ownership.  The ASF licenses this file
//     to you under the Apache License, Version 2.0 (the
//     "License"); you may not use this file except in compliance
//     with the License.  You may obtain a copy of the License at
// 
//       http://www.apache.org/licenses/LICENSE-2.0
// 
//     Unless required by applicable law or agreed to in writing,
//     software distributed under the License is distributed on an
//     "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//     KIND, either express or implied.  See the License for the
//     specific language governing permissions and limitations
//     under the License.
//

= Adicionando Instrumentação do JMX (Java Management Extensions) à Aplicação Java
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: Adicionando Instrumentação do JMX (Java Management Extensions) à Aplicação Java - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Adicionando Instrumentação do JMX (Java Management Extensions) à Aplicação Java

*Duração esperada: 60 minutos*

O Módulo do Assistente JMX do NetBeans integra a tecnologia do JMX correta para seu workflow no NetBeans IDE. Este módulo permite que você desenvolva aplicações de gerenciamento, adicione o gerenciamento às aplicações existentes, desenvolva aplicações do gerenciador e monitore o estado da Máquina Virtual.

Este tutorial mostra como adicionar gerenciamento a uma aplicação existente (a aplicação Jogo de Anagramas de amostra do NetBeans). Primeiro você criará um Projeto Java de Anagrama não gerenciável. Depois você usará os Assistentes do JMX para gerar 90% do gerenciamento. Em seguida, você implementará o procedimento de gerenciamento específico da aplicação. Finalmente, você usará a opção Executar/Depurar projeto com JConsole para visualizar o MBeans do Anagrama.


== Exercícios do tutorial

image::images/netbeans-stamp-80-74-73.png[title="O conteúdo desta página se aplica ao NetBeans IDE 7.2, 7.3, 7.4 e 8.0"]

* <<Exercise_1,Exercício 1: Criando o projeto de amostra do Jogo de Anagramas do NetBeans>>
* <<Exercise_2,Exercício 2: Criando o MBean Padrão do JMX AnagramsStats e sua interface de Gerenciamento>>
* <<Exercise_3,Exercício 3: Adicionando atributos, operação e notificação ao MBean Padrão JMX AnagramsStats>>
* <<Exercise_4,Exercício 4: Adicionando o código de implementação ao MBean Padrão do JMX AnagramsStats>>
* <<Exercise_5,Exercício 5: Estabelecendo conexão ao gerenciamento e à aplicação juntos>>
* <<Exercise_6,Exercício 6: Executando o Jogo de Anagramas com JConsole>>


=== Pré-requisitos

Este tutorial pressupõe que você tenha algum conhecimento básico das tecnologias a seguir ou alguma experiência de programação com elas:

* Tecnologia JMX: link:http://download.oracle.com/javase/6/docs/technotes/guides/jmx/index.html[+ Documentação on-line do JMX+]
* Tecnologia Java: link:http://www.oracle.com/technetwork/java/javase/tech/index.html[+ Visão Geral das Tecnologias Java SE+]
* NetBeans IDE

Você também se beneficiará tendo conhecimento sobrelink:http://download.oracle.com/javase/6/docs/technotes/guides/management/index.html[+ Monitoramento e Gerenciamento da Plataforma Java+]


=== Software Necessário para o Tutorial

Para este tutorial, você precisa ter instalado no computador os seguintes softwares:

|===
|Software ou Recurso |Versão Necessária 

|link:https://netbeans.org/downloads/index.html[+NetBeans IDE+] |Versão Java 7.2, 7.3, 7.4, 8.0 

|link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+JDK (Java Development Kit)+] |versão 7 ou 8 

|Plug-in do JMX |Disponível na Central de Atualização do NetBeans 

|Plug-in de JConsole |Disponível na Central de Atualização do NetBeans 
|===

Para instalar os plug-ins *JMX* e *JConsole*, selecione Ferramentas > Plug-ins e faça download do módulo do Centro de Atualização do NetBeans.


=== Recursos


== Exercício 1: Criando o projeto de amostra do Jogo de Anagramas do NetBeans

O objetivo deste exercício é criar um Projeto Java executável. O jogo de Anagramas é uma Aplicação Swing que exibe uma palavra embaralhada para o usuário e espera que o usuário resolva o anagrama.

1. Selecione Arquivo > Novo Projeto (Ctrl-Shift-N).
2. Selecione a categoria Amostras > Java.
3. Selecione o projeto Jogo de Anagramas. Clique em Próximo.
4. No painel Nome e Localização do Projeto, defina a localização do projeto ou mantenha o valor default, se ele for adequado. Marque a caixa de seleção "Definir como Projeto Principal" se não estiver selecionada porque ela tornará as próximas ações mais fáceis. Clique em Finalizar.

Quando você clica em Finalizar, o IDE cria o projeto Jogo de Anagramas e exibe o projeto na janela Projetos.


[start=5]
. Clique com o botão direito do mouse no projeto AnagramGame e selecione Propriedades.

[start=6]
. Selecione a categoria Códigos-fonte e confirme se o formato de Código-fonte/Binário está definido como JDK 7 ou JDK 8. Clique em OK.

*Observação.* Para selecionar JDK 7 ou JDK 8, a Plataforma Java do projeto Jogo de Anagramas também deve ser pelo menos JDK 7 ou JKD 8, respectivamente. Você pode alterar a Plataforma Java do Jogo de Anagramas na categoria Bibliotecas na janela Propriedades.


[start=7]
. Clique com o botão direito do mouse no nó de projeto Jogo de Anagramas e selecione Executar.

Quando escolher Executar, o IDE compilará e acionará a aplicação Jogo de Anagramas.


== Exercício 2: Criando o MBean Padrão do JMX AnagramsStats e sua interface de Gerenciamento

A meta deste exercício é criar um esqueleto do MBean Padrão do JMX que é composto de sua classe de implementação e de sua interface de gerenciamento.

Execute as etapas a seguir para criar o MBean Padrão do JMX.

1. Confirme se o projeto Jogo de Anagramas está definido como o projeto principal.
2. Escolha Arquivo > Novo Arquivo (Ctrl-N).
3. Na categoria JMX, selecione MBean Padrão. Clique em Próximo.
image::images/jmx-newfile.png[title="Tipo de arquivo MBean Padrão no Assistente Novo Arquivo"]

[start=4]
. Digite as seguintes informações no painel Nome e Localização:
* Nome da Classe:  ``AnagramsStats`` 
* Localização: Pacotes de Origem (default)
* Pacote:  ``com.toy.anagrams.mbeans`` 
* Descrição:  ``Monitoramento e Gerenciamento do Jogo de Anagramas`` 

image::images/jmx-newmbean.png[]

[start=5]
. Clique em Finalizar.

Quando você clicar em Finalizar, a classe  ``AnagramsStats``  do MBean e a interface  ``AnagramsStatsMBean``  do MBean são geradas no pacote  ``com.toy.anagrams.mbeans``  do projeto AnagrmGame. Agora há vários esqueletos vazios que você preencherá no próximo exercício.


== Exercício 3: Adicionando atributos, operação e notificação ao MBean Padrão JMX AnagramsStats

A meta deste exercício é preencher o esqueleto do MBean gerado, de forma que ele monitore o tempo gasto pelo usuário para resolver um novo anagrama e uma notificação do JMX seja enviada, cada vez que um anagrama for resolvido.

O MBean conterá o seguinte:

* Dois Atributos chamados  ``LastThinkingTime``  e  ``NumResolvedAnagrams`` 
* Uma Operação chamada  ``resetAll`` .
* Uma notificação do tipo  ``AttributeChangeNotification`` . Esta notificação é emitida quando  ``LastThinkingTime``  é atualizado.

Execute as seguintes etapas para preencher o esqueleto do MBean.

1. Abra o arquivo de implementação  ``AnagramsStats.java``  do MBean no editor do NetBeans.
2. Clique com o botão direito do mouse no editor de código-fonte e selecione *JMX > Adicionar Atributos de MBean* no menu pop-up.
3. Adicione o atributo  ``LastThinkingTime``  clicando no botão Adicionar Atributo e fornecendo as seguintes informações.
* Nome do Atributo:  ``LastThinkingTime`` 
* Tipo: int
* Acesso: Somente Leitura
* Descrição:  ``Tempo gasto para resolver o último anagrama`` 

*Observação.* Não clique em OK ainda!


[start=4]
. Clique em Adicionar Atributo novamente e adicione o seguinte atributo  ``NumSolvedAnagrams`` . Clique em OK.
* Nome do Atributo:  ``NumSolvedAnagrams`` 
* Tipo: int
* Acesso: Somente Leitura
* Descrição:  ``Número de anagramas resolvidos`` 

image::images/jmx-addattribute.png[]

O código necessário para expor os atributos  ``LastThinkingTime``  e  ``NumSolvedAnagrams``  somente para leitura é gerado na classe  ``AnagramsStats``  do MBean e em sua interface.

Você pode ver a declaração de campos privados e os métodos getter públicos. Mais precisamente, olhando a view membros e no código gerado, você observará que os métodos  ``getLastThinkingTime``  e  ``getNumSolvedAnagrams``  são gerados na classe  ``AnagramsStats``  e em sua interface  ``AnagramsStatsMBean`` . Os campos privados  ``lastThinkingTime``  e  ``numSolvedAnagrams``  do tipo  ``int``  também foram gerados e serão utilizados para armazenar os valores do atributo real.

Em seguida, você adicionará mais três atributos para manter controle do tempo mínimo e máximo de reflexão que o usuário leva e do anagrama atual que está sendo proposto ao usuário.


[start=5]
. Clique com o botão direito do mouse no editor de código-fonte e selecione *JMX > Adicionar Atributos de MBean* no menu pop-up.

[start=6]
. Clique no botão Adicionar Atributo e adicione os seguintes atributos.
|===

|Nome do Atributo |Tipo |Acesso |Descrição 

|MinThinkingTime |int |Somente para Leitura |Tempo mínimo decorrido para resolver um anagrama 

|MaxThinkingTime |int |Somente para Leitura |Tempo máximo decorrido para resolver um anagrama 

|CurrentAnagram |String |Somente para Leitura |Anagrama atual para resolução 
|===

A caixa de diálogo deve ser semelhante à seguinte imagem.

image::images/jmx-addattribute2.png[title="Caixa de diálogo Adicionar Atributo após adicionar mais 3 atributos"]

*Observação.* Observe que os atributos que você já criou estão listados na caixa de diálogo.


[start=7]
. Clique em OK e salve suas alterações.

[start=8]
. Clique com o botão direito do mouse no editor de código-fonte e selecione *JMX > Adicionar Operações de MBean* no menu pop-up.

[start=9]
. Clique em Adicionar Operação e adicione a operação  ``resetAll()``  e especifique os seguintes detalhes. Clique em OK.
* Nome da Operação:  ``resetAll`` 
* Tipo de Retorno:  ``void`` 
* Parâmetros: (deixe vazia)
* Exceções: (deixe vazia)
* Descrição:  ``Redefinir estado do MBean`` 

image::images/jmx-addoperation.png[title="Adicionando a operação resetAll na caixa de diálogo Adicionar Operação"]

Depois de clicar em OK, você poderá ver se o código necessário para expor a operação  ``resetAll``  foi gerado na classe  ``AnagramsStats``  do MBean e em sua interface.


[start=10]
. Clique com o botão direito do mouse no editor de código-fonte e selecione *JMX > Interface Implementar NotificationEmitter* no menu pop-up.

[start=11]
. Especifique os seguintes detalhes na caixa de diálogo Implementar interface NotificationEmitter.
* *Selecione Gerar Delegação para Difusor.* Todos os métodos declarados pela interface  ``NotificationEmitter``  serão implementados, delegando um difusor de notificação. Um difusor de notificação simplifica a forma em que o MBean enviará notificações.
* *Selecione Gerar Número de Sequência Privada e Acessador.* Um código será gerado para tratar o valor do número de sequência exclusivo que deve ser adicionado a cada notificação enviada.
* *Clique em Adicionar Notificação.* Especifique os detalhes a seguir na tabela Notificações.
* Classe de Notificação:  ``javax.management.AttributeChangeNotification`` 
* Tipo de Notificação: (é definido automaticamente para  ``ATTRIBUTE_CHANGE`` )
* Descrição:  ``O Anagrama foi Resolvido`` 

image::images/jmx-changenotification.png[title="Adicionando notificação de alteração na caixa de diálogo Implementar NotificationEmitter"]

Clique em OK.

Você pode ver que o código necessário para implementar a interface  ``NotificationEmitter``  foi gerado na classe  ``AnagramsStats``  do MBean. Você pode ver como a implementação gerada delega o tratamento de notificações para a classe  ``NotificationBroadcasterSupport`` .


[start=12]
. Salve as alterações.

Neste exercício, você aprendeu a adicionar atributos, operações e emissão de notificações a um MBean usando o módulo Assistente JMX. As etapas necessárias para preencher seu MBean com a infraestrutura necessária para expor as informações de gerenciamento que você quer são finalizadas agora. Agora você precisa adicionar uma lógica interna à implementação da classe  ``AnagramsStats``  do MBean, em seguida, criar a ponte entre a aplicação MBean e o Jogo de Anagramas.


== Exercício 4: Adicionando o código de implementação ao MBean Padrão do JMX AnagramsStats

Neste exercício, você adicionará uma lógica interna à implementação da classe  ``AnagramsStats``  do MBean.

Execute as etapas a seguir para adicionar o código de implementação.

1. Os atributos já têm seus campos privados declarados e nada precisa ser adicionado a seus métodos getter.
2. O método  ``resetAll()``  precisa ser implementado. O corpo gerado está vazio. Quando  ``resetAll()``  é chamado, simplesmente definimos todos os contadores para 0. Adicione as seguintes linhas do código (em negrito) ao corpo do método  ``resetAll()`` :

[source,java]
----

public void resetAll() {
    *minThinkingTime = 0;
    maxThinkingTime = 0;
    lastThinkingTime = 0;
    numSolvedAnagrams = 0;*
}
----

[start=3]
. Você também precisa adicionar algum código de implementação que executará o seguinte:
* calcular o tempo de reflexão que o usuário levou para resolve o último anagrama,
* calcular os tempos mínimo e máximo de reflexão,
* incrementar o contador de anagramas resolvidos,
* saber que é o anagrama atual,
* criar e enviar a notificação quando um anagrama é resolvido.

Para esse objetivo, você adiciona um campo privado  ``startTime``  para armazenar o tempo no qual o último anagrama foi apresentado ao usuário, dois métodos  ``startThinking()``  e  ``stopThinking()``  para executar as operações listadas acima e um método  ``setCurrentAnagram()`` .

Adicione o seguinte código a  ``AnagramsStats.java`` ; por exemplo, no fim da implementação de classe.


[source,java]
----

/*
 * Methods exposed to Anagrams application to feed management with data.
 */

//Stores the time at which a new anagram is proposed to the user.
private long startTime;

/**
 * A new Anagram is proposed to the user: store current time.
 */
public void startThinking() {
    startTime = System.currentTimeMillis();
}

/**
 * An Anagram has been resolved.
 */
public void stopThinking() {

    //Update the number of resolved anagrams
    numSolvedAnagrams++;

    // Compute last, min and max thinking times
    lastThinkingTime = (int) (System.currentTimeMillis() - startTime) / 1000 ;
    minThinkingTime = (lastThinkingTime < minThinkingTime || minThinkingTime == 0) ?
                      lastThinkingTime :
                      minThinkingTime;
    maxThinkingTime = (lastThinkingTime > maxThinkingTime) ?
                      lastThinkingTime :
                      maxThinkingTime;

    //Create a JMX Notification
    Notification notification = new Notification(AttributeChangeNotification.ATTRIBUTE_CHANGE,
            this,
            getNextSeqNumber(),
            "Anagram solved: " + currentAnagram);

    // Send a JMX notification.
    broadcaster.sendNotification(notification);
}

/**
 * Set latest anagram which has been computed by the Anagram application
 */
public void setCurrentAnagram(String currentAnagram) {
    this.currentAnagram = currentAnagram;
}
----

Observe que os três métodos  ``startThinking()`` ,  ``stopThinking()``  e  ``setCurrentAnagram()``  não fazem parte da interface de gerenciamento do MBean porque eles não são declarados na interface  ``AnagramsStatsMBean`` , mas são públicos porque são chamados pela aplicação Jogo de Anagramas para informar ao MBean cada vez que um novo anagrama é apresentado ao usuário e quando é resolvido, e que é o anagrama atual. Dessa forma, eles são uma parte necessária da ponte entre a aplicação e nosso MBean.

Observe também como uma notificação JMX do tipo  ``ATTRIBUTE_CHANGE``  é enviada cada vez que um anagrama é resolvido.

Agora você concluiu a implementação do MBean. Nesta seção, você adicionou código e métodos para permitir o seguinte:

* atualizações de estado do MBean interno
* chamadas da aplicação
* envio de notificações do JMX


== Exercício 5: Estabelecendo Conexão ao Gerenciamento e à Aplicação Juntos

Neste exercício, vamos adicionar o código à aplicação Jogo de Anagramas, de forma que ele possa acessar o MBean para passar informações de gerenciamento.

Execute as seguintes etapas para

1. Abra  ``Anagrams.java``  no editor.

A classe  ``Anagrams``  no pacote  ``com.toy.anagrams.ui``  é a classe  ``main``  da aplicação de Jogos de Anagramas. O arquivo é aberto na view Design do Editor porque a classe  ``Anagrams``  também é a classe da Interface do Usuário.


[start=2]
. Clique no botão Código-fonte na parte superior da janela Editor para editar a classe na view Código-fonte.

[start=3]
. Adicione o seguinte método privado  ``initManagement()``  vazio para a classe  ``Anagrams`` : após o construtor  ``Anagrams`` .

[source,java]
----

/**
 * JMX initialization:
 * Create and register Anagrams MBean in Platform MBeanServer.
 * Initialize thinking time and current anagram.
 */
private void initManagement() throws Exception {

}
----

[start=4]
. Adicione a seguinte chamada ao método  ``initManagement()``  no fim do construtor da classe  ``Anagrams``  antes de a chave de fechamento marcar o fim do construtor.

[source,java]
----

//JMX Management initialization
initManagement();
          
----

Adicione também uma cláusula  ``throws Exception``  ao constructo  ``Anagrams()``  e envolva a instrução  ``new Anagrams().setVisible(true);``  com um bloco try/catch no método  ``Main()``  para compilação. Você poderá ver o glifo de sugestão na margem esquerda do editor. Coloque o cursor de inserção na linha do código e pressione Alt-Enter para chamar a dica de código no editor de código-fonte.

image::images/jmx-initmanagement-try.png[title="Dica de código para adicionar try-catch"]

Veja a seguir o que deverá ser exibido neste estágio [clique para exibir uma imagem maior]:

[.feature]
--
image:images/jmx-initmanagement-sm.png[role="left", link="images/jmx-initmanagement.png"]
--

[start=5]
. Agora vamos adicionar o código de registro do MBean ao método  ``initManagement()`` , usando o assistente de registro do MBean do Módulo JMX:

Na janela do editor do código-fonte  ``Anagrams.java`` , clique com o botão direito do mouse *no* corpo do método  ``initManagement()`` , selecione o submenu JMX e, em seguida, selecione a ação "Gerar Registro de MBean...". No painel "Instanciar e Registrar MBean", que é mostrado acima, mantenha o botão de opção "Registrar MBean Existente" selecionado, clique no botão Procurar ou escolha a classe  ``AnagramsStats``  do MBean e clique em OK no painel Procurar. Agora você deverá ver o seguinte:

image::images/jmx-registermbeandialog.png[]

Não é necessário alterar o Nome do Objeto e o Construtor do MBean especificados automaticamente. Clique em OK. Você verá o código de registro do MBean no corpo do método  ``initManagement()`` .


=== Melhor prática para nomear seus MBeans

* Ao nomear seu MBean, use a chave " ``type=`` " no Nome do Objeto. O valor desta chave deve ser a classe MBean (em nosso caso  ``AnagramsStats`` ).
* No caso de um MBean singleton (um MBean que tem uma instância única em sua aplicação), ter esta chave exclusiva é suficiente para fins de nomeação.
* Evita a criação de muitos nomes de domínio. Use seus nomes de pacote Java da aplicação. Você também pode usar o nome de domínio default: não especificar um domínio antes do separador  ``ObjectName``  " ``:`` " faz referência implicitamente ao domínio default.

A aplicação das melhores práticas fará com que o procedimento usado para nomear seus MBeans seja mais formalizado.

Dessa forma, o  ``ObjectName``  criado por default em nosso caso acima é:  ``com.toy.anagrams.mbeans:type=AnagramsStats`` 


No contexto deste tutorial, uma etapa extra é obrigatória. Você deseja que a aplicação tenha acesso à classe que implementa a interface de gerenciamento ( ``AnagramsStats`` ). Esta não é uma regra geral, mas ela pode ser útil quando sua aplicação precisar expandir dados para um MBean. Neste caso, os métodos  ``startThinking()`` ,  ``stopThinking()``  e  ``setCurrentAnagram()``  não são métodos de gerenciamento, mas são usados pela aplicação Jogo de Anagramas para notificar o MBeans que ocorreram alguns eventos. Por sua vez, o MBean atualiza seu estado. Para tornar o  ``AnagramsStats``  acessível da classe  ``Anagrams``  da IU, precisamos da classe  ``Anagrams``  para manter uma referência direta à instância do MBean  ``AnagramsStats`` .

Portanto, você precisa fazer as seguintes alterações no código do arquivo  ``Anagrams.java`` .


[start=6]
. Adicione o seguinte campo privado à classe  ``Anagrams`` .

[source,java]
----

    // Reference to the AnagramsStats MBean
    private AnagramsStats mbean;
    
----

[start=7]
. Inicialize a referência ao MBean  ``AnagramsStats``  no método  ``initManagement()``  modificando o código de Registro do MBean gerado, de forma que ele leia o seguinte:

[source,java]
----

private void initManagement() throws Exception {
    try { // Register MBean in Platform MBeanServer
         *mbean = new AnagramsStats();*
         ManagementFactory.getPlatformMBeanServer().
                registerMBean(*mbean*,
                new ObjectName("com.toy.anagrams.mbeans:type=AnagramsStats"));
    } catch (JMException ex) {
        *ex.printStackTrace();*
}
----

[start=8]
. Inicialize o estado  ``AnagramsStats``  do MBean: quando a aplicação Jogo de Anagramas é iniciada, um anagrama é exibido imediatamente. Assim, é necessário informar ao MBean o valor da string do anagrama e começar a calcular o tempo de reflexão. Copie e cole as linhas abaixo no fim do método  ``initManagement()`` :

[source,java]
----

       // When the Anagrams game is first displayed, a word is proposed to the user.
       // We must start time computing and set the current anagram
       mbean.startThinking();
       mbean.setCurrentAnagram(wordLibrary.getScrambledWord(wordIdx));
      
----

Veja a seguir o que deverá ser exibido neste estágio [clique para exibir uma imagem maior]:

[.feature]
--
image:images/jmx-initmanagement2-sm.png[role="left", link="images/jmx-initmanagement2.png"]
--

Agora você precisa adicionar o código para rastrear a experiência do usuário na resolução do anagrama.


[start=9]
. Localize o método  ``nextTrialActionPerformed()``  e cole o seguinte código no fim do método  ``nextTrialActionPerformed()`` .

[source,java]
----

    //Update management statistics and values
    try {
        mbean.setCurrentAnagram(wordLibrary.getScrambledWord(wordIdx));
        mbean.startThinking();
        } catch (Exception e) {e.printStackTrace();}
----

Cada vez que um novo anagrama é proposto ao usuário, o código informa ao MBean qual é o anagrama e começa a contar o tempo de reflexão do usuário.


[start=10]
. Localize o método  ``guessedWordActionPerformed()``  e adicione as seguintes linhas ao código. Salve as alterações.

[source,java]
----

    //Update management stats
    try {
        mbean.stopThinking();
    } catch(Exception e) {e.printStackTrace();}
----

O método  ``stopThinking()``  no MBean é chamado cada vez que um anagrama é respondido corretamente.

Agora você deve ver o seguinte no editor [clique para exibir uma imagem maior]:

[.feature]
--
image:images/jmx-stopthinking-sm.png[role="left", link="images/jmx-stopthinking.png"]
--

Agora você terminou a vinculação à camada de gerenciamento JMX para a camada da aplicação. Na próxima seção, você criará e executará a aplicação Jogo de Anagramas e verificará as informações de gerenciamento expostas por meio da GUI JConsole.


== Exercício 6: Executando a Aplicação com JConsole

Neste exercício, você aprenderá a criar e executar seu projeto e estabelecerá conexão ao JConsole para visualizar o estado da JVM, bem como os MBeans da aplicação.

Execute as seguintes etapas para executar a aplicação e exibir as informações de gerenciamento.

1. Uma etapa única executa estas três tarefas: basta clicar no botão "Executar Projeto Principal com Monitoramento e Gerenciamento" na barra de ferramentas (  image::images/run-project24.png[title="Botão Executar Projeto Principal com Monitoramento e Gerenciamento"])

Você também pode chamar a ação do menu Executar no menu principal.

*Observação.* Na primeira vez que você constrói e executa a aplicação, o IDE exibe uma caixa de diálogo de advertência a qual informa que os arquivos  ``build.xml``  serão atualizados. Você pode clicar em OK na caixa de diálogo.

image::images/jmx-firsttime.png[title="Caixa de diálogo Advertência ao monitorar a aplicação pela primeira vez"]

Agora você pode seguir a execução na janela de Saída.

image::images/jmx-compiling.png[title="Janela de Saída que exibe o processo"]

O IDE construirá e iniciará o jogo de Anagramas e abrirá automaticamente a janela JConsole.

image::images/jmx-anagram.png[title="Jogo de Anagramas"]

*Observações.* É possível que você veja uma advertência de Falha de Conexão na Console de Monitoramento e Gerenciamento Java quando a console tenta estabelecer conexão com o processo do Jogo de Anagramas. Neste tutorial, você pode clicar em Não Seguro quando solicitado a autorizar a conexão.


[start=2]
. Selecione a guia MBeans na janela JConsole.

[start=3]
. No layout da árvore no painel esquerdo, expanda todos os nós em  ``com.toy.anagrams.mbeans`` . 
image::images/jmx-jconsole-mbeans1.png[title="Guia MBeans que mostra o nó AnagramsStats"]

[start=4]
. Selecione o nó Notificações e clique no botão Assinar na parte inferior, de forma que o JConsole recebem uma nova notificação cada vez que um anagrama é resolvido.

[start=5]
. Na janela Jogo de Anagramas, resolva os primeiros três ou quatro anagramas.

As soluções para os anagramas (abstração, ambíguos, aritmética, barra invertida,...) estão contidas na classe  ``WordLibrary`` .


[start=6]
. Na janela JConsole observe que ela recebeu notificações para cada uma das soluções. 
[.feature]
--
image::images/jmx-jconsole-mbeans2-sm.png[role="left", link="images/jmx-jconsole-mbeans2.png"]
--

[start=7]
. Clique no nó Atributos e observe que os valores do atributo estão atualizados: 
image::images/jmx-jconsole-mbeans3.png[title="Guia MBeans que mostra o nó AnagramsStats"]

Você pode experimentar a interface JConsole e o Jogo de Anagramas. Por exemplo, se você chamar a operação de gerenciamento  ``resetAll()``  verá que os valores do atributo do MBean são redefinidos como 0.

*Agora você terminou! Realmente você fez um bom trabalho. Parabéns! *

link:/about/contact_form.html?to=3&subject=Feedback:%20Adding%20Java%20Management%20Extensions%20(JMX)%20Instrumentation[+Enviar Feedback neste Tutorial+]


== Consulte Também

Para obter mais informações, consulte os seguintes tópicos:

* link:jmx-getstart.html[+Conceitos Básicos sobre Monitoramento do JMX no NetBeans IDE+]