Criando um Cliente Gráfico para o Twitter

Neste tutorial, você usa o NetBeans IDE para criar um cliente gráfico simples com base no REST, que exibe mensagens da linha do tempo dos amigos do Twitter e permite exibir e atualizar seu status do Twitter. A aplicação usa o suporte do Swing e do NetBeans IDE para as operações SaaS do Twitter.

Cliente em execução que exibe mensagens do Twitter

Se não tiver uma conta do Twitter, vá ao twitter.com e crie uma conta antes de prosseguir com este tutorial.

Uma amostra completa desta aplicação está disponível para download. Clique aqui para fazer o download da amostra.

Conteúdo

O conteúdo dessa página aplica-se ao NetBeans IDE 6.9 a 7.1

Para concluir este tutorial, você precisa dos seguintes recursos e softwares.

Software ou Recurso Versão Necessária
NetBeans IDE Pacote de download do Java EE
Java Development Kit (JDK) Versão 6 ou versão 7
Nome de usuário e senha para uma conta do Twitter

Criando o JFrame

Nesta etapa, você cria os elementos da GUI que exibirão a linha de tempo dos amigos do Twitter, seu ícone de usuário e onde lê e atualiza seu status. Os elementos da GUI serão todos encapsulados em um JFrame. Não é necessário criar o layout dos elementos da GUI exatamente como descrito nesta seção. Este layout é apenas uma sugestão. Você pode, por exemplo, adicionar mais funcionalidades. No entanto, é necessário criar, pelo menos, todos os elementos descritos neste tutorial.

Para criar o JFrame:

  1. Escolha Arquivo > Novo Projeto. O Assistente Novo Projeto será Aberto. Selecione a categoria Java e, em seguida, um projeto de Aplicação Java. Clique em Próximo.
  2. Nomeie o projeto como TwitterSwingClient. Selecione uma Localização para o Projeto. Desmarque Criar Classe Principal. (O JFrame será a classe principal). Clique em Finalizar.
    Assistente Novo Projeto que mostra campos para criação do projeto TwitterSwingClient
  3. O IDE cria o projeto TwitterSwingClient, que aparece na janela Projetos. Clique com o botão direito do mouse no nó do projeto TwitterSwingClient e selecione Novo > Form JFrame (ou Novo > Outro > Forms da GUI Swing > Form JFrame). O assistente Novo form JFrame será aberto.
  4. Nomeie o form TwitterJFrame e crie um pacote para ele denominado twitterclient. Clique em Finalizar.
    Assistente Novo Form JFrame que mostra campos para criação do TwitterJFrame
  5. O IDE abre o TwitterJFrame no editor na view de Design. Aqui você tem uma paleta de todos os componentes Swing que podem ser arrastados e soltos no JFrame.
    J Frame do Twitter na view de Design do Editor
  6. Clique no ícone Botão em Controles Swing na Paleta. Arraste e solte-o no canto direito inferior do JFrame. Observe que o botão exibe jButton1, que é o nome deste objeto JButton.
    JFrame que mostra o jButton1 recém-adicionado
  7. Clique com o botão direito do mouse em jButton1 e selecione Editar Texto no menu de contexto. Altere o texto de exibição para "Atualizar".
  8. Arraste e solte um Label (jLabel1) para o canto esquerdo inferior do JFrame. Altere o texto de exibição para "Ícone". Seu ícone de usuário será exibido neste label.
  9. Arraste e solte um Campo de Texto (jTextField1) entre o Label e o Botão. Altere o texto de exibição para "Status". Clique na borda direita do campo de texto e estique-a em direção ao botão. Linhas guia azuis aparecerão, mostrando as distâncias sugeridas do botão.
  10. Clique com o botão direito do mouse em jLabel1 e selecione Propriedades no menu de contexto. A caixa de diálogo JLabel1 será aberta. Defina a propriedade labelFor para apontar para jTextField1. (Isso aumenta a acessibilidade).
  11. Encontre as propriedades Tamanho Máximo, Tamanho Mínimo e Tamanho Preferencial. Defina cada uma dessas propriedades como [48,48], para que correspondam às dimensões 48px X 48px dos ícones do Twitter.
    Propriedades de j Label 1 no J Frame do Twitter, que mostra os tamanhos Máximo, Mínimo e Preferencial definidos como 48, 48
  12. Arraste e solte um Painel de Rolagem para a parte superior do JFrame. Arraste suas bordas para expandi-lo para preencher quase ou todo o espaço acima do campo de texto e do botão. (Você pode deixar uma margem se desejar adicionar mais funcionalidade em outro momento, como o menu na amostra).
  13. Arraste e solte a Lista no Painel de Rolagem. Aparecerá uma lista de amostra de itens. Salve o TwitterJFrame. O JFrame deveria se parecer com a seguinte imagem:
    J Frame do Twitter na view de Design com todos os elementos básicos da GUI

Agora temos todos os componentes básicos da GUI para o cliente Swing. É o momento de adicionar a primeira operação Twitter SaaS (Software como um Serviço).

Mostrando Seu Status de Usuário

Nesta seção você cria um novo método e adiciona a operação Twitter getUserTimeline nesse método. A operação getUserTimeline obtém seu ícone de usuário e seu status atual. Você então adiciona o código ao método para exibir seu ícone e status no jLabel1 e jTextField, respectivamente. Finalmente, adiciona uma linha ao construtor do JFrame para inicializar o método.

Para mostrar seu status de usuário:

  1. Alterne para a view Código-Fonte do TwitterJFrame.
  2. Pressione Alt-Insert ou clique com o botão direito do mouse e selecione Inserir Código no menu de contexto. Um menu com os códigos para inserção será exibido.
    Menu de códigos para inserção no método initUserInfo
  3. Clique em Gerar Cliente REST. A caixa de diálogo Recursos REST Disponíveis será aberta.
    Caixa de diálogo Recursos REST disponíveis
  4. Selecione o botão de opção IDE Registrado e clique em Procurar. Vá a Twitter > Twitter OAuth > [statuses] > [user_timeline.{format}]. Clique em OK.
    Janela Serviços com a árvore Web Services mostrando a operação getUserTimelineById do Twitter escolhida
  5. A caixa de diálogo Recursos REST Disponíveis agora mostra o recurso user_timeline selecionado do OAuth do Twitter, o nome da classe correspondente e o tipo de autenticação do OAuth. Clique em OK.
    Caixa de diálogo Recurso REST Disponível preenchida
  6. Uma caixa de diálogo será aberta perguntando se você deseja gerar objetos Java das referências de esquema XML no arquivo WADL. Clique em Sim.
  7. No final da classe TwitterJFrame, o IDE gera uma classe interna chamada Twitter_OAuth_user_timeline__format_JerseyClient.

    A classe interna é complexa e contém os seguintes campos, métodos e classes internas:

    • CONSUMER_KEY: string de Consumer Key
    • CONSUMER_SECRET: String de Consumer Secret
    • initOAuth(): método para inicialização do OAuth
    • getUserTimeline(): método que corresponde ao método HTTP: getUserTimeline (do recurso REST)
    • makeOAuthRequestUnique(): útil para várias chamadas de API em uma única sessão
    • login: usado para efetuar log-in na Aplicação Twitter (força a autenticação). Este método chama mais dois métodos gerados, getOAuthAccessToken e getOAuthRequestToken.

    Esta é a estrutura da classe conforme mostrada na janela Navegador.

    Janela Navegador que mostra a classe Twitter_OAuth_user_timeline__format_JerseyClient
  8. No TwitterJFrame imediatamente acima da classe interna Twitter_OAuth_user_timeline__format_JerseyClient, digite a seguinte linha de código. Este código cria uma variável chamada client para representar uma instância da classe interna.
    private Twitter_OAuth_user_timeline__format_JerseyClient client;
    Snippet de código que mostra a variável do cliente imediatamente acima da classe interna
  9. Localize o método main no TwitterJFrame. Acima deste método, crie um novo método chamado initUserInfo que lança uma MalformedURLException e uma IOException.
    private void initUserInfo() throws MalformedURLException, IOException {
    
    
    
    }
  10. Digite o código a seguir no corpo do método de initUserInfo. Os comentários no código explicam o que o código faz.
    private void initUserInfo() throws MalformedURLException, IOException {
    
    //Create an instance of the internal service class client = new Twitter_OAuth_user_timeline__format_JerseyClient("xml");
    //Log in, get tokens, and append the tokens to the consumer and secret //keys client.login(); client.initOAuth();
    //Call getUserTimeline, get a list of statuses, pass the most recent //status as a StatusType object, and display the text of that object //in the JTextField Statuses statuses = client.getUserTimeline(Statuses.class, null, null, null, "1"); StatusType st = statuses.getStatus().get(0); jTextField1.setText(st.getText().trim());
    //Get a UserType object from the StatusType object, get the URL of that //user's icon, and display that icon in the JLabel UserType user = st.getUser(); String iconSrc = user.getProfileImageUrl(); URL iconUrl = new URL(iconSrc); ImageIcon icon = new ImageIcon(iconUrl, user.getScreenName()); jLabel1.setIcon(icon); }
  11. Abra a caixa de diálogo Corrigir Importações (Ctrl/⌘-Shift-I ou no menu de contexto). Na caixa de diálogo, selecione twitter.twitteroauth.twitterresponse.StatusType e não a classe Java default StatusType.
    Caixa de diálogo Corrigir Importações depois da conclusão do método intUserInfo
  12. Adicione um bloco try/catch ao construtor TwitterJForm para chamar initUserInfo quando a aplicação for executada. Corrija as Importações após adicionar o bloco try/catch.
    public TwitterJFrame() {
        initComponents();
    
        try {
            initUserInfo();
        } catch (IOException ex) {
            Logger.getLogger(TwitterJFrame.class.getName()).log(Level.SEVERE, null, ex);
        }
     }

Depois de obter as chaves OAuth do Twitter, o projeto poderá ser executado. Clique com o botão direito do mouse no nó do projeto e selecione Executar a partir do menu de contexto. Uma aplicação será aberta mostrando seu ícone e status de usuário.

Obtendo as Chaves OAuth do Twitter

Para que a aplicação Java possa acessar os dados do Twitter, é necessário obter as chaves CUSTOMER_KEY e CUSTOMER_SECRET juntamente com uma string de verificação proveniente do Twitter. O Twitter usa a autorização OAuth, que precisa dessas chaves. No entanto, o OAuth é configurado com a intenção de que seja chamado por uma aplicação Web em um servidor. Para obter as chaves de autorização, registre uma aplicação web "fictícia".

Para obter as chaves OAuth do Twitter:

  1. Abra o browser. Vá para a página Twitter > Aplicações e clique em Registrar uma nova aplicação. É necessário efetuar log-in na conta do Twitter. Certifique-se de ter efetuado log-in na conta correta, caso você tenha várias contas.
  2. Digite Aplicação Linha do tempo do Usuário do NB no campo de texto Nome da Aplicação.
  3. Digite uma descrição no campo Descrição. É necessário digitar uma descrição. Você pode colocar, por exemplo, "Aplicação Java criada no NetBeans IDE chamando a operação user_timeline".
  4. Digite um URL arbitrário no campo Website da Aplicação.
  5. Na opção Tipo de Aplicação, selecione o botão de opção Cliente.
  6. Na seção Tipo de Acesso Default, selecione o botão Leitura e Gravação.

    Cuidado: certifique-se de ter selecionado Leitura e Gravação. Embora você possa voltar e editar as definições mais tarde, parece que isso não afeta os privilégios de acesso da aplicação.

  7. Deixe as outras opções como default e clique em Salvar. A página do browser será aberta com os detalhes da aplicação que você registrou. Os detalhes importantes são consumer key e consumer secret.
  8. Copie a Consumer key do browser. No IDE, localize a linha onde a CONSUMER_KEY está definida. Cole o valor da consumer key entre as aspas.
    TwitterClient que mostra a localização de CONSUMER_KEY e CONSUMER_SECRET
  9. Copie a chave Consumer secret do browser e cole-a no TwitterSwingClient. Salve as alterações.

Executando o Projeto

Agora que já tem a Consumer key e a chave Consumer secret, pode executar o projeto. A aplicação chama o Twitter, que abre a janela do browser para que você permita que a aplicação acesse os dados.

Para executar o projeto:

  1. Se o TwitterSwingClient for o seu projeto principal, pressione F6. Caso contrário, clique com o botão direito do mouse no nó do projeto TwitterSwingClient e selecione Executar no menu de contexto.
  2. Uma janela do browser será aberta perguntando se você deseja permitir que a aplicação registrada acesse seus dados do Twitter. Clique em Permitir.
  3. A janela do browser será atualizada para uma nova janela que mostra um PIN. Copie esse PIN.
  4. No IDE, a janela de saída mostra a solicitação na qual você digita a string oauth_verifier. Cole o PIN depois dos dois-pontos (:) e pressione Enter.
    Janela Saída no IDE pedindo a srting de verificação, que ainda não foi colada
  5. O cliente da área de trabalho será aberto, exibindo sua última mensagem de status no Twitter.
    Executando a aplicação, mostrando ícone e status do usuário

Chamando Vários Serviços

O desenho final da aplicação requer chamadas a três serviços do Twitter: user_timeline{format} (já chamado), update{format} e friends_timeline{format}. As chamadas para esses serviços precisam compartilhar um log-in. Para que as chamadas compartilhem o mesmo log-in, elas devem estar na mesma classe do cliente. A chamada a vários serviços com base em um cliente requer duas etapas:

  • Adicionar vários serviços a uma classe do cliente.
  • Modificar os caminhos do recurso na classe do cliente

Adicionando serviços e combinando chamadas em uma única classe

Nesta seção, você primeiro adiciona clientes de outros serviços e os combina em um cliente geral.

Para adicionar vários serviços:

  1. Pressione Alt-Insert e selecione Gerar Cliente REST.
    Menu de códigos para inserção no método initUserInfo
  2. Siga o mesmo procedimento para gerar um cliente REST que você seguiu na seção Mostrando Seu Status de Usuário, mas selecione o serviço [statuses] > [update.{format}]. O IDE gerará a classe interna Twitter_OAuth_update__format_JerseyClient, que é semelhante à classe Twitter_OAuth_user_timeline__format_JerseyClient.
    A caixa de diálogo Recursos REST Disponíveis mostrando o serviço de atualização de formato
  3. Repita as etapas 1 e 2 acima, mas adicione um cliente ao serviço [friends_timeline.{format}].
  4. Altere o nome da classe original Twitter_OAuth_user_timeline__format_JerseyClient. Você transformará essa classe na classe geral do cliente que chamará os três serviços. Selecione uma instância do nome Twitter_OAuth_user_timeline__format_JerseyClient e pressione Ctrl-R ou clique com o botão direito do mouse e selecione Refatorar > Renomear. A caixa de diálogo Renomear Classe será aberta. Digite o novo nome TwitterClient.
    Caixa de diálogo Renomear Classe com novo TwitterClient
  5. Clique em Refatorar. O IDE substituirá todas as instâncias do nome da classe.
    Nome da classe alterado em vários lugares
  6. Na janela Navegador, localize a classe Twitter_Oauth_friends_timeline__format_JerseyClient. Nessa classe, localize e clique duas vezes no método getFriendsTimeline.
    Janela Navegador que mostra o método getPublicTimeline
  7. O cursor do Editor se move para o método getFriendsTimeline. Recorte esse método (reproduzido abaixo).
    public <T> T getFriendsTimeline(Class<T> responseType, String since, String since_id, String page, String count) throws UniformInterfaceException {
          String[] queryParamNames = new String[]{"since", "since_id", "page", "count"};
          String[] queryParamValues = new String[]{since, since_id, page, count};
          return webResource.queryParams(getQueryOrFormParams(queryParamNames, queryParamValues)).accept(javax.ws.rs.core.MediaType.TEXT_XML).get(responseType);
    }
  8. Cole o método getFriendsTimeline na classe interna TwitterClient, abaixo do método getUserTimeline.
  9. Recorte e cole o método updateStatus do Twitter_OAuth_update__format_JerseyClient em TwitterClient, abaixo do método getFriendsTimeline.

Modificando os caminhos do recurso

Todas as chamadas de serviço do Twitter estão agora em uma classe do cliente. No entanto, os caminhos do recurso dessa classe do cliente não estão construídos corretamente. O IDE gerou os caminhos do recurso específicos para o serviço user_timeline ao gerar a classe pela primeira vez. É necessário modificar a classe para que, no nível da classe, o caminho do recurso seja genérico e os caminhos específicos sejam designados pelos métodos de chamada de serviço.

Para modificar os caminhos do recurso:

  1. Localize o construtor TwitterClient e remova o parâmetro String format.
    View de antes e depois da remoção do parâmetro do construtor
  2. Será exibida uma barra vermelha de erros na margem direita. Ao clicar nela, você será levado à linha do initUserInfo que instancia a classe TwitterClient. Essa linha é client = new TwitterClient("xml");. Delete o parâmetro "xml", pois o construtor TwitterClient já não o utiliza. A linha agora é client = new TwitterClient();. Os ícones de erro desaparecerão.
  3. Volte ao construtor TwitterClient. (A janela Navegador pode ajudá-lo.) Localize a seguinte linha:
    String resourcePath = java.text.MessageFormat.format("statuses/user_timeline.{0}", new Object[]{format}); 

    Essa linha define o resourcePath de toda a classe. Altere a linha para que resourcePath aponte para o diretório statuses pai. A linha agora fica assim:

    String resourcePath = "statuses";
  4. Vá ao método getUserTimeline. Localize a linha return:
    return webResource.queryParams(getQueryOrFormParams(queryParamNames, queryParamValues))...;

    Acrescente informações sobre o caminho (em negrito, abaixo) ao início da chamada.

    return webResource.path("user_timeline.xml").queryParams(getQueryOrFormParams(queryParamNames, queryParamValues)).accept(javax.ws.rs.core.MediaType.TEXT_XML).get(responseType);
  5. Vá ao método getFriendsTimeline. Localize a linha return:
    return webResource.queryParams(getQueryOrFormParams(queryParamNames, queryParamValues)).accept(javax.ws.rs.core.MediaType.TEXT_XML).get(responseType);

    Acrescente informações sobre o caminho ao início da chamada.

    return webResource.path("friends_timeline.xml").queryParams(getQueryOrFormParams(queryParamNames, queryParamValues)).accept(javax.ws.rs.core.MediaType.TEXT_XML).get(responseType);
  6. Navegue ao método updateStatus. Localize a linha return:
    return webResource.type(javax.ws.rs.core.MediaType.APPLICATION_FORM_URLENCODED)...

    Acrescente informações sobre o caminho ao início da chamada.

    return webResource.path("update.xml").type(javax.ws.rs.core.MediaType.APPLICATION_FORM_URLENCODED).post(responseType, getQueryOrFormParams(formParamNames, formParamValues));
  7. Localize e comente o método setResourcePath do TwitterClient. Ele nunca é chamado, mas isso é uma precaução.
  8. Delete as classes Twitter_OAuth_update__format_JerseyClient e Twitter_Oauth_friends_timeline__format_JerseyClient.

Agora há três serviços disponíveis na classe JerseyClient.

Importante: são alteradas três instruções return em três métodos no procedimento acima. Certifique-se de ter alterado as três!

Adicionando uma Ação de Atualização de Status

  1. Retorne à view de Design do TwitterJFrame. Clique duas vezes no botão Atualizar no JFrame. O editor volta para a view Código-fonte, no corpo do método jButton1ActionPerformed, que o IDE acabou de criar para você.
    TwitterJFrame na view Código-fonte, com o cursor no meio do método jButton1ActionPerformed recém-criado
  2. Preencha o corpo do método jButton1ActionPerformed da seguinte forma:

    Cuidado: ao atualizar seu status, ele aparecerá com a codificação UTF-8, com espaços como sinais de + ou símbolos %21, etc. No entanto, se não converter o conteúdo do campo de texto para UTF-8, a aplicação falhará exibindo "Assinatura inválida" se você digitar espaços na mensagem de status! Se alguém encontrar uma solução para esse problema, entre em contato conosco usando o link Feedback na parte inferior do tutorial.

    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                         
        String rawStatus = jTextField1.getText().trim();
        String status = URLEncoder.encode(rawStatus, "UTF-8");
        client.makeOAuthRequestUnique();
        try {
        client.updateStatus(String.class, status, null);
        } catch(UniformInterfaceException ex) {
            System.out.println("Exception when calling updateStatus = " + ex.getResponse().getEntity(String.class));
        }
    
    }    

Esse código obtém o texto do campo de texto e o passa para a classe updateStatus. Observe a chamada a makeOAuthRequestUnique. O código chama esse método porque a aplicação já está conectada e autenticada pelas chamadas de initUserInfo a login e initOAuth quando a aplicação é inicializada. O método makeOAuthRequestUnique aumenta os parâmetros OAuth nonce e timestamp para tornar cada solicitação única.

Cuidado: não está totalmente claro se aqui é melhor chamar a makeOAuthRequestUnique ou a initOAuth. Se tiver problemas de autenticação, tente as duas formas.

Observe também que a chamada a updateStatus está encapsulada em um bloco try/catch. Isso ajuda você a depurar quaisquer problemas que surjam ao chamar updateStatus.

Exibindo Nomes de Usuário e Status no JFrame

Agora você configura a aplicação para exibir os nomes de usuários e os status dos amigos do Twitter.

  • Para obter os nomes de usuário e os status do Twitter, a aplicação chama a operação getFriendsTimeline do Twitter quando a aplicação é executada. Para configurar isso, crie um novo método de execução que substitui o método run no main. Insira chamadas a getFriendsTimeline neste método.
  • Para que a exibição seja automaticamente atualizada, encapsule o método de execução que contém a operação getFriendsTimeline em um java.util.TimerTask que executa o método run a cada 75 segundos.
  • A aplicação exibe os dados como células em uma lista. Você precisa passar os dados para os componentes da GUI que possam ser renderizados como células na lista e também precisará formatar a exibição dos dados. Para isso, crie um novo JPanel que implementa o javax.swing.ListCellRenderer. Esse JPanel retorna um objeto java.awt.Component com o nome de usuário e status passados no JLabels. Troque o formato do JPanel.
  • No TwitterJFrame, configure o JList para exibir os objetos Componente retornados pelo JPanel.

Criando um TimerTask

Para atualizar automaticamente a exibição da linha de tempo dos amigos do Twitter, encapsule o código de execução em um TimerTask. Primeiro escreva o encapsulador TimerTask e, em seguida, preencha-o com o código de execução. Caso contrário, seu código estará repleto de advertências de erros.

Para criar o TimerTask:

  1. Abra o TwitterJFrame na view Código-fonte do editor.
  2. Encontre a declaração de classe e o construtor.
    public class TwitterJFrame extends javax.swing.JFrame {
    
        /** Creates new form TwitterJFrame */
        public TwitterJFrame() {
            initComponents();
            try {
                initUserInfo();
            } catch (IOException ex) {
                Logger.getLogger(TwitterJFrame.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
  3. No corpo do método do construtor, acima de initComponents();, instancie a classe java.util.Timer. O parâmetro nomeia o thread Timer "Atualizador do Twitter" e especifica que não pode ser executado como um daemon.
    public class TwitterJFrame extends javax.swing.JFrame {
    
        /** Creates new form TwitterJFrame */
        public TwitterJFrame() {
            Timer t = new Timer("Twitter Updater`", false);
            initComponents();
            try {
                initUserInfo();
            } catch (IOException ex) {
                Logger.getLogger(TwitterJFrame.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
                        
  4. Clique com o botão direito do mouse em qualquer lugar do editor e selecione Corrigir Importações no menu de contexto ou pressione Ctrl/⌘-Shift-I. Uma caixa de diálogo será aberta e oferecerá opções de classes para importar. Adicione uma instrução de importação para java.util.Timer.
  5. Abaixo da instanciação de Timer, crie um novo método Timer.scheduleAtFixedRate. Os parâmetros do método são um objeto TimerTask, o atraso antes que execute a tarefa pela primeira vez e a frequência na qual ele executa a tarefa. Defina o método para esperar 30 segundos antes de ser executado pela primeira vez e ser executado novamente a cada 75 segundos. (O longo atraso inicial tem a finalidade de dar-lhe tempo para efetuar log-in.) O código exato se encontra a seguir, em negrito. Uma linha vazia é deixada onde você coloca o código de execução. Observe que você tem que adicionar uma instrução de importação para java.util.TimerTask.
    public class TwitterJFrame extends javax.swing.JFrame {
    
        /** Creates new form TwitterJFrame */
        public TwitterJFrame() {
            Timer t = new Timer("Twitter Updater`", false);
            t.scheduleAtFixedRate(new TimerTask() {

    }, 30000, 75000);
    initComponents(); try { initUserInfo(); } catch (IOException ex) { Logger.getLogger(TwitterJFrame.class.getName()).log(Level.SEVERE, null, ex); } }

A encapsulador TimerTask do código agora está concluído. Em seguida, você adiciona o código de execução.

Adicionando um método run com a operação getFriendsTimeline

Para exibir nomes de usuário e status, a aplicação obtém primeiro esses dados do Twitter. O Twitter SaaS fornece a operação getFriendsTimeline para obter nomes de usuário e status. Para executar a operação getFriendscTimeline quando a aplicação é executada, a operação precisa estar dentro de um método run. Finalmente, como a aplicação exibe os nomes de usuário e status em uma JList, ela precisa adicionar os resultados de getFriendsTimeline como elementos de um objeto DefaultListModel.

Para adicionar um método de execução com a operação getFriendsTimeline:

  1. Acima do construtor TwitterJFrame, crie um objeto DefaultListModel denominado statusListModel.
    public class TwitterJFrame extends javax.swing.JFrame {
    
        private DefaultListModel statusesListModel = new DefaultListModel();
    
    /** Creates new form TwitterJFrame */ public TwitterJFrame() {
  2. Clique com o botão direito do mouse em qualquer lugar do editor e selecione Corrigir Importações no menu de contexto ou pressione Ctrl/⌘-Shift-I. Essa ação adiciona uma instrução de importação a DefaultListModel.
  3. No corpo do objeto TimerTask, crie um novo método run. Use a anotação @Override para substituir o método run em main.
    public class TwitterJFrame extends javax.swing.JFrame {
    
        private DefaultListModel statuses = new DefaultListModel();

    /** Creates new form TwitterJFrame */ public TwitterJFrame() { Timer t = new Timer("Twitter Updater`", false);
    t.scheduleAtFixedRate(new TimerTask() {
    @Override
    public void run(){

    }

    }, 1500, 75000);
    initComponents(); try { initUserInfo(); } catch (IOException ex) { Logger.getLogger(TwitterJFrame.class.getName()).log(Level.SEVERE, null, ex); }
  4. Insira o seguinte código no corpo do método run.
    @Override
    public void run() {
        System.out.println("Timer Task is running");
        try {
            client.initOAuth();
            Statuses response = client.getFriendsTimeline(Statuses.class, null, null, null, "10");
            // Clear the list model so it does not replicate the contents from the last run
            statusesListModel.clear();
            // Create a Status Type object for every status in the Status list, and add an element
            // to the list model for every status type object
            for (final StatusType st : response.getStatus()) {
                SwingUtilities.invokeLater(new Runnable() {
                    public void run() {
                        statusesListModel.addElement(st);
                    }
                });
            }
        } catch (UniformInterfaceException ex) {
        System.out.println("Exception when calling getFriendsTimeline = " + ex.getResponse().getEntity(String.class));
        }
    }

O código para obter o status da linha de tempo dos amigos do Twitter agora está concluído. em seguida, você escreve uma nova classe que retorna um Componente com elementos de lista renderizados em componentes da GUI.

Criando um Componente de Renderização da Célula da Lista

Agora você tem o código que obtém os objetos Status da Linha de Tempo dos Amigos do Twitter e que cria um elemento de lista para cada status. No entanto, você não pode exibir esses elementos de lista bruta em uma JList. É preciso passar os dados para os componentes da GUI. Para isso, crie um novo JPanel que implementa javax.swing.ListCellRenderer. Este JPanel retorna um objeto java.awt.Component com o nome de usuário e status passados no JLabels. Você pode personalizar a aparência dos JLabels no JPanel.

Para adicionar um Componente de renderização da célula da lista:

  1. Clique com o botão direito do mouse no nó do projeto e selecione Novo > Form JPanel. O assistente Novo Form JPanel será aberto.
  2. Nomeie o JPanel como Item e coloque-o no pacote twitterclient.
    Assistente Novo Form JPanel que mostra o painel de nome Item e o pacote twitterclient
  3. Clique em Finalizar. O Item.java será aberto na view de Design do editor.
  4. Arraste e solte um Label e um Painel de Texto no JPanel. O Label exibirá o nome de usuário e o Painel de Texto exibirá a mensagem de status daquele usuário.
  5. Posicione o Label e o Painel de Texto para que estejam de acordo com as suas preferências de exibição dos dados. Na imagem a seguir, o nome de usuário está no canto esquerdo superior e o texto do status está abaixo e um pouco recuado. O projeto de amostra tem os dados no canto esquerdo superior e o nome de usuário no canto inferior direito. Deixe espaço vazio suficiente no JPanel abaixo do Painel de Texto para que ele possa ser expandido quando contiver texto mais longo.
    Layout de jlabels que exibem o nome de usuário e o texto de status
  6. Clique com o botão direito do mouse no elemento jLabel e selecione Propriedades no menu de contexto. Em Propriedades, é possível alterar a fonte, a cor, o alinhamento e outras qualidades. Defina a propriedade labelFor para apontar para jTextPane1. Isso aprimora a acessibilidade. Teste as propriedades do label até estar satisfeito com a aparência. Na imagem a seguir, a cor da fonte está definida como azul na propriedade Primeiro plano.
    Caixa de diálogo propriedades do JLabel com o Primeiro plano definido como azul
  7. Abra a caixa de diálogo Propriedades do JTextPane e faça experiências com sua aparência.
  8. Alterne para a view Código-fonte de Item.java. Localize o bloco Código Gerado e expanda-o. Isso mostra o código gerado pelo IDE quando você define as propriedades do JLabel e do JTextPane.

    Na imagem a seguir, observe a definição da cor azul para JLabel1. Você pode ver quais propriedades estão definidas para o JTextPane?

    Código gerado em Item.java pela definição das propriedades de JLabel na view de Design
  9. Encontre a declaração de classe e adicione o código implements ListCellRenderer.
    public class Item extends javax.swing.JPanel implements ListCellRenderer {
  10. Pressione Ctrl-Shift-I (⌘-Shift-I no MacOS). Essa ação adiciona uma instrução de importação a javax.swing.ListCellRenderer. Aparece uma advertência informando ser necessário implementar todos os métodos abstratos.
  11. Adicione algumas linhas vazias entre o bloco de código gerado e as declarações de variáveis. Nesse espaço, adicione o seguinte código, que implementa o método abstrato getListCellRendererComponent. (Você pode copiar e colar o código ou pode tentar reproduzi-lo com a funcionalidade autocompletar código). Esse código substitui os textos de label default "nome de usuário" e "texto" pelos objetos Text, User e ScreenName, obtidos com a classe twitteroauth StatusType. Em seguida, o código retorna uma instância de Component com esses novos valores de texto do JLabel.
    public Component getListCellRendererComponent(JList list, Object value, int index, boolean sel, boolean focus) {
            StatusType st = (StatusType) value;
            jTextPane1.setText(st.getText());
            jLabel1.setText("<html>" + st.getUser().getScreenName() + "</html>");
            return this;
    }
  12. Pressione Ctrl-Shift-I (⌘-Shift-I no MacOS). Isso adiciona instruções de importação das classes StatusType e Component. Selecione a versão twitteroauth de StatusType. Salve Item.java.

Agora você tem uma classe Item que retorna um objeto Component com o nome de usuário e status exibidos em um JLabel e em um JTextPane. Em seguida, você modifica TwitterJFrame para usar esse componente.

Exibindo o Componente no TwitterJFrame

Para poder exibir o objeto Component criado em Item.java, a JList no TwitterJFrame tem que usar Item.java como seu renderizador de célula.

  1. Retorne ao TwitterJFrame. Na view de Design, selecione a JList. Clique com o botão direito do mouse e abra suas Propriedades.
    Caixa de diálogo Propriedades do elemento JList no TwitterJFrame
  2. Selecione a propriedade modelo. Pressione Ctrl-Espaço. O editor de propriedade personalizada será aberto, mostrando o texto default exibido na lista.
    Editor de propriedades personalizadas do J list
  3. No menu drop-down "Definir a propriedade do modelo jLlist1 usando:" selecione Código Personalizado. Aparecerá um campo de texto onde você digita as propriedades de jLabel1.setModel. Digite statusesListModel no campo e clique em OK.
    Editor de propriedade personalizada do jList que mostra setModel(statuses) escolhido no editor de código personalizado
  4. Na caixa de diálogo Propriedades, selecione cellRenderer e pressione Ctrl-Espaço. O editor de propriedade personalizada será aberto.
  5. No menu drop-down "Definir a propriedade cellRenderer do jList1 usando:" selecione Código Personalizado. Aparecerá um campo de texto em que você digita as propriedades de jList1.cellRenderer. Digite new Item() e clique em OK.
    Editor de propriedades do renderizador de célula personalizada do J List que mostra o novo Item escolhido

Sua aplicação cliente agora está completa! Salve todos os arquivos e execute a aplicação. (Clique com o botão direito do mouse no nó do projeto e selecione Executar). A aplicação será aberta, mostrando uma lista de mensagens de linha de tempo e um campo com seu próprio status.

Cliente em execução que exibe mensagens do Twitter

Conectando por meio de um Proxy;

Se estiver se conectado à Internet por meio de um proxy, será necessário configurar o IDE e seu projeto TwitterSwingClient para usar as definições do proxy.

Para configurar o IDE, abra Ferramentas > Opções > Geral. Localize a seção Definições de Proxy. Você tem as opções de não usar nenhuma definição de proxy, usar as definições de proxy do sistema ou de usar definições manuais de proxy. O IDE obtém as definições de proxy do seu sistema por meio do seu Web browser default.

Para o projeto TwitterSwingClient, é preciso especificar o proxy que o handler do protocolo HTTP utiliza. Isso está descrito na documentação do Java SE 6. Você especifica o proxy nas opções passadas para a máquina virtual. Com o NetBeans IDE, essas opções são definidas na caixa de diálogo Propriedades.

Para especificar o proxy do projeto TwitterSwingClient:

  1. Na janela Projetos, clique com o botão direito do mouse no nó do projeto TwitterSwingClient e selecione Propriedades. A caixa de diálogo Propriedades será aberta.
  2. Na árvore Categorias, selecione Executar. As Propriedades de Execução serão Exibidas:
  3. No campo Opções da VM, digite -Dhttp.proxyHost=server -Dhttp.proxyPort=port. Substitua "server" e "port" pelo nome do host e a porta de seu servidor proxy!
    Definições de proxy e opções da VM na caixa de diálogo Propriedades do projeto

Mais Exercícios

A seguir, encontam-se mais algumas ideias para você explorar:

  • Altere seu ícone de usuário do Twitter (em um browser) e execute novamente o cliente. O novo ícone aparece?
  • Adicione uma barra de ferramentas com algumas funções no JFrame.

Consulte Também

Para obter mais informações sobre como usar o NetBeans IDE para criar e consumir Web services e para criar GUIs, consulte os seguintes recursos:

Para enviar comentários e sugestões, obter suporte e se manter informado sobre os mais recentes desenvolvimento das funcionalidades de desenvolvimento de Java EE do NetBeans IDE, inscreva-se na lista de correspondência .

get support for the NetBeans

Support


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