Google Git
Sign in
apache / netbeans-website-cleanup / refs/heads/asciidoc-features / . / src / content / kb / docs / javaee / cdi-validate_pt_BR.html
blob: aeca9433189b04f613468118f882d8f9d729c174 [file] [log] [blame]
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Aplicando Anotações de Ciclo de Vida e de Beans @Alternative: Tutorial do NetBeans IDE</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<meta name="description" content="This tutorial explores CDI's injection facilities to perform custom validation using NetBeans IDE">
<meta name="keywords" content="NetBeans, IDE, integrated development environment,
Contexts and Dependency Injection, CDI, Web Beans, injection, qualifier">
<link rel="stylesheet" type="text/css" href="../../../netbeans.css">
</head>
<body>
<!--
Copyright (c) 2009, 2010, 2011, Oracle and/or its affiliates. All rights reserved.
-->
<h1>Aplicando Anotações de Ciclo de Vida e de Beans @Alternative</h1>
<p><em>Contribuição de Andy Gibson</em></p>
<div class="margin-around">
<div class="feedback-box margin-around float-left" style="margin-right:15px">
<h3>Injeção de Dependência e Contextos</h3>
<ol>
<li><a href="cdi-intro.html">Introdução ao CDI e ao JSF 2.0</a></li>
<li><a href="cdi-inject.html">Trabalhando com Injeção e Qualificadores no CDI</a></li>
<li><strong>Aplicando Anotações @Alternative Beans e de Ciclo de Vida</strong>
<ul style="margin: 5px 0 0 -2em">
<li><a href="#alternative">Tratando Várias Implantações</a></li>
<li><a href="#lifecycle">Aplicando Anotações de Ciclo de Vida em Beans gerenciado</a></li>
<li><a href="#seealso">Consulte Também</a></li>
</ul></li>
<li><a href="cdi-events.html">Trabalhando com Eventos no CDI</a></li>
</ol>
</div>
</div>
<img alt="O conteúdo desta página se aplica ao NetBeans IDE 7.2, 7.3, 7.4 e 8.0" class="stamp" src="../../../images_www/articles/73/netbeans-stamp-80-74-73.png" title="O conteúdo desta página se aplica ao NetBeans IDE 7.2, 7.3, 7.4 e 8.0">
<p>A Injeção de Dependência e Contextos (CDI), especificada por <a href="http://jcp.org/en/jsr/detail?id=299">JSR-299</a>, é parte integrante do Java EE 6 e fornece uma arquitetura que permite aos componentes do Java EE, como os servlets, enterprise beans e JavaBeans, existirem dentro do ciclo de vida de uma aplicação com escopos bem definidos. Além disso, os serviços CDI permitem que os componentes do Java EE, como beans de sessão EJB e beans gerenciados do JavaServer Faces (JSF), sejam injetados e interajam de maneira acoplada flexível, disparando e observando eventos.</p>
<p>Este tutorial tem base no post do blog de Andy Gibson, intitulado <a href="http://www.andygibson.net/blog/index.php/2009/12/22/getting-started-with-cdi-part-2-injection/">Introdução ao CDI parte 2: Injeção</a>. Ele demonstra como é possível usufruir da anotação <code>@Alternative</code> para configurar sua aplicação para diferentes implantações e também como utilizar as anotações do ciclo de vida do bean gerenciado, como a <code>@PostConstruct</code>e a <code>@PostDestroy</code>, para combinar a injeção CDI com a funcionalidade fornecida pela <a href="http://jcp.org/en/jsr/detail?id=316">Especificação do Bean Gerenciado do Java EE 6</a>.</p>
<p>O NetBeans IDE fornece um suporte incorporado para a Injeção de Dependência e Contextos, incluindo a opção de geração do arquivo de configuração de CDI <code>beans.xml</code> durante a criação do projeto, do editor e do suporte de navegação para anotações, assim como vários assistentes para a criação de artefatos CDI comumente utilizados.</p>
<br style="clear:left;">
<div class="indent">
<p>Para concluir este tutorial, você precisa dos seguintes recursos e softwares.</p>
<table id="requiredSoftware">
<tbody>
<tr>
<th class="tblheader" scope="col">Software ou Recurso</th>
<th class="tblheader" scope="col">Versão Necessária</th>
</tr>
<tr>
<td class="tbltd1"><a href="https://netbeans.org/downloads/index.html">NetBeans IDE</a></td>
<td class="tbltd1">Versão Java EE 7.2, 7.3, 7.4, 8.0</td>
</tr>
<tr>
<td class="tbltd1"><a href="http://www.oracle.com/technetwork/java/javase/downloads/index.html">JDK (Java Development Kit)</a></td>
<td class="tbltd1">versão 7 ou 8</td>
</tr>
<tr>
<td class="tbltd1"><a href="http://glassfish.dev.java.net/">GlassFish Server</a></td>
<td class="tbltd1">Open Source Edition 3.x ou 4.x</td>
</tr>
<tr>
<td class="tbltd1"><a href="https://netbeans.org/projects/samples/downloads/download/Samples%252FJavaEE%252FcdiDemo2.zip">cdiDemo2.zip</a></td>
<td class="tbltd1">n/d</td>
</tr>
</tbody>
</table>
<p class="notes"><strong>Observações:</strong></p>
</div>
<ul>
<li>O pacote Java EE do NetBeans inclui também o GlassFish Server Open Source Edition, que é um contêiner compatível com Java EE.</li>
<li>É possível fazer download do projeto modelo de solução deste tutorial: <a href="https://netbeans.org/projects/samples/downloads/download/Samples%252FJavaEE%252FcdiDemo3.zip">cdiDemo3.zip</a></li>
</ul>
<br>
<h2 id="alternative">Tratando Várias Implantações</h2>
<p>O CDI oferece o uso da anotação <code>@Aternative</code> que lhe permite encapsular vários beans que coincidem com um ponto de injeção sem erros de ambiguidade. Em outras palavras, é possível aplicar a anotação <code>@Alternative</code> a dois ou mais beans e, em seguida, com base na implantação, especificar o bean que deseja utilizar no arquivo de configuração do CDI <code>beans.xml</code>.</p>
<p>Considere o seguinte cenário como demonstração disso. Nós injetamos um <code>ItemValidator</code> na nossa classe <code>ItemProcessor</code> principal. O <code>ItemValidator</code> é implementado pelo <code>DefaultItemValidator</code> e pelo <code>RelaxedItemValidator</code>. Com base nos requisitos de implantação, gostaríamos de utilizar o <code>DefaultItemValidator</code> para a maior parte dos casos, mas também é exigido o <code>RelaxedItemValidator</code> para uma implantação específica. Para resolver isso, anotamos os dois beans e, em seguida, especificamos qual bean utilizar para uma determinada implantação, adicionando uma entrada ao arquivo <code>beans.xml</code> da aplicação.</p>
<div class="indent">
<img alt="Diagrama de CDI que mostra os objetos criados neste exercício" class="margin-around" src="../../../images_www/articles/73/javaee/cdi-validate/cdi-diagram-alternative.png" title="Use a injeção de CDI para acoplar, livremente, as classes na sua aplicação">
</div>
<ol>
<li>Começando pela extração do projeto inicial modelo a partir do arquivo <code>cdiDemo2.zip</code> (Consulte a <a href="#requiredSoftware">tabela acima, que lista os recursos necessários</a>.) Abra o projeto no IDE escolhendo Arquivo > Abrir Projeto (Ctrl-Shift-O; ⌘-Shift-O no Mac) e, em seguida, selecionando o projeto no seu local no computador.</li>
<li>Clique com o botão direito do mouse no nó do projeto na janela Projetos e escolha Propriedades.</li>
<li>Selecione a categoria Executar e confirme se a instância do GlassFish está selecionada na lista drop-down Servidor. </li>
<li>Crie uma interface <code>ItemValidator</code>. <br><br>Clique no botão Novo Arquivo (<img alt="Botão Novo Arquivo" src="../../../images_www/articles/73/javaee/cdi-common/new-file-btn.png">) ou pressione CTRL-N (⌘-N no Mac) para abrir o assistente de Arquivo.</li>
<li>Selecione a categoria Java e, em seguida, selecione Interface Java. Clique em Próximo.</li>
<li>Digite <strong>ItemValidator</strong> como o nome da classe e, em seguida, <strong>exercício3</strong> como o pacote.</li>
<li>Clique em Finalizar. A nova interface será gerada e aberta no editor.</li>
<li>Adicione um método chamado <code>isValid()</code> que utiliza um objeto <code>Item</code> e retorna um valor <code>boolean</code>.
<pre class="examplecode">
public interface ItemValidator {
<strong>boolean isValid(Item item);</strong>
}</pre>
(Utilize a dica do editor para adicionar a instrução de importação para o <code>exercise2.Item</code>.)</li>
<li>Expanda a classe <code>ItemProcessor</code> para incorporar a nova funcionalidade. Abra o <code>ItemProcessor</code> no editor e faça as seguintes alterações.
<pre class="examplecode">
@Named
@RequestScoped
public class ItemProcessor {
@Inject @Demo
private ItemDao itemDao;
<strong>@Inject
private ItemValidator itemValidator;</strong>
public void execute() {
List&lt;Item&gt; items = itemDao.fetchItems();
for (Item item : items) {
System.out.println(<strong>&quot;Item = &quot; + item + &quot; valid = &quot; + itemValidator.isValid(item)</strong>);
}
}
}</pre>
<p class="tips">(Utilize a dica do editor para adicionar a instrução de importação para <code>exercise3.ItemValidator</code>.)</p></li>
<li>Crie uma implementação do <code>ItemValidator</code> chamado <code>DefaultItemValidator</code> que simplesmente testa o limite com relação ao valor.
<p>
Na janela Projetos, clique com o botão direito do mouse no pacote <code>exercise3</code> e selecione Nova > Classe Java. Nomeie a classe como <strong>DefaultItemValidator</strong> e clique em Finalizar.</p></li>
<li>Faça com que o <code>DefaultItemValidator</code> implemente o <code>ItemValidator</code> e substitua o método <code>isValid()</code> como se segue.
<pre class="examplecode">
public class DefaultItemValidator <strong>implements ItemValidator</strong> {
<strong>@Override
public boolean isValid(Item item) {
return item.getValue() &lt; item.getLimit();
}</strong>
}</pre>
<p>(Utilize a dica do editor para adicionar a instrução de importação para o <code>exercise2.Item</code>.)</p></li>
<li>Clique no botão Executar Projeto (<img alt="Botão Executar Projeto" src="../../../images_www/articles/73/javaee/cdi-common/run-project-btn.png">) na barra de ferramentas principal do IDE. O projeto é compilado e implantado no GlassFish e a página de boas-vindas da aplicação (<code>process.xhtml</code>) será aberta no browser.</li>
<li>Clique no botão "<code>Execute</code>" que é exibido na página. Volte ao IDE e examine o log do GlassFish Server. O log do servidor é exibido na janela Saída (Ctrl-4; ⌘-4 no Mac) na guia GlassFish. É possível notar que os itens estão sendo validados e que o único item válido listado é o caso em que o valoe é menor que o limite.
<pre class="examplecode">
INFO: Item = exercise2.Item@e857ac [Value=34, Limit=7] valid = false
INFO: Item = exercise2.Item@63124f52 [Value=4, Limit=37] valid = true
INFO: Item = exercise2.Item@4715c34e [Value=24, Limit=19] valid = false
INFO: Item = exercise2.Item@65c95a57 [Value=89, Limit=32] valid = false</pre>
<img alt="Janela Saída - log do GlassFish Server" class="margin-around b-all" src="../../../images_www/articles/73/javaee/cdi-validate/output-window.png" title="Exiba o log do servidor na janela Saída"></li>
<li>Agora, considere o cenário onde temos que implantar em um site diferente, mais flexível, e considere um item como inválido somente se o valor for mais de duas vezes maior que o limite. Pode ser necessário ter um outro bean que implemente a interface <code>ItemValidator</code> para essa lógica.
<p>
Crie uma nova implementação do <code>ItemValidator</code> chamada <code>RelaxedItemValidator</code>. Na janela Projetos, clique com o botão direito do mouse no pacote <code>exercise3</code> e selecione Nova > Classe Java. Nomeie a classe <strong>RelaxedItemValidator</strong> e clique em Finalizar.</p></li>
<li>Faça com que o <code>RelaxedItemValidator</code> implemente o <code>ItemValidator</code> e substitua o método <code>isValid()</code> como se segue.
<pre class="examplecode">
public class RelaxedItemValidator <strong>implements ItemValidator</strong> {
<strong>@Override
public boolean isValid(Item item) {
return item.getValue() &lt; (item.getLimit() * 2);
}</strong>
}</pre>
<p>(Utilize a dica do editor para adicionar a instrução de importação para o <code>exercise2.Item</code>.)</p></li>
<li>Clique no botão Executar Projeto (<img alt="Botão Executar Projeto" src="../../../images_www/articles/73/javaee/cdi-common/run-project-btn.png">) para executar o projeto. Observe que o projeto agora falha na implantação.</li>
<li>Examine o log do servidor na janela Saída (Ctrl-4; ⌘-4 no Mac). Você nota uma mensagem de erro relatando um problema de "dependência ambígua". Isso ocorre porque agora temos duas classes implementando a mesma interface.
<pre class="examplecode">
org.glassfish.deployment.common.DeploymentException: Injection point has ambiguous dependencies.
Injection point: field exercise2.ItemProcessor.itemValidator;
Qualifiers: [@javax.enterprise.inject.Default()];
Possible dependencies: [exercise3.RelaxedItemValidator, exercise3.DefaultItemValidator]</pre>
<p>Weld, a implementação para CDI, não pode determinar se deve utilizar o <code>RelaxedItemValidator</code> ou o <code>DefaultItemValidator</code> para o ponto de injeção fornecido.</p>
<p>
Como mencionado anteriormente, a única diferença é baseada na implantação. Para a maioria das implantações, preferimos utilizar o validador default, mas para uma implantação, preferimos utilizar a implantação "flexível". O CDI oferece o uso da anotação <code>@Alternative</code> que lhe permite encapsular vários beans que coincidam com um ponto de injeção sem erros de ambiguidade e o bean a ser utilizado, que é definido no arquivo <code>beans.xml</code>. Isso lhe permite implantar as duas implementações no mesmo módulo com a definição <code>beans.xml</code> sendo a única diferença, que pode ser alterada ao longo de implantações diferentes.</p></li>
<li>Adicione a anotação <code>@Alternative</code> e as instruções de importação correspondentes a <code>RelaxedItemValidator</code> e <code>DefaultItemValidator</code>. <br><br> Abra o <code>RelaxedItemValidator</code> no editor e faça as seguintes alterações.
<pre class="examplecode">
<strong>import javax.enterprise.inject.Alternative;</strong>
...
<strong>@Alternative</strong>
public class RelaxedItemValidator implements ItemValidator {
public boolean isValid(Item item) {
return item.getValue() &lt; (item.getLimit() * 2);
}
}</pre>
<p class="tips">Digite "<code>@Al</code>" e, em seguida, pressione Ctrl-Espaço para chamar a funcionalidade autocompletar código. Como somente uma opção é filtrada, a anotação <code>@Alternative</code> é autocompletada e a instrução de importação correspondente para o <code>javax.enterprise.inject.Alternative</code> é adicionada automaticamente à parte superior do arquivo. Normalmente, ao pressionar Ctrl-Espaço nas anotações também é fornecido uma documentação pop-up Javadoc.</p>
<img alt="Pop-up de documentação Javadoc no editor" class="margin-around b-all" src="../../../images_www/articles/73/javaee/cdi-validate/code-completion-alternative.png" title="Pressione Ctrl-Espaço em anotações para chamar a documentação Javadoc">
<p>
Alterne para <code>DefaultItemValidator</code> (pressione Ctrl-Tab) e faça as alterações a seguir.</p>
<pre class="examplecode">
<strong>import javax.enterprise.inject.Alternative;</strong>
...
<strong>@Alternative</strong>
public class DefaultItemValidator implements ItemValidator {
public boolean isValid(Item item) {
return item.getValue() &lt; item.getLimit();
}
}</pre>
<p>Se tivéssemos implantado a aplicação, agora obteríamos uma mensagem de erro "dependência não-satisfeita", já que definimos os dois beans coincidentes como alternativos, mas não ativamos nenhum deles no arquivo <code>beans.xml</code>.</p></li>
<li>Utilize a caixa de diálogo Ir para Arquivo do IDE para abrir rapidamente o arquivo <code>beans.xml</code>. Selecione Navegar > Ir para Arquivo no menu principal do IDE (Alt-Shift-O; Ctrl-Shift-O no Mac) e, em seguida, digite "<code>beans</code>". Clique em OK. <img alt="Caixa de diálogo Ir para Arquivo" class="margin-around b-all" src="../../../images_www/articles/73/javaee/cdi-validate/go-to-file.png" title="Use a caixa de diálogo Ir para Arquivo para localizar rapidamente um arquivo de projeto"></li>
<li>Faça as seguintes alterações no arquivo <code>bean.xml</code>.
<pre class="examplecode">
&lt;beans xmlns=&quot;http://java.sun.com/xml/ns/javaee&quot;
xmlns:xsi=&quot;http://www.w3.org/2001/XMLSchema-instance&quot;
xsi:schemaLocation=&quot;http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/beans_1_0.xsd&quot;&gt;
<strong>&lt;alternatives&gt;
&lt;class&gt;exercise3.RelaxedItemValidator&lt;/class&gt;
&lt;/alternatives&gt;</strong>
&lt;/beans&gt;</pre>
<p>Isso informa ao CDI que o <code>RelaxedItemValidator</code> deve ser usado para esta implantação. É possível achar que a anotação <code>@Alternative</code> desativa efetivamente o bean, tornando-o indisponível para injeção, mas permitindo que a implementação seja encapsulada com os outros beans. Adicioná-la como uma alternativa no arquivo <code>beans.xml</code> reabilita efetivamente o bean, tornando-o disponível para injeção. Ao movermos esse tipo de metadados para o arquivo <code>beans.xml</code>, podemos colocar no pacote versões diferentes do arquivo à várias implantações.</p></li>
<li>Clique no botão Executar Projeto (<img alt="Botão Executar Projeto" src="../../../images_www/articles/73/javaee/cdi-common/run-project-btn.png">) para executar o projeto (como alternativa, Pressione F6; fn-F6 no Mac). No browser, clique no botão "<code>Execute</code>" exibido na página. Volte ao IDE e examine o log do GlassFish Server exibido na janela Saída (Ctrl-4; ⌘-4 no Mac).
<pre class="examplecode">
INFO: Item = exercise2.Item@672f0924 [Value=34, Limit=7] valid = false
INFO: Item = exercise2.Item@41014f68 [Value=4, Limit=37] valid = true
INFO: Item = exercise2.Item@3d04562f [Value=24, Limit=19] valid = true
INFO: Item = exercise2.Item@67b646f4 [Value=89, Limit=32] valid = false</pre>
<p>Você pode notar que a implementação <code>RelaxedItemValidator</code> está sendo utilizada como o terceiro item exibido como válido, ao mesmo tempo em que o valor fornecido (<code>24</code>) é maior que o limite informado (<code>19</code>).</p></li>
</ol>
<br>
<h2 id="lifecycle">Aplicando Anotações de Ciclo de Vida aos Beans Gerenciados</h2>
<p>Neste exercício, será injetado um <code>ItemErrorHandler</code> na <code>ItemProcessor</code> principal. Como o <code>FileErrorReporter</code> é a única implementação da interface <code>ItemErrorHandler</code>, ela será selecionada como a injeção. Para configurar as ações específicas de ciclo de vida para a classe, é necessário utilizar as anotações <code>@PostConstruct</code> e <code>@PreDestroy</code> a partir da especificação do Bean gerenciado (incluídas no <a href="http://jcp.org/en/jsr/detail?id=316">JSR 316: Plataforma Java, Especificação do Enterprise Edition 6</a>).</p>
<div class="indent">
<img alt="Diagrama de CDI que mostra os objetos criados neste exercício" class="margin-around" src="../../../images_www/articles/73/javaee/cdi-validate/cdi-diagram-lifecycle.png" title="Use a injeção de CDI para acoplar, livremente, as classes na sua aplicação">
</div>
<p>Prosseguindo com o exemplo, crie uma interface <code>ItemErrorHandler</code> para tratar itens inválidos ao serem descobertos.</p>
<ol>
<li>Na janela Projetos, clique com o botão direito do mouse no pacote <code>exercise3</code> e selecione Nova > Interface Java.</li>
<li>No assistente de Interface Java, digite <strong>ItemErrorHandler</strong> como o nome da classe e, em seguida <strong>exercício3</strong> como o pacote. Clique em Finalizar.
<p>A nova interface será gerada e aberta no editor.</p></li>
<li>Adicione o método chamado <code>handleItem()</code> que utiliza um objeto <code>Item</code> como um argumento.
<pre class="examplecode">
public interface ItemErrorHandler {
<strong>void handleItem(Item item);</strong>
}</pre>
<p>(Utilize a dica do editor para adicionar a instrução de importação para o <code>exercise2.Item</code>.)</p></li>
<li>Comece com a implementação do <code>ItemErrorHandler</code> com um handler falso chamado <code>FileErrorReporter</code> que salva os detalhes do item em um arquivo.
<p>
Na janela Projetos, clique com o botão direito do mouse no pacote <code>exercise3</code> e selecione Nova > Classe Java. Nomeie a classe <strong>FileErrorReporter</strong> e clique em Finalizar.</p></li>
<li>Faça com que o <code>FileErrorReporter</code> implemente o <code>ItemErrorHandler</code> e substitua o método <code>handlerItem()</code> como se segue.
<pre class="examplecode">
public class FileErrorReporter <strong>implements ItemErrorHandler</strong> {
<strong>@Override
public void handleItem(Item item) {
System.out.println(&quot;Saving &quot; + item + &quot; to file&quot;);
}</strong>
}</pre>
<p>(Utilize a dica do editor para adicionar a instrução de importação para o <code>exercise2.Item</code>.)</p>
<p>
Você deseja abrir o arquivo antes de começar a tratar itens, portanto, deixe-o aberto durante o processo em que o conteúdo é adicionado ao arquivo e, em seguida, feche o arquivo quando processamento tiver sido concluído. Você poderia adicionar manualmente os métodos <code>initProcess()</code> e <code>finishProcess()</code> ao bean de informe de erro, mas então não poderia codificar a interface, já que o chamador precisaria conhecer esses métodos específicos da classe. Você poderia adicionar esses mesmos métodos à interface <code>ItemErrorReporter</code>, mas então seria necessário implementar desnecessariamente tais métodos em cada classe que implemente aquela interface. Em vez disso, é possível utilizar algumas das anotações de ciclo de vida da especificação do Bean Gerenciado (incluídas na <a href="http://jcp.org/en/jsr/detail?id=316">JSR 316: plataforma Java, Especificação do Enterprise Edition 6</a>) para chamar os métodos no bean em alguns pontos no ciclo de vida do bean. Um método anotado <code>@PostConstruct</code> é chamado quando o bean tiver sido construído e qualquer dependência do bean tiver sido injetada. Da mesma forma, um método anotado <code>@PreDestroy</code> é chamado um pouco antes do bean ser descartado pelo contêiner.</p></li>
<li>Adicione os seguintes métodos <code>init()</code> e <code>release()</code> com as anotações <code>@PostConstruct</code> e <code>@PreDestroy</code> correspondentes.
<pre class="examplecode">
public class FileErrorReporter implements ItemErrorHandler {
<strong>@PostConstruct
public void init() {
System.out.println(&quot;Creating file error reporter&quot;);
}
@PreDestroy
public void release() {
System.out.println(&quot;Closing file error reporter&quot;);
}</strong>
@Override
public void handleItem(Item item) {
System.out.println(&quot;Saving &quot; + item + &quot; to file&quot;);
}
}</pre></li>
<li>Corrigir importações. Clique com o botão direito do mouse no editor e selecione Corrigir importações ou pressione Ctrl-Shift-I (⌘-Shift-I no Mac). Instruções de importação para <code>javax.annotation.PostConstruct</code> e <code>javax.annotation.PreDestroy</code> serão adicionadas à parte superior do arquivo.</li>
<li>Finalmente, adicione o novo bean <code>ItemErrorHandler</code> ao <code>ItemProcessor</code>.
<pre class="examplecode">
@Named
@RequestScoped
public class ItemProcessor {
@Inject @Demo
private ItemDao itemDao;
@Inject
private ItemValidator itemValidator;
<strong>@Inject
private ItemErrorHandler itemErrorHandler;</strong>
public void execute() {
List&lt;Item&gt; items = itemDao.fetchItems();
for (Item item : items) {
<strong>if (!itemValidator.isValid(item)) {
itemErrorHandler.handleItem(item);
}</strong>
}
}
}</pre>
<p>(Utilize a dica do editor para adicionar a instrução de importação para o <code>exercise3.ItemErrorHandler</code>.)</p>
</li>
<li>Clique no botão Executar Projeto (<img alt="Botão Executar Projeto" src="../../../images_www/articles/73/javaee/cdi-common/run-project-btn.png">) para executar o projeto (como alternativa, Pressione F6; fn-F6 no Mac). No browser, clique no botão "<code>Execute</code>" exibido na página. Volte ao IDE e examine o log do GlassFish Server exibido na janela Saída (Ctrl-4; ⌘-4 no Mac).
<pre class="examplecode">
INFO: Creating file error reporter
INFO: Saving exercise2.Item@6257d812 [Value=34, Limit=7] to file
INFO: Saving exercise2.Item@752ab82e [Value=89, Limit=32] to file
INFO: Closing file error reporter</pre>
</li>
</ol>
<div class="feedback-box">
<a href="/about/contact_form.html?to=3&amp;subject=Feedback:%20Using%20CDI%20Injection%20to%20Perform%20Custom%20Validation">Enviar Feedback neste Tutorial</a>
</div>
<br style="clear:both;">
<h2 id="seealso">Consulte Também</h2>
<p>Diferentes implantações de aplicações podem utilizar regras diversas para tratar itens inválidos, tal como a rejeição de um item, o envio de notificações aos indivíduos, a sinalização desses itens, ou simplesmente a listagem deles em um arquivo de saída. Além disso, é possível fazer uma combinação dessas regras (ex., rejeitar um pedido, enviar um e-mail a um representante de vendas e listar o pedido em um arquivo). Uma maneira excelente de tratar esse tipo de problema multifacetado é utilizando <em>eventos</em>. Os eventos CDI são o assunto do artigo final desta série:</p>
<ul>
<li><a href="cdi-events.html">Trabalhando com Eventos no CDI</a></li>
</ul>
<p>Para obter mais informações sobre o CDI e o Java EE, consulte os recursos a seguir.</p>
<ul>
<li><a href="cdi-intro.html">Introdução à Injeção de Dependência e Contextos e JSF 2.0</a></li>
<li><a href="cdi-inject.html">Trabalhando com Injeção e Qualificadores no CDI</a></li>
<li><a href="javaee-gettingstarted.html">Conceitos Básicos sobre Aplicações do Java EE</a></li>
<li><a href="http://blogs.oracle.com/enterprisetechtips/entry/using_cdi_and_dependency_injection">Dica Técnica do Enterprise: Utilizando Injeção de Dependência e de CDI para Java em uma Aplicação JSF 2.0</a></li>
<li><a href="http://download.oracle.com/javaee/6/tutorial/doc/gjbnr.html">O Tutorial do Java EE 6, Parte V: Injeção de Dependência e Contextos para a Plataforma Java EE</a></li>
<li><a href="http://jcp.org/en/jsr/detail?id=299">JSR 299: Especificação para Injeção de Dependência e Contextos</a></li>
<li><a href="http://jcp.org/en/jsr/detail?id=316">JSR 316: Plataforma Java, Especificação do Enterprise Edition 6</a></li>
</ul>
</body>
</html>