| // |
| // 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. |
| // |
| |
| = Web Service Passando Dados Binários, parte 5: Criando o Cliente Swing |
| :jbake-type: tutorial |
| :jbake-tags: tutorials |
| :jbake-status: published |
| :icons: font |
| :syntax: true |
| :source-highlighter: pygments |
| :toc: left |
| :toc-title: |
| :description: Web Service Passando Dados Binários, parte 5: Criando o Cliente Swing - Apache NetBeans |
| :keywords: Apache NetBeans, Tutorials, Web Service Passando Dados Binários, parte 5: Criando o Cliente Swing |
| |
| O objetivo deste exercício é criar um cliente para o Web service criado e implantado anteriormente e, em seguida, adicionar uma interface de GUI a esse cliente. A interface exibe as imagens que o Web service passa como dados binários. |
| |
| É possível fazer download de uma versão completa do cliente a partir do link:https://netbeans.org/projects/samples/downloads/download/Samples%252FWeb%2520Services%252FWeb%2520Service%2520Passing%2520Binary%2520Data%2520--%2520EE6%252FFlowerClient.zip[+Catálogo de Amostras do NetBeans+]. |
| |
| *Lições Deste Tutorial* |
| |
| image::images/netbeans-stamp-74-73-72.png[title="O conteúdo desta página se aplica ao NetBeans IDE 7.2, 7.3 e 7.4"] |
| |
| 1. link:./flower_overview.html[+Visão Geral+] |
| 2. link:./flower_ws.html[+Criando o Web Service+] |
| 3. link:./flower-code-ws.html[+Codificando e Testando o Web Service+] |
| 4. link:./flower_wsdl_schema.html[+ Modificando o Esquema e os Arquivos WSDL para Passar Dados Binários+] |
| 5. => Criando o Cliente Swing |
| |
| |
| [start=1] |
| 1. <<create-client-app,Criando a Aplicação Cliente>> |
| |
| |
| [start=2] |
| . <<design-jframe,Projetando o JFrame>> |
| |
| [start=3] |
| . |
| <<bind-jframe,Vinculando os Componentes do JFrame>> |
| |
| |
| [start=4] |
| . <<code-main-class,Codificando a Classe Principal>> |
| |
| |
| == Criando a Aplicação Cliente |
| |
| Nesta seção, você criará uma aplicação Web. Nessa aplicação, você criará um cliente que consumirá o Web service criado e modificado em tutoriais anteriores. |
| |
| *Para criar a aplicação cliente:* |
| |
| 1. Selecione Arquivo > Novo Projeto (Ctrl-Shift-N no Linux/Windows, ⌘-Shift-N no MacOS). O Assistente de Novo Projeto será exibido. |
| 2. Selecione Aplicação Java na categoria Java. Clique em Próximo. O assistente de Nova Aplicação Java será exibido. Digite ``FlowerClient`` em Nome do Projeto. Selecione uma localização para o projeto e clique em Finalizar. O IDE criará um novo projeto de aplicação Java. |
| 3. Clique com o botão direito do mouse no nó do projeto ``FlowerClient`` e selecione Novo > Cliente de Web Service no menu de contexto. O assistente de Novo Cliente de Web Service será aberto. |
| 4. Selecione o botão de opção URL WSDL e cole o URL do arquivo WSDL nesse campo. (Por default, o URL é ``http://localhost:8080/FlowerAlbumService/FlowerServiceService?wsdl`` . Localize o URL no browser testando o Web service e substituindo ``?Tester`` por ``?wsdl`` no final do URL.) Aceite todos os outros valores default, incluindo um nome de pacote em branco. |
| image::images/ws-client-wiz.png[] |
| |
| [start=5] |
| . Clique em Finalizar. O IDE faz download do arquivo WSDL, adiciona stubs de cliente para interagir com o Web service e adiciona nós à janela Projetos no projeto de aplicação Java. |
| image::images/client-generated-sources.png[title="Visualização Projetos mostrando o novo cliente do Web Service"] |
| |
| |
| [[design-jframe]] |
| == Projetando o Form JFrame |
| |
| Nesta seção, você adicionará um ``JFrame`` à aplicação Web e projetará uma interface de GUI dentro dele utilizando componentes Swing. Finalmente, você vinculará os componentes Swing ao código do cliente de Web service. |
| |
| Se não desejar projetar o form JFrame você mesmo, você poderá fazer download de um arquivo Java do JFrame pré-projetado link:https://netbeans.org/projects/www/downloads/download/webservices%252FFlowerFrame.java[+aqui+]. |
| |
| 1. Clique com o botão direito do mouse no nó ``FlowerClient`` e selecione Novo > Form JFrame. Chame o quadro de ``FlowerFrame`` . Coloque-o no pacote ``flowerclient`` . |
| 2. ``FlowerFrame`` será aberto no editor. Abra a Paleta, se ainda não estiver aberta. Estenda o limite inferior do quadro em aproximadamente um terço. |
| image::images/opened-flowerform.png[] |
| |
| [start=3] |
| . Arraste um JPanel da seção Contêineres Swing da Paleta para o ``FlowerFrame`` . Expanda-o para preencher o ``FlowerFrame`` inteiro. |
| image::images/add-panel.png[] |
| |
| [start=4] |
| . Clique com o botão direito do mouse no Painel na View do Design. Selecione Alterar Nome da Variável... no menu de contexto. Defina o nome do painel como ``gardenFlowersPanel`` . |
| |
| [start=5] |
| . Arraste um JLabel da Paleta para o início do `` gardenFlowersPanel`` . Clique com o botão direito do mouse no label e altere seu nome de variável para ``titleLabel`` . Clique com o botão direito do mouse novamente em ``titleLabel`` e selecione Editar Texto. Altere o texto para Flores do Jardim. Talvez você queira explorar as propriedades do ``titleLabel`` e dar a ele uma fonte de maior expressão. |
| |
| [start=6] |
| . Arraste um Grupo de Botões para a view de design. Aceite o nome da variável default do grupo de botões, ``buttonGroup1`` . |
| |
| [start=7] |
| . Arraste quatro Botões de Opções para uma linha horizontal abaixo do ``titleLabel`` . Nas propriedades de cada botão, defina-o como um membro de ``buttonGroup1`` . As outras propriedades dos botões são: |
| |=== |
| |Botões de Opção em ButtonGroup1 |
| |
| |Nome da Variável |Selecionado |Texto |
| |
| |asterRadioButton |verdadeiro |Áster |
| |
| |honeysuckleRadioButton |falso |Madressilva |
| |
| |roseRadioButton |falso |Rosa |
| |
| |sunflowerRadioButton |falso |Girassol |
| |=== |
| |
| [start=8] |
| . Arraste um Painel de Rolagem para baixo dos botões de opções. Expanda-o para preencher todo o espaço horizontal e cerca de dois terços do espaço vertical livre. Altere o nome da variável do painel de rolagem para ``mainScrollPane`` . |
| |
| [start=9] |
| . Arraste um Painel para o ``mainScrollPane`` . Altere o nome da variável do Painel para ``mainPanel`` . |
| |
| [start=10] |
| . Na view Design, clique com o botão direito do mouse no ``mainPanel`` e selecione Definir layout > Layout da Borda. |
| |
| [start=11] |
| . Arraste um Botão para o ``mainPanel`` . Como o ``mainPanel`` tem layout de borda, o botão automaticamente preenche todo o painel. Altere o nome da variável do botão para ``mainPictureButton`` e mude o texto do botão para "Aguardando imagem..." |
| |
| [start=12] |
| . Arraste outro Painel de Rolagem para o espaço abaixo do ``mainScrollPane`` . Expanda o novo painel de rolagem para preencher todo o espaço livre remanescente. Altere o nome da variável do novo painel de rolagem para ``thumbnailScrollPane`` . |
| |
| [start=13] |
| . Arraste um Painel para o ``thumbnailScrollPane`` . Altere o nome da variável do Painel para ``thumbnailPanel`` . Defina o layout do ``thumbnailPanel`` para Layout de Grade. |
| |
| [start=14] |
| . Arraste quatro Botões para o ``thumbnailPanel`` Como o ``thumbnailPanel`` tem Layout de Grade, os botões são automaticamente de mesmo tamanho e preenchem o painel completamente. As propriedades dos botões são: Botões no thumbnailPanel |
| |=== |
| |
| |Nome da Variável |Texto |
| |
| |asterButton |Aguardando... |
| |
| |honeysuckleButton |Aguardando... |
| |
| |roseButton |Aguardando |
| |
| |sunflowerButton |Aguardando... |
| |=== |
| |
| O Form JFrame agora está totalmente projetado. Nesse ponto, o ``FlowerFrame`` deverá ter a seguinte aparência. |
| image::images/designed-form.png[title="Quadro de Flores Concluído mostrando os textos do botão em vez de imagens"] |
| |
| |
| == Vinculando os Componentes do JFrame |
| |
| Nesta seção, você inicializará os componentes no construtor e vinculará os componentes aos listeners. Os listeners chamam o código que mostra as imagens das flores. |
| |
| |
| === [[Inicializando os Componentes]] |
| |
| [[Nesta seção, você preencherá o construtor ``FlowerFrame`` |
| |
| ]] |
| |
| 1. Alterne para a view de Código-fonte do editor. Localize o início do corpo da classe ``FlowerFrame`` e o construtor ``FlowerFrame`` . |
| image::images/ff-empty-constructor.png[] |
| . Na parte superior do corpo da classe do ``FlowerFrame`` , antes do construtor, crie um array de strings dos nomes de cada flor. |
| |
| [source,java] |
| ---- |
| |
| protected static final String[] FLOWERS = {"aster", "honeysuckle", "rose", "sunflower"}; |
| ---- |
| . Entre o array da string FLOWERS e o construtor, adicione uma linha que inicialize um ``link:http://download.oracle.com/javase/6/docs/api/java/util/Map.html[+java.util.Map+]`` denominado ``flores`` . O mapa utiliza uma ``String`` e a mapeia para uma ``Image`` . |
| |
| [source,java] |
| ---- |
| |
| private Map<String, Image> flowers; |
| ---- |
| . Adicione instruções de importação para ``java.util.Map`` e ``java.awt.Image`` . |
| . Adicione código ao construtor ``FlowerFrame`` para associar uma ``Image`` específica a uma ``String`` específica de uma instância específica do mapa ``flowers`` |
| |
| [source,java] |
| ---- |
| |
| public FlowerFrame(Map<String, Image> flowers) { |
| |
| this.flowers = flowers; |
| for (String flower:FLOWERS) { |
| flowers.put(flower,null); |
| } |
| |
| initComponents(); |
| } |
| ---- |
| |
| [start=3] |
| . Inicialize ``ItemListener`` s para os botões de opções e ``ActionListener`` s para os quatro botões de flores e defina o título default. |
| |
| [source,java] |
| ---- |
| |
| public FlowerFrame(Map<String, Image> flowers) { |
| |
| this.flowers = flowers; |
| for (String flower:FLOWERS) { |
| flowers.put(flower,null); |
| } |
| |
| initComponents(); |
| |
| setTitle("Garden Flowers [waiting for picture]"); |
| |
| ItemListener rbListener = new RBListener(); |
| asterRadioButton.addItemListener(rbListener); |
| honeysuckleRadioButton.addItemListener(rbListener); |
| roseRadioButton.addItemListener(rbListener); |
| sunflowerRadioButton.addItemListener(rbListener); |
| |
| ActionListener bListener = new ButtonListener(); |
| asterButton.addActionListener(bListener); |
| honeysuckleButton.addActionListener(bListener); |
| roseButton.addActionListener(bListener); |
| sunflowerButton.addActionListener(bListener); |
| } |
| ---- |
| |
| [start=4] |
| . Adicione instruções de importação para ``link:http://download.oracle.com/javase/6/docs/api/java/awt/event/ItemListener.html[+java.awt.event.ItemListener+]`` e ``link:http://download.oracle.com/javase/6/docs/api/java/awt/event/ActionListener.html[+java.awt.event.ActionListener+]`` . |
| |
| Agora, o construtor está completo. Você receberá advertências de erros de compilação no código porque ele não contém as classes ``RBListener`` e ``ButtonListener`` . Essas duas classes são implementações personalizadas do ``ItemListener`` e ``ActionListener`` , respectivamente. Você escreverá essas duas classes na próxima seção. |
| |
| |
| === [[Mostrando as Flores]] |
| |
| [[Nesta seção, você escreverá listeners personalizados para os botões de opções e os botões de flores. Você também escreverá um método que determinará qual flor será selecionada pelos botões e obterá uma ``Image`` daquela flor a partir do mapa ``flowers`` . Finalmente, você escreverá um método que é chamado pela classe ``Main`` e que obterá uma ``Image`` para cada miniatura. |
| |
| ]] |
| |
| 1. Encontre o método ``public static void main(String args[])`` no corpo da classe ``FlowerFrame`` . Delete esse método e sua documentação. (A aplicação utilizará a classe ``Main`` .) |
| . No lugar do método ``main`` , escreva um ``ItemListener`` personalizado para os botões de opções. Esse listener mostrará uma nova imagem de flor quando um botão de opção for selecionado. |
| |
| [source,java] |
| ---- |
| |
| private class RBListener implements ItemListener { |
| public void itemStateChanged(ItemEvent e) { |
| showFlower(); |
| } |
| } |
| ---- |
| . Adicione uma instrução de importação para ``link:http://download.oracle.com/javase/6/docs/api/java/awt/event/ItemEvent.html[+java.awt.event.ItemEvent+]`` . |
| . Abaixo do ``ItemListener`` personalizado, escreva um ``ActionListener`` personalizado para os quatro botões de flores. Quando um botão for clicado, o listener selecionará o botão de opção relacionado: |
| |
| [source,java] |
| ---- |
| |
| private class ButtonListener implements ActionListener { |
| |
| public void actionPerformed(ActionEvent e) { |
| if (e.getSource() == asterButton) asterRadioButton.setSelected(true); |
| else if (e.getSource() == honeysuckleButton) honeysuckleRadioButton.setSelected(true); |
| else if (e.getSource() == roseButton) roseRadioButton.setSelected(true); |
| else if (e.getSource() == sunflowerButton) sunflowerRadioButton.setSelected(true); |
| } |
| } |
| ---- |
| |
| [start=2] |
| . Adicione uma instrução de importação para ``link:http://download.oracle.com/javase/6/docs/api/java/awt/event/ActionEvent.html[+java.awt.event.ActionEvent+]`` . |
| |
| [start=3] |
| . Abaixo do ``ActionListener`` personalizado, escreva o método ``showFlower`` . Esse método determina o botão de opção selecionado e obtém uma ``Image`` da flor correspondente a partir do mapa ``flowers`` . |
| |
| [source,java] |
| ---- |
| |
| void showFlower() { |
| Image img = null; |
| if (asterRadioButton.isSelected()) { |
| img = flowers.get("aster"); |
| if (img != null) { |
| mainPictureButton.setIcon(new ImageIcon(img)); |
| setTitle("Garden Flowers [Aster]"); |
| } |
| } else if (honeysuckleRadioButton.isSelected()) { |
| img = flowers.get("honeysuckle"); |
| if (img != null) { |
| mainPictureButton.setIcon(new ImageIcon(img)); |
| setTitle("Garden Flowers [Honeysuckle]"); |
| } |
| |
| } else if (roseRadioButton.isSelected()) { |
| img = flowers.get("rose"); |
| if (img != null) { |
| mainPictureButton.setIcon(new ImageIcon(img)); |
| setTitle("Garden Flowers [Rose]"); |
| } |
| } else if (sunflowerRadioButton.isSelected()) { |
| img = flowers.get("sunflower"); |
| if (img != null) { |
| mainPictureButton.setIcon(new ImageIcon(img)); |
| setTitle("Garden Flowers [Sunflower]"); |
| } |
| } |
| if (img == null) { |
| mainPictureButton.setIcon(null); |
| setTitle("Garden Flowers [waiting for picture]"); |
| } else mainPictureButton.setText(""); |
| } |
| ---- |
| |
| [start=4] |
| . Adicione uma instrução de importação para ``link:http://download.oracle.com/javase/6/docs/api/javax/swing/ImageIcon.html[+javax.swing.ImageIcon+]`` . |
| |
| [start=5] |
| . Escreva o método ``setThumbnails`` . Esse método obtém uma imagem para cada miniatura do mapa ``flowers`` . A classe ``Main`` chama esse método. |
| |
| [source,java] |
| ---- |
| |
| void setThumbnails(Map<String, Image> thumbs) { |
| Image img = thumbs.get("aster"); |
| if (img != null) { |
| asterButton.setIcon(new ImageIcon(img)); |
| asterButton.setText(""); |
| } |
| img = thumbs.get("honeysuckle"); |
| if (img != null) { |
| honeysuckleButton.setIcon(new ImageIcon(img)); |
| honeysuckleButton.setText(""); |
| } |
| img = thumbs.get("rose"); |
| if (img != null) { |
| roseButton.setIcon(new ImageIcon(img)); |
| roseButton.setText(""); |
| } |
| img = thumbs.get("sunflower"); |
| if (img != null) { |
| sunflowerButton.setIcon(new ImageIcon(img)); |
| sunflowerButton.setText(""); |
| } |
| } |
| ---- |
| |
| [start=6] |
| . Corrija as importações em ``FlowerFrame`` , caso elas não tenham sido corrigidas quando foram coladas no código. É possível corrigir todas de uma vez clicando com o botão direito do mouse no editor e selecionando Corrigir Importações, no menu de contexto. O conjunto completo de instruções de importação é: |
| |
| [source,java] |
| ---- |
| |
| import java.awt.Image;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.ItemEvent;import java.awt.event.ItemListener;import java.util.Map;import javax.swing.ImageIcon; |
| ---- |
| |
| O ``FlowerFrame`` agora está completo. |
| |
| |
| == [[Codificando a Classe Principal]] |
| |
| [[Nesta seção, você completará a classe ``Main`` para que mostre o ``FlowerFrame`` , estabelecerá uma conexão com o Web service e chamará as operações do Web service. |
| |
| 1. Abra a classe ``Main.java`` no editor. |
| image::images/main-empty.png[] |
| |
| [start=2] |
| . No corpo da classe, antes do método ``principal`` , inicialize uma variável ``int`` para a quantidade de imagens obtidas por download. |
| |
| [source,java] |
| ---- |
| |
| private static int downloadedPictures; |
| ---- |
| |
| [start=3] |
| . No corpo do método ``main`` , crie um ``HashMap`` de quatro flores e outro ``HashMap`` de quatro miniaturas. |
| |
| [source,java] |
| ---- |
| |
| final Map<String,Image> flowers = new HashMap<String,Image>(4); |
| final Map<String,Image> thumbs = new HashMap<String,Image>(4); |
| ---- |
| |
| [start=4] |
| . Adicione instruções de importação para ``java.awt.Image`` , ``java.util.Map`` e ``java.util.HashMap`` . |
| |
| [start=5] |
| . No corpo do método ``main`` , adicione código para mostrar o ``FlowerFrame`` .*// Show the FlowerFrame.* |
| |
| [source,java] |
| ---- |
| |
| final FlowerFrame frame = new FlowerFrame(flowers); |
| frame.setVisible(true); |
| ---- |
| |
| [start=6] |
| . No corpo do método ``main`` , adicione o código para conectar o cliente ao serviço.*// The client connects to the service with this code.* |
| |
| [source,java] |
| ---- |
| |
| FlowerServiceService service = new FlowerServiceService(); |
| final FlowerService port = service.getFlowerServicePort(); |
| ---- |
| |
| [start=7] |
| . Adicione instruções de importação para ``org.flower.service.FlowerService`` e ``org.flower.service.FlowerServiceService`` . |
| |
| [start=8] |
| . No corpo do método ``main`` , adicione o código que cria um array de quatro threads ``Runnable`` e chama a operação ``getFlower`` do Web service uma vez em cada thread.*// The web service getFlower operation |
| // is called 4 times, each in a separate thread. |
| // When the operation finishes the picture is shown in |
| // a specific button.* |
| |
| [source,java] |
| ---- |
| |
| Runnable[] tasks = new Runnable[4]; |
| |
| for (int i=0; i<4;i++) { |
| final int index = i; |
| tasks[i] = new Runnable() { |
| public void run() { |
| try { |
| |
| *// Call the getFlower operation |
| // on the web service:* |
| Image img = port.getFlower(FlowerFrame.FLOWERS[index]); |
| System.out.println("picture downloaded: "+FlowerFrame.FLOWERS[index]); |
| |
| *// Add strings to the hashmap:* |
| flowers.put(FlowerFrame.FLOWERS[index],img); |
| |
| *// Call the showFlower operation |
| // on the FlowerFrame:* |
| frame.showFlower(); |
| |
| } catch (IOException_Exception ex) { |
| ex.printStackTrace(); |
| } |
| downloadedPictures++; |
| } |
| }; |
| new Thread(tasks[i]).start(); |
| } |
| ---- |
| |
| [start=9] |
| . Adicione uma instrução de importação para ``org.flower.service.IOException_Exception`` . |
| |
| [start=10] |
| . No corpo do método ``principal`` , adicione o código que chama a operação ``getThumbnails`` do Web service em um thread separado.*// The web service getThumbnails operation is called |
| // in a separate thread, just after the previous four threads finish. |
| // When the images are downloaded, the thumbnails are shown at |
| // the bottom of the frame.* |
| |
| [source,java] |
| ---- |
| |
| Runnable thumbsTask = new Runnable() { |
| public void run() { |
| try { |
| while (downloadedPictures < 4) { |
| try {Thread.sleep(100);} catch (InterruptedException ex) {} |
| } |
| |
| *// Call the getThumbnails operation |
| // on the web service:* |
| List<Image> images = port.getThumbnails(); |
| System.out.println("thumbs downloaded"); |
| |
| if (images != null && images.size() == 4) { |
| for (int i=0;i<4;i++) { |
| thumbs.put(FlowerFrame.FLOWERS[i],images.get(i)); |
| } |
| frame.setThumbnails(thumbs); |
| } |
| } catch (IOException_Exception ex) { |
| ex.printStackTrace(); |
| } |
| } |
| }; |
| new Thread(thumbsTask).start(); |
| |
| ---- |
| |
| [start=11] |
| . Corrija as importações em ``Main.java`` , caso elas não tenham sido corrigidas quando foram coladas no código. É possível corrigir todas de uma vez clicando com o botão direito do mouse no editor e selecionando Corrigir Importações, no menu de contexto. Você verá uma Lista de classes para importação; selecione ``java.util.List`` . O conjunto completo de instruções de importação é: |
| |
| [source,java] |
| ---- |
| |
| import flower.album.FlowerService;import flower.album.FlowerService_Service;import flower.album.IOException_Exception;import java.awt.Image;import java.util.HashMap;import java.util.List;import java.util.Map; |
| ---- |
| |
| A classe ``Main`` agora está completa. |
| |
| |
| [source,java] |
| ---- |
| |
| public class Main { |
| |
| private static int downloadedPictures; |
| |
| public static void main(String[] args) { |
| |
| final Map<String,Image> flowers = new HashMap<String,Image>(4); |
| final Map<String,Image> thumbs = new HashMap<String,Image>(4); |
| |
| *// Show the FlowerFrame.* |
| final FlowerFrame frame = new FlowerFrame(flowers); |
| frame.setVisible(true); |
| * // The client connects to the service with this code.* |
| FlowerService_Service service = new FlowerService_Service(); |
| final FlowerService port = service.getFlowerServicePort(); |
| |
| Runnable[] tasks = new Runnable[4]; |
| |
| *// The web service getFlower operation |
| // is called 4 times, each in a separate thread. |
| // When the operation finishes the picture is shown in |
| // a specific button.* |
| for (int i=0; i<4;i++) { |
| final int index = i; |
| tasks[i] = new Runnable() { |
| public void run() { |
| try { |
| |
| *// Call the getFlower operation |
| // on the web service:* |
| Image img = port.getFlower(FlowerFrame.FLOWERS[index]); |
| System.out.println("picture downloaded: "+FlowerFrame.FLOWERS[index]); |
| |
| *// Add strings to the hashmap:* |
| flowers.put(FlowerFrame.FLOWERS[index],img); |
| |
| *// Call the showFlower operation |
| // on the FlowerFrame:* |
| frame.showFlower(); |
| |
| } catch (IOException_Exception ex) { |
| ex.printStackTrace(); |
| } |
| downloadedPictures++; |
| } |
| }; |
| new Thread(tasks[i]).start(); |
| } |
| *// The web service getThumbnails operation is called |
| // in a separate thread, just after the previous four threads finish. |
| // When the images are downloaded, the thumbnails are shown at |
| // the bottom of the frame.* |
| Runnable thumbsTask = new Runnable() { |
| public void run() { |
| try { |
| while (downloadedPictures < 4) { |
| try {Thread.sleep(100);} catch (InterruptedException ex) {} |
| } |
| |
| *// Call the getThumbnails operation |
| // on the web service:* |
| List<Image> images = port.getThumbnails(); |
| System.out.println("thumbs downloaded"); |
| |
| if (images != null && images.size() == 4) { |
| for (int i=0;i<4;i++) { |
| thumbs.put(FlowerFrame.FLOWERS[i],images.get(i)); |
| } |
| frame.setThumbnails(thumbs); |
| } |
| } catch (IOException_Exception ex) { |
| ex.printStackTrace(); |
| } |
| } |
| }; |
| new Thread(thumbsTask).start(); |
| } |
| |
| } |
| ---- |
| |
| A aplicação cliente agora está completa, com o código que interage com o Web service que é delegado ao módulo EJB para a exposição de suas imagens. Clique com o botão direito do mouse no cliente e selecione Executar. A aplicação Swing é iniciada e, depois de um tempo, é preenchida com as imagens recebidas do Web service. Se as imagens não aparecerem, limpe e construa o projeto FlowerService e execute-o novamente. Observe que é possível alterar a imagem exibida no quadro principal selecionando um botão de opção ou clicando em uma miniatura. |
| |
| ]] |
| |
| link:/about/contact_form.html?to=3&subject=Feedback:%20Flower%20Swing%20Client%20EE6[+Enviar Feedback neste Tutorial+] |
| |
| Para enviar comentários e sugestões, obter suporte e se manter informado sobre os mais recentes desenvolvimentos das funcionalidades de desenvolvimento Java EE do NetBeans IDE, link:../../../community/lists/top.html[+inscreva-se na lista de notícias nbj2ee@netbeans.org+]. |
| |
