Introdução

O ZK é análogo ao Ajax sem JavaScript. É uma estrutura poderosa composta de um mecanismo acionado por eventos baseado em Ajax, um conjunto rico de componentes XHTML e XUL e a linguagem de marcação ZUML para criação de interfaces com o usuário repletas de recursos.

Neste artigo, aprenda sobre Contextos e Injeção de Dependência (CDI) para o modelo de programação da plataforma Java EE em relação à estrutura ZK. Este artigo é desenvolvido com base no aplicativo de exemplo em Aplicativos de Internet rica que usam o ZK: Uma estrutura Ajax de software livre", um artigo que explora o poder do ZK. Usando ZK e CDI, é possível estender o aplicativo de exemplo real e detalhado para o gerenciamento de clientes.

É possível fazer o download do código de origem do aplicativo neste artigo.

JSR-299 e CDI

Java Specification Request (JSR) 299, ou CDI Java, é um padrão Java para gerenciamento de ciclo de vida de injeção de dependência e contextual. Através do padrão, um conjunto de serviços que facilitam e limpam o desenvolvimento de aplicativos é definido. Os serviços fornecem:

• Interação dos objetos através de um mecanismo de notificação de eventos
• Injeção de dependência de tipo seguro
• Métodos de ciclo de vida para objetos stateful ligados aos contextos
• Um interceptor "decorator" para conectar o interceptor aos objetos
• Uma interface com o provedor de serviço (SPI) para desenvolver extensões móveis

Como o CDI enfatiza o loose coupling e uma linguagem fortemente tipada, o bean não precisa estar ciente de certos aspectos como implementação, modelo de encadeamento ou ciclo de vida. Esses aspectos podem variar com base na implementação, sem afetar o cliente de forma alguma. O loose coupling facilita a manutenção do código e o torna extensível.

ZK e CDI

O CDI do ZK, fornecido pela estrutura ZK, fornece integração contínua com o CDI para expor serviços de CDI na estrutura ZK. Ele permite aos desenvolvedores corporativos a integração de aplicativos dirigidos por CDI, com um frontend Ajax abrangente e poderoso fornecido pelo ZK. O uso conjunto do CDI e do ZK facilmente preenche a lacuna entre a camada da Web do Java EE e o Java EE.

A extensão de CDI do ZK permite o uso contínuo dos recursos de CDI no modelo de programação ZK. Além dos recursos de CDI integrados, as extensões de CDI do ZK fornecem os seguintes recursos para facilitar o desenvolvimento.

Resolvedor de variável customizada/resolvedor EL

Resolve beans gerenciados por CDI dentro da tag <zscript />, uma expressão EL ( ${...}) e uma expressão de ligação de dados com anotações de ZK (@{…}) por seu nome EL.

Escopos customizados de ZK

Além dos escopos de CDI integrados (Session, Request, Application e Conversation), essa extensão fornece mais cinco escopos de ZK: Desktop, Page, Execution, IdSpace e Component.

Componentes de ZK como beans gerenciados

Permitem a injeção de componentes de ZK em beans gerenciados, como criadores ZK.

Manipuladores de evento de UI usando anotação customizada de ZK e modelo de notificação de eventos fornecido por CDI

Permitem a anotação de qualquer método com anotação customizada de ZK e a transformação para um método de manipulador de eventos

A extensão de CDI do ZK é baseada no Weld, que é uma implementação de referência da especificação JSR-299 que define CDI (consulte a seção Recursos para obter mais informações).

Voltar para parte superior

Usando ZK com CDI

O exemplo simples a seguir mostra como acessar um bean gerenciado por CDI a partir de um arquivo ZUL. (A extensão do arquivo .zul é para arquivo de interfaces com o usuário do ZK.) No contexto do CDI, um bean gerenciado, ou simplesmente bean, é um componente Java EE que pode ser injetado em outros componentes, associados com um contexto, ou acessado através de expressões EL.

O exemplo simples de HelloWorld na Listagem 1 mostra como um bean gerenciado é acessado através da expressão EL em um arquivo ZUL. Primeiro, defina a classe HelloWorld com um único campo de cadeia de caractere chamado text e o método getter getText(). De acordo com a especificação do CDI, a presença de um construtor padrão no-arg torna a classe elegível para ser um bean gerenciado. Para fazer referência ao bean gerenciado HelloWorld através de uma expressão unificada EL, ele precisa ser anotado com o qualificador @javax.inject.Named. Qualquer nome EL pode ser dado ao bean gerenciado fornecendo um membro de valor do qualificador @Named . Se não for especificado, o nome EL será definido como padrão para o nome de classe não qualificado da classe de bean após a conversão do primeiro caractere para minúscula. No exemplo, o HelloWorld é definido como padrão para EL helloWorld.

                
@Named
@SessionScoped
public class HelloWorld implements Serializable {

	private String text = "HelloWorld";
	
	public String getText() {
		return text;
	}
}

O código ZUL na Listagem 2 acessa o bean HelloWorld usando seu nome EL padronizado, helloWorld.

                
<?variable-resolver class="org.zkoss.zkplus.cdi.DelegatingVariableResolver"?>
<window title="ZK + CDI: Hello World" width="300px" border="normal">
    My CDI-injected bean says: ${helloWorld.text}
</window>

O ZK fornece uma diretiva de resolvedor de variável <?variable-resolver ?> . É possível usá-la para especificar uma classe de resolvedor a ser usada pelo avaliador EL do ZK (${...}), o componente de ligação anotado do ZK (@{...}) e o interpretador <zscript> para resolver variáveis desconhecidas.

Um recurso da extensão de CDI do ZK é um resolvedor EL customizado chamado DelegatingVariableResolver, que pode ser usado para resolver um bean gerenciado HelloWorld por seu nome EL em uma expressão EL unificada.

No arquivo index.zul na Listagem 2, um componente de janela simples é definido e exibe um campo de texto da classe HelloWorld usando a expressão EL ${helloWorld.text} . Durante a fase de renderização ZUL, quando o analisador ZUL encontrar essa expressão EL, ele irá usar o DelegatingVariableResolver especificado no <?variable-resolver ?> para resolver a instância de bean helloWorld. Como o HelloWorld agora é um bean gerenciado de contêiner, o contêiner deverá fornecer uma instância de bean HelloWorld. Ao usar a instância bean retornada pelo contêiner, ${helloWorld.text} será avaliado. A avaliação resultante do método getText() retorna a cadeia de caractere "Hello World", conforme mostrado na Figura 1.

Voltar para parte superior

Implementando um aplicativo real usando ZK com CDI

Esta seção explora mais recursos de CDI através da implementação de um aplicativo real. O desenvolvimento será feito com base no aplicativo Manage Customer demonstrado no artigo "Aplicativos de Internet rica que usam o ZK". O aplicativo Manage Customer permite aos usuários a execução de várias operações como a adição de um novo cliente, a edição dos dados do cliente e exclusões recuperáveis de entradas de clientes no banco de dados. A Figura 2 mostra a principal tela de interface com o usuário do aplicativo Manage Customers.

Os clientes registrados no aplicativo são listados. A lista é uma grade, com colunas para o ID, o nome do cliente, a data ativa e o sinalizador de exclusão. Os dados na grade podem ser classificados (na ordem crescente ou decrescente) clicando no botão perto dos nomes das colunas. A classificação foi ativada para as colunas ID (número inteiro), Name (cadeia de caractere) e Active Date (Data). A paginação também foi ativada para esse aplicativo, conforme mostrado na parte inferior da tela. A página foi configurada para mostrar 5 registros por vez. Os usuários podem ir para a próxima página ou diretamente para uma página específica.

A Figura 3 mostra a barra superior do aplicativo Manage Customer.

A barra de menus é implementada usando o widget menubar do ZK. Ele inclui uma opção para registrar um novo cliente e sair do aplicativo.

Voltar para parte superior

Configurando o ambiente de desenvolvimento

Antes de nos aprofundar nos detalhes da implementação, vamos revisar alguns detalhes sobre a criação de um aplicativo de amostra para gerenciar clientes. O IDE Eclipse é usado para criar o aplicativo, mas qualquer outro IDE desejado deve funcionar.

A ideia básica é criar um projeto de aplicativo da Web dinâmico e apontá-lo para o tempo de execução do servidor de aplicativos, que neste caso é o tempo de execução do Apache Tomcat. Depois de configurar o novo projeto e o tempo de execução, replique a estrutura de pastas, conforme mostrado na Figura 4.

A estrutura de diretório do aplicativo Manage Customer segue o mesmo padrão mostrado na Figura 4.

Os arquivos principais desse aplicativo estão contidos na pasta WebContent, com os seguintes subdiretórios:

• META-INF contém as informações de credenciais do banco de dados para conexão com o banco de dados MySQL.
• WEB-INF inclui a pasta da biblioteca que contém os arquivos JAR do ZK necessários para a execução do aplicativo. Ela também inclui três arquivos de configuração.
  • beans.xml, que indica as classes de bean do aplicativo que estão disponíveis para injeção.
  • web.xml, que descreve a origem de dados, os servlets do ZK e as configurações do Weld.
  • zk.xml, que pode conter configurações específicas do ZK.

Todos os outros arquivos ZUL e HTML associados estão contidos na pasta WebContent. Esses arquivos atuam como a parte de visualização do aplicativo, fornecendo o conteúdo dinâmico e estático para o aplicativo da Web.

O arquivo de amostra zkManageCustomer.zip (consulte a seção Download) contém a versão compactada do aplicativo. Ele também inclui os arquivos de metadados necessários para o Eclipse ser importado diretamente para o IDE de forma contínua.

A perspectiva do Java 2 Platform, Enterprise Edition (J2EE) no Eclipse possui uma guia de servidor que, quando clicada com o botão direito do mouse, exibe uma opção para a criação de um novo servidor. Esse servidor pode ser usado para gerenciar o servidor de aplicativos do IDE Eclipse.

Depois da configuração do novo servidor, os recursos recém-criados precisam ser configurados no servidor. Essa configuração do servidor implementa os recursos criados durante o curso do desenvolvimento.

Configurando o MySQL

O programa de exemplo é configurado para trabalhar com o Tomcat e o MySQL. No entanto, não deve haver dificuldade para executá-lo em outro servidor de aplicativo ativado para CDI. Como o exemplo usa JDBC, deve funcionar com qualquer banco de dados SQL suportado, como o DB2 Express-C, com apenas algumas modificações no código de conexão.

Para conectar o Tomcat ao banco de dados MySQL, é necessário definir uma referência de recurso. Esse elemento especifica o nome de uma referência de conexão fábrica do gerenciador de recursos, conforme mostrado na Listagem 3. Neste caso, seria a conexão com o banco de dados especificada pelo jdbc/mysql, que é do tipo javax.sql.DataSource .

                
<resource-ref>
      <description>DB Connection</description>
      <res-ref-name>jdbc/mysql</res-ref-name>
      <res-type>javax.sql.DataSource</res-type>
      <res-auth>Container</res-auth>
</resource-ref>
            

Também é necessário definir um recurso de conexão no arquivo context.xml na pasta WebContent/META-INF. Esse arquivo contém propriedades como o nome do driver, o nome JNDI, o nome de usuário, a senha, o tipo de dados e a URL.

                
<Resource driverClassName="com.mysql.jdbc.Driver" 
	maxActive="4" maxIdle="2" maxWait="5000" auth="Container" 
	name="jdbc/mysql" password="as1008" type="javax.sql.DataSource" 
	url="jdbc:mysql://localhost:3306/customer" username="root"/>
            

