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

= Usando o CDI para Injetar Pacotes OSGi como Serviços no NetBeans IDE
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: Usando o CDI para Injetar Pacotes OSGi como Serviços no NetBeans IDE - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Usando o CDI para Injetar Pacotes OSGi como Serviços no NetBeans IDE

Este documento demonstra como o suporte integrado para o framework link:http://www.osgi.org/Main/HomePage[+Open Services Gateway Initiative+] (OSGi) no NetBeans IDE simplifica o processo de criação de pacotes OSGi e o uso dos pacotes em seus projetos. Neste tutorial, você criará dois pacotes OSGi simples a partir do arquétipo de pacote Maven OSGi e, em seguida, implantará os pacotes no GlassFish Server Open Source Edition 3.1.

Depois de criar os pacotes OSGi básicos, você criará uma aplicação cliente Web e usará o CDI para injetar os pacotes como um serviço. A seguir, você implantará a aplicação Web como um pacote no servidor. O tutorial, em seguida, demonstrará como usar a Console de Admin OSGi para trabalhar com pacotes OSGi.

Utilizar um pacote OSGi em uma Aplicação Corporativa pode fornecer maior modularidade e flexibilidade em relação à atualização de pacotes individuais. O suporte predefinido para OSGi que acompanha o GlassFish Server torna a incorporação de pacotes na sua aplicação muito fácil.

Este tutorial tem base na publicação do blog link:http://blogs.oracle.com/arungupta/entry/totd_154_dynamic_osgi_services[+ TOTD #154: Dynamic OSGi services in GlassFish 3.1 - Using CDI and @OSGiService +] e outras entradas do blog que podem ser encontradas no link:http://blog.arungupta.me/[+blog de Arun Gupta+]. Certifique-se de visitar o blog e ver muitas outras entradas excelentes relacionadas ao trabalho com o OSGi.

Além disso, os recursos a seguir contêm uma variedade de informações sobre o uso do OSGi e CDI em aplicações híbridas.

* link:http://weblogs.java.net/blog/2009/06/14/developing-hybrid-osgi-java-ee-applications-glassfish[+ Desenvolvendo aplicações Híbridas (OSGi + Java EE) no GlassFish+]
* link:http://blogs.oracle.com/sivakumart/entry/typesafe_injection_of_dynamic_osgi[+ Injeção segura de serviços OSGi dinâmicos em aplicações Java EE híbridas+]
* link:http://weblogs.java.net/blog/2009/06/04/osgi-enabled-web-applications-inglassfish[+ Aplicações Web compatíveis com OSGi no GlassFish+]
* link:http://www.youtube.com/watch?v=vaOpJJ-Xm70[+ Vídeo do YouTube: injeção segura de serviços OSGI dinâmicos com o GlassFish 3.1 e CDI +]
* link:http://glassfish.java.net/public/GF-OSGi-Features.pdf[+ Desenvolvimento de Aplicações OSGi usando o GlassFish Server"+] [PDF]

*Exercícios do Tutorial*

* <<Exercise_1,Criando o Projeto POM pai>>
* <<Exercise_2,Criando os Projetos de Pacotes OSGi>>
* <<Exercise_2a,Criando o Pacote da Interface MavenHelloServiceApi>>
* <<Exercise_2b,Criando o Pacote de Implementação MavenHelloServiceImpl>>
* <<Exercise_2c,Construindo e Implantando os Pacotes OSGi>>
* <<Exercise_3,Criando a Aplicação Cliente Web>>
* <<Exercise_3a,Configurando as Dependências no Projeto POM>>
* <<Exercise_3b,Criando a Aplicação Web MavenHelloWebClient>>
* <<Exercise_3c,Construindo a Aplicação Web como um Pacote>>
* <<Exercise_3d,Implantando o Pacote de Aplicações Web>>
* <<Exercise_4,Instalando e Usando a Console de Admin OSGi>>
* <<Exercise_5,Referências e Leitura Adicional>>

*Para seguir este tutorial, são necessários os recursos e o software a seguir.*

|===
|Software ou Recurso |Versão Necessária 

|link:http://download.netbeans.org/netbeans/7.1/beta/[+NetBeans IDE+] |Versão Java EE 7.2, 7.3, 7.4, 8.0 

|link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+JDK (Java Development Kit)+] |versão 7 ou 8 

|GlassFish Server Open Source Edition |3.1.x ou 4.x 
|===

*Pré-requisitos*

Este tutorial pressupõe que você tenha algum conhecimento básico das tecnologias a seguir, ou alguma experiência de programação com elas:

* Programação em Java
* NetBeans IDE
* Framework Maven

Antes de começar este tutorial, talvez você queira se familiarizar com a documentação a seguir.

* link:http://wiki.netbeans.org/MavenBestPractices[+Melhores Práticas para o Apache Maven no NetBeans IDE+]
* link:http://books.sonatype.com/mvnref-book/reference/introduction.html[+Capítulo 1. Introdução ao Apache Maven+] (do link:http://books.sonatype.com/mvnref-book/reference/index.html[+Maven: A Referência Completa +])
* link:http://www.osgi.org/javadoc/r4v42/[+Framework OSGi +]

 


== Criando o Projeto POM Pai

Nesta seção você criará o projeto POM pai para os pacotes OSGi que serão criados neste tutorial. Você editará o projeto POM ( ``pom.xml`` ) para adicionar elementos de Gerenciamento de Dependências que serão herdados como dependências por projetos filho.

1. Selecione Novo Projeto (Ctrl-Shift-N; ⌘-Shift-N no Mac) no menu principal.
2. Selecione o Projeto POM na categoria Maven.

image::images/cdi-newpomproject.png[title="Arquétipo do Projeto POM Maven no Assistente de Novo Projeto"]



. Digite *MavenOSGiCDIProject* como nome do Projeto. Clique em Finalizar.

Quando você clica em Finalizar, o IDE cria o projeto POM e abre o projeto na janela Projetos.



. Expanda o nó dos Arquivos do Projeto na janela Projetos e clique duas vezes em  ``pom.xml``  para abrir o arquivo no editor.

O POM básico do projeto deverá ser similar ao seguinte.


[source,xml]
----

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mycompany</groupId>
    <artifactId>MavenOSGiCDIProject</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
</project>
        
----


. Modifique o  ``pom.xml``  pai para adicionar os elementos a seguir. Salve as alterações.

[source,xml]
----

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mycompany</groupId>
    <artifactId>MavenOSGiCDIProject</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    *<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.osgi</groupId>
                <artifactId>org.osgi.core</artifactId>
                <version>4.2.0</version>
                <scope>provided</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>*
</project>
        
----

Neste exercício, você especificou explicitamente um artefato e a versão do artefato que serão usados no projeto. Ao usar o Gerenciamento de Dependências e especificar os artefatos no POM pai, é possível tornar os POMs nos projetos filho mais simples e garantir que as versões das dependências estejam consistentes no projeto.

Para saber mais sobre o uso do Gerenciamento de Dependências, consulte link:http://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html[+Introdução ao Mecanismo de Dependências+].


== Criando os Projetos de Pacotes OSGi

A categoria Maven no assistente Novos Projetos inclui um arquétipo do Pacote OSGi para a criação de projetos de pacotes OSGi. Quando você cria um projeto de pacote OSGi, o POM gerado declara o JAR  ``org.osgi.core``  como uma dependência e especifica o  ``plug-in-do-pacote-maven``  para a construção do projeto.


=== Criando o Pacote da Interface MavenHelloServiceApi

Neste exercício, você utilizará o assistente Novo Projeto para criar um projeto de pacote OSGi que fornecerá uma interface simples que será implementada por outros pacotes. Depois de criar o pacote e a interface, você modificará o POM para atualizar a dependência no artefato  ``org.osgi.core``  que foi especificado no projeto POM pai.

1. Selecione Arquivo > Novo Projeto para abrir o assistente de Novo Projeto.
2. Selecione Pacote OSGi na categoria Maven. Clique em Próximo.

image::images/cdi-new-osgiproject.png[title="Arquétipo do Pacote OSGI Maven no assistente de Novo Projeto"]



. Digite *MavenHelloServiceApi* como Nome do Projeto.


. Clique em Procurar e selecione o projeto POM *MavenOSGiCDIProject* como o Local. Clique em Finalizar.

Quando você clica em Finalizar, o IDE cria o projeto do pacote e abre o projeto na janela Projetos. Se você abrir  ``pom.xml``  para o projeto MavenHelloServiceApi no editor, verá que o elemento  ``encapsulamento``  especifica o  ``pacote``  e que o  ``plug-in-do-pacote-maven``  será usado ao construir o pacote.


[source,xml]
----

<project>
    <modelVersion>4.0.0</modelVersion>
    <parent>
    <artifactId>MavenOSGiCDIProject</artifactId>
    <groupId>com.mycompany</groupId>
    <version>1.0-SNAPSHOT</version>
    </parent>

    <groupId>com.mycompany</groupId>
    <artifactId>MavenHelloServiceApi</artifactId>
    <version>1.0-SNAPSHOT</version>
    *<packaging>bundle</packaging>*
    <name>MavenHelloServiceApi OSGi Bundle</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.osgi</groupId>
            <artifactId>org.osgi.core</artifactId>
            <version>4.3.0</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.felix</groupId>
                *<artifactId>maven-bundle-plugin</artifactId>*
                <version>2.3.7</version>
                <extensions>true</extensions>
                <configuration>
                    <instructions>
                        <Bundle-Activator>com.mycompany.mavenhelloserviceimpl.Activator</Bundle-Activator>
                        <Export-Package />
                    </instructions>
                </configuration>
            </plugin>

            ...
        </plugins>
    </build>

    ...
<project>
----

Você também poderá ver que, ao criar um projeto de pacote OSGi utilizando o arquétipo do Pacote OSGi Maven, o IDE adicionou o artefato  ``org.osgi.core``  como uma dependência por padrão.



. Clique com o botão direito do mouse no nó do projeto MavenHelloServiceApi na janela Projetos e selecione Propriedades.


. Selecione a categoria Códigos-fonte na caixa de diálogo Propriedades do Projeto.


. Defina *Source/Binary Format* como 1.6 e confirme se a *Codificação* é UTF-8. Clique em OK.


. Clique com o botão direito do mouse no nó Pacotes de Código-fonte e selecione Novo > Interface Java.


. Digite *Hello* como Nome da Classe.


. Selecione *com.mycompany.mavenhelloserviceapi* como o Pacote. Clique em Finalizar.


. Adicione o método  ``sayHello``  a seguir à interface (em negrito) e salve as alterações.

[source,java]
----

public interface Hello {
    *String sayHello(String name);*
}
----


. Clique com o botão direito do mouse no nó do projeto na janela Projetos e selecione Construir.

Depois de construir o projeto, se você abrir a janela Arquivos e expandir o nó do projeto, verá que  ``MavenHelloServiceApi-1.0-SNAPSHOT.jar``  foi criado na pasta de  ``destino`` .

image::images/cdi-manifest.png[title="Exibir o conteúdo do JAR compilado na janela Arquivos"]

O  ``plug-in-do-pacote-maven``  trata da geração do arquivo  ``MANIFEST.MF``  ao construir o projeto. Se abrir o arquivo  ``MANIFEST.MF``  no JAR compilado, você verá que o plug-in gerou um cabeçalho de manifesto que declara os pacotes exportados. Para OSGi, todos os pacotes que você deseja que sejam expostos e estejam disponíveis para outros pacotes devem ser listados no elemento  ``Exportar-Pacote``  no  ``MANIFEST.MF`` .



. Confirme se o  ``MANIFEST.MF``  contém o elemento  ``Export-Package``  (o elemento mostrado em *negrito* no exemplo abaixo).

[source,java]
----

Manifest-Version: 1.0
Bnd-LastModified: 1395049732676
Build-Jdk: 1.7.0_45
Built-By: nb
Bundle-Activator: com.mycompany.mavenhelloserviceapi.Activator
Bundle-ManifestVersion: 2
Bundle-Name: MavenHelloServiceApi OSGi Bundle
Bundle-SymbolicName: com.mycompany.MavenHelloServiceApi
Bundle-Version: 1.0.0.SNAPSHOT
Created-By: Apache Maven Bundle Plugin
*Export-Package: com.mycompany.mavenhelloserviceapi;uses:="org.osgi.frame
 work";version="1.0.0.SNAPSHOT"*
Import-Package: org.osgi.framework;version="[1.6,2)"
Tool: Bnd-1.50.0
----

O contêiner OSGi lerá o cabeçalho do manifesto  ``Exportar-Pacote``  para determinar as classes no pacote que podem ser acessadas de fora do pacote. Nesse exemplo, as classes no pacote  ``com.mycompany.mavenhelloserviceapi``  estão expostas.

NOTE:  Se o  `` MANIFEST.MF``  não contiver o elemento  `` Export-Package`` , você precisará ativar o procedimento do plug-in default para o plug-in na janela Propriedades do Projeto e reconstruir o projeto. Na janela Propriedades do Projeto, selecione a categoria Exportar Pacotes e selecione a opção *Default maven-bundle-plugin behavior*. Você pode usar o painel Exportar Pacotes da janela Propriedades do Projeto para especificar explicitamente os pacotes que deverão ser expostos ou especificar os pacotes diretamente em  ``pom.xml.`` .

   


=== Criando o Pacote de Implementação MavenHelloServiceImpl

Neste exercício, você criará o MavenHelloServiceImpl no projeto POM.

1. Selecione Arquivo > Novo Projeto para abrir o assistente de Novo Projeto.
2. Selecione o Pacote OSGi na categoria Maven. Clique em Próximo.
3. Digite *MavenHelloServiceImpl* como Nome do Projeto.
4. Clique em Procurar e selecione o projeto POM *MavenOSGiCDIProject* como o Local (caso não esteja selecionado). Clique em Finalizar.
5. Clique com o botão direito do mouse no nó do projeto na janela Projetos e escolha Propriedades.
6. Selecione a categoria Códigos-fonte na caixa de diálogo Propriedades do Projeto.
7. Defina *Source/Binary Format* como 1.6 e confirme se a *Codificação* é UTF-8. Clique em OK.
8. Clique com o botão direito do mouse no nó Pacotes de Código-fonte na janela Projetos e selecione Novo > Classe Java.
9. Digite *HelloImpl* para o Nome da Classe.
10. Selecione *com.mycompany.mavenhelloserviceimpl* como o Pacote. Clique em Finalizar.
11. Digite o seguinte (em negrito) e salve as alterações.

[source,java]
----

public class HelloImpl *implements Hello {
    
    public String sayHello(String name) {
        return "Hello " + name;*
    }
}
----

Quando você implementar  ``Hello`` , o IDE exibirá um erro que deverá ser resolvido adicionando o projeto MavenHelloServiceApi como uma dependência.



. Clique com o botão direito do mouse no nó Dependências do *MavenHelloServiceImpl* na janela Projetos e selecione Adicionar Dependência.


. Clique na guia Abrir Projetos na caixa de diálogo Adicionar Biblioteca.


. Selecione o Pacote OSGi MavenHelloServiceApi. Clique em Add.

image::images/cdi-add-dependency.png[title="Clique na guia Abrir Projetos na caixa de diálogo Adicionar Biblioteca."]



. Clique com o botão direito do mouse na classe  ``HelloImpl.java``  que está aberta no editor e selecione Corrigir Importações (Alt-Shift-I; ⌘-Shift-I no Mac) para adicionar uma instrução de importação para  ``com.mycompany.mavenhelloserviceapi.Hello`` . Salve as alterações.


. Expanda o pacote  ``com.mycompany.mavenhelloserviceimpl``  e clique duas vezes em  ``Activator.java``  para abrir o arquivo no editor.

image::images/cdi-activator.png[title="Classe do ativador na janela Projetos"]

O IDE criou automaticamente a classe ativadora do pacote  ``Activator.java``  em seu projeto. Um ativador de pacote é utilizado para gerenciar o ciclo de vida de um pacote. A classe do ativador de pacote é declarada no  ``MANIFEST.MF``  do pacote e é instanciada quando o pacote é iniciado pelo contêiner.

Um pacote OSGi não requer uma classe de ativador de pacote, mas é possível utilizar o método  ``start()``  na classe do ativador, por exemplo, para inicializar serviços ou outros recursos necessários para o pacote. Neste exercício, você adicionará algumas linhas de código à classe que imprimirá mensagens na janela de Saída. Isso facilitará a identificação de quando um pacote é iniciado e parado.



. Modifique os métodos  ``start()``  e  ``stop()``  na classe do ativador do pacote para adicionar as linhas a seguir (em negrito).

[source,java]
----

public class Activator implements BundleActivator {

    public void start(BundleContext context) throws Exception {
        *System.out.println("HelloActivator::start");
        context.registerService(Hello.class.getName(), new HelloImpl(), null);
        System.out.println("HelloActivator::registration of Hello service successful");*
    }

    public void stop(BundleContext context) throws Exception {
        *context.ungetService(context.getServiceReference(Hello.class.getName()));
        System.out.println("HelloActivator stopped");*
    }
}
----

Você pode ver que a classe do ativador de pacotes importa  ``org.osgi.framework.BundleActivator``  e  ``org.osgi.framework.BundleContext`` . Por default, a classe gerada contém dois métodos:  ``start()``  e  ``stop()`` . O framework do OSGi invoca os métodos  ``start()``  e  ``stop()``  para iniciar e parar a funcionalidade fornecida pelo pacote. Quando o pacote é iniciado, o componente de serviço fornecido pelo pacote é registrado no registro de serviço do OSGi. Depois que um pacote é registrado, outros pacotes poderão utilizar o registro para pesquisa e, em seguida, utilizar os serviços ativos por meio do contexto do pacote.

Ao olhar o POM do projeto, você verá o elemento  ``<Bundle-Activator>``  que especifica o ativador do pacote sob o elemento de configuração do  ``plug-in-do-pacote-maven`` .


[source,xml]
----

<plugin>
    <groupId>org.apache.felix</groupId>
    <artifactId>maven-bundle-plugin</artifactId>
    <version>2.3.7</version>
    <extensions>true</extensions>
      <configuration>
            <instructions>
                  *<Bundle-Activator>com.mycompany.mavenhelloserviceimpl.Activator</Bundle-Activator>*
            </instructions>
      </configuration>
</plugin>
----

Quando você construir o pacote, o plug-in gerará um Cabeçalho de Manifesto no arquivo de manifesto do pacote no JAR e especificará a classe do Ativador do Pacote. O runtime do OSGi procura pelo cabeçalho  ``Bundle-Activator``  no arquivo do manifesto quando um pacote é implantado.



. Corrija as instruções de importação em  ``Activator.java``  para importar  ``com.mycompany.mavenhelloserviceapi.Hello`` . Salve as alterações.


. Expanda o nó Dependências e confirme se o artefato  ``org.osgi.core``  é listado como uma dependência.

NOTE:  Remova todas as versões mais antigas do artefato que são listadas no nó Dependências, clicando com o botão direito do mouse no artefato e escolhendo Remover Dependência. As únicas dependências devem ser o projeto MavenHelloServiceApi e o artefato  ``org.osgi.core`` .

image::images/cdi-implproject.png[title="Classe do ativador na janela Projetos"]
   


=== Construindo e Implantando os Pacotes OSGi

Neste exercício, você construirá os pacotes OSGi e implantará os pacotes no GlassFish.

1. Clique com o botão direito do mouse no nó MavenOSGiCDIProject na janela Projetos e selecione Limpar e Construir.

Quando você construir o projeto, o IDE criará os arquivos JAR na pasta de  ``destino``  de cada um dos projetos e também instalará o JAR de snapshot no repositório local. Na janela Arquivos, você pode expandir a pasta de  ``destino``  para cada um dos dois projetos de pacotes e ver os dois arquivos compactados JAR ( ``MavenHelloServiceApi-1.0-SNAPSHOT.jar``  e  ``MavenHelloServiceImpl-1.0-SNAPSHOT.jar`` ).



. Inicie o GlassFish Server, se ainda não o tiver feito.


. Copie o  ``MavenHelloServiceApi-1.0-SNAPSHOT.jar``  para o diretório  ``glassfish/domains/domain1/autodeploy/bundles/``  da instalação do GlassFish.

No log do GlassFish Server, na janela de Saída, você deverá ver uma saída semelhante à mostrada a seguir.


[source,java]
----

INFO: Started bundle: file:/glassfish-4.0/glassfish/domains/domain1/autodeploy/bundles/MavenHelloServiceApi-1.0-SNAPSHOT.jar

----

Clique com o botão direito do mouse no nó do GlassFish Server na janela Serviços e selecione Exibir Log do Servidor de Domínio, se o log do servidor não estiver visível na janela de Saída.



. Repita as etapas para copiar o  ``MavenHelloServiceImpl-1.0-SNAPSHOT.jar``  no diretório  ``autodeploy/bundles`` .

No log do GlassFish Server, você agora deverá ver uma saída semelhante à mostrada a seguir.


[source,java]
----

INFO: HelloActivator::start
INFO: HelloActivator::registration of Hello service successful
INFO: Started bundle: file:/glassfish-4.0/glassfish/domains/domain1/autodeploy/bundles/MavenHelloServiceImpl-1.0-SNAPSHOT.jar
INFO: Started bundle: file:/glassfish-4.0/glassfish/domains/domain1/autodeploy/bundles/MavenHelloServiceImpl-1.0-SNAPSHOT.jar
        
----

Ou então, é possível instalar os pacotes a partir da Console de Admin OSGi do GlassFish. Para obter mais informações, consulte a seção <<Exercise_4,Instalando e Usando a Console de Admin OSGi>>.


== Criando uma Aplicação Cliente Web

Esta seção demonstra como criar um cliente Web Java EE que acessa o serviço fornecido pelo pacote OSGi. Você criará um servlet simples em uma aplicação Web e, em seguida, injetará os serviços declarados. Antes de criar o projeto, você adicionará alguns elementos de gerenciamento de dependências ao projeto POM pai.


=== Configurando dependências no Projeto POM Pai

Neste exercício, você especificará elementos de dependência no projeto POM pai. Você também adicionará um repositório para artefatos que serão utilizados no projeto.

1. Expanda o nó Arquivos do Projeto do projeto *MavenOSGiCDIProject* na janela Projetos e clique duas vezes em  ``pom.xml``  para abrir o arquivo no editor.
2. Modifique o  ``pom.xml``  pai para adicionar os seguintes elementos de Gerenciamento de Dependências (em negrito). Salve as alterações.

[source,xml]
----

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mycompany</groupId>
    <artifactId>MavenOSGiCDIProject</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    ...    
            
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.osgi</groupId>
                <artifactId>org.osgi.core</artifactId>
                <version>4.3.0</version>
                <scope>provided</scope>
            </dependency>
            *<dependency>
                <groupId>org.osgi</groupId>
                <artifactId>org.osgi.compendium</artifactId>
                <version>4.2.0</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>org.glassfish</groupId>
                <artifactId>osgi-cdi-api</artifactId>
                <version>3.1-b41</version>
                <type>jar</type>
                <scope>provided</scope>
            </dependency>*
          
        </dependencies>
    </dependencyManagement>

    ...
</project>

----


. Adicione os elementos a seguir para adicionar o repositório do GlassFish ao POM. Salve as alterações.

[source,xml]
----

<project>

    ...

    </dependencyManagement>

    *<repositories>
        <!-- glassfish nexus repo for glassfish dependencies -->
        <repository>
            <id>glassfish-repo-archive</id>
            <name>Nexus repository collection for Glassfish</name>
            <url>http://maven.glassfish.org/content/groups/glassfish</url>
            <snapshots>
                <updatePolicy>never</updatePolicy>
            </snapshots>
        </repository>
    </repositories>*
    <modules>
        <module>MavenHelloServiceApi</module>
        <module>MavenHelloServiceImpl</module>
    </modules>
</project>
            
----

Depois de adicionar o repositório do GlassFish ao POM, se você exibir a lista de repositórios no nó Repositórios Maven na janela Serviços, verá que o IDE adicionou automaticamente um nó para o repositório do GlassFish. Por default, o IDE exibe um nó para o repositório Maven Local. Quando um projeto aberto especifica um repositório, o IDE automaticamente adiciona um nó ao repositório no nó Repositórios Maven.

image::images/cdi-maven-repositories.png[title="Repositório do GlassFish na janela Repositórios Maven"]

Neste exercício, você adicionou artefatos extras e versões de artefatos que serão utilizados no projeto. Você também adicionou o repositório do GlassFish que contém os artefatos  ``osgi-cdi-api`` .


=== Criando a Aplicação Web MavenHelloWebClient

Primeiro, você criará uma aplicação Web regular e, em seguida, modificará o projeto para torná-lo um pacote OSGi (Pacote de Aplicação Web (WAB)).

1. Escolha Arquivo > Novo Projeto no menu principal.
2. Selecione Aplicação Web na categoria Maven. Clique em Próximo.
3. Digite *MavenHelloWebClient* como nome do Projeto.
4. Clique em Procurar e selecione o projeto POM *MavenOSGiCDIProject* como o Local (caso não esteja selecionado). Clique em Próximo.
5. Selecione o GlassFish Server como servidor e o Java EE 6 ou Java EE 7 como a versão do Java EE. Clique em Finalizar.
6. Clique com o botão direito do mouse no nó do projeto e selecione Novo > Servlet.
7. Digite *HelloServlet* no Nome da Classe.
8. Selecione  ``com.mycompany.mavenhellowebclient``  como o Pacote. Clique em Finalizar.
9. Delete os métodos default no servlet que foram gerados pelo IDE ( ``processRequest`` ,  ``doGet`` ,  ``doPost`` ,  ``getServletInfo`` ).

NOTE:  Você precisará expandir a pasta do editor para deletar os métodos do HttpServlet.



. Digite o código a seguir (em negrito) para injetar o serviço.

[source,java]
----

@WebServlet(name = "HelloServlet", urlPatterns = {"/HelloServlet"})
public class HelloServlet extends HttpServlet {

    *@Inject
    @OSGiService(dynamic=true)
    Hello hello;*
}
----


. Adicione o método  ``doGet``  a seguir.

[source,java]
----

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        PrintWriter out = response.getWriter();
        out.println(hello.sayHello("Duke"));
    }
----


. Clique com o botão direito do mouse no nó do projeto e selecione Novo > Outro.


. Selecione *beans.xml* na categoria Contextos e Injeção de Dependências. Clique em Próximo.


. Use o nome de arquivo default ( ``beans`` ). Clique em Finalizar.

Quando você clicar em Finalizar, o assistente criará o arquivo  ``beans.xml``  na aplicação Web. O CDI será automaticamente ativado se o  ``beans.xml``  for parte da aplicação.



. Modifique o arquivo  ``beans.xml``  para alterar o valor padrão de  ``bean-discovery-mode``  para  ``all`` .

[source,java]
----

bean-discovery-mode="*all*"
----

Salve suas alterações e feche o arquivo.

Para obter mais informações sobre as diferenças entre os valores  ``bean-discovery-mode`` , consulte as seguintes páginas:

* link:http://docs.oracle.com/javaee/7/tutorial/doc/cdi-adv001.htm[+25.1 Encapsulando Aplicações CDI+] no Tutorial do Java EE 7
* link:http://stackoverflow.com/questions/18107858/cdi-inject-fails-on-maven-embedded-glassfish-plugin-org-jboss-weld-exceptions[+http://stackoverflow.com/questions/18107858/cdi-inject-fails-on-maven-embedded-glassfish-plugin-org-jboss-weld-exceptions+]


. Clique com o botão direito do mouse no nó Dependências do MavenHelloWebClient na janela Projetos e selecione Adicionar Dependência.


. Selecione *Provided* como o Escopo.


. Clique na guia Abrir Projetos na caixa de diálogo Adicionar Biblioteca e selecione *Pacote OSGi MavenHelloServiceApi*. Clique em Add.


. Clique novamente com o botão direito do mouse no nó Dependências e selecione Adicionar Dependência.


. Clique na guia Gerenciamento de Dependências na caixa de diálogo Adicionar Biblioteca e selecione o artefato  ``osgi-cdi-api``  que você especificou no projeto POM pai. Clique em Add.

image::images/cdi-add-dependency3.png[title="Guia de Gerenciamento de Dependências na caixa de diálogo Adicionar Biblioteca"]



. Clique com o botão direito do mouse em  ``HelloServlet.java``  no editor e selecione Corrigir Importações (Alt-Shift-I; ⌘-Shift-I no Mac) para adicionar  ``com.mycompany.mavenhelloserviceapi.Hello`` ,  ``javax.inject.Inject``  e  ``org.glassfish.osgicdi.OSGiService`` . Salve as alterações.

NOTE:  Pode ser preciso adicionar manualmente uma instrução de importação para o  ``com.mycompany.mavenhelloserviceapi.hello``  se o IDE não adicionar automaticamente para você.



. Clique com o botão direito do mouse em MavenOSGiCDIProject e selecione Limpar e Construir.

Ao construir o projeto, na janela de Saída, você deverá ver uma saída semelhante à seguinte.


[source,java]
----

Reactor Summary:

MavenOSGiCDIProject ............................... SUCCESS [0.798s]
MavenHelloServiceApi OSGi Bundle .................. SUCCESS [7.580s]
MavenHelloServiceImpl OSGi Bundle ................. SUCCESS [1.142s]
MavenHelloWebClient ............................... SUCCESS [8.072s]
------------------------------------------------------------------------
BUILD SUCCESS
----

NOTE:  Crie a aplicação web manualmente se ela não for criada automaticamente quando você criar o projeto MavenOSGiCDIProject.

Na janela Arquivos, expanda o nó do projeto para a aplicação Web e confirme se o arquivo compactado  ``MavenHelloWebClient-1.0-SNAPSHOT.war``  foi criado no diretório de destino. Se você expandir o arquivo compactado WAR do cliente Web e examinar o  ``MANIFEST.MF`` , verá que o manifesto contém linhas similares às seguintes.


[source,java]
----

Manifest-Version: 1.0
Archiver-Version: Plexus Archiver
Created-By: Apache Maven
Built-By: nb
Build-Jdk: 1.7.0_45
----


=== Construindo a aplicação Web como um Pacote OSGi

Para usar o  ``@OSGiService``  e recuperar pacotes OSGi registrados, é preciso tornar a aplicação Web um pacote que possa acessar o  ``BundleContext`` . Para tornar o WAR um pacote OSGi (Pacote de Aplicação Web), adicione os metadados  ``Web-ContextPath``  ao  ``MANIFEST.MF``  no WAR.  Para tanto, especifique o elemento  ``<Web-ContextPath>``  nas instruções do  ``maven-bundle-plugin``  e o manifesto gerado pelo plug-in conterá o elemento. Em seguida, você modificará a configuração do  ``maven-war-plugin``  para instruir o plug-in a adicionar o manifesto que foi gerado pelo  ``plug-in-do-pacote-maven``  ao arquivo compactado WAR.

1. Na janela Projetos, expanda o nó dos Arquivos de Projeto sob o MavenHelloWebCliente clique duas vezes em  ``pom.xml``  para abrir o arquivo no editor.
2. Adicione a seguinte entrada para adicionar o  ``plug-in-do-pacote-maven``  ao POM.

[source,xml]
----

<build> 
    <plugins>
        *<plugin>
             <groupId>org.apache.felix</groupId>
             <artifactId>maven-bundle-plugin</artifactId>
             <version>2.2.0</version>
             <extensions>true</extensions>
             <configuration>
                 <supportedProjectTypes>
                     <supportedProjectType>ejb</supportedProjectType>
                     <supportedProjectType>war</supportedProjectType>
                     <supportedProjectType>bundle</supportedProjectType>
                     <supportedProjectType>jar</supportedProjectType>
                 </supportedProjectTypes>
                 <instructions>
                     <!-- Specify elements to add to MANIFEST.MF -->
                     <Web-ContextPath>/mavenhellowebclient</Web-ContextPath>
                     <!-- By default, nothing is exported -->
                     <Export-Package>!*.impl.*, *</Export-Package>
                 </instructions>
             </configuration>
             <executions>
                 <execution>
                     <id>bundle-manifest</id>
                     <phase>process-classes</phase>
                     <goals>
                         <goal>manifest</goal>
                     </goals>
                 </execution>
                 <execution>
                     <id>bundle-install</id>
                     <phase>install</phase>
                     <goals>
                         <goal>install</goal>
                     </goals>
                 </execution>
             </executions>
         </plugin>*
            
----


. Modifique os elementos de configuração do  ``maven-war-plugin``  para adicionar informações do pacote ao  ``MANIFEST.MF`` . Salve as alterações.

[source,xml]
----

 <plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-war-plugin</artifactId>
     <version>2.3</version>
     <configuration>
         *<archive>
             <!-- add bundle plugin generated manifest to the war -->
             <manifestFile>
                 ${project.build.outputDirectory}/META-INF/MANIFEST.MF
             </manifestFile>
             <!-- For some reason, adding Bundle-ClassPath in maven-bundle-plugin
             confuses that plugin and it generates wrong Import-Package, etc.
             So, we generate it here.-->
             <manifestEntries>
                 <Bundle-ClassPath>WEB-INF/classes/</Bundle-ClassPath>
             </manifestEntries>
         </archive>*
         <failOnMissingWebXml>false</failOnMissingWebXml>
     </configuration>
 </plugin>
----


. Clique com o botão direito do mouse no nó do projeto MavenHelloWebClient na janela Projetos e selecione Limpar e Construir.

Ao expandir o arquivo compactado WAR e abrir o  ``MANIFEST.MF``  no editor, você verá que o  ``MANIFEST.MF``  contém informações adicionais, incluindo a entrada  ``Web-ContextPath: /mavenhellowebclient``  especificada na configuração  ``maven-bundle-plugin``  e entradas de nome de pacote.


[source,java]
----

Manifest-Version: 1.0
Export-Package: com.mycompany.mavenhellowebclient;uses:="com.mycompany
 .mavenhelloserviceapi,javax.servlet,org.glassfish.osgicdi,javax.injec
 t,javax.servlet.annotation,javax.servlet.http";version="1.0.0.SNAPSHO
 T"
Bundle-ClassPath: WEB-INF/classes/
Built-By: nb
Tool: Bnd-1.50.0
Bundle-Name: MavenHelloWebClient
Created-By: Apache Maven Bundle Plugin
*Web-ContextPath: /mavenhellowebclient*
Build-Jdk: 1.7.0_45
Bundle-Version: 1.0.0.SNAPSHOT
Bnd-LastModified: 1395053424008
Bundle-ManifestVersion: 2
Import-Package: com.mycompany.mavenhelloserviceapi;version="[1.0,2)",j
 avax.inject,javax.servlet,javax.servlet.annotation,javax.servlet.http
 ,org.glassfish.osgicdi;version="[1.0,2)"
Bundle-SymbolicName: com.mycompany.MavenHelloWebClient
Archiver-Version: Plexus Archiver
----

Para obter mais informações sobre como construir aplicações Web como pacotes OSGi, consulte as páginas seguintes.

* link:http://weblogs.java.net/blog/2009/06/04/osgi-enabled-web-applications-inglassfish[+ http://weblogs.java.net/blog/2009/06/04/osgi-enabled-web-applications-inglassfish+]
* link:http://felix.apache.org/site/apache-felix-maven-bundle-plugin-bnd.html[+ http://felix.apache.org/site/apache-felix-maven-bundle-plugin-bnd.html+]


=== Implantando o Pacote de Aplicação Web

Neste exercício, você copiará o pacote da aplicação Web para a pasta  ``implantação automática/pacotes``  na instalação do GlassFish.

1. Navegue até o diretório de  ``destino``  que contém o  ``MavenHelloWebClient-1.0-SNAPSHOT.war`` .
2. Copie o  ``MavenHelloWebClient-1.0-SNAPSHOT.war``  na pasta ``implantação automática/pacotes``  da instalação do GlassFish.

Quando você copiar o arquivo compactado WAR para o diretório, um resultado semelhante ao mostrado a seguir será exibido no log do GlassFish Server.


[source,java]
----

INFO: Started bundle: file:/glassfish-3.1.1/glassfish/domains/domain1/autodeploy/bundles/MavenHelloWebClient-1.0-SNAPSHOT.war
...
INFO: ---- Injection requested for framework service type interface com.mycompany.mavenhelloserviceapi.Hello and annotated with dynamic=true, serviceCriteria=
INFO: WEB0671: Loading application [com.mycompany.MavenHelloWebClient_1.0.0.SNAPSHOT] at [/mavenhellowebclient]
INFO: Registered ServletContext as a service with properties: {osgi.web.symbolicname=com.mycompany.MavenHelloWebClient, osgi.web.version=1.0.0.SNAPSHOT, osgi.web.contextpath=/mavenhellowebclient} 
        
----

É possível exibir o servlet no browser clicando no link a seguir link:http://localhost:8080/mavenhellowebclient/HelloServlet[+http://localhost:8080/mavenhellowebclient/HelloServlet+].


== Instalando e Usando a Console de Admnin do OSGI

Você pode usar a Console de Admin do OSGi GlassFish para instalar, iniciar e parar os pacotes do OSGi implantados no servidor. Neste exercício, você ativará a Console de Admin do OSGi GlassFish e, em seguida, exibirá a lista de pacotes OSGi registrados.

Realize as etapas a seguir para instalar os add-ons do GlassFish necessários para a ativação da Console do OSGi e para exibir os pacotes na Console de Admin do Domínio do GlassFish.

1. Abra a Console de Admin do Domínio do GlassFish no browser.

Clique com o botão direito do mouse no nó do GlassFish server na janela Serviços e selecione Exibir Console de Admin de Domínio.



. Clique na Ferramenta de Atualização na coluna de navegação esquerda.


. Selecione  ``glassfish-osgi-gui``  na lista de add-ons disponíveis.

Clique em Instalar e aceite a licença.

image::images/cdi-glassfish-addons.png[title="Ferramenta de Atualização da Console de Admin do GlassFish"]



. Reinicie o GlassFish Server.

*Importante:* se você estiver executando GlassFish Server 3.1.2.2 você precisará modificar o arquivo  ``osgi.properties``  localizado no diretório  ``_GLASSFISH-INSTALL_/glassfish/config/``  e definir o valor da propriedade  ``org.osgi.framework.startlevel.beginning``  como "2" ( ``org.osgi.framework.startlevel.beginning=2`` ).
Consulte o seguinte fórum para obter mais detalhes: 
link:http://www.java.net/forum/topic/glassfish/glassfish/cannot-start-web-console-glassfish-version-3122[+Não é possível iniciar a console Web no Glassfish versão 3.1.2.2+].



. Abra a Console de Admin novamente e clique em *servidor (Servidor de Admin)* na coluna de navegação esquerda.


. Clique na guia da Console do OSGi para exibir uma lista de pacotes OSGi implantados. 

image::images/cdi-glassfish-console.png[title="Guia de Gerenciamento de Dependências na caixa de diálogo Adicionar Biblioteca"]

NOTE:  Você poderá ser solicitado a informar o nome de usuário e a senha para exibir a lista de pacotes OSGi. Confirme se a caixa de diálogo de autorização não está oculta se você não vir uma lista de pacotes na guia Console do OSGi. O nome de usuário padrão do servidor GlassFish 4 é  ``admin``  se você instalou o servidor quando instalou o IDE. A senha fica vazia por padrão.

É possível rolar a lista para baixo para exibir os status dos pacotes OSGi registrados, além de iniciar e parar os pacotes individuais. Se a lista for ordenada por Id (maior para menor), você verá que os três pacotes que foram implantados serão exibidos perto do topo da lista.


link:/about/contact_form.html?to=3&subject=Feedback:%20Using%20CDI%20to%20Inject%20OSGi%20Bundles%20as%20Services[+Enviar Feedback neste Tutorial+]



== Consulte Também

Para obter mais informações sobre o uso do NetBeans IDE e Maven para desenvolver pacotes OSGi, consulte os seguintes recursos:

* link:http://wiki.netbeans.org/OSGiAndNetBeans[+OSGi And NetBeans at wiki.netbeans.org+]
* link:http://wiki.netbeans.org/MavenBestPractices[+Melhores Práticas para o Apache Maven no NetBeans IDE+]
* link:https://blogs.oracle.com/arungupta/entry/totd_125_creating_an_osgi[+TOTD #125: Criando um pacote OSGi utilizando o NetBeans e implantando no GlassFish+]
* link:../../trails/java-ee.html[+Trilha de Aprendizado do Java EE e Java Web+]

Para enviar comentários e sugestões, obter suporte e se manter informado sobre os mais recentes desenvolvimentos das funcionalidades de desenvolvimento do Java EE do NetBeans IDE, link:../../../community/lists/top.html[+inscreva-se na lista de correspondência de nbj2ee+].

