Criando o pacote

Neste exercício, você utilizará o assistente Novo projeto para criar um projeto de pacote OSGi.

1. Selecione Arquivo > Novo projeto para abrir o assistente Novo projeto.
2. Escolha Pacote Maven OSGi a partir da categoria Maven. Clique em Próximo.
   
3. Digite MavenHelloService no Nome do projeto. Clique em Terminar.
4. Abra a janela Propriedades do projeto e confirme se Formato binário/código fonte está definido como 1.6 e que a Codificação é UTF-8 na categoria Códigos-fonte.

Ao criar um projeto de pacote OSGi utilizando o arquétipo Pacote Maven OSGi, o IDE automaticamente adiciona org.osgi.core-1.4.0.jar como uma dependência. Se olhar pom.xml, verá que o elemento empacotamento especifica pacote.

<modelVersion>4.0.0</modelVersion>
<groupId>com.mycompany</groupId>
<artifactId>MavenHelloService</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pacote</packaging>
<name>MavenHelloService OSGi Bundle</name>

O POM também especifica que o maven-bundle-plugin será utilizado ao construir o pacote.

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.felix</groupId>
                <artifactId>maven-bundle-plugin</artifactId>
                <version>2.0.1</version>
                <extensions>true</extensions>
            </plugin>
        </plugins>
    </build>

Adicionando um ativador de pacote

Neste exercício, você utilizará um assistente para criar uma classe Java chamada Installer que implementa a interface org.osgi.framework.BundleActivator. Um ativador de pacote é utilizado para gerenciar o ciclo de vida de um pacote. A classe do ativador de pacote é 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 que são 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á identificar quando um pacote é iniciado e parado.

1. Clique com o botão direito do mouse no projeto do pacote na janela Projetos e selecione Novo > Outro.
2. Selecione Ativador do pacote na categoria OSGi. Clique em Próximo.
3. Digite Installer no nome da classe e selecione com.mycompany.mavenhelloservice como o Pacote. Clique em Terminar.
   
4. Abra Installer.java no editor e modifique os métodos start() e stop() para adicionar as linhas a seguir.

   package com.mycompany.mavenhelloservice;
   
   import org.osgi.framework.BundleActivator;
   import org.osgi.framework.BundleContext;
   
   /**
    *
    * @author nb
    */
   public class Installer implements BundleActivator {
   
       public void start(BundleContext context) throws Exception {
           String userName = context.getProperty("user.name");
           System.out.println("Maven Hello Service: Started OSGi bundle");
           System.out.println("User Name: " + userName);
       }
   
       public void stop(BundleContext context) throws Exception {
           System.out.println("Maven Hello Service: Stopped OSGi bundle");
       }
   
   }

5. Salve as alterações.

Você pode ver que a classe do ativador de pacotes importa org.osgi.framework.BundleActivator e org.osgi.framework.BundleContext. Por padrão, a classe gerada contém dois métodos: start() e stop(). A estrutura 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 OSGi. Depois que um pacote for registrado, outros pacotes poderão utilizar o registro para pesquisa e, em seguida, utilizar os serviços ativos por meio do contexto do pacote.

Se olhar o POM do projeto, verá que o IDE adicionou o elemento <Bundle-Activator> à configuração do maven-bundle-plugin.

<plugin>
    <groupId>org.apache.felix</groupId>
    <artifactId>maven-bundle-plugin</artifactId>
    <version>2.0.1</version>
    <extensions>true</extensions>
      <configuration>
            <instructions>
                  <Bundle-Activator>com.mycompany.mavenhelloservice.Installer</Bundle-Activator>
            </instructions>
      </configuration>
</plugin>

Ao construir o pacote, o plug-in gerará um Cabeçalho de manifesto no arquivo de manifesto do pacote no JAR e especificará a classe Ativador do pacote. O tempo de execução do OSGi procura pelo cabeçalho Bundle-Activator no arquivo do manifesto quando um pacote é implantado.

Construindo e verificando o pacote

Neste exercício, você construirá o pacote OSGi. Em seguida, poderá verificar se o pacote está funcionando corretamente implantando-o no contêiner incorporado Apache Felix OSGi. O Apache Felix está incluído no IDE, mas é possível registrar outros contêineres OSGi, como o Eclipse Equinox.

1. Clique com o botão direito do mouse no projeto e escolha Construir.

   Ao clicar em Construir, o IDE constroi e instala a captura JAR no repositório local.

2. Clique em Executar e verá o seguinte na janela de Saída.

   Welcome to Felix
   ================
   
   Maven Hello Service: Started OSGi bundle
   User Name: nb

Agora que já criou um pacote OSGi básico com um ativador de pacotes, é possível começar a adicionar alguma funcionalidade. Posteriormente neste tutorial, você modificará este pacote para torná-lo um serviço que implementa uma interface, mas primeiro criará a interface.

Criando o pacote API

Neste exercício, você criará o pacote e a interface.

1. Abra o assistente Novo projeto e selecione Pacote Maven OSGi a partir da categoria Maven. Clique em Próximo.
2. Digite MavenHelloServiceAPI como o nome do projeto. Clique em Terminar.
3. Clique com o botão direito do mouse no nó Pacotes de origem do projeto MavenHelloServiceAPI e selecione Novo > Interface Java. Clique em Próximo.
4. Digite HelloService como o Nome da classe.
5. Selecione com.mycompany.mavenhelloserviceapi como o Pacote. Clique em Terminar.
6. Modifique a interface para adicionar o seguinte código e salvar suas alterações.

   public interface HelloService {
   
       public String sayHello(String name);
   
   }

Especificando os pacotes a exportar

Neste exercício, você abrirá a janela Propriedades do projeto e selecionará os pacotes que deseja que estejam acessíveis para outros pacotes e projetos. Por padrão, classes em um pacote não são visíveis para outros pacotes. Se quiser que algumas classes em um pacote sejam acessíveis, os pacotes que deseja exportar deverão ser declarados no MANIFEST.MF. Outros pacotes poderão, então, importar os pacotes expostos.

1. Clique com o botão direito do mouse no nó do projeto e escolha Propriedades.
2. Selecione a categoria Pacotes exportados e selecione o pacote com.mycompany.mavenhelloserviceapi. Clique em OK.
   

   Ao selecionar os pacotes exportados na janela Propriedades, o IDE modifica o POM para especificar o pacote de exportação.

   <plugin>
       <groupId>org.apache.felix</groupId>
       <artifactId>maven-bundle-plugin</artifactId>
       <version>2.0.1</version>
       <extensions>true</extensions>
       <configuration>
           <instructions>
               <Export-Package>com.mycompany.mavenhelloserviceapi</Export-Package>
               <Private-Package>com.mycompany.mavenhelloserviceapi.*</Private-Package>
           </instructions>
       </configuration>
   </plugin>

3. Clique com o botão direito do mouse no nó do projeto e escolha Construir.

O maven-bundle-plugin manipula a 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 especificados no POM.

Manifest-Version: 1.0
Export-Package: com.mycompany.mavenhelloserviceapi
Bundle-Version: 1.0.0.SNAPSHOT
Build-Jdk: 1.6.0_17
Built-By: nb
Tool: Bnd-0.0.357
Bnd-LastModified: 1274279178454
Bundle-Name: MavenHelloServiceApi OSGi Bundle
Bundle-ManifestVersion: 2
Created-By: Apache Maven Bundle Plugin
Import-Package: com.mycompany.mavenhelloserviceapi
Bundle-SymbolicName: com.mycompany.MavenHelloServiceApi

O contêiner OSGi lerá o cabeçalho do manifesto Export-Package 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 expostos.

Implantando o pacote OSGi no servidor GlassFish

Neste exercício, você implantará o pacote da interface no servidor GlassFish, onde ele poderá ser acessado por outros pacotes ou aplicativos. Para implantar um pacote no servidor GlassFish, só é preciso copiar o pacote para o diretório apropriado no servidor e o contêiner Felix automaticamente ativará e registrará o pacote.

Neste exercício, você implantará os pacotes OSGi no servidor GlassFish a partir da linha de comando, pois o IDE não tem uma UI para isso. Existem diferentes formas de implantar pacotes e, neste exemplo, utilizaremos o comando asadmin deploy. Uma alternativa é simplesmente copiar o JAR para o diretório domains/domain1/autodeploy/bundles de instalação de seu servidor GlassFish.

Para obter exemplos adicionais e detalhes da implantação de pacotes OSGi no servidor GlassFish, consulte TOTD #118: Managing OSGi bundles in GlassFish v3 - asadmin, filesystem, telnet console, web browser, REST, osgish, de Arun Gupta. Você também poderia ter criado seu próprio diretório monitorado utilizando o agente Apache Felix File Install, como descrito na postagem do blog de Sahoo Utilizando operações filesystem para gerenciar pacotes OSGi no GlassFish.

1. Inicie o servidor GlassFish a partir da janela Serviços. Alternativamente, é possível iniciar o servidor a partir da linha de comando.
2. Abra um terminal de linha de comando.
3. A partir da linha de comando, navegue para o diretório de destino que contém o MavenHelloServiceApi-1.0-SNAPSHOT.jar.
4. Digite o seguinte no terminal.

   <glassfish-install>/glassfish/bin/asadmin deploy --type osgi MavenHelloServiceApi-1.0-SNAPSHOT.jar
   

   Onde <glassfish-install> é o local de instalação de seu servidor GlassFish. Você verá algo semelhante ao seguinte na janela do terminal:

   Authentication failed with password from login store: /Users/nb/.asadminpass
   Enter admin password for user "admin">
   
   Application deployed successfully with name MavenHelloServiceApi-1.0-SNAPSHOT.
   Comando implantar executado com sucesso.

   Nota. Pressione a tecla Enter quando for solicitado a informar a senha (a senha padrão do admin é "null").

Você verá algo similar ao seguinte na janela de Saída do IDE.

INFO: MavenHelloServiceApi-1.0-SNAPSHOT was successfully deployed in 372 milliseconds.

No terminal, é possível ver os aplicativos e pacotes implantados digitando o seguinte:

<glassfish-install>/glassfish/bin/asadmin list-applications
Authentication failed with password from login store: /Users/nb/.asadminpass
Enter admin password for user "admin">
MavenHelloServiceApi-1.0-SNAPSHOT

Adicionando suporte para Anotações SCR

Neste exercício, você adicionará uma dependência na biblioteca org.apache.felix.scr.annotations para habilitar o uso de anotações para Componentes e Serviços em seu código. O plug-in Maven SCR processará as anotações para gerar os arquivos de configuração XML ao construir o pacote.

1. Expanda o projeto MavenHelloService na janela Projetos.
2. Clique com o botão direito do mouse no nó Bibliotecas e escolha Adicionar dependência.
3. Digite org.apache.felix para o GroupId, org.apache.felix.scr.annotations para o ArtifactId e 1.3.0 para a Versão. Clique em OK.

   Alternativamente, é possível inserir termos de pesquisa na janela (por exemplo, "scr.annotations") e pesquisar os repositórios Maven.

O IDE modifica o POM para declarar a dependência e a exibe sob o nó Bibliotecas na janela Projetos.

Criando uma implementação da Interface de serviço

Neste exercício, você criará uma classe de implementação simples no pacote e adicionará anotações para declarar o serviço.

1. Clique com o botão direito do mouse em Pacotes de fontes e escolha Novo > Classe Java. Clique em Próximo.
2. Digite HelloImpl como o Nome da classe.
3. Digite com.mycompany.mavenhelloservice.impl como o Pacote. Clique em Terminar.
4. Implemente a interface HelloService e, em seguida, implemente os métodos abstratos.
5. Modifique o método sayHello para retornar a string nome.

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

6. Adicione as anotações @Service e @Component.

   package com.mycompany.mavenhelloservice.impl;
   
   import com.mycompany.mavenhelloservice.api.HelloService;
   import org.apache.felix.scr.annotations.Component;
   import org.apache.felix.scr.annotations.Service;
   
   /**
    *
    * @author nb
    */
   @Component(name="hello-service")
   @Service
   public class HelloImpl implements HelloService {
   
       public String sayHello(String name) {
           return "Hello " + name;
       }
   
   }

   Note que o atributo name da anotação@Component é utilizado para especificar o nome do serviço.

7. Corrija as importações para importar as bibliotecas org.apache.felix.scr.annotations.Component e org.apache.felix.scr.annotations.Service.

Adicionando o plug-in Felix Maven SCR ao POM

Neste exercício, você editará o POM para adicionar o maven-scr-plugin como um plug-in de construção e adicionar instruções para que o plug-in gere o arquivo de configuração XML.

1. Expanda o nó Arquivos do projeto e abra pom.xml no editor.
2. Modifique o POM para adicionar maven-scr-plugin como um plug-in de construção.

   <build>
       <plugins>
           <plugin>
               <groupId>org.apache.felix</groupId>
               <artifactId>maven-scr-plugin</artifactId>
               <executions>
                      <execution>
                           <id>generate-scr-scrdescriptor</id>
                           <goals>
                               <goal>scr</goal>
                           </goals>
                      </execution>
               </executions>
           </plugin>

Para obter detalhes sobre o comportamento do plug-in, consulte a página Apache Felix Maven SCR Plugin.

Criando e implantando o pacote

Neste exercício, você construirá o pacote e examinará o conteúdo do pacote JAR.

1. Clique com o botão direito do mouse no projeto do pacote e escolha Construir.

   Ao escolher Construir, o IDE cria o JAR no diretório de destino do projeto e copia o JAR para o repositório local. Você verá uma saída similar à seguinte na janela de Saída:

   Installing com/mycompany/MavenHelloService/1.0-SNAPSHOT/MavenHelloService-1.0-SNAPSHOT.jar
   Writing OBR metadata
   ------------------------------------------------------------------------
   BUILD SUCCESSFUL
   ------------------------------------------------------------------------
   Total time: 5 seconds
   Finished at: Fri May 07 16:34:41 CEST 2010
   Final Memory: 23M/79M
   ------------------------------------------------------------------------
   

   É possível expandir o JAR criado no diretório de destino para ver que MANIFEST.MF foi criado no diretório META-INF e que serviceComponents.xml foi criado no diretório OSGI-INF. Se você abrir MANIFEST.MF, poderá ver os seguintes detalhes do cabeçalho do manifesto.

   Manifest-Version: 1.0
   Service-Component: OSGI-INF/serviceComponents.xml
   Export-Package: com.mycompany.mavenhelloservice;uses:="com.mycompany.m
    avenhelloserviceapi,org.osgi.framework"
   Built-By: nb
   Tool: Bnd-0.0.357
   Bundle-Name: MavenHelloService OSGi Bundle
   Created-By: Apache Maven Bundle Plugin
   Build-Jdk: 1.6.0_17
   Bundle-Version: 1.0.0.SNAPSHOT
   Bnd-LastModified: 1274279195883
   Bundle-ManifestVersion: 2
   Bundle-Activator: com.mycompany.mavenhelloservice.Installer
   Bundle-SymbolicName: com.mycompany.MavenHelloService
   Import-Package: com.mycompany.mavenhelloservice,com.mycompany.mavenhel
    loserviceapi,org.osgi.framework;version="1.5"
   
   

   É possível ver que o maven-bundle-plugin gerou um cabeçalho de manifesto no arquivo MANIFEST.MF para declarar a classe Ativador de pacote, conforme especificado no POM. O arquivo também especifica o local do arquivo descritor serviceComponents.xml, onde os serviços foram declarados

   O maven-scr-plugin manipula a geração do arquivo descritor serviceComponents.xml. Se você abrir serviceComponents.xml, verá que o arquivo declara o nome, a classe de implementação e a interface dos serviços nomeados.

   <components xmlns:scr="http://www.osgi.org/xmlns/scr/v1.0.0">
       <scr:component enabled="true" name="hello-service">
           <implementation class="com.mycompany.mavenhelloservice.HelloImpl"/>
           <service servicefactory="false">
               <provide interface="com.mycompany.mavenhelloserviceapi.HelloService"/>
           </service>
           <property name="service.pid" value="hello-service"/>
       </scr:component>
   </components>

2. A partir da linha de comando, navegue para o diretório de destino que contém o MavenHelloService-1.0-SNAPSHOT.jar.
3. Implante o pacote digitando o seguinte no terminal.

   <glassfish-install>/glassfish/bin/asadmin deploy --type osgi MavenHelloService-1.0-SNAPSHOT.jar
               

Desta vez, você verá algo similar ao seguinte na janela de Saída do IDE ao implantar o pacote.

INFO: Maven Hello Service: Started OSGi bundle
INFO: User Name: nb
INFO: MavenHelloService-1.0-SNAPSHOT was successfully deployed in 372 milliseconds.
        

A partir da mensagem "Maven Hello Service: Started OSGi bundle", é possível ver que a classe do ativador do pacote Installer foi instanciada quando o pacote foi implantado.

Criando o projeto Web

Neste exercício, você criará um projeto de aplicativo da Web e adicionará dependências ao pacote MavenHelloService.

1. Escolha Arquivo > Novo projeto e selecione Aplicativo da Web Maven a partir da categoria Maven. Clique em Próximo.
2. Digite MavenHelloWebClient como o Nome do projeto. Clique em Terminar.
3. Abra a janela de Propriedades do projeto e defina o Servidor como GlassFish Server 3 na categoria Executar.
4. Digite /HelloClient como URL Relativo. Clique em OK.
5. Clique com o botão direito do mouse no nó do projeto e escolha Novo > Servlet.
6. Digite HelloClient no nome da classe e selecione o pacote com.mycompany.mavenhellowebclient na lista suspensa. Clique em Terminar.
7. Clique com o botão direito do mouse no nó Bibliotecas e escolha Adicionar dependência.
8. Digite helloservice no campo de texto Consulta para pesquisar o repositório local.
9. Selecione o pacote MavenHelloServiceAPI Snapshot no grupo com.mycompany. Clique em OK.

   Alternativamente, se o projeto do pacote estiver aberto no IDE, é possível clicar na aba Projetos abertos na caixa de diálogo Adicionar dependência e selecionar o projeto a partir da lista.

10. Abra o POM e adicione um elemento <scope> à declaração de dependência para MavenHelloServiceAPI e especifique que a dependência é fornecida.

    <dependency>
          <groupId>${project.groupId}</groupId>
          <artifactId>MavenHelloServiceAPI</artifactId>
          <version>${project.version}</version>
          <scope>provided</scope>
    </dependency>

Ao especificar o escopo como fornecido, o pacote MavenHelloServiceAPI não será incluído no arquivo WAR gerado. Não é necessário incluir o pacote porque, na seção anterior, você implantou o pacote no servidor.

Injetando os serviços

Neste exercício, você injetará o recurso HelloService no servlet e, em seguida, modificará o servlet para invocar o serviço e imprimir uma cadeia na página da Web.

1. Injete os recursos do sistema utilizando anotações.

   @WebServlet(name="HelloClient", urlPatterns={"/HelloClient"})
   public class HelloClient extends HttpServlet {
   
      @Resource(mappedName="hello-service")
      HelloService helloService;

2. Modifique o método processRequest para adicionar println para chamar o método sayHello nos serviços

   out.println("<h1>Servlet HelloClient at " + request.getContextPath () + "</h1>");
   
   out.println(helloService.sayHello("Duke"));
   
   out.println("</body>");
   out.println("</html>");

3. Corrija as importações e salve as alterações.

Construindo e executando o aplicativo

Agora, você pode construir e executar o aplicativo da Web.

1. Clique com o botão direito do mouse no projeto do aplicativo da Web e escolha Executar.

Ao escolher Executar, o IDE constroi o aplicativo, implanta o arquivo WAR no servidor e abre o navegador na página HelloClient.

Se você olhar o projeto na janela Arquivos, poderá ver que o diretório de destino contém o arquivo MavenHelloWebClient.war. Se expandir o WAR, verá que o arquivo não contém o JAR MavenHelloServiceAPI.

Utilizando o comando undeploy

Quando executou o comando deploy, você utilizou o parâmetro type para especificar OSGi. Quando executou o comando, o pacote OSGi foi copiado para o diretório <GLASSFISH-INSTALL>/glassfish/domains/domain1/applications no servidor GlassFish. Para desimplantar um pacote, por exemplo, o MavenHelloService-1.0-SNAPSHOT.jar, é possível digitar o seguinte no terminal.

<glassfish-install>/glassfish/bin/asadmin undeploy MavenHelloService-1.0-SNAPSHOT

Implantando com a cópia dos pacotes OSGi

Por padrão, quaisquer pacotes OSGi que sejam copiados para o diretório autodeploy/bundles do servidor GlassFish são automaticamente implantados. Por exemplo, é possível utilizar o comando de cópia (por exemplo, cp) para copiar um pacote OSGi JAR para o diretório <GLASSFISH-INSTALL>/glassfish/domains/domain1/autodeploy/bundles.

cp /Users/nb/Documents/nbproject/MyOSGiBundle/target/MyOSGiBundle-1.0-SNAPSHOT.jar modules/autostart

Ao copiar o JAR para o diretório, você verá uma saída similar à seguinte na janela de Saída.

INFO: Installed /Applications/NetBeans/glassfishv3/glassfish/modules/autostart/MyOSGiBundle-1.0-SNAPSHOT.jar
INFO: Started bundle: file:/Applications/NetBeans/glassfishv3/glassfish/modules/autostart/MyOSGiBundle-1.0-SNAPSHOT.jar

Se você olhar o diretório autostart, poderá ver que o diretório agora contém o JAR.

É possível utilizar o comando de remoção (por exemplo, rm) para excluir o JAR do diretório autostart. Ao remover o JAR do diretório, você verá uma saída similar à seguinte na janela de Saída.

INFO: Uninstalled /Applications/NetBeans/glassfishv3/glassfish/domains/domain1/autodeploy/bundles/MavenHelloService-1.0-SNAPSHOT.jar