O banco de dados do cliente possui uma única tabela que pode ser criada executando o script da Listagem 5.

                
use customer;
CREATE TABLE 'customer' (
	  'ID' int(11) NOT NULL AUTO_INCREMENT,
	  'name' varchar(255) DEFAULT NULL,
	  'date' date DEFAULT NULL,
	  'deleted' tinyint(1) DEFAULT '0',
	  PRIMARY KEY ('ID')
	); 

Ativando o suporte para a extensão de CDI do ZK

Para aproveitar a extensão de CDI do ZK, copie o arquivo zkcdi.jar (na distribuição binária da extensão de CDI do ZK) na pasta WEB-INF/lib do seu projeto de aplicativo da Web. O zkcdi.jar deve ser usado como uma biblioteca do aplicativo da Web.

Ativando o suporte para Weld para o Tomcat

Para ativar o suporte para Weld para o Tomcat:

1. Especifique o ouvinte do servlet Weld (usado para fazer o boot do Weld e controlar suar interações com as solicitações) no arquivo WEB-INF/web.xml na raiz da Web como:

   <listener> <listener-class>org.jboss.weld.environment.servlet.Listener</listener-class> </listener> <listener> <listener-class>org.jboss.weld.el.WeldELContextListener</listener-class> </listener>

   
   

2. O Tomcat possui um JNDI somente leitura, então o Weld não pode conectar automaticamente a SPI de extensão BeanManager. Para conectar o BeanManager no JNDI, é preciso preencher o META-INF/context.xml na raiz da Web com os seguintes conteúdos para disponibilizá-lo para a sua implementação como:

   <Resource name="BeanManager" auth="Container" type="javax.enterprise.inject.spi.BeanManager" factory="org.jboss.weld.resources.ManagerObjectFactory" />

   
   

   <resource-env-ref> <description>Object factory for the CDI Bean Manager</description> <resource-env-ref-name>BeanManager</resource-env-ref-name> <resource-env-ref-type>javax.enterprise.inject.spi.BeanManager </resource-env-ref-type> </resource-env-ref>

   
   

3. Inclua um arquivo beans.xml vazio na pasta WEB-INF para ativar a injeção de dependência pelo CDI.

Para obter instruções similares de configuração do Weld com outros servidores de aplicativos e ambiente, consulte a seção Recursos.

Voltar para parte superior

Estendendo o aplicativo

O aplicativo Manage Customers fornece as seguintes funções:

• Um painel para operações do usuário, incluindo uma visualização de todos os clientes
• Adição de novos clientes
• Edição dos clientes existentes
• Exclusão de clientes (exclusão recuperável)

A Figura 2 mostra o painel com uma lista de todos os clientes registrados. O usuário pode classificar os dados com base no ID ou no Nome. O arquivo index.zul possui vários atributos que definem a aparência e o ambiente do aplicativo como borderlayout, menubar, menue menupopup.

                
<?page id="manageCust" title="Manage Customers" cacheable="false" 
	language="xul/html" zscriptLanguage="Java" contentType="text/html;charset=UTF-8"?>
	<?variable-resolver class="org.zkoss.zkplus.cdi.DelegatingVariableResolver"?>
<zk>
  <window id="win" border="normal" width="810px" minheight="300"
   apply="${manageCustomer}">
      <caption label="Manage Customers"/>
         <borderlayout height="30px">
	     <north border="none">
	        <menubar id="menubar" width="800px">
		   <menu label="Manage Customers">
		      <menupopup>
		         <menuitem id="add" label="Register New Customer">
			  </menuitem>
			  <menuseparator />
			  <menuitem id="exit" label="Exit" onClick="win.detach()" />
		       </menupopup>
		    </menu>
		 </menubar>
	      </north>
	  </borderlayout>
      <listbox id="customerList" mold="paging" pageSize="5" multiple="true" width="800px">
	   <listhead sizable="true">
	      <listheader label="Id" sort="auto(id)"/>
	      <listheader label="Name" sort="auto(name)"/>
	      <listheader label="Active Date" sort="auto(date)"/>
	      <listheader label="Deleted?" />
	   </listhead>
	</listbox>
</window>
</zk>
            

Diferente da implementação anterior do Manage Customer, esse exemplo usa uma abordagem MVC do ZK para separar a visualização do controlador. O arquivo index.zul contém somente a parte da visualização do aplicativo, enquanto o código do controlador é escrito separadamente na classe do criador ManageCustomer. Isso permite o aproveitamento dos recursos de CDI do ZK.

Com a abordagem MVC do ZK, um controlador pode ser aplicado para um componente específico usando o atributo apply . O exemplo usa essa técnica para aplicar o ManageCustomer ao componente da janela principal do painel. Ele também demonstra o uso da diretiva de resolvedor de variável para o DelegatingVariableResolver e uma expressão EL para aplicar a instância de bean gerenciado ManageCustomer fornecida pelo contêiner.

Existem dois componentes principais na página do painel.

• O menu na parte superior possui dois itens de submenu: Register New Customer e Exit.

  Menubar é um componente menubar do ZK com dois componentes-filho menuitem do ZK com os IDs add e exit.

• A tabela listando os clientes que estão atualmente no banco de dados. A tabela do exemplo é um componente listbox do ZK cujo ID é o customerList. Os cabeçalhos da coluna da tabela são definidos pelos componentes-filho listheader da caixa de listagem customerList .

Até agora, você explorou os componentes que definem a UI do painel, mas e os dados? Quando a caixa de listagem customerList será preenchida? Veja a classe do controlador ManageCustomer mostrada na Listagem 7.

                
@Named
@SessionScoped
public class ManageCustomer extends GenericComposer implements Serializable {	
	@Inject @SessionScoped CustomerService custSvc;
	@Inject @ComponentId("customerList") private transient Listbox customerList;
	/**
	 * Set up list of all customers on the dashboard
	 * @param component
	 */
	public void doAfterCompose(Component component) throws Exception {
    	   super.doAfterCompose(component);
	   List myList = custSvc.getAllCustomers();
	   ListModelList lm = new ListModelList(myList);
	   customerList.setModel(lm);
	   customerList.setItemRenderer(new CustomersListboxRenderer());
	}
...
            

Primeiro, marque a classe de bean ManageCustomer com o qualificador @Named , permitindo o acesso através de uma expressão EL unificada. Isso foi demonstrado no componente de janela do arquivo index.zul com o valor do atributo apply de "${manageCustomer}".

A próxima etapa é usar o recurso de injeção de dependência do tipo seguro de CDI para injetar o bean CustomerService dentro do controlador ManageCustomer . O bean CustomerService é uma classe do utilitário que implementa métodos de acesso ao banco de dados para inclusão, atualização, remoção e recuperação de informações do cliente. É possível fazer isso especificando um campo CustomerService dentro da classe ManageCustomer e anotando o campo com @javax.inject.Inject. Conforme a especificação do CDI, sempre que a instância de bean ManageCustomer for instanciada por um contêiner, a instância de bean CustomerService será autoinjetada nele.

Nesse momento, é necessário acessar a caixa de listagem customerList para preenchê-la com todos os dados do cliente. O exemplo usa a classe do utilitário GenericComposer fornecida pela extensão de CDI do ZK. Estenda a classe ManageCustomer com org.zkoss.cdi.util.GenericComposer, permitindo dessa forma a injeção automática dos componentes-filho do componente da janela na classe do controlador ManageCustomer . A injeção automática dos componentes do ZK requer o uso do qualificador @org.zkoss.cdi.inject.ComponentId com o mesmo ID de componente especificado no arquivo index.zul. Além disso, de acordo com a especificação de extensão do CDI do ZK, o valor do membro qualificador ComponentId deve corresponder ao nome do campo. Por exemplo: para injetar a caixa de listagem customerList no ManageCustomer, use:

@Inject @ComponentId("customerList") private transient Listbox customerList;
            

Agora é hora de colocar alguns dados na caixa de listagem. O preenchimento dos dados precisa ser feito antes da página ser renderizada no navegador do cliente. O GenericComposer é do tipo Composer e precisa do método doAfterCompose() . Esse é um método de retorno de chamada que é chamado depois que todos os componentes são compostos. Ele permite a ocorrência do preenchimento de dados da caixa de listagem do cliente após a renderização, mas antes da composição de todos os componentes ZUL. Ainda é necessário chamar o doAfterCompose() do GenericComposer antes de qualquer coisa no método doAfterCompose() substituído.

Registre um cliente novo

O que acontece quando alguém clica em "Register New Customer" (o item de menu Add na barra de menus do painel do Manage Customer)? Depois de clicado, ele deveria apresentar a janela Enter Customer Data e salvar os dados de entrada como um novo registro de cliente no banco de dados. Para fazer isso, é preciso primeiro ter um método de identificador de eventos no controlador ManageCustomer para um item de menu "add" de evento onClick . É possível fazer isso facilmente usando o qualificador @org.zkoss.cdi.event.Events definido pela extensão de CDI do ZK e um modelo de notificação de eventos definido pelo CDI. Defina um método registerNewCustomer() simples, conforme mostrado na Listagem 8.

                
public void registerNewCustomer(@Observes @Events("add.onClick")  
                MouseEvent evt) throws Exception {
   Window win1 = (Window)Executions.createComponents("addCustomer.zul", null, null);
   win1.doModal();
   win1.setTitle("Enter Customer Data");
   win1.setClosable(true);
   win1.setMaximizable(true);
}
            

O exemplo usa a anotação @javax.enterprise.event.Observes para o parâmetro do método do tipo MouseEvent, que é um tipo de evento do ZK. Isso transformará o método registerNewCustomer() em um método observador (um método que observa um tipo MouseEvent). Sempre que um evento do tipo MouseEvent for publicado pelo CDI, esse método será notificado. Podem existir vários eventos do tipo MouseEvent, então como diferenciá-los? É nessa parte que o qualificador @Events é usado. O qualificador @Events pode ser fornecido com um valor de membro para indicar o tipo de evento que será notificado para o método. O valor de membro @Events pode ser especificado na forma de um ID de componente seguido pelo nome do evento. Por exemplo: para o item de menu Add do evento onClick , o qualificador @Events pode ser fornecido com um valor "add.OnClick" , conforme mostrado na Listagem 7.

Qual a sequência de eventos quando o item de menu "Register New Customer" é clicado? Primeiro, um evento do ZK to tipo MouseEvent é enviado para o servidor. A estrutura do ZK irá receber esse evento. Em seguida, a extensão de CDI do ZK irá publicar/acionar um evento de CDI com o qualificador @Events apropriado, juntamente com um valor de membro do tipo MouseEvent . O CDI irá notificar os métodos que estão observando sobre o tipo MouseEvent com o qualificador @Events exato e o valor de membro.

                
<?page title="Add Customer" contentType="text/html;charset=UTF-8"?>
<?variable-resolver class="org.zkoss.zkplus.cdi.DelegatingVariableResolver"?>
<zk>
   <window id="addCustomerWin" title="Register New Customer" border="normal"
       apply="${addCustomer}">
      <grid fixedLayout="true" width="450px">
         <rows>
	    <row>
	       <label value="Customer Name" />
		<textbox id="customerName" constraint="no empty" />
	    </row>
	    <row>
	        <label value="Date" />
		   <datebox id="date" constraint="no empty"/>
	      </row>
	      <row>
		 <button id="saveBtn" label="Save" />
		 <button id="cancelBtn" label="Cancel" onClick="addCustomerWin.detach()"/>
	       </row>
	     </rows>
       </grid>
   </window>
</zk> 
            

Depois de ser chamado, o método registerNewCustomer() simplesmente cria um novo componente de janela usando o addCustomer.zul e o torna uma janela de diálogo modal. A Figura 5 mostra um exemplo.

Similar à página index.zule, o exemplo usa a diretiva <?variable-resolver ?> e o DelegatingVariableResolver para aplicar o bean gerenciado AddCustomer como um controlador para o componente da janela addCustomerWin . A caixa de diálogo Register Customer é implementada como uma grade com os valores obrigatórios para o nome do cliente e a data. A implementação AddCustomer é similar à classe ManageCustomer . O bean CustomerService é injetado usando o qualificador @Inject ; os componentes-filho do addCustomerWin também são injetados automaticamente usando os qualificadores @Inject e @ComponentId , conforme mostrado na Listagem 10.

                
@Named
@SessionScoped
public class AddCustomer extends GenericComposer implements Serializable {
   @Inject @SessionScoped CustomerService custSvc;
   @Inject @ComponentId("customerName") private transient Textbox customerName;
   @Inject @ComponentId("date") private transient Datebox date;
   @Inject @ComponentId("saveBtn") private transient Button saveBtn;
}
            

Como o método registerNewCustomer() na classe ManageCustomer , o exemplo implementa o método observador saveNewCustomerDetails() , conforme descrito na Listagem 11.

                    
public void saveNewCustomerDetails(
   @Observes @Events("saveBtn.onClick") MouseEvent evt, @New Customer newCustomer)
      throws Exception {
   newCustomer.setName(customerName.getValue());
   java.util.Date utilDate = date.getValue();
   java.sql.Date sqlDate = new java.sql.Date(utilDate.getTime());
   newCustomer.setDate(sqlDate);
   custSvc.addCustomer(newCustomer);
   Executions.getCurrent().sendRedirect("index.zul");
   evt.getTarget().getParent().detach();
}	
            

Sempre que o botão Save (saveBtn) for clicado, o método saveNewCustomerDetails() é notificado do MouseEvent onClick correspondente. Esse método também possui um parâmetro adicional do tipo Customer. Ele é anotado com o qualificador @New porque, de acordo com a especificação do CDI, uma nova instância do bean Customer é injetada automaticamente no parâmetro todas as vezes que esse método é observado.

Edite/exclua clientes (com recuperação)

O usuário pode acessar a tela Edit Customer selecionando qualquer linha de cliente no painel do Manage Customer, conforme mostrado na Figura 6.

Similar ao método registerNewCustomer() , o exemplo define o método observador editCustomer() que @Observes um SelectEventdo ZK, que é enviado sempre que um listitem for selecionado na caixa de listagem.

           
public void editCustomer(
   @Observes @Events("customerList.onSelect") SelectEvent evt) throws Exception {
      Listitem selectedCustomer = customerList.getSelectedItem();
      String custId = ((Listcell) (selectedCustomer.getChildren().get(0))).getLabel();
      Map<String, String> args = new HashMap<String, String>();
      args.put("custId", custId);
      Window win2 = (Window) Executions.createComponents("editCustomer.zul", null, args);
      win2.doModal();
      win2.setTitle("Enter Customer Data");
      win2.setClosable(true);
      win2.setMaximizable(true);
}	

A implementação da classe do controlador EditCustomer para o componente de janela editCustomerWin do editCustomer.zul é muito similar ao AddCustomer. Para evitar repetições, ela não é descrita neste artigo.

É possível fazer o download do código desse aplicativo, da fonte da classe EditCustomer e do arquivo editCustomer.zul.

Voltar para parte superior

Resumo

Neste artigo, você explorou o ZK, uma estrutura Ajax de software livre escrita no código Java e na especificação JSR-299 Contextos e Injeção de Dependência. A extensão de CDI do ZK possui recursos que permitem o uso do CDI no modelo de programação do ZK. Foi usado um exemplo real simples em execução no Apache Tomcat com conexão ao banco de dados MySQL.

A estrutura do ZK possui um conjunto rico de componentes, uma linguagem de marcação, ferramentas de desenvolvimento poderosas e uma excelente documentação. Ela é uma estrutura de Ajax de software livre acionada por eventos. O CDI, conforme definido pela especificação JSR-299 da plataforma Java EE 6, também fornece um conjunto de recursos poderosos, como a injeção de dependência do tipo seguro, um modelo de notificação de eventos e um SPI para desenvolver extensões portáteis. A extensão de CDI do ZK integra o modelo de programação do ZK com CDI, permitindo o desenvolvimento contínuo de aplicativos corporativos do Java EE 6.

Voltar para parte superior

Download

Informações sobre métodos de download

Recursos

Aprender

• "Aplicativos de Internet rica que usam o ZK: Uma estrutura Ajax de software livre" (developerWorks, janeiro de 2010) fornece uma introdução sobre o ZK e um exemplo real do seu uso em execução no Apache Tomcat com conexão ao banco de dados MySQL.
  
  
• Faça um tour, execute um demo e faça download do Ajax de software livre do ZK.
  
  
• Leia o Guia do desenvolvedor do ZK para obter informações sobre os fundamentos e o componente ZUL e obter informações detalhadas do ZK.
  
  
• Assista aos demos dinâmicos dos aplicativos usando ZK (ZK Explorer, ZK SpreadSheet, ZK Calendar, entre outros).
  
  
• Obtenha toda a documentação do ZK Studio: Introdução, Guia do desenvolvedor e Webinars.
  
  
• Saiba tudo sobre a especificação JSR-299: Contextos e Injeção de Dependência para a plataforma Java™ EE.
  
  
• Leia Getting started with ZK CDI para obter ajuda com a configuração do seu ambiente de desenvolvimento.
  
  
• Leia sobre Weld, a implementação de referência da especificação JSR-299 que define CDI.
  
  
• Leia o artigo "Dependency injection with Guice" (developerWorks, dezembro de 2008) para fazer um tour no Guice, a estrutura do Google de injeção de dependência de software livre para desenvolvimento Java.
  
  
• "Introduction to Spring 2 and JPA" (developerWorks, agosto de 2006) é uma discussão antiga, porém útil, sobre a estrutura Spring e os conceitos de DI.
  
  
• "Java EE 5: Power and productivity with less complexity" (developerWorks, novembro de 2007) fornece um tour rápido com uma solução alternativa do JEE 5, incluindo os detalhes de DI.
  
  
• Para aprender mais sobre como configurar o Weld com outros servidores de aplicativos e ambientes, consulte o capítulo 18: Application servers and environments supported by Weld de "Community Documentation".
  
  

Obter produtos e tecnologias

• Faça o download das versões de avaliação de produto IBM ou explore as versões de teste on-line no IBM SOA Sandbox e entre em contato com as ferramentas de desenvolvimento de aplicativos e produtos de middleware do DB2®, Lotus®, Rational®, Tivoli®e WebSphere®.
  
  

Discutir

• Blogs do developerWorks: Confira os blogs do developerWorks e participe da comunidade do developerWorks.
  
  

Sobre os autores

Sachin fez mestrado na Universidade de Utah, em Salt Lake City. Ele trabalhou em empresas de pequeno e grande porte nos EUA e na Índia em várias funções técnicas e gerenciais. Sachin atualmente trabalha na divisão IBM Software Group Lotus.

Ashish se formou na Universidade de Pune, na Índia, e trabalhou com a plataforma Java EE por seis anos em diversos aplicativos corporativos para empresas multinacionais. Ele atualmente trabalha na Potix Corporation, que é a força impulsora da estrutura ZK Ajax.

Classificar este artigo

Comentários

Voltar para parte superior

Índice

• Introdução
• Usando ZK com CDI
• Implementing a real application
• Setting up the environment
• Estendendo o aplicativo
• Resumo
• Download
• Recursos
• Sobre os autores
• Comentários

Conheça a IBM da sua cidade

A IBM está mais perto do que você imagina!

---

Saiba mais