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

This tutorial needs a review. You can open a JIRA issue, or edit it in GitHub following these contribution guidelines.

Março de 2014 [Número da revisão: V8.0-1]

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.

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 7.4 ou 8.0 do NetBeans com o plug-in C/C++

JDK (Java Developer Kit)

versão 7 ou 8

Compiladores C e C++, make , gdb

+ Configurando o NetBeans IDE para C/C+/Fortran

Consulte as Instruções de instalação do NetBeans IDE 8.0 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.

jni new project java

  1. No campo Nome do Projeto, digite JNIDemoJava .

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

  1. Deixe a caixa de seleção Criar Classe Principal selecionada e altere o nome da classe Principal para jnidemojava.Main .

jni new java app

  1. Clique em Finalizar.

O IDE cria a pasta do projeto NetBeansProjects/JNIDemoJava .

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 a lógica da aplicação do código //TODO da linha aqui no método principal pelo seguinte:

new Main().nativePrint();

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

  1. Clique neste atalho e o IDE insere o seguinte código:

private void nativePrint() {
      throw new UnsupportedOperationException("Not supported yet");
   }

  1. Deletar a linha

throw new UnsupportedOperationException("Not supported yet");

  1. Modifique o método nativePrint() , 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();
}

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

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

jni new project c

  1. No campo Nome do Projeto, digite JNIDemoCdl .

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

  1. Aceite os defaults de todos os outros campos e 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 Cabeçalho…​ e clique em Adicionar na caixa de diálogo Incluir Diretórios e Cabeçalhos.

  4. Navegue para seu diretório JDK e selecione o subdiretório Incluir .

  5. Selecione a opção Armazenar caminho como Absoluto e, em seguida, clique em Selecionar para adicionar este diretório em Incluir Diretórios.

  6. Adicione o diretório include/linux do JDK da mesma forma e clique em OK.

jni include directories

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

  1. Localize a área de Linha de Compilação das opções do Compilador C. Clique no campo de texto da propriedade Opções Adicionais e tipo -shared -m32 . jni project properties cmd options

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.

  1. Clique na categoria Vinculador no painel esquerdo.

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

jni project properties linker

  1. 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 do Cabeçalho do projeto JNIDemoCdl e escolha Adicionar Item Existente. Navegue até o diretório NetBeansProjects/JNIDemoCdl . e selecione o arquivo JNIDemoJava.h . Em seguida, clique em Selecionar.

O arquivo JNIDemoJava.h aparece em Arquivos do Cabeçalho.

jni source files include file

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");

}

  1. Salve o arquivo JNIDemo.c .

  1. Clique com o botão direito do mouse no nó de projeto JNIDemoCdl e escolha Construir. A janela de Saída exibe BUILD SUCCESSFUL (tempo total 171ms) ou semelhante.

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 código de inicialização a seguir para a biblioteca dinâmica C++ após a linha public class Main , 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");
       }

Substitua full-path-to-NetBeansProjects-dir pelo caminho em seu diretório NetBeansProjects, que deve ser algo semelhante a /home/username/NetBeansProjects

  1. Salve o arquivo Main.java .

Executando a Aplicação JNIDemoJava

  1. Selecione a aplicação JNIDemoJava na janela Projetos.

  2. Pressione F6 ou clique no botão Executar na barra de ferramentas para executar a aplicação. O programa deve ser executado corretamente, e a janela de Saída deve exibir uma saída semelhante à seguinte:

jni build success

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: