<html>
<head>
   <title>Introdução ao JNI com NetBeans IDE e Plug-in do C/C++ no Linux</title>
   <meta name="DESCRIPTION" content="A tutorial describing how to compile
and run JNI powered Java applications using NetBeans IDE">
   <meta name="author" content="Susan Morgan"><!--Optional tag-->
   <link rel="stylesheet" type="text/css" href="../../../netbeans.css">
  <meta HTTP-EQUIV="Content-Type" Content="text/html; charset=UTF-8"></head>
<body>
<a name="top"></a>

<h1>Introdução ao JNI com NetBeans IDE e Plug-in do C/C++ no Linux</h1>
<!-- START INTRO ---------------------------------------------------------------------------------------* -->
<div class="articledate" style="margin-left: 0px;font-style:italic;">
   <p><em>Contribuição de <i>Susan Morgan</i> <br> Junho de 2009</em> [Número da revisão: V6.7-1]</div>

<p>Este tutorial o orienta pelo processo de criação de uma aplicação simples que usa o código Java<sup><small>TM</small></sup> Native Interface (JNI) escrito na linguagem de programação C.
<p class="notes">Este tutorial é específico para o Linux.</p>
<!-- END INTRO -->

<h3>Conteúdo</h3>
<img alt="O conteúdo desta página aplica-se ao NetBeans IDE 6.7, 6.8 e 6.9" class="stamp" src="../../../images_www/articles/67/netbeans-stamp-67-68-69.png" title="O conteúdo desta página aplica-se ao NetBeans IDE 6.7, 6.8 e 6.9">
<table class="b-none" cellpadding="0" cellspacing="0" class="vatop">
   <tr>
      <td class="hyphen">-&nbsp;</td>
      <td><a href="#requirements" title="Requisitos">Requisitos</a></td>
   </tr>
    <tr>
      <td class="hyphen">-&nbsp;</td>
      <td><a href="#modules" title="Configurando seu Ambiente para o Tutorial"> Configurando seu Ambiente para o Tutorial</a></td>
   </tr>
   <tr>
      <td class="hyphen">-&nbsp;</td>
      <td><a href="#javaproject" title="Configurando o Projeto de Aplicação Java">Configurando o Projeto de Aplicação Java</a></td>
   </tr>
   <tr>
      <td class="hyphen">-&nbsp;</td>
      <td><a href="#c-library" title="Configurando um Novo Projeto de Biblioteca Dinâmica C/C++"> Configurando um Novo Projeto de Biblioteca Dinâmica C/C++</a>
</td>
   </tr>
    <tr>
      <td class="hyphen">-&nbsp;</td>
      <td><a href="#running" title="Construindo e Executando a Aplicação">Construindo e Executando a Aplicação</a></td>
      </tr>
       <tr>
      <td class="hyphen">-&nbsp;</td>
      <td><a href="#next" title="Próximas Etapas">Próximas Etapas</a></td>
      </tr>
</table>

<h2><a NAME="requirements"></a>Requisitos</h2>
<p><b>Para seguir este tutorial, são necessários os recursos e o software a seguir.</b> </p>

<table>
<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">NetBeans IDE</td>
<td class="tbltd1"><a href="https://netbeans.org/downloads/index.html">versão 6.7 com módulo de plug-in C/C++ do NetBeans</a></td>
</tr>
<tr>
<td class="tbltd1">JDK (Java Developer Kit)</td>
<td class="tbltd1"><a href="http://www.oracle.com/technetwork/java/javase/downloads/index.html">versão 6</a></td>
</tr>
<tr>
<td class="tbltd1">
Compiladores C e C++, <tt>make</tt>, <tt>gdb</tt> <br>
   </td>
   <td class="tbltd1"><br>
    <p>
   <a href="./supported-tool-collections.html">Coleções de Ferramentas C/C++ Testadas com o NetBeans IDE</a>

</table>
<p>Consulte as <a href="../../../community/releases/67/install.html">Instruções de instalação do NetBeans IDE 6.7</a> e <a HREF="../../../community/releases/67/cpp-setup-instructions.html">Instalando e Configurando o NetBeans para C/C++/Fortran</a> para obter informações sobre como fazer download e instalar o software necessário. 
</p>

<h2><a name="modules"></a>Configurando seu Ambiente para o Tutorial</h2>
<p>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.</p>
<p>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++.
<p><b>Para fazer download dos módulos Java e C/C++ que possam estar faltando:</b></p>
<ol><li>No NetBeans IDE, selecione Ferramentas > Plug-ins.</li>
<li>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.
</li>
<li>Clique em Instalar.</li>
<li>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.</li>
<li>Clique em Finalizar quando a instalação tiver sido concluída.</li></ol>

<h2><a name="javaproject"></a>Configurando o Projeto de Aplicação Java</h2>
<p>
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.
</p>
<ol>
<li>Escolha Arquivo > Novo Projeto. Selecione a categoria Java e o tipo de projeto de Aplicação Java. Clique em Próximo.</li>
<img alt="Tela do Assistente de Novo Projeto" class="margin-around" src="../../../images_www/articles/67/cnd/beginning-jni-linux/jni-new-project-java.png">
<li>No campo Nome do Projeto, digite <tt>JNIDemoJava</tt>.</li>
<li>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.
</li>
<li>Deixe a caixa de seleção Criar Classe Principal selecionada e aceite o valor default para o campo de texto correspondente.</li>
<li>
<p>Deixe marcada a caixa de seleção Definir como Projeto Principal. Em seguida, clique em Finalizar.
</p>
<p>
O IDE cria a pasta do projeto <tt>NetBeansProjects/JNIDemoJava</tt>.
</p>
<br> <img alt="Tela da página Nome e Local do novo assistente da Nova Aplicação Java" class="margin-around" src="../../../images_www/articles/67/cnd/beginning-jni-linux/jni-new-java-app.png">
</li>
</ol>
<h3>Editando o Código-fonte da Classe Principal</h3>
<ol>
<li>Para a abrir o código-fonte da classe Principal no editor, clique com o botão direito do mouse no nó da classe <tt>Main.java</tt> e escolha Abrir.</li>
<li>Substitua o corpo do método <tt>main</tt> pelo seguinte:
<pre class="examplecode">new Main().nativePrint();</pre>
</li>
<li>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 <tt>nativePrint</tt>.  </li>
<li>Clique neste atalho e o IDE insere o seguinte código:
<pre class="examplecode">private void nativePrint() {
      throw new UnsupportedOperationException("Not yet implemented");
   }</pre>
   
</li>
<li>Modifique o corpo do método <tt>nativePrint()</tt> deletando seu conteúdo e inserindo a palavra-chave <tt>native</tt> na assinatura do método para que pareça como segue:
<pre class="examplecode">private native void nativePrint();</pre>
<p>
A palavra-chave <tt>native</tt> 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.
</p>
<p>O novo método principal deveria se parecer como segue:</p>
<pre class="examplecode">public static void main(String[] args) {
       new Main().nativePrint();
   }

   private native void nativePrint();
}</pre>

</li>

<li>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.
</li>
</ol>
<h3><a name="header"></a>Criando o Arquivo de Cabeçalho da Biblioteca Nativa</h3>
Nesta seção, usamos o <tt>javah</tt>, uma ferramenta Java que cria um cabeçalho C de uma classe Java.
<ol>
<li>Na janela do terminal, navegue para o diretório <tt>NetBeansProjects</tt>.
</li>
<li>Digite o seguinte:
<pre class="examplecode">
javah -o JNIDemoJava.h -classpath JNIDemoJava/build/classes jnidemojava.Main
</pre>
<p>
Um arquivo de cabeçalho C <tt>JNIDemoJava.h</tt> é 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 <tt>nativePrint()</tt>. Você precisar do mesmo mais tarde ao criar a parte C desta aplicação.</p>
</li>
<li>Alterne de volta para a janela do NetBeans IDE.
</li>
</ol>
<p><b>Resumo</b>
<p>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.</p>

<h2><a name="c-library"></a>Configurando um Novo Projeto de Biblioteca Dinâmica C/C++</h2>
<p>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.
</p>
<p>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.

<ol>
<li>
Escolha Arquivo > Novo Projeto. Em Categorias, selecione C/C++. Em Projetos, selecione Biblioteca Dinâmica C/C++. Clique em Próximo. <br> <img alt="Tela da página Escolher Projeto do assistente Novo Projeto" class="margin-around" src="../../../images_www/articles/67/cnd/beginning-jni-linux/jni-new-project-c.png">
</li>
<li>No campo Nome do Projeto, digite <tt>JNIDemoCdl</tt>.
</li>
<li>No campo Localização do Projeto, use a mesma localização usada para o projeto da aplicação Java, <tt>NetBeansProjects</tt>. A localização deve ser mostrada como o valor default.
</li>
<li>Aceite os defaults para todos os outros campos.
</li>
<li>
<p>Deixe marcada a caixa de seleção Definir como Projeto Principal. Em seguida, clique em Finalizar.
<p>O IDE cria a pasta do projeto <tt>NetBeansProjects/JNIDemoCdl</tt>.
</p>
</li>
</ol>
<h3>Definindo Propriedades do Projeto</h3>
<ol>
<li>Clique com o botão direito do mouse no nó do projeto JNIDemoCdl e escolha Propriedades.
</li>
<li>
Na caixa de diálogo Propriedades, selecione o nó Compilador C nas propriedades Build.</li>
<li>Clique no botão Incluir Diretórios ... e clique em Adicionar na caixa de diálogo Incluir Diretórios.
<li>Navegue para seu diretório JDK e selecione o subdiretório <tt>Incluir</tt>. </li>
<li>Selecione a opção Armazenar como Absoluto, e a seguir clique em Selecionar para adicionar este diretório em Incluir Diretórios do projeto.</li>
<li>Adicione o diretório <tt>include/linux</tt> do JDK da mesma forma e clique em OK.</li>

<img alt="Tela da caixa de diálogo Propriedades do Projeto e a Depuração Incluir Diretórios" class="margin-around" src="../../../images_www/articles/67/cnd/beginning-jni-linux/jni-include-directories.png">

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

<li>
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 <tt>-shared -m32</tt>. <img alt="Tela do campo de texto Depuração - Opções Adicionais sendo editada" class="margin-around" src="../../../images_www/articles/67/cnd/beginning-jni-linux/jni-project-properties-cmd-options.png">

<p>
A opção <tt>-shared</tt> informa ao compilador para gerar uma biblioteca dinâmica.<br> A opção <tt>-m32</tt> 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.
</p>
</li>
<li>
Clique na categoria Vinculador no painel esquerdo.<br> <img alt="Tela da caixa de diálogo Propriedades do Projeto com propriedades do Vinculador" class="margin-around" src="../../../images_www/articles/67/cnd/beginning-jni-linux/jni-project-properties-linker.png">


</li>
<li>Clique no campo de texto Saída e substitua a string
 <pre class="examplecode">$[CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/libJNIDemoCdl.so</pre>

 pela string
 <pre class="examplecode">dist/libJNIDemoCdl.so</pre>
 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.</li>
<li>Clique em OK. As definições definidas são salvas.
</li>
</ol>

<h3>Adicionando um Arquivo de Cabeçalho</h3>
<ol>
<li>Acesse uma janela de terminal e mova o arquivo de cabeçalho <tt>JNIDemoJava.h</tt> que foi anteriormente gerado no <tt>NetBeansProjects</tt> para o diretório do projeto Biblioteca C/C++, <tt>NetBeansProjects/JNIDemoCdl</tt>.
</li>
<li>
<p>Na janela Projetos, clique com o botão direito do mouse no nó Arquivos de Código-fonte do projeto <tt>JNIDemoCdl</tt> e escolha Adicionar Item Existente. Navegue para <tt>NetBeansProjects/JNIDemoCdl</tt>, selecione o arquivo <tt>JNIDemoJava.h</tt> e, a seguir, clique em OK.
</p>
<p>O arquivo <tt>JNIDemoJava.h</tt> aparece sob Arquivos de Código-fonte.
</p>

<img alt="Tela da janela Projetos" class="margin-around" src="../../../images_www/articles/67/cnd/beginning-jni-linux/jni-source-files-include-file.png">
</li>
</ol>
<h3>Implementando um Método</h3>

<ol>
<li>Clique com o botão direito do mouse no nó Arquivos de Código-fonte do projeto <tt>JNIDemoCdl</tt> e escolha Novo > Arquivo de código-fonte C. Digite <tt>JNIDemo</tt> no campo Nome do Arquivo e clique em Finalizar. O editor abre o arquivo <tt>JNIDemo.c</tt>.
</li>
<li>Edite o arquivo <tt>JNIDemo.c</tt> digitando o seguinte código:
<pre class="examplecode">
#include &lt;jni.h&gt;
#include &lt;stdio.h&gt;
#include "JNIDemoJava.h"

JNIEXPORT void JNICALL Java_jnidemojava_Main_nativePrint
        (JNIEnv *env, jobject obj)
{

    printf("\nHello World from C\n");

}
</pre>
</li>
<li>Salve o arquivo <tt>JNIDemo.c</tt>.</li>
<li>
Clique com o botão direito do mouse no nó do projeto <tt>JNIDemoCdl</tt> e escolha Construir Projeto. A janela Saída exibe <tt>Criação bem-sucedida. Valor de saída 0.</tt>
</li>
</ol>
<p><b>Resumo</b></p>

<p>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.
</p>
</div>
<h2><a name="running"></a>Construindo e Executando a Aplicação</h2>
<p>
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.
</p>
<div class="indent">
<h3>Configurando o Projeto Java</h3>
<ol>
<li>Abra o arquivo <tt>Main.java</tt> no editor.
<li>Adicione o seguinte código de inicialização, usando o caminho para o arquivo de saída que reduzimos no exercício anterior:
<pre class="examplecode">
static {
        System.load("<i>full-path-to-NetBeansProjects-dir</i>/JNIDemoCdl/dist/libJNIDemoCdl.so");
       }
</pre>
<i>full-path-to-NetBeansProjects-dir</i> deverá ser similar a <tt>/home/username/NetBeansProjects</tt>

</li>
<li>Salve o arquivo <tt>Main.java</tt>.</li>

</ol>
<h3>Executando a Aplicação</h3>
<ol>
<li>Para definir o projeto Java <tt>JNIDemoJava</tt> como o projeto principal, clique com o botão direito do mouse no nó do projeto e escolha Definir como Projeto Principal.</li>
<li>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: <br> <img alt="Tela da janela Saída" class="margin-around" src="../../../images_www/articles/67/cnd/beginning-jni-linux/jni-build-success.png">
</li>
</ol>
<h3>Resumo</h3>
<p>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.
</p>
</div>
<h2><a name="next"></a>Próximas Etapas</h2>
<p>Se desejar verificar o seu trabalho com relação a um exemplo funcional, você pode <a href="https://netbeans.org/projects/samples/downloads/download/Samples%252FCPlusPlus%252FJNIDemo.zip" target="_blank"> efetuar o download de um arquivo zip contendo o código-fonte</a> do netbeans.org.
</p>
   

<p>
Você pode usar os seguintes documentos para obter mais informações:
<ul>
<li><a href="quickstart.html">Tutorial para Início Rápido de Projetos em C/C++</a>

<li><a href="http://en.wikipedia.org/wiki/Java_Native_Interface" target="_blank">Interface Nativa do Java</a>

</ul>
  <DIV CLASS="feedback-box">
   <a HREF="https://netbeans.org/about/contact_form.html?to=7&amp;subject=Feedback:Beginning JNI with NetBeans IDE and C/C++ Plugin on Linux">Envie-nos Seu Feedback</a>
</DIV>
</body>
</html>
