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

O conteúdo desta página se aplica ao NetBeans IDE 7.2, 7.3, 7.4 e 8.0

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:

Você também se beneficiará tendo conhecimento sobre 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
NetBeans IDE Versão Java 7.2, 7.3, 7.4, 8.0
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

  • Conteúdo de ajuda do NetBeans (Ajuda > Conteúdo de Ajuda > JMX). Esta ajuda também fica disponível nos Assistentes.

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.

  5. Clique com o botão direito do mouse no projeto AnagramGame e selecione Propriedades.
  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.

  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.
    tela do tipo de arquivo MBean Padrão no Assistente Novo Arquivo
  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

    create_mbean2: criar novo MBean Padrão, etapa 2
  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!

  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

    create_mbean7: Adicionar o atributo LastThinkingTime

    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.

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

    Tela da 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.

  7. Clique em OK e salve suas alterações.
  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.
  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

    Tela da 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.

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

    Tela da 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.

  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():
    public void resetAll() {
        minThinkingTime = 0;
        maxThinkingTime = 0;
        lastThinkingTime = 0;
        numSolvedAnagrams = 0;
    }
  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.

    /*
     * 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.

  2. Clique no botão Código-fonte na parte superior da janela Editor para editar a classe na view Código-fonte.
  3. Adicione o seguinte método privado initManagement() vazio para a classe Anagrams: após o construtor Anagrams.
    /**
     * JMX initialization:
     * Create and register Anagrams MBean in Platform MBeanServer.
     * Initialize thinking time and current anagram.
     */
    private void initManagement() throws Exception {
    
    }
  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.
    //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.

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

    instrument_anagram1: adicionando initManagement()
  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:

    create_mbean_registration: Gerar código de Registro do MBean

    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.

  6. Adicione o seguinte campo privado à classe Anagrams.
        // Reference to the AnagramsStats MBean
        private AnagramsStats mbean;
        
  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:
    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();
    }
  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():
           // 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]:

    instrument_anagram1: adicionando initManagement()

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

  9. Localize o método nextTrialActionPerformed() e cole o seguinte código no fim do método nextTrialActionPerformed().
        //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.

  10. Localize o método guessedWordActionPerformed() e adicione as seguintes linhas ao código. Salve as alterações.
        //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]:

    instrument_anagram3: chamar métodos de MBean

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 (  Botão Executar Projeto Principal com Monitoramento e Gerenciamento na barra de ferramentas)

    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.

    tela da caixa de diálogo de advertência

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

    tela da janela de Saída

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

    tela do 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.

  2. Selecione a guia MBeans na janela JConsole.
  3. No layout da árvore no painel esquerdo, expanda todos os nós em com.toy.anagrams.mbeans.
    tela da guia MBeans que mostra o nó AnagramsStats
  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.
  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.

  6. Na janela JConsole observe que ela recebeu notificações para cada uma das soluções.
    tela da guia MBeans que mostra o nó AnagramsStats
  7. Clique no nó Atributos e observe que os valores do atributo estão atualizados:
    tela da 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!


Consulte Também

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

get support for the NetBeans

Support


By use of this website, you agree to the NetBeans Policies and Terms of Use. © 2015, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo