Java Academy · Aula

Criando uma imagem nativa

Compilação antecipada.

Criando uma imagem nativa é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Criando uma imagem nativa

A ferramenta native-image transforma código de bytes Java compilado em um único executável nativo independente. Nesta lição, você percorrerá o processo de compilação, entenderá o que acontece internamente e aprenderá a executar o resultado.

Comece com Java comum

A imagem nativa começa com classes compiladas normalmente. Imagine um programa simples que será compilado em código nativo.

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello from a native binary!");
    }
}

Compile e depois crie

As duas etapas são: primeiro, javac Hello.java produz Hello.class; depois, native-image Hello produz um executável chamado hello. A compilação é muito mais lenta do que a compilação do código-fonte porque analisa o programa inteiro.

Análise de mundo fechado

native-image realiza uma análise de mundo fechado: precisa encontrar todo o código que poderia ser executado. Partindo de main, percorre todos os métodos alcançáveis e inclui somente esses métodos no binário. Tudo o que não for alcançável é removido (eliminação de código morto no momento da vinculação).

Compilação antecipada

Os métodos alcançáveis são compilados antecipadamente em código de máquina nativo. Como não resta código de bytes para interpretar e não há compilação em tempo de execução, também não há aquecimento — o programa funciona em velocidade máxima desde sua primeira instrução.

Inicialização no tempo de compilação

Para iniciar rapidamente, native-image pode executar inicializadores estáticos no momento da compilação e incorporar a memória resultante à imagem (a área de memória da imagem). Isso significa que alguns objetos já existem no instante em que o programa é iniciado.

Executando o executável

A saída é um executável comum do OS. Você o executa diretamente — sem java -jar e sem precisar instalar uma JVM na máquina de destino. Ele também é totalmente estático ou em sua maior parte estático, dependendo das opções.

Opções comuns de compilação

Entre as opções úteis estão:

-o name — nome do arquivo de saída.
--no-fallback — falha em vez de emitir uma imagem alternativa dependente da JVM.
-O2 / -O3 — nível de otimização.
--static — binário totalmente vinculado estaticamente (Linux).

Memória e disco

A própria compilação exige muita memória — aplicativos grandes podem precisar de vários gigabytes de RAM e de minutos de CPU. Esse custo é pago uma vez no momento da compilação, em troca de uma inicialização rápida e barata durante a execução.

Criando via Maven/Gradle

Em projetos reais, raramente você chama native-image manualmente. Os plug-ins de ferramentas de compilação nativa do GraalVM integram a ferramenta ao Maven (native:compile) e ao Gradle (nativeCompile), fazendo com que o binário faça parte do seu fluxo normal de compilação.

Verificando a inicialização

Depois da compilação, compare a inicialização: uma execução de java -jar pode levar centenas de milissegundos, enquanto o binário nativo retorna em poucos milissegundos. Medir essa diferença é o principal objetivo de usar o formato nativo.

Verificação rápida

Teste sua compreensão sobre a criação de imagens nativas.

Recapitulação

Você aprendeu como funciona a compilação de uma imagem nativa:

Comece com código de bytes compilado; native-image produz um executável independente.
A análise de mundo fechado encontra todo o código alcançável a partir de main.
O código alcançável é compilado com AOT; o código inalcançável é removido.
A inicialização no momento da compilação incorpora uma área de memória à imagem para permitir uma inicialização rápida.
A compilação é lenta e exige muita memória; integre-a por meio de plug-ins do Maven/Gradle.

Perguntas Frequentes

A aula “Criando uma imagem nativa” é grátis?

Sim — o texto completo de “Criando uma imagem nativa” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Criando uma imagem nativa”?

Compilação antecipada. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Criando uma imagem nativa”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy