Introdução ao JNI com NetBeans IDE e Plug-in do C/C++ no Linux

Este tutorial o orienta pelo processo de criação de uma aplicação simples que usa o código JavaTM Native Interface (JNI) escrito na linguagem de programação C.

Este tutorial é específico para o Linux.

Conteúdo

O conteúdo desta página aplica-se ao NetBeans IDE 6.7, 6.8 e 6.9
Requisitos
Configurando seu Ambiente para o Tutorial
Configurando o Projeto de Aplicação Java
Configurando um Novo Projeto de Biblioteca Dinâmica C/C++
Construindo e Executando a Aplicação
Próximas Etapas

Requisitos

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

Software ou Recurso Versão Necessária
NetBeans IDE versão 6.7 com módulo de plug-in C/C++ do NetBeans
JDK (Java Developer Kit) versão 6
Compiladores C e C++, make, gdb

Coleções de Ferramentas C/C++ Testadas com o NetBeans IDE

Consulte as Instruções de instalação do NetBeans IDE 6.7 e Instalando e Configurando o NetBeans para C/C++/Fortran para obter informações sobre como fazer download e instalar o software necessário.

Configurando seu Ambiente para o Tutorial

Você precisa dos módulos Java e dos módulos C/C++ para este tutorial. Caso já tenha feito download do pacote NetBeans IDE C/C++, poderá fazer download separadamente os módulos Java adicionais.

Para determinar se você tem os módulos Java e C/C++, selecione Arquivo > Novo Projeto. As categorias de projetos devem incluir o Java e a C/C++.

Para fazer download dos módulos Java e C/C++ que possam estar faltando:

  1. No NetBeans IDE, selecione Ferramentas > Plug-ins.
  2. Na guia Plug-ins disponíveis, marque a caixa de seleção para Java ou C/C++, dependendo do que estiver faltando em seu IDE. Caso já tenha os plug-ins, eles estarão listados na guia Instalado.
  3. Clique em Instalar.
  4. Clique em Próximo na caixa de diálogo Instalador do NetBeans IDE, aceite os termos da licença na caixa de seleção, e clique em Instalar.
  5. Clique em Finalizar quando a instalação tiver sido concluída.

Configurando o Projeto de Aplicação Java

Este programa requer um projeto Java e um projeto C. Nesta seção, você irá criar e configurar o projeto Java para a aplicação JNI que estará desenvolvendo. Você irá criar um novo projeto de aplicação Java, inicializar sua classe principal e adicionar um método nativo à essa classe.

  1. Escolha Arquivo > Novo Projeto. Selecione a categoria Java e o tipo de projeto de Aplicação Java. Clique em Próximo.
  2. Tela do Assistente de Novo Projeto
  3. No campo Nome do Projeto, digite JNIDemoJava.
  4. Você pode alterar a Localização do Projeto para qualquer diretório em seu computador, mas aqui nós usamos o NetBeansProjects default no diretório do usuário.
  5. Deixe a caixa de seleção Criar Classe Principal selecionada e aceite o valor default para o campo de texto correspondente.
  6. Deixe marcada a caixa de seleção Definir como Projeto Principal. Em seguida, clique em Finalizar.

    O IDE cria a pasta do projeto NetBeansProjects/JNIDemoJava.


    Tela da página Nome e Local do novo assistente da Nova Aplicação Java

Editando o Código-fonte da Classe Principal

  1. Para a abrir o código-fonte da classe Principal no editor, clique com o botão direito do mouse no nó da classe Main.java e escolha Abrir.
  2. Substitua o corpo do método main pelo seguinte:
    new Main().nativePrint();
  3. Observe que o indicador na margem esquerda está mostrando um erro e uma lâmpada. Clique no indicador; será solicitado que você crie um atalho para criar o método nativePrint.
  4. Clique neste atalho e o IDE insere o seguinte código:
    private void nativePrint() {
          throw new UnsupportedOperationException("Not yet implemented");
       }
  5. Modifique o corpo do método nativePrint() deletando seu conteúdo e inserindo a palavra-chave native na assinatura do método para que pareça como segue:
    private native void nativePrint();

    A palavra-chave native indica que o método tem uma implementação localizada em uma biblioteca nativa externa. No entanto, no runtime a localização da biblioteca não é clara.

    O novo método principal deveria se parecer como segue:

    public static void main(String[] args) {
           new Main().nativePrint();
       }
    
       private native void nativePrint();
    }
  6. Clique com o botão direito do mouse no nome do projeto e selecione Limpar e Construir. O projeto deve ser construído com êxito.

Criando o Arquivo de Cabeçalho da Biblioteca Nativa

Nesta seção, usamos o javah, uma ferramenta Java que cria um cabeçalho C de uma classe Java.
  1. Na janela do terminal, navegue para o diretório NetBeansProjects.
  2. Digite o seguinte:
    javah -o JNIDemoJava.h -classpath JNIDemoJava/build/classes jnidemojava.Main
    

    Um arquivo de cabeçalho C JNIDemoJava.h é gerado no diretório NetBeansProjects. O arquivo é necessário para fornecer a declaração de função correta para a implementação nativa do método nativePrint(). Você precisar do mesmo mais tarde ao criar a parte C desta aplicação.

  3. Alterne de volta para a janela do NetBeans IDE.

Resumo

Neste exercício você criou um projeto da aplicação Java, especificou sua localização, e definiu o pacote e nome da classe principal do projeto. Você também adicionou um novo método à classe principal e o marcou como um método tendo uma implementação nativa. Como uma etapa final, você criou um arquivo de cabeçalho C, que é necessário mais tarde para a compilação de biblioteca nativa.

Configurando um Novo Projeto de Biblioteca Dinâmica C/C++

Esta seção mostra como criar a parte nativa da aplicação. Você irá criar o projeto de biblioteca dinâmica C++, e irá configurá-lo para ser capaz de construir o código JNI.

Após ter configurado o projeto, você irá criar a implementação para o método nativo declarado anteriormente na parte Java da aplicação.

  1. Escolha Arquivo > Novo Projeto. Em Categorias, selecione C/C++. Em Projetos, selecione Biblioteca Dinâmica C/C++. Clique em Próximo.
    Tela da página Escolher Projeto do assistente Novo Projeto
  2. No campo Nome do Projeto, digite JNIDemoCdl.
  3. No campo Localização do Projeto, use a mesma localização usada para o projeto da aplicação Java, NetBeansProjects. A localização deve ser mostrada como o valor default.
  4. Aceite os defaults para todos os outros campos.
  5. Deixe marcada a caixa de seleção Definir como Projeto Principal. Em seguida, clique em Finalizar.

    O IDE cria a pasta do projeto NetBeansProjects/JNIDemoCdl.

Definindo Propriedades do Projeto

  1. Clique com o botão direito do mouse no nó do projeto JNIDemoCdl e escolha Propriedades.
  2. Na caixa de diálogo Propriedades, selecione o nó Compilador C nas propriedades Build.
  3. Clique no botão Incluir Diretórios ... e clique em Adicionar na caixa de diálogo Incluir Diretórios.
  4. Navegue para seu diretório JDK e selecione o subdiretório Incluir.
  5. Selecione a opção Armazenar como Absoluto, e a seguir clique em Selecionar para adicionar este diretório em Incluir Diretórios do projeto.
  6. Adicione o diretório include/linux do JDK da mesma forma e clique em OK.
  7. Tela da caixa de diálogo Propriedades do Projeto e a Depuração Incluir Diretórios

    Essas definições são necessárias para ativar as referências à biblioteca jni.h do Java de seu código C.

  8. Localize a área de Linha de Comando das opções do Compilador C. Clique no campo de texto da propriedade Opções Adicionais e tipo -shared -m32. Tela do campo de texto Depuração - Opções Adicionais sendo editada

    A opção -shared informa ao compilador para gerar uma biblioteca dinâmica.
    A opção -m32 informa ao compilador para criar um binário de 32 bits. Por default, em sistema de 64 bits, os binários compilados são de 64 bits, o que causa muitos problemas com JDKs de 32 bits.

  9. Clique na categoria Vinculador no painel esquerdo.
    Tela da caixa de diálogo Propriedades do Projeto com propriedades do Vinculador
  10. Clique no campo de texto Saída e substitua a string
    $[CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/libJNIDemoCdl.so
    pela string
    dist/libJNIDemoCdl.so
    para simplificar o caminho do arquivo de objeto compartilhado resultante. Isso fará com que seja mais fácil referenciar o arquivo a partir do Java.
  11. Clique em OK. As definições definidas são salvas.

Adicionando um Arquivo de Cabeçalho

  1. Acesse uma janela de terminal e mova o arquivo de cabeçalho JNIDemoJava.h que foi anteriormente gerado no NetBeansProjects para o diretório do projeto Biblioteca C/C++, NetBeansProjects/JNIDemoCdl.
  2. Na janela Projetos, clique com o botão direito do mouse no nó Arquivos de Código-fonte do projeto JNIDemoCdl e escolha Adicionar Item Existente. Navegue para NetBeansProjects/JNIDemoCdl, selecione o arquivo JNIDemoJava.h e, a seguir, clique em OK.

    O arquivo JNIDemoJava.h aparece sob Arquivos de Código-fonte.

    Tela da janela Projetos

Implementando um Método

  1. Clique com o botão direito do mouse no nó Arquivos de Código-fonte do projeto JNIDemoCdl e escolha Novo > Arquivo de código-fonte C. Digite JNIDemo no campo Nome do Arquivo e clique em Finalizar. O editor abre o arquivo JNIDemo.c.
  2. Edite o arquivo JNIDemo.c digitando o seguinte código:
    #include <jni.h>
    #include <stdio.h>
    #include "JNIDemoJava.h"
    
    JNIEXPORT void JNICALL Java_jnidemojava_Main_nativePrint
            (JNIEnv *env, jobject obj)
    {
    
        printf("\nHello World from C\n");
    
    }
    
  3. Salve o arquivo JNIDemo.c.
  4. Clique com o botão direito do mouse no nó do projeto JNIDemoCdl e escolha Construir Projeto. A janela Saída exibe Criação bem-sucedida. Valor de saída 0.

Resumo

Neste exercício você criou uma nova Biblioteca Dinâmica C/C++, especificou sua localização, e configurou a mesma para que seja capaz de construir um implementação JNI de seu método Java. Você adicionou o arquivo de cabeçalho gerado para o método nativo que foi declarado na aplicação Java e o implementou.

Construindo e Executando a Aplicação

Neste exercício, você irá executar algumas alterações finais na parte Java da aplicação. Estas alterações são necessárias para assegurar que a parte Java carregue apropriadamente a biblioteca nativa compilada no exercício anterior. Após isso, você compila e executa a aplicação resultante.

Configurando o Projeto Java

  1. Abra o arquivo Main.java no editor.
  2. Adicione o seguinte código de inicialização, usando o caminho para o arquivo de saída que reduzimos no exercício anterior:
    static {
            System.load("full-path-to-NetBeansProjects-dir/JNIDemoCdl/dist/libJNIDemoCdl.so");
           }
    
    full-path-to-NetBeansProjects-dir deverá ser similar a /home/username/NetBeansProjects
  3. Salve o arquivo Main.java.

Executando a Aplicação

  1. Para definir o projeto Java JNIDemoJava como o projeto principal, clique com o botão direito do mouse no nó do projeto e escolha Definir como Projeto Principal.
  2. Pressione F6 ou clique no botão Executar na barra de ferramentas para executar a aplicação. O programa deve ser corretamente executado e a janela Saída deve ser exibida:
    Tela da janela Saída

Resumo

Neste exercício você executou algumas etapas de configuração final e executou a aplicação para verificar se a implementação do método nativo vem da biblioteca C nativa.

Próximas Etapas

Se desejar verificar o seu trabalho com relação a um exemplo funcional, você pode efetuar o download de um arquivo zip contendo o código-fonte do netbeans.org.

Você pode usar os seguintes documentos para obter mais informações:

get support for the NetBeans

Support


By use of this website, you agree to the NetBeans Policies and Terms of Use. © 2013, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